/*
|
**
|
** Copyright 2014, The Android Open Source Project
|
**
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
** you may not use this file except in compliance with the License.
|
** You may obtain a copy of the License at
|
**
|
** http://www.apache.org/licenses/LICENSE-2.0
|
**
|
** Unless required by applicable law or agreed to in writing, software
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
** See the License for the specific language governing permissions and
|
** limitations under the License.
|
*/
|
|
|
#define LOG_TAG "AudioFlinger::PatchPanel"
|
//#define LOG_NDEBUG 0
|
|
#include "Configuration.h"
|
#include <utils/Log.h>
|
#include <audio_utils/primitives.h>
|
|
#include "AudioFlinger.h"
|
#include <media/AudioParameter.h>
|
#include <media/PatchBuilder.h>
|
#include <mediautils/ServiceUtilities.h>
|
|
// ----------------------------------------------------------------------------
|
|
// Note: the following macro is used for extremely verbose logging message. In
|
// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
|
// 0; but one side effect of this is to turn all LOGV's as well. Some messages
|
// are so verbose that we want to suppress them even when we have ALOG_ASSERT
|
// turned on. Do not uncomment the #def below unless you really know what you
|
// are doing and want to see all of the extremely verbose messages.
|
//#define VERY_VERY_VERBOSE_LOGGING
|
#ifdef VERY_VERY_VERBOSE_LOGGING
|
#define ALOGVV ALOGV
|
#else
|
#define ALOGVV(a...) do { } while(0)
|
#endif
|
|
namespace android {
|
|
/* List connected audio ports and their attributes */
|
status_t AudioFlinger::listAudioPorts(unsigned int *num_ports,
|
struct audio_port *ports)
|
{
|
Mutex::Autolock _l(mLock);
|
return mPatchPanel.listAudioPorts(num_ports, ports);
|
}
|
|
/* Get supported attributes for a given audio port */
|
status_t AudioFlinger::getAudioPort(struct audio_port *port)
|
{
|
Mutex::Autolock _l(mLock);
|
return mPatchPanel.getAudioPort(port);
|
}
|
|
/* Connect a patch between several source and sink ports */
|
status_t AudioFlinger::createAudioPatch(const struct audio_patch *patch,
|
audio_patch_handle_t *handle)
|
{
|
Mutex::Autolock _l(mLock);
|
return mPatchPanel.createAudioPatch(patch, handle);
|
}
|
|
/* Disconnect a patch */
|
status_t AudioFlinger::releaseAudioPatch(audio_patch_handle_t handle)
|
{
|
Mutex::Autolock _l(mLock);
|
return mPatchPanel.releaseAudioPatch(handle);
|
}
|
|
/* List connected audio ports and they attributes */
|
status_t AudioFlinger::listAudioPatches(unsigned int *num_patches,
|
struct audio_patch *patches)
|
{
|
Mutex::Autolock _l(mLock);
|
return mPatchPanel.listAudioPatches(num_patches, patches);
|
}
|
|
status_t AudioFlinger::PatchPanel::SoftwarePatch::getLatencyMs_l(double *latencyMs) const
|
{
|
const auto& iter = mPatchPanel.mPatches.find(mPatchHandle);
|
if (iter != mPatchPanel.mPatches.end()) {
|
return iter->second.getLatencyMs(latencyMs);
|
} else {
|
return BAD_VALUE;
|
}
|
}
|
|
/* List connected audio ports and their attributes */
|
status_t AudioFlinger::PatchPanel::listAudioPorts(unsigned int *num_ports __unused,
|
struct audio_port *ports __unused)
|
{
|
ALOGV(__func__);
|
return NO_ERROR;
|
}
|
|
/* Get supported attributes for a given audio port */
|
status_t AudioFlinger::PatchPanel::getAudioPort(struct audio_port *port __unused)
|
{
|
ALOGV(__func__);
|
return NO_ERROR;
|
}
|
|
/* Connect a patch between several source and sink ports */
|
status_t AudioFlinger::PatchPanel::createAudioPatch(const struct audio_patch *patch,
|
audio_patch_handle_t *handle)
|
{
|
if (handle == NULL || patch == NULL) {
|
return BAD_VALUE;
|
}
|
ALOGV("%s() num_sources %d num_sinks %d handle %d",
|
__func__, patch->num_sources, patch->num_sinks, *handle);
|
status_t status = NO_ERROR;
|
audio_patch_handle_t halHandle = AUDIO_PATCH_HANDLE_NONE;
|
|
if (!audio_patch_is_valid(patch) || (patch->num_sinks == 0 && patch->num_sources != 2)) {
|
return BAD_VALUE;
|
}
|
// limit number of sources to 1 for now or 2 sources for special cross hw module case.
|
// only the audio policy manager can request a patch creation with 2 sources.
|
if (patch->num_sources > 2) {
|
return INVALID_OPERATION;
|
}
|
|
if (*handle != AUDIO_PATCH_HANDLE_NONE) {
|
auto iter = mPatches.find(*handle);
|
if (iter != mPatches.end()) {
|
ALOGV("%s() removing patch handle %d", __func__, *handle);
|
Patch &removedPatch = iter->second;
|
// free resources owned by the removed patch if applicable
|
// 1) if a software patch is present, release the playback and capture threads and
|
// tracks created. This will also release the corresponding audio HAL patches
|
if (removedPatch.isSoftware()) {
|
removedPatch.clearConnections(this);
|
}
|
// 2) if the new patch and old patch source or sink are devices from different
|
// hw modules, clear the audio HAL patches now because they will not be updated
|
// by call to create_audio_patch() below which will happen on a different HW module
|
if (removedPatch.mHalHandle != AUDIO_PATCH_HANDLE_NONE) {
|
audio_module_handle_t hwModule = AUDIO_MODULE_HANDLE_NONE;
|
const struct audio_patch &oldPatch = removedPatch.mAudioPatch;
|
if (oldPatch.sources[0].type == AUDIO_PORT_TYPE_DEVICE &&
|
(patch->sources[0].type != AUDIO_PORT_TYPE_DEVICE ||
|
oldPatch.sources[0].ext.device.hw_module !=
|
patch->sources[0].ext.device.hw_module)) {
|
hwModule = oldPatch.sources[0].ext.device.hw_module;
|
} else if (patch->num_sinks == 0 ||
|
(oldPatch.sinks[0].type == AUDIO_PORT_TYPE_DEVICE &&
|
(patch->sinks[0].type != AUDIO_PORT_TYPE_DEVICE ||
|
oldPatch.sinks[0].ext.device.hw_module !=
|
patch->sinks[0].ext.device.hw_module))) {
|
// Note on (patch->num_sinks == 0): this situation should not happen as
|
// these special patches are only created by the policy manager but just
|
// in case, systematically clear the HAL patch.
|
// Note that removedPatch.mAudioPatch.num_sinks cannot be 0 here because
|
// removedPatch.mHalHandle would be AUDIO_PATCH_HANDLE_NONE in this case.
|
hwModule = oldPatch.sinks[0].ext.device.hw_module;
|
}
|
sp<DeviceHalInterface> hwDevice = findHwDeviceByModule(hwModule);
|
if (hwDevice != 0) {
|
hwDevice->releaseAudioPatch(removedPatch.mHalHandle);
|
}
|
}
|
mPatches.erase(iter);
|
removeSoftwarePatchFromInsertedModules(*handle);
|
}
|
}
|
|
Patch newPatch{*patch};
|
audio_module_handle_t insertedModule = AUDIO_MODULE_HANDLE_NONE;
|
|
switch (patch->sources[0].type) {
|
case AUDIO_PORT_TYPE_DEVICE: {
|
audio_module_handle_t srcModule = patch->sources[0].ext.device.hw_module;
|
AudioHwDevice *audioHwDevice = findAudioHwDeviceByModule(srcModule);
|
if (!audioHwDevice) {
|
status = BAD_VALUE;
|
goto exit;
|
}
|
for (unsigned int i = 0; i < patch->num_sinks; i++) {
|
// support only one sink if connection to a mix or across HW modules
|
if ((patch->sinks[i].type == AUDIO_PORT_TYPE_MIX ||
|
(patch->sinks[i].type == AUDIO_PORT_TYPE_DEVICE &&
|
patch->sinks[i].ext.device.hw_module != srcModule)) &&
|
patch->num_sinks > 1) {
|
ALOGW("%s() multiple sinks for mix or across modules not supported", __func__);
|
status = INVALID_OPERATION;
|
goto exit;
|
}
|
// reject connection to different sink types
|
if (patch->sinks[i].type != patch->sinks[0].type) {
|
ALOGW("%s() different sink types in same patch not supported", __func__);
|
status = BAD_VALUE;
|
goto exit;
|
}
|
}
|
|
// manage patches requiring a software bridge
|
// - special patch request with 2 sources (reuse one existing output mix) OR
|
// - Device to device AND
|
// - source HW module != destination HW module OR
|
// - audio HAL does not support audio patches creation
|
if ((patch->num_sources == 2) ||
|
((patch->sinks[0].type == AUDIO_PORT_TYPE_DEVICE) &&
|
((patch->sinks[0].ext.device.hw_module != srcModule) ||
|
!audioHwDevice->supportsAudioPatches()))) {
|
audio_devices_t outputDevice = patch->sinks[0].ext.device.type;
|
String8 outputDeviceAddress = String8(patch->sinks[0].ext.device.address);
|
if (patch->num_sources == 2) {
|
if (patch->sources[1].type != AUDIO_PORT_TYPE_MIX ||
|
(patch->num_sinks != 0 && patch->sinks[0].ext.device.hw_module !=
|
patch->sources[1].ext.mix.hw_module)) {
|
ALOGW("%s() invalid source combination", __func__);
|
status = INVALID_OPERATION;
|
goto exit;
|
}
|
|
sp<ThreadBase> thread =
|
mAudioFlinger.checkPlaybackThread_l(patch->sources[1].ext.mix.handle);
|
if (thread == 0) {
|
ALOGW("%s() cannot get playback thread", __func__);
|
status = INVALID_OPERATION;
|
goto exit;
|
}
|
// existing playback thread is reused, so it is not closed when patch is cleared
|
newPatch.mPlayback.setThread(
|
reinterpret_cast<PlaybackThread*>(thread.get()), false /*closeThread*/);
|
} else {
|
audio_config_t config = AUDIO_CONFIG_INITIALIZER;
|
audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
|
audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;
|
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
|
config.sample_rate = patch->sinks[0].sample_rate;
|
}
|
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
|
config.channel_mask = patch->sinks[0].channel_mask;
|
}
|
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FORMAT) {
|
config.format = patch->sinks[0].format;
|
}
|
if (patch->sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS) {
|
flags = patch->sinks[0].flags.output;
|
}
|
sp<ThreadBase> thread = mAudioFlinger.openOutput_l(
|
patch->sinks[0].ext.device.hw_module,
|
&output,
|
&config,
|
outputDevice,
|
outputDeviceAddress,
|
flags);
|
ALOGV("mAudioFlinger.openOutput_l() returned %p", thread.get());
|
if (thread == 0) {
|
status = NO_MEMORY;
|
goto exit;
|
}
|
newPatch.mPlayback.setThread(reinterpret_cast<PlaybackThread*>(thread.get()));
|
}
|
audio_devices_t device = patch->sources[0].ext.device.type;
|
String8 address = String8(patch->sources[0].ext.device.address);
|
audio_config_t config = AUDIO_CONFIG_INITIALIZER;
|
// open input stream with source device audio properties if provided or
|
// default to peer output stream properties otherwise.
|
if (patch->sources[0].config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) {
|
config.sample_rate = patch->sources[0].sample_rate;
|
} else {
|
config.sample_rate = newPatch.mPlayback.thread()->sampleRate();
|
}
|
if (patch->sources[0].config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) {
|
config.channel_mask = patch->sources[0].channel_mask;
|
} else {
|
config.channel_mask = audio_channel_in_mask_from_count(
|
newPatch.mPlayback.thread()->channelCount());
|
}
|
if (patch->sources[0].config_mask & AUDIO_PORT_CONFIG_FORMAT) {
|
config.format = patch->sources[0].format;
|
} else {
|
config.format = newPatch.mPlayback.thread()->format();
|
}
|
audio_input_flags_t flags =
|
patch->sources[0].config_mask & AUDIO_PORT_CONFIG_FLAGS ?
|
patch->sources[0].flags.input : AUDIO_INPUT_FLAG_NONE;
|
audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
|
sp<ThreadBase> thread = mAudioFlinger.openInput_l(srcModule,
|
&input,
|
&config,
|
device,
|
address,
|
AUDIO_SOURCE_MIC,
|
flags,
|
outputDevice,
|
outputDeviceAddress);
|
ALOGV("mAudioFlinger.openInput_l() returned %p inChannelMask %08x",
|
thread.get(), config.channel_mask);
|
if (thread == 0) {
|
status = NO_MEMORY;
|
goto exit;
|
}
|
newPatch.mRecord.setThread(reinterpret_cast<RecordThread*>(thread.get()));
|
status = newPatch.createConnections(this);
|
if (status != NO_ERROR) {
|
goto exit;
|
}
|
if (audioHwDevice->isInsert()) {
|
insertedModule = audioHwDevice->handle();
|
}
|
} else {
|
if (patch->sinks[0].type == AUDIO_PORT_TYPE_MIX) {
|
sp<ThreadBase> thread = mAudioFlinger.checkRecordThread_l(
|
patch->sinks[0].ext.mix.handle);
|
if (thread == 0) {
|
thread = mAudioFlinger.checkMmapThread_l(patch->sinks[0].ext.mix.handle);
|
if (thread == 0) {
|
ALOGW("%s() bad capture I/O handle %d",
|
__func__, patch->sinks[0].ext.mix.handle);
|
status = BAD_VALUE;
|
goto exit;
|
}
|
}
|
status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
|
// remove stale audio patch with same input as sink if any
|
for (auto& iter : mPatches) {
|
if (iter.second.mAudioPatch.sinks[0].ext.mix.handle == thread->id()) {
|
mPatches.erase(iter.first);
|
break;
|
}
|
}
|
} else {
|
sp<DeviceHalInterface> hwDevice = audioHwDevice->hwDevice();
|
status = hwDevice->createAudioPatch(patch->num_sources,
|
patch->sources,
|
patch->num_sinks,
|
patch->sinks,
|
&halHandle);
|
if (status == INVALID_OPERATION) goto exit;
|
}
|
}
|
} break;
|
case AUDIO_PORT_TYPE_MIX: {
|
audio_module_handle_t srcModule = patch->sources[0].ext.mix.hw_module;
|
ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(srcModule);
|
if (index < 0) {
|
ALOGW("%s() bad src hw module %d", __func__, srcModule);
|
status = BAD_VALUE;
|
goto exit;
|
}
|
// limit to connections between devices and output streams
|
audio_devices_t type = AUDIO_DEVICE_NONE;
|
for (unsigned int i = 0; i < patch->num_sinks; i++) {
|
if (patch->sinks[i].type != AUDIO_PORT_TYPE_DEVICE) {
|
ALOGW("%s() invalid sink type %d for mix source",
|
__func__, patch->sinks[i].type);
|
status = BAD_VALUE;
|
goto exit;
|
}
|
// limit to connections between sinks and sources on same HW module
|
if (patch->sinks[i].ext.device.hw_module != srcModule) {
|
status = BAD_VALUE;
|
goto exit;
|
}
|
type |= patch->sinks[i].ext.device.type;
|
}
|
sp<ThreadBase> thread =
|
mAudioFlinger.checkPlaybackThread_l(patch->sources[0].ext.mix.handle);
|
if (thread == 0) {
|
thread = mAudioFlinger.checkMmapThread_l(patch->sources[0].ext.mix.handle);
|
if (thread == 0) {
|
ALOGW("%s() bad playback I/O handle %d",
|
__func__, patch->sources[0].ext.mix.handle);
|
status = BAD_VALUE;
|
goto exit;
|
}
|
}
|
if (thread == mAudioFlinger.primaryPlaybackThread_l()) {
|
AudioParameter param = AudioParameter();
|
param.addInt(String8(AudioParameter::keyRouting), (int)type);
|
|
mAudioFlinger.broacastParametersToRecordThreads_l(param.toString());
|
}
|
|
status = thread->sendCreateAudioPatchConfigEvent(patch, &halHandle);
|
|
// remove stale audio patch with same output as source if any
|
for (auto& iter : mPatches) {
|
if (iter.second.mAudioPatch.sources[0].ext.mix.handle == thread->id()) {
|
mPatches.erase(iter.first);
|
break;
|
}
|
}
|
} break;
|
default:
|
status = BAD_VALUE;
|
goto exit;
|
}
|
exit:
|
ALOGV("%s() status %d", __func__, status);
|
if (status == NO_ERROR) {
|
*handle = (audio_patch_handle_t) mAudioFlinger.nextUniqueId(AUDIO_UNIQUE_ID_USE_PATCH);
|
newPatch.mHalHandle = halHandle;
|
mPatches.insert(std::make_pair(*handle, std::move(newPatch)));
|
if (insertedModule != AUDIO_MODULE_HANDLE_NONE) {
|
addSoftwarePatchToInsertedModules(insertedModule, *handle);
|
}
|
ALOGV("%s() added new patch handle %d halHandle %d", __func__, *handle, halHandle);
|
} else {
|
newPatch.clearConnections(this);
|
}
|
return status;
|
}
|
|
AudioFlinger::PatchPanel::Patch::~Patch()
|
{
|
ALOGE_IF(isSoftware(), "Software patch connections leaked %d %d",
|
mRecord.handle(), mPlayback.handle());
|
}
|
|
status_t AudioFlinger::PatchPanel::Patch::createConnections(PatchPanel *panel)
|
{
|
// create patch from source device to record thread input
|
status_t status = panel->createAudioPatch(
|
PatchBuilder().addSource(mAudioPatch.sources[0]).
|
addSink(mRecord.thread(), { .source = AUDIO_SOURCE_MIC }).patch(),
|
mRecord.handlePtr());
|
if (status != NO_ERROR) {
|
*mRecord.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
|
return status;
|
}
|
|
// create patch from playback thread output to sink device
|
if (mAudioPatch.num_sinks != 0) {
|
status = panel->createAudioPatch(
|
PatchBuilder().addSource(mPlayback.thread()).addSink(mAudioPatch.sinks[0]).patch(),
|
mPlayback.handlePtr());
|
if (status != NO_ERROR) {
|
*mPlayback.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
|
return status;
|
}
|
} else {
|
*mPlayback.handlePtr() = AUDIO_PATCH_HANDLE_NONE;
|
}
|
|
// use a pseudo LCM between input and output framecount
|
size_t playbackFrameCount = mPlayback.thread()->frameCount();
|
int playbackShift = __builtin_ctz(playbackFrameCount);
|
size_t recordFrameCount = mRecord.thread()->frameCount();
|
int shift = __builtin_ctz(recordFrameCount);
|
if (playbackShift < shift) {
|
shift = playbackShift;
|
}
|
size_t frameCount = (playbackFrameCount * recordFrameCount) >> shift;
|
ALOGV("%s() playframeCount %zu recordFrameCount %zu frameCount %zu",
|
__func__, playbackFrameCount, recordFrameCount, frameCount);
|
|
// create a special record track to capture from record thread
|
uint32_t channelCount = mPlayback.thread()->channelCount();
|
audio_channel_mask_t inChannelMask = audio_channel_in_mask_from_count(channelCount);
|
audio_channel_mask_t outChannelMask = mPlayback.thread()->channelMask();
|
uint32_t sampleRate = mPlayback.thread()->sampleRate();
|
audio_format_t format = mPlayback.thread()->format();
|
|
audio_format_t inputFormat = mRecord.thread()->format();
|
if (!audio_is_linear_pcm(inputFormat)) {
|
// The playbackThread format will say PCM for IEC61937 packetized stream.
|
// Use recordThread format.
|
format = inputFormat;
|
}
|
audio_input_flags_t inputFlags = mAudioPatch.sources[0].config_mask & AUDIO_PORT_CONFIG_FLAGS ?
|
mAudioPatch.sources[0].flags.input : AUDIO_INPUT_FLAG_NONE;
|
if (sampleRate == mRecord.thread()->sampleRate() &&
|
inChannelMask == mRecord.thread()->channelMask() &&
|
mRecord.thread()->fastTrackAvailable() &&
|
mRecord.thread()->hasFastCapture()) {
|
// Create a fast track if the record thread has fast capture to get better performance.
|
// Only enable fast mode when there is no resample needed.
|
inputFlags = (audio_input_flags_t) (inputFlags | AUDIO_INPUT_FLAG_FAST);
|
} else {
|
// Fast mode is not available in this case.
|
inputFlags = (audio_input_flags_t) (inputFlags & ~AUDIO_INPUT_FLAG_FAST);
|
}
|
sp<RecordThread::PatchRecord> tempRecordTrack = new (std::nothrow) RecordThread::PatchRecord(
|
mRecord.thread().get(),
|
sampleRate,
|
inChannelMask,
|
format,
|
frameCount,
|
NULL,
|
(size_t)0 /* bufferSize */,
|
inputFlags);
|
status = mRecord.checkTrack(tempRecordTrack.get());
|
if (status != NO_ERROR) {
|
return status;
|
}
|
|
audio_output_flags_t outputFlags = mAudioPatch.sinks[0].config_mask & AUDIO_PORT_CONFIG_FLAGS ?
|
mAudioPatch.sinks[0].flags.output : AUDIO_OUTPUT_FLAG_NONE;
|
audio_stream_type_t streamType = AUDIO_STREAM_PATCH;
|
if (mAudioPatch.num_sources == 2 && mAudioPatch.sources[1].type == AUDIO_PORT_TYPE_MIX) {
|
// "reuse one existing output mix" case
|
streamType = mAudioPatch.sources[1].ext.mix.usecase.stream;
|
}
|
if (mPlayback.thread()->hasFastMixer()) {
|
// Create a fast track if the playback thread has fast mixer to get better performance.
|
// Note: we should have matching channel mask, sample rate, and format by the logic above.
|
outputFlags = (audio_output_flags_t) (outputFlags | AUDIO_OUTPUT_FLAG_FAST);
|
} else {
|
outputFlags = (audio_output_flags_t) (outputFlags & ~AUDIO_OUTPUT_FLAG_FAST);
|
}
|
|
// create a special playback track to render to playback thread.
|
// this track is given the same buffer as the PatchRecord buffer
|
sp<PlaybackThread::PatchTrack> tempPatchTrack = new (std::nothrow) PlaybackThread::PatchTrack(
|
mPlayback.thread().get(),
|
streamType,
|
sampleRate,
|
outChannelMask,
|
format,
|
frameCount,
|
tempRecordTrack->buffer(),
|
tempRecordTrack->bufferSize(),
|
outputFlags);
|
status = mPlayback.checkTrack(tempPatchTrack.get());
|
if (status != NO_ERROR) {
|
return status;
|
}
|
|
// tie playback and record tracks together
|
mRecord.setTrackAndPeer(tempRecordTrack, tempPatchTrack);
|
mPlayback.setTrackAndPeer(tempPatchTrack, tempRecordTrack);
|
|
// start capture and playback
|
mRecord.track()->start(AudioSystem::SYNC_EVENT_NONE, AUDIO_SESSION_NONE);
|
mPlayback.track()->start();
|
|
return status;
|
}
|
|
void AudioFlinger::PatchPanel::Patch::clearConnections(PatchPanel *panel)
|
{
|
ALOGV("%s() mRecord.handle %d mPlayback.handle %d",
|
__func__, mRecord.handle(), mPlayback.handle());
|
mRecord.stopTrack();
|
mPlayback.stopTrack();
|
mRecord.clearTrackPeer(); // mRecord stop is synchronous. Break PeerProxy sp<> cycle.
|
mRecord.closeConnections(panel);
|
mPlayback.closeConnections(panel);
|
}
|
|
status_t AudioFlinger::PatchPanel::Patch::getLatencyMs(double *latencyMs) const
|
{
|
if (!isSoftware()) return INVALID_OPERATION;
|
|
auto recordTrack = mRecord.const_track();
|
if (recordTrack.get() == nullptr) return INVALID_OPERATION;
|
|
auto playbackTrack = mPlayback.const_track();
|
if (playbackTrack.get() == nullptr) return INVALID_OPERATION;
|
|
// Latency information for tracks may be called without obtaining
|
// the underlying thread lock.
|
//
|
// We use record server latency + playback track latency (generally smaller than the
|
// reverse due to internal biases).
|
//
|
// TODO: is this stable enough? Consider a PatchTrack synchronized version of this.
|
|
// For PCM tracks get server latency.
|
if (audio_is_linear_pcm(recordTrack->format())) {
|
double recordServerLatencyMs, playbackTrackLatencyMs;
|
if (recordTrack->getServerLatencyMs(&recordServerLatencyMs) == OK
|
&& playbackTrack->getTrackLatencyMs(&playbackTrackLatencyMs) == OK) {
|
*latencyMs = recordServerLatencyMs + playbackTrackLatencyMs;
|
return OK;
|
}
|
}
|
|
// See if kernel latencies are available.
|
// If so, do a frame diff and time difference computation to estimate
|
// the total patch latency. This requires that frame counts are reported by the
|
// HAL are matched properly in the case of record overruns and playback underruns.
|
ThreadBase::TrackBase::FrameTime recordFT{}, playFT{};
|
recordTrack->getKernelFrameTime(&recordFT);
|
playbackTrack->getKernelFrameTime(&playFT);
|
if (recordFT.timeNs > 0 && playFT.timeNs > 0) {
|
const int64_t frameDiff = recordFT.frames - playFT.frames;
|
const int64_t timeDiffNs = recordFT.timeNs - playFT.timeNs;
|
|
// It is possible that the patch track and patch record have a large time disparity because
|
// one thread runs but another is stopped. We arbitrarily choose the maximum timestamp
|
// time difference based on how often we expect the timestamps to update in normal operation
|
// (typical should be no more than 50 ms).
|
//
|
// If the timestamps aren't sampled close enough, the patch latency is not
|
// considered valid.
|
//
|
// TODO: change this based on more experiments.
|
constexpr int64_t maxValidTimeDiffNs = 200 * NANOS_PER_MILLISECOND;
|
if (std::abs(timeDiffNs) < maxValidTimeDiffNs) {
|
*latencyMs = frameDiff * 1e3 / recordTrack->sampleRate()
|
- timeDiffNs * 1e-6;
|
return OK;
|
}
|
}
|
|
return INVALID_OPERATION;
|
}
|
|
String8 AudioFlinger::PatchPanel::Patch::dump(audio_patch_handle_t myHandle) const
|
{
|
// TODO: Consider table dump form for patches, just like tracks.
|
String8 result = String8::format("Patch %d: thread %p => thread %p",
|
myHandle, mRecord.const_thread().get(), mPlayback.const_thread().get());
|
|
// add latency if it exists
|
double latencyMs;
|
if (getLatencyMs(&latencyMs) == OK) {
|
result.appendFormat(" latency: %.2lf ms", latencyMs);
|
}
|
return result;
|
}
|
|
/* Disconnect a patch */
|
status_t AudioFlinger::PatchPanel::releaseAudioPatch(audio_patch_handle_t handle)
|
{
|
ALOGV("%s handle %d", __func__, handle);
|
status_t status = NO_ERROR;
|
|
auto iter = mPatches.find(handle);
|
if (iter == mPatches.end()) {
|
return BAD_VALUE;
|
}
|
Patch &removedPatch = iter->second;
|
const struct audio_patch &patch = removedPatch.mAudioPatch;
|
|
const struct audio_port_config &src = patch.sources[0];
|
switch (src.type) {
|
case AUDIO_PORT_TYPE_DEVICE: {
|
sp<DeviceHalInterface> hwDevice = findHwDeviceByModule(src.ext.device.hw_module);
|
if (hwDevice == 0) {
|
ALOGW("%s() bad src hw module %d", __func__, src.ext.device.hw_module);
|
status = BAD_VALUE;
|
break;
|
}
|
|
if (removedPatch.isSoftware()) {
|
removedPatch.clearConnections(this);
|
break;
|
}
|
|
if (patch.sinks[0].type == AUDIO_PORT_TYPE_MIX) {
|
audio_io_handle_t ioHandle = patch.sinks[0].ext.mix.handle;
|
sp<ThreadBase> thread = mAudioFlinger.checkRecordThread_l(ioHandle);
|
if (thread == 0) {
|
thread = mAudioFlinger.checkMmapThread_l(ioHandle);
|
if (thread == 0) {
|
ALOGW("%s() bad capture I/O handle %d", __func__, ioHandle);
|
status = BAD_VALUE;
|
break;
|
}
|
}
|
status = thread->sendReleaseAudioPatchConfigEvent(removedPatch.mHalHandle);
|
} else {
|
status = hwDevice->releaseAudioPatch(removedPatch.mHalHandle);
|
}
|
} break;
|
case AUDIO_PORT_TYPE_MIX: {
|
if (findHwDeviceByModule(src.ext.mix.hw_module) == 0) {
|
ALOGW("%s() bad src hw module %d", __func__, src.ext.mix.hw_module);
|
status = BAD_VALUE;
|
break;
|
}
|
audio_io_handle_t ioHandle = src.ext.mix.handle;
|
sp<ThreadBase> thread = mAudioFlinger.checkPlaybackThread_l(ioHandle);
|
if (thread == 0) {
|
thread = mAudioFlinger.checkMmapThread_l(ioHandle);
|
if (thread == 0) {
|
ALOGW("%s() bad playback I/O handle %d", __func__, ioHandle);
|
status = BAD_VALUE;
|
break;
|
}
|
}
|
status = thread->sendReleaseAudioPatchConfigEvent(removedPatch.mHalHandle);
|
} break;
|
default:
|
status = BAD_VALUE;
|
}
|
|
mPatches.erase(iter);
|
removeSoftwarePatchFromInsertedModules(handle);
|
return status;
|
}
|
|
/* List connected audio ports and they attributes */
|
status_t AudioFlinger::PatchPanel::listAudioPatches(unsigned int *num_patches __unused,
|
struct audio_patch *patches __unused)
|
{
|
ALOGV(__func__);
|
return NO_ERROR;
|
}
|
|
status_t AudioFlinger::PatchPanel::getDownstreamSoftwarePatches(
|
audio_io_handle_t stream,
|
std::vector<AudioFlinger::PatchPanel::SoftwarePatch> *patches) const
|
{
|
for (const auto& module : mInsertedModules) {
|
if (module.second.streams.count(stream)) {
|
for (const auto& patchHandle : module.second.sw_patches) {
|
const auto& patch_iter = mPatches.find(patchHandle);
|
if (patch_iter != mPatches.end()) {
|
const Patch &patch = patch_iter->second;
|
patches->emplace_back(*this, patchHandle,
|
patch.mPlayback.const_thread()->id(),
|
patch.mRecord.const_thread()->id());
|
} else {
|
ALOGE("Stale patch handle in the cache: %d", patchHandle);
|
}
|
}
|
return OK;
|
}
|
}
|
// The stream is not associated with any of inserted modules.
|
return BAD_VALUE;
|
}
|
|
void AudioFlinger::PatchPanel::notifyStreamOpened(
|
AudioHwDevice *audioHwDevice, audio_io_handle_t stream)
|
{
|
if (audioHwDevice->isInsert()) {
|
mInsertedModules[audioHwDevice->handle()].streams.insert(stream);
|
}
|
}
|
|
void AudioFlinger::PatchPanel::notifyStreamClosed(audio_io_handle_t stream)
|
{
|
for (auto& module : mInsertedModules) {
|
module.second.streams.erase(stream);
|
}
|
}
|
|
AudioHwDevice* AudioFlinger::PatchPanel::findAudioHwDeviceByModule(audio_module_handle_t module)
|
{
|
if (module == AUDIO_MODULE_HANDLE_NONE) return nullptr;
|
ssize_t index = mAudioFlinger.mAudioHwDevs.indexOfKey(module);
|
if (index < 0) {
|
ALOGW("%s() bad hw module %d", __func__, module);
|
return nullptr;
|
}
|
return mAudioFlinger.mAudioHwDevs.valueAt(index);
|
}
|
|
sp<DeviceHalInterface> AudioFlinger::PatchPanel::findHwDeviceByModule(audio_module_handle_t module)
|
{
|
AudioHwDevice *audioHwDevice = findAudioHwDeviceByModule(module);
|
return audioHwDevice ? audioHwDevice->hwDevice() : nullptr;
|
}
|
|
void AudioFlinger::PatchPanel::addSoftwarePatchToInsertedModules(
|
audio_module_handle_t module, audio_patch_handle_t handle)
|
{
|
mInsertedModules[module].sw_patches.insert(handle);
|
}
|
|
void AudioFlinger::PatchPanel::removeSoftwarePatchFromInsertedModules(
|
audio_patch_handle_t handle)
|
{
|
for (auto& module : mInsertedModules) {
|
module.second.sw_patches.erase(handle);
|
}
|
}
|
|
void AudioFlinger::PatchPanel::dump(int fd) const
|
{
|
String8 patchPanelDump;
|
const char *indent = " ";
|
|
// Only dump software patches.
|
bool headerPrinted = false;
|
for (const auto& iter : mPatches) {
|
if (iter.second.isSoftware()) {
|
if (!headerPrinted) {
|
patchPanelDump += "\nSoftware patches:\n";
|
headerPrinted = true;
|
}
|
patchPanelDump.appendFormat("%s%s\n", indent, iter.second.dump(iter.first).string());
|
}
|
}
|
|
headerPrinted = false;
|
for (const auto& module : mInsertedModules) {
|
if (!module.second.streams.empty() || !module.second.sw_patches.empty()) {
|
if (!headerPrinted) {
|
patchPanelDump += "\nTracked inserted modules:\n";
|
headerPrinted = true;
|
}
|
String8 moduleDump = String8::format("Module %d: I/O handles: ", module.first);
|
for (const auto& stream : module.second.streams) {
|
moduleDump.appendFormat("%d ", stream);
|
}
|
moduleDump.append("; SW Patches: ");
|
for (const auto& patch : module.second.sw_patches) {
|
moduleDump.appendFormat("%d ", patch);
|
}
|
patchPanelDump.appendFormat("%s%s\n", indent, moduleDump.string());
|
}
|
}
|
|
if (!patchPanelDump.isEmpty()) {
|
write(fd, patchPanelDump.string(), patchPanelDump.size());
|
}
|
}
|
|
} // namespace android
|
