Google Git
Sign in
android / device / samsung / manta / a7f0edc / . / voicefx / eS305VoiceProcessing.cpp
blob: 9a906851027f0c759a4b2a1fbd520e3ca4128839 [file] [log] [blame]
/*
* Copyright (C) 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.
*/
#include <errno.h>
#include <fcntl.h>
#define LOG_TAG "eS305VoiceProcessing"
//#define LOG_NDEBUG 0
#include <cutils/log.h>
#include "eS305VoiceProcessing.h"
#include <audio_effects/effect_aec.h>
#include <audio_effects/effect_ns.h>
#include <audio_effects/effect_agc.h>
extern "C" {
//------------------------------------------------------------------------------
// local definitions
//------------------------------------------------------------------------------
// number of sessions this effect bundle can be used for
#define ADNC_PFX_NUM_SESSION 8
// types of pre processing modules
enum adnc_pfx_id
{
PFX_ID_AEC = 0, // Acoustic Echo Cancellation
PFX_ID_NS, // Noise Suppression
PFX_ID_AGC, // Automatic Gain Control
PFX_ID_CNT
};
// Session state
enum adnc_pfx_session_state {
PFX_SESSION_STATE_INIT, // initialized
PFX_SESSION_STATE_CONFIG // configuration received
};
// Effect/Preprocessor state
enum adnc_pfx_effect_state {
PFX_EFFECT_STATE_INIT, // initialized
PFX_EFFECT_STATE_CREATED, // effect created
PFX_EFFECT_STATE_CONFIG, // configuration received/disabled
PFX_EFFECT_STATE_ACTIVE // active/enabled
};
typedef struct adnc_pfx_session_s adnc_pfx_session_t;
typedef struct adnc_pfx_effect_s adnc_pfx_effect_t;
typedef struct adnc_pfx_ops_s adnc_pfx_ops_t;
// Effect operation table. Functions for all pre processors are declared in sPreProcOps[] table.
// Function pointer can be null if no action required.
struct adnc_pfx_ops_s {
int (* create)(adnc_pfx_effect_t *fx);
int (* init)(adnc_pfx_effect_t *fx);
int (* reset)(adnc_pfx_effect_t *fx);
void (* enable)(adnc_pfx_effect_t *fx);
void (* disable)(adnc_pfx_effect_t *fx);
int (* set_parameter)(adnc_pfx_effect_t *fx, void *param, void *value);
int (* get_parameter)(adnc_pfx_effect_t *fx, void *param, size_t *size, void *value);
int (* set_device)(adnc_pfx_effect_t *fx, uint32_t device);
};
// Effect context
struct adnc_pfx_effect_s {
const struct effect_interface_s *itfe;
uint32_t procId; // type of pre processor (enum adnc_pfx_id)
uint32_t state; // current state (enum adnc_pfx_effect_state)
adnc_pfx_session_t *session; // session the effect is on
const adnc_pfx_ops_t *ops; // effect ops table
};
// Session context
struct adnc_pfx_session_s {
uint32_t state; // current state (enum adnc_pfx_session_state)
audio_source_t audioSource;
// FIXME not used, delete?
//int audioSessionId; // audio session ID
int ioHandle; // handle of input stream this session is on
uint32_t createdMsk; // bit field containing IDs of created pre processors
uint32_t activeMsk; // bit field containing IDs of pre processors currently active
struct adnc_pfx_effect_s effects[PFX_ID_CNT]; // effects in this session
// effect settings
// none controllable from public API here
};
//-----------------------------------------
// forward declarations
//-----------------------------------------
int Adnc_SetNoiseSuppressionInt_l(bool);
int Adnc_SetAutomaticGainControlInt_l(bool);
int Adnc_SetEchoCancellationInt_l(bool);
int Adnc_ReevaluateUsageInt_l(audio_io_handle_t);
int Adnc_SleepInt_l();
//------------------------------------------------------------------------------
// eS305 control
//------------------------------------------------------------------------------
#define ES305_SYSFS_PATH "/sys/class/i2c-dev/i2c-4/device/4-003e/"
#define ES305_VOICE_PROCESSING_PATH ES305_SYSFS_PATH "voice_processing"
#define ES305_PRESET_PATH ES305_SYSFS_PATH "preset"
#define ES305_TX_NS_LEVEL_PATH ES305_SYSFS_PATH "tx_ns_level"
#define ES305_TX_AGC_ENABLE_PATH ES305_SYSFS_PATH "tx_agc_enable"
#define ES305_AEC_ENABLE_PATH ES305_SYSFS_PATH "aec_enable"
#define ES305_SLEEP_PATH ES305_SYSFS_PATH "sleep"
enum eS305_controls {
ES305_CTRL_VOICE_PROCESSING = 0,
ES305_CTRL_PRESET,
ES305_CTRL_TX_NS_LEVEL,
ES305_CTRL_TX_AGC_ENABLE,
ES305_CTRL_AEC_ENABLE,
ES305_CTRL_SLEEP,
ES305_NUM_CTRL
};
struct eS305_ctrl_s {
int fd[ES305_NUM_CTRL];
int current_preset;
int requested_preset;
int ioHandle;
};
typedef struct eS305_ctrl_s eS305_ctrl_t;
static eS305_ctrl_t eS305_ctrl = {
{ -1/*vp*/, -1/*preset*/, -1/*ns*/, -1/*agc*/, -1/*aec*/, -1/*sleep*/},
ES305_PRESET_OFF /*current_preset*/,
ES305_PRESET_INIT /*requested_preset, an invalid preset, different from current_preset*/,
ES305_IO_HANDLE_NONE
};
//------------------------------------------------------------------------------
// Effect descriptors
//------------------------------------------------------------------------------
// UUIDs for effect types have been generated from http://www.itu.int/ITU-T/asn1/uuid.html
// as the pre processing effects are not defined by OpenSL ES
// Acoustic Echo Cancellation
static const effect_descriptor_t aec_descriptor = {
FX_IID_AEC_, // type
{ 0xfd90ff00, 0x0b55, 0x11e2, 0x892e, { 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 } }, // uuid
EFFECT_CONTROL_API_VERSION,
(EFFECT_FLAG_TYPE_PRE_PROC|EFFECT_FLAG_DEVICE_IND),
0, //FIXME indicate CPU load
0, //FIXME indicate memory usage
"Acoustic Echo Canceler",
"Audience"
};
// Noise suppression
static const effect_descriptor_t ns_descriptor = {
FX_IID_NS_, // type
{ 0x08fa98b0, 0x0b56, 0x11e2, 0x892e, { 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 } }, // uuid
EFFECT_CONTROL_API_VERSION,
(EFFECT_FLAG_TYPE_PRE_PROC|EFFECT_FLAG_DEVICE_IND),
0, //FIXME indicate CPU load
0, //FIXME indicate memory usage
"Noise Suppression",
"Audience"
};
// Automatic Gain Control
static const effect_descriptor_t agc_descriptor = {
FX_IID_AGC_, // type
{ 0xe9e87eb0, 0x0b55, 0x11e2, 0x892e, { 0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66 } }, // uuid
EFFECT_CONTROL_API_VERSION,
(EFFECT_FLAG_TYPE_PRE_PROC|EFFECT_FLAG_DEVICE_IND),
0, //FIXME indicate CPU load
0, //FIXME indicate memory usage
"Automatic Gain Control",
"Audience"
};
static const effect_descriptor_t *adnc_pfx_descriptors[PFX_ID_CNT] = {
&aec_descriptor,
&ns_descriptor,
&agc_descriptor
};
//------------------------------------------------------------------------------
// Helper functions
//------------------------------------------------------------------------------
static const effect_uuid_t * const sAdncUuidTable[PFX_ID_CNT] = {
FX_IID_AEC,
FX_IID_NS,
FX_IID_AGC
};
const effect_uuid_t * Adnc_ProcIdToUuid(int procId)
{
if (procId >= PFX_ID_CNT) {
return EFFECT_UUID_NULL;
}
return sAdncUuidTable[procId];
}
uint32_t Adnc_UuidToProcId(const effect_uuid_t * uuid)
{
size_t i;
for (i = 0; i < PFX_ID_CNT; i++) {
if (memcmp(uuid, sAdncUuidTable[i], sizeof(*uuid)) == 0) {
break;
}
}
return i;
}
//------------------------------------------------------------------------------
// Acoustic Echo Canceler (AEC)
//------------------------------------------------------------------------------
int aec_init (adnc_pfx_effect_t *effect)
{
ALOGV("aec_init [noop]");
return 0;
}
int aec_create(adnc_pfx_effect_t *effect)
{
ALOGV("aec_create [noop]");
return aec_init (effect);
}
int aec_reset(adnc_pfx_effect_t *effect)
{
ALOGV("aec_reset [noop]");
return 0;
}
int aec_get_parameter(adnc_pfx_effect_t *effect,
void *pParam,
size_t *pValueSize,
void *pValue)
{
int status = 0;
uint32_t param = *(uint32_t *)pParam;
if (*pValueSize < sizeof(uint32_t)) {
return -EINVAL;
}
/* NOT SUPPORTED
switch (param) {
case AEC_PARAM_ECHO_DELAY:
case AEC_PARAM_PROPERTIES:
break;
default:
ALOGW("aec_get_parameter() unknown param %08x value %08x", param, *(uint32_t *)pValue);
status = -EINVAL;
break;
}
return status;
*/
return -EINVAL;
}
int aec_set_parameter (adnc_pfx_effect_t *effect, void *pParam, void *pValue)
{
int status = 0;
uint32_t param = *(uint32_t *)pParam;
uint32_t value = *(uint32_t *)pValue;
/* NOT SUPPORTED
switch (param) {
case AEC_PARAM_ECHO_DELAY:
case AEC_PARAM_PROPERTIES:
ALOGV("aec_setParameter() echo delay %d us, status %d", value, status);
break;
default:
ALOGW("aec_setParameter() unknown param %08x value %08x", param, *(uint32_t *)pValue);
status = -EINVAL;
break;
}
*/
return status;
}
void aec_enable(adnc_pfx_effect_t *effect)
{
ALOGV("aec_enable [noop]");
}
void aec_disable(adnc_pfx_effect_t *effect)
{
ALOGV("aec_disable [noop]");
}
int aec_set_device(adnc_pfx_effect_t *effect, uint32_t device)
{
ALOGV("aec_set_device(device=%08x) [noop]", device);
/*
switch(device) {
case AUDIO_DEVICE_OUT_EARPIECE:
break;
case AUDIO_DEVICE_OUT_SPEAKER:
break;
case AUDIO_DEVICE_OUT_WIRED_HEADSET:
case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
default:
break;
}
*/
return 0;
}
static const adnc_pfx_ops_t aec_ops = {
aec_create,
aec_init,
aec_reset,
aec_enable,
aec_disable,
aec_set_parameter,
aec_get_parameter,
aec_set_device,
};
//------------------------------------------------------------------------------
// Noise Suppression (NS)
//------------------------------------------------------------------------------
int ns_init (adnc_pfx_effect_t *effect)
{
ALOGV("ns_init [noop]");
return 0;
}
int ns_create(adnc_pfx_effect_t *effect)
{
ALOGV("ns_create %p", effect);
return ns_init (effect);
}
int ns_get_parameter(adnc_pfx_effect_t *effect,
void *pParam,
size_t *pValueSize,
void *pValue)
{
int status = 0;
return status;
}
int ns_set_parameter(adnc_pfx_effect_t *effect, void *pParam, void *pValue)
{
int status = 0;
return status;
}
void ns_enable(adnc_pfx_effect_t *effect)
{
ALOGV("ns_enable [noop]");
}
void ns_disable(adnc_pfx_effect_t *effect)
{
ALOGV("ns_disable [noop]");
}
static const adnc_pfx_ops_t ns_ops = {
ns_create,
ns_init,
NULL,
ns_enable,
ns_disable,
ns_set_parameter,
ns_get_parameter,
NULL,
};
//------------------------------------------------------------------------------
// Automatic Gain Control (AGC)
//------------------------------------------------------------------------------
int agc_init (adnc_pfx_effect_t *effect)
{
ALOGV("agc_init [noop]");
return 0;
}
int agc_create(adnc_pfx_effect_t *effect)
{
ALOGV("agc_create %p", effect);
return agc_init (effect);
}
int agc_get_parameter(adnc_pfx_effect_t *effect,
void *pParam,
size_t *pValueSize,
void *pValue)
{
int status = 0;
return status;
}
int agc_set_parameter(adnc_pfx_effect_t *effect, void *pParam, void *pValue)
{
int status = 0;
return status;
}
void agc_enable(adnc_pfx_effect_t *effect)
{
ALOGV("agc_enable [noop]");
}
void agc_disable(adnc_pfx_effect_t *effect)
{
ALOGV("agc_disable [noop]");
}
static const adnc_pfx_ops_t agc_ops = {
agc_create,
agc_init,
NULL,
agc_enable,
agc_disable,
agc_set_parameter,
agc_get_parameter,
NULL,
};
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
static const adnc_pfx_ops_t *sPreProcOps[PFX_ID_CNT] = {
&aec_ops,
&ns_ops,
&agc_ops
};
//------------------------------------------------------------------------------
// Pre-processing effect functions
//------------------------------------------------------------------------------
extern const struct effect_interface_s sEffectInterface;
#define BAD_STATE_ABORT(from, to) \
LOG_ALWAYS_FATAL("Bad state transition from %d to %d", from, to);
void AdncSession_SetProcEnabled(adnc_pfx_session_t *session, uint32_t procId, bool enabled);
int AdncPreProFx_SetState(adnc_pfx_effect_t *effect, uint32_t state)
{
int status = 0;
ALOGV("AdncPreProFx_SetState procId %d, new %d old %d", effect->procId, state, effect->state);
switch(state) {
case PFX_EFFECT_STATE_INIT:
switch(effect->state) {
case PFX_EFFECT_STATE_ACTIVE:
effect->ops->disable(effect);
AdncSession_SetProcEnabled(effect->session, effect->procId, false);
case PFX_EFFECT_STATE_CONFIG:
case PFX_EFFECT_STATE_CREATED:
case PFX_EFFECT_STATE_INIT:
break;
default:
BAD_STATE_ABORT(effect->state, state);
}
break;
case PFX_EFFECT_STATE_CREATED:
switch(effect->state) {
case PFX_EFFECT_STATE_INIT:
status = effect->ops->create(effect);
break;
case PFX_EFFECT_STATE_CREATED:
case PFX_EFFECT_STATE_ACTIVE:
case PFX_EFFECT_STATE_CONFIG:
ALOGE("Effect_SetState invalid transition");
status = -ENOSYS;
break;
default:
BAD_STATE_ABORT(effect->state, state);
}
break;
case PFX_EFFECT_STATE_CONFIG:
switch(effect->state) {
case PFX_EFFECT_STATE_INIT:
ALOGE("Effect_SetState invalid transition");
status = -ENOSYS;
break;
case PFX_EFFECT_STATE_ACTIVE:
effect->ops->disable(effect);
AdncSession_SetProcEnabled(effect->session, effect->procId, false);
break;
case PFX_EFFECT_STATE_CREATED:
case PFX_EFFECT_STATE_CONFIG:
break;
default:
BAD_STATE_ABORT(effect->state, state);
}
break;
case PFX_EFFECT_STATE_ACTIVE:
switch(effect->state) {
case PFX_EFFECT_STATE_INIT:
case PFX_EFFECT_STATE_CREATED:
ALOGE("Effect_SetState invalid transition");
status = -ENOSYS;
break;
case PFX_EFFECT_STATE_ACTIVE:
// enabling an already enabled effect is just ignored
break;
case PFX_EFFECT_STATE_CONFIG:
effect->ops->enable(effect);
AdncSession_SetProcEnabled(effect->session, effect->procId, true);
break;
default:
BAD_STATE_ABORT(effect->state, state);
}
break;
default:
BAD_STATE_ABORT(effect->state, state);
}
if (status == 0) {
effect->state = state;
}
return status;
}
int AdncPreProFx_Init(adnc_pfx_effect_t *effect, uint32_t procId)
{
ALOGV(" AdncPreProFx_Init(procId=%d)", procId);
effect->itfe = &sEffectInterface;
effect->ops = sPreProcOps[procId];
effect->procId = procId;
effect->state = PFX_EFFECT_STATE_INIT;
return 0;
}
int AdncPreProFx_Create(adnc_pfx_effect_t *effect,
adnc_pfx_session_t *session,
effect_handle_t *interface)
{
ALOGV(" AdncPreProFx_Create(effect=%p)", effect);
effect->session = session;
*interface = (effect_handle_t)&effect->itfe;
return AdncPreProFx_SetState(effect, PFX_EFFECT_STATE_CREATED);
}
int AdncPreProFx_Release(adnc_pfx_effect_t *effect)
{
return AdncPreProFx_SetState(effect, PFX_EFFECT_STATE_INIT);
}
//------------------------------------------------------------------------------
// Session functions
//------------------------------------------------------------------------------
/*
* Initialize a session context.
* Must be called with a lock on sAdncBundleLock.
*/
int AdncSession_Init_l(adnc_pfx_session_t *session)
{
ALOGV("AdncSession_Init()");
size_t i;
int status = 0;
session->state = PFX_SESSION_STATE_INIT;
session->audioSource = AUDIO_SOURCE_DEFAULT;
//session->audioSessionId = ES305_SESSION_ID_NONE; // FIXME not used delete?
session->ioHandle = ES305_IO_HANDLE_NONE;
session->createdMsk = 0;
session->activeMsk = 0;
// initialize each effect for this session context
for (i = 0; i < PFX_ID_CNT && status == 0; i++) {
status = AdncPreProFx_Init(&session->effects[i], i);
}
return status;
}
/*
* Must be called with a lock on sAdncBundleLock.
*/
int AdncSession_CreateEffect_l(adnc_pfx_session_t *session,
int32_t procId,
effect_handle_t *interface)
{
int status = -ENOMEM;
ALOGV("AdncSession_CreateEffect handle=%d procId %d, old createdMsk %08x",
session->ioHandle, procId, session->createdMsk);
status = AdncPreProFx_Create(&session->effects[procId], session, interface);
if (status >= 0) {
ALOGV(" AdncSession_CreateEffect OK");
session->createdMsk |= (1 << procId);
}
return status;
}
int AdncSession_SetConfig(adnc_pfx_session_t *session, effect_config_t *config)
{
ALOGV("AdncSession_SetConfig [noop]");
return 0;
}
void AdncSession_GetConfig(adnc_pfx_session_t *session, effect_config_t *config)
{
ALOGV("AdncSession_GetConfig [noop]");
}
int AdncSession_SetReverseConfig(adnc_pfx_session_t *session, effect_config_t *config)
{
ALOGV("AdncSession_SetReverseConfig [noop]");
return 0;
}
void AdncSession_GetReverseConfig(adnc_pfx_session_t *session, effect_config_t *config)
{
ALOGV("AdncSession_GetReverseConfig [noop]");
}
void AdncSession_SetProcEnabled(adnc_pfx_session_t *session, uint32_t procId, bool enabled)
{
ALOGV("AdncSession_SetProcEnabled [noop] proc %d, enabled %d", procId, enabled);
//no need to reevaluate session settings, if recording is currently ongoing, we'll reevaluate
// through eS305_AddEffect()
}
int AdncSession_SetSource(adnc_pfx_session_t *session, audio_source_t source)
{
session->audioSource = source;
return 0;
}
//------------------------------------------------------------------------------
// Bundle functions
//------------------------------------------------------------------------------
#define ADNC_BUNDLE_NO_INIT 1
static int sAdncBundleInitStatus = ADNC_BUNDLE_NO_INIT;
static adnc_pfx_session_t sAdncSessions[ADNC_PFX_NUM_SESSION];
static pthread_mutex_t sAdncBundleLock;
/* Returns a session context for the given IO handle
* Returns an existing session context if the IO handle matches, initializes a new one otherwise.
* Returns NULL if no more session contexts are available
* Must be called with a lock on sAdncBundleLock
*/
adnc_pfx_session_t *AdncBundle_GetSession_l(int32_t procId, int32_t sessionId, int32_t ioId)
{
size_t i;
for (i = 0; i < ADNC_PFX_NUM_SESSION; i++) {
if (sAdncSessions[i].ioHandle == ioId) {
return &sAdncSessions[i];
}
}
for (i = 0; i < ADNC_PFX_NUM_SESSION; i++) {
if (sAdncSessions[i].ioHandle == ES305_IO_HANDLE_NONE) {
//sAdncSessions[i].audioSessionId = sessionId; // FIXME not used delete?
sAdncSessions[i].ioHandle = ioId;
return &sAdncSessions[i];
}
}
ALOGV("AdncBundle_GetSession_l");
return NULL;
}
/*
* Must be called with a lock on sAdncBundleLock.
*/
int AdncBundle_Init_l() {
size_t i;
int status = 0;
if (sAdncBundleInitStatus <= 0) {
return sAdncBundleInitStatus;
}
// initialize all the session contexts that this bundle supports
for (i = 0; i < ADNC_PFX_NUM_SESSION && status == 0; i++) {
status = AdncSession_Init_l(&sAdncSessions[i]);
}
sAdncBundleInitStatus = status;
return sAdncBundleInitStatus;
}
/*
* Must be called with a lock on sAdncBundleLock.
*/
int AdncBundle_Release_l() {
ALOGV("AdncBundle_Release_l()");
Adnc_SleepInt_l();
for (int i = 0 ; i < ES305_NUM_CTRL ; i++) {
if (eS305_ctrl.fd[i] >= 0) {
close(eS305_ctrl.fd[i]);
}
eS305_ctrl.fd[i] = -1;
}
return 0;
}
const effect_descriptor_t *AdncBundle_GetDescriptor(const effect_uuid_t *uuid)
{
size_t i;
for (i = 0; i < PFX_ID_CNT; i++) {
if (memcmp(&adnc_pfx_descriptors[i]->uuid, uuid, sizeof(effect_uuid_t)) == 0) {
return adnc_pfx_descriptors[i];
}
}
return NULL;
}
/*
* Debug only: display session contexts
*/
void AdncBundle_logv_dumpSessions() {
ALOGV("Sessions:");
for (int i=0 ; i<ADNC_PFX_NUM_SESSION ; i++) {
ALOGV(" session %d handle=%d cre=%2x act=%2x",
i, sAdncSessions[i].ioHandle, sAdncSessions[i].createdMsk, sAdncSessions[i].activeMsk);
}
}
//------------------------------------------------------------------------------
// Effect Control Interface Implementation
//------------------------------------------------------------------------------
int AdncVoiceProcessingFx_Command(effect_handle_t self,
uint32_t cmdCode,
uint32_t cmdSize,
void *pCmdData,
uint32_t *replySize,
void *pReplyData)
{
adnc_pfx_effect_t * effect = (adnc_pfx_effect_t *) self;
int retsize;
int status;
if (effect == NULL){
return -EINVAL;
}
ALOGV("AdncVoiceProcessingFx_Command: command %d cmdSize %d",cmdCode, cmdSize);
switch (cmdCode){
case EFFECT_CMD_INIT:
if (pReplyData == NULL || *replySize != sizeof(int)){
return -EINVAL;
}
if (effect->ops->init) {
effect->ops->init(effect);
}
*(int *)pReplyData = 0;
break;
case EFFECT_CMD_SET_CONFIG: {
if (pCmdData == NULL||
cmdSize != sizeof(effect_config_t)||
pReplyData == NULL||
*replySize != sizeof(int)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_SET_CONFIG: ERROR");
return -EINVAL;
}
*(int *)pReplyData = AdncSession_SetConfig(effect->session, (effect_config_t *)pCmdData);
if (*(int *)pReplyData != 0) {
break;
}
if (effect->state != PFX_EFFECT_STATE_ACTIVE) {
*(int *)pReplyData = AdncPreProFx_SetState(effect, PFX_EFFECT_STATE_CONFIG);
}
} break;
case EFFECT_CMD_GET_CONFIG:
if (pReplyData == NULL ||
*replySize != sizeof(effect_config_t)) {
ALOGV("\tLVM_ERROR : AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_GET_CONFIG: ERROR");
return -EINVAL;
}
AdncSession_GetConfig(effect->session, (effect_config_t *)pReplyData);
break;
case EFFECT_CMD_SET_CONFIG_REVERSE:
if (pCmdData == NULL ||
cmdSize != sizeof(effect_config_t) ||
pReplyData == NULL ||
*replySize != sizeof(int)) {
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_SET_CONFIG_REVERSE: ERROR");
return -EINVAL;
}
*(int *)pReplyData = AdncSession_SetReverseConfig(effect->session,
(effect_config_t *)pCmdData);
if (*(int *)pReplyData != 0) {
break;
}
break;
case EFFECT_CMD_GET_CONFIG_REVERSE:
if (pReplyData == NULL ||
*replySize != sizeof(effect_config_t)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_GET_CONFIG_REVERSE: ERROR");
return -EINVAL;
}
AdncSession_GetReverseConfig(effect->session, (effect_config_t *)pCmdData);
break;
case EFFECT_CMD_RESET:
if (effect->ops->reset) {
effect->ops->reset(effect);
}
break;
case EFFECT_CMD_GET_PARAM:{
if (pCmdData == NULL ||
cmdSize < (int)sizeof(effect_param_t) ||
pReplyData == NULL ||
*replySize < (int)sizeof(effect_param_t)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_GET_PARAM: ERROR");
return -EINVAL;
}
effect_param_t *p = (effect_param_t *)pCmdData;
memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
p = (effect_param_t *)pReplyData;
int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
if (effect->ops->get_parameter) {
p->status = effect->ops->get_parameter(effect, p->data,
(size_t *)&p->vsize,
p->data + voffset);
*replySize = sizeof(effect_param_t) + voffset + p->vsize;
}
} break;
case EFFECT_CMD_SET_PARAM:{
if (pCmdData == NULL||
cmdSize < (int)sizeof(effect_param_t) ||
pReplyData == NULL ||
*replySize != sizeof(int32_t)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_SET_PARAM: ERROR");
return -EINVAL;
}
effect_param_t *p = (effect_param_t *) pCmdData;
if (p->psize != sizeof(int32_t)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: "
"EFFECT_CMD_SET_PARAM: ERROR, psize is not sizeof(int32_t)");
return -EINVAL;
}
if (effect->ops->set_parameter) {
*(int *)pReplyData = effect->ops->set_parameter(effect,
(void *)p->data,
p->data + p->psize);
}
} break;
case EFFECT_CMD_ENABLE:
if (pReplyData == NULL || *replySize != sizeof(int)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: EFFECT_CMD_ENABLE: ERROR");
return -EINVAL;
}
*(int *)pReplyData = AdncPreProFx_SetState(effect, PFX_EFFECT_STATE_ACTIVE);
break;
case EFFECT_CMD_DISABLE:
if (pReplyData == NULL || *replySize != sizeof(int)){
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: EFFECT_CMD_DISABLE: ERROR");
return -EINVAL;
}
*(int *)pReplyData = AdncPreProFx_SetState(effect, PFX_EFFECT_STATE_CONFIG);
break;
case EFFECT_CMD_SET_DEVICE:
case EFFECT_CMD_SET_INPUT_DEVICE:
if (pCmdData == NULL ||
cmdSize != sizeof(uint32_t)) {
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: EFFECT_CMD_SET_DEVICE: ERROR");
return -EINVAL;
}
if (effect->ops->set_device) {
effect->ops->set_device(effect, *(uint32_t *)pCmdData);
}
break;
case EFFECT_CMD_SET_VOLUME:
case EFFECT_CMD_SET_AUDIO_MODE:
case EFFECT_CMD_SET_FEATURE_CONFIG:
break;
case EFFECT_CMD_SET_AUDIO_SOURCE:
if (pCmdData == NULL ||
cmdSize != sizeof(uint32_t)) {
ALOGV("AdncVoiceProcessingFx_Command cmdCode Case: EFFECT_CMD_SET_AUDIO_SOURCE: ERROR");
return -EINVAL;
}
return AdncSession_SetSource(effect->session, (audio_source_t) *(uint32_t *)pCmdData);
break;
default:
return -EINVAL;
}
return 0;
}
int AdncVoiceProcessingFx_GetDescriptor(effect_handle_t self,
effect_descriptor_t *pDescriptor)
{
adnc_pfx_effect_t * effect = (adnc_pfx_effect_t *) self;
if (effect == NULL || pDescriptor == NULL) {
return -EINVAL;
}
memcpy(pDescriptor, adnc_pfx_descriptors[effect->procId], sizeof(effect_descriptor_t));
return 0;
}
// effect_handle_t interface implementation for effect
const struct effect_interface_s sEffectInterface = {
NULL, /* Process */
AdncVoiceProcessingFx_Command,
AdncVoiceProcessingFx_GetDescriptor,
NULL
};
//------------------------------------------------------------------------------
// Effect Library Interface Implementation
//------------------------------------------------------------------------------
int adnc_create(const effect_uuid_t *uuid,
int32_t sessionId,
int32_t ioId,
effect_handle_t *pInterface)
{
ALOGV("adnc_create: uuid: %08x session %d IO: %d", uuid->timeLow, sessionId, ioId);
int status = 0;
const effect_descriptor_t *desc;
adnc_pfx_session_t *session;
uint32_t procId;
pthread_mutex_lock(&sAdncBundleLock);
if (AdncBundle_Init_l() != 0) {
status = sAdncBundleInitStatus;
goto exit;
}
desc = AdncBundle_GetDescriptor(uuid);
if (desc == NULL) {
ALOGW(" adnc_create: fx not found uuid: %08x", uuid->timeLow);
status = -EINVAL;
goto exit;
}
procId = Adnc_UuidToProcId(&desc->type);
session = AdncBundle_GetSession_l(procId, sessionId, ioId);
if (session == NULL) {
ALOGW(" adnc_create: no more session available");
status = -EINVAL;
goto exit;
}
status = AdncSession_CreateEffect_l(session, procId, pInterface);
if (status < 0 && session->createdMsk == 0) {
session->ioHandle = ES305_IO_HANDLE_NONE;
}
exit:
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
int adnc_release(effect_handle_t interface)
{
int i, status = 0;
ALOGV("adnc_release %p", interface);
// the effect handle comes from the effect framework, ok to cast
const adnc_pfx_effect_t * fx = (adnc_pfx_effect_t *) interface;
const uint32_t removalMsk = ~(1 << fx->procId);
pthread_mutex_lock(&sAdncBundleLock);
if (AdncBundle_Init_l() != 0) {
status = sAdncBundleInitStatus;
goto exit;
}
if (fx->session->ioHandle == 0) {
status = -EINVAL;
goto exit;
}
// effect is released, flag it as inactive and not created
fx->session->createdMsk &= removalMsk;
fx->session->activeMsk &= removalMsk;
// configuration has changed, reevaluate
status = Adnc_ReevaluateUsageInt_l(fx->session->ioHandle);
// not checking the return status here: if there was an error,
// we still need to free the session and wouldn't exit here
// free session if it has no more effects
if (fx->session->createdMsk == 0) {
ALOGV(" resetting session on handle %d after effect release", fx->session->ioHandle);
const int statusInit = AdncSession_Init_l(fx->session);
if (status == 0) {
status = statusInit;
}
}
exit:
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
int adnc_get_descriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) {
if (pDescriptor == NULL || uuid == NULL){
ALOGV("adnc_get_descriptor() invalid params");
return -EINVAL;
}
const effect_descriptor_t *desc = AdncBundle_GetDescriptor(uuid);
if (desc == NULL) {
ALOGV("adnc_get_descriptor() not found");
return -EINVAL;
}
ALOGV("adnc_get_descriptor() got fx %s", desc->name);
memcpy(pDescriptor, desc, sizeof(effect_descriptor_t));
return 0;
}
audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
tag : AUDIO_EFFECT_LIBRARY_TAG,
version : EFFECT_LIBRARY_API_VERSION,
name : "Audience Voice Preprocessing Library",
implementor : "The Android Open Source Project",
create_effect : adnc_create,
release_effect : adnc_release,
get_descriptor : adnc_get_descriptor
};
//-------------------------------------------------------
// eS305 control interface
//-------------------------------------------------------
int Adnc_SetAutomaticGainControlInt_l(bool agc_on)
{
ALOGV("Adnc_SetAutomaticGainControlInt_l(%d)", agc_on);
if (eS305_ctrl.fd[ES305_CTRL_TX_AGC_ENABLE] < 0) {
ALOGV(" opening eS305 path for agc");
eS305_ctrl.fd[ES305_CTRL_TX_AGC_ENABLE] = open(ES305_TX_AGC_ENABLE_PATH, O_RDWR);
if (eS305_ctrl.fd[ES305_CTRL_TX_AGC_ENABLE] < 0) {
ALOGE(" Cannot open eS305 path for agc: %s", strerror(errno));
return -ENODEV;
}
}
if (agc_on) {
write(eS305_ctrl.fd[ES305_CTRL_TX_AGC_ENABLE], ES305_AGC_ON, strlen(ES305_AGC_ON));
} else {
write(eS305_ctrl.fd[ES305_CTRL_TX_AGC_ENABLE], ES305_AEC_OFF, strlen(ES305_AGC_OFF));
}
return 0;
}
int Adnc_SetEchoCancellationInt_l(bool aec_on)
{
ALOGV("Adnc_SetEchoCancellationInt_l(%d)", aec_on);
if (eS305_ctrl.fd[ES305_CTRL_AEC_ENABLE] < 0) {
ALOGV(" opening eS305 path for aec");
eS305_ctrl.fd[ES305_CTRL_AEC_ENABLE] = open(ES305_AEC_ENABLE_PATH, O_RDWR);
if (eS305_ctrl.fd[ES305_CTRL_AEC_ENABLE] < 0) {
ALOGE(" Cannot open eS305 path for aec: %s", strerror(errno));
return -ENODEV;
}
}
if (aec_on) {
write(eS305_ctrl.fd[ES305_CTRL_AEC_ENABLE], ES305_AEC_ON, strlen(ES305_AEC_ON));
} else {
write(eS305_ctrl.fd[ES305_CTRL_AEC_ENABLE], ES305_AEC_OFF, strlen(ES305_AEC_OFF));
}
return 0;
}
int Adnc_SetNoiseSuppressionInt_l(bool ns_on)
{
ALOGV("Adnc_SetNoiseSuppressionInt(%d)", ns_on);
if (eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL] < 0) {
ALOGV(" opening eS305 path for ns");
eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL] = open(ES305_TX_NS_LEVEL_PATH, O_RDWR);
if (eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL] < 0) {
ALOGE(" Cannot open eS305 path for ns: %s", strerror(errno));
return -ENODEV;
}
}
if (ns_on) {
if (eS305_ctrl.requested_preset == ES305_PRESET_ASRA_HANDHELD) {
ALOGV(" setting ns to %s", ES305_NS_VOICE_REC_HANDHELD_ON);
write(eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL],
ES305_NS_VOICE_REC_HANDHELD_ON, strlen(ES305_NS_VOICE_REC_HANDHELD_ON));
} else if ((eS305_ctrl.requested_preset == ES305_PRESET_ASRA_DESKTOP)
|| (eS305_ctrl.requested_preset == ES305_PRESET_ASRA_HEADSET)) {
ALOGV(" setting ns to %s", ES305_NS_VOICE_REC_SINGLE_MIC_ON);
write(eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL],
ES305_NS_VOICE_REC_SINGLE_MIC_ON, strlen(ES305_NS_VOICE_REC_SINGLE_MIC_ON));
} else {
ALOGV(" setting ns to %s", ES305_NS_DEFAULT_ON);
write(eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL],
ES305_NS_DEFAULT_ON, strlen(ES305_NS_DEFAULT_ON));
}
} else {
ALOGV(" setting ns to %s", ES305_NS_OFF);
write(eS305_ctrl.fd[ES305_CTRL_TX_NS_LEVEL], ES305_NS_OFF, strlen(ES305_NS_OFF));
}
return 0;
}
int Adnc_SetVoiceProcessingInt_l(bool vp_on)
{
if (eS305_ctrl.fd[ES305_CTRL_VOICE_PROCESSING] < 0) {
ALOGV(" opening eS305 path for VP");
eS305_ctrl.fd[ES305_CTRL_VOICE_PROCESSING] = open(ES305_VOICE_PROCESSING_PATH, O_RDWR);
if (eS305_ctrl.fd[ES305_CTRL_VOICE_PROCESSING] < 0) {
ALOGE(" cannot open eS305 path for VP: %s", strerror(errno));
return -ENODEV;
}
}
if (vp_on) {
write(eS305_ctrl.fd[ES305_CTRL_VOICE_PROCESSING], ES305_ON, strlen(ES305_ON));
} else {
write(eS305_ctrl.fd[ES305_CTRL_VOICE_PROCESSING], ES305_OFF, strlen(ES305_OFF));
}
return 0;
}
/*
* Put the eS305 to sleep
* Post condition when no error: eS305_ctrl.current_preset == ES305_PRESET_OFF
*/
int Adnc_SleepInt_l()
{
if (eS305_ctrl.current_preset == ES305_PRESET_OFF) {
return 0;
}
ALOGV(" Adnc_SleepInt()_l setting VP off + sleep 1");
Adnc_SetVoiceProcessingInt_l(false /*vp_on*/);
ALOGV(" Adnc_SetSleepInt_l");
if (eS305_ctrl.fd[ES305_CTRL_SLEEP] < 0) {
ALOGV(" opening eS305 path for sleep");
eS305_ctrl.fd[ES305_CTRL_SLEEP] = open(ES305_SLEEP_PATH, O_RDWR);
if (eS305_ctrl.fd[ES305_CTRL_SLEEP] < 0) {
ALOGE(" cannot open eS305 path for sleep: %s", strerror(errno));
return -ENODEV;
}
}
write(eS305_ctrl.fd[ES305_CTRL_SLEEP], ES305_ON, strlen(ES305_ON));
eS305_ctrl.current_preset = ES305_PRESET_OFF;
return 0;
}
/*
* Apply the eS305_ctrl.requested_preset preset after turning VP on
* Post condition when no error: eS305_ctrl.current_preset == eS305_ctrl.requested_preset
*/
int Adnc_ApplyPresetInt_l()
{
ALOGV("Adnc_ApplyPresetInt() current_preset=%d, requested_preset=%d",
eS305_ctrl.current_preset, eS305_ctrl.requested_preset);
if (eS305_ctrl.requested_preset == eS305_ctrl.current_preset) {
ALOGV(" nothing to do, preset %d is current", eS305_ctrl.requested_preset);
return 0;
}
// preset off implies going to sleep
if (eS305_ctrl.requested_preset == ES305_PRESET_OFF) {
return Adnc_SleepInt_l();
}
// voice processing must be on before setting the preset
if ((eS305_ctrl.current_preset == ES305_PRESET_OFF)
|| (eS305_ctrl.current_preset == ES305_PRESET_INIT)) {
const int status = Adnc_SetVoiceProcessingInt_l(true /*vp_on*/);
if (status != 0) {
return status;
}
}
if (eS305_ctrl.fd[ES305_CTRL_PRESET] < 0) {
ALOGV(" opening eS305 path for PRESET");
eS305_ctrl.fd[ES305_CTRL_PRESET] = open(ES305_PRESET_PATH, O_RDWR);
}
if (eS305_ctrl.fd[ES305_CTRL_PRESET] < 0) {
ALOGE(" Cannot open eS305 path for PRESET: %s", strerror(errno));
return -ENODEV;
}
char str[8];
sprintf(str, "%d", eS305_ctrl.requested_preset);
write(eS305_ctrl.fd[ES305_CTRL_PRESET], str, strlen(str));
eS305_ctrl.current_preset = eS305_ctrl.requested_preset;
return 0;
}
/*
* Apply the settings of given the session context
*/
int Adnc_ApplySettingsFromSessionContextInt_l(adnc_pfx_session_t * session)
{
ALOGV("Adnc_ApplySettingsFromSessionContextInt_l cre=%2x ac=%2x handle=%d",
session->createdMsk, session->activeMsk, session->ioHandle);
int status = 0;
if (session->ioHandle != eS305_ctrl.ioHandle) {
return status;
}
// NS: special case of noise suppression, always reset according to effect state
// as default desirable value might differ from the preset
const bool ns_on = ((session->activeMsk & (1 << PFX_ID_NS)) != 0);
status = Adnc_SetNoiseSuppressionInt_l(ns_on /*ns_on*/);
// AEC
if ((session->createdMsk & (1 << PFX_ID_AEC)) /* the effect has been created */
&& (session->activeMsk & (1 << PFX_ID_AEC))) /* the effect is active */
{
Adnc_SetEchoCancellationInt_l(true /*aec_on*/);
}
// AGC
if ((session->createdMsk & (1 << PFX_ID_AGC)) /* the effect has been created */
&& (session->activeMsk & (1 << PFX_ID_AGC))) /* the effect is active */
{
Adnc_SetAutomaticGainControlInt_l(true /*agc_on*/);
}
return status;
}
/*
* Return a value between 0 and ADNC_PFX_NUM_SESSION-1 if a session context has the given handle,
* -1 if the handle isn't in handled by one of the sessions.
* Must be called with a lock on sAdncBundleLock
*/
int Adnc_SessionNumberForHandle_l(audio_io_handle_t handle)
{
for (int i = 0 ; i < ADNC_PFX_NUM_SESSION ; i++) {
if (sAdncSessions[i].ioHandle == handle) {
return i;
}
}
return -1;
}
/*
* Apply the settings of the session matching the given IO handle.
* Must be called with a lock on sAdncBundleLock
*/
int Adnc_ApplySettingsForHandleInt_l(audio_io_handle_t handle)
{
ALOGV(" Adnc_ApplySettingsForHandleInt_l(handle=%d)", handle);
// indicates whether this effect bundle currently has a session context for this IO handle
bool hasSession = false;
int status = 0;
int i;
if (sAdncBundleInitStatus != 0) {
// This assumes that the default config of the eS305 after setting a preset
// is the correct configuration.
ALOGV(" no effect settings to apply for IO handle %d, no effect bundle", handle);
return status;
}
const int sessionId = Adnc_SessionNumberForHandle_l(handle);
if (sessionId >= 0) {
ALOGV(" applying settings from session num %d", sessionId);
status = Adnc_ApplySettingsFromSessionContextInt_l( &sAdncSessions[sessionId] );
}
else {
ALOGV(" no session found for handle %d", handle);
}
return status;
}
/*
* Reevaluate the usage of the eS305 based on the given IO handle.
* Must be called with a lock on sAdncBundleLock
*/
int Adnc_ReevaluateUsageInt_l(audio_io_handle_t handle)
{
ALOGV(" Adnc_ReevaluateUsageInt_l(handle=%d) current_preset=%d requested_preset=%d",
handle, eS305_ctrl.current_preset, eS305_ctrl.requested_preset);
int status = 0;
if ((eS305_ctrl.requested_preset == ES305_PRESET_OFF) || (handle == ES305_IO_HANDLE_NONE)) {
status = Adnc_SleepInt_l();
} else {
const int sessionId = Adnc_SessionNumberForHandle_l(handle);
if (sessionId >= 0) {
// recording active, use the preset only if there is an effect,
// reset preset to off otherwise
if (sAdncSessions[sessionId].activeMsk != 0) {
status = Adnc_ApplyPresetInt_l();
if (status == 0) {
//apply the settings of the session associated with the handle (if any)
status = Adnc_ApplySettingsForHandleInt_l(handle);
}
} else {
status = Adnc_SleepInt_l();
}
}
}
return status;
}
//-------------------------------------------------------
// eS305 public control interface from HAL
//-------------------------------------------------------
int eS305_UsePreset(int preset)
{
ALOGV("eS305_UsePreset(%d) current=%d handle=%d",
preset, eS305_ctrl.current_preset, eS305_ctrl.ioHandle);
int status = 0;
pthread_mutex_lock(&sAdncBundleLock);
//if (preset != -1) { AdncBundle_logv_dumpSessions(); }
// allow preset transition from any preset to any other during recording,
// except from one ASRA preset to another
if (eS305_ctrl.ioHandle != ES305_IO_HANDLE_NONE) {
switch(eS305_ctrl.current_preset) {
case ES305_PRESET_ASRA_HANDHELD:
case ES305_PRESET_ASRA_DESKTOP:
case ES305_PRESET_ASRA_HEADSET:
switch(preset) {
case ES305_PRESET_ASRA_HANDHELD:
case ES305_PRESET_ASRA_DESKTOP:
case ES305_PRESET_ASRA_HEADSET:
ALOGV(" not switching from ASRA preset %d to %d during voice recognition",
eS305_ctrl.current_preset, preset);
status = -EINVAL;
goto exit;
default:
// transitioning from ASRA to non-ASRA: valid
break;
}
break;
default:
// transitioning from non-ASRA: valid
break;
}
}
eS305_ctrl.requested_preset = preset;
status = AdncBundle_Init_l();
if (status != 0) {
ALOGE(" error applying preset, bundle failed to initialize");
goto exit;
}
status = Adnc_ReevaluateUsageInt_l(eS305_ctrl.ioHandle);
exit:
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
int eS305_SetActiveIoHandle(audio_io_handle_t handle)
{
ALOGV("eS305_SetActiveIoHandle(%d)", handle);
pthread_mutex_lock(&sAdncBundleLock);
int status = AdncBundle_Init_l();
if (status != 0) {
ALOGE(" error setting active handle, bundle failed to initialize");
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
status = Adnc_ReevaluateUsageInt_l(handle);
if (status == 0) {
eS305_ctrl.ioHandle = handle;
} else {
ALOGE(" failed to update for new handle %d (current preset = %d)",
handle, eS305_ctrl.current_preset);
}
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
int eS305_AddEffect(effect_descriptor_t * descr, audio_io_handle_t handle)
{
ALOGV("eS305_AddEffect(handle=%d)", handle);
pthread_mutex_lock(&sAdncBundleLock);
int status = AdncBundle_Init_l();
if (status != 0) {
ALOGE(" error setting adding effect, bundle failed to initialize");
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
if (descr == NULL){
ALOGV(" eS305_AddEffect() ERROR effect descriptor is NULL");
pthread_mutex_unlock(&sAdncBundleLock);
return -EINVAL;
}
uint32_t procId = Adnc_UuidToProcId(&descr->type);
adnc_pfx_session_t * session = AdncBundle_GetSession_l(
procId, ES305_SESSION_ID_NONE, handle/*ioId*/);
if (session != NULL) {
// mark the effect as active
session->activeMsk |= (1 << procId);
// update settings if necessary
Adnc_ReevaluateUsageInt_l(session->ioHandle);
}
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
int eS305_RemoveEffect(effect_descriptor_t * descr, audio_io_handle_t handle)
{
ALOGV("eS305_RemoveEffect()");
pthread_mutex_lock(&sAdncBundleLock);
int status = AdncBundle_Init_l();
if (status != 0) {
ALOGE(" error setting removing effect, bundle failed to initialize");
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
if (descr == NULL){
ALOGV(" eS305_AddEffect() ERROR effect descriptor is NULL");
pthread_mutex_unlock(&sAdncBundleLock);
return -EINVAL;
}
uint32_t procId = Adnc_UuidToProcId(&descr->type);
adnc_pfx_session_t * session = AdncBundle_GetSession_l(
procId, ES305_SESSION_ID_NONE, handle/*ioId*/);
if (session != NULL) {
// mark the effect as inactive
session->activeMsk &= ~(1 << procId);
// update settings if necessary
Adnc_ReevaluateUsageInt_l(session->ioHandle);
}
pthread_mutex_unlock(&sAdncBundleLock);
return status;
}
int eS305_Release() {
ALOGV("eS305_Release()");
pthread_mutex_lock(&sAdncBundleLock);
AdncBundle_Release_l();
pthread_mutex_unlock(&sAdncBundleLock);
return 0;
}
} // extern "C"