Gitiles
Code Review Sign In
LeafOS / LeafOS-Project / android_frameworks_av / c65d59fe3979a9eec28301d388fd815be5ccdfe9 / . / services / audioflinger / Effects.cpp
blob: 73a89e5ff06b8b12ab45dea1ba9ed27514a39af9 [file] [log] [blame]
/*
**
** Copyright 2012, 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"
//#define LOG_NDEBUG 0
#include "Effects.h"
#include "Client.h"
#include "EffectConfiguration.h"
#include <afutils/DumpTryLock.h>
#include <audio_utils/channels.h>
#include <audio_utils/primitives.h>
#include <media/AudioCommonTypes.h>
#include <media/AudioContainers.h>
#include <media/AudioDeviceTypeAddr.h>
#include <media/AudioEffect.h>
#include <media/ShmemCompat.h>
#include <media/TypeConverter.h>
#include <media/audiohal/EffectHalInterface.h>
#include <media/audiohal/EffectsFactoryHalInterface.h>
#include <mediautils/MethodStatistics.h>
#include <mediautils/ServiceUtilities.h>
#include <mediautils/TimeCheck.h>
#include <system/audio_effects/effect_aec.h>
#include <system/audio_effects/effect_downmix.h>
#include <system/audio_effects/effect_dynamicsprocessing.h>
#include <system/audio_effects/effect_hapticgenerator.h>
#include <system/audio_effects/effect_ns.h>
#include <system/audio_effects/effect_spatializer.h>
#include <system/audio_effects/effect_visualizer.h>
#include <utils/Log.h>
#include <algorithm>
// ----------------------------------------------------------------------------
// 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
#define DEFAULT_OUTPUT_SAMPLE_RATE 48000
namespace android {
using aidl_utils::statusTFromBinderStatus;
using audioflinger::EffectConfiguration;
using binder::Status;
namespace {
// Append a POD value into a vector of bytes.
template<typename T>
void appendToBuffer(const T& value, std::vector<uint8_t>* buffer) {
const uint8_t* ar(reinterpret_cast<const uint8_t*>(&value));
buffer->insert(buffer->end(), ar, ar + sizeof(T));
}
// Write a POD value into a vector of bytes (clears the previous buffer
// content).
template<typename T>
void writeToBuffer(const T& value, std::vector<uint8_t>* buffer) {
buffer->clear();
appendToBuffer(value, buffer);
}
} // namespace
// ----------------------------------------------------------------------------
// EffectBase implementation
// ----------------------------------------------------------------------------
#undef LOG_TAG
#define LOG_TAG "EffectBase"
EffectBase::EffectBase(const sp<EffectCallbackInterface>& callback,
effect_descriptor_t *desc,
int id,
audio_session_t sessionId,
bool pinned)
: mPinned(pinned),
mCallback(callback), mId(id), mSessionId(sessionId),
mDescriptor(*desc)
{
}
// must be called with EffectModule::mutex() held
status_t EffectBase::setEnabled_l(bool enabled)
{
ALOGV("setEnabled %p enabled %d", this, enabled);
if (enabled != isEnabled()) {
switch (mState) {
// going from disabled to enabled
case IDLE:
mState = STARTING;
break;
case STOPPED:
mState = RESTART;
break;
case STOPPING:
mState = ACTIVE;
break;
// going from enabled to disabled
case RESTART:
mState = STOPPED;
break;
case STARTING:
mState = IDLE;
break;
case ACTIVE:
mState = STOPPING;
break;
case DESTROYED:
return NO_ERROR; // simply ignore as we are being destroyed
}
for (size_t i = 1; i < mHandles.size(); i++) {
IAfEffectHandle *h = mHandles[i];
if (h != NULL && !h->disconnected()) {
h->setEnabled(enabled);
}
}
}
return NO_ERROR;
}
status_t EffectBase::setEnabled(bool enabled, bool fromHandle)
{
status_t status;
{
audio_utils::lock_guard _l(mutex());
status = setEnabled_l(enabled);
}
if (fromHandle) {
if (enabled) {
if (status != NO_ERROR) {
getCallback()->checkSuspendOnEffectEnabled(this, false, false /*threadLocked*/);
} else {
getCallback()->onEffectEnable(this);
}
} else {
getCallback()->onEffectDisable(this);
}
}
return status;
}
bool EffectBase::isEnabled() const
{
switch (mState) {
case RESTART:
case STARTING:
case ACTIVE:
return true;
case IDLE:
case STOPPING:
case STOPPED:
case DESTROYED:
default:
return false;
}
}
void EffectBase::setSuspended(bool suspended)
{
audio_utils::lock_guard _l(mutex());
mSuspended = suspended;
}
bool EffectBase::suspended() const
{
audio_utils::lock_guard _l(mutex());
return mSuspended;
}
status_t EffectBase::addHandle(IAfEffectHandle *handle)
{
status_t status;
audio_utils::lock_guard _l(mutex());
int priority = handle->priority();
size_t size = mHandles.size();
IAfEffectHandle *controlHandle = nullptr;
size_t i;
for (i = 0; i < size; i++) {
IAfEffectHandle *h = mHandles[i];
if (h == NULL || h->disconnected()) {
continue;
}
// first non destroyed handle is considered in control
if (controlHandle == NULL) {
controlHandle = h;
}
if (h->priority() <= priority) {
break;
}
}
// if inserted in first place, move effect control from previous owner to this handle
if (i == 0) {
bool enabled = false;
if (controlHandle != NULL) {
enabled = controlHandle->enabled();
controlHandle->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/);
}
handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/);
status = NO_ERROR;
} else {
status = ALREADY_EXISTS;
}
ALOGV("addHandle() %p added handle %p in position %zu", this, handle, i);
mHandles.insertAt(handle, i);
return status;
}
status_t EffectBase::updatePolicyState()
{
status_t status = NO_ERROR;
bool doRegister = false;
bool registered = false;
bool doEnable = false;
bool enabled = false;
audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
product_strategy_t strategy = PRODUCT_STRATEGY_NONE;
{
audio_utils::lock_guard _l(mutex());
if ((isInternal_l() && !mPolicyRegistered)
|| !getCallback()->isAudioPolicyReady()) {
return NO_ERROR;
}
// register effect when first handle is attached and unregister when last handle is removed
if (mPolicyRegistered != mHandles.size() > 0) {
doRegister = true;
mPolicyRegistered = mHandles.size() > 0;
if (mPolicyRegistered) {
const auto callback = getCallback();
io = callback->io();
strategy = callback->strategy();
}
}
// enable effect when registered according to enable state requested by controlling handle
if (mHandles.size() > 0) {
IAfEffectHandle *handle = controlHandle_l();
if (handle != nullptr && mPolicyEnabled != handle->enabled()) {
doEnable = true;
mPolicyEnabled = handle->enabled();
}
}
registered = mPolicyRegistered;
enabled = mPolicyEnabled;
// The simultaneous release of two EffectHandles with the same EffectModule
// may cause us to call this method at the same time.
// This may deadlock under some circumstances (b/180941720). Avoid this.
if (!doRegister && !(registered && doEnable)) {
return NO_ERROR;
}
}
policyMutex().lock();
ALOGV("%s name %s id %d session %d doRegister %d registered %d doEnable %d enabled %d",
__func__, mDescriptor.name, mId, mSessionId, doRegister, registered, doEnable, enabled);
if (doRegister) {
if (registered) {
status = AudioSystem::registerEffect(
&mDescriptor,
io,
strategy,
mSessionId,
mId);
} else {
status = AudioSystem::unregisterEffect(mId);
}
}
if (registered && doEnable) {
status = AudioSystem::setEffectEnabled(mId, enabled);
}
policyMutex().unlock();
return status;
}
ssize_t EffectBase::removeHandle(IAfEffectHandle *handle)
{
audio_utils::lock_guard _l(mutex());
return removeHandle_l(handle);
}
ssize_t EffectBase::removeHandle_l(IAfEffectHandle *handle)
{
size_t size = mHandles.size();
size_t i;
for (i = 0; i < size; i++) {
if (mHandles[i] == handle) {
break;
}
}
if (i == size) {
ALOGW("%s %p handle not found %p", __FUNCTION__, this, handle);
return BAD_VALUE;
}
ALOGV("removeHandle_l() %p removed handle %p in position %zu", this, handle, i);
mHandles.removeAt(i);
// if removed from first place, move effect control from this handle to next in line
if (i == 0) {
IAfEffectHandle *h = controlHandle_l();
if (h != NULL) {
h->setControl(true /*hasControl*/, true /*signal*/ , handle->enabled() /*enabled*/);
}
}
// Prevent calls to process() and other functions on effect interface from now on.
// The effect engine will be released by the destructor when the last strong reference on
// this object is released which can happen after next process is called.
if (mHandles.size() == 0 && !mPinned) {
mState = DESTROYED;
}
return mHandles.size();
}
// must be called with EffectModule::mutex() held
IAfEffectHandle *EffectBase::controlHandle_l()
{
// the first valid handle in the list has control over the module
for (size_t i = 0; i < mHandles.size(); i++) {
IAfEffectHandle *h = mHandles[i];
if (h != NULL && !h->disconnected()) {
return h;
}
}
return NULL;
}
// unsafe method called when the effect parent thread has been destroyed
ssize_t EffectBase::disconnectHandle(IAfEffectHandle *handle, bool unpinIfLast)
{
const auto callback = getCallback();
ALOGV("disconnect() %p handle %p", this, handle);
if (callback->disconnectEffectHandle(handle, unpinIfLast)) {
return mHandles.size();
}
audio_utils::lock_guard _l(mutex());
ssize_t numHandles = removeHandle_l(handle);
if ((numHandles == 0) && (!mPinned || unpinIfLast)) {
mutex().unlock();
callback->updateOrphanEffectChains(this);
mutex().lock();
}
return numHandles;
}
bool EffectBase::purgeHandles()
{
bool enabled = false;
audio_utils::lock_guard _l(mutex());
IAfEffectHandle *handle = controlHandle_l();
if (handle != NULL) {
enabled = handle->enabled();
}
mHandles.clear();
return enabled;
}
void EffectBase::checkSuspendOnEffectEnabled(bool enabled, bool threadLocked) {
getCallback()->checkSuspendOnEffectEnabled(this, enabled, threadLocked);
}
static String8 effectFlagsToString(uint32_t flags) {
String8 s;
s.append("conn. mode: ");
switch (flags & EFFECT_FLAG_TYPE_MASK) {
case EFFECT_FLAG_TYPE_INSERT: s.append("insert"); break;
case EFFECT_FLAG_TYPE_AUXILIARY: s.append("auxiliary"); break;
case EFFECT_FLAG_TYPE_REPLACE: s.append("replace"); break;
case EFFECT_FLAG_TYPE_PRE_PROC: s.append("preproc"); break;
case EFFECT_FLAG_TYPE_POST_PROC: s.append("postproc"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
s.append("insert pref: ");
switch (flags & EFFECT_FLAG_INSERT_MASK) {
case EFFECT_FLAG_INSERT_ANY: s.append("any"); break;
case EFFECT_FLAG_INSERT_FIRST: s.append("first"); break;
case EFFECT_FLAG_INSERT_LAST: s.append("last"); break;
case EFFECT_FLAG_INSERT_EXCLUSIVE: s.append("exclusive"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
s.append("volume mgmt: ");
switch (flags & EFFECT_FLAG_VOLUME_MASK) {
case EFFECT_FLAG_VOLUME_NONE: s.append("none"); break;
case EFFECT_FLAG_VOLUME_CTRL: s.append("implements control"); break;
case EFFECT_FLAG_VOLUME_IND: s.append("requires indication"); break;
case EFFECT_FLAG_VOLUME_MONITOR: s.append("monitors volume"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
uint32_t devind = flags & EFFECT_FLAG_DEVICE_MASK;
if (devind) {
s.append("device indication: ");
switch (devind) {
case EFFECT_FLAG_DEVICE_IND: s.append("requires updates"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
}
s.append("input mode: ");
switch (flags & EFFECT_FLAG_INPUT_MASK) {
case EFFECT_FLAG_INPUT_DIRECT: s.append("direct"); break;
case EFFECT_FLAG_INPUT_PROVIDER: s.append("provider"); break;
case EFFECT_FLAG_INPUT_BOTH: s.append("direct+provider"); break;
default: s.append("not set"); break;
}
s.append(", ");
s.append("output mode: ");
switch (flags & EFFECT_FLAG_OUTPUT_MASK) {
case EFFECT_FLAG_OUTPUT_DIRECT: s.append("direct"); break;
case EFFECT_FLAG_OUTPUT_PROVIDER: s.append("provider"); break;
case EFFECT_FLAG_OUTPUT_BOTH: s.append("direct+provider"); break;
default: s.append("not set"); break;
}
s.append(", ");
uint32_t accel = flags & EFFECT_FLAG_HW_ACC_MASK;
if (accel) {
s.append("hardware acceleration: ");
switch (accel) {
case EFFECT_FLAG_HW_ACC_SIMPLE: s.append("non-tunneled"); break;
case EFFECT_FLAG_HW_ACC_TUNNEL: s.append("tunneled"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
}
uint32_t modeind = flags & EFFECT_FLAG_AUDIO_MODE_MASK;
if (modeind) {
s.append("mode indication: ");
switch (modeind) {
case EFFECT_FLAG_AUDIO_MODE_IND: s.append("required"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
}
uint32_t srcind = flags & EFFECT_FLAG_AUDIO_SOURCE_MASK;
if (srcind) {
s.append("source indication: ");
switch (srcind) {
case EFFECT_FLAG_AUDIO_SOURCE_IND: s.append("required"); break;
default: s.append("unknown/reserved"); break;
}
s.append(", ");
}
if (flags & EFFECT_FLAG_OFFLOAD_MASK) {
s.append("offloadable, ");
}
int len = s.length();
if (s.length() > 2) {
(void) s.lockBuffer(len);
s.unlockBuffer(len - 2);
}
return s;
}
void EffectBase::dump(int fd, const Vector<String16>& args __unused) const
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
String8 result;
result.appendFormat("\tEffect ID %d:\n", mId);
const bool locked = afutils::dumpTryLock(mutex());
// failed to lock - AudioFlinger is probably deadlocked
if (!locked) {
result.append("\t\tCould not lock Fx mutex:\n");
}
bool isInternal = isInternal_l();
result.append("\t\tSession State Registered Internal Enabled Suspended:\n");
result.appendFormat("\t\t%05d %03d %s %s %s %s\n",
mSessionId, mState, mPolicyRegistered ? "y" : "n", isInternal ? "y" : "n",
((isInternal && isEnabled()) || (!isInternal && mPolicyEnabled)) ? "y" : "n",
mSuspended ? "y" : "n");
result.append("\t\tDescriptor:\n");
char uuidStr[64];
AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
result.appendFormat("\t\t- UUID: %s\n", uuidStr);
AudioEffect::guidToString(&mDescriptor.type, uuidStr, sizeof(uuidStr));
result.appendFormat("\t\t- TYPE: %s\n", uuidStr);
result.appendFormat("\t\t- apiVersion: %08X\n\t\t- flags: %08X (%s)\n",
mDescriptor.apiVersion,
mDescriptor.flags,
effectFlagsToString(mDescriptor.flags).c_str());
result.appendFormat("\t\t- name: %s\n",
mDescriptor.name);
result.appendFormat("\t\t- implementor: %s\n",
mDescriptor.implementor);
result.appendFormat("\t\t%zu Clients:\n", mHandles.size());
result.append("\t\t\t Pid Priority Ctrl Locked client server\n");
char buffer[256];
for (size_t i = 0; i < mHandles.size(); ++i) {
IAfEffectHandle *handle = mHandles[i];
if (handle != NULL && !handle->disconnected()) {
handle->dumpToBuffer(buffer, sizeof(buffer));
result.append(buffer);
}
}
if (locked) {
mutex().unlock();
}
write(fd, result.c_str(), result.length());
}
// ----------------------------------------------------------------------------
// EffectModule implementation
// ----------------------------------------------------------------------------
#undef LOG_TAG
#define LOG_TAG "EffectModule"
EffectModule::EffectModule(const sp<EffectCallbackInterface>& callback,
effect_descriptor_t *desc,
int id,
audio_session_t sessionId,
bool pinned,
audio_port_handle_t deviceId)
: EffectBase(callback, desc, id, sessionId, pinned),
// clear mConfig to ensure consistent initial value of buffer framecount
// in case buffers are associated by setInBuffer() or setOutBuffer()
// prior to configure().
mConfig{{}, {}},
mStatus(NO_INIT),
mMaxDisableWaitCnt(1), // set by configure(), should be >= 1
mDisableWaitCnt(0), // set by process() and updateState()
mOffloaded(false),
mIsOutput(false)
, mSupportsFloat(false)
{
ALOGV("Constructor %p pinned %d", this, pinned);
int lStatus;
// create effect engine from effect factory
mStatus = callback->createEffectHal(
&desc->uuid, sessionId, deviceId, &mEffectInterface);
if (mStatus != NO_ERROR) {
return;
}
lStatus = init();
if (lStatus < 0) {
mStatus = lStatus;
goto Error;
}
setOffloaded(callback->isOffload(), callback->io());
ALOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface.get());
return;
Error:
mEffectInterface.clear();
ALOGV("Constructor Error %d", mStatus);
}
EffectModule::~EffectModule()
{
ALOGV("Destructor %p", this);
if (mEffectInterface != 0) {
char uuidStr[64];
AudioEffect::guidToString(&mDescriptor.uuid, uuidStr, sizeof(uuidStr));
ALOGW("EffectModule %p destructor called with unreleased interface, effect %s",
this, uuidStr);
release_l();
}
}
bool EffectModule::updateState() {
audio_utils::lock_guard _l(mutex());
bool started = false;
switch (mState) {
case RESTART:
reset_l();
FALLTHROUGH_INTENDED;
case STARTING:
// clear auxiliary effect input buffer for next accumulation
if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
memset(mConfig.inputCfg.buffer.raw,
0,
mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
}
if (start_l() == NO_ERROR) {
mState = ACTIVE;
started = true;
} else {
mState = IDLE;
}
break;
case STOPPING:
// volume control for offload and direct threads must take effect immediately.
if (stop_l() == NO_ERROR
&& !(isVolumeControl() && isOffloadedOrDirect())) {
mDisableWaitCnt = mMaxDisableWaitCnt;
} else {
mDisableWaitCnt = 1; // will cause immediate transition to IDLE
}
mState = STOPPED;
break;
case STOPPED:
// mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the
// turn off sequence.
if (--mDisableWaitCnt == 0) {
reset_l();
mState = IDLE;
}
break;
case ACTIVE:
for (size_t i = 0; i < mHandles.size(); i++) {
if (!mHandles[i]->disconnected()) {
mHandles[i]->framesProcessed(mConfig.inputCfg.buffer.frameCount);
}
}
break;
default: //IDLE , ACTIVE, DESTROYED
break;
}
return started;
}
void EffectModule::process()
{
audio_utils::lock_guard _l(mutex());
if (mState == DESTROYED || mEffectInterface == 0 || mInBuffer == 0 || mOutBuffer == 0) {
return;
}
const uint32_t inChannelCount =
audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
const uint32_t outChannelCount =
audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
const bool auxType =
(mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
// safeInputOutputSampleCount is 0 if the channel count between input and output
// buffers do not match. This prevents automatic accumulation or copying between the
// input and output effect buffers without an intermediary effect process.
// TODO: consider implementing channel conversion.
const size_t safeInputOutputSampleCount =
mInChannelCountRequested != mOutChannelCountRequested ? 0
: mOutChannelCountRequested * std::min(
mConfig.inputCfg.buffer.frameCount,
mConfig.outputCfg.buffer.frameCount);
const auto accumulateInputToOutput = [this, safeInputOutputSampleCount]() {
accumulate_float(
mConfig.outputCfg.buffer.f32,
mConfig.inputCfg.buffer.f32,
safeInputOutputSampleCount);
};
const auto copyInputToOutput = [this, safeInputOutputSampleCount]() {
memcpy(
mConfig.outputCfg.buffer.f32,
mConfig.inputCfg.buffer.f32,
safeInputOutputSampleCount * sizeof(*mConfig.outputCfg.buffer.f32));
};
if (isProcessEnabled()) {
int ret;
if (isProcessImplemented()) {
if (auxType) {
// We overwrite the aux input buffer here and clear after processing.
// aux input is always mono.
if (!mSupportsFloat) {
memcpy_to_i16_from_float(
mConfig.inputCfg.buffer.s16,
mConfig.inputCfg.buffer.f32,
mConfig.inputCfg.buffer.frameCount);
}
}
sp<EffectBufferHalInterface> inBuffer = mInBuffer;
sp<EffectBufferHalInterface> outBuffer = mOutBuffer;
if (!auxType && mInChannelCountRequested != inChannelCount) {
adjust_channels(
inBuffer->audioBuffer()->f32, mInChannelCountRequested,
mInConversionBuffer->audioBuffer()->f32, inChannelCount,
sizeof(float),
sizeof(float)
* mInChannelCountRequested * mConfig.inputCfg.buffer.frameCount);
inBuffer = mInConversionBuffer;
}
if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE
&& mOutChannelCountRequested != outChannelCount) {
adjust_selected_channels(
outBuffer->audioBuffer()->f32, mOutChannelCountRequested,
mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
sizeof(float),
sizeof(float)
* mOutChannelCountRequested * mConfig.outputCfg.buffer.frameCount);
outBuffer = mOutConversionBuffer;
}
if (!mSupportsFloat) { // convert input to int16_t as effect doesn't support float.
if (!auxType) {
if (mInConversionBuffer == nullptr) {
ALOGW("%s: mInConversionBuffer is null, bypassing", __func__);
goto data_bypass;
}
memcpy_to_i16_from_float(
mInConversionBuffer->audioBuffer()->s16,
inBuffer->audioBuffer()->f32,
inChannelCount * mConfig.inputCfg.buffer.frameCount);
inBuffer = mInConversionBuffer;
}
if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
if (mOutConversionBuffer == nullptr) {
ALOGW("%s: mOutConversionBuffer is null, bypassing", __func__);
goto data_bypass;
}
memcpy_to_i16_from_float(
mOutConversionBuffer->audioBuffer()->s16,
outBuffer->audioBuffer()->f32,
outChannelCount * mConfig.outputCfg.buffer.frameCount);
outBuffer = mOutConversionBuffer;
}
}
ret = mEffectInterface->process();
if (!mSupportsFloat) { // convert output int16_t back to float.
sp<EffectBufferHalInterface> target =
mOutChannelCountRequested != outChannelCount
? mOutConversionBuffer : mOutBuffer;
memcpy_to_float_from_i16(
target->audioBuffer()->f32,
mOutConversionBuffer->audioBuffer()->s16,
outChannelCount * mConfig.outputCfg.buffer.frameCount);
}
if (mOutChannelCountRequested != outChannelCount) {
adjust_selected_channels(mOutConversionBuffer->audioBuffer()->f32, outChannelCount,
mOutBuffer->audioBuffer()->f32, mOutChannelCountRequested,
sizeof(float),
sizeof(float) * outChannelCount * mConfig.outputCfg.buffer.frameCount);
}
} else {
data_bypass:
if (!auxType /* aux effects do not require data bypass */
&& mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
accumulateInputToOutput();
} else {
copyInputToOutput();
}
}
ret = -ENODATA;
}
// force transition to IDLE state when engine is ready
if (mState == STOPPED && ret == -ENODATA) {
mDisableWaitCnt = 1;
}
// clear auxiliary effect input buffer for next accumulation
if (auxType) {
const size_t size =
mConfig.inputCfg.buffer.frameCount * inChannelCount * sizeof(float);
memset(mConfig.inputCfg.buffer.raw, 0, size);
}
} else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
// mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw
mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
// If an insert effect is idle and input buffer is different from output buffer,
// accumulate input onto output
if (getCallback()->activeTrackCnt() != 0) {
// similar handling with data_bypass above.
if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
accumulateInputToOutput();
} else { // EFFECT_BUFFER_ACCESS_WRITE
copyInputToOutput();
}
}
}
}
void EffectModule::reset_l()
{
if (mStatus != NO_ERROR || mEffectInterface == 0) {
return;
}
int reply = 0;
uint32_t replySize = sizeof(reply);
mEffectInterface->command(EFFECT_CMD_RESET, 0, NULL, &replySize, &reply);
}
status_t EffectModule::configure()
{
ALOGVV("configure() started");
status_t status;
uint32_t size;
audio_channel_mask_t channelMask;
sp<EffectCallbackInterface> callback;
if (mEffectInterface == 0) {
status = NO_INIT;
goto exit;
}
// TODO: handle configuration of effects replacing track process
// TODO: handle configuration of input (record) SW effects above the HAL,
// similar to output EFFECT_FLAG_TYPE_INSERT/REPLACE,
// in which case input channel masks should be used here.
callback = getCallback();
channelMask = callback->inChannelMask(mId);
mConfig.inputCfg.channels = channelMask;
mConfig.outputCfg.channels = callback->outChannelMask();
if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_MONO) {
mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
ALOGV("Overriding auxiliary effect input channels %#x as MONO",
mConfig.inputCfg.channels);
}
}
if (isHapticGenerator()) {
audio_channel_mask_t hapticChannelMask = callback->hapticChannelMask();
mConfig.inputCfg.channels |= hapticChannelMask;
mConfig.outputCfg.channels |= hapticChannelMask;
}
mInChannelCountRequested =
audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
mOutChannelCountRequested =
audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
mConfig.inputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
mConfig.outputCfg.format = AUDIO_FORMAT_PCM_FLOAT;
// Don't use sample rate for thread if effect isn't offloadable.
if (callback->isOffloadOrDirect() && !isOffloaded()) {
mConfig.inputCfg.samplingRate = DEFAULT_OUTPUT_SAMPLE_RATE;
ALOGV("Overriding effect input as 48kHz");
} else {
mConfig.inputCfg.samplingRate = callback->sampleRate();
}
mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
mConfig.inputCfg.bufferProvider.cookie = NULL;
mConfig.inputCfg.bufferProvider.getBuffer = NULL;
mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
mConfig.outputCfg.bufferProvider.cookie = NULL;
mConfig.outputCfg.bufferProvider.getBuffer = NULL;
mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
// Insert effect:
// - in global sessions (e.g AUDIO_SESSION_OUTPUT_MIX),
// always overwrites output buffer: input buffer == output buffer
// - in other sessions:
// last effect in the chain accumulates in output buffer: input buffer != output buffer
// other effect: overwrites output buffer: input buffer == output buffer
// Auxiliary effect:
// accumulates in output buffer: input buffer != output buffer
// Therefore: accumulate <=> input buffer != output buffer
mConfig.outputCfg.accessMode = requiredEffectBufferAccessMode();
mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
mConfig.inputCfg.buffer.frameCount = callback->frameCount();
mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount;
mIsOutput = callback->isOutput();
ALOGV("configure() %p chain %p buffer %p framecount %zu",
this, callback->chain().promote().get(),
mConfig.inputCfg.buffer.raw, mConfig.inputCfg.buffer.frameCount);
status_t cmdStatus;
size = sizeof(int);
status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
sizeof(mConfig),
&mConfig,
&size,
&cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
if (status != NO_ERROR &&
EffectConfiguration::isHidl() && // only HIDL effects support channel conversion
mIsOutput &&
(mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
|| mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO)) {
// Older effects may require exact STEREO position mask.
if (mConfig.inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO
&& (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
ALOGV("Overriding effect input channels %#x as STEREO", mConfig.inputCfg.channels);
mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
}
if (mConfig.outputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) {
ALOGV("Overriding effect output channels %#x as STEREO", mConfig.outputCfg.channels);
mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
}
size = sizeof(int);
status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
sizeof(mConfig),
&mConfig,
&size,
&cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
}
if (status == NO_ERROR) {
mSupportsFloat = true;
}
// only HIDL effects support integer conversion.
if (status != NO_ERROR && EffectConfiguration::isHidl()) {
ALOGV("EFFECT_CMD_SET_CONFIG failed with float format, retry with int16_t.");
mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
size = sizeof(int);
status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG,
sizeof(mConfig),
&mConfig,
&size,
&cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
if (status == NO_ERROR) {
mSupportsFloat = false;
ALOGVV("config worked with 16 bit");
} else {
ALOGE("%s failed %d with int16_t (as well as float)", __func__, status);
}
}
if (status == NO_ERROR) {
// Establish Buffer strategy
setInBuffer(mInBuffer);
setOutBuffer(mOutBuffer);
// Update visualizer latency
if (memcmp(&mDescriptor.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) {
uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
effect_param_t *p = (effect_param_t *)buf32;
p->psize = sizeof(uint32_t);
p->vsize = sizeof(uint32_t);
size = sizeof(int);
*(int32_t *)p->data = VISUALIZER_PARAM_LATENCY;
uint32_t latency = callback->latency();
*((int32_t *)p->data + 1)= latency;
mEffectInterface->command(EFFECT_CMD_SET_PARAM,
sizeof(effect_param_t) + 8,
&buf32,
&size,
&cmdStatus);
}
}
// mConfig.outputCfg.buffer.frameCount cannot be zero.
mMaxDisableWaitCnt = (uint32_t)std::max(
(uint64_t)1, // mMaxDisableWaitCnt must be greater than zero.
(uint64_t)mConfig.outputCfg.buffer.frameCount == 0 ? 1
: (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate
/ ((uint64_t)1000 * mConfig.outputCfg.buffer.frameCount)));
exit:
// TODO: consider clearing mConfig on error.
mStatus = status;
ALOGVV("configure ended");
return status;
}
status_t EffectModule::init()
{
audio_utils::lock_guard _l(mutex());
if (mEffectInterface == 0) {
return NO_INIT;
}
status_t cmdStatus;
uint32_t size = sizeof(status_t);
status_t status = mEffectInterface->command(EFFECT_CMD_INIT,
0,
NULL,
&size,
&cmdStatus);
if (status == 0) {
status = cmdStatus;
}
return status;
}
void EffectModule::addEffectToHal_l()
{
if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
(mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
if (mCurrentHalStream == getCallback()->io()) {
return;
}
(void)getCallback()->addEffectToHal(mEffectInterface);
mCurrentHalStream = getCallback()->io();
}
}
// start() must be called with PlaybackThread::mutex() or EffectChain::mutex() held
status_t EffectModule::start()
{
status_t status;
{
audio_utils::lock_guard _l(mutex());
status = start_l();
}
if (status == NO_ERROR) {
getCallback()->resetVolume();
}
return status;
}
status_t EffectModule::start_l()
{
if (mEffectInterface == 0) {
return NO_INIT;
}
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t cmdStatus;
uint32_t size = sizeof(status_t);
status_t status = mEffectInterface->command(EFFECT_CMD_ENABLE,
0,
NULL,
&size,
&cmdStatus);
if (status == 0) {
status = cmdStatus;
}
if (status == 0) {
addEffectToHal_l();
}
return status;
}
status_t EffectModule::stop()
{
audio_utils::lock_guard _l(mutex());
return stop_l();
}
status_t EffectModule::stop_l()
{
if (mEffectInterface == 0) {
return NO_INIT;
}
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t cmdStatus = NO_ERROR;
uint32_t size = sizeof(status_t);
if (isVolumeControl() && isOffloadedOrDirect()) {
// We have the EffectChain and EffectModule lock, permit a reentrant call to setVolume:
// resetVolume_l --> setVolume_l --> EffectModule::setVolume
mSetVolumeReentrantTid = gettid();
getCallback()->resetVolume();
mSetVolumeReentrantTid = INVALID_PID;
}
status_t status = mEffectInterface->command(EFFECT_CMD_DISABLE,
0,
NULL,
&size,
&cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
if (status == NO_ERROR) {
status = removeEffectFromHal_l();
}
return status;
}
// must be called with EffectChain::mutex() held
void EffectModule::release_l()
{
if (mEffectInterface != 0) {
removeEffectFromHal_l();
// release effect engine
mEffectInterface->close();
mEffectInterface.clear();
}
}
status_t EffectModule::removeEffectFromHal_l()
{
if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
(mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
if (mCurrentHalStream != getCallback()->io()) {
return (mCurrentHalStream == AUDIO_IO_HANDLE_NONE) ? NO_ERROR : INVALID_OPERATION;
}
getCallback()->removeEffectFromHal(mEffectInterface);
mCurrentHalStream = AUDIO_IO_HANDLE_NONE;
}
return NO_ERROR;
}
// round up delta valid if value and divisor are positive.
template <typename T>
static T roundUpDelta(const T &value, const T &divisor) {
T remainder = value % divisor;
return remainder == 0 ? 0 : divisor - remainder;
}
status_t EffectModule::command(int32_t cmdCode,
const std::vector<uint8_t>& cmdData,
int32_t maxReplySize,
std::vector<uint8_t>* reply)
{
audio_utils::lock_guard _l(mutex());
ALOGVV("command(), cmdCode: %d, mEffectInterface: %p", cmdCode, mEffectInterface.get());
if (mState == DESTROYED || mEffectInterface == 0) {
return NO_INIT;
}
if (mStatus != NO_ERROR) {
return mStatus;
}
if (maxReplySize < 0 || maxReplySize > EFFECT_PARAM_SIZE_MAX) {
return -EINVAL;
}
size_t cmdSize = cmdData.size();
const effect_param_t* param = cmdSize >= sizeof(effect_param_t)
? reinterpret_cast<const effect_param_t*>(cmdData.data())
: nullptr;
if (cmdCode == EFFECT_CMD_GET_PARAM &&
(param == nullptr || param->psize > cmdSize - sizeof(effect_param_t))) {
android_errorWriteLog(0x534e4554, "32438594");
android_errorWriteLog(0x534e4554, "33003822");
return -EINVAL;
}
if (cmdCode == EFFECT_CMD_GET_PARAM &&
(maxReplySize < static_cast<signed>(sizeof(effect_param_t)) ||
param->psize > maxReplySize - sizeof(effect_param_t))) {
android_errorWriteLog(0x534e4554, "29251553");
return -EINVAL;
}
if (cmdCode == EFFECT_CMD_GET_PARAM &&
(static_cast<signed>(sizeof(effect_param_t)) > maxReplySize
|| param->psize > maxReplySize - sizeof(effect_param_t)
|| param->vsize > maxReplySize - sizeof(effect_param_t)
- param->psize
|| roundUpDelta(param->psize, (uint32_t) sizeof(int)) >
maxReplySize
- sizeof(effect_param_t)
- param->psize
- param->vsize)) {
ALOGV("\tLVM_ERROR : EFFECT_CMD_GET_PARAM: reply size inconsistent");
android_errorWriteLog(0x534e4554, "32705438");
return -EINVAL;
}
if ((cmdCode == EFFECT_CMD_SET_PARAM
|| cmdCode == EFFECT_CMD_SET_PARAM_DEFERRED)
&& // DEFERRED not generally used
(param == nullptr
|| param->psize > cmdSize - sizeof(effect_param_t)
|| param->vsize > cmdSize - sizeof(effect_param_t)
- param->psize
|| roundUpDelta(param->psize,
(uint32_t) sizeof(int)) >
cmdSize
- sizeof(effect_param_t)
- param->psize
- param->vsize)) {
android_errorWriteLog(0x534e4554, "30204301");
return -EINVAL;
}
uint32_t replySize = maxReplySize;
reply->resize(replySize);
status_t status = mEffectInterface->command(cmdCode,
cmdSize,
const_cast<uint8_t*>(cmdData.data()),
&replySize,
reply->data());
reply->resize(status == NO_ERROR ? replySize : 0);
if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) {
for (size_t i = 1; i < mHandles.size(); i++) {
IAfEffectHandle *h = mHandles[i];
if (h != NULL && !h->disconnected()) {
h->commandExecuted(cmdCode, cmdData, *reply);
}
}
}
return status;
}
bool EffectModule::isProcessEnabled() const
{
if (mStatus != NO_ERROR) {
return false;
}
switch (mState) {
case RESTART:
case ACTIVE:
case STOPPING:
case STOPPED:
return true;
case IDLE:
case STARTING:
case DESTROYED:
default:
return false;
}
}
bool EffectModule::isOffloadedOrDirect() const
{
return getCallback()->isOffloadOrDirect();
}
bool EffectModule::isVolumeControlEnabled() const
{
return (isVolumeControl() && (isOffloadedOrDirect() ? isEnabled() : isProcessEnabled()));
}
void EffectModule::setInBuffer(const sp<EffectBufferHalInterface>& buffer) {
ALOGVV("setInBuffer %p",(&buffer));
// mConfig.inputCfg.buffer.frameCount may be zero if configure() is not called yet.
if (buffer != 0) {
mConfig.inputCfg.buffer.raw = buffer->audioBuffer()->raw;
buffer->setFrameCount(mConfig.inputCfg.buffer.frameCount);
} else {
mConfig.inputCfg.buffer.raw = NULL;
}
mInBuffer = buffer;
mEffectInterface->setInBuffer(buffer);
// aux effects do in place conversion to float - we don't allocate mInConversionBuffer.
// Theoretically insert effects can also do in-place conversions (destroying
// the original buffer) when the output buffer is identical to the input buffer,
// but we don't optimize for it here.
const bool auxType = (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY;
const uint32_t inChannelCount =
audio_channel_count_from_out_mask(mConfig.inputCfg.channels);
const bool formatMismatch = !mSupportsFloat || mInChannelCountRequested != inChannelCount;
if (!auxType && formatMismatch && mInBuffer != nullptr) {
// we need to translate - create hidl shared buffer and intercept
const size_t inFrameCount = mConfig.inputCfg.buffer.frameCount;
// Use FCC_2 in case mInChannelCountRequested is mono and the effect is stereo.
const uint32_t inChannels = std::max((uint32_t)FCC_2, mInChannelCountRequested);
const size_t size = inChannels * inFrameCount * std::max(sizeof(int16_t), sizeof(float));
ALOGV("%s: setInBuffer updating for inChannels:%d inFrameCount:%zu total size:%zu",
__func__, inChannels, inFrameCount, size);
if (size > 0 && (mInConversionBuffer == nullptr
|| size > mInConversionBuffer->getSize())) {
mInConversionBuffer.clear();
ALOGV("%s: allocating mInConversionBuffer %zu", __func__, size);
(void)getCallback()->allocateHalBuffer(size, &mInConversionBuffer);
}
if (mInConversionBuffer != nullptr) {
mInConversionBuffer->setFrameCount(inFrameCount);
mEffectInterface->setInBuffer(mInConversionBuffer);
} else if (size > 0) {
ALOGE("%s cannot create mInConversionBuffer", __func__);
}
}
}
void EffectModule::setOutBuffer(const sp<EffectBufferHalInterface>& buffer) {
ALOGVV("setOutBuffer %p",(&buffer));
// mConfig.outputCfg.buffer.frameCount may be zero if configure() is not called yet.
if (buffer != 0) {
mConfig.outputCfg.buffer.raw = buffer->audioBuffer()->raw;
buffer->setFrameCount(mConfig.outputCfg.buffer.frameCount);
} else {
mConfig.outputCfg.buffer.raw = NULL;
}
mOutBuffer = buffer;
mEffectInterface->setOutBuffer(buffer);
// Note: Any effect that does not accumulate does not need mOutConversionBuffer and
// can do in-place conversion from int16_t to float. We don't optimize here.
const uint32_t outChannelCount =
audio_channel_count_from_out_mask(mConfig.outputCfg.channels);
const bool formatMismatch = !mSupportsFloat || mOutChannelCountRequested != outChannelCount;
if (formatMismatch && mOutBuffer != nullptr) {
const size_t outFrameCount = mConfig.outputCfg.buffer.frameCount;
// Use FCC_2 in case mOutChannelCountRequested is mono and the effect is stereo.
const uint32_t outChannels = std::max((uint32_t)FCC_2, mOutChannelCountRequested);
const size_t size = outChannels * outFrameCount * std::max(sizeof(int16_t), sizeof(float));
ALOGV("%s: setOutBuffer updating for outChannels:%d outFrameCount:%zu total size:%zu",
__func__, outChannels, outFrameCount, size);
if (size > 0 && (mOutConversionBuffer == nullptr
|| size > mOutConversionBuffer->getSize())) {
mOutConversionBuffer.clear();
ALOGV("%s: allocating mOutConversionBuffer %zu", __func__, size);
(void)getCallback()->allocateHalBuffer(size, &mOutConversionBuffer);
}
if (mOutConversionBuffer != nullptr) {
mOutConversionBuffer->setFrameCount(outFrameCount);
mEffectInterface->setOutBuffer(mOutConversionBuffer);
} else if (size > 0) {
ALOGE("%s cannot create mOutConversionBuffer", __func__);
}
}
}
status_t EffectModule::setVolume(uint32_t *left, uint32_t *right, bool controller)
{
AutoLockReentrant _l(mutex(), mSetVolumeReentrantTid);
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t status = NO_ERROR;
// Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume
// if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set)
if (isProcessEnabled() &&
((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL ||
(mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND ||
(mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_MONITOR)) {
status = setVolumeInternal(left, right, controller);
}
return status;
}
status_t EffectModule::setVolumeInternal(
uint32_t *left, uint32_t *right, bool controller) {
uint32_t volume[2] = {*left, *right};
uint32_t *pVolume = controller ? volume : nullptr;
uint32_t size = sizeof(volume);
status_t status = mEffectInterface->command(EFFECT_CMD_SET_VOLUME,
size,
volume,
&size,
pVolume);
if (controller && status == NO_ERROR && size == sizeof(volume)) {
*left = volume[0];
*right = volume[1];
}
return status;
}
void EffectChain::setVolumeForOutput_l(uint32_t left, uint32_t right)
{
// for offload or direct thread, if the effect chain has non-offloadable
// effect and any effect module within the chain has volume control, then
// volume control is delegated to effect, otherwise, set volume to hal.
if (mEffectCallback->isOffloadOrDirect() &&
!(isNonOffloadableEnabled_l() && hasVolumeControlEnabled_l())) {
float vol_l = (float)left / (1 << 24);
float vol_r = (float)right / (1 << 24);
mEffectCallback->setVolumeForOutput(vol_l, vol_r);
}
}
status_t EffectModule::sendSetAudioDevicesCommand(
const AudioDeviceTypeAddrVector &devices, uint32_t cmdCode)
{
audio_devices_t deviceType = deviceTypesToBitMask(getAudioDeviceTypes(devices));
if (deviceType == AUDIO_DEVICE_NONE) {
return NO_ERROR;
}
audio_utils::lock_guard _l(mutex());
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t status = NO_ERROR;
if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
status_t cmdStatus;
uint32_t size = sizeof(status_t);
// FIXME: use audio device types and addresses when the hal interface is ready.
status = mEffectInterface->command(cmdCode,
sizeof(uint32_t),
&deviceType,
&size,
&cmdStatus);
}
return status;
}
status_t EffectModule::setDevices(const AudioDeviceTypeAddrVector &devices)
{
return sendSetAudioDevicesCommand(devices, EFFECT_CMD_SET_DEVICE);
}
status_t EffectModule::setInputDevice(const AudioDeviceTypeAddr &device)
{
return sendSetAudioDevicesCommand({device}, EFFECT_CMD_SET_INPUT_DEVICE);
}
status_t EffectModule::setMode(audio_mode_t mode)
{
audio_utils::lock_guard _l(mutex());
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t status = NO_ERROR;
if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
status_t cmdStatus;
uint32_t size = sizeof(status_t);
status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_MODE,
sizeof(audio_mode_t),
&mode,
&size,
&cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
}
return status;
}
status_t EffectModule::setAudioSource(audio_source_t source)
{
audio_utils::lock_guard _l(mutex());
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t status = NO_ERROR;
if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_SOURCE_MASK) == EFFECT_FLAG_AUDIO_SOURCE_IND) {
uint32_t size = 0;
status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_SOURCE,
sizeof(audio_source_t),
&source,
&size,
NULL);
}
return status;
}
status_t EffectModule::setOffloaded(bool offloaded, audio_io_handle_t io)
{
audio_utils::lock_guard _l(mutex());
if (mStatus != NO_ERROR) {
return mStatus;
}
status_t status = NO_ERROR;
if ((mDescriptor.flags & EFFECT_FLAG_OFFLOAD_SUPPORTED) != 0) {
status_t cmdStatus;
uint32_t size = sizeof(status_t);
effect_offload_param_t cmd;
cmd.isOffload = offloaded;
cmd.ioHandle = io;
status = mEffectInterface->command(EFFECT_CMD_OFFLOAD,
sizeof(effect_offload_param_t),
&cmd,
&size,
&cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
mOffloaded = (status == NO_ERROR) ? offloaded : false;
} else {
if (offloaded) {
status = INVALID_OPERATION;
}
mOffloaded = false;
}
ALOGV("setOffloaded() offloaded %d io %d status %d", offloaded, io, status);
return status;
}
bool EffectModule::isOffloaded() const
{
audio_utils::lock_guard _l(mutex());
return mOffloaded;
}
/*static*/
bool IAfEffectModule::isHapticGenerator(const effect_uuid_t *type) {
return memcmp(type, FX_IID_HAPTICGENERATOR, sizeof(effect_uuid_t)) == 0;
}
bool EffectModule::isHapticGenerator() const {
return IAfEffectModule::isHapticGenerator(&mDescriptor.type);
}
status_t EffectModule::setHapticIntensity(int id, os::HapticScale intensity)
{
if (mStatus != NO_ERROR) {
return mStatus;
}
if (!isHapticGenerator()) {
ALOGW("Should not set haptic intensity for effects that are not HapticGenerator");
return INVALID_OPERATION;
}
std::vector<uint8_t> request(sizeof(effect_param_t) + 3 * sizeof(uint32_t));
effect_param_t *param = (effect_param_t*) request.data();
param->psize = sizeof(int32_t);
param->vsize = sizeof(int32_t) * 2;
*(int32_t*)param->data = HG_PARAM_HAPTIC_INTENSITY;
*((int32_t*)param->data + 1) = id;
*((int32_t*)param->data + 2) = static_cast<int32_t>(intensity);
std::vector<uint8_t> response;
status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
if (status == NO_ERROR) {
LOG_ALWAYS_FATAL_IF(response.size() != 4);
status = *reinterpret_cast<const status_t*>(response.data());
}
return status;
}
status_t EffectModule::setVibratorInfo(const media::AudioVibratorInfo& vibratorInfo)
{
if (mStatus != NO_ERROR) {
return mStatus;
}
if (!isHapticGenerator()) {
ALOGW("Should not set vibrator info for effects that are not HapticGenerator");
return INVALID_OPERATION;
}
const size_t paramCount = 3;
std::vector<uint8_t> request(
sizeof(effect_param_t) + sizeof(int32_t) + paramCount * sizeof(float));
effect_param_t *param = (effect_param_t*) request.data();
param->psize = sizeof(int32_t);
param->vsize = paramCount * sizeof(float);
*(int32_t*)param->data = HG_PARAM_VIBRATOR_INFO;
float* vibratorInfoPtr = reinterpret_cast<float*>(param->data + sizeof(int32_t));
vibratorInfoPtr[0] = vibratorInfo.resonantFrequency;
vibratorInfoPtr[1] = vibratorInfo.qFactor;
vibratorInfoPtr[2] = vibratorInfo.maxAmplitude;
std::vector<uint8_t> response;
status_t status = command(EFFECT_CMD_SET_PARAM, request, sizeof(int32_t), &response);
if (status == NO_ERROR) {
LOG_ALWAYS_FATAL_IF(response.size() != sizeof(status_t));
status = *reinterpret_cast<const status_t*>(response.data());
}
return status;
}
status_t EffectModule::getConfigs(
audio_config_base_t* inputCfg, audio_config_base_t* outputCfg, bool* isOutput) const {
audio_utils::lock_guard _l(mutex());
if (mConfig.inputCfg.mask == 0 || mConfig.outputCfg.mask == 0) {
return NO_INIT;
}
inputCfg->sample_rate = mConfig.inputCfg.samplingRate;
inputCfg->channel_mask = static_cast<audio_channel_mask_t>(mConfig.inputCfg.channels);
inputCfg->format = static_cast<audio_format_t>(mConfig.inputCfg.format);
outputCfg->sample_rate = mConfig.outputCfg.samplingRate;
outputCfg->channel_mask = static_cast<audio_channel_mask_t>(mConfig.outputCfg.channels);
outputCfg->format = static_cast<audio_format_t>(mConfig.outputCfg.format);
*isOutput = mIsOutput;
return NO_ERROR;
}
static std::string dumpInOutBuffer(bool isInput, const sp<EffectBufferHalInterface> &buffer) {
std::stringstream ss;
if (buffer == nullptr) {
return "nullptr"; // make different than below
} else if (buffer->externalData() != nullptr) {
ss << (isInput ? buffer->externalData() : buffer->audioBuffer()->raw)
<< " -> "
<< (isInput ? buffer->audioBuffer()->raw : buffer->externalData());
} else {
ss << buffer->audioBuffer()->raw;
}
return ss.str();
}
void EffectModule::dump(int fd, const Vector<String16>& args) const
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
EffectBase::dump(fd, args);
String8 result;
const bool locked = afutils::dumpTryLock(mutex());
result.append("\t\tStatus Engine:\n");
result.appendFormat("\t\t%03d %p\n",
mStatus, mEffectInterface.get());
result.appendFormat("\t\t- data: %s\n", mSupportsFloat ? "float" : "int16");
result.append("\t\t- Input configuration:\n");
result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
mConfig.inputCfg.buffer.raw,
mConfig.inputCfg.buffer.frameCount,
mConfig.inputCfg.samplingRate,
mConfig.inputCfg.channels,
mConfig.inputCfg.format,
toString(static_cast<audio_format_t>(mConfig.inputCfg.format)).c_str());
result.append("\t\t- Output configuration:\n");
result.append("\t\t\tBuffer Frames Smp rate Channels Format\n");
result.appendFormat("\t\t\t%p %05zu %05d %08x %6d (%s)\n",
mConfig.outputCfg.buffer.raw,
mConfig.outputCfg.buffer.frameCount,
mConfig.outputCfg.samplingRate,
mConfig.outputCfg.channels,
mConfig.outputCfg.format,
toString(static_cast<audio_format_t>(mConfig.outputCfg.format)).c_str());
result.appendFormat("\t\t- HAL buffers:\n"
"\t\t\tIn(%s) InConversion(%s) Out(%s) OutConversion(%s)\n",
dumpInOutBuffer(true /* isInput */, mInBuffer).c_str(),
dumpInOutBuffer(true /* isInput */, mInConversionBuffer).c_str(),
dumpInOutBuffer(false /* isInput */, mOutBuffer).c_str(),
dumpInOutBuffer(false /* isInput */, mOutConversionBuffer).c_str());
write(fd, result.c_str(), result.length());
if (mEffectInterface != 0) {
dprintf(fd, "\tEffect ID %d HAL dump:\n", mId);
(void)mEffectInterface->dump(fd);
}
if (locked) {
mutex().unlock();
}
}
// ----------------------------------------------------------------------------
// EffectHandle implementation
// ----------------------------------------------------------------------------
#undef LOG_TAG
#define LOG_TAG "EffectHandle"
/* static */
sp<IAfEffectHandle> IAfEffectHandle::create(
const sp<IAfEffectBase>& effect,
const sp<Client>& client,
const sp<media::IEffectClient>& effectClient,
int32_t priority, bool notifyFramesProcessed)
{
return sp<EffectHandle>::make(
effect, client, effectClient, priority, notifyFramesProcessed);
}
EffectHandle::EffectHandle(const sp<IAfEffectBase>& effect,
const sp<Client>& client,
const sp<media::IEffectClient>& effectClient,
int32_t priority, bool notifyFramesProcessed)
: BnEffect(),
mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL),
mPriority(priority), mHasControl(false), mEnabled(false), mDisconnected(false),
mNotifyFramesProcessed(notifyFramesProcessed)
{
ALOGV("constructor %p client %p", this, client.get());
setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
if (client == 0) {
return;
}
int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
mCblkMemory = client->allocator().allocate(mediautils::NamedAllocRequest{
{static_cast<size_t>(EFFECT_PARAM_BUFFER_SIZE + bufOffset)},
std::string("Effect ID: ")
.append(std::to_string(effect->id()))
.append(" Session ID: ")
.append(std::to_string(static_cast<int>(effect->sessionId())))
.append(" \n")
});
if (mCblkMemory == 0 ||
(mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->unsecurePointer())) == NULL) {
ALOGE("not enough memory for Effect size=%zu", EFFECT_PARAM_BUFFER_SIZE +
sizeof(effect_param_cblk_t));
mCblkMemory.clear();
return;
}
new(mCblk) effect_param_cblk_t();
mBuffer = (uint8_t *)mCblk + bufOffset;
}
EffectHandle::~EffectHandle()
{
ALOGV("Destructor %p", this);
disconnect(false);
}
// Creates an association between Binder code to name for IEffect.
#define IEFFECT_BINDER_METHOD_MACRO_LIST \
BINDER_METHOD_ENTRY(enable) \
BINDER_METHOD_ENTRY(disable) \
BINDER_METHOD_ENTRY(command) \
BINDER_METHOD_ENTRY(disconnect) \
BINDER_METHOD_ENTRY(getCblk) \
BINDER_METHOD_ENTRY(getConfig) \
// singleton for Binder Method Statistics for IEffect
mediautils::MethodStatistics<int>& getIEffectStatistics() {
using Code = int;
#pragma push_macro("BINDER_METHOD_ENTRY")
#undef BINDER_METHOD_ENTRY
#define BINDER_METHOD_ENTRY(ENTRY) \
{(Code)media::BnEffect::TRANSACTION_##ENTRY, #ENTRY},
static mediautils::MethodStatistics<Code> methodStatistics{
IEFFECT_BINDER_METHOD_MACRO_LIST
METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
};
#pragma pop_macro("BINDER_METHOD_ENTRY")
return methodStatistics;
}
status_t EffectHandle::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
const std::string methodName = getIEffectStatistics().getMethodForCode(code);
mediautils::TimeCheck check(
std::string("IEffect::").append(methodName),
[code](bool timeout, float elapsedMs) {
if (timeout) {
; // we don't timeout right now on the effect interface.
} else {
getIEffectStatistics().event(code, elapsedMs);
}
}, {} /* timeoutDuration */, {} /* secondChanceDuration */, false /* crashOnTimeout */);
return BnEffect::onTransact(code, data, reply, flags);
}
status_t EffectHandle::initCheck() const
{
return mClient == 0 || mCblkMemory != 0 ? OK : NO_MEMORY;
}
#define RETURN(code) \
*_aidl_return = (code); \
return Status::ok();
#define VALUE_OR_RETURN_STATUS_AS_OUT(exp) \
({ \
auto _tmp = (exp); \
if (!_tmp.ok()) { RETURN(_tmp.error()); } \
std::move(_tmp.value()); \
})
Status EffectHandle::enable(int32_t* _aidl_return)
{
audio_utils::lock_guard _l(mutex());
ALOGV("enable %p", this);
sp<IAfEffectBase> effect = mEffect.promote();
if (effect == 0 || mDisconnected) {
RETURN(DEAD_OBJECT);
}
if (!mHasControl) {
RETURN(INVALID_OPERATION);
}
if (mEnabled) {
RETURN(NO_ERROR);
}
mEnabled = true;
status_t status = effect->updatePolicyState();
if (status != NO_ERROR) {
mEnabled = false;
RETURN(status);
}
effect->checkSuspendOnEffectEnabled(true, false /*threadLocked*/);
// checkSuspendOnEffectEnabled() can suspend this same effect when enabled
if (effect->suspended()) {
RETURN(NO_ERROR);
}
status = effect->setEnabled(true, true /*fromHandle*/);
if (status != NO_ERROR) {
mEnabled = false;
}
RETURN(status);
}
Status EffectHandle::disable(int32_t* _aidl_return)
{
ALOGV("disable %p", this);
audio_utils::lock_guard _l(mutex());
sp<IAfEffectBase> effect = mEffect.promote();
if (effect == 0 || mDisconnected) {
RETURN(DEAD_OBJECT);
}
if (!mHasControl) {
RETURN(INVALID_OPERATION);
}
if (!mEnabled) {
RETURN(NO_ERROR);
}
mEnabled = false;
effect->updatePolicyState();
if (effect->suspended()) {
RETURN(NO_ERROR);
}
status_t status = effect->setEnabled(false, true /*fromHandle*/);
RETURN(status);
}
Status EffectHandle::disconnect()
{
ALOGV("%s %p", __FUNCTION__, this);
disconnect(true);
return Status::ok();
}
void EffectHandle::disconnect(bool unpinIfLast)
{
audio_utils::lock_guard _l(mutex());
ALOGV("disconnect(%s) %p", unpinIfLast ? "true" : "false", this);
if (mDisconnected) {
if (unpinIfLast) {
android_errorWriteLog(0x534e4554, "32707507");
}
return;
}
mDisconnected = true;
{
sp<IAfEffectBase> effect = mEffect.promote();
if (effect != 0) {
if (effect->disconnectHandle(this, unpinIfLast) > 0) {
ALOGW("%s Effect handle %p disconnected after thread destruction",
__func__, this);
}
effect->updatePolicyState();
}
}
if (mClient != 0) {
if (mCblk != NULL) {
// unlike ~TrackBase(), mCblk is never a local new, so don't delete
mCblk->~effect_param_cblk_t(); // destroy our shared-structure.
}
mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to
// Client destructor must run with AudioFlinger client mutex locked
audio_utils::lock_guard _l2(mClient->afClientCallback()->clientMutex());
mClient.clear();
}
}
Status EffectHandle::getCblk(media::SharedFileRegion* _aidl_return) {
LOG_ALWAYS_FATAL_IF(!convertIMemoryToSharedFileRegion(mCblkMemory, _aidl_return));
return Status::ok();
}
Status EffectHandle::getConfig(
media::EffectConfig* _config, int32_t* _aidl_return) {
audio_utils::lock_guard _l(mutex());
sp<IAfEffectBase> effect = mEffect.promote();
if (effect == nullptr || mDisconnected) {
RETURN(DEAD_OBJECT);
}
sp<IAfEffectModule> effectModule = effect->asEffectModule();
if (effectModule == nullptr) {
RETURN(INVALID_OPERATION);
}
audio_config_base_t inputCfg = AUDIO_CONFIG_BASE_INITIALIZER;
audio_config_base_t outputCfg = AUDIO_CONFIG_BASE_INITIALIZER;
bool isOutput;
status_t status = effectModule->getConfigs(&inputCfg, &outputCfg, &isOutput);
if (status == NO_ERROR) {
constexpr bool isInput = false; // effects always use 'OUT' channel masks.
_config->inputCfg = VALUE_OR_RETURN_STATUS_AS_OUT(
legacy2aidl_audio_config_base_t_AudioConfigBase(inputCfg, isInput));
_config->outputCfg = VALUE_OR_RETURN_STATUS_AS_OUT(
legacy2aidl_audio_config_base_t_AudioConfigBase(outputCfg, isInput));
_config->isOnInputStream = !isOutput;
}
RETURN(status);
}
Status EffectHandle::command(int32_t cmdCode,
const std::vector<uint8_t>& cmdData,
int32_t maxResponseSize,
std::vector<uint8_t>* response,
int32_t* _aidl_return)
{
ALOGVV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p",
cmdCode, mHasControl, mEffect.unsafe_get());
// reject commands reserved for internal use by audio framework if coming from outside
// of audioserver
switch(cmdCode) {
case EFFECT_CMD_ENABLE:
case EFFECT_CMD_DISABLE:
case EFFECT_CMD_SET_PARAM:
case EFFECT_CMD_SET_PARAM_DEFERRED:
case EFFECT_CMD_SET_PARAM_COMMIT:
case EFFECT_CMD_GET_PARAM:
break;
default:
if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY) {
break;
}
android_errorWriteLog(0x534e4554, "62019992");
RETURN(BAD_VALUE);
}
if (cmdCode == EFFECT_CMD_ENABLE) {
if (maxResponseSize < static_cast<signed>(sizeof(int))) {
android_errorWriteLog(0x534e4554, "32095713");
RETURN(BAD_VALUE);
}
writeToBuffer(NO_ERROR, response);
return enable(_aidl_return);
} else if (cmdCode == EFFECT_CMD_DISABLE) {
if (maxResponseSize < static_cast<signed>(sizeof(int))) {
android_errorWriteLog(0x534e4554, "32095713");
RETURN(BAD_VALUE);
}
writeToBuffer(NO_ERROR, response);
return disable(_aidl_return);
}
audio_utils::lock_guard _l(mutex());
sp<IAfEffectBase> effect = mEffect.promote();
if (effect == 0 || mDisconnected) {
RETURN(DEAD_OBJECT);
}
// only get parameter command is permitted for applications not controlling the effect
if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) {
RETURN(INVALID_OPERATION);
}
// handle commands that are not forwarded transparently to effect engine
if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) {
if (mClient == 0) {
RETURN(INVALID_OPERATION);
}
if (maxResponseSize < (signed)sizeof(int)) {
android_errorWriteLog(0x534e4554, "32095713");
RETURN(BAD_VALUE);
}
writeToBuffer(NO_ERROR, response);
// No need to trylock() here as this function is executed in the binder thread serving a
// particular client process: no risk to block the whole media server process or mixer
// threads if we are stuck here
Mutex::Autolock _l2(mCblk->lock);
// keep local copy of index in case of client corruption b/32220769
const uint32_t clientIndex = mCblk->clientIndex;
const uint32_t serverIndex = mCblk->serverIndex;
if (clientIndex > EFFECT_PARAM_BUFFER_SIZE ||
serverIndex > EFFECT_PARAM_BUFFER_SIZE) {
mCblk->serverIndex = 0;
mCblk->clientIndex = 0;
RETURN(BAD_VALUE);
}
status_t status = NO_ERROR;
std::vector<uint8_t> param;
for (uint32_t index = serverIndex; index < clientIndex;) {
int *p = (int *)(mBuffer + index);
const int size = *p++;
if (size < 0
|| size > EFFECT_PARAM_BUFFER_SIZE
|| ((uint8_t *)p + size) > mBuffer + clientIndex) {
ALOGW("command(): invalid parameter block size");
status = BAD_VALUE;
break;
}
std::copy(reinterpret_cast<const uint8_t*>(p),
reinterpret_cast<const uint8_t*>(p) + size,
std::back_inserter(param));
std::vector<uint8_t> replyBuffer;
status_t ret = effect->command(EFFECT_CMD_SET_PARAM,
param,
sizeof(int),
&replyBuffer);
int reply = *reinterpret_cast<const int*>(replyBuffer.data());
// verify shared memory: server index shouldn't change; client index can't go back.
if (serverIndex != mCblk->serverIndex
|| clientIndex > mCblk->clientIndex) {
android_errorWriteLog(0x534e4554, "32220769");
status = BAD_VALUE;
break;
}
// stop at first error encountered
if (ret != NO_ERROR) {
status = ret;
writeToBuffer(reply, response);
break;
} else if (reply != NO_ERROR) {
writeToBuffer(reply, response);
break;
}
index += size;
}
mCblk->serverIndex = 0;
mCblk->clientIndex = 0;
RETURN(status);
}
status_t status = effect->command(cmdCode,
cmdData,
maxResponseSize,
response);
RETURN(status);
}
void EffectHandle::setControl(bool hasControl, bool signal, bool enabled)
{
ALOGV("setControl %p control %d", this, hasControl);
mHasControl = hasControl;
mEnabled = enabled;
if (signal && mEffectClient != 0) {
mEffectClient->controlStatusChanged(hasControl);
}
}
void EffectHandle::commandExecuted(uint32_t cmdCode,
const std::vector<uint8_t>& cmdData,
const std::vector<uint8_t>& replyData)
{
if (mEffectClient != 0) {
mEffectClient->commandExecuted(cmdCode, cmdData, replyData);
}
}
void EffectHandle::setEnabled(bool enabled)
{
if (mEffectClient != 0) {
mEffectClient->enableStatusChanged(enabled);
}
}
void EffectHandle::framesProcessed(int32_t frames) const
{
if (mEffectClient != 0 && mNotifyFramesProcessed) {
mEffectClient->framesProcessed(frames);
}
}
void EffectHandle::dumpToBuffer(char* buffer, size_t size) const
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
const bool locked = mCblk != nullptr && afutils::dumpTryLock(mCblk->lock);
snprintf(buffer, size, "\t\t\t%5d %5d %3s %3s %5u %5u\n",
(mClient == 0) ? getpid() : mClient->pid(),
mPriority,
mHasControl ? "yes" : "no",
locked ? "yes" : "no",
mCblk ? mCblk->clientIndex : 0,
mCblk ? mCblk->serverIndex : 0
);
if (locked) {
mCblk->lock.unlock();
}
}
#undef LOG_TAG
#define LOG_TAG "EffectChain"
/* static */
sp<IAfEffectChain> IAfEffectChain::create(
const sp<IAfThreadBase>& thread,
audio_session_t sessionId)
{
return sp<EffectChain>::make(thread, sessionId);
}
EffectChain::EffectChain(const sp<IAfThreadBase>& thread,
audio_session_t sessionId)
: mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX),
mEffectCallback(new EffectCallback(wp<EffectChain>(this), thread))
{
mStrategy = thread->getStrategyForStream(AUDIO_STREAM_MUSIC);
mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
thread->frameCount();
}
// getEffectFromDesc_l() must be called with IAfThreadBase::mutex() held
sp<IAfEffectModule> EffectChain::getEffectFromDesc_l(
effect_descriptor_t *descriptor) const
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) {
return mEffects[i];
}
}
return 0;
}
// getEffectFromId_l() must be called with IAfThreadBase::mutex() held
sp<IAfEffectModule> EffectChain::getEffectFromId_l(int id) const
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
// by convention, return first effect if id provided is 0 (0 is never a valid id)
if (id == 0 || mEffects[i]->id() == id) {
return mEffects[i];
}
}
return 0;
}
// getEffectFromType_l() must be called with IAfThreadBase::mutex() held
sp<IAfEffectModule> EffectChain::getEffectFromType_l(
const effect_uuid_t *type) const
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) {
return mEffects[i];
}
}
return 0;
}
std::vector<int> EffectChain::getEffectIds() const
{
std::vector<int> ids;
audio_utils::lock_guard _l(mutex());
for (size_t i = 0; i < mEffects.size(); i++) {
ids.push_back(mEffects[i]->id());
}
return ids;
}
void EffectChain::clearInputBuffer()
{
audio_utils::lock_guard _l(mutex());
clearInputBuffer_l();
}
// Must be called with EffectChain::mutex() locked
void EffectChain::clearInputBuffer_l()
{
if (mInBuffer == NULL) {
return;
}
const size_t frameSize = audio_bytes_per_sample(AUDIO_FORMAT_PCM_FLOAT)
* mEffectCallback->inChannelCount(mEffects[0]->id());
memset(mInBuffer->audioBuffer()->raw, 0, mEffectCallback->frameCount() * frameSize);
mInBuffer->commit();
}
// Must be called with EffectChain::mutex() locked
void EffectChain::process_l()
{
// never process effects when:
// - on an OFFLOAD thread
// - no more tracks are on the session and the effect tail has been rendered
bool doProcess = !mEffectCallback->isOffloadOrMmap();
if (!audio_is_global_session(mSessionId)) {
bool tracksOnSession = (trackCnt() != 0);
if (!tracksOnSession && mTailBufferCount == 0) {
doProcess = false;
}
if (activeTrackCnt() == 0) {
// if no track is active and the effect tail has not been rendered,
// the input buffer must be cleared here as the mixer process will not do it
if (tracksOnSession || mTailBufferCount > 0) {
clearInputBuffer_l();
if (mTailBufferCount > 0) {
mTailBufferCount--;
}
}
}
}
size_t size = mEffects.size();
if (doProcess) {
// Only the input and output buffers of the chain can be external,
// and 'update' / 'commit' do nothing for allocated buffers, thus
// it's not needed to consider any other buffers here.
mInBuffer->update();
if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
mOutBuffer->update();
}
for (size_t i = 0; i < size; i++) {
mEffects[i]->process();
}
mInBuffer->commit();
if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) {
mOutBuffer->commit();
}
}
bool doResetVolume = false;
for (size_t i = 0; i < size; i++) {
doResetVolume = mEffects[i]->updateState() || doResetVolume;
}
if (doResetVolume) {
resetVolume_l();
}
}
// createEffect_l() must be called with IAfThreadBase::mutex() held
status_t EffectChain::createEffect_l(sp<IAfEffectModule>& effect,
effect_descriptor_t *desc,
int id,
audio_session_t sessionId,
bool pinned)
{
audio_utils::lock_guard _l(mutex());
effect = new EffectModule(mEffectCallback, desc, id, sessionId, pinned, AUDIO_PORT_HANDLE_NONE);
status_t lStatus = effect->status();
if (lStatus == NO_ERROR) {
lStatus = addEffect_ll(effect);
}
if (lStatus != NO_ERROR) {
effect.clear();
}
return lStatus;
}
// addEffect_l() must be called with IAfThreadBase::mutex() held
status_t EffectChain::addEffect_l(const sp<IAfEffectModule>& effect)
{
audio_utils::lock_guard _l(mutex());
return addEffect_ll(effect);
}
// addEffect_l() must be called with IAfThreadBase::mutex() and EffectChain::mutex() held
status_t EffectChain::addEffect_ll(const sp<IAfEffectModule>& effect)
{
effect->setCallback(mEffectCallback);
effect_descriptor_t desc = effect->desc();
if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
// Auxiliary effects are inserted at the beginning of mEffects vector as
// they are processed first and accumulated in chain input buffer
mEffects.insertAt(effect, 0);
// the input buffer for auxiliary effect contains mono samples in
// 32 bit format. This is to avoid saturation in AudoMixer
// accumulation stage. Saturation is done in EffectModule::process() before
// calling the process in effect engine
size_t numSamples = mEffectCallback->frameCount();
sp<EffectBufferHalInterface> halBuffer;
status_t result = mEffectCallback->allocateHalBuffer(
numSamples * sizeof(float), &halBuffer);
if (result != OK) return result;
effect->configure();
effect->setInBuffer(halBuffer);
// auxiliary effects output samples to chain input buffer for further processing
// by insert effects
effect->setOutBuffer(mInBuffer);
} else {
ssize_t idx_insert = getInsertIndex(desc);
if (idx_insert < 0) {
return INVALID_OPERATION;
}
size_t previousSize = mEffects.size();
mEffects.insertAt(effect, idx_insert);
effect->configure();
// - By default:
// All effects read samples from chain input buffer.
// The last effect in the chain, writes samples to chain output buffer,
// otherwise to chain input buffer
// - In the OUTPUT_STAGE chain of a spatializer mixer thread:
// The spatializer effect (first effect) reads samples from the input buffer
// and writes samples to the output buffer.
// All other effects read and writes samples to the output buffer
if (mEffectCallback->isSpatializer()
&& mSessionId == AUDIO_SESSION_OUTPUT_STAGE) {
effect->setOutBuffer(mOutBuffer);
if (idx_insert == 0) {
if (previousSize != 0) {
mEffects[1]->configure();
mEffects[1]->setInBuffer(mOutBuffer);
mEffects[1]->updateAccessMode(); // reconfig if neeeded.
}
effect->setInBuffer(mInBuffer);
} else {
effect->setInBuffer(mOutBuffer);
}
} else {
effect->setInBuffer(mInBuffer);
if (idx_insert == static_cast<ssize_t>(previousSize)) {
if (idx_insert != 0) {
mEffects[idx_insert-1]->configure();
mEffects[idx_insert-1]->setOutBuffer(mInBuffer);
mEffects[idx_insert - 1]->updateAccessMode(); // reconfig if neeeded.
}
effect->setOutBuffer(mOutBuffer);
} else {
effect->setOutBuffer(mInBuffer);
}
}
ALOGV("%s effect %p, added in chain %p at rank %zu",
__func__, effect.get(), this, idx_insert);
}
effect->configure();
return NO_ERROR;
}
std::optional<size_t> EffectChain::findVolumeControl_l(size_t from, size_t to) const {
for (size_t i = std::min(to, mEffects.size()); i > from; i--) {
if (mEffects[i - 1]->isVolumeControlEnabled()) {
return i - 1;
}
}
return std::nullopt;
}
ssize_t EffectChain::getInsertIndex(const effect_descriptor_t& desc) {
// Insert effects are inserted at the end of mEffects vector as they are processed
// after track and auxiliary effects.
// Insert effect order as a function of indicated preference:
// if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if
// another effect is present
// else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the
// last effect claiming first position
// else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the
// first effect claiming last position
// else if EFFECT_FLAG_INSERT_ANY insert after first or before last
// Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
// already present
// Spatializer or Downmixer effects are inserted in first position because
// they adapt the channel count for all other effects in the chain
if ((memcmp(&desc.type, FX_IID_SPATIALIZER, sizeof(effect_uuid_t)) == 0)
|| (memcmp(&desc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0)) {
return 0;
}
size_t size = mEffects.size();
uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK;
ssize_t idx_insert;
ssize_t idx_insert_first = -1;
ssize_t idx_insert_last = -1;
idx_insert = size;
for (size_t i = 0; i < size; i++) {
effect_descriptor_t d = mEffects[i]->desc();
uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK;
uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK;
if (iMode == EFFECT_FLAG_TYPE_INSERT) {
// check invalid effect chaining combinations
if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
ALOGW("%s could not insert effect %s: exclusive conflict with %s",
__func__, desc.name, d.name);
return -1;
}
// remember position of first insert effect and by default
// select this as insert position for new effect
if (idx_insert == static_cast<ssize_t>(size)) {
idx_insert = i;
}
// remember position of last insert effect claiming
// first position
if (iPref == EFFECT_FLAG_INSERT_FIRST) {
idx_insert_first = i;
}
// remember position of first insert effect claiming
// last position
if (iPref == EFFECT_FLAG_INSERT_LAST &&
idx_insert_last == -1) {
idx_insert_last = i;
}
}
}
// modify idx_insert from first position if needed
if (insertPref == EFFECT_FLAG_INSERT_LAST) {
if (idx_insert_last != -1) {
idx_insert = idx_insert_last;
} else {
idx_insert = size;
}
} else {
if (idx_insert_first != -1) {
idx_insert = idx_insert_first + 1;
}
}
return idx_insert;
}
// removeEffect_l() must be called with IAfThreadBase::mutex() held
size_t EffectChain::removeEffect_l(const sp<IAfEffectModule>& effect,
bool release)
{
audio_utils::lock_guard _l(mutex());
size_t size = mEffects.size();
uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK;
for (size_t i = 0; i < size; i++) {
if (effect == mEffects[i]) {
// calling stop here will remove pre-processing effect from the audio HAL.
// This is safe as we hold the EffectChain mutex which guarantees that we are not in
// the middle of a read from audio HAL
if (mEffects[i]->state() == EffectModule::ACTIVE ||
mEffects[i]->state() == EffectModule::STOPPING) {
mEffects[i]->stop();
}
if (release) {
mEffects[i]->release_l();
}
if (type != EFFECT_FLAG_TYPE_AUXILIARY) {
if (i == size - 1 && i != 0) {
mEffects[i - 1]->configure();
mEffects[i - 1]->setOutBuffer(mOutBuffer);
mEffects[i - 1]->updateAccessMode(); // reconfig if neeeded.
}
}
mEffects.removeAt(i);
// make sure the input buffer configuration for the new first effect in the chain
// is updated if needed (can switch from HAL channel mask to mixer channel mask)
if (type != EFFECT_FLAG_TYPE_AUXILIARY // TODO(b/284522658) breaks for aux FX, why?
&& i == 0 && size > 1) {
mEffects[0]->configure();
mEffects[0]->setInBuffer(mInBuffer);
mEffects[0]->updateAccessMode(); // reconfig if neeeded.
}
ALOGV("removeEffect_l() effect %p, removed from chain %p at rank %zu", effect.get(),
this, i);
break;
}
}
return mEffects.size();
}
// setDevices_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setDevices_l(const AudioDeviceTypeAddrVector &devices)
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
mEffects[i]->setDevices(devices);
}
}
// setInputDevice_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setInputDevice_l(const AudioDeviceTypeAddr &device)
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
mEffects[i]->setInputDevice(device);
}
}
// setMode_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setMode_l(audio_mode_t mode)
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
mEffects[i]->setMode(mode);
}
}
// setAudioSource_l() must be called with IAfThreadBase::mutex() held
void EffectChain::setAudioSource_l(audio_source_t source)
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
mEffects[i]->setAudioSource(source);
}
}
bool EffectChain::hasVolumeControlEnabled_l() const {
for (const auto &effect : mEffects) {
if (effect->isVolumeControlEnabled()) return true;
}
return false;
}
// setVolume_l() must be called with IAfThreadBase::mutex() or EffectChain::mutex() held
bool EffectChain::setVolume_l(uint32_t *left, uint32_t *right, bool force)
{
uint32_t newLeft = *left;
uint32_t newRight = *right;
const size_t size = mEffects.size();
// first update volume controller
const auto volumeControlIndex = findVolumeControl_l(0, size);
const int ctrlIdx = volumeControlIndex.value_or(-1);
const sp<IAfEffectModule> volumeControlEffect =
volumeControlIndex.has_value() ? mEffects[ctrlIdx] : nullptr;
const sp<IAfEffectModule> cachedVolumeControlEffect = mVolumeControlEffect.promote();
if (!force && volumeControlEffect == cachedVolumeControlEffect &&
*left == mLeftVolume && *right == mRightVolume) {
if (volumeControlIndex.has_value()) {
*left = mNewLeftVolume;
*right = mNewRightVolume;
}
return volumeControlIndex.has_value();
}
if (volumeControlEffect != cachedVolumeControlEffect) {
// The volume control effect is a new one. Set the old one as full volume. Set the new onw
// as zero for safe ramping.
if (cachedVolumeControlEffect != nullptr) {
uint32_t leftMax = 1 << 24;
uint32_t rightMax = 1 << 24;
cachedVolumeControlEffect->setVolume(&leftMax, &rightMax, true /*controller*/);
}
if (volumeControlEffect != nullptr) {
uint32_t leftZero = 0;
uint32_t rightZero = 0;
volumeControlEffect->setVolume(&leftZero, &rightZero, true /*controller*/);
}
mVolumeControlEffect = volumeControlEffect;
}
mLeftVolume = newLeft;
mRightVolume = newRight;
// second get volume update from volume controller
if (ctrlIdx >= 0) {
mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true);
mNewLeftVolume = newLeft;
mNewRightVolume = newRight;
}
// then indicate volume to all other effects in chain.
// Pass altered volume to effects before volume controller
// and requested volume to effects after controller or with volume monitor flag
uint32_t lVol = newLeft;
uint32_t rVol = newRight;
for (size_t i = 0; i < size; i++) {
if ((int)i == ctrlIdx) {
continue;
}
// this also works for ctrlIdx == -1 when there is no volume controller
if ((int)i > ctrlIdx) {
lVol = *left;
rVol = *right;
}
// Pass requested volume directly if this is volume monitor module
if (mEffects[i]->isVolumeMonitor()) {
mEffects[i]->setVolume(left, right, false);
} else {
mEffects[i]->setVolume(&lVol, &rVol, false);
}
}
*left = newLeft;
*right = newRight;
setVolumeForOutput_l(*left, *right);
return volumeControlIndex.has_value();
}
// resetVolume_l() must be called with IAfThreadBase::mutex() or EffectChain::mutex() held
void EffectChain::resetVolume_l()
{
if ((mLeftVolume != UINT_MAX) && (mRightVolume != UINT_MAX)) {
uint32_t left = mLeftVolume;
uint32_t right = mRightVolume;
(void)setVolume_l(&left, &right, true);
}
}
// containsHapticGeneratingEffect_l must be called with
// IAfThreadBase::mutex() or EffectChain::mutex() held
bool EffectChain::containsHapticGeneratingEffect_l()
{
for (size_t i = 0; i < mEffects.size(); ++i) {
if (mEffects[i]->isHapticGenerator()) {
return true;
}
}
return false;
}
void EffectChain::setHapticIntensity_l(int id, os::HapticScale intensity)
{
audio_utils::lock_guard _l(mutex());
for (size_t i = 0; i < mEffects.size(); ++i) {
mEffects[i]->setHapticIntensity(id, intensity);
}
}
void EffectChain::syncHalEffectsState()
{
audio_utils::lock_guard _l(mutex());
for (size_t i = 0; i < mEffects.size(); i++) {
if (mEffects[i]->state() == EffectModule::ACTIVE ||
mEffects[i]->state() == EffectModule::STOPPING) {
mEffects[i]->addEffectToHal_l();
}
}
}
void EffectChain::dump(int fd, const Vector<String16>& args) const
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
String8 result;
const size_t numEffects = mEffects.size();
result.appendFormat(" %zu effects for session %d\n", numEffects, mSessionId);
if (numEffects) {
const bool locked = afutils::dumpTryLock(mutex());
// failed to lock - AudioFlinger is probably deadlocked
if (!locked) {
result.append("\tCould not lock mutex:\n");
}
const std::string inBufferStr = dumpInOutBuffer(true /* isInput */, mInBuffer);
const std::string outBufferStr = dumpInOutBuffer(false /* isInput */, mOutBuffer);
result.appendFormat("\t%-*s%-*s Active tracks:\n",
(int)inBufferStr.size(), "In buffer ",
(int)outBufferStr.size(), "Out buffer ");
result.appendFormat("\t%s %s %d\n",
inBufferStr.c_str(), outBufferStr.c_str(), mActiveTrackCnt);
write(fd, result.c_str(), result.size());
for (size_t i = 0; i < numEffects; ++i) {
sp<IAfEffectModule> effect = mEffects[i];
if (effect != 0) {
effect->dump(fd, args);
}
}
if (locked) {
mutex().unlock();
}
} else {
write(fd, result.c_str(), result.size());
}
}
// must be called with IAfThreadBase::mutex() held
void EffectChain::setEffectSuspended_l(
const effect_uuid_t *type, bool suspend)
{
sp<SuspendedEffectDesc> desc;
// use effect type UUID timelow as key as there is no real risk of identical
// timeLow fields among effect type UUIDs.
ssize_t index = mSuspendedEffects.indexOfKey(type->timeLow);
if (suspend) {
if (index >= 0) {
desc = mSuspendedEffects.valueAt(index);
} else {
desc = new SuspendedEffectDesc();
desc->mType = *type;
mSuspendedEffects.add(type->timeLow, desc);
ALOGV("setEffectSuspended_l() add entry for %08x", type->timeLow);
}
if (desc->mRefCount++ == 0) {
sp<IAfEffectModule> effect = getEffectIfEnabled(type);
if (effect != 0) {
desc->mEffect = effect;
effect->setSuspended(true);
effect->setEnabled(false, false /*fromHandle*/);
}
}
} else {
if (index < 0) {
return;
}
desc = mSuspendedEffects.valueAt(index);
if (desc->mRefCount <= 0) {
ALOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount);
desc->mRefCount = 0;
return;
}
if (--desc->mRefCount == 0) {
ALOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
if (desc->mEffect != 0) {
sp<IAfEffectModule> effect = desc->mEffect.promote();
if (effect != 0) {
effect->setSuspended(false);
effect->mutex().lock();
IAfEffectHandle *handle = effect->controlHandle_l();
if (handle != NULL && !handle->disconnected()) {
effect->setEnabled_l(handle->enabled());
}
effect->mutex().unlock();
}
desc->mEffect.clear();
}
mSuspendedEffects.removeItemsAt(index);
}
}
}
// must be called with IAfThreadBase::mutex() held
void EffectChain::setEffectSuspendedAll_l(bool suspend)
{
sp<SuspendedEffectDesc> desc;
ssize_t index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
if (suspend) {
if (index >= 0) {
desc = mSuspendedEffects.valueAt(index);
} else {
desc = new SuspendedEffectDesc();
mSuspendedEffects.add((int)kKeyForSuspendAll, desc);
ALOGV("setEffectSuspendedAll_l() add entry for 0");
}
if (desc->mRefCount++ == 0) {
Vector< sp<IAfEffectModule> > effects;
getSuspendEligibleEffects(effects);
for (size_t i = 0; i < effects.size(); i++) {
setEffectSuspended_l(&effects[i]->desc().type, true);
}
}
} else {
if (index < 0) {
return;
}
desc = mSuspendedEffects.valueAt(index);
if (desc->mRefCount <= 0) {
ALOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount);
desc->mRefCount = 1;
}
if (--desc->mRefCount == 0) {
Vector<const effect_uuid_t *> types;
for (size_t i = 0; i < mSuspendedEffects.size(); i++) {
if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) {
continue;
}
types.add(&mSuspendedEffects.valueAt(i)->mType);
}
for (size_t i = 0; i < types.size(); i++) {
setEffectSuspended_l(types[i], false);
}
ALOGV("setEffectSuspendedAll_l() remove entry for %08x",
mSuspendedEffects.keyAt(index));
mSuspendedEffects.removeItem((int)kKeyForSuspendAll);
}
}
}
// The volume effect is used for automated tests only
#ifndef OPENSL_ES_H_
static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6,
{ 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
#endif //OPENSL_ES_H_
/* static */
bool EffectChain::isEffectEligibleForBtNrecSuspend(const effect_uuid_t *type)
{
// Only NS and AEC are suspended when BtNRec is off
if ((memcmp(type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) ||
(memcmp(type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) {
return true;
}
return false;
}
bool EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)
{
// auxiliary effects and visualizer are never suspended on output mix
if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
(((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) ||
(memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) ||
(memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0) ||
(memcmp(&desc.type, SL_IID_DYNAMICSPROCESSING, sizeof(effect_uuid_t)) == 0))) {
return false;
}
return true;
}
void EffectChain::getSuspendEligibleEffects(
Vector< sp<IAfEffectModule> > &effects)
{
effects.clear();
for (size_t i = 0; i < mEffects.size(); i++) {
if (isEffectEligibleForSuspend(mEffects[i]->desc())) {
effects.add(mEffects[i]);
}
}
}
sp<IAfEffectModule> EffectChain::getEffectIfEnabled(const effect_uuid_t *type)
{
sp<IAfEffectModule> effect = getEffectFromType_l(type);
return effect != 0 && effect->isEnabled() ? effect : 0;
}
void EffectChain::checkSuspendOnEffectEnabled(const sp<IAfEffectModule>& effect,
bool enabled)
{
ssize_t index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
if (enabled) {
if (index < 0) {
// if the effect is not suspend check if all effects are suspended
index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
if (index < 0) {
return;
}
if (!isEffectEligibleForSuspend(effect->desc())) {
return;
}
setEffectSuspended_l(&effect->desc().type, enabled);
index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
if (index < 0) {
ALOGW("checkSuspendOnEffectEnabled() Fx should be suspended here!");
return;
}
}
ALOGV("checkSuspendOnEffectEnabled() enable suspending fx %08x",
effect->desc().type.timeLow);
sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
// if effect is requested to suspended but was not yet enabled, suspend it now.
if (desc->mEffect == 0) {
desc->mEffect = effect;
effect->setEnabled(false, false /*fromHandle*/);
effect->setSuspended(true);
}
} else {
if (index < 0) {
return;
}
ALOGV("checkSuspendOnEffectEnabled() disable restoring fx %08x",
effect->desc().type.timeLow);
sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
desc->mEffect.clear();
effect->setSuspended(false);
}
}
bool EffectChain::isNonOffloadableEnabled() const
{
audio_utils::lock_guard _l(mutex());
return isNonOffloadableEnabled_l();
}
bool EffectChain::isNonOffloadableEnabled_l() const
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
if (mEffects[i]->isEnabled() && !mEffects[i]->isOffloadable()) {
return true;
}
}
return false;
}
void EffectChain::setThread(const sp<IAfThreadBase>& thread)
{
audio_utils::lock_guard _l(mutex());
mEffectCallback->setThread(thread);
}
void EffectChain::checkOutputFlagCompatibility(audio_output_flags_t *flags) const
{
if ((*flags & AUDIO_OUTPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
*flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_RAW);
}
if ((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
*flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST);
}
if ((*flags & AUDIO_OUTPUT_FLAG_BIT_PERFECT) != 0 && !isBitPerfectCompatible()) {
*flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_BIT_PERFECT);
}
}
void EffectChain::checkInputFlagCompatibility(audio_input_flags_t *flags) const
{
if ((*flags & AUDIO_INPUT_FLAG_RAW) != 0 && !isRawCompatible()) {
*flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_RAW);
}
if ((*flags & AUDIO_INPUT_FLAG_FAST) != 0 && !isFastCompatible()) {
*flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST);
}
}
bool EffectChain::isRawCompatible() const
{
audio_utils::lock_guard _l(mutex());
for (const auto &effect : mEffects) {
if (effect->isProcessImplemented()) {
return false;
}
}
// Allow effects without processing.
return true;
}
bool EffectChain::isFastCompatible() const
{
audio_utils::lock_guard _l(mutex());
for (const auto &effect : mEffects) {
if (effect->isProcessImplemented()
&& effect->isImplementationSoftware()) {
return false;
}
}
// Allow effects without processing or hw accelerated effects.
return true;
}
bool EffectChain::isBitPerfectCompatible() const {
audio_utils::lock_guard _l(mutex());
for (const auto &effect : mEffects) {
if (effect->isProcessImplemented()
&& effect->isImplementationSoftware()) {
return false;
}
}
// Allow effects without processing or hw accelerated effects.
return true;
}
// isCompatibleWithThread_l() must be called with thread->mutex() held
bool EffectChain::isCompatibleWithThread_l(const sp<IAfThreadBase>& thread) const
{
audio_utils::lock_guard _l(mutex());
for (size_t i = 0; i < mEffects.size(); i++) {
if (thread->checkEffectCompatibility_l(&(mEffects[i]->desc()), mSessionId) != NO_ERROR) {
return false;
}
}
return true;
}
// EffectCallbackInterface implementation
status_t EffectChain::EffectCallback::createEffectHal(
const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
sp<EffectHalInterface> *effect) {
status_t status = NO_INIT;
const sp<EffectsFactoryHalInterface> effectsFactory =
EffectConfiguration::getEffectsFactoryHal();
if (effectsFactory != 0) {
status = effectsFactory->createEffect(pEffectUuid, sessionId, io(), deviceId, effect);
}
return status;
}
bool EffectChain::EffectCallback::updateOrphanEffectChains(
const sp<IAfEffectBase>& effect) {
// in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
return mAfThreadCallback->updateOrphanEffectChains(effect->asEffectModule());
}
status_t EffectChain::EffectCallback::allocateHalBuffer(
size_t size, sp<EffectBufferHalInterface>* buffer) {
return mAfThreadCallback->getEffectsFactoryHal()->allocateBuffer(size, buffer);
}
status_t EffectChain::EffectCallback::addEffectToHal(
const sp<EffectHalInterface>& effect) {
status_t result = NO_INIT;
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return result;
}
sp <StreamHalInterface> st = t->stream();
if (st == nullptr) {
return result;
}
result = st->addEffect(effect);
ALOGE_IF(result != OK, "Error when adding effect: %d", result);
return result;
}
status_t EffectChain::EffectCallback::removeEffectFromHal(
const sp<EffectHalInterface>& effect) {
status_t result = NO_INIT;
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return result;
}
sp <StreamHalInterface> st = t->stream();
if (st == nullptr) {
return result;
}
result = st->removeEffect(effect);
ALOGE_IF(result != OK, "Error when removing effect: %d", result);
return result;
}
audio_io_handle_t EffectChain::EffectCallback::io() const {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_IO_HANDLE_NONE;
}
return t->id();
}
bool EffectChain::EffectCallback::isOutput() const {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return true;
}
return t->isOutput();
}
bool EffectChain::EffectCallback::isOffload() const {
return mThreadType == IAfThreadBase::OFFLOAD;
}
bool EffectChain::EffectCallback::isOffloadOrDirect() const {
return mThreadType == IAfThreadBase::OFFLOAD
|| mThreadType == IAfThreadBase::DIRECT;
}
bool EffectChain::EffectCallback::isOffloadOrMmap() const {
switch (mThreadType) {
case IAfThreadBase::OFFLOAD:
case IAfThreadBase::MMAP_PLAYBACK:
case IAfThreadBase::MMAP_CAPTURE:
return true;
default:
return false;
}
}
bool EffectChain::EffectCallback::isSpatializer() const {
return mThreadType == IAfThreadBase::SPATIALIZER;
}
uint32_t EffectChain::EffectCallback::sampleRate() const {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return 0;
}
return t->sampleRate();
}
audio_channel_mask_t EffectChain::EffectCallback::inChannelMask(int id) const
NO_THREAD_SAFETY_ANALYSIS
// calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively
{
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_CHANNEL_NONE;
}
sp<IAfEffectChain> c = chain().promote();
if (c == nullptr) {
return AUDIO_CHANNEL_NONE;
}
if (mThreadType == IAfThreadBase::SPATIALIZER) {
if (c->sessionId() == AUDIO_SESSION_OUTPUT_STAGE) {
if (c->isFirstEffect(id)) {
return t->mixerChannelMask();
} else {
return t->channelMask();
}
} else if (!audio_is_global_session(c->sessionId())) {
if ((t->hasAudioSession_l(c->sessionId())
& IAfThreadBase::SPATIALIZED_SESSION) != 0) {
return t->mixerChannelMask();
} else {
return t->channelMask();
}
} else {
return t->channelMask();
}
} else {
return t->channelMask();
}
}
uint32_t EffectChain::EffectCallback::inChannelCount(int id) const {
return audio_channel_count_from_out_mask(inChannelMask(id));
}
audio_channel_mask_t EffectChain::EffectCallback::outChannelMask() const
NO_THREAD_SAFETY_ANALYSIS
// calling function 'hasAudioSession_l' requires holding mutex 'ThreadBase_Mutex' exclusively
{
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_CHANNEL_NONE;
}
sp<IAfEffectChain> c = chain().promote();
if (c == nullptr) {
return AUDIO_CHANNEL_NONE;
}
if (mThreadType == IAfThreadBase::SPATIALIZER) {
if (!audio_is_global_session(c->sessionId())) {
if ((t->hasAudioSession_l(c->sessionId())
& IAfThreadBase::SPATIALIZED_SESSION) != 0) {
return t->mixerChannelMask();
} else {
return t->channelMask();
}
} else {
return t->channelMask();
}
} else {
return t->channelMask();
}
}
uint32_t EffectChain::EffectCallback::outChannelCount() const {
return audio_channel_count_from_out_mask(outChannelMask());
}
audio_channel_mask_t EffectChain::EffectCallback::hapticChannelMask() const {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return AUDIO_CHANNEL_NONE;
}
return t->hapticChannelMask();
}
size_t EffectChain::EffectCallback::frameCount() const {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return 0;
}
return t->frameCount();
}
uint32_t EffectChain::EffectCallback::latency() const
NO_THREAD_SAFETY_ANALYSIS // latency_l() access
{
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return 0;
}
// TODO(b/275956781) - this requires the thread lock.
return t->latency_l();
}
void EffectChain::EffectCallback::setVolumeForOutput(float left, float right) const
NO_THREAD_SAFETY_ANALYSIS // setVolumeForOutput_l() access
{
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
t->setVolumeForOutput_l(left, right);
}
void EffectChain::EffectCallback::checkSuspendOnEffectEnabled(
const sp<IAfEffectBase>& effect, bool enabled, bool threadLocked) {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
t->checkSuspendOnEffectEnabled(enabled, effect->sessionId(), threadLocked);
sp<IAfEffectChain> c = chain().promote();
if (c == nullptr) {
return;
}
// in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
c->checkSuspendOnEffectEnabled(effect->asEffectModule(), enabled);
}
void EffectChain::EffectCallback::onEffectEnable(const sp<IAfEffectBase>& effect) {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
// in EffectChain context, an EffectBase is always from an EffectModule so static cast is safe
t->onEffectEnable(effect->asEffectModule());
}
void EffectChain::EffectCallback::onEffectDisable(const sp<IAfEffectBase>& effect) {
checkSuspendOnEffectEnabled(effect, false, false /*threadLocked*/);
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return;
}
t->onEffectDisable();
}
bool EffectChain::EffectCallback::disconnectEffectHandle(IAfEffectHandle *handle,
bool unpinIfLast) {
const sp<IAfThreadBase> t = thread().promote();
if (t == nullptr) {
return false;
}
t->disconnectEffectHandle(handle, unpinIfLast);
return true;
}
void EffectChain::EffectCallback::resetVolume() {
sp<IAfEffectChain> c = chain().promote();
if (c == nullptr) {
return;
}
c->resetVolume_l();
}
product_strategy_t EffectChain::EffectCallback::strategy() const {
sp<IAfEffectChain> c = chain().promote();
if (c == nullptr) {
return PRODUCT_STRATEGY_NONE;
}
return c->strategy();
}
int32_t EffectChain::EffectCallback::activeTrackCnt() const {
sp<IAfEffectChain> c = chain().promote();
if (c == nullptr) {
return 0;
}
return c->activeTrackCnt();
}
#undef LOG_TAG
#define LOG_TAG "DeviceEffectProxy"
/* static */
sp<IAfDeviceEffectProxy> IAfDeviceEffectProxy::create(
const AudioDeviceTypeAddr& device,
const sp<DeviceEffectManagerCallback>& callback,
effect_descriptor_t *desc, int id, bool notifyFramesProcessed)
{
return sp<DeviceEffectProxy>::make(device,
callback,
desc, id, notifyFramesProcessed);
}
status_t DeviceEffectProxy::setEnabled(bool enabled, bool fromHandle)
{
status_t status = EffectBase::setEnabled(enabled, fromHandle);
audio_utils::lock_guard _l(proxyMutex());
if (status == NO_ERROR) {
for (auto& handle : mEffectHandles) {
Status bs;
if (enabled) {
bs = handle.second->asIEffect()->enable(&status);
} else {
bs = handle.second->asIEffect()->disable(&status);
}
if (!bs.isOk()) {
status = statusTFromBinderStatus(bs);
}
}
}
ALOGV("%s enable %d status %d", __func__, enabled, status);
return status;
}
status_t DeviceEffectProxy::init(
const std::map <audio_patch_handle_t, IAfPatchPanel::Patch>& patches) {
//For all audio patches
//If src or sink device match
//If the effect is HW accelerated
// if no corresponding effect module
// Create EffectModule: mHalEffect
//Create and attach EffectHandle
//If the effect is not HW accelerated and the patch sink or src is a mixer port
// Create Effect on patch input or output thread on session -1
//Add EffectHandle to EffectHandle map of Effect Proxy:
ALOGV("%s device type %d address %s", __func__, mDevice.mType, mDevice.getAddress());
status_t status = NO_ERROR;
for (auto &patch : patches) {
status = onCreatePatch(patch.first, patch.second);
ALOGV("%s onCreatePatch status %d", __func__, status);
if (status == BAD_VALUE) {
return status;
}
}
return status;
}
status_t DeviceEffectProxy::onUpdatePatch(audio_patch_handle_t oldPatchHandle,
audio_patch_handle_t newPatchHandle,
const IAfPatchPanel::Patch& /* patch */) {
status_t status = NAME_NOT_FOUND;
ALOGV("%s", __func__);
audio_utils::lock_guard _l(proxyMutex());
if (mEffectHandles.find(oldPatchHandle) != mEffectHandles.end()) {
ALOGV("%s replacing effect from handle %d to handle %d", __func__, oldPatchHandle,
newPatchHandle);
sp<IAfEffectHandle> effect = mEffectHandles.at(oldPatchHandle);
mEffectHandles.erase(oldPatchHandle);
mEffectHandles.emplace(newPatchHandle, effect);
status = NO_ERROR;
}
return status;
}
status_t DeviceEffectProxy::onCreatePatch(
audio_patch_handle_t patchHandle, const IAfPatchPanel::Patch& patch) {
status_t status = NAME_NOT_FOUND;
sp<IAfEffectHandle> handle;
// only consider source[0] as this is the only "true" source of a patch
status = checkPort(patch, &patch.mAudioPatch.sources[0], &handle);
ALOGV("%s source checkPort status %d", __func__, status);
for (uint32_t i = 0; i < patch.mAudioPatch.num_sinks && status == NAME_NOT_FOUND; i++) {
status = checkPort(patch, &patch.mAudioPatch.sinks[i], &handle);
ALOGV("%s sink %d checkPort status %d", __func__, i, status);
}
if (status == NO_ERROR || status == ALREADY_EXISTS) {
audio_utils::lock_guard _l(proxyMutex());
size_t erasedHandle = mEffectHandles.erase(patchHandle);
ALOGV("%s %s effecthandle %p for patch %d",
__func__, (erasedHandle == 0 ? "adding" : "replacing"), handle.get(), patchHandle);
mEffectHandles.emplace(patchHandle, handle);
}
ALOGW_IF(status == BAD_VALUE,
"%s cannot attach effect %s on patch %d", __func__, mDescriptor.name, patchHandle);
return status;
}
status_t DeviceEffectProxy::checkPort(const IAfPatchPanel::Patch& patch,
const struct audio_port_config *port, sp<IAfEffectHandle> *handle)
NO_THREAD_SAFETY_ANALYSIS
// calling function 'createEffect_l' requires holding mutex 'AudioFlinger_Mutex' exclusively
{
ALOGV("%s type %d device type %d address %s device ID %d patch.isSoftware() %d",
__func__, port->type, port->ext.device.type,
port->ext.device.address, port->id, patch.isSoftware());
if (port->type != AUDIO_PORT_TYPE_DEVICE || port->ext.device.type != mDevice.mType ||
port->ext.device.address != mDevice.address()) {
return NAME_NOT_FOUND;
}
if (((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) &&
(audio_port_config_has_input_direction(port))) {
ALOGI("%s don't create postprocessing effect on record port", __func__);
return NAME_NOT_FOUND;
}
if (((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC) &&
(!audio_port_config_has_input_direction(port))) {
ALOGI("%s don't create preprocessing effect on playback port", __func__);
return NAME_NOT_FOUND;
}
status_t status = NAME_NOT_FOUND;
if (mDescriptor.flags & EFFECT_FLAG_HW_ACC_TUNNEL) {
audio_utils::lock_guard _l(proxyMutex());
if (mHalEffect != nullptr && mDevicePort.id == port->id) {
ALOGV("%s reusing HAL effect", __func__);
} else {
mDevicePort = *port;
mHalEffect = new EffectModule(mMyCallback,
const_cast<effect_descriptor_t *>(&mDescriptor),
mMyCallback->newEffectId(), AUDIO_SESSION_DEVICE,
false /* pinned */, port->id);
if (audio_is_input_device(mDevice.mType)) {
mHalEffect->setInputDevice(mDevice);
} else {
mHalEffect->setDevices({mDevice});
}
mHalEffect->configure();
}
*handle = new EffectHandle(mHalEffect, nullptr, nullptr, 0 /*priority*/,
mNotifyFramesProcessed);
status = (*handle)->initCheck();
if (status == OK) {
status = mHalEffect->addHandle((*handle).get());
} else {
mHalEffect.clear();
mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
}
} else if (patch.isSoftware() || patch.thread().promote() != nullptr) {
sp<IAfThreadBase> thread;
if (audio_port_config_has_input_direction(port)) {
if (patch.isSoftware()) {
thread = patch.mRecord.thread();
} else {
thread = patch.thread().promote();
}
} else {
if (patch.isSoftware()) {
thread = patch.mPlayback.thread();
} else {
thread = patch.thread().promote();
}
}
int enabled;
*handle = thread->createEffect_l(nullptr, nullptr, 0, AUDIO_SESSION_DEVICE,
const_cast<effect_descriptor_t *>(&mDescriptor),
&enabled, &status, false, false /*probe*/,
mNotifyFramesProcessed);
ALOGV("%s thread->createEffect_l status %d", __func__, status);
} else {
status = BAD_VALUE;
}
if (status == NO_ERROR || status == ALREADY_EXISTS) {
Status bs;
if (isEnabled()) {
bs = (*handle)->asIEffect()->enable(&status);
} else {
bs = (*handle)->asIEffect()->disable(&status);
}
if (!bs.isOk()) {
status = statusTFromBinderStatus(bs);
}
}
return status;
}
void DeviceEffectProxy::onReleasePatch(audio_patch_handle_t patchHandle) {
sp<IAfEffectHandle> effect;
{
audio_utils::lock_guard _l(proxyMutex());
if (mEffectHandles.find(patchHandle) != mEffectHandles.end()) {
effect = mEffectHandles.at(patchHandle);
mEffectHandles.erase(patchHandle);
}
}
}
size_t DeviceEffectProxy::removeEffect(const sp<IAfEffectModule>& effect)
{
audio_utils::lock_guard _l(proxyMutex());
if (effect == mHalEffect) {
mHalEffect->release_l();
mHalEffect.clear();
mDevicePort.id = AUDIO_PORT_HANDLE_NONE;
}
return mHalEffect == nullptr ? 0 : 1;
}
status_t DeviceEffectProxy::addEffectToHal(
const sp<EffectHalInterface>& effect) {
if (mHalEffect == nullptr) {
return NO_INIT;
}
return mManagerCallback->addEffectToHal(&mDevicePort, effect);
}
status_t DeviceEffectProxy::removeEffectFromHal(
const sp<EffectHalInterface>& effect) {
if (mHalEffect == nullptr) {
return NO_INIT;
}
return mManagerCallback->removeEffectFromHal(&mDevicePort, effect);
}
status_t DeviceEffectProxy::command(
int32_t cmdCode, const std::vector<uint8_t>& cmdData, int32_t maxReplySize,
std::vector<uint8_t>* reply) {
audio_utils::lock_guard _l(proxyMutex());
status_t status = EffectBase::command(cmdCode, cmdData, maxReplySize, reply);
if (status == NO_ERROR) {
for (auto& handle : mEffectHandles) {
sp<IAfEffectBase> effect = handle.second->effect().promote();
if (effect != nullptr) {
status = effect->command(cmdCode, cmdData, maxReplySize, reply);
}
}
}
ALOGV("%s status %d", __func__, status);
return status;
}
bool DeviceEffectProxy::isOutput() const {
if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE) {
return mDevicePort.role == AUDIO_PORT_ROLE_SINK;
}
return true;
}
uint32_t DeviceEffectProxy::sampleRate() const {
if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE &&
(mDevicePort.config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) != 0) {
return mDevicePort.sample_rate;
}
return DEFAULT_OUTPUT_SAMPLE_RATE;
}
audio_channel_mask_t DeviceEffectProxy::channelMask() const {
if (mDevicePort.id != AUDIO_PORT_HANDLE_NONE &&
(mDevicePort.config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) != 0) {
return mDevicePort.channel_mask;
}
return AUDIO_CHANNEL_OUT_STEREO;
}
uint32_t DeviceEffectProxy::channelCount() const {
if (isOutput()) {
return audio_channel_count_from_out_mask(channelMask());
}
return audio_channel_count_from_in_mask(channelMask());
}
void DeviceEffectProxy::dump2(int fd, int spaces) const
NO_THREAD_SAFETY_ANALYSIS // conditional try lock
{
const Vector<String16> args;
EffectBase::dump(fd, args);
const bool locked = afutils::dumpTryLock(proxyMutex());
if (!locked) {
String8 result("DeviceEffectProxy may be deadlocked\n");
write(fd, result.c_str(), result.size());
}
String8 outStr;
if (mHalEffect != nullptr) {
outStr.appendFormat("%*sHAL Effect Id: %d\n", spaces, "", mHalEffect->id());
} else {
outStr.appendFormat("%*sNO HAL Effect\n", spaces, "");
}
write(fd, outStr.c_str(), outStr.size());
outStr.clear();
outStr.appendFormat("%*sSub Effects:\n", spaces, "");
write(fd, outStr.c_str(), outStr.size());
outStr.clear();
for (const auto& iter : mEffectHandles) {
outStr.appendFormat("%*sEffect for patch handle %d:\n", spaces + 2, "", iter.first);
write(fd, outStr.c_str(), outStr.size());
outStr.clear();
sp<IAfEffectBase> effect = iter.second->effect().promote();
if (effect != nullptr) {
effect->dump(fd, args);
}
}
if (locked) {
proxyMutex().unlock();
}
}
#undef LOG_TAG
#define LOG_TAG "DeviceEffectProxy::ProxyCallback"
int DeviceEffectProxy::ProxyCallback::newEffectId() {
return mManagerCallback->newEffectId();
}
bool DeviceEffectProxy::ProxyCallback::disconnectEffectHandle(
IAfEffectHandle *handle, bool unpinIfLast) {
sp<IAfEffectBase> effectBase = handle->effect().promote();
if (effectBase == nullptr) {
return false;
}
sp<IAfEffectModule> effect = effectBase->asEffectModule();
if (effect == nullptr) {
return false;
}
// restore suspended effects if the disconnected handle was enabled and the last one.
bool remove = (effect->removeHandle(handle) == 0) && (!effect->isPinned() || unpinIfLast);
if (remove) {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy != nullptr) {
proxy->removeEffect(effect);
}
if (handle->enabled()) {
effectBase->checkSuspendOnEffectEnabled(false, false /*threadLocked*/);
}
}
return true;
}
status_t DeviceEffectProxy::ProxyCallback::createEffectHal(
const effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t deviceId,
sp<EffectHalInterface> *effect) {
return mManagerCallback->createEffectHal(pEffectUuid, sessionId, deviceId, effect);
}
status_t DeviceEffectProxy::ProxyCallback::addEffectToHal(
const sp<EffectHalInterface>& effect) {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return NO_INIT;
}
return proxy->addEffectToHal(effect);
}
status_t DeviceEffectProxy::ProxyCallback::removeEffectFromHal(
const sp<EffectHalInterface>& effect) {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return NO_INIT;
}
return proxy->removeEffectFromHal(effect);
}
bool DeviceEffectProxy::ProxyCallback::isOutput() const {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return true;
}
return proxy->isOutput();
}
uint32_t DeviceEffectProxy::ProxyCallback::sampleRate() const {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return DEFAULT_OUTPUT_SAMPLE_RATE;
}
return proxy->sampleRate();
}
audio_channel_mask_t DeviceEffectProxy::ProxyCallback::inChannelMask(
int id __unused) const {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return AUDIO_CHANNEL_OUT_STEREO;
}
return proxy->channelMask();
}
uint32_t DeviceEffectProxy::ProxyCallback::inChannelCount(int id __unused) const {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return 2;
}
return proxy->channelCount();
}
audio_channel_mask_t DeviceEffectProxy::ProxyCallback::outChannelMask() const {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return AUDIO_CHANNEL_OUT_STEREO;
}
return proxy->channelMask();
}
uint32_t DeviceEffectProxy::ProxyCallback::outChannelCount() const {
sp<DeviceEffectProxy> proxy = mProxy.promote();
if (proxy == nullptr) {
return 2;
}
return proxy->channelCount();
}
void DeviceEffectProxy::ProxyCallback::onEffectEnable(
const sp<IAfEffectBase>& effectBase) {
sp<IAfEffectModule> effect = effectBase->asEffectModule();
if (effect == nullptr) {
return;
}
effect->start();
}
void DeviceEffectProxy::ProxyCallback::onEffectDisable(
const sp<IAfEffectBase>& effectBase) {
sp<IAfEffectModule> effect = effectBase->asEffectModule();
if (effect == nullptr) {
return;
}
effect->stop();
}
} // namespace android