Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 8e103da1: Merge "Various fixes and improvements in audio effects implementation" into gingerbread

Browse Source 
Merge commit '8e103da1f1b0656e3427b34b75f02d7ddf6073d5' into gingerbread-plus-aosp

* commit '8e103da1f1b0656e3427b34b75f02d7ddf6073d5':
  Various fixes and improvements in audio effects implementation
This commit is contained in:
Eric Laurent
2010-06-25 12:38:31 -07:00
committed by Android Git Automerger
parent 2f8f81f5c2 8e103da1f1
commit cdf1357b6e
21 changed files with 909 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
include/media/AudioCommon.h
View File

@@ -1,80 +0,0 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef ANDROID_AUDIOCOMMON_H_
#define ANDROID_AUDIOCOMMON_H_
#if __cplusplus
extern "C" {
#endif
/////////////////////////////////////////////////
// Common definitions for PCM audio
/////////////////////////////////////////////////
// PCM Sample format
enum audio_format_e {
PCM_FORMAT_S15 = 1, // PCM signed 16 bits, must be 1 for backward compatibility
PCM_FORMAT_U8 = 2, // PCM unsigned 8 bits, must be 2 for backward compatibility
PCM_FORMAT_S7_24 // signed 7.24 fixed point representation
};
// Channel mask definitions
enum audio_channels_e {
CHANNEL_FRONT_LEFT = 0x4, // front left channel
CHANNEL_FRONT_RIGHT = 0x8, // front right channel
CHANNEL_FRONT_CENTER = 0x10, // front center channel
CHANNEL_LOW_FREQUENCY = 0x20, // low frequency channel
CHANNEL_BACK_LEFT = 0x40, // back left channel
CHANNEL_BACK_RIGHT = 0x80, // back right channel
CHANNEL_FRONT_LEFT_OF_CENTER = 0x100, // front left of center channel
CHANNEL_FRONT_RIGHT_OF_CENTER = 0x200, // front right of center channel
CHANNEL_BACK_CENTER = 0x400, // back center channel
CHANNEL_MONO = CHANNEL_FRONT_LEFT,
CHANNEL_STEREO = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT),
CHANNEL_QUAD = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT),
CHANNEL_SURROUND = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_FRONT_CENTER | CHANNEL_BACK_CENTER),
CHANNEL_5POINT1 = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_FRONT_CENTER | CHANNEL_LOW_FREQUENCY | CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT),
CHANNEL_7POINT1 = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_FRONT_CENTER | CHANNEL_LOW_FREQUENCY | CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT |
CHANNEL_FRONT_LEFT_OF_CENTER | CHANNEL_FRONT_RIGHT_OF_CENTER),
};
// Render device definitions
enum audio_device_e {
DEVICE_EARPIECE = 0x1, // earpiece
DEVICE_SPEAKER = 0x2, // speaker
DEVICE_WIRED_HEADSET = 0x4, // wired headset, with microphone
DEVICE_WIRED_HEADPHONE = 0x8, // wired headphone, without microphone
DEVICE_BLUETOOTH_SCO = 0x10, // generic bluetooth SCO
DEVICE_BLUETOOTH_SCO_HEADSET = 0x20, // bluetooth SCO headset
DEVICE_BLUETOOTH_SCO_CARKIT = 0x40, // bluetooth SCO car kit
DEVICE_BLUETOOTH_A2DP = 0x80, // generic bluetooth A2DP
DEVICE_BLUETOOTH_A2DP_HEADPHONES = 0x100, // bluetooth A2DP headphones
DEVICE_BLUETOOTH_A2DP_SPEAKER = 0x200, // bluetooth A2DP speakers
DEVICE_AUX_DIGITAL = 0x400 // digital output
};
#if __cplusplus
} // extern "C"
#endif
#endif /*ANDROID_AUDIOCOMMON_H_*/

20
include/media/AudioEffect.h
View File

@@ -93,14 +93,14 @@ public:
/* /*
* Returns the number of effects available. This method together * Returns the number of effects available. This method together
* with EffectQueryNext() is used to enumerate all effects: * with queryEffect() is used to enumerate all effects:
* The enumeration sequence is: * The enumeration sequence is:
* QueryNumberEffects(&num_effects); * queryNumberEffects(&num_effects);
* while (num_effects--) * for (i = 0; i < num_effects; i++)
* QueryNextEffect(); * queryEffect(i,...);
* *
* Parameters: * Parameters:
* pNumEffects: address where the number of effects should be returned. * numEffects: address where the number of effects should be returned.
* *
* Returned status (from utils/Errors.h) can be: * Returned status (from utils/Errors.h) can be:
* NO_ERROR successful operation. * NO_ERROR successful operation.
@@ -114,24 +114,24 @@ public:
static status_t queryNumberEffects(uint32_t *numEffects); static status_t queryNumberEffects(uint32_t *numEffects);
/* /*
* Returns number effect descriptor during effect * Returns an effect descriptor during effect
* enumeration. * enumeration.
* *
* Parameters: * Parameters:
* pDescriptor: address where the effect descriptor should be returned. * index: index of the queried effect.
* descriptor: address where the effect descriptor should be returned.
* *
* Returned status (from utils/Errors.h) can be: * Returned status (from utils/Errors.h) can be:
* NO_ERROR successful operation. * NO_ERROR successful operation.
* NAME_NOT_FOUND no more effect available
* PERMISSION_DENIED could not get AudioFlinger interface * PERMISSION_DENIED could not get AudioFlinger interface
* NO_INIT effect library failed to initialize * NO_INIT effect library failed to initialize
* BAD_VALUE invalid descriptor pointer * BAD_VALUE invalid descriptor pointer or index
* INVALID_OPERATION effect list has changed since last execution of queryNumberEffects() * INVALID_OPERATION effect list has changed since last execution of queryNumberEffects()
* *
* Returned value * Returned value
* *descriptor: updated with effect descriptor * *descriptor: updated with effect descriptor
*/ */
static status_t queryNextEffect(effect_descriptor_t *descriptor); static status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor);
/* /*

62
include/media/AudioSystem.h
View File

@@ -20,7 +20,6 @@
#include <utils/RefBase.h> #include <utils/RefBase.h>
#include <utils/threads.h> #include <utils/threads.h>
#include <media/IAudioFlinger.h> #include <media/IAudioFlinger.h>
#include <media/AudioCommon.h>
namespace android { namespace android {
@@ -51,8 +50,8 @@ public:
// Audio sub formats (see AudioSystem::audio_format). // Audio sub formats (see AudioSystem::audio_format).
enum pcm_sub_format { enum pcm_sub_format {
PCM_SUB_16_BIT = PCM_FORMAT_S15, // must be 1 for backward compatibility PCM_SUB_16_BIT = 0x1, // must be 1 for backward compatibility
PCM_SUB_8_BIT = PCM_FORMAT_U8, // must be 2 for backward compatibility PCM_SUB_8_BIT = 0x2, // must be 2 for backward compatibility
}; };
// MP3 sub format field definition : can use 11 LSBs in the same way as MP3 frame header to specify // MP3 sub format field definition : can use 11 LSBs in the same way as MP3 frame header to specify
@@ -104,21 +103,26 @@ public:
// Channel mask definitions must be kept in sync with JAVA values in /media/java/android/media/AudioFormat.java // Channel mask definitions must be kept in sync with JAVA values in /media/java/android/media/AudioFormat.java
enum audio_channels { enum audio_channels {
// output channels // output channels
CHANNEL_OUT_FRONT_LEFT = CHANNEL_FRONT_LEFT, CHANNEL_OUT_FRONT_LEFT = 0x4,
CHANNEL_OUT_FRONT_RIGHT = CHANNEL_FRONT_RIGHT, CHANNEL_OUT_FRONT_RIGHT = 0x8,
CHANNEL_OUT_FRONT_CENTER = CHANNEL_FRONT_CENTER, CHANNEL_OUT_FRONT_CENTER = 0x10,
CHANNEL_OUT_LOW_FREQUENCY = CHANNEL_LOW_FREQUENCY, CHANNEL_OUT_LOW_FREQUENCY = 0x20,
CHANNEL_OUT_BACK_LEFT = CHANNEL_BACK_LEFT, CHANNEL_OUT_BACK_LEFT = 0x40,
CHANNEL_OUT_BACK_RIGHT = CHANNEL_BACK_RIGHT, CHANNEL_OUT_BACK_RIGHT = 0x80,
CHANNEL_OUT_FRONT_LEFT_OF_CENTER = CHANNEL_FRONT_LEFT_OF_CENTER, CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x100,
CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = CHANNEL_FRONT_RIGHT_OF_CENTER, CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x200,
CHANNEL_OUT_BACK_CENTER = CHANNEL_BACK_CENTER, CHANNEL_OUT_BACK_CENTER = 0x400,
CHANNEL_OUT_MONO = CHANNEL_MONO, CHANNEL_OUT_MONO = CHANNEL_OUT_FRONT_LEFT,
CHANNEL_OUT_STEREO = CHANNEL_STEREO, CHANNEL_OUT_STEREO = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT),
CHANNEL_OUT_QUAD = CHANNEL_QUAD, CHANNEL_OUT_QUAD = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_SURROUND = CHANNEL_SURROUND, CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
CHANNEL_OUT_5POINT1 = CHANNEL_5POINT1, CHANNEL_OUT_SURROUND = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_7POINT1 = CHANNEL_7POINT1, CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_BACK_CENTER),
CHANNEL_OUT_5POINT1 = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
CHANNEL_OUT_7POINT1 = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT |
CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER),
CHANNEL_OUT_ALL = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | CHANNEL_OUT_ALL = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT | CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT |
CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER | CHANNEL_OUT_BACK_CENTER), CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER | CHANNEL_OUT_BACK_CENTER),
@@ -238,17 +242,17 @@ public:
enum audio_devices { enum audio_devices {
// output devices // output devices
DEVICE_OUT_EARPIECE = DEVICE_EARPIECE, DEVICE_OUT_EARPIECE = 0x1,
DEVICE_OUT_SPEAKER = DEVICE_SPEAKER, DEVICE_OUT_SPEAKER = 0x2,
DEVICE_OUT_WIRED_HEADSET = DEVICE_WIRED_HEADSET, DEVICE_OUT_WIRED_HEADSET = 0x4,
DEVICE_OUT_WIRED_HEADPHONE = DEVICE_WIRED_HEADPHONE, DEVICE_OUT_WIRED_HEADPHONE = 0x8,
DEVICE_OUT_BLUETOOTH_SCO = DEVICE_BLUETOOTH_SCO, DEVICE_OUT_BLUETOOTH_SCO = 0x10,
DEVICE_OUT_BLUETOOTH_SCO_HEADSET = DEVICE_BLUETOOTH_SCO_HEADSET, DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
DEVICE_OUT_BLUETOOTH_SCO_CARKIT = DEVICE_BLUETOOTH_SCO_CARKIT, DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
DEVICE_OUT_BLUETOOTH_A2DP = DEVICE_BLUETOOTH_A2DP, DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = DEVICE_BLUETOOTH_A2DP_HEADPHONES, DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = DEVICE_BLUETOOTH_A2DP_SPEAKER, DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
DEVICE_OUT_AUX_DIGITAL = DEVICE_AUX_DIGITAL, DEVICE_OUT_AUX_DIGITAL = 0x400,
DEVICE_OUT_DEFAULT = 0x8000, DEVICE_OUT_DEFAULT = 0x8000,
DEVICE_OUT_ALL = (DEVICE_OUT_EARPIECE | DEVICE_OUT_SPEAKER | DEVICE_OUT_WIRED_HEADSET | DEVICE_OUT_ALL = (DEVICE_OUT_EARPIECE | DEVICE_OUT_SPEAKER | DEVICE_OUT_WIRED_HEADSET |
DEVICE_OUT_WIRED_HEADPHONE | DEVICE_OUT_BLUETOOTH_SCO | DEVICE_OUT_BLUETOOTH_SCO_HEADSET | DEVICE_OUT_WIRED_HEADPHONE | DEVICE_OUT_BLUETOOTH_SCO | DEVICE_OUT_BLUETOOTH_SCO_HEADSET |

466
include/media/EffectApi.h
View File

@@ -20,7 +20,6 @@
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
#include <sys/types.h> #include <sys/types.h>
#include <media/AudioCommon.h>
#if __cplusplus #if __cplusplus
extern "C" { extern "C" {
@@ -65,10 +64,11 @@ typedef struct effect_interface_s **effect_interface_t;
//--- Effect descriptor structure effect_descriptor_t //--- Effect descriptor structure effect_descriptor_t
// //
// Unique effect ID (can be generated from the following site: http://www.itu.int/ITU-T/asn1/uuid.html) // Unique effect ID (can be generated from the following site:
// http://www.itu.int/ITU-T/asn1/uuid.html)
// This format is used for both "type" and "uuid" fields of the effect descriptor structure. // This format is used for both "type" and "uuid" fields of the effect descriptor structure.
// - When used for effect type and the engine is implementing and effect corresponding to a standard OpenSL ES // - When used for effect type and the engine is implementing and effect corresponding to a standard
// interface, this ID must be the one defined in OpenSLES_IID.h for that interface. // OpenSL ES interface, this ID must be the one defined in OpenSLES_IID.h for that interface.
// - When used as uuid, it should be a unique UUID for this particular implementation. // - When used as uuid, it should be a unique UUID for this particular implementation.
typedef struct effect_uuid_s { typedef struct effect_uuid_s {
uint32_t timeLow; uint32_t timeLow;
@@ -79,23 +79,32 @@ typedef struct effect_uuid_s {
} effect_uuid_t; } effect_uuid_t;
// NULL UUID definition (matches SL_IID_NULL_) // NULL UUID definition (matches SL_IID_NULL_)
#define EFFECT_UUID_INITIALIZER { 0xec7178ec, 0xe5e1, 0x4432, 0xa3f4, { 0x46, 0x57, 0xe6, 0x79, 0x52, 0x10 } } #define EFFECT_UUID_INITIALIZER { 0xec7178ec, 0xe5e1, 0x4432, 0xa3f4, \
{ 0x46, 0x57, 0xe6, 0x79, 0x52, 0x10 } }
static const effect_uuid_t EFFECT_UUID_NULL_ = EFFECT_UUID_INITIALIZER; static const effect_uuid_t EFFECT_UUID_NULL_ = EFFECT_UUID_INITIALIZER;
const effect_uuid_t * const EFFECT_UUID_NULL = &EFFECT_UUID_NULL_; const effect_uuid_t * const EFFECT_UUID_NULL = &EFFECT_UUID_NULL_;
const char * const EFFECT_UUID_NULL_STR = "ec7178ec-e5e1-4432-a3f4-4657e6795210"; const char * const EFFECT_UUID_NULL_STR = "ec7178ec-e5e1-4432-a3f4-4657e6795210";
// the effect descriptor contains necessary information to facilitate the enumeration of the effect // The effect descriptor contains necessary information to facilitate the enumeration of the effect
// engines present in a library. // engines present in a library.
typedef struct effect_descriptor_s { typedef struct effect_descriptor_s {
effect_uuid_t type; // UUID corresponding to the OpenSL ES interface implemented by this effect effect_uuid_t type; // UUID of to the OpenSL ES interface implemented by this effect
effect_uuid_t uuid; // UUID for this particular implementation effect_uuid_t uuid; // UUID for this particular implementation
uint16_t apiVersion; // Version of the effect API implemented: must match current EFFECT_API_VERSION uint16_t apiVersion; // Version of the effect API implemented: matches EFFECT_API_VERSION
uint32_t flags; // effect engine capabilities/requirements flags (see below) uint32_t flags; // effect engine capabilities/requirements flags (see below)
char name[EFFECT_STRING_LEN_MAX] ; // human readable effect name uint16_t cpuLoad; // CPU load indication (see below)
char implementor[EFFECT_STRING_LEN_MAX] ; // human readable effect implementor name uint16_t memoryUsage; // Data Memory usage (see below)
char name[EFFECT_STRING_LEN_MAX]; // human readable effect name
char implementor[EFFECT_STRING_LEN_MAX]; // human readable effect implementor name
} effect_descriptor_t; } effect_descriptor_t;
// definitions for flags field of effect descriptor. // CPU load and memory usage indication: each effect implementation must provide an indication of
// its CPU and memory usage for the audio effect framework to limit the number of effects
// instantiated at a given time on a given platform.
// The CPU load is expressed in 0.1 MIPS units as estimated on an ARM9E core (ARMv5TE) with 0 WS.
// The memory usage is expressed in KB and includes only dynamically allocated memory
// Definitions for flags field of effect descriptor.
// +---------------------------+-----------+----------------------------------- // +---------------------------+-----------+-----------------------------------
// | description | bits | values // | description | bits | values
// +---------------------------+-----------+----------------------------------- // +---------------------------+-----------+-----------------------------------
@@ -117,7 +126,7 @@ typedef struct effect_descriptor_s {
// | | | 2 requires volume indication // | | | 2 requires volume indication
// | | | 3 reserved // | | | 3 reserved
// +---------------------------+-----------+----------------------------------- // +---------------------------+-----------+-----------------------------------
// | Device management | 7..8 | 0 none // | Device indication | 7..8 | 0 none
// | | | 1 requires device updates // | | | 1 requires device updates
// | | | 2..3 reserved // | | | 2..3 reserved
// +---------------------------+-----------+----------------------------------- // +---------------------------+-----------+-----------------------------------
@@ -125,7 +134,8 @@ typedef struct effect_descriptor_s {
// | | | command must specify a buffer descriptor // | | | command must specify a buffer descriptor
// | | | 1 provider: process() function uses the // | | | 1 provider: process() function uses the
// | | | bufferProvider indicated by the // | | | bufferProvider indicated by the
// | | | EFFECT_CMD_CONFIGURE command to request input buffers. // | | | EFFECT_CMD_CONFIGURE command to request input.
// | | | buffers.
// | | | 2 both: both input modes are supported // | | | 2 both: both input modes are supported
// | | | 3 reserved // | | | 3 reserved
// +---------------------------+-----------+----------------------------------- // +---------------------------+-----------+-----------------------------------
@@ -133,18 +143,34 @@ typedef struct effect_descriptor_s {
// | | | command must specify a buffer descriptor // | | | command must specify a buffer descriptor
// | | | 1 provider: process() function uses the // | | | 1 provider: process() function uses the
// | | | bufferProvider indicated by the // | | | bufferProvider indicated by the
// | | | EFFECT_CMD_CONFIGURE command to request output buffers. // | | | EFFECT_CMD_CONFIGURE command to request output
// | | | buffers.
// | | | 2 both: both output modes are supported // | | | 2 both: both output modes are supported
// | | | 3 reserved // | | | 3 reserved
// +---------------------------+-----------+----------------------------------- // +---------------------------+-----------+-----------------------------------
// | Hardware acceleration | 13..15 | 0 No hardware acceleration
// | | | 1 non tunneled hw acceleration: the process() function
// | | | reads the samples, send them to HW accelerated
// | | | effect processor, reads back the processed samples
// | | | and returns them to the output buffer.
// | | | 2 tunneled hw acceleration: the process() function is
// | | | transparent. The effect interface is only used to
// | | | control the effect engine. This mode is relevant for
// | | | global effects actually applied by the audio
// | | | hardware on the output stream.
// +---------------------------+-----------+-----------------------------------
// | Audio Mode indication | 16..17 | 0 none
// | | | 1 requires audio mode updates
// | | | 2..3 reserved
// +---------------------------+-----------+-----------------------------------
// insert mode // Insert mode
#define EFFECT_FLAG_TYPE_MASK 0x00000003 #define EFFECT_FLAG_TYPE_MASK 0x00000003
#define EFFECT_FLAG_TYPE_INSERT 0x00000000 #define EFFECT_FLAG_TYPE_INSERT 0x00000000
#define EFFECT_FLAG_TYPE_AUXILIARY 0x00000001 #define EFFECT_FLAG_TYPE_AUXILIARY 0x00000001
#define EFFECT_FLAG_TYPE_REPLACE 0x00000002 #define EFFECT_FLAG_TYPE_REPLACE 0x00000002
// insert preference // Insert preference
#define EFFECT_FLAG_INSERT_MASK 0x0000001C #define EFFECT_FLAG_INSERT_MASK 0x0000001C
#define EFFECT_FLAG_INSERT_ANY 0x00000000 #define EFFECT_FLAG_INSERT_ANY 0x00000000
#define EFFECT_FLAG_INSERT_FIRST 0x00000004 #define EFFECT_FLAG_INSERT_FIRST 0x00000004
@@ -152,30 +178,40 @@ typedef struct effect_descriptor_s {
#define EFFECT_FLAG_INSERT_EXCLUSIVE 0x0000000C #define EFFECT_FLAG_INSERT_EXCLUSIVE 0x0000000C
// volume control // Volume control
#define EFFECT_FLAG_VOLUME_MASK 0x00000060 #define EFFECT_FLAG_VOLUME_MASK 0x00000060
#define EFFECT_FLAG_VOLUME_CTRL 0x00000020 #define EFFECT_FLAG_VOLUME_CTRL 0x00000020
#define EFFECT_FLAG_VOLUME_IND 0x00000040 #define EFFECT_FLAG_VOLUME_IND 0x00000040
#define EFFECT_FLAG_VOLUME_NONE 0x00000000 #define EFFECT_FLAG_VOLUME_NONE 0x00000000
// device control // Device indication
#define EFFECT_FLAG_DEVICE_MASK 0x00000180 #define EFFECT_FLAG_DEVICE_MASK 0x00000180
#define EFFECT_FLAG_DEVICE_IND 0x00000080 #define EFFECT_FLAG_DEVICE_IND 0x00000080
#define EFFECT_FLAG_DEVICE_NONE 0x00000000 #define EFFECT_FLAG_DEVICE_NONE 0x00000000
// sample input modes // Sample input modes
#define EFFECT_FLAG_INPUT_MASK 0x00000600 #define EFFECT_FLAG_INPUT_MASK 0x00000600
#define EFFECT_FLAG_INPUT_DIRECT 0x00000000 #define EFFECT_FLAG_INPUT_DIRECT 0x00000000
#define EFFECT_FLAG_INPUT_PROVIDER 0x00000200 #define EFFECT_FLAG_INPUT_PROVIDER 0x00000200
#define EFFECT_FLAG_INPUT_BOTH 0x00000400 #define EFFECT_FLAG_INPUT_BOTH 0x00000400
// sample output modes // Sample output modes
#define EFFECT_FLAG_OUTPUT_MASK 0x00001800 #define EFFECT_FLAG_OUTPUT_MASK 0x00001800
#define EFFECT_FLAG_OUTPUT_DIRECT 0x00000000 #define EFFECT_FLAG_OUTPUT_DIRECT 0x00000000
#define EFFECT_FLAG_OUTPUT_PROVIDER 0x00000800 #define EFFECT_FLAG_OUTPUT_PROVIDER 0x00000800
#define EFFECT_FLAG_OUTPUT_BOTH 0x00001000 #define EFFECT_FLAG_OUTPUT_BOTH 0x00001000
// forward definition of type audio_buffer_t // Hardware acceleration mode
#define EFFECT_FLAG_HW_ACC_MASK 0x00006000
#define EFFECT_FLAG_HW_ACC_SIMPLE 0x00002000
#define EFFECT_FLAG_HW_ACC_TUNNEL 0x00004000
// Audio mode indication
#define EFFECT_FLAG_AUDIO_MODE_MASK 0x00018000
#define EFFECT_FLAG_AUDIO_MODE_IND 0x00008000
#define EFFECT_FLAG_AUDIO_MODE_NONE 0x00000000
// Forward definition of type audio_buffer_t
typedef struct audio_buffer_s audio_buffer_t; typedef struct audio_buffer_s audio_buffer_t;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -206,7 +242,9 @@ typedef struct audio_buffer_s audio_buffer_t;
// -EINVAL invalid interface handle or // -EINVAL invalid interface handle or
// invalid input/output buffer description // invalid input/output buffer description
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
typedef int32_t (*effect_process_t)(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer); typedef int32_t (*effect_process_t)(effect_interface_t self,
audio_buffer_t *inBuffer,
audio_buffer_t *outBuffer);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
@@ -238,7 +276,12 @@ typedef int32_t (*effect_process_t)(effect_interface_t self, audio_buffer_t *inB
// *pReplyData updated with command response // *pReplyData updated with command response
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
typedef int32_t (*effect_command_t)(effect_interface_t self, int32_t cmdCode, int32_t cmdSize, void *pCmdData, int32_t *replySize, void *pReplyData); typedef int32_t (*effect_command_t)(effect_interface_t self,
int32_t cmdCode,
int32_t cmdSize,
void *pCmdData,
int32_t *replySize,
void *pReplyData);
// Effect control interface definition // Effect control interface definition
@@ -248,75 +291,9 @@ struct effect_interface_s {
}; };
//--- Standardized command codes for command function //
// +--------------------------------+-------------------------------+-------------------------------+-------------------------- //--- Standardized command codes for command() function
// | description | command code | command format | reply format //
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Initialize effect engine: | EFFECT_CMD_INIT | size: 0 | size: sizeof(int)
// | All configurations return to | | data: N/A | data: status
// | default | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Apply new audio parameters | EFFECT_CMD_CONFIGURE | size: sizeof(effect_config_t) | size: sizeof(int)
// | configurations for input and | | data: effect_config_t | data: status
// | output buffers | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Reset effect engine: keep | EFFECT_CMD_RESET | size: 0 | size: 0
// | configuration but reset state | | data: N/A | data: N/A
// | and buffer content. | | |
// | Called by the framework before | | |
// | enabling the effect | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Enable the process | EFFECT_CMD_ENABLE | size: 0 | size: sizeof(int)
// | Called by the framework before | | data: N/A | data: status
// | the first call to process() | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Disable the process | EFFECT_CMD_DISABLE | size: 0 | size: sizeof(int)
// | Called by the framework after | | data: N/A | data: status
// | the last call to process() | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Set a parameter and apply it | EFFECT_CMD_SET_PARAM | size: sizeof(effect_param_t) | size: sizeof(int)
// | immediately | | + size of param + value | data: status
// | | | data: effect_param_t |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Set a parameter but apply it | EFFECT_CMD_SET_PARAM_DEFERRED | size: sizeof(effect_param_t) | size: 0
// | only when receiving command | | + size of param + value | data: N/A
// | EFFECT_CMD_SET_PARAM_COMMIT | | data: effect_param_t |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Apply all previously received | EFFECT_CMD_SET_PARAM_COMMIT | size: 0 | size: sizeof(int)
// | EFFECT_CMD_SET_PARAM_DEFERRED | | data: N/A | data: status
// | commands | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Get a parameter value | EFFECT_CMD_GET_PARAM | size: sizeof(effect_param_t) | size: sizeof(effect_param_t)
// | | | + size of param | + size of param + value
// | | | data: effect_param_t | data: effect_param_t
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Set the rendering device the | EFFECT_CMD_SET_DEVICE | size: sizeof(uint32_t) | size: 0
// | audio output path is connected | | data: audio_device_e | data: N/A
// | to. See audio_device_e in | | |
// | AudioCommon.h for device values| | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | Set and get volume. Used by | EFFECT_CMD_SET_VOLUME | size: n * sizeof(uint32_t) | size: n * sizeof(uint32_t)
// | audio framework to delegate | | data: volume for each channel | data: volume for each channel
// | volume control to effect engine| | defined in effect_config_t in | defined in effect_config_t in
// | If volume control flag is set | | 8.24 fixed point format | 8.24 fixed point format
// | in the effect descriptor, the | | | It is legal to receive a null
// | effect engine must return the | | | pointer as pReplyData in which
// | volume that should be applied | | | case the effect framework has
// | before the effect is processed | | | delegated volume control to
// | The overall volume (the volume | | | another effect.
// | actually applied by the effect | | |
// | multiplied by the returned | | |
// | value) should match the | | |
// | requested value | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
// | All proprietary effect commands| EFFECT_CMD_FIRST_PROPRIETARY | |
// | must use command codes above | | |
// | this value. The size and format| | |
// | of command and response fields | | |
// | is free in this case. | | |
// +--------------------------------+-------------------------------+-------------------------------+--------------------------
enum effect_command_e { enum effect_command_e {
EFFECT_CMD_INIT, // initialize effect engine EFFECT_CMD_INIT, // initialize effect engine
EFFECT_CMD_CONFIGURE, // configure effect engine (see effect_config_t) EFFECT_CMD_CONFIGURE, // configure effect engine (see effect_config_t)
@@ -327,18 +304,202 @@ enum effect_command_e {
EFFECT_CMD_SET_PARAM_DEFERRED, // set parameter deferred EFFECT_CMD_SET_PARAM_DEFERRED, // set parameter deferred
EFFECT_CMD_SET_PARAM_COMMIT, // commit previous set parameter deferred EFFECT_CMD_SET_PARAM_COMMIT, // commit previous set parameter deferred
EFFECT_CMD_GET_PARAM, // get parameter EFFECT_CMD_GET_PARAM, // get parameter
EFFECT_CMD_SET_DEVICE, // set audio device (see audio_device_e in AudioCommon.h) EFFECT_CMD_SET_DEVICE, // set audio device (see audio_device_e)
EFFECT_CMD_SET_VOLUME, // set volume EFFECT_CMD_SET_VOLUME, // set volume
EFFECT_CMD_SET_AUDIO_MODE, // set the audio mode (normal, ring, ...)
EFFECT_CMD_FIRST_PROPRIETARY = 0x10000 // first proprietary command code EFFECT_CMD_FIRST_PROPRIETARY = 0x10000 // first proprietary command code
}; };
// Audio buffer descriptor used by process(), bufferProvider() functions and buffer_config_t structure //==================================================================================================
// Multi-channel audio is always interleaved. The channel order is from LSB to MSB with regard to the // command: EFFECT_CMD_INIT
// channel mask definition in audio_channels_e (AudioCommon.h) e.g : //--------------------------------------------------------------------------------------------------
// description:
// Initialize effect engine: All configurations return to default
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_CONFIGURE
//--------------------------------------------------------------------------------------------------
// description:
// Apply new audio parameters configurations for input and output buffers
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_config_t)
// data: effect_config_t
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_RESET
//--------------------------------------------------------------------------------------------------
// description:
// Reset the effect engine. Keep configuration but resets state and buffer content
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_ENABLE
//--------------------------------------------------------------------------------------------------
// description:
// Enable the process. Called by the framework before the first call to process()
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_DISABLE
//--------------------------------------------------------------------------------------------------
// description:
// Disable the process. Called by the framework after the last call to process()
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_PARAM
//--------------------------------------------------------------------------------------------------
// description:
// Set a parameter and apply it immediately
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_param_t) + size of param and value
// data: effect_param_t + param + value. See effect_param_t definition below for value offset
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_SET_PARAM_DEFERRED
//--------------------------------------------------------------------------------------------------
// description:
// Set a parameter but apply it only when receiving EFFECT_CMD_SET_PARAM_COMMIT command
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_param_t) + size of param and value
// data: effect_param_t + param + value. See effect_param_t definition below for value offset
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_SET_PARAM_COMMIT
//--------------------------------------------------------------------------------------------------
// description:
// Apply all previously received EFFECT_CMD_SET_PARAM_DEFERRED commands
//--------------------------------------------------------------------------------------------------
// command format:
// size: 0
// data: N/A
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(int)
// data: status
//==================================================================================================
// command: EFFECT_CMD_GET_PARAM
//--------------------------------------------------------------------------------------------------
// description:
// Get a parameter value
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(effect_param_t) + size of param
// data: effect_param_t + param
//--------------------------------------------------------------------------------------------------
// reply format:
// size: sizeof(effect_param_t) + size of param and value
// data: effect_param_t + param + value. See effect_param_t definition below for value offset
//==================================================================================================
// command: EFFECT_CMD_SET_DEVICE
//--------------------------------------------------------------------------------------------------
// description:
// Set the rendering device the audio output path is connected to. See audio_device_e for device
// values.
// The effect implementation must set EFFECT_FLAG_DEVICE_IND flag in its descriptor to receive this
// command when the device changes
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: audio_device_e
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_SET_VOLUME
//--------------------------------------------------------------------------------------------------
// description:
// Set and get volume. Used by audio framework to delegate volume control to effect engine.
// The effect implementation must set EFFECT_FLAG_VOLUME_IND and/or EFFECT_FLAG_VOLUME_CTRL flag in
// its descriptor to receive this command before every call to process() function
// If EFFECT_FLAG_VOLUME_CTRL flag is set in the effect descriptor, the effect engine must return
// the volume that should be applied before the effect is processed. The overall volume (the volume
// actually applied by the effect engine multiplied by the returned value) should match the value
// indicated in the command.
//--------------------------------------------------------------------------------------------------
// command format:
// size: n * sizeof(uint32_t)
// data: volume for each channel defined in effect_config_t for output buffer expressed in
// 8.24 fixed point format
//--------------------------------------------------------------------------------------------------
// reply format:
// size: n * sizeof(uint32_t) / 0
// data: - if EFFECT_FLAG_VOLUME_CTRL is set in effect descriptor:
// volume for each channel defined in effect_config_t for output buffer expressed in
// 8.24 fixed point format
// - if EFFECT_FLAG_VOLUME_CTRL is not set in effect descriptor:
// N/A
// It is legal to receive a null pointer as pReplyData in which case the effect framework has
// delegated volume control to another effect
//==================================================================================================
// command: EFFECT_CMD_SET_AUDIO_MODE
//--------------------------------------------------------------------------------------------------
// description:
// Set the audio mode. The effect implementation must set EFFECT_FLAG_AUDIO_MODE_IND flag in its
// descriptor to receive this command when the audio mode changes.
//--------------------------------------------------------------------------------------------------
// command format:
// size: sizeof(uint32_t)
// data: audio_mode_e
//--------------------------------------------------------------------------------------------------
// reply format:
// size: 0
// data: N/A
//==================================================================================================
// command: EFFECT_CMD_FIRST_PROPRIETARY
//--------------------------------------------------------------------------------------------------
// description:
// All proprietary effect commands must use command codes above this value. The size and format of
// command and response fields is free in this case
//==================================================================================================
// Audio buffer descriptor used by process(), bufferProvider() functions and buffer_config_t
// structure. Multi-channel audio is always interleaved. The channel order is from LSB to MSB with
// regard to the channel mask definition in audio_channels_e e.g :
// Stereo: left, right // Stereo: left, right
// 5 point 1: front left, front right, front center, low frequency, back left, back right // 5 point 1: front left, front right, front center, low frequency, back left, back right
// The buffer size is expressed in frame count, a frame being composed of samples for all // The buffer size is expressed in frame count, a frame being composed of samples for all
// channels at a given time // channels at a given time. Frame size for unspecified format (AUDIO_FORMAT_OTHER) is 8 bit by
// definition
struct audio_buffer_s { struct audio_buffer_s {
size_t frameCount; // number of frames in buffer size_t frameCount; // number of frames in buffer
union { union {
@@ -349,7 +510,7 @@ struct audio_buffer_s {
}; };
}; };
// the buffer_provider_s structure contains functions that can be used // The buffer_provider_s structure contains functions that can be used
// by the effect engine process() function to query and release input // by the effect engine process() function to query and release input
// or output audio buffer. // or output audio buffer.
// The getBuffer() function is called to retrieve a buffer where data // The getBuffer() function is called to retrieve a buffer where data
@@ -369,6 +530,7 @@ typedef struct buffer_provider_s {
void *cookie; // for use by client of buffer provider functions void *cookie; // for use by client of buffer provider functions
} buffer_provider_t; } buffer_provider_t;
// The buffer_config_s structure specifies the input or output audio format // The buffer_config_s structure specifies the input or output audio format
// to be used by the effect engine. It is part of the effect_config_t // to be used by the effect engine. It is part of the effect_config_t
// structure that defines both input and output buffer configurations and is // structure that defines both input and output buffer configurations and is
@@ -376,14 +538,69 @@ typedef struct buffer_provider_s {
typedef struct buffer_config_s { typedef struct buffer_config_s {
audio_buffer_t buffer; // buffer for use by process() function if not passed explicitly audio_buffer_t buffer; // buffer for use by process() function if not passed explicitly
uint32_t samplingRate; // sampling rate uint32_t samplingRate; // sampling rate
uint32_t channels; // channel mask (see audio_channels_e in AudioCommon.h) uint32_t channels; // channel mask (see audio_channels_e)
buffer_provider_t bufferProvider; // buffer provider buffer_provider_t bufferProvider; // buffer provider
uint8_t format; // PCM format (see audio_format_e in AudioCommon.h) uint8_t format; // Audio format (see audio_format_e)
uint8_t accessMode; // read/write or accumulate in buffer (effect_buffer_access_e) uint8_t accessMode; // read/write or accumulate in buffer (effect_buffer_access_e)
uint16_t mask; // indicates which of the above fields is valid uint16_t mask; // indicates which of the above fields is valid
} buffer_config_t; } buffer_config_t;
// values for "accessMode" field of buffer_config_t: // Sample format
enum audio_format_e {
SAMPLE_FORMAT_PCM_S15, // PCM signed 16 bits
SAMPLE_FORMAT_PCM_U8, // PCM unsigned 8 bits
SAMPLE_FORMAT_PCM_S7_24, // PCM signed 7.24 fixed point representation
SAMPLE_FORMAT_OTHER // other format (e.g. compressed)
};
// Channel mask
enum audio_channels_e {
CHANNEL_FRONT_LEFT = 0x1, // front left channel
CHANNEL_FRONT_RIGHT = 0x2, // front right channel
CHANNEL_FRONT_CENTER = 0x4, // front center channel
CHANNEL_LOW_FREQUENCY = 0x8, // low frequency channel
CHANNEL_BACK_LEFT = 0x10, // back left channel
CHANNEL_BACK_RIGHT = 0x20, // back right channel
CHANNEL_FRONT_LEFT_OF_CENTER = 0x40, // front left of center channel
CHANNEL_FRONT_RIGHT_OF_CENTER = 0x80, // front right of center channel
CHANNEL_BACK_CENTER = 0x100, // back center channel
CHANNEL_MONO = CHANNEL_FRONT_LEFT,
CHANNEL_STEREO = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT),
CHANNEL_QUAD = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT),
CHANNEL_SURROUND = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_FRONT_CENTER | CHANNEL_BACK_CENTER),
CHANNEL_5POINT1 = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_FRONT_CENTER | CHANNEL_LOW_FREQUENCY | CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT),
CHANNEL_7POINT1 = (CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT |
CHANNEL_FRONT_CENTER | CHANNEL_LOW_FREQUENCY | CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT |
CHANNEL_FRONT_LEFT_OF_CENTER | CHANNEL_FRONT_RIGHT_OF_CENTER),
};
// Render device
enum audio_device_e {
DEVICE_EARPIECE = 0x1, // earpiece
DEVICE_SPEAKER = 0x2, // speaker
DEVICE_WIRED_HEADSET = 0x4, // wired headset, with microphone
DEVICE_WIRED_HEADPHONE = 0x8, // wired headphone, without microphone
DEVICE_BLUETOOTH_SCO = 0x10, // generic bluetooth SCO
DEVICE_BLUETOOTH_SCO_HEADSET = 0x20, // bluetooth SCO headset
DEVICE_BLUETOOTH_SCO_CARKIT = 0x40, // bluetooth SCO car kit
DEVICE_BLUETOOTH_A2DP = 0x80, // generic bluetooth A2DP
DEVICE_BLUETOOTH_A2DP_HEADPHONES = 0x100, // bluetooth A2DP headphones
DEVICE_BLUETOOTH_A2DP_SPEAKER = 0x200, // bluetooth A2DP speakers
DEVICE_AUX_DIGITAL = 0x400, // digital output
DEVICE_EXTERNAL_SPEAKER = 0x800 // external speaker (stereo and High quality)
};
// Audio mode
enum audio_mode_e {
AUDIO_MODE_NORMAL, // phone idle
AUDIO_MODE_RINGTONE, // phone ringing
AUDIO_MODE_IN_CALL // phone call connected
};
// Values for "accessMode" field of buffer_config_t:
// overwrite, read only, accumulate (read/modify/write) // overwrite, read only, accumulate (read/modify/write)
enum effect_buffer_access_e { enum effect_buffer_access_e {
EFFECT_BUFFER_ACCESS_WRITE, EFFECT_BUFFER_ACCESS_WRITE,
@@ -392,7 +609,7 @@ enum effect_buffer_access_e {
}; };
// values for bit field "mask" in buffer_config_t. If a bit is set, the corresponding field // Values for bit field "mask" in buffer_config_t. If a bit is set, the corresponding field
// in buffer_config_t must be taken into account when executing the EFFECT_CMD_CONFIGURE command // in buffer_config_t must be taken into account when executing the EFFECT_CMD_CONFIGURE command
#define EFFECT_CONFIG_BUFFER 0x0001 // buffer field must be taken into account #define EFFECT_CONFIG_BUFFER 0x0001 // buffer field must be taken into account
#define EFFECT_CONFIG_SMP_RATE 0x0002 // samplingRate field must be taken into account #define EFFECT_CONFIG_SMP_RATE 0x0002 // samplingRate field must be taken into account
@@ -404,13 +621,15 @@ enum effect_buffer_access_e {
EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT | \ EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT | \
EFFECT_CONFIG_ACC_MODE | EFFECT_CONFIG_PROVIDER) EFFECT_CONFIG_ACC_MODE | EFFECT_CONFIG_PROVIDER)
// effect_config_s structure describes the format of the pCmdData argument of EFFECT_CMD_CONFIGURE command
// to configure audio parameters and buffers for effect engine input and output. // effect_config_s structure describes the format of the pCmdData argument of EFFECT_CMD_CONFIGURE
// command to configure audio parameters and buffers for effect engine input and output.
typedef struct effect_config_s { typedef struct effect_config_s {
buffer_config_t inputCfg; buffer_config_t inputCfg;
buffer_config_t outputCfg;; buffer_config_t outputCfg;;
} effect_config_t; } effect_config_t;
// effect_param_s structure describes the format of the pCmdData argument of EFFECT_CMD_SET_PARAM // effect_param_s structure describes the format of the pCmdData argument of EFFECT_CMD_SET_PARAM
// command and pCmdData and pReplyData of EFFECT_CMD_GET_PARAM command. // command and pCmdData and pReplyData of EFFECT_CMD_GET_PARAM command.
// psize and vsize represent the actual size of parameter and value. // psize and vsize represent the actual size of parameter and value.
@@ -452,7 +671,7 @@ typedef struct effect_param_s {
// specified here as the effect framework will get the function address with dlsym(): // specified here as the effect framework will get the function address with dlsym():
// //
// - effect_QueryNumberEffects_t EffectQueryNumberEffects; // - effect_QueryNumberEffects_t EffectQueryNumberEffects;
// - effect_QueryNextEffect_t EffectQueryNext; // - effect_QueryEffect_t EffectQueryEffect;
// - effect_CreateEffect_t EffectCreate; // - effect_CreateEffect_t EffectCreate;
// - effect_ReleaseEffect_t EffectRelease; // - effect_ReleaseEffect_t EffectRelease;
@@ -463,11 +682,8 @@ typedef struct effect_param_s {
// //
// Description: Returns the number of different effects exposed by the // Description: Returns the number of different effects exposed by the
// library. Each effect must have a unique effect uuid (see // library. Each effect must have a unique effect uuid (see
// effect_descriptor_t). This function together with EffectQueryNext() // effect_descriptor_t). This function together with EffectQueryEffect()
// is used to enumerate all effects present in the library. // is used to enumerate all effects present in the library.
// Each time EffectQueryNumberEffects() is called, the library must
// reset the index of the effect descriptor returned by next call to
// EffectQueryNext() to restart enumeration from the beginning.
// //
// Input/Output: // Input/Output:
// pNumEffects: address where the number of effects should be returned. // pNumEffects: address where the number of effects should be returned.
@@ -483,28 +699,33 @@ typedef int32_t (*effect_QueryNumberEffects_t)(uint32_t *pNumEffects);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
// Function: EffectQueryNext // Function: EffectQueryEffect
// //
// Description: Returns a descriptor of the next available effect. // Description: Returns the descriptor of the effect engine which index is
// given as first argument.
// See effect_descriptor_t for details on effect descriptors. // See effect_descriptor_t for details on effect descriptors.
// This function together with EffectQueryNext() is used to enumerate all // This function together with EffectQueryNumberEffects() is used to enumerate all
// effects present in the library. The enumeration sequence is: // effects present in the library. The enumeration sequence is:
// EffectQueryNumberEffects(&num_effects); // EffectQueryNumberEffects(&num_effects);
// while (num_effects--) // for (i = 0; i < num_effects; i++)
// EffectQueryNext(); // EffectQueryEffect(i,...);
// //
// Input/Output: // Input/Output:
// index: index of the effect
// pDescriptor: address where to return the effect descriptor. // pDescriptor: address where to return the effect descriptor.
// //
// Output: // Output:
// returned value: 0 successful operation. // returned value: 0 successful operation.
// -ENODEV library failed to initialize // -ENODEV library failed to initialize
// -EINVAL invalid pDescriptor // -EINVAL invalid pDescriptor or index
// -ENOSYS effect list has changed since last execution of
// EffectQueryNumberEffects()
// -ENOENT no more effect available // -ENOENT no more effect available
// *pDescriptor: updated with the effect descriptor. // *pDescriptor: updated with the effect descriptor.
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
typedef int32_t (*effect_QueryNextEffect_t)(effect_descriptor_t *pDescriptor); typedef int32_t (*effect_QueryEffect_t)(uint32_t index,
effect_descriptor_t *pDescriptor);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
@@ -516,7 +737,13 @@ typedef int32_t (*effect_QueryNextEffect_t)(effect_descriptor_t *pDescriptor);
// a handle on the effect control interface. // a handle on the effect control interface.
// //
// Input: // Input:
// pEffectUuid: pointer to the effect uuid. // uuid: pointer to the effect uuid.
// sessionId: audio session to which this effect instance will be attached. All effects
// created with the same session ID are connected in series and process the same signal
// stream. Knowing that two effects are part of the same effect chain can help the
// library implement some kind of optimizations.
// ioId: identifies the output or input stream this effect is directed to at audio HAL.
// For future use especially with tunneled HW accelerated effects
// //
// Input/Output: // Input/Output:
// pInterface: address where to return the effect interface. // pInterface: address where to return the effect interface.
@@ -529,7 +756,10 @@ typedef int32_t (*effect_QueryNextEffect_t)(effect_descriptor_t *pDescriptor);
// *pInterface: updated with the effect interface handle. // *pInterface: updated with the effect interface handle.
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
typedef int32_t (*effect_CreateEffect_t)(effect_uuid_t *uuid, effect_interface_t *pInterface); typedef int32_t (*effect_CreateEffect_t)(effect_uuid_t *uuid,
int32_t sessionId,
int32_t ioId,
effect_interface_t *pInterface);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //

31
include/media/EffectFactoryApi.h → include/media/EffectsFactoryApi.h
View File

@@ -14,8 +14,8 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef ANDROID_EFFECTFACTORYAPI_H_ #ifndef ANDROID_EFFECTSFACTORYAPI_H_
#define ANDROID_EFFECTFACTORYAPI_H_ #define ANDROID_EFFECTSFACTORYAPI_H_
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
@@ -36,11 +36,11 @@ extern "C" {
// //
// Description: Returns the number of different effects in all loaded libraries. // Description: Returns the number of different effects in all loaded libraries.
// Each effect must have a different effect uuid (see // Each effect must have a different effect uuid (see
// effect_descriptor_t). This function together with EffectQueryNext() // effect_descriptor_t). This function together with EffectQueryEffect()
// is used to enumerate all effects present in all loaded libraries. // is used to enumerate all effects present in all loaded libraries.
// Each time EffectQueryNumberEffects() is called, the factory must // Each time EffectQueryNumberEffects() is called, the factory must
// reset the index of the effect descriptor returned by next call to // reset the index of the effect descriptor returned by next call to
// EffectQueryNext() to restart enumeration from the beginning. // EffectQueryEffect() to restart enumeration from the beginning.
// //
// Input/Output: // Input/Output:
// pNumEffects: address where the number of effects should be returned. // pNumEffects: address where the number of effects should be returned.
@@ -56,28 +56,29 @@ int EffectQueryNumberEffects(uint32_t *pNumEffects);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
// Function: EffectQueryNext // Function: EffectQueryEffect
// //
// Description: Returns a descriptor of the next available effect. // Description: Returns a descriptor of the next available effect.
// See effect_descriptor_t for a details on effect descriptor. // See effect_descriptor_t for a details on effect descriptor.
// This function together with EffectQueryNext() is used to enumerate all // This function together with EffectQueryNumberEffects() is used to enumerate all
// effects present in all loaded libraries. The enumeration sequence is: // effects present in all loaded libraries. The enumeration sequence is:
// EffectQueryNumberEffects(&num_effects); // EffectQueryNumberEffects(&num_effects);
// while (num_effects--) // for (i = 0; i < num_effects; i++)
// EffectQueryNext(); // EffectQueryEffect(i,...);
// //
// Input/Output: // Input/Output:
// pDescriptor: address where to return the effect descriptor. // pDescriptor: address where to return the effect descriptor.
// //
// Output: // Output:
// returned value: 0 successful operation. // returned value: 0 successful operation.
// -ENOENT no more effect available
// -ENODEV factory failed to initialize // -ENODEV factory failed to initialize
// -EINVAL invalid pDescriptor // -EINVAL invalid pDescriptor
// -ENOENT no more effect available // -ENOSYS effect list has changed since last execution of EffectQueryNumberEffects()
// *pDescriptor: updated with the effect descriptor. // *pDescriptor: updated with the effect descriptor.
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
int EffectQueryNext(effect_descriptor_t *pDescriptor); int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
@@ -90,6 +91,12 @@ int EffectQueryNext(effect_descriptor_t *pDescriptor);
// //
// Input: // Input:
// pEffectUuid: pointer to the effect uuid. // pEffectUuid: pointer to the effect uuid.
// sessionId: audio session to which this effect instance will be attached. All effects created
// with the same session ID are connected in series and process the same signal stream.
// Knowing that two effects are part of the same effect chain can help the library implement
// some kind of optimizations.
// ioId: identifies the output or input stream this effect is directed to at audio HAL. For future
// use especially with tunneled HW accelerated effects
// //
// Input/Output: // Input/Output:
// pInterface: address where to return the effect interface. // pInterface: address where to return the effect interface.
@@ -102,7 +109,7 @@ int EffectQueryNext(effect_descriptor_t *pDescriptor);
// *pInterface: updated with the effect interface. // *pInterface: updated with the effect interface.
// //
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
int EffectCreate(effect_uuid_t *pEffectUuid, effect_interface_t *pInterface); int EffectCreate(effect_uuid_t *pEffectUuid, int32_t sessionId, int32_t ioId, effect_interface_t *pInterface);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// //
@@ -211,4 +218,4 @@ int EffectIsNullUuid(effect_uuid_t *pEffectUuid);
#endif #endif
#endif /*ANDROID_EFFECTFACTORYAPI_H_*/ #endif /*ANDROID_EFFECTSFACTORYAPI_H_*/

2
include/media/IAudioFlinger.h
View File

@@ -148,7 +148,7 @@ public:
virtual status_t queryNumberEffects(uint32_t *numEffects) = 0; virtual status_t queryNumberEffects(uint32_t *numEffects) = 0;
virtual status_t queryNextEffect(effect_descriptor_t *pDescriptor) = 0; virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor) = 0;
virtual status_t getEffectDescriptor(effect_uuid_t *pEffectUUID, effect_descriptor_t *pDescriptor) = 0; virtual status_t getEffectDescriptor(effect_uuid_t *pEffectUUID, effect_descriptor_t *pDescriptor) = 0;

397
libs/audioflinger/AudioFlinger.cpp
View File

@@ -51,7 +51,7 @@
#include "lifevibes.h" #include "lifevibes.h"
#endif #endif
#include <media/EffectFactoryApi.h> #include <media/EffectsFactoryApi.h>
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// the sim build doesn't have gettid // the sim build doesn't have gettid
@@ -126,7 +126,8 @@ static bool settingsAllowed() {
AudioFlinger::AudioFlinger() AudioFlinger::AudioFlinger()
: BnAudioFlinger(), : BnAudioFlinger(),
mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1) mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1),
mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0)
{ {
mHardwareStatus = AUDIO_HW_IDLE; mHardwareStatus = AUDIO_HW_IDLE;
@@ -135,8 +136,8 @@ AudioFlinger::AudioFlinger()
mHardwareStatus = AUDIO_HW_INIT; mHardwareStatus = AUDIO_HW_INIT;
if (mAudioHardware->initCheck() == NO_ERROR) { if (mAudioHardware->initCheck() == NO_ERROR) {
// open 16-bit output stream for s/w mixer // open 16-bit output stream for s/w mixer
mMode = AudioSystem::MODE_NORMAL;
setMode(AudioSystem::MODE_NORMAL); setMode(mMode);
setMasterVolume(1.0f); setMasterVolume(1.0f);
setMasterMute(false); setMasterMute(false);
@@ -431,6 +432,8 @@ status_t AudioFlinger::setMasterVolume(float value)
status_t AudioFlinger::setMode(int mode) status_t AudioFlinger::setMode(int mode)
{ {
status_t ret;
// check calling permissions // check calling permissions
if (!settingsAllowed()) { if (!settingsAllowed()) {
return PERMISSION_DENIED; return PERMISSION_DENIED;
@@ -440,15 +443,23 @@ status_t AudioFlinger::setMode(int mode)
return BAD_VALUE; return BAD_VALUE;
} }
{ // scope for the lock
AutoMutex lock(mHardwareLock); AutoMutex lock(mHardwareLock);
mHardwareStatus = AUDIO_HW_SET_MODE; mHardwareStatus = AUDIO_HW_SET_MODE;
status_t ret = mAudioHardware->setMode(mode); ret = mAudioHardware->setMode(mode);
#ifdef LVMX
if (NO_ERROR == ret) {
LifeVibes::setMode(mode);
}
#endif
mHardwareStatus = AUDIO_HW_IDLE; mHardwareStatus = AUDIO_HW_IDLE;
}
if (NO_ERROR == ret) {
Mutex::Autolock _l(mLock);
mMode = mode;
for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)
mPlaybackThreads.valueAt(i)->setMode(mode);
#ifdef LVMX
LifeVibes::setMode(mode);
#endif
}
return ret; return ret;
} }
@@ -1385,6 +1396,15 @@ sp<AudioFlinger::EffectChain> AudioFlinger::PlaybackThread::getEffectChain_l(int
return chain; return chain;
} }
void AudioFlinger::PlaybackThread::setMode(uint32_t mode)
{
Mutex::Autolock _l(mLock);
size_t size = mEffectChains.size();
for (size_t i = 0; i < size; i++) {
mEffectChains[i]->setMode(mode);
}
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device) AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)
@@ -1805,7 +1825,7 @@ void AudioFlinger::MixerThread::invalidateTracks(int streamType)
t->mCblk->lock.unlock(); t->mCblk->lock.unlock();
} }
} }
} }
// getTrackName_l() must be called with ThreadBase::mLock held // getTrackName_l() must be called with ThreadBase::mLock held
@@ -4466,10 +4486,10 @@ status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects)
return EffectQueryNumberEffects(numEffects); return EffectQueryNumberEffects(numEffects);
} }
status_t AudioFlinger::queryNextEffect(effect_descriptor_t *descriptor) status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
{ {
Mutex::Autolock _l(mLock); Mutex::Autolock _l(mLock);
return EffectQueryNext(descriptor); return EffectQueryEffect(index, descriptor);
} }
status_t AudioFlinger::getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor) status_t AudioFlinger::getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor)
@@ -4529,10 +4549,10 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid,
LOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus); LOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus);
goto Exit; goto Exit;
} }
for (; numEffects > 0; numEffects--) { for (uint32_t i = 0; i < numEffects; i++) {
lStatus = EffectQueryNext(&desc); lStatus = EffectQueryEffect(i, &desc);
if (lStatus < 0) { if (lStatus < 0) {
LOGW("createEffect() error %d from EffectQueryNext", lStatus); LOGW("createEffect() error %d from EffectQueryEffect", lStatus);
continue; continue;
} }
if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) { if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) {
@@ -4567,6 +4587,13 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid,
goto Exit; goto Exit;
} }
// Session -1 is reserved for output stage effects that can only be created
// by audio policy manager (running in same process)
if (sessionId == -1 && getpid() != IPCThreadState::self()->getCallingPid()) {
lStatus = INVALID_OPERATION;
goto Exit;
}
// return effect descriptor // return effect descriptor
memcpy(pDesc, &desc, sizeof(effect_descriptor_t)); memcpy(pDesc, &desc, sizeof(effect_descriptor_t));
@@ -4574,7 +4601,7 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid,
// output threads. // output threads.
// TODO: allow attachment of effect to inputs // TODO: allow attachment of effect to inputs
if (output == 0) { if (output == 0) {
if (sessionId == 0) { if (sessionId <= 0) {
// default to first output // default to first output
// TODO: define criteria to choose output when not specified. Or // TODO: define criteria to choose output when not specified. Or
// receive output from audio policy manager // receive output from audio policy manager
@@ -4621,6 +4648,33 @@ Exit:
return handle; return handle;
} }
status_t AudioFlinger::registerEffectResource_l(effect_descriptor_t *desc) {
if (mTotalEffectsCpuLoad + desc->cpuLoad > MAX_EFFECTS_CPU_LOAD) {
LOGW("registerEffectResource() CPU Load limit exceeded for Fx %s, CPU %f MIPS",
desc->name, (float)desc->cpuLoad/10);
return INVALID_OPERATION;
}
if (mTotalEffectsMemory + desc->memoryUsage > MAX_EFFECTS_MEMORY) {
LOGW("registerEffectResource() memory limit exceeded for Fx %s, Memory %d KB",
desc->name, desc->memoryUsage);
return INVALID_OPERATION;
}
mTotalEffectsCpuLoad += desc->cpuLoad;
mTotalEffectsMemory += desc->memoryUsage;
LOGV("registerEffectResource_l() effect %s, CPU %d, memory %d",
desc->name, desc->cpuLoad, desc->memoryUsage);
LOGV(" total CPU %d, total memory %d", mTotalEffectsCpuLoad, mTotalEffectsMemory);
return NO_ERROR;
}
void AudioFlinger::unregisterEffectResource_l(effect_descriptor_t *desc) {
mTotalEffectsCpuLoad -= desc->cpuLoad;
mTotalEffectsMemory -= desc->memoryUsage;
LOGV("unregisterEffectResource_l() effect %s, CPU %d, memory %d",
desc->name, desc->cpuLoad, desc->memoryUsage);
LOGV(" total CPU %d, total memory %d", mTotalEffectsCpuLoad, mTotalEffectsMemory);
}
// PlaybackThread::createEffect_l() must be called with AudioFlinger::mLock held // PlaybackThread::createEffect_l() must be called with AudioFlinger::mLock held
sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l( sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l(
const sp<AudioFlinger::Client>& client, const sp<AudioFlinger::Client>& client,
@@ -4638,6 +4692,7 @@ sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l(
sp<Track> track; sp<Track> track;
sp<EffectChain> chain; sp<EffectChain> chain;
bool effectCreated = false; bool effectCreated = false;
bool effectRegistered = false;
if (mOutput == 0) { if (mOutput == 0) {
LOGW("createEffect_l() Audio driver not initialized."); LOGW("createEffect_l() Audio driver not initialized.");
@@ -4680,20 +4735,26 @@ sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l(
LOGV("createEffect_l() got effect %p on chain %p", effect == 0 ? 0 : effect.get(), chain.get()); LOGV("createEffect_l() got effect %p on chain %p", effect == 0 ? 0 : effect.get(), chain.get());
if (effect == 0) { if (effect == 0) {
// Check CPU and memory usage
lStatus = mAudioFlinger->registerEffectResource_l(desc);
if (lStatus != NO_ERROR) {
goto Exit;
}
effectRegistered = true;
// create a new effect module if none present in the chain // create a new effect module if none present in the chain
effectCreated = true;
effect = new EffectModule(this, chain, desc, mAudioFlinger->nextUniqueId(), sessionId); effect = new EffectModule(this, chain, desc, mAudioFlinger->nextUniqueId(), sessionId);
lStatus = effect->status(); lStatus = effect->status();
if (lStatus != NO_ERROR) { if (lStatus != NO_ERROR) {
goto Exit; goto Exit;
} }
//TODO: handle CPU load and memory usage here
lStatus = chain->addEffect(effect); lStatus = chain->addEffect(effect);
if (lStatus != NO_ERROR) { if (lStatus != NO_ERROR) {
goto Exit; goto Exit;
} }
effectCreated = true;
effect->setDevice(mDevice); effect->setDevice(mDevice);
effect->setMode(mAudioFlinger->getMode());
} }
// create effect handle and connect it to effect module // create effect handle and connect it to effect module
handle = new EffectHandle(effect, client, effectClient, priority); handle = new EffectHandle(effect, client, effectClient, priority);
@@ -4705,11 +4766,14 @@ sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l(
Exit: Exit:
if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) { if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
if (chain != 0 && effectCreated) { if (effectCreated) {
if (chain->removeEffect(effect) == 0) { if (chain->removeEffect(effect) == 0) {
removeEffectChain_l(chain); removeEffectChain_l(chain);
} }
} }
if (effectRegistered) {
mAudioFlinger->unregisterEffectResource_l(desc);
}
handle.clear(); handle.clear();
} }
@@ -4719,21 +4783,37 @@ Exit:
return handle; return handle;
} }
void AudioFlinger::PlaybackThread::disconnectEffect(const sp< EffectModule>& effect,
const wp<EffectHandle>& handle) {
effect_descriptor_t desc = effect->desc();
Mutex::Autolock _l(mLock);
// delete the effect module if removing last handle on it
if (effect->removeHandle(handle) == 0) {
if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
detachAuxEffect_l(effect->id());
}
sp<EffectChain> chain = effect->chain().promote();
if (chain != 0) {
// remove effect chain if remove last effect
if (chain->removeEffect(effect) == 0) {
removeEffectChain_l(chain);
}
}
mLock.unlock();
mAudioFlinger->mLock.lock();
mAudioFlinger->unregisterEffectResource_l(&desc);
mAudioFlinger->mLock.unlock();
}
}
status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain) status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
{ {
int session = chain->sessionId(); int session = chain->sessionId();
int16_t *buffer = mMixBuffer; int16_t *buffer = mMixBuffer;
bool ownsBuffer = false;
LOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session); LOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
if (session == 0) { if (session > 0) {
chain->setInBuffer(buffer, false);
chain->setOutBuffer(buffer);
// Effect chain for session 0 is inserted at end of effect chains list
// to be processed last as it contains output mix effects to apply after
// all track specific effects
mEffectChains.add(chain);
} else {
bool ownsBuffer = false;
// Only one effect chain can be present in direct output thread and it uses // Only one effect chain can be present in direct output thread and it uses
// the mix buffer as input // the mix buffer as input
if (mType != DIRECT) { if (mType != DIRECT) {
@@ -4743,13 +4823,6 @@ status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& c
LOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session); LOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session);
ownsBuffer = true; ownsBuffer = true;
} }
chain->setInBuffer(buffer, ownsBuffer);
chain->setOutBuffer(mMixBuffer);
// Effect chain for session other than 0 is inserted at beginning of effect
// chains list to be processed before output mix effects. Relative order between
// sessions other than 0 is not important
mEffectChains.insertAt(chain, 0);
}
// Attach all tracks with same session ID to this chain. // Attach all tracks with same session ID to this chain.
for (size_t i = 0; i < mTracks.size(); ++i) { for (size_t i = 0; i < mTracks.size(); ++i) {
@@ -4769,6 +4842,23 @@ status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& c
chain->startTrack(); chain->startTrack();
} }
} }
}
chain->setInBuffer(buffer, ownsBuffer);
chain->setOutBuffer(mMixBuffer);
// Effect chain for session -1 is inserted at end of effect chains list
// in order to be processed last as it contains output stage effects
// Effect chain for session 0 is inserted before session -1 to be processed
// after track specific effects and before output stage
// Effect chain for session other than 0 is inserted at beginning of effect
// chains list to be processed before output mix effects. Relative order between
// sessions other than 0 is not important
size_t size = mEffectChains.size();
size_t i = 0;
for (i = 0; i < size; i++) {
if (mEffectChains[i]->sessionId() < session) break;
}
mEffectChains.insertAt(chain, i);
return NO_ERROR; return NO_ERROR;
} }
@@ -4884,7 +4974,8 @@ AudioFlinger::EffectModule::EffectModule(const wp<ThreadBase>& wThread,
memcpy(&mDescriptor, desc, sizeof(effect_descriptor_t)); memcpy(&mDescriptor, desc, sizeof(effect_descriptor_t));
// create effect engine from effect factory // create effect engine from effect factory
mStatus = EffectCreate(&desc->uuid, &mEffectInterface); mStatus = EffectCreate(&desc->uuid, sessionId, p->id(), &mEffectInterface);
if (mStatus != NO_ERROR) { if (mStatus != NO_ERROR) {
return; return;
} }
@@ -4969,22 +5060,11 @@ void AudioFlinger::EffectModule::disconnect(const wp<EffectHandle>& handle)
// keep a strong reference on this EffectModule to avoid calling the // keep a strong reference on this EffectModule to avoid calling the
// destructor before we exit // destructor before we exit
sp<EffectModule> keep(this); sp<EffectModule> keep(this);
{
sp<ThreadBase> thread = mThread.promote(); sp<ThreadBase> thread = mThread.promote();
if (thread != 0) { if (thread != 0) {
Mutex::Autolock _l(thread->mLock);
// delete the effect module if removing last handle on it
if (removeHandle(handle) == 0) {
PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { playbackThread->disconnectEffect(keep, handle);
playbackThread->detachAuxEffect_l(mId);
}
sp<EffectChain> chain = mChain.promote();
if (chain != 0) {
// remove effect chain if remove last effect
if (chain->removeEffect(keep) == 0) {
playbackThread->removeEffectChain_l(chain);
}
}
} }
} }
} }
@@ -5007,88 +5087,25 @@ void AudioFlinger::EffectModule::process()
// TODO: handle effects with buffer provider // TODO: handle effects with buffer provider
if (mState != ACTIVE) { if (mState != ACTIVE) {
uint32_t count = mConfig.inputCfg.buffer.frameCount;
int32_t amp = 32767L << 16;
int32_t step = amp / count;
int16_t *pIn = mConfig.inputCfg.buffer.s16;
int16_t *pOut = mConfig.outputCfg.buffer.s16;
int inChannels;
int outChannels;
if (mConfig.inputCfg.channels == CHANNEL_MONO) {
inChannels = 1;
} else {
inChannels = 2;
}
if (mConfig.outputCfg.channels == CHANNEL_MONO) {
outChannels = 1;
} else {
outChannels = 2;
}
switch (mState) { switch (mState) {
case RESET: case RESET:
reset(); reset();
mState = STARTING;
// clear auxiliary effect input buffer for next accumulation // clear auxiliary effect input buffer for next accumulation
if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
memset(mConfig.inputCfg.buffer.raw, 0, mConfig.inputCfg.buffer.frameCount*sizeof(int32_t)); memset(mConfig.inputCfg.buffer.raw, 0, mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
} }
step = -step; return;
mState = STARTING;
break;
case STARTING: case STARTING:
start(); start();
amp = 0;
pOut = mConfig.inputCfg.buffer.s16;
outChannels = inChannels;
mState = ACTIVE; mState = ACTIVE;
break; break;
case STOPPING: case STOPPING:
step = -step;
pOut = mConfig.inputCfg.buffer.s16;
outChannels = inChannels;
mState = STOPPED; mState = STOPPED;
break; break;
case STOPPED: case STOPPED:
stop(); stop();
amp = 0;
mState = IDLE; mState = IDLE;
break;
}
// ramp volume down or up before activating or deactivating the effect
if (inChannels == 1) {
if (outChannels == 1) {
while (count--) {
*pOut++ = (int16_t)(((int32_t)*pIn++ * (amp >> 16)) >> 15);
amp += step;
}
} else {
while (count--) {
int32_t smp = (int16_t)(((int32_t)*pIn++ * (amp >> 16)) >> 15);
*pOut++ = smp;
*pOut++ = smp;
amp += step;
}
}
} else {
if (outChannels == 1) {
while (count--) {
int32_t smp = (((int32_t)*pIn * (amp >> 16)) >> 16) +
(((int32_t)*(pIn + 1) * (amp >> 16)) >> 16);
pIn += 2;
*pOut++ = (int16_t)smp;
amp += step;
}
} else {
while (count--) {
*pOut++ = (int16_t)((int32_t)*pIn++ * (amp >> 16)) >> 15;
*pOut++ = (int16_t)((int32_t)*pIn++ * (amp >> 16)) >> 15;
amp += step;
}
}
}
if (mState == STARTING || mState == IDLE) {
return; return;
} }
} }
@@ -5148,8 +5165,8 @@ status_t AudioFlinger::EffectModule::configure()
mConfig.inputCfg.channels = channels; mConfig.inputCfg.channels = channels;
} }
mConfig.outputCfg.channels = channels; mConfig.outputCfg.channels = channels;
mConfig.inputCfg.format = PCM_FORMAT_S15; mConfig.inputCfg.format = SAMPLE_FORMAT_PCM_S15;
mConfig.outputCfg.format = PCM_FORMAT_S15; mConfig.outputCfg.format = SAMPLE_FORMAT_PCM_S15;
mConfig.inputCfg.samplingRate = thread->sampleRate(); mConfig.inputCfg.samplingRate = thread->sampleRate();
mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate; mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
mConfig.inputCfg.bufferProvider.cookie = NULL; mConfig.inputCfg.bufferProvider.cookie = NULL;
@@ -5160,7 +5177,7 @@ status_t AudioFlinger::EffectModule::configure()
mConfig.outputCfg.bufferProvider.releaseBuffer = NULL; mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
// Insert effect: // Insert effect:
// - in session 0, always overwrites output buffer: input buffer == output buffer // - in session 0 or -1, always overwrites output buffer: input buffer == output buffer
// - in other sessions: // - in other sessions:
// last effect in the chain accumulates in output buffer: input buffer != output buffer // last effect in the chain accumulates in output buffer: input buffer != output buffer
// other effect: overwrites output buffer: input buffer == output buffer // other effect: overwrites output buffer: input buffer == output buffer
@@ -5331,7 +5348,12 @@ status_t AudioFlinger::EffectModule::setVolume(uint32_t *left, uint32_t *right,
status_t AudioFlinger::EffectModule::setDevice(uint32_t device) status_t AudioFlinger::EffectModule::setDevice(uint32_t device)
{ {
status_t status = NO_ERROR; status_t status = NO_ERROR;
if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_MASK) { if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
// convert device bit field from AudioSystem to EffectApi format.
device = deviceAudioSystemToEffectApi(device);
if (device == 0) {
return BAD_VALUE;
}
status_t cmdStatus; status_t cmdStatus;
int size = sizeof(status_t); int size = sizeof(status_t);
status = (*mEffectInterface)->command(mEffectInterface, EFFECT_CMD_SET_DEVICE, sizeof(uint32_t), &device, &size, &cmdStatus); status = (*mEffectInterface)->command(mEffectInterface, EFFECT_CMD_SET_DEVICE, sizeof(uint32_t), &device, &size, &cmdStatus);
@@ -5342,6 +5364,70 @@ status_t AudioFlinger::EffectModule::setDevice(uint32_t device)
return status; return status;
} }
status_t AudioFlinger::EffectModule::setMode(uint32_t mode)
{
status_t status = NO_ERROR;
if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
// convert audio mode from AudioSystem to EffectApi format.
int effectMode = modeAudioSystemToEffectApi(mode);
if (effectMode < 0) {
return BAD_VALUE;
}
status_t cmdStatus;
int size = sizeof(status_t);
status = (*mEffectInterface)->command(mEffectInterface, EFFECT_CMD_SET_AUDIO_MODE, sizeof(int), &effectMode, &size, &cmdStatus);
if (status == NO_ERROR) {
status = cmdStatus;
}
}
return status;
}
// update this table when AudioSystem::audio_devices or audio_device_e (in EffectApi.h) are modified
const uint32_t AudioFlinger::EffectModule::sDeviceConvTable[] = {
DEVICE_EARPIECE, // AudioSystem::DEVICE_OUT_EARPIECE
DEVICE_SPEAKER, // AudioSystem::DEVICE_OUT_SPEAKER
DEVICE_WIRED_HEADSET, // case AudioSystem::DEVICE_OUT_WIRED_HEADSET
DEVICE_WIRED_HEADPHONE, // AudioSystem::DEVICE_OUT_WIRED_HEADPHONE
DEVICE_BLUETOOTH_SCO, // AudioSystem::DEVICE_OUT_BLUETOOTH_SCO
DEVICE_BLUETOOTH_SCO_HEADSET, // AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET
DEVICE_BLUETOOTH_SCO_CARKIT, // AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT
DEVICE_BLUETOOTH_A2DP, // AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP
DEVICE_BLUETOOTH_A2DP_HEADPHONES, // AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES
DEVICE_BLUETOOTH_A2DP_SPEAKER, // AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER
DEVICE_AUX_DIGITAL // AudioSystem::DEVICE_OUT_AUX_DIGITAL
};
uint32_t AudioFlinger::EffectModule::deviceAudioSystemToEffectApi(uint32_t device)
{
uint32_t deviceOut = 0;
while (device) {
const uint32_t i = 31 - __builtin_clz(device);
device &= ~(1 << i);
if (i >= sizeof(sDeviceConvTable)/sizeof(uint32_t)) {
LOGE("device convertion error for AudioSystem device 0x%08x", device);
return 0;
}
deviceOut |= (uint32_t)sDeviceConvTable[i];
}
return deviceOut;
}
// update this table when AudioSystem::audio_mode or audio_mode_e (in EffectApi.h) are modified
const uint32_t AudioFlinger::EffectModule::sModeConvTable[] = {
AUDIO_MODE_NORMAL, // AudioSystem::MODE_NORMAL
AUDIO_MODE_RINGTONE, // AudioSystem::MODE_RINGTONE
AUDIO_MODE_IN_CALL // AudioSystem::MODE_IN_CALL
};
int AudioFlinger::EffectModule::modeAudioSystemToEffectApi(uint32_t mode)
{
int modeOut = -1;
if (mode < sizeof(sModeConvTable) / sizeof(uint32_t)) {
modeOut = (int)sModeConvTable[mode];
}
return modeOut;
}
status_t AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args) status_t AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args)
{ {
@@ -5525,7 +5611,16 @@ status_t AudioFlinger::EffectHandle::command(int cmdCode, int cmdSize, void *pCm
int rsize = sizeof(int); int rsize = sizeof(int);
int *p = (int *)(mBuffer + mCblk->serverIndex); int *p = (int *)(mBuffer + mCblk->serverIndex);
int size = *p++; int size = *p++;
if (((uint8_t *)p + size) > mBuffer + mCblk->clientIndex) {
LOGW("command(): invalid parameter block size");
break;
}
effect_param_t *param = (effect_param_t *)p; effect_param_t *param = (effect_param_t *)p;
if (param->psize == 0 || param->vsize == 0) {
LOGW("command(): null parameter or value size");
mCblk->serverIndex += size;
continue;
}
int psize = sizeof(effect_param_t) + ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize; int psize = sizeof(effect_param_t) + ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
status_t ret = mEffect->command(EFFECT_CMD_SET_PARAM, psize, p, &rsize, &reply); status_t ret = mEffect->command(EFFECT_CMD_SET_PARAM, psize, p, &rsize, &reply);
if (ret == NO_ERROR) { if (ret == NO_ERROR) {
@@ -5659,7 +5754,7 @@ void AudioFlinger::EffectChain::process_l()
} }
// if no track is active, input buffer must be cleared here as the mixer process // if no track is active, input buffer must be cleared here as the mixer process
// will not do it // will not do it
if (mSessionId != 0 && activeTracks() == 0) { if (mSessionId > 0 && activeTracks() == 0) {
sp<ThreadBase> thread = mThread.promote(); sp<ThreadBase> thread = mThread.promote();
if (thread != 0) { if (thread != 0) {
size_t numSamples = thread->frameCount() * thread->channelCount(); size_t numSamples = thread->frameCount() * thread->channelCount();
@@ -5697,15 +5792,16 @@ status_t AudioFlinger::EffectChain::addEffect(sp<EffectModule>& effect)
} else { } else {
// Insert effects are inserted at the end of mEffects vector as they are processed // Insert effects are inserted at the end of mEffects vector as they are processed
// after track and auxiliary effects. // after track and auxiliary effects.
// Insert effect order: // Insert effect order as a function of indicated preference:
// if EFFECT_FLAG_INSERT_FIRST or EFFECT_FLAG_INSERT_EXCLUSIVE insert as first insert effect // 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 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last
// else insert as last insert effect // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
// Reject insertion if: // already present
// - EFFECT_FLAG_INSERT_EXCLUSIVE and another effect is present
// - an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is present
// - EFFECT_FLAG_INSERT_FIRST or EFFECT_FLAG_INSERT_LAST and an effect with same
// preference is present
int size = (int)mEffects.size(); int size = (int)mEffects.size();
int idx_insert = size; int idx_insert = size;
@@ -5719,35 +5815,40 @@ status_t AudioFlinger::EffectChain::addEffect(sp<EffectModule>& effect)
if (iMode == EFFECT_FLAG_TYPE_INSERT) { if (iMode == EFFECT_FLAG_TYPE_INSERT) {
// check invalid effect chaining combinations // check invalid effect chaining combinations
if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE || if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
iPref == EFFECT_FLAG_INSERT_EXCLUSIVE || iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
(insertPref != EFFECT_FLAG_INSERT_ANY LOGW("addEffect() could not insert effect %s: exclusive conflict with %s", desc.name, d.name);
&& insertPref == iPref)) {
return INVALID_OPERATION; return INVALID_OPERATION;
} }
// remember position of first insert effect // remember position of first insert effect and by default
// select this as insert position for new effect
if (idx_insert == size) { if (idx_insert == size) {
idx_insert = i; idx_insert = i;
} }
// remember position of insert effect claiming // remember position of last insert effect claiming
// first place // first position
if (iPref == EFFECT_FLAG_INSERT_FIRST) { if (iPref == EFFECT_FLAG_INSERT_FIRST) {
idx_insert_first = i; idx_insert_first = i;
} }
// remember position of insert effect claiming // remember position of first insert effect claiming
// last place // last position
if (iPref == EFFECT_FLAG_INSERT_LAST) { if (iPref == EFFECT_FLAG_INSERT_LAST &&
idx_insert_last == -1) {
idx_insert_last = i; idx_insert_last = i;
} }
} }
} }
// modify idx_insert from first place if needed // 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) { if (idx_insert_first != -1) {
idx_insert = idx_insert_first + 1; idx_insert = idx_insert_first + 1;
} else if (idx_insert_last != -1) { }
idx_insert = idx_insert_last;
} else if (insertPref == EFFECT_FLAG_INSERT_LAST) {
idx_insert = size;
} }
// always read samples from chain input buffer // always read samples from chain input buffer
@@ -5764,14 +5865,14 @@ status_t AudioFlinger::EffectChain::addEffect(sp<EffectModule>& effect)
} else { } else {
effect->setOutBuffer(mInBuffer); effect->setOutBuffer(mInBuffer);
} }
status_t status = mEffects.insertAt(effect, idx_insert); mEffects.insertAt(effect, idx_insert);
// Always give volume control to last effect in chain with volume control capability // Always give volume control to last effect in chain with volume control capability
if (((desc.flags & EFFECT_FLAG_VOLUME_MASK) & EFFECT_FLAG_VOLUME_CTRL) && if (((desc.flags & EFFECT_FLAG_VOLUME_MASK) & EFFECT_FLAG_VOLUME_CTRL) &&
mVolumeCtrlIdx < idx_insert) { mVolumeCtrlIdx < idx_insert) {
mVolumeCtrlIdx = idx_insert; mVolumeCtrlIdx = idx_insert;
} }
LOGV("addEffect() effect %p, added in chain %p at rank %d status %d", effect.get(), this, idx_insert, status); LOGV("addEffect() effect %p, added in chain %p at rank %d", effect.get(), this, idx_insert);
} }
effect->configure(); effect->configure();
return NO_ERROR; return NO_ERROR;
@@ -5823,6 +5924,14 @@ void AudioFlinger::EffectChain::setDevice(uint32_t device)
} }
} }
void AudioFlinger::EffectChain::setMode(uint32_t mode)
{
size_t size = mEffects.size();
for (size_t i = 0; i < size; i++) {
mEffects[i]->setMode(mode);
}
}
bool AudioFlinger::EffectChain::setVolume(uint32_t *left, uint32_t *right) bool AudioFlinger::EffectChain::setVolume(uint32_t *left, uint32_t *right)
{ {
uint32_t newLeft = *left; uint32_t newLeft = *left;

30
libs/audioflinger/AudioFlinger.h
View File

@@ -149,7 +149,7 @@ public:
virtual status_t queryNumberEffects(uint32_t *numEffects); virtual status_t queryNumberEffects(uint32_t *numEffects);
virtual status_t queryNextEffect(effect_descriptor_t *descriptor); virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor);
virtual status_t getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor); virtual status_t getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor);
@@ -163,6 +163,9 @@ public:
int *id, int *id,
int *enabled); int *enabled);
status_t registerEffectResource_l(effect_descriptor_t *desc);
void unregisterEffectResource_l(effect_descriptor_t *desc);
enum hardware_call_state { enum hardware_call_state {
AUDIO_HW_IDLE = 0, AUDIO_HW_IDLE = 0,
AUDIO_HW_INIT, AUDIO_HW_INIT,
@@ -200,6 +203,8 @@ public:
Parcel* reply, Parcel* reply,
uint32_t flags); uint32_t flags);
uint32_t getMode() { return mMode; }
private: private:
AudioFlinger(); AudioFlinger();
virtual ~AudioFlinger(); virtual ~AudioFlinger();
@@ -601,6 +606,8 @@ private:
effect_descriptor_t *desc, effect_descriptor_t *desc,
int *enabled, int *enabled,
status_t *status); status_t *status);
void disconnectEffect(const sp< EffectModule>& effect,
const wp<EffectHandle>& handle);
bool hasAudioSession(int sessionId); bool hasAudioSession(int sessionId);
sp<EffectChain> getEffectChain(int sessionId); sp<EffectChain> getEffectChain(int sessionId);
@@ -614,6 +621,7 @@ private:
void detachAuxEffect_l(int effectId); void detachAuxEffect_l(int effectId);
status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId); status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId);
status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId); status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId);
void setMode(uint32_t mode);
struct stream_type_t { struct stream_type_t {
stream_type_t() stream_type_t()
@@ -930,9 +938,11 @@ private:
size_t removeHandle (const wp<EffectHandle>& handle); size_t removeHandle (const wp<EffectHandle>& handle);
effect_descriptor_t& desc() { return mDescriptor; } effect_descriptor_t& desc() { return mDescriptor; }
wp<EffectChain>& chain() { return mChain; }
status_t setDevice(uint32_t device); status_t setDevice(uint32_t device);
status_t setVolume(uint32_t *left, uint32_t *right, bool controller); status_t setVolume(uint32_t *left, uint32_t *right, bool controller);
status_t setMode(uint32_t mode);
status_t dump(int fd, const Vector<String16>& args); status_t dump(int fd, const Vector<String16>& args);
@@ -944,6 +954,14 @@ private:
status_t start(); status_t start();
status_t stop(); status_t stop();
// update this table when AudioSystem::audio_devices or audio_device_e (in EffectApi.h) are modified
static const uint32_t sDeviceConvTable[];
static uint32_t deviceAudioSystemToEffectApi(uint32_t device);
// update this table when AudioSystem::audio_mode or audio_mode_e (in EffectApi.h) are modified
static const uint32_t sModeConvTable[];
static int modeAudioSystemToEffectApi(uint32_t mode);
Mutex mLock; // mutex for process, commands and handles list protection Mutex mLock; // mutex for process, commands and handles list protection
wp<ThreadBase> mThread; // parent thread wp<ThreadBase> mThread; // parent thread
wp<EffectChain> mChain; // parent effect chain wp<EffectChain> mChain; // parent effect chain
@@ -1042,6 +1060,8 @@ private:
sp<EffectModule> getVolumeController(); sp<EffectModule> getVolumeController();
bool setVolume(uint32_t *left, uint32_t *right); bool setVolume(uint32_t *left, uint32_t *right);
void setDevice(uint32_t device); void setDevice(uint32_t device);
void setMode(uint32_t mode);
void setInBuffer(int16_t *buffer, bool ownsBuffer = false) { void setInBuffer(int16_t *buffer, bool ownsBuffer = false) {
mInBuffer = buffer; mInBuffer = buffer;
@@ -1104,6 +1124,14 @@ private:
#ifdef LVMX #ifdef LVMX
int mLifeVibesClientPid; int mLifeVibesClientPid;
#endif #endif
uint32_t mMode;
// Maximum CPU load allocated to audio effects in 0.1 MIPS (ARMv5TE, 0 WS memory) units
static const uint32_t MAX_EFFECTS_CPU_LOAD = 1000;
// Maximum memory allocated to audio effects in KB
static const uint32_t MAX_EFFECTS_MEMORY = 512;
uint32_t mTotalEffectsCpuLoad; // current CPU load used by effects
uint32_t mTotalEffectsMemory; // current memory used by effects
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

2
media/jni/audioeffect/android_media_AudioEffect.cpp
View File

@@ -758,7 +758,7 @@ android_media_AudioEffect_native_queryEffects(JNIEnv *env, jclass clazz)
LOGV("queryEffects() numEffects: %d", numEffects); LOGV("queryEffects() numEffects: %d", numEffects);
for (i = 0; i < numEffects; i++) { for (i = 0; i < numEffects; i++) {
if (AudioEffect::queryNextEffect(&desc) != NO_ERROR) { if (AudioEffect::queryEffect(i, &desc) != NO_ERROR) {
goto queryEffects_failure; goto queryEffects_failure;
} }

10
media/libeffects/Android.mk
View File

@@ -1,5 +1,8 @@
LOCAL_PATH:= $(call my-dir) LOCAL_PATH:= $(call my-dir)
#
TEST_EFFECT_LIBRARIES := true
# Effect factory library # Effect factory library
include $(CLEAR_VARS) include $(CLEAR_VARS)
@@ -25,7 +28,8 @@ LOCAL_C_INCLUDES := \
include $(BUILD_SHARED_LIBRARY) include $(BUILD_SHARED_LIBRARY)
# Default Reverb library ifeq ($(TEST_EFFECT_LIBRARIES),true)
# Test Reverb library
include $(CLEAR_VARS) include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \ LOCAL_SRC_FILES:= \
@@ -54,7 +58,7 @@ LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY) include $(BUILD_SHARED_LIBRARY)
# Default Equalizer library # Test Equalizer library
include $(CLEAR_VARS) include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \ LOCAL_SRC_FILES:= \
@@ -88,3 +92,5 @@ LOCAL_C_INCLUDES := \
LOCAL_PRELINK_MODULE := false LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY) include $(BUILD_SHARED_LIBRARY)
endif

2
media/libeffects/AudioCoefInterpolator.cpp
View File

@@ -46,7 +46,7 @@ void AudioCoefInterpolator::getCoef(const int intCoord[], uint32_t fracCoord[],
while (dim-- > 0) { while (dim-- > 0) {
if (UNLIKELY(intCoord[dim] < 0)) { if (UNLIKELY(intCoord[dim] < 0)) {
fracCoord[dim] = 0; fracCoord[dim] = 0;
} else if (UNLIKELY(intCoord[dim] >= mInDims[dim] - 1)) { } else if (UNLIKELY(intCoord[dim] >= (int)mInDims[dim] - 1)) {
fracCoord[dim] = 0; fracCoord[dim] = 0;
index += mInDimOffsets[dim] * (mInDims[dim] - 1); index += mInDimOffsets[dim] * (mInDims[dim] - 1);
} else { } else {

2
media/libeffects/AudioCommon.h
View File

@@ -1,4 +1,4 @@
/* //device/include/server/AudioFlinger/AudioCommon.h /*
** **
** Copyright 2009, The Android Open Source Project ** Copyright 2009, The Android Open Source Project
** **

6
media/libeffects/AudioFormatAdapter.h
View File

@@ -75,7 +75,7 @@ public:
while (numSamples > 0) { while (numSamples > 0) {
uint32_t numSamplesIter = min(numSamples, mMaxSamplesPerCall); uint32_t numSamplesIter = min(numSamples, mMaxSamplesPerCall);
uint32_t nSamplesChannels = numSamplesIter * mNumChannels; uint32_t nSamplesChannels = numSamplesIter * mNumChannels;
if (mPcmFormat == PCM_FORMAT_S7_24) { if (mPcmFormat == SAMPLE_FORMAT_PCM_S7_24) {
if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) { if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) {
mpProcessor->process( mpProcessor->process(
reinterpret_cast<const audio_sample_t *> (pIn), reinterpret_cast<const audio_sample_t *> (pIn),
@@ -125,7 +125,7 @@ private:
// sample. // sample.
// numSamples The number of single-channel samples to process. // numSamples The number of single-channel samples to process.
void ConvertInput(const void *& pIn, uint32_t numSamples) { void ConvertInput(const void *& pIn, uint32_t numSamples) {
if (mPcmFormat == PCM_FORMAT_S15) { if (mPcmFormat == SAMPLE_FORMAT_PCM_S15) {
const int16_t * pIn16 = reinterpret_cast<const int16_t *>(pIn); const int16_t * pIn16 = reinterpret_cast<const int16_t *>(pIn);
audio_sample_t * pOut = mBuffer; audio_sample_t * pOut = mBuffer;
while (numSamples-- > 0) { while (numSamples-- > 0) {
@@ -143,7 +143,7 @@ private:
// When function exist will point to the next output sample. // When function exist will point to the next output sample.
// numSamples The number of single-channel samples to process. // numSamples The number of single-channel samples to process.
void ConvertOutput(void *& pOut, uint32_t numSamples) { void ConvertOutput(void *& pOut, uint32_t numSamples) {
if (mPcmFormat == PCM_FORMAT_S15) { if (mPcmFormat == SAMPLE_FORMAT_PCM_S15) {
const audio_sample_t * pIn = mBuffer; const audio_sample_t * pIn = mBuffer;
int16_t * pOut16 = reinterpret_cast<int16_t *>(pOut); int16_t * pOut16 = reinterpret_cast<int16_t *>(pOut);
if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) { if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) {

4
media/libeffects/AudioShelvingFilter.cpp
View File

@@ -50,8 +50,8 @@ AudioCoefInterpolator AudioShelvingFilter::mLoCoefInterp(2, kLoInDims, 5, (const
AudioShelvingFilter::AudioShelvingFilter(ShelfType type, int nChannels, AudioShelvingFilter::AudioShelvingFilter(ShelfType type, int nChannels,
int sampleRate) int sampleRate)
: mBiquad(nChannels, sampleRate) : mType(type),
, mType(type) { mBiquad(nChannels, sampleRate) {
configure(nChannels, sampleRate); configure(nChannels, sampleRate);
} }

37
media/libeffects/EffectEqualizer.cpp
View File

@@ -39,10 +39,11 @@ const effect_descriptor_t gEqualizerDescriptor = {
{0xe25aa840, 0x543b, 0x11df, 0x98a5, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid {0xe25aa840, 0x543b, 0x11df, 0x98a5, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
EFFECT_API_VERSION, EFFECT_API_VERSION,
(EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST), (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST),
0, // TODO
1,
"Graphic Equalizer", "Graphic Equalizer",
"Google Inc.", "Google Inc.",
}; };
static int gEffectIndex;
/////////////////// BEGIN EQ PRESETS /////////////////////////////////////////// /////////////////// BEGIN EQ PRESETS ///////////////////////////////////////////
const int kNumBands = 5; const int kNumBands = 5;
@@ -101,7 +102,6 @@ struct EqualizerContext {
AudioEqualizer * pEqualizer; AudioEqualizer * pEqualizer;
}; };
//--- local function prototypes //--- local function prototypes
int Equalizer_init(EqualizerContext *pContext); int Equalizer_init(EqualizerContext *pContext);
@@ -116,22 +116,23 @@ int Equalizer_setParameter(AudioEqualizer * pEqualizer, int32_t *pParam, void *p
extern "C" int EffectQueryNumberEffects(uint32_t *pNumEffects) { extern "C" int EffectQueryNumberEffects(uint32_t *pNumEffects) {
*pNumEffects = 1; *pNumEffects = 1;
gEffectIndex = 0;
return 0; return 0;
} /* end EffectQueryNumberEffects */ } /* end EffectQueryNumberEffects */
extern "C" int EffectQueryNext(effect_descriptor_t *pDescriptor) { extern "C" int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor) {
if (pDescriptor == NULL) { if (pDescriptor == NULL) {
return -EINVAL; return -EINVAL;
} }
if (gEffectIndex++ > 0) { if (index > 0) {
return -ENOENT; return -EINVAL;
} }
memcpy(pDescriptor, &gEqualizerDescriptor, sizeof(effect_descriptor_t)); memcpy(pDescriptor, &gEqualizerDescriptor, sizeof(effect_descriptor_t));
return 0; return 0;
} /* end EffectQueryNext */ } /* end EffectQueryNext */
extern "C" int EffectCreate(effect_uuid_t *uuid, extern "C" int EffectCreate(effect_uuid_t *uuid,
int32_t sessionId,
int32_t ioId,
effect_interface_t *pInterface) { effect_interface_t *pInterface) {
int ret; int ret;
int i; int i;
@@ -160,7 +161,7 @@ extern "C" int EffectCreate(effect_uuid_t *uuid,
*pInterface = (effect_interface_t)pContext; *pInterface = (effect_interface_t)pContext;
LOGV("EffectLibCreateEffect %p", pContext); LOGV("EffectLibCreateEffect %p, size %d", pContext, AudioEqualizer::GetInstanceSize(kNumBands)+sizeof(EqualizerContext));
return 0; return 0;
@@ -219,8 +220,8 @@ int Equalizer_configure(EqualizerContext *pContext, effect_config_t *pConfig)
CHECK_ARG((pConfig->inputCfg.channels == CHANNEL_MONO) || (pConfig->inputCfg.channels == CHANNEL_STEREO)); CHECK_ARG((pConfig->inputCfg.channels == CHANNEL_MONO) || (pConfig->inputCfg.channels == CHANNEL_STEREO));
CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE
|| pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE); || pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
CHECK_ARG(pConfig->inputCfg.format == PCM_FORMAT_S7_24 CHECK_ARG(pConfig->inputCfg.format == SAMPLE_FORMAT_PCM_S7_24
|| pConfig->inputCfg.format == PCM_FORMAT_S15); || pConfig->inputCfg.format == SAMPLE_FORMAT_PCM_S15);
int channelCount; int channelCount;
if (pConfig->inputCfg.channels == CHANNEL_MONO) { if (pConfig->inputCfg.channels == CHANNEL_MONO) {
@@ -230,6 +231,8 @@ int Equalizer_configure(EqualizerContext *pContext, effect_config_t *pConfig)
} }
CHECK_ARG(channelCount <= AudioBiquadFilter::MAX_CHANNELS); CHECK_ARG(channelCount <= AudioBiquadFilter::MAX_CHANNELS);
memcpy(&pContext->config, pConfig, sizeof(effect_config_t));
pContext->pEqualizer->configure(channelCount, pContext->pEqualizer->configure(channelCount,
pConfig->inputCfg.samplingRate); pConfig->inputCfg.samplingRate);
@@ -268,7 +271,7 @@ int Equalizer_init(EqualizerContext *pContext)
pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
pContext->config.inputCfg.channels = CHANNEL_STEREO; pContext->config.inputCfg.channels = CHANNEL_STEREO;
pContext->config.inputCfg.format = PCM_FORMAT_S15; pContext->config.inputCfg.format = SAMPLE_FORMAT_PCM_S15;
pContext->config.inputCfg.samplingRate = 44100; pContext->config.inputCfg.samplingRate = 44100;
pContext->config.inputCfg.bufferProvider.getBuffer = NULL; pContext->config.inputCfg.bufferProvider.getBuffer = NULL;
pContext->config.inputCfg.bufferProvider.releaseBuffer = NULL; pContext->config.inputCfg.bufferProvider.releaseBuffer = NULL;
@@ -276,7 +279,7 @@ int Equalizer_init(EqualizerContext *pContext)
pContext->config.inputCfg.mask = EFFECT_CONFIG_ALL; pContext->config.inputCfg.mask = EFFECT_CONFIG_ALL;
pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE; pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
pContext->config.outputCfg.channels = CHANNEL_STEREO; pContext->config.outputCfg.channels = CHANNEL_STEREO;
pContext->config.outputCfg.format = PCM_FORMAT_S15; pContext->config.outputCfg.format = SAMPLE_FORMAT_PCM_S15;
pContext->config.outputCfg.samplingRate = 44100; pContext->config.outputCfg.samplingRate = 44100;
pContext->config.outputCfg.bufferProvider.getBuffer = NULL; pContext->config.outputCfg.bufferProvider.getBuffer = NULL;
pContext->config.outputCfg.bufferProvider.releaseBuffer = NULL; pContext->config.outputCfg.bufferProvider.releaseBuffer = NULL;
@@ -526,6 +529,7 @@ extern "C" int Equalizer_process(effect_interface_t self, audio_buffer_t *inBuff
} }
pContext->adapter.process(inBuffer->raw, outBuffer->raw, outBuffer->frameCount); pContext->adapter.process(inBuffer->raw, outBuffer->raw, outBuffer->frameCount);
return 0; return 0;
} // end Equalizer_process } // end Equalizer_process
@@ -589,6 +593,17 @@ extern "C" int Equalizer_command(effect_interface_t self, int cmdCode, int cmdSi
*(int *)pReplyData = android::Equalizer_setParameter(pEqualizer, (int32_t *)p->data, *(int *)pReplyData = android::Equalizer_setParameter(pEqualizer, (int32_t *)p->data,
p->data + p->psize); p->data + p->psize);
} break; } break;
case EFFECT_CMD_ENABLE:
case EFFECT_CMD_DISABLE:
if (pReplyData == NULL || *replySize != sizeof(int)) {
return -EINVAL;
}
*(int *)pReplyData = 0;
break;
case EFFECT_CMD_SET_DEVICE:
case EFFECT_CMD_SET_VOLUME:
case EFFECT_CMD_SET_AUDIO_MODE:
break;
default: default:
LOGW("Equalizer_command invalid command %d",cmdCode); LOGW("Equalizer_command invalid command %d",cmdCode);
return -EINVAL; return -EINVAL;

93
media/libeffects/EffectReverb.c
View File

@@ -24,8 +24,6 @@
#include "EffectReverb.h" #include "EffectReverb.h"
#include "EffectsMath.h" #include "EffectsMath.h"
static int gEffectIndex;
// effect_interface_t interface implementation for reverb effect // effect_interface_t interface implementation for reverb effect
const struct effect_interface_s gReverbInterface = { const struct effect_interface_s gReverbInterface = {
Reverb_Process, Reverb_Process,
@@ -37,7 +35,10 @@ static const effect_descriptor_t gAuxEnvReverbDescriptor = {
{0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}}, {0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}},
{0x1f0ae2e0, 0x4ef7, 0x11df, 0xbc09, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, {0x1f0ae2e0, 0x4ef7, 0x11df, 0xbc09, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
EFFECT_API_VERSION, EFFECT_API_VERSION,
EFFECT_FLAG_TYPE_AUXILIARY, // flags other than EFFECT_FLAG_TYPE_AUXILIARY set for test purpose
EFFECT_FLAG_TYPE_AUXILIARY | EFFECT_FLAG_DEVICE_IND | EFFECT_FLAG_AUDIO_MODE_IND,
0, // TODO
33,
"Aux Environmental Reverb", "Aux Environmental Reverb",
"Google Inc." "Google Inc."
}; };
@@ -48,6 +49,8 @@ static const effect_descriptor_t gInsertEnvReverbDescriptor = {
{0xaa476040, 0x6342, 0x11df, 0x91a4, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, {0xaa476040, 0x6342, 0x11df, 0x91a4, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
EFFECT_API_VERSION, EFFECT_API_VERSION,
EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST, EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST,
0, // TODO
33,
"Insert Environmental reverb", "Insert Environmental reverb",
"Google Inc." "Google Inc."
}; };
@@ -58,6 +61,8 @@ static const effect_descriptor_t gAuxPresetReverbDescriptor = {
{0x63909320, 0x53a6, 0x11df, 0xbdbd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, {0x63909320, 0x53a6, 0x11df, 0xbdbd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
EFFECT_API_VERSION, EFFECT_API_VERSION,
EFFECT_FLAG_TYPE_AUXILIARY, EFFECT_FLAG_TYPE_AUXILIARY,
0, // TODO
33,
"Aux Preset Reverb", "Aux Preset Reverb",
"Google Inc." "Google Inc."
}; };
@@ -68,6 +73,8 @@ static const effect_descriptor_t gInsertPresetReverbDescriptor = {
{0xd93dc6a0, 0x6342, 0x11df, 0xb128, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, {0xd93dc6a0, 0x6342, 0x11df, 0xb128, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
EFFECT_API_VERSION, EFFECT_API_VERSION,
EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST, EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST,
0, // TODO
33,
"Insert Preset Reverb", "Insert Preset Reverb",
"Google Inc." "Google Inc."
}; };
@@ -77,8 +84,7 @@ static const effect_descriptor_t * const gDescriptors[] = {
&gAuxEnvReverbDescriptor, &gAuxEnvReverbDescriptor,
&gInsertEnvReverbDescriptor, &gInsertEnvReverbDescriptor,
&gAuxPresetReverbDescriptor, &gAuxPresetReverbDescriptor,
&gInsertPresetReverbDescriptor, &gInsertPresetReverbDescriptor
NULL
}; };
/*---------------------------------------------------------------------------- /*----------------------------------------------------------------------------
@@ -88,25 +94,25 @@ static const effect_descriptor_t * const gDescriptors[] = {
/*--- Effect Library Interface Implementation ---*/ /*--- Effect Library Interface Implementation ---*/
int EffectQueryNumberEffects(uint32_t *pNumEffects) { int EffectQueryNumberEffects(uint32_t *pNumEffects) {
*pNumEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *) *pNumEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);
- 1;
gEffectIndex = 0;
return 0; return 0;
} }
int EffectQueryNext(effect_descriptor_t *pDescriptor) { int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor) {
if (pDescriptor == NULL) { if (pDescriptor == NULL) {
return -EINVAL; return -EINVAL;
} }
if (gDescriptors[gEffectIndex] == NULL) { if (index >= sizeof(gDescriptors) / sizeof(const effect_descriptor_t *)) {
return -ENOENT; return -EINVAL;
} }
memcpy(pDescriptor, gDescriptors[gEffectIndex++], memcpy(pDescriptor, gDescriptors[index],
sizeof(effect_descriptor_t)); sizeof(effect_descriptor_t));
return 0; return 0;
} }
int EffectCreate(effect_uuid_t *uuid, int EffectCreate(effect_uuid_t *uuid,
int32_t sessionId,
int32_t ioId,
effect_interface_t *pInterface) { effect_interface_t *pInterface) {
int ret; int ret;
int i; int i;
@@ -152,7 +158,7 @@ int EffectCreate(effect_uuid_t *uuid,
*pInterface = (effect_interface_t) module; *pInterface = (effect_interface_t) module;
LOGV("EffectLibCreateEffect %p", module); LOGV("EffectLibCreateEffect %p ,size %d", module, sizeof(reverb_module_t));
return 0; return 0;
} }
@@ -191,8 +197,23 @@ static int Reverb_Process(effect_interface_t self, audio_buffer_t *inBuffer, aud
//if bypassed or the preset forces the signal to be completely dry //if bypassed or the preset forces the signal to be completely dry
if (pReverb->m_bBypass) { if (pReverb->m_bBypass) {
if (inBuffer->raw != outBuffer->raw && !pReverb->m_Aux) { if (inBuffer->raw != outBuffer->raw) {
memcpy(outBuffer->raw, inBuffer->raw, outBuffer->frameCount * NUM_OUTPUT_CHANNELS * sizeof(int16_t)); int16_t smp;
pSrc = inBuffer->s16;
pDst = outBuffer->s16;
size_t count = inBuffer->frameCount;
if (pRvbModule->config.inputCfg.channels == pRvbModule->config.outputCfg.channels) {
count *= 2;
while (count--) {
*pDst++ = *pSrc++;
}
} else {
while (count--) {
smp = *pSrc++;
*pDst++ = smp;
*pDst++ = smp;
}
}
} }
return 0; return 0;
} }
@@ -226,10 +247,11 @@ static int Reverb_Process(effect_interface_t self, audio_buffer_t *inBuffer, aud
numSamples -= processedSamples; numSamples -= processedSamples;
if (pReverb->m_Aux) { if (pReverb->m_Aux) {
pDst += processedSamples; pSrc += processedSamples;
} else { } else {
pSrc += processedSamples * NUM_OUTPUT_CHANNELS; pSrc += processedSamples * NUM_OUTPUT_CHANNELS;
} }
pDst += processedSamples * NUM_OUTPUT_CHANNELS;
} }
return 0; return 0;
@@ -292,6 +314,35 @@ static int Reverb_Command(effect_interface_t self, int cmdCode, int cmdSize,
*(int *)pReplyData = Reverb_setParameter(pReverb, *(int32_t *)cmd->data, *(int *)pReplyData = Reverb_setParameter(pReverb, *(int32_t *)cmd->data,
cmd->vsize, cmd->data + sizeof(int32_t)); cmd->vsize, cmd->data + sizeof(int32_t));
break; break;
case EFFECT_CMD_ENABLE:
case EFFECT_CMD_DISABLE:
if (pReplyData == NULL || *replySize != sizeof(int)) {
return -EINVAL;
}
*(int *)pReplyData = 0;
break;
case EFFECT_CMD_SET_DEVICE:
if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) {
return -EINVAL;
}
LOGV("Reverb_Command EFFECT_CMD_SET_DEVICE: 0x%08x", *(uint32_t *)pCmdData);
break;
case EFFECT_CMD_SET_VOLUME: {
// audio output is always stereo => 2 channel volumes
if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t) * 2) {
return -EINVAL;
}
float left = (float)(*(uint32_t *)pCmdData) / (1 << 24);
float right = (float)(*((uint32_t *)pCmdData + 1)) / (1 << 24);
LOGV("Reverb_Command EFFECT_CMD_SET_VOLUME: left %f, right %f ", left, right);
break;
}
case EFFECT_CMD_SET_AUDIO_MODE:
if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) {
return -EINVAL;
}
LOGV("Reverb_Command EFFECT_CMD_SET_AUDIO_MODE: %d", *(uint32_t *)pCmdData);
break;
default: default:
LOGW("Reverb_Command invalid command %d",cmdCode); LOGW("Reverb_Command invalid command %d",cmdCode);
return -EINVAL; return -EINVAL;
@@ -339,7 +390,7 @@ int Reverb_Init(reverb_module_t *pRvbModule, int aux, int preset) {
} else { } else {
pRvbModule->config.inputCfg.channels = CHANNEL_STEREO; pRvbModule->config.inputCfg.channels = CHANNEL_STEREO;
} }
pRvbModule->config.inputCfg.format = PCM_FORMAT_S15; pRvbModule->config.inputCfg.format = SAMPLE_FORMAT_PCM_S15;
pRvbModule->config.inputCfg.bufferProvider.getBuffer = NULL; pRvbModule->config.inputCfg.bufferProvider.getBuffer = NULL;
pRvbModule->config.inputCfg.bufferProvider.releaseBuffer = NULL; pRvbModule->config.inputCfg.bufferProvider.releaseBuffer = NULL;
pRvbModule->config.inputCfg.bufferProvider.cookie = NULL; pRvbModule->config.inputCfg.bufferProvider.cookie = NULL;
@@ -347,7 +398,7 @@ int Reverb_Init(reverb_module_t *pRvbModule, int aux, int preset) {
pRvbModule->config.inputCfg.mask = EFFECT_CONFIG_ALL; pRvbModule->config.inputCfg.mask = EFFECT_CONFIG_ALL;
pRvbModule->config.outputCfg.samplingRate = 44100; pRvbModule->config.outputCfg.samplingRate = 44100;
pRvbModule->config.outputCfg.channels = CHANNEL_STEREO; pRvbModule->config.outputCfg.channels = CHANNEL_STEREO;
pRvbModule->config.outputCfg.format = PCM_FORMAT_S15; pRvbModule->config.outputCfg.format = SAMPLE_FORMAT_PCM_S15;
pRvbModule->config.outputCfg.bufferProvider.getBuffer = NULL; pRvbModule->config.outputCfg.bufferProvider.getBuffer = NULL;
pRvbModule->config.outputCfg.bufferProvider.releaseBuffer = NULL; pRvbModule->config.outputCfg.bufferProvider.releaseBuffer = NULL;
pRvbModule->config.outputCfg.bufferProvider.cookie = NULL; pRvbModule->config.outputCfg.bufferProvider.cookie = NULL;
@@ -391,8 +442,8 @@ int Reverb_Configure(reverb_module_t *pRvbModule, effect_config_t *pConfig,
if (pConfig->inputCfg.samplingRate if (pConfig->inputCfg.samplingRate
!= pConfig->outputCfg.samplingRate != pConfig->outputCfg.samplingRate
|| pConfig->outputCfg.channels != OUTPUT_CHANNELS || pConfig->outputCfg.channels != OUTPUT_CHANNELS
|| pConfig->inputCfg.format != PCM_FORMAT_S15 || pConfig->inputCfg.format != SAMPLE_FORMAT_PCM_S15
|| pConfig->outputCfg.format != PCM_FORMAT_S15) { || pConfig->outputCfg.format != SAMPLE_FORMAT_PCM_S15) {
LOGV("Reverb_Configure invalid config"); LOGV("Reverb_Configure invalid config");
return -EINVAL; return -EINVAL;
} }
@@ -1033,6 +1084,7 @@ int Reverb_setParameter(reverb_object_t *pReverb, int32_t param, size_t size,
// Convert milliseconds to => m_nRvbLpfFwd (function of m_nRvbLpfFbk) // Convert milliseconds to => m_nRvbLpfFwd (function of m_nRvbLpfFbk)
// convert ms to samples // convert ms to samples
value32 = (value32 * pReverb->m_nSamplingRate) / 1000; value32 = (value32 * pReverb->m_nSamplingRate) / 1000;
// calculate valid decay time range as a function of current reverb delay and // calculate valid decay time range as a function of current reverb delay and
// max feed back gain. Min value <=> -40dB in one pass, Max value <=> feedback gain = -1 dB // max feed back gain. Min value <=> -40dB in one pass, Max value <=> feedback gain = -1 dB
// Calculate attenuation for each round in late reverb given a total attenuation of -6000 millibels. // Calculate attenuation for each round in late reverb given a total attenuation of -6000 millibels.
@@ -1834,7 +1886,6 @@ static int ReverbUpdateRoom(reverb_object_t *pReverb, bool fullUpdate) {
//gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval; //gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval;
pReverb->m_nXfadeCounter = pReverb->m_nXfadeInterval + 1; // force update on first iteration pReverb->m_nXfadeCounter = pReverb->m_nXfadeInterval + 1; // force update on first iteration
pReverb->m_nCurrentRoom = pReverb->m_nNextRoom; pReverb->m_nCurrentRoom = pReverb->m_nNextRoom;
return 0; return 0;

4
media/libeffects/EffectReverb.h
View File

@@ -293,8 +293,8 @@ typedef struct reverb_module_s {
*------------------------------------ *------------------------------------
*/ */
int EffectQueryNumberEffects(uint32_t *pNumEffects); int EffectQueryNumberEffects(uint32_t *pNumEffects);
int EffectQueryNext(effect_descriptor_t *pDescriptor); int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor);
int EffectCreate(effect_uuid_t *effectUID, effect_interface_t *pInterface); int EffectCreate(effect_uuid_t *effectUID, int32_t sessionId, int32_t ioId, effect_interface_t *pInterface);
int EffectRelease(effect_interface_t interface); int EffectRelease(effect_interface_t interface);
static int Reverb_Process(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer); static int Reverb_Process(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer);

94
media/libeffects/EffectsFactory.c
View File

@@ -26,11 +26,16 @@
static list_elem_t *gEffectList; // list of effect_entry_t: all currently created effects static list_elem_t *gEffectList; // list of effect_entry_t: all currently created effects
static list_elem_t *gLibraryList; // list of lib_entry_t: all currently loaded libraries static list_elem_t *gLibraryList; // list of lib_entry_t: all currently loaded libraries
static pthread_mutex_t gLibLock = PTHREAD_MUTEX_INITIALIZER; // controls access to gLibraryList static pthread_mutex_t gLibLock = PTHREAD_MUTEX_INITIALIZER; // controls access to gLibraryList
static uint32_t gNumEffects; // total number number of effects
static list_elem_t *gCurLib; // current library in enumeration process static list_elem_t *gCurLib; // current library in enumeration process
static list_elem_t *gCurEffect; // current effect in enumeration process static list_elem_t *gCurEffect; // current effect in enumeration process
static uint32_t gCurEffectIdx; // current effect index in enumeration process
static const char * const gEffectLibPath = "/system/lib/soundfx"; // path to built-in effect libraries static const char * const gEffectLibPath = "/system/lib/soundfx"; // path to built-in effect libraries
static int gInitDone; // true is global initialization has been preformed static int gInitDone; // true is global initialization has been preformed
static int gNextLibId; // used by loadLibrary() to allocate unique library handles
static int gCanQueryEffect; // indicates that call to EffectQueryEffect() is valid, i.e. that the list of effects
// was not modified since last call to EffectQueryNumberEffects()
///////////////////////////////////////////////// /////////////////////////////////////////////////
// Local functions prototypes // Local functions prototypes
@@ -39,7 +44,8 @@ static int gInitDone; // true is global initialization has been preformed
static int init(); static int init();
static int loadLibrary(const char *libPath, int *handle); static int loadLibrary(const char *libPath, int *handle);
static int unloadLibrary(int handle); static int unloadLibrary(int handle);
static uint32_t numEffectModules(); static void resetEffectEnumeration();
static uint32_t updateNumEffects();
static int findEffect(effect_uuid_t *uuid, lib_entry_t **lib, effect_descriptor_t **desc); static int findEffect(effect_uuid_t *uuid, lib_entry_t **lib, effect_descriptor_t **desc);
static void dumpEffectDescriptor(effect_descriptor_t *desc, char *str, size_t len); static void dumpEffectDescriptor(effect_descriptor_t *desc, char *str, size_t len);
@@ -107,38 +113,53 @@ int EffectQueryNumberEffects(uint32_t *pNumEffects)
} }
pthread_mutex_lock(&gLibLock); pthread_mutex_lock(&gLibLock);
*pNumEffects = numEffectModules(); *pNumEffects = gNumEffects;
gCanQueryEffect = 1;
pthread_mutex_unlock(&gLibLock); pthread_mutex_unlock(&gLibLock);
LOGV("EffectQueryNumberEffects(): %d", *pNumEffects); LOGV("EffectQueryNumberEffects(): %d", *pNumEffects);
return ret; return ret;
} }
int EffectQueryNext(effect_descriptor_t *pDescriptor) int EffectQueryEffect(uint32_t index, effect_descriptor_t *pDescriptor)
{ {
int ret = init(); int ret = init();
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
if (pDescriptor == NULL) { if (pDescriptor == NULL ||
index >= gNumEffects) {
return -EINVAL; return -EINVAL;
} }
if (gCanQueryEffect == 0) {
return -ENOSYS;
}
pthread_mutex_lock(&gLibLock); pthread_mutex_lock(&gLibLock);
ret = -ENOENT; ret = -ENOENT;
if (index < gCurEffectIdx) {
resetEffectEnumeration();
}
while (gCurLib) { while (gCurLib) {
if (gCurEffect) { if (gCurEffect) {
if (index == gCurEffectIdx) {
memcpy(pDescriptor, gCurEffect->object, sizeof(effect_descriptor_t)); memcpy(pDescriptor, gCurEffect->object, sizeof(effect_descriptor_t));
gCurEffect = gCurEffect->next;
ret = 0; ret = 0;
break; break;
} else {
gCurEffect = gCurEffect->next;
gCurEffectIdx++;
}
} else { } else {
gCurLib = gCurLib->next; gCurLib = gCurLib->next;
gCurEffect = ((lib_entry_t *)gCurLib->object)->effects; gCurEffect = ((lib_entry_t *)gCurLib->object)->effects;
} }
} }
#if (LOG_NDEBUG == 0)
char str[256]; char str[256];
dumpEffectDescriptor(pDescriptor, str, 256); dumpEffectDescriptor(pDescriptor, str, 256);
LOGV("EffectQueryNext() desc:%s", str); LOGV("EffectQueryEffect() desc:%s", str);
#endif
pthread_mutex_unlock(&gLibLock); pthread_mutex_unlock(&gLibLock);
return ret; return ret;
} }
@@ -164,7 +185,7 @@ int EffectGetDescriptor(effect_uuid_t *uuid, effect_descriptor_t *pDescriptor)
return ret; return ret;
} }
int EffectCreate(effect_uuid_t *uuid, effect_interface_t *pInterface) int EffectCreate(effect_uuid_t *uuid, int32_t sessionId, int32_t ioId, effect_interface_t *pInterface)
{ {
list_elem_t *e = gLibraryList; list_elem_t *e = gLibraryList;
lib_entry_t *l = NULL; lib_entry_t *l = NULL;
@@ -198,9 +219,9 @@ int EffectCreate(effect_uuid_t *uuid, effect_interface_t *pInterface)
} }
// create effect in library // create effect in library
ret = l->createFx(uuid, &itfe); ret = l->createFx(uuid, sessionId, ioId, &itfe);
if (ret < 0) { if (ret != 0) {
LOGW("EffectCreate() library %s: could not create fx %s", l->path, d->name); LOGW("EffectCreate() library %s: could not create fx %s, error %d", l->path, d->name, ret);
goto exit; goto exit;
} }
@@ -282,7 +303,10 @@ int EffectLoadLibrary(const char *libPath, int *handle)
if (libPath == NULL) { if (libPath == NULL) {
return -EINVAL; return -EINVAL;
} }
return loadLibrary(libPath, handle);
ret = loadLibrary(libPath, handle);
updateNumEffects();
return ret;
} }
int EffectUnloadLibrary(int handle) int EffectUnloadLibrary(int handle)
@@ -292,7 +316,9 @@ int EffectUnloadLibrary(int handle)
return ret; return ret;
} }
return unloadLibrary(handle); ret = unloadLibrary(handle);
updateNumEffects();
return ret;
} }
int EffectIsNullUuid(effect_uuid_t *uuid) int EffectIsNullUuid(effect_uuid_t *uuid)
@@ -339,7 +365,7 @@ int init() {
} }
} }
closedir(dir); closedir(dir);
updateNumEffects();
gInitDone = 1; gInitDone = 1;
LOGV("init() done"); LOGV("init() done");
return 0; return 0;
@@ -350,7 +376,7 @@ int loadLibrary(const char *libPath, int *handle)
{ {
void *hdl; void *hdl;
effect_QueryNumberEffects_t queryNumFx; effect_QueryNumberEffects_t queryNumFx;
effect_QueryNextEffect_t queryFx; effect_QueryEffect_t queryFx;
effect_CreateEffect_t createFx; effect_CreateEffect_t createFx;
effect_ReleaseEffect_t releaseFx; effect_ReleaseEffect_t releaseFx;
uint32_t numFx; uint32_t numFx;
@@ -378,9 +404,9 @@ int loadLibrary(const char *libPath, int *handle)
ret = -ENODEV; ret = -ENODEV;
goto error; goto error;
} }
queryFx = (effect_QueryNextEffect_t)dlsym(hdl, "EffectQueryNext"); queryFx = (effect_QueryEffect_t)dlsym(hdl, "EffectQueryEffect");
if (queryFx == NULL) { if (queryFx == NULL) {
LOGW("could not get EffectQueryNext from lib %s", libPath); LOGW("could not get EffectQueryEffect from lib %s", libPath);
ret = -ENODEV; ret = -ENODEV;
goto error; goto error;
} }
@@ -409,7 +435,7 @@ int loadLibrary(const char *libPath, int *handle)
ret = -ENOMEM; ret = -ENOMEM;
goto error; goto error;
} }
ret = queryFx(d); ret = queryFx(fx, d);
if (ret == 0) { if (ret == 0) {
#if (LOG_NDEBUG==0) #if (LOG_NDEBUG==0)
char s[256]; char s[256];
@@ -434,8 +460,12 @@ int loadLibrary(const char *libPath, int *handle)
LOGW("Error querying effect # %d on lib %s", fx, libPath); LOGW("Error querying effect # %d on lib %s", fx, libPath);
} }
} }
pthread_mutex_lock(&gLibLock);
// add entry for library in gLibraryList // add entry for library in gLibraryList
l = malloc(sizeof(lib_entry_t)); l = malloc(sizeof(lib_entry_t));
l->id = ++gNextLibId;
l->handle = hdl; l->handle = hdl;
strncpy(l->path, libPath, PATH_MAX); strncpy(l->path, libPath, PATH_MAX);
l->createFx = createFx; l->createFx = createFx;
@@ -444,14 +474,13 @@ int loadLibrary(const char *libPath, int *handle)
pthread_mutex_init(&l->lock, NULL); pthread_mutex_init(&l->lock, NULL);
e = malloc(sizeof(list_elem_t)); e = malloc(sizeof(list_elem_t));
pthread_mutex_lock(&gLibLock);
e->next = gLibraryList; e->next = gLibraryList;
e->object = l; e->object = l;
gLibraryList = e; gLibraryList = e;
pthread_mutex_unlock(&gLibLock); pthread_mutex_unlock(&gLibLock);
LOGV("loadLibrary() linked library %p", l); LOGV("loadLibrary() linked library %p", l);
*handle = (int)hdl; *handle = l->id;
return 0; return 0;
@@ -480,7 +509,7 @@ int unloadLibrary(int handle)
el2 = NULL; el2 = NULL;
while (el1) { while (el1) {
l = (lib_entry_t *)el1->object; l = (lib_entry_t *)el1->object;
if (handle == (int)l->handle) { if (handle == l->id) {
if (el2) { if (el2) {
el2->next = el1->next; el2->next = el1->next;
} else { } else {
@@ -508,6 +537,7 @@ int unloadLibrary(int handle)
// disable all effects from this library // disable all effects from this library
pthread_mutex_lock(&l->lock); pthread_mutex_lock(&l->lock);
el1 = gEffectList; el1 = gEffectList;
while (el1) { while (el1) {
fx = (effect_entry_t *)el1->object; fx = (effect_entry_t *)el1->object;
@@ -523,17 +553,23 @@ int unloadLibrary(int handle)
return 0; return 0;
} }
void resetEffectEnumeration()
{
gCurLib = gLibraryList;
gCurEffect = NULL;
if (gCurLib) {
gCurEffect = ((lib_entry_t *)gCurLib->object)->effects;
}
gCurEffectIdx = 0;
}
uint32_t updateNumEffects() {
uint32_t numEffectModules() { list_elem_t *e;
list_elem_t *e = gLibraryList;
uint32_t cnt = 0; uint32_t cnt = 0;
// Reset pointers for EffectQueryNext() resetEffectEnumeration();
gCurLib = e;
if (e) { e = gLibraryList;
gCurEffect = ((lib_entry_t *)e->object)->effects;
}
while (e) { while (e) {
lib_entry_t *l = (lib_entry_t *)e->object; lib_entry_t *l = (lib_entry_t *)e->object;
list_elem_t *efx = l->effects; list_elem_t *efx = l->effects;
@@ -543,6 +579,8 @@ uint32_t numEffectModules() {
} }
e = e->next; e = e->next;
} }
gNumEffects = cnt;
gCanQueryEffect = 0;
return cnt; return cnt;
} }

3
media/libeffects/EffectsFactory.h
View File

@@ -20,7 +20,7 @@
#include <cutils/log.h> #include <cutils/log.h>
#include <pthread.h> #include <pthread.h>
#include <dirent.h> #include <dirent.h>
#include <media/EffectFactoryApi.h> #include <media/EffectsFactoryApi.h>
#if __cplusplus #if __cplusplus
@@ -35,6 +35,7 @@ typedef struct list_elem_s {
typedef struct lib_entry_s { typedef struct lib_entry_s {
char path[PATH_MAX]; char path[PATH_MAX];
void *handle; void *handle;
int id;
effect_CreateEffect_t createFx; effect_CreateEffect_t createFx;
effect_ReleaseEffect_t releaseFx; effect_ReleaseEffect_t releaseFx;
list_elem_t *effects; //list of effect_descriptor_t list_elem_t *effects; //list of effect_descriptor_t

4
media/libmedia/AudioEffect.cpp
View File

@@ -394,11 +394,11 @@ status_t AudioEffect::queryNumberEffects(uint32_t *numEffects)
return af->queryNumberEffects(numEffects); return af->queryNumberEffects(numEffects);
} }
status_t AudioEffect::queryNextEffect(effect_descriptor_t *descriptor) status_t AudioEffect::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
{ {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED; if (af == 0) return PERMISSION_DENIED;
return af->queryNextEffect(descriptor); return af->queryEffect(index, descriptor);
} }
status_t AudioEffect::getEffectDescriptor(effect_uuid_t *uuid, effect_descriptor_t *descriptor) status_t AudioEffect::getEffectDescriptor(effect_uuid_t *uuid, effect_descriptor_t *descriptor)

11
media/libmedia/IAudioFlinger.cpp
View File

@@ -67,7 +67,7 @@ enum {
LOAD_EFFECT_LIBRARY, LOAD_EFFECT_LIBRARY,
UNLOAD_EFFECT_LIBRARY, UNLOAD_EFFECT_LIBRARY,
QUERY_NUM_EFFECTS, QUERY_NUM_EFFECTS,
QUERY_NEXT_EFFECT, QUERY_EFFECT,
GET_EFFECT_DESCRIPTOR, GET_EFFECT_DESCRIPTOR,
CREATE_EFFECT CREATE_EFFECT
}; };
@@ -586,14 +586,15 @@ public:
return NO_ERROR; return NO_ERROR;
} }
virtual status_t queryNextEffect(effect_descriptor_t *pDescriptor) virtual status_t queryEffect(uint32_t index, effect_descriptor_t *pDescriptor)
{ {
if (pDescriptor == NULL) { if (pDescriptor == NULL) {
return BAD_VALUE; return BAD_VALUE;
} }
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor()); data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
status_t status = remote()->transact(QUERY_NEXT_EFFECT, data, &reply); data.writeInt32(index);
status_t status = remote()->transact(QUERY_EFFECT, data, &reply);
if (status != NO_ERROR) { if (status != NO_ERROR) {
return status; return status;
} }
@@ -980,10 +981,10 @@ status_t BnAudioFlinger::onTransact(
} }
return NO_ERROR; return NO_ERROR;
} }
case QUERY_NEXT_EFFECT: { case QUERY_EFFECT: {
CHECK_INTERFACE(IAudioFlinger, data, reply); CHECK_INTERFACE(IAudioFlinger, data, reply);
effect_descriptor_t desc; effect_descriptor_t desc;
status_t status = queryNextEffect(&desc); status_t status = queryEffect(data.readInt32(), &desc);
reply->writeInt32(status); reply->writeInt32(status);
if (status == NO_ERROR) { if (status == NO_ERROR) {
reply->write(&desc, sizeof(effect_descriptor_t)); reply->write(&desc, sizeof(effect_descriptor_t));