Fix issue 2667796: [Audio Effect Framework] Effect factory and libraries.
First effect factory and effect library API implementation.
Also added default effect libraries for reverb and equalizer effects.
These libraries are for functional test only and are not fine tuned with
regard to audio quality. They will probably be replaced by other implementations
before the release.
Change-Id: I6868f8612146ae282c64052765c61a52ec789ec8
diff --git a/include/media/AudioCommon.h b/include/media/AudioCommon.h
new file mode 100644
index 0000000..245d760
--- /dev/null
+++ b/include/media/AudioCommon.h
@@ -0,0 +1,80 @@
+/*
+ * 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_*/
diff --git a/include/media/AudioSystem.h b/include/media/AudioSystem.h
index d0ccc505..9caef8f 100644
--- a/include/media/AudioSystem.h
+++ b/include/media/AudioSystem.h
@@ -20,6 +20,7 @@
#include <utils/RefBase.h>
#include <utils/threads.h>
#include <media/IAudioFlinger.h>
+#include <media/AudioCommon.h>
namespace android {
@@ -50,8 +51,8 @@
// Audio sub formats (see AudioSystem::audio_format).
enum pcm_sub_format {
- PCM_SUB_16_BIT = 0x1, // must be 1 for backward compatibility
- PCM_SUB_8_BIT = 0x2, // must be 2 for backward compatibility
+ PCM_SUB_16_BIT = PCM_FORMAT_S15, // must be 1 for backward compatibility
+ PCM_SUB_8_BIT = PCM_FORMAT_U8, // 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
@@ -103,26 +104,21 @@
// Channel mask definitions must be kept in sync with JAVA values in /media/java/android/media/AudioFormat.java
enum audio_channels {
// output channels
- CHANNEL_OUT_FRONT_LEFT = 0x4,
- CHANNEL_OUT_FRONT_RIGHT = 0x8,
- CHANNEL_OUT_FRONT_CENTER = 0x10,
- CHANNEL_OUT_LOW_FREQUENCY = 0x20,
- CHANNEL_OUT_BACK_LEFT = 0x40,
- CHANNEL_OUT_BACK_RIGHT = 0x80,
- CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x100,
- CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x200,
- CHANNEL_OUT_BACK_CENTER = 0x400,
- CHANNEL_OUT_MONO = CHANNEL_OUT_FRONT_LEFT,
- CHANNEL_OUT_STEREO = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT),
- CHANNEL_OUT_QUAD = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
- CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
- CHANNEL_OUT_SURROUND = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
- 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_FRONT_LEFT = CHANNEL_FRONT_LEFT,
+ CHANNEL_OUT_FRONT_RIGHT = CHANNEL_FRONT_RIGHT,
+ CHANNEL_OUT_FRONT_CENTER = CHANNEL_FRONT_CENTER,
+ CHANNEL_OUT_LOW_FREQUENCY = CHANNEL_LOW_FREQUENCY,
+ CHANNEL_OUT_BACK_LEFT = CHANNEL_BACK_LEFT,
+ CHANNEL_OUT_BACK_RIGHT = CHANNEL_BACK_RIGHT,
+ CHANNEL_OUT_FRONT_LEFT_OF_CENTER = CHANNEL_FRONT_LEFT_OF_CENTER,
+ CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = CHANNEL_FRONT_RIGHT_OF_CENTER,
+ CHANNEL_OUT_BACK_CENTER = CHANNEL_BACK_CENTER,
+ CHANNEL_OUT_MONO = CHANNEL_MONO,
+ CHANNEL_OUT_STEREO = CHANNEL_STEREO,
+ CHANNEL_OUT_QUAD = CHANNEL_QUAD,
+ CHANNEL_OUT_SURROUND = CHANNEL_SURROUND,
+ CHANNEL_OUT_5POINT1 = CHANNEL_5POINT1,
+ CHANNEL_OUT_7POINT1 = CHANNEL_7POINT1,
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_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER | CHANNEL_OUT_BACK_CENTER),
@@ -240,17 +236,17 @@
enum audio_devices {
// output devices
- DEVICE_OUT_EARPIECE = 0x1,
- DEVICE_OUT_SPEAKER = 0x2,
- DEVICE_OUT_WIRED_HEADSET = 0x4,
- DEVICE_OUT_WIRED_HEADPHONE = 0x8,
- DEVICE_OUT_BLUETOOTH_SCO = 0x10,
- DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
- DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
- DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
- DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
- DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
- DEVICE_OUT_AUX_DIGITAL = 0x400,
+ DEVICE_OUT_EARPIECE = DEVICE_EARPIECE,
+ DEVICE_OUT_SPEAKER = DEVICE_SPEAKER,
+ DEVICE_OUT_WIRED_HEADSET = DEVICE_WIRED_HEADSET,
+ DEVICE_OUT_WIRED_HEADPHONE = DEVICE_WIRED_HEADPHONE,
+ DEVICE_OUT_BLUETOOTH_SCO = DEVICE_BLUETOOTH_SCO,
+ DEVICE_OUT_BLUETOOTH_SCO_HEADSET = DEVICE_BLUETOOTH_SCO_HEADSET,
+ DEVICE_OUT_BLUETOOTH_SCO_CARKIT = DEVICE_BLUETOOTH_SCO_CARKIT,
+ DEVICE_OUT_BLUETOOTH_A2DP = DEVICE_BLUETOOTH_A2DP,
+ DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = DEVICE_BLUETOOTH_A2DP_HEADPHONES,
+ DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = DEVICE_BLUETOOTH_A2DP_SPEAKER,
+ DEVICE_OUT_AUX_DIGITAL = DEVICE_AUX_DIGITAL,
DEVICE_OUT_DEFAULT = 0x8000,
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 |
diff --git a/include/media/EffectApi.h b/include/media/EffectApi.h
new file mode 100644
index 0000000..a1bc3b82
--- /dev/null
+++ b/include/media/EffectApi.h
@@ -0,0 +1,555 @@
+/*
+ * 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_EFFECTAPI_H_
+#define ANDROID_EFFECTAPI_H_
+
+#include <errno.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <media/AudioCommon.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+/////////////////////////////////////////////////
+// Effect control interface
+/////////////////////////////////////////////////
+
+// The effect control interface is exposed by each effect engine implementation. It consists of
+// a set of functions controlling the configuration, activation and process of the engine.
+// The functions are grouped in a structure of type effect_interface_s:
+// struct effect_interface_s {
+// effect_process_t process;
+// effect_command_t command;
+// };
+
+
+// effect_interface_t: Effect control interface handle.
+// The effect_interface_t serves two purposes regarding the implementation of the effect engine:
+// - 1 it is the address of a pointer to an effect_interface_s structure where the functions
+// of the effect control API for a particular effect are located.
+// - 2 it is the address of the context of a particular effect instance.
+// A typical implementation in the effect library would define a structure as follows:
+// struct effect_module_s {
+// const struct effect_interface_s *itfe;
+// effect_config_t config;
+// effect_context_t context;
+// }
+// The implementation of EffectCreate() function would then allocate a structure of this
+// type and return its address as effect_interface_t
+typedef struct effect_interface_s **effect_interface_t;
+
+
+// Effect API version 1.0
+#define EFFECT_API_VERSION 0x0100 // Format 0xMMmm MM: Major version, mm: minor version
+
+// Maximum length of character strings in structures defines by this API.
+#define EFFECT_STRING_LEN_MAX 64
+
+//
+//--- 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)
+// 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
+// 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.
+typedef struct effect_uuid_s {
+ uint32_t timeLow;
+ uint16_t timeMid;
+ uint16_t timeHiAndVersion;
+ uint16_t clockSeq;
+ uint8_t node[6];
+} effect_uuid_t;
+
+// NULL UUID definition (matches SL_IID_NULL_)
+#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;
+const effect_uuid_t * const EFFECT_UUID_NULL = &EFFECT_UUID_NULL_;
+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
+// engines present in a library.
+typedef struct effect_descriptor_s {
+ effect_uuid_t type; // UUID corresponding to the OpenSL ES interface implemented by this effect
+ effect_uuid_t uuid; // UUID for this particular implementation
+ uint16_t apiVersion; // Version of the effect API implemented: must match current EFFECT_API_VERSION
+ uint32_t flags; // effect engine capabilities/requirements flags (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;
+
+// definitions for flags field of effect descriptor.
+// +---------------------------+-----------+-----------------------------------
+// | description | bits | values
+// +---------------------------+-----------+-----------------------------------
+// | connection mode | 0..1 | 0 insert: after track process
+// | | | 1 auxiliary: connect to track auxiliary
+// | | | output and use send level
+// | | | 2 replace: replaces track process function;
+// | | | must implement SRC, volume and mono to stereo.
+// | | | 3 reserved
+// +---------------------------+-----------+-----------------------------------
+// | insertion preference | 2..4 | 0 none
+// | | | 1 first of the chain
+// | | | 2 last of the chain
+// | | | 3 exclusive (only effect in the insert chain)
+// | | | 4..7 reserved
+// +---------------------------+-----------+-----------------------------------
+// | Volume management | 5..6 | 0 none
+// | | | 1 implements volume control
+// | | | 2..3 reserved
+// +---------------------------+-----------+-----------------------------------
+// | Device management | 7..8 | 0 none
+// | | | 1 requires device updates
+// | | | 2..3 reserved
+// +---------------------------+-----------+-----------------------------------
+// | Sample input mode | 9..10 | 0 direct: process() function or EFFECT_CMD_CONFIGURE
+// | | | command must specify a buffer descriptor
+// | | | 1 provider: process() function uses the
+// | | | bufferProvider indicated by the
+// | | | EFFECT_CMD_CONFIGURE command to request input buffers.
+// | | | 2 both: both input modes are supported
+// | | | 3 reserved
+// +---------------------------+-----------+-----------------------------------
+// | Sample output mode | 11..12 | 0 direct: process() function or EFFECT_CMD_CONFIGURE
+// | | | command must specify a buffer descriptor
+// | | | 1 provider: process() function uses the
+// | | | bufferProvider indicated by the
+// | | | EFFECT_CMD_CONFIGURE command to request output buffers.
+// | | | 2 both: both output modes are supported
+// | | | 3 reserved
+// +---------------------------+-----------+-----------------------------------
+
+// insert mode
+#define EFFECT_FLAG_TYPE_MASK 0x00000003
+#define EFFECT_FLAG_TYPE_INSERT 0x00000000
+#define EFFECT_FLAG_TYPE_AUXILIARY 0x00000001
+#define EFFECT_FLAG_TYPE_REPLACE 0x00000002
+
+// insert preference
+#define EFFECT_FLAG_INSERT_MASK 0x0000001C
+#define EFFECT_FLAG_INSERT_ANY 0x00000000
+#define EFFECT_FLAG_INSERT_FIRST 0x00000004
+#define EFFECT_FLAG_INSERT_LAST 0x00000008
+#define EFFECT_FLAG_INSERT_EXCLUSIVE 0x0000000C
+
+
+// volume control
+#define EFFECT_FLAG_VOLUME_MASK 0x00000060
+#define EFFECT_FLAG_VOLUME_CTRL 0x00000020
+#define EFFECT_FLAG_VOLUME_NONE 0x00000000
+
+// device control
+#define EFFECT_FLAG_DEVICE_MASK 0x00000180
+#define EFFECT_FLAG_DEVICE_IND 0x00000080
+#define EFFECT_FLAG_DEVICE_NONE 0x00000000
+
+// sample input modes
+#define EFFECT_FLAG_INPUT_MASK 0x00000600
+#define EFFECT_FLAG_INPUT_DIRECT 0x00000000
+#define EFFECT_FLAG_INPUT_PROVIDER 0x00000200
+#define EFFECT_FLAG_INPUT_BOTH 0x00000400
+
+// sample output modes
+#define EFFECT_FLAG_OUTPUT_MASK 0x00001800
+#define EFFECT_FLAG_OUTPUT_DIRECT 0x00000000
+#define EFFECT_FLAG_OUTPUT_PROVIDER 0x00000800
+#define EFFECT_FLAG_OUTPUT_BOTH 0x00001000
+
+// forward definition of type audio_buffer_t
+typedef struct audio_buffer_s audio_buffer_t;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: process
+//
+// Description: Effect process function. Takes input samples as specified
+// (count and location) in input buffer descriptor and output processed
+// samples as specified in output buffer descriptor. If the buffer descriptor
+// is not specified the function must use either the buffer or the
+// buffer provider function installed by the EFFECT_CMD_CONFIGURE command.
+//
+// NOTE: the process() function implementation should be "real-time safe" that is
+// it should not perform blocking calls: malloc/free, sleep, read/write/open/close,
+// pthread_cond_wait/pthread_mutex_lock...
+//
+// Input:
+// effect_interface_t: handle to the effect interface this function
+// is called on.
+// inBuffer: buffer descriptor indicating where to read samples to process.
+// If NULL, use the configuration passed by EFFECT_CMD_CONFIGURE command.
+//
+// inBuffer: buffer descriptor indicating where to write processed samples.
+// If NULL, use the configuration passed by EFFECT_CMD_CONFIGURE command.
+//
+// Output:
+// returned value: 0 successful operation
+// -EINVAL invalid interface handle or
+// invalid input/output buffer description
+////////////////////////////////////////////////////////////////////////////////
+typedef int32_t (*effect_process_t)(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: command
+//
+// Description: Send a command and receive a response to/from effect engine.
+//
+// Input:
+// effect_interface_t: handle to the effect interface this function
+// is called on.
+// cmdCode: command code: the command can be a standardized command defined in
+// effect_command_e (see below) or a proprietary command.
+// cmdSize: size of command in bytes
+// pCmdData: pointer to command data
+// pReplyData: pointer to reply data
+//
+// Input/Output:
+// replySize: maximum size of reply data as input
+// actual size of reply data as output
+//
+// Output:
+// returned value: 0 successful operation
+// -EINVAL invalid interface handle or
+// invalid command/reply size or format according to command code
+// The return code should be restricted to indicate problems related to the this
+// API specification. Status related to the execution of a particular command should be
+// indicated as part of the reply field.
+//
+// *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);
+
+
+// Effect control interface definition
+struct effect_interface_s {
+ effect_process_t process;
+ effect_command_t command;
+};
+
+
+//--- 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
+// | The engine must return the | | 8.24 fixed point format | 8.24 fixed point format
+// | volume that should be applied | | |
+// | before the effect is processed | | |
+// | The overall volume (the volume | | |
+// | 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 {
+ EFFECT_CMD_INIT, // initialize effect engine
+ EFFECT_CMD_CONFIGURE, // configure effect engine (see effect_config_t)
+ EFFECT_CMD_RESET, // reset effect engine
+ EFFECT_CMD_ENABLE, // enable effect process
+ EFFECT_CMD_DISABLE, // disable effect process
+ EFFECT_CMD_SET_PARAM, // set parameter immediately (see effect_param_t)
+ EFFECT_CMD_SET_PARAM_DEFERRED, // set parameter deferred
+ EFFECT_CMD_SET_PARAM_COMMIT, // commit previous set parameter deferred
+ EFFECT_CMD_GET_PARAM, // get parameter
+ EFFECT_CMD_SET_DEVICE, // set audio device (see audio_device_e in AudioCommon.h)
+ EFFECT_CMD_SET_VOLUME, // set volume
+ 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
+// channel mask definition in audio_channels_e (AudioCommon.h) e.g :
+// Stereo: left, 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
+// channels at a given time
+struct audio_buffer_s {
+ size_t frameCount; // number of frames in buffer
+ union {
+ void* raw; // raw pointer to start of buffer
+ int32_t* s32; // pointer to signed 32 bit data at start of buffer
+ int16_t* s16; // pointer to signed 16 bit data at start of buffer
+ uint8_t* u8; // pointer to unsigned 8 bit data at start of buffer
+ };
+};
+
+// the buffer_provider_s structure contains functions that can be used
+// by the effect engine process() function to query and release input
+// or output audio buffer.
+// The getBuffer() function is called to retrieve a buffer where data
+// should read from or written to by process() function.
+// The releaseBuffer() function MUST be called when the buffer retrieved
+// with getBuffer() is not needed anymore.
+// The process function should use the buffer provider mechanism to retrieve
+// input or output buffer if the inBuffer or outBuffer passed as argument is NULL
+// and the buffer configuration (buffer_config_t) given by the EFFECT_CMD_CONFIGURE
+// command did not specify an audio buffer.
+
+typedef int32_t (* buffer_function_t)(void *cookie, audio_buffer_t *buffer);
+
+typedef struct buffer_provider_s {
+ buffer_function_t getBuffer; // retrieve next buffer
+ buffer_function_t releaseBuffer; // release used buffer
+ void *cookie; // for use by client of buffer provider functions
+} buffer_provider_t;
+
+// 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
+// structure that defines both input and output buffer configurations and is
+// passed by the EFFECT_CMD_CONFIGURE command.
+typedef struct buffer_config_s {
+ audio_buffer_t buffer; // buffer for use by process() function is not passed explicitly
+ uint32_t samplingRate; // sampling rate
+ uint32_t channels; // channel mask (see audio_channels_e in AudioCommon.h)
+ buffer_provider_t bufferProvider; // buffer provider
+ uint8_t format; // PCM format (see audio_format_e in AudioCommon.h)
+ uint8_t accessMode; // read/write or accumulate in buffer (effect_buffer_access_e)
+ uint16_t mask; // indicates which of the above fields is valid
+} buffer_config_t;
+
+// values for "accessMode" field of buffer_config_t:
+// overwrite, read only, accumulate (read/modify/write)
+enum effect_buffer_access_e {
+ EFFECT_BUFFER_ACCESS_WRITE,
+ EFFECT_BUFFER_ACCESS_READ,
+ EFFECT_BUFFER_ACCESS_ACCUMULATE
+
+};
+
+// 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
+#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_CHANNELS 0x0004 // channels field must be taken into account
+#define EFFECT_CONFIG_FORMAT 0x0008 // format field must be taken into account
+#define EFFECT_CONFIG_ACC_MODE 0x0010 // accessMode field must be taken into account
+#define EFFECT_CONFIG_PROVIDER 0x0020 // bufferProvider field must be taken into account
+#define EFFECT_CONFIG_ALL (EFFECT_CONFIG_BUFFER | EFFECT_CONFIG_SMP_RATE | \
+ EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT | \
+ 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.
+typedef struct effect_config_s {
+ buffer_config_t inputCfg;
+ buffer_config_t outputCfg;;
+} effect_config_t;
+
+// 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.
+// psize and vsize represent the actual size of parameter and value.
+//
+// NOTE: the start of value field inside the data field is always on a 32 bit boundary:
+//
+// +-----------+
+// | status | sizeof(int)
+// +-----------+
+// | psize | sizeof(int)
+// +-----------+
+// | vsize | sizeof(int)
+// +-----------+
+// | | | |
+// ~ parameter ~ > psize |
+// | | | > ((psize - 1)/sizeof(int) + 1) * sizeof(int)
+// +-----------+ |
+// | padding | |
+// +-----------+
+// | | |
+// ~ value ~ > vsize
+// | | |
+// +-----------+
+
+typedef struct effect_param_s {
+ int32_t status; // Transaction status (unused for command, used for reply)
+ uint32_t psize; // Parameter size
+ uint32_t vsize; // Value size
+ char data[]; // Start of Parameter + Value data
+} effect_param_t;
+
+
+/////////////////////////////////////////////////
+// Effect library interface
+/////////////////////////////////////////////////
+
+// An effect library is required to implement and expose the following functions
+// to enable effect enumeration and instantiation. The name of these functions must be as
+// specified here as the effect framework will get the function address with dlsym():
+//
+// - effect_QueryNumberEffects_t EffectQueryNumberEffects;
+// - effect_QueryNextEffect_t EffectQueryNext;
+// - effect_CreateEffect_t EffectCreate;
+// - effect_ReleaseEffect_t EffectRelease;
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectQueryNumberEffects
+//
+// Description: Returns the number of different effect exposed by the
+// library. Each effect must have a unique effect uuid (see
+// effect_descriptor_t). This function together with EffectQueryNext()
+// 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:
+// pNumEffects: address where the number of effects should be returned.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV library failed to initialize
+// -EINVAL invalid pNumEffects
+// *pNumEffects: updated with number of effects in library
+//
+////////////////////////////////////////////////////////////////////////////////
+typedef int32_t (*effect_QueryNumberEffects_t)(int32_t *pNumEffects);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectQueryNext
+//
+// Description: Returns a descriptor of the next available effect.
+// See effect_descriptor_t for details on effect descriptors.
+// This function together with EffectQueryNext() is used to enumerate all
+// effects present in the library. The enumeration sequence is:
+// EffectQueryNumberEffects(&num_effects);
+// while (num_effects--)
+// EffectQueryNext();
+//
+// Input/Output:
+// pDescriptor: address where to return the effect descriptor.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV library failed to initialize
+// -EINVAL invalid pDescriptor
+// -ENOENT no more effect available
+// *pDescriptor: updated with the effect descriptor.
+//
+////////////////////////////////////////////////////////////////////////////////
+typedef int32_t (*effect_QueryNextEffect_t)(effect_descriptor_t *pDescriptor);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectCreate
+//
+// Description: Creates an effect engine of the specified type and returns an
+// effect control interface on this engine. The function will allocate the
+// resources for an instance of the requested effect engine and return
+// a handle on the effect control interface.
+//
+// Input:
+// pEffectUuid: pointer to the effect uuid.
+//
+// Input/Output:
+// pInterface: address where to return the effect interface.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV library failed to initialize
+// -EINVAL invalid pEffectUuid or pInterface
+// -ENOENT No effect with this uuid found
+// *pInterface: updated with the effect interface handle.
+//
+////////////////////////////////////////////////////////////////////////////////
+typedef int32_t (*effect_CreateEffect_t)(effect_uuid_t *uuid, effect_interface_t *pInterface);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectRelease
+//
+// Description: Releases the effect engine whose handle is given as argument.
+// All resources allocated to this particular instance of the effect are
+// released.
+//
+// Input:
+// interface: handle on the effect interface to be released.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV library failed to initialize
+// -EINVAL invalid interface handle
+//
+////////////////////////////////////////////////////////////////////////////////
+typedef int32_t (*effect_ReleaseEffect_t)(effect_interface_t interface);
+
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECTAPI_H_*/
diff --git a/include/media/EffectEqualizerApi.h b/include/media/EffectEqualizerApi.h
new file mode 100644
index 0000000..e3069d5
--- /dev/null
+++ b/include/media/EffectEqualizerApi.h
@@ -0,0 +1,50 @@
+/*
+ * 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_EFFECTEQUALIZERAPI_H_
+#define ANDROID_EFFECTEQUALIZERAPI_H_
+
+#include <media/EffectApi.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+//TODO replace by openSL ES include when available
+static const effect_uuid_t SL_IID_EQUALIZER_ = { 0x0bed4300, 0xddd6, 0x11db, 0x8f34, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+const effect_uuid_t * const SL_IID_EQUALIZER = &SL_IID_EQUALIZER_;
+
+/* enumerated parameters for Equalizer effect */
+typedef enum
+{
+ EQ_PARAM_NUM_BANDS, // Gets the number of frequency bands that the equalizer supports.
+ EQ_PARAM_LEVEL_RANGE, // Returns the minimum and maximum band levels supported.
+ EQ_PARAM_BAND_LEVEL, // Gets/Sets the gain set for the given equalizer band.
+ EQ_PARAM_CENTER_FREQ, // Gets the center frequency of the given band.
+ EQ_PARAM_BAND_FREQ_RANGE, // Gets the frequency range of the given frequency band.
+ EQ_PARAM_GET_BAND, // Gets the band that has the most effect on the given frequency.
+ EQ_PARAM_CUR_PRESET, // Gets/Sets the current preset.
+ EQ_PARAM_GET_NUM_OF_PRESETS, // Gets the total number of presets the equalizer supports.
+ EQ_PARAM_GET_PRESET_NAME // Gets the preset name based on the index.
+} t_equalizer_params;
+
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECTEQUALIZERAPI_H_*/
diff --git a/include/media/EffectFactoryApi.h b/include/media/EffectFactoryApi.h
new file mode 100644
index 0000000..8179c234
--- /dev/null
+++ b/include/media/EffectFactoryApi.h
@@ -0,0 +1,214 @@
+/*
+ * 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_EFFECTFACTORYAPI_H_
+#define ANDROID_EFFECTFACTORYAPI_H_
+
+#include <errno.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <media/EffectApi.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+/////////////////////////////////////////////////
+// Effect factory interface
+/////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectQueryNumberEffects
+//
+// Description: Returns the number of different effect in all loaded libraries.
+// Each effect must have a different effect uuid (see
+// effect_descriptor_t). This function together with EffectQueryNext()
+// is used to enumerate all effects present in all loaded libraries.
+// Each time EffectQueryNumberEffects() is called, the factory must
+// reset the index of the effect descriptor returned by next call to
+// EffectQueryNext() to restart enumeration from the beginning.
+//
+// Input/Output:
+// pNumEffects: address where the number of effects should be returned.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV factory failed to initialize
+// -EINVAL invalid pNumEffects
+// *pNumEffects: updated with number of effects in factory
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectQueryNumberEffects(int *pNumEffects);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectQueryNext
+//
+// Description: Returns a descriptor of the next available effect.
+// See effect_descriptor_t for a details on effect descriptor.
+// This function together with EffectQueryNext() is used to enumerate all
+// effects present in all loaded libraries. The enumeration sequence is:
+// EffectQueryNumberEffects(&num_effects);
+// while (num_effects--)
+// EffectQueryNext();
+//
+// Input/Output:
+// pDescriptor: address where to return the effect descriptor.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV factory failed to initialize
+// -EINVAL invalid pDescriptor
+// -ENOENT no more effect available
+// *pDescriptor: updated with the effect descriptor.
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectQueryNext(effect_descriptor_t *pDescriptor);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectCreate
+//
+// Description: Creates an effect engine of the specified type and returns an
+// effect control interface on this engine. The function will allocate the
+// resources for an instance of the requested effect engine and return
+// a handler on the effect control interface.
+//
+// Input:
+// pEffectUuid: pointer to the effect uuid.
+//
+// Input/Output:
+// pInterface: address where to return the effect interface.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV factory failed to initialize
+// -EINVAL invalid pEffectUuid or pInterface
+// -ENOENT No effect with this uuid found
+// *pInterface: updated with the effect interface.
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectCreate(effect_uuid_t *pEffectUuid, effect_interface_t *pInterface);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectRelease
+//
+// Description: Releases the effect engine whose handler is given as argument.
+// All resources allocated to this particular instance of the effect are
+// released.
+//
+// Input:
+// interface: handler on the effect interface to be released.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV factory failed to initialize
+// -EINVAL invalid interface handler
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectRelease(effect_interface_t interface);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectLoadLibrary
+//
+// Description: Loads the effect library which path is given as first argument.
+// This must be the full path of a dynamic library (.so) implementing one or
+// more effect engines and exposing the effect library interface described in
+// EffectApi.h. The function returns a handle on the library for used by
+// further call to EffectUnloadLibrary() to unload the library.
+//
+// Input:
+// libPath: full path of the dynamic library file in the file system.
+//
+// handle: address where to return the library handle
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV Effect factory not initialized or
+// library could not be loaded or
+// library does not implement required functions
+// -EINVAL invalid libPath string or handle
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectLoadLibrary(const char *libPath, int *handle);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectUnloadLibrary
+//
+// Description: Unloads the effect library which handle is given as argument.
+//
+// Input:
+// handle: library handle
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV Effect factory not initialized
+// -ENOENT invalid handle
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectUnloadLibrary(int handle);
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectGetDescriptor
+//
+// Description: Returns the descriptor of the effect which uuid is pointed
+// to by first argument.
+//
+// Input:
+// pEffectUuid: pointer to the effect uuid.
+//
+// Input/Output:
+// pDescriptor: address where to return the effect descriptor.
+//
+// Output:
+// returned value: 0 successful operation.
+// -ENODEV factory failed to initialize
+// -EINVAL invalid pEffectUuid or pDescriptor
+// -ENOENT No effect with this uuid found
+// *pDescriptor: updated with the effect descriptor.
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectGetDescriptor(effect_uuid_t *pEffectUuid, effect_descriptor_t *pDescriptor);
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Function: EffectIsNullUuid
+//
+// Description: Helper function to compare effect uuid to EFFECT_UUID_NULL
+//
+// Input:
+// pEffectUuid: pointer to effect uuid to compare to EFFECT_UUID_NULL.
+//
+// Output:
+// returned value: 0 if uuid is different from EFFECT_UUID_NULL.
+// 1 if uuid is equal to EFFECT_UUID_NULL.
+//
+////////////////////////////////////////////////////////////////////////////////
+int EffectIsNullUuid(effect_uuid_t *pEffectUuid);
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECTFACTORYAPI_H_*/
diff --git a/include/media/EffectReverbApi.h b/include/media/EffectReverbApi.h
new file mode 100644
index 0000000..6371adb
--- /dev/null
+++ b/include/media/EffectReverbApi.h
@@ -0,0 +1,82 @@
+/*
+ * 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_EFFECTREVERBAPI_H_
+#define ANDROID_EFFECTREVERBAPI_H_
+
+#include <media/EffectApi.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+// TODO: include OpenSLES_IID.h instead
+static const effect_uuid_t SL_IID_ENVIRONMENTALREVERB_ = { 0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, { 0x4e, 0x23, 0x4d, 0x6, 0x83, 0x9e } };
+const effect_uuid_t * const SL_IID_ENVIRONMENTALREVERB = &SL_IID_ENVIRONMENTALREVERB_;
+
+static const effect_uuid_t SL_IID_PRESETREVERB_ = { 0x47382d60, 0xddd8, 0x11db, 0xbf3a, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+const effect_uuid_t * const SL_IID_PRESETREVERB = &SL_IID_PRESETREVERB_;
+
+/* enumerated parameter settings for Reverb effect */
+typedef enum
+{
+ REVERB_PARAM_BYPASS,
+ REVERB_PARAM_PRESET,
+ // Parameters below are as defined in OpenSL ES specification for environmental reverb interface
+ REVERB_PARAM_ROOM_LEVEL, // in millibels, range -6000 to 0
+ REVERB_PARAM_ROOM_HF_LEVEL, // in millibels, range -4000 to 0
+ REVERB_PARAM_DECAY_TIME, // in milliseconds, range 100 to 20000
+ REVERB_PARAM_DECAY_HF_RATIO, // in permilles, range 100 to 1000
+ REVERB_PARAM_REFLECTIONS_LEVEL, // in millibels, range -6000 to 0
+ REVERB_PARAM_REFLECTIONS_DELAY, // in milliseconds, range 0 to 65
+ REVERB_PARAM_REVERB_LEVEL, // in millibels, range -6000 to 0
+ REVERB_PARAM_REVERB_DELAY, // in milliseconds, range 0 to 65
+ REVERB_PARAM_DIFFUSION, // in permilles, range 0 to 1000
+ REVERB_PARAM_DENSITY, // in permilles, range 0 to 1000
+ REVERB_PARAM_PROPERTIES
+} t_reverb_params;
+
+
+typedef enum
+{
+ REVERB_PRESET_LARGE_HALL,
+ REVERB_PRESET_HALL,
+ REVERB_PRESET_CHAMBER,
+ REVERB_PRESET_ROOM,
+} t_reverb_presets;
+
+//t_reverb_properties is equal to SLEnvironmentalReverbSettings defined in OpenSL ES specification.
+typedef struct s_reverb_properties {
+ int16_t roomLevel;
+ int16_t roomHFLevel;
+ int32_t decayTime;
+ int16_t decayHFRatio;
+ int16_t reflectionsLevel;
+ int32_t reflectionsDelay;
+ int32_t reverbDelay;
+ int16_t reverbLevel;
+ int16_t diffusion;
+ int16_t density;
+ int16_t padding;
+} t_reverb_properties;
+
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECTREVERBAPI_H_*/
diff --git a/media/libeffects/Android.mk b/media/libeffects/Android.mk
new file mode 100644
index 0000000..ff21454
--- /dev/null
+++ b/media/libeffects/Android.mk
@@ -0,0 +1,90 @@
+LOCAL_PATH:= $(call my-dir)
+
+# Effect factory library
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ EffectsFactory.c
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
+LOCAL_MODULE:= libeffects
+
+ifeq ($(TARGET_OS)-$(TARGET_SIMULATOR),linux-true)
+LOCAL_LDLIBS += -ldl
+endif
+
+ifneq ($(TARGET_SIMULATOR),true)
+LOCAL_SHARED_LIBRARIES += libdl
+endif
+
+LOCAL_C_INCLUDES := \
+
+include $(BUILD_SHARED_LIBRARY)
+
+
+# Default Reverb library
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ EffectReverb.c.arm \
+ EffectsMath.c.arm
+LOCAL_CFLAGS+= -O2
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/soundfx
+LOCAL_MODULE:= libreverb
+
+ifeq ($(TARGET_OS)-$(TARGET_SIMULATOR),linux-true)
+LOCAL_LDLIBS += -ldl
+endif
+
+ifneq ($(TARGET_SIMULATOR),true)
+LOCAL_SHARED_LIBRARIES += libdl
+endif
+
+LOCAL_C_INCLUDES := \
+ $(call include-path-for, graphics corecg)
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+# Default Equalizer library
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ EffectsMath.c.arm \
+ EffectEqualizer.cpp \
+ AudioBiquadFilter.cpp.arm \
+ AudioCoefInterpolator.cpp.arm \
+ AudioPeakingFilter.cpp.arm \
+ AudioShelvingFilter.cpp.arm \
+ AudioEqualizer.cpp.arm
+
+LOCAL_CFLAGS+= -O2
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/soundfx
+LOCAL_MODULE:= libequalizer
+
+ifeq ($(TARGET_OS)-$(TARGET_SIMULATOR),linux-true)
+LOCAL_LDLIBS += -ldl
+endif
+
+ifneq ($(TARGET_SIMULATOR),true)
+LOCAL_SHARED_LIBRARIES += libdl
+endif
+
+LOCAL_C_INCLUDES := \
+ $(call include-path-for, graphics corecg)
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
\ No newline at end of file
diff --git a/media/libeffects/AudioBiquadFilter.cpp b/media/libeffects/AudioBiquadFilter.cpp
new file mode 100644
index 0000000..72917a3
--- /dev/null
+++ b/media/libeffects/AudioBiquadFilter.cpp
@@ -0,0 +1,260 @@
+/* //device/servers/AudioFlinger/AudioBiquadFilter.cpp
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <string.h>
+#include <assert.h>
+
+#include "AudioBiquadFilter.h"
+
+#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
+#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
+
+namespace android {
+
+const audio_coef_t AudioBiquadFilter::IDENTITY_COEFS[AudioBiquadFilter::NUM_COEFS] = { AUDIO_COEF_ONE, 0, 0, 0, 0 };
+
+AudioBiquadFilter::AudioBiquadFilter(int nChannels, int sampleRate) {
+ configure(nChannels, sampleRate);
+ reset();
+}
+
+void AudioBiquadFilter::configure(int nChannels, int sampleRate) {
+ assert(nChannels > 0 && nChannels <= MAX_CHANNELS);
+ assert(sampleRate > 0);
+ mNumChannels = nChannels;
+ mMaxDelta = static_cast<int64_t>(MAX_DELTA_PER_SEC)
+ * AUDIO_COEF_ONE
+ / sampleRate;
+ clear();
+}
+
+void AudioBiquadFilter::reset() {
+ memcpy(mCoefs, IDENTITY_COEFS, sizeof(mCoefs));
+ mCoefDirtyBits = 0;
+ setState(STATE_BYPASS);
+}
+
+void AudioBiquadFilter::clear() {
+ memset(mDelays, 0, sizeof(mDelays));
+}
+
+void AudioBiquadFilter::setCoefs(const audio_coef_t coefs[NUM_COEFS], bool immediate) {
+ memcpy(mTargetCoefs, coefs, sizeof(mTargetCoefs));
+ if (mState & STATE_ENABLED_MASK) {
+ if (UNLIKELY(immediate)) {
+ memcpy(mCoefs, coefs, sizeof(mCoefs));
+ setState(STATE_NORMAL);
+ } else {
+ setState(STATE_TRANSITION_TO_NORMAL);
+ }
+ }
+}
+
+void AudioBiquadFilter::process(const audio_sample_t in[], audio_sample_t out[],
+ int frameCount) {
+ (this->*mCurProcessFunc)(in, out, frameCount);
+}
+
+void AudioBiquadFilter::enable(bool immediate) {
+ if (UNLIKELY(immediate)) {
+ memcpy(mCoefs, mTargetCoefs, sizeof(mCoefs));
+ setState(STATE_NORMAL);
+ } else {
+ setState(STATE_TRANSITION_TO_NORMAL);
+ }
+}
+
+void AudioBiquadFilter::disable(bool immediate) {
+ if (UNLIKELY(immediate)) {
+ memcpy(mCoefs, IDENTITY_COEFS, sizeof(mCoefs));
+ setState(STATE_BYPASS);
+ } else {
+ setState(STATE_TRANSITION_TO_BYPASS);
+ }
+}
+
+void AudioBiquadFilter::setState(state_t state) {
+ switch (state) {
+ case STATE_BYPASS:
+ mCurProcessFunc = &AudioBiquadFilter::process_bypass;
+ break;
+ case STATE_TRANSITION_TO_BYPASS:
+ if (mNumChannels == 1) {
+ mCurProcessFunc = &AudioBiquadFilter::process_transition_bypass_mono;
+ } else {
+ mCurProcessFunc = &AudioBiquadFilter::process_transition_bypass_multi;
+ }
+ mCoefDirtyBits = (1 << NUM_COEFS) - 1;
+ break;
+ case STATE_TRANSITION_TO_NORMAL:
+ if (mNumChannels == 1) {
+ mCurProcessFunc = &AudioBiquadFilter::process_transition_normal_mono;
+ } else {
+ mCurProcessFunc = &AudioBiquadFilter::process_transition_normal_multi;
+ }
+ mCoefDirtyBits = (1 << NUM_COEFS) - 1;
+ break;
+ case STATE_NORMAL:
+ if (mNumChannels == 1) {
+ mCurProcessFunc = &AudioBiquadFilter::process_normal_mono;
+ } else {
+ mCurProcessFunc = &AudioBiquadFilter::process_normal_multi;
+ }
+ break;
+ }
+ mState = state;
+}
+
+bool AudioBiquadFilter::updateCoefs(const audio_coef_t coefs[NUM_COEFS],
+ int frameCount) {
+ int64_t maxDelta = mMaxDelta * frameCount;
+ for (int i = 0; i < NUM_COEFS; ++i) {
+ if (mCoefDirtyBits & (1<<i)) {
+ audio_coef_t diff = coefs[i] - mCoefs[i];
+ if (diff > maxDelta) {
+ mCoefs[i] += maxDelta;
+ } else if (diff < -maxDelta) {
+ mCoefs[i] -= maxDelta;
+ } else {
+ mCoefs[i] = coefs[i];
+ mCoefDirtyBits ^= (1<<i);
+ }
+ }
+ }
+ return mCoefDirtyBits == 0;
+}
+
+void AudioBiquadFilter::process_bypass(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ // The common case is in-place processing, because this is what the EQ does.
+ if (UNLIKELY(in != out)) {
+ memcpy(out, in, frameCount * mNumChannels * sizeof(audio_sample_t));
+ }
+}
+
+void AudioBiquadFilter::process_normal_mono(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ size_t nFrames = frameCount;
+ audio_sample_t x1 = mDelays[0][0];
+ audio_sample_t x2 = mDelays[0][1];
+ audio_sample_t y1 = mDelays[0][2];
+ audio_sample_t y2 = mDelays[0][3];
+ const audio_coef_t b0 = mCoefs[0];
+ const audio_coef_t b1 = mCoefs[1];
+ const audio_coef_t b2 = mCoefs[2];
+ const audio_coef_t a1 = mCoefs[3];
+ const audio_coef_t a2 = mCoefs[4];
+ while (nFrames-- > 0) {
+ audio_sample_t x0 = *(in++);
+ audio_coef_sample_acc_t acc;
+ acc = mul_coef_sample(b0, x0);
+ acc = mac_coef_sample(b1, x1, acc);
+ acc = mac_coef_sample(b2, x2, acc);
+ acc = mac_coef_sample(a1, y1, acc);
+ acc = mac_coef_sample(a2, y2, acc);
+ audio_sample_t y0 = coef_sample_acc_to_sample(acc);
+ y2 = y1;
+ y1 = y0;
+ x2 = x1;
+ x1 = x0;
+ (*out++) = y0;
+ }
+ mDelays[0][0] = x1;
+ mDelays[0][1] = x2;
+ mDelays[0][2] = y1;
+ mDelays[0][3] = y2;
+}
+
+void AudioBiquadFilter::process_transition_normal_mono(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ if (updateCoefs(mTargetCoefs, frameCount)) {
+ setState(STATE_NORMAL);
+ }
+ process_normal_mono(in, out, frameCount);
+}
+
+void AudioBiquadFilter::process_transition_bypass_mono(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ if (updateCoefs(IDENTITY_COEFS, frameCount)) {
+ setState(STATE_NORMAL);
+ }
+ process_normal_mono(in, out, frameCount);
+}
+
+void AudioBiquadFilter::process_normal_multi(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ const audio_coef_t b0 = mCoefs[0];
+ const audio_coef_t b1 = mCoefs[1];
+ const audio_coef_t b2 = mCoefs[2];
+ const audio_coef_t a1 = mCoefs[3];
+ const audio_coef_t a2 = mCoefs[4];
+ for (int ch = 0; ch < mNumChannels; ++ch) {
+ size_t nFrames = frameCount;
+ audio_sample_t x1 = mDelays[ch][0];
+ audio_sample_t x2 = mDelays[ch][1];
+ audio_sample_t y1 = mDelays[ch][2];
+ audio_sample_t y2 = mDelays[ch][3];
+ while (nFrames-- > 0) {
+ audio_sample_t x0 = *in;
+ audio_coef_sample_acc_t acc;
+ acc = mul_coef_sample(b0, x0);
+ acc = mac_coef_sample(b1, x1, acc);
+ acc = mac_coef_sample(b2, x2, acc);
+ acc = mac_coef_sample(a1, y1, acc);
+ acc = mac_coef_sample(a2, y2, acc);
+ audio_sample_t y0 = coef_sample_acc_to_sample(acc);
+ y2 = y1;
+ y1 = y0;
+ x2 = x1;
+ x1 = x0;
+ *out = y0;
+ in += mNumChannels;
+ out += mNumChannels;
+ }
+ mDelays[ch][0] = x1;
+ mDelays[ch][1] = x2;
+ mDelays[ch][2] = y1;
+ mDelays[ch][3] = y2;
+ in -= frameCount * mNumChannels - 1;
+ out -= frameCount * mNumChannels - 1;
+ }
+}
+
+void AudioBiquadFilter::process_transition_normal_multi(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ if (updateCoefs(mTargetCoefs, frameCount)) {
+ setState(STATE_NORMAL);
+ }
+ process_normal_multi(in, out, frameCount);
+}
+
+void AudioBiquadFilter::process_transition_bypass_multi(const audio_sample_t * in,
+ audio_sample_t * out,
+ int frameCount) {
+ if (updateCoefs(IDENTITY_COEFS, frameCount)) {
+ setState(STATE_NORMAL);
+ }
+ process_normal_multi(in, out, frameCount);
+}
+
+}
diff --git a/media/libeffects/AudioBiquadFilter.h b/media/libeffects/AudioBiquadFilter.h
new file mode 100644
index 0000000..2b0e2d6
--- /dev/null
+++ b/media/libeffects/AudioBiquadFilter.h
@@ -0,0 +1,180 @@
+/* //device/include/server/AudioFlinger/AudioBiquadFilter.h
+**
+** Copyright 2007, 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_AUDIO_BIQUAD_FILTER_H
+#define ANDROID_AUDIO_BIQUAD_FILTER_H
+
+#include "AudioCommon.h"
+
+namespace android {
+// A biquad filter.
+// Implements the recursion y[n]=a0*y[n-1]+a1*y[n-2]+b0*x[n]+b1*x[n-1]+b2*x[n-2]
+// (the a0 and a1 coefficients have an opposite sign to the common convention)
+// The filter works on fixed sized blocks of data (frameCount multi-channel
+// samples, as defined during construction). An arbitrary number of interlaced
+// channels is supported.
+// Filter can operate in an enabled (active) or disabled (bypassed) states.
+// A mechanism for suppression of artifacts caused by abrupt coefficient changes
+// is implemented: normally, when the enable(), disable() and setCoefs() methods
+// are called without the immediate flag set, the filter smoothly transitions
+// from its current state to the desired state.
+class AudioBiquadFilter {
+public:
+ // Max number of channels (can be changed here, and everything should work).
+ static const int MAX_CHANNELS = 2;
+ // Number of coefficients.
+ static const int NUM_COEFS = 5;
+
+ // Constructor.
+ // nChannels Number of input/output channels.
+ // sampleRate Sample rate, in Hz.
+ AudioBiquadFilter(int nChannels, int sampleRate);
+
+ // Reconfiguration of the filter. Implies clear().
+ // nChannels Number of input/output channels.
+ // sampleRate Sample rate, in Hz.
+ void configure(int nChannels, int sampleRate);
+
+ // Resets the internal state of the filter.
+ // Coefficients are reset to identity, state becomes disabled. This change
+ // happens immediately and might cause discontinuities in the output.
+ // Delay lines are not cleared.
+ void reset();
+
+ // Clears the delay lines.
+ // This change happens immediately and might cause discontinuities in the
+ // output.
+ void clear();
+
+ // Sets the coefficients.
+ // If called when filter is disabled, will have no immediate effect, but the
+ // new coefficients will be set and used next time the filter is enabled.
+ // coefs The new coefficients.
+ // immediate If true, transitions to new coefficients smoothly, without
+ // introducing discontinuities in the output. Otherwise,
+ // transitions immediately.
+ void setCoefs(const audio_coef_t coefs[NUM_COEFS], bool immediate = false);
+
+ // Process a buffer of data. Always processes frameCount multi-channel
+ // samples. Processing can be done in-place, by passing the same buffer as
+ // both arguments.
+ // in The input buffer. Should be of size frameCount * nChannels.
+ // out The output buffer. Should be of size frameCount * nChannels.
+ // frameCount Number of multi-channel samples to process.
+ void process(const audio_sample_t in[], audio_sample_t out[],
+ int frameCount);
+
+ // Enables (activates) the filter.
+ // immediate If true, transitions to new state smoothly, without
+ // introducing discontinuities in the output. Otherwise,
+ // transitions immediately.
+ void enable(bool immediate = false);
+
+ // Disables (bypasses) the filter.
+ // immediate If true, transitions to new state smoothly, without
+ // introducing discontinuities in the output. Otherwise,
+ // transitions immediately.
+ void disable(bool immediate = false);
+
+private:
+ // A prototype of the actual processing function. Has the same semantics as
+ // the process() method.
+ typedef void (AudioBiquadFilter::*process_func)(const audio_sample_t[],
+ audio_sample_t[],
+ int frameCount);
+
+ // The maximum rate of coefficient change, measured in coefficient units per
+ // second.
+ static const audio_coef_t MAX_DELTA_PER_SEC = 2000;
+
+ // Coefficients of identity transformation.
+ static const audio_coef_t IDENTITY_COEFS[NUM_COEFS];
+
+ // Filter state.
+ enum state_t {
+ // Bypass.
+ STATE_BYPASS = 0x01,
+ // In the process of smooth transition to bypass state.
+ STATE_TRANSITION_TO_BYPASS = 0x02,
+ // In the process of smooth transition to normal (enabled) state.
+ STATE_TRANSITION_TO_NORMAL = 0x04,
+ // In normal (enabled) state.
+ STATE_NORMAL = 0x05,
+ // A bit-mask for determining whether the filter is enabled or disabled
+ // in the eyes of the client.
+ STATE_ENABLED_MASK = 0x04
+ };
+
+ // Number of channels.
+ int mNumChannels;
+ // Current state.
+ state_t mState;
+ // Maximum coefficient delta per sample.
+ audio_coef_t mMaxDelta;
+
+ // A bit-mask designating for which coefficients the current value is not
+ // necessarily identical to the target value (since we're in transition
+ // state).
+ uint32_t mCoefDirtyBits;
+ // The current coefficients.
+ audio_coef_t mCoefs[NUM_COEFS];
+ // The target coefficients. Will not be identical to mCoefs if we are in a
+ // transition state.
+ audio_coef_t mTargetCoefs[NUM_COEFS];
+
+ // The delay lines.
+ audio_sample_t mDelays[MAX_CHANNELS][4];
+
+ // Current processing function (determines according to current state and
+ // number of channels).
+ process_func mCurProcessFunc;
+
+ // Sets a new state. Updates the processing function accordingly, and sets
+ // the dirty bits if changing to a transition state.
+ void setState(state_t state);
+
+ // In a transition state, modifies the current coefs towards the passed
+ // coefs, while keeping a smooth change rate. Whenever a coef reaches its
+ // target value, the dirty bit is cleared. If all are clear, the function
+ // returns true, and we can then change to our target state.
+ bool updateCoefs(const audio_coef_t coefs[NUM_COEFS], int frameCount);
+
+ // Processing function when in disabled state.
+ void process_bypass(const audio_sample_t * in, audio_sample_t * out,
+ int frameCount);
+ // Processing function when in normal state, mono.
+ void process_normal_mono(const audio_sample_t * in, audio_sample_t * out,
+ int frameCount);
+ // Processing function when transitioning to normal state, mono.
+ void process_transition_normal_mono(const audio_sample_t * in,
+ audio_sample_t * out, int frameCount);
+ // Processing function when transitioning to bypass state, mono.
+ void process_transition_bypass_mono(const audio_sample_t * in,
+ audio_sample_t * out, int frameCount);
+ // Processing function when in normal state, multi-channel.
+ void process_normal_multi(const audio_sample_t * in, audio_sample_t * out,
+ int frameCount);
+ // Processing function when transitioning to normal state, multi-channel.
+ void process_transition_normal_multi(const audio_sample_t * in,
+ audio_sample_t * out, int frameCount);
+ // Processing function when transitioning to bypass state, multi-channel.
+ void process_transition_bypass_multi(const audio_sample_t * in,
+ audio_sample_t * out, int frameCount);
+};
+}
+
+#endif // ANDROID_AUDIO_BIQUAD_FILTER_H
diff --git a/media/libeffects/AudioCoefInterpolator.cpp b/media/libeffects/AudioCoefInterpolator.cpp
new file mode 100644
index 0000000..05898c9
--- /dev/null
+++ b/media/libeffects/AudioCoefInterpolator.cpp
@@ -0,0 +1,84 @@
+/* //device/servers/AudioFlinger/AudioCoefInterpolator.cpp
+ **
+ ** Copyright 2008, The Android Open Source Project
+ **
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ **
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ **
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ */
+
+#include <string.h>
+#include "AudioCoefInterpolator.h"
+
+#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
+#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
+
+namespace android {
+
+AudioCoefInterpolator::AudioCoefInterpolator(size_t nInDims,
+ const size_t inDims[],
+ size_t nOutDims,
+ const audio_coef_t * table) {
+ mNumInDims = nInDims;
+ memcpy(mInDims, inDims, nInDims * sizeof(size_t));
+ mNumOutDims = nOutDims;
+ mTable = table;
+ // Initialize offsets array
+ size_t dim = nInDims - 1;
+ mInDimOffsets[nInDims - 1] = nOutDims;
+ while (dim-- > 0) {
+ mInDimOffsets[dim] = mInDimOffsets[dim + 1] * mInDims[dim + 1];
+ }
+}
+
+void AudioCoefInterpolator::getCoef(const int intCoord[], uint32_t fracCoord[],
+ audio_coef_t out[]) {
+ size_t index = 0;
+ size_t dim = mNumInDims;
+ while (dim-- > 0) {
+ if (UNLIKELY(intCoord[dim] < 0)) {
+ fracCoord[dim] = 0;
+ } else if (UNLIKELY(intCoord[dim] >= mInDims[dim] - 1)) {
+ fracCoord[dim] = 0;
+ index += mInDimOffsets[dim] * (mInDims[dim] - 1);
+ } else {
+ index += mInDimOffsets[dim] * intCoord[dim];
+ }
+ }
+ getCoefRecurse(index, fracCoord, out, 0);
+}
+
+void AudioCoefInterpolator::getCoefRecurse(size_t index,
+ const uint32_t fracCoord[],
+ audio_coef_t out[], size_t dim) {
+ if (dim == mNumInDims) {
+ memcpy(out, mTable + index, mNumOutDims * sizeof(audio_coef_t));
+ } else {
+ getCoefRecurse(index, fracCoord, out, dim + 1);
+ if (LIKELY(fracCoord != 0)) {
+ audio_coef_t tempCoef[MAX_OUT_DIMS];
+ getCoefRecurse(index + mInDimOffsets[dim], fracCoord, tempCoef,
+ dim + 1);
+ size_t d = mNumOutDims;
+ while (d-- > 0) {
+ out[d] = interp(out[d], tempCoef[d], fracCoord[dim]);
+ }
+ }
+ }
+}
+
+audio_coef_t AudioCoefInterpolator::interp(audio_coef_t lo, audio_coef_t hi,
+ uint32_t frac) {
+ int64_t delta = static_cast<int64_t>(hi-lo) * frac;
+ return lo + static_cast<audio_coef_t> (delta >> 32);
+}
+
+}
diff --git a/media/libeffects/AudioCoefInterpolator.h b/media/libeffects/AudioCoefInterpolator.h
new file mode 100644
index 0000000..13e5697
--- /dev/null
+++ b/media/libeffects/AudioCoefInterpolator.h
@@ -0,0 +1,98 @@
+/* //device/include/server/AudioFlinger/AudioCoefInterpolator.h
+ **
+ ** Copyright 2007, 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_AUDIO_COEF_INTERPOLATOR_H
+#define ANDROID_AUDIO_COEF_INTERPOLATOR_H
+
+#include "AudioCommon.h"
+
+namespace android {
+
+// A helper class for linear interpolation of N-D -> M-D coefficient tables.
+// This class provides support for out-of-range indexes.
+// Details:
+// The purpose is efficient approximation of a N-dimensional vector to
+// M-dimensional function. The approximation is based on a table of output
+// values on a uniform grid of the input values. Values not on the grid are
+// linearly interpolated.
+// Access to values are done by specifying input values in table index units,
+// having an integer and a fractional part, e.g. retrieving a value from index
+// 1.4 will result in linear interpolation between index 1 and index 2.
+class AudioCoefInterpolator {
+public:
+ // Constructor.
+ // nInDims Number of input dimensions (limited to MAX_IN_DIMS).
+ // inDims An array of size nInDims with the size of the table on each
+ // respective dimension.
+ // nOutDims Number of output dimensions (limited to MAX_OUT_DIMS).
+ // table The coefficient table. Should be of size:
+ // inDims[0]*inDims[1]*...*inDims[nInDims-1]*nOutDims, where
+ // func([i,j,k]) = table(i,j,k,:)
+ AudioCoefInterpolator(size_t nInDims, const size_t inDims[],
+ size_t nOutDims, const audio_coef_t * table);
+
+ // Get the value of the approximated function at a given point.
+ // intCoord The integer part of the input value. Should be an array of
+ // size nInDims.
+ // fracCoord The fractional part of the input value. Should be an array
+ // of size nInDims. This value is in 32-bit precision.
+ // out An array for the output value. Should be of size nOutDims.
+ void getCoef(const int intCoord[], uint32_t fracCoord[], audio_coef_t out[]);
+
+private:
+ // Maximum allowed number of input dimensions.
+ static const size_t MAX_IN_DIMS = 8;
+ // Maximum allowed number of output dimensions.
+ static const size_t MAX_OUT_DIMS = 8;
+
+ // Number of input dimensions.
+ size_t mNumInDims;
+ // Number of input dimensions.
+ size_t mInDims[MAX_IN_DIMS];
+ // The offset between two consecutive indexes of each dimension. This is in
+ // fact a cumulative product of mInDims (done in reverse).
+ size_t mInDimOffsets[MAX_IN_DIMS];
+ // Number of output dimensions.
+ size_t mNumOutDims;
+ // The coefficient table.
+ const audio_coef_t * mTable;
+
+ // A recursive function for getting an interpolated coefficient value.
+ // The recursion depth is the number of input dimensions.
+ // At each step, we fetch two interpolated values of the current dimension,
+ // by two recursive calls to this method for the next dimensions. We then
+ // linearly interpolate these values over the current dimension.
+ // index The linear integer index of the value we need to interpolate.
+ // fracCoord A vector of fractional coordinates for each of the input
+ // dimensions.
+ // out Where the output should be written. Needs to be of size
+ // mNumOutDims.
+ // dim The input dimensions we are currently interpolating. This
+ // value will be increased on recursive calls.
+ void getCoefRecurse(size_t index, const uint32_t fracCoord[],
+ audio_coef_t out[], size_t dim);
+
+ // Scalar interpolation of two data points.
+ // lo The first data point.
+ // hi The second data point.
+ // frac A 32-bit fraction designating the weight of the second point.
+ static audio_coef_t interp(audio_coef_t lo, audio_coef_t hi, uint32_t frac);
+};
+
+}
+
+#endif // ANDROID_AUDIO_COEF_INTERPOLATOR_H
diff --git a/media/libeffects/AudioCommon.h b/media/libeffects/AudioCommon.h
new file mode 100644
index 0000000..12d2193
--- /dev/null
+++ b/media/libeffects/AudioCommon.h
@@ -0,0 +1,92 @@
+/* //device/include/server/AudioFlinger/AudioCommon.h
+**
+** Copyright 2009, 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_AUDIO_COMMON_H
+#define ANDROID_AUDIO_COMMON_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+namespace android {
+
+// Audio coefficient type.
+typedef int32_t audio_coef_t;
+// Audio sample type.
+typedef int32_t audio_sample_t;
+// Accumulator type for coef x sample.
+typedef int64_t audio_coef_sample_acc_t;
+
+// Number of fraction bits for audio coefficient.
+static const int AUDIO_COEF_PRECISION = 24;
+// Audio coefficient with the value of 1.0
+static const audio_coef_t AUDIO_COEF_ONE = 1 << AUDIO_COEF_PRECISION;
+// Audio coefficient with the value of 0.5
+static const audio_coef_t AUDIO_COEF_HALF = 1 << (AUDIO_COEF_PRECISION - 1);
+// Number of fraction bits for audio sample.
+static const int AUDIO_SAMPLE_PRECISION = 24;
+// Audio sample with the value of 1.0
+static const audio_sample_t AUDIO_SAMPLE_ONE = 1 << AUDIO_SAMPLE_PRECISION;
+
+// TODO: These are just temporary naive implementations of the necessary
+// arithmetic operations needed for the filter. They should be moved to a more
+// generic location and implemented more efficiently.
+
+// Multiply a sample by a coefficient to return an accumulator.
+inline audio_coef_sample_acc_t mul_coef_sample(audio_coef_t x, audio_sample_t y) {
+ return ((audio_coef_sample_acc_t) (x)) * y;
+}
+
+// Multiply and accumulate sample by a coefficient to return an accumulator.
+inline audio_coef_sample_acc_t mac_coef_sample(audio_coef_t x, audio_sample_t y, audio_coef_sample_acc_t acc) {
+ return acc + ((audio_coef_sample_acc_t) (x)) * y;
+}
+
+// Convert a sample-coefficient accumulator to a sample.
+inline audio_sample_t coef_sample_acc_to_sample(audio_coef_sample_acc_t acc) {
+ if (acc < 0) {
+ acc += AUDIO_COEF_ONE - 1;
+ }
+ return (audio_sample_t) (acc >> AUDIO_COEF_PRECISION);
+}
+
+// Convert a S15 sample to audio_sample_t
+inline audio_sample_t s15_to_audio_sample_t(int16_t s15) {
+ return audio_sample_t(s15) << 9;
+}
+
+// Convert a audio_sample_t sample to S15 (no clipping)
+inline int16_t audio_sample_t_to_s15(audio_sample_t sample) {
+ return int16_t((sample + (1 << 8)) >> 9);
+}
+
+// Convert a audio_sample_t sample to S15 (with clipping)
+inline int16_t audio_sample_t_to_s15_clip(audio_sample_t sample) {
+ // TODO: optimize for targets supporting this as an atomic operation.
+ if (__builtin_expect(sample >= (0x7FFF << 9), 0)) {
+ return 0x7FFF;
+ } else if (__builtin_expect(sample <= -(0x8000 << 9), 0)) {
+ return 0x8000;
+ } else {
+ return audio_sample_t_to_s15(sample);
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+}
+
+#endif // ANDROID_AUDIO_COMMON_H
diff --git a/media/libeffects/AudioEqualizer.cpp b/media/libeffects/AudioEqualizer.cpp
new file mode 100644
index 0000000..44c9476
--- /dev/null
+++ b/media/libeffects/AudioEqualizer.cpp
@@ -0,0 +1,315 @@
+/*
+ * Copyright 2009, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "AudioEqualizer"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <new>
+#include <utils/Log.h>
+
+#include "AudioEqualizer.h"
+#include "AudioPeakingFilter.h"
+#include "AudioShelvingFilter.h"
+#include "EffectsMath.h"
+
+namespace android {
+
+size_t AudioEqualizer::GetInstanceSize(int nBands) {
+ assert(nBands >= 2);
+ return sizeof(AudioEqualizer) +
+ sizeof(AudioShelvingFilter) * 2 +
+ sizeof(AudioPeakingFilter) * (nBands - 2);
+}
+
+AudioEqualizer * AudioEqualizer::CreateInstance(void * pMem, int nBands,
+ int nChannels, int sampleRate,
+ const PresetConfig * presets,
+ int nPresets) {
+ LOGV("AudioEqualizer::CreateInstance(pMem=%p, nBands=%d, nChannels=%d, "
+ "sampleRate=%d, nPresets=%d)",
+ pMem, nBands, nChannels, sampleRate, nPresets);
+ assert(nBands >= 2);
+ bool ownMem = false;
+ if (pMem == NULL) {
+ pMem = malloc(GetInstanceSize(nBands));
+ if (pMem == NULL) {
+ return NULL;
+ }
+ ownMem = true;
+ }
+ return new (pMem) AudioEqualizer(pMem, nBands, nChannels, sampleRate,
+ ownMem, presets, nPresets);
+}
+
+void AudioEqualizer::configure(int nChannels, int sampleRate) {
+ LOGV("AudioEqualizer::configure(nChannels=%d, sampleRate=%d)", nChannels,
+ sampleRate);
+ mpLowShelf->configure(nChannels, sampleRate);
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].configure(nChannels, sampleRate);
+ }
+ mpHighShelf->configure(nChannels, sampleRate);
+}
+
+void AudioEqualizer::clear() {
+ LOGV("AudioEqualizer::clear()");
+ mpLowShelf->clear();
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].clear();
+ }
+ mpHighShelf->clear();
+}
+
+void AudioEqualizer::free() {
+ LOGV("AudioEqualizer::free()");
+ if (mpMem != NULL) {
+ ::free(mpMem);
+ }
+}
+
+void AudioEqualizer::reset() {
+ LOGV("AudioEqualizer::reset()");
+ const int32_t bottom = Effects_log2(kMinFreq);
+ const int32_t top = Effects_log2(mSampleRate * 500);
+ const int32_t jump = (top - bottom) / (mNumPeaking + 2);
+ int32_t centerFreq = bottom + jump/2;
+
+ mpLowShelf->reset();
+ mpLowShelf->setFrequency(Effects_exp2(centerFreq));
+ centerFreq += jump;
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].reset();
+ mpPeakingFilters[i].setFrequency(Effects_exp2(centerFreq));
+ centerFreq += jump;
+ }
+ mpHighShelf->reset();
+ mpHighShelf->setFrequency(Effects_exp2(centerFreq));
+ commit(true);
+ mCurPreset = PRESET_CUSTOM;
+}
+
+void AudioEqualizer::setGain(int band, int32_t millibel) {
+ LOGV("AudioEqualizer::setGain(band=%d, millibel=%d)", band, millibel);
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band == 0) {
+ mpLowShelf->setGain(millibel);
+ } else if (band == mNumPeaking + 1) {
+ mpHighShelf->setGain(millibel);
+ } else {
+ mpPeakingFilters[band - 1].setGain(millibel);
+ }
+ mCurPreset = PRESET_CUSTOM;
+}
+
+void AudioEqualizer::setFrequency(int band, uint32_t millihertz) {
+ LOGV("AudioEqualizer::setFrequency(band=%d, millihertz=%d)", band,
+ millihertz);
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band == 0) {
+ mpLowShelf->setFrequency(millihertz);
+ } else if (band == mNumPeaking + 1) {
+ mpHighShelf->setFrequency(millihertz);
+ } else {
+ mpPeakingFilters[band - 1].setFrequency(millihertz);
+ }
+ mCurPreset = PRESET_CUSTOM;
+}
+
+void AudioEqualizer::setBandwidth(int band, uint32_t cents) {
+ LOGV("AudioEqualizer::setBandwidth(band=%d, cents=%d)", band, cents);
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band > 0 && band < mNumPeaking + 1) {
+ mpPeakingFilters[band - 1].setBandwidth(cents);
+ mCurPreset = PRESET_CUSTOM;
+ }
+}
+
+int32_t AudioEqualizer::getGain(int band) const {
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band == 0) {
+ return mpLowShelf->getGain();
+ } else if (band == mNumPeaking + 1) {
+ return mpHighShelf->getGain();
+ } else {
+ return mpPeakingFilters[band - 1].getGain();
+ }
+}
+
+uint32_t AudioEqualizer::getFrequency(int band) const {
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band == 0) {
+ return mpLowShelf->getFrequency();
+ } else if (band == mNumPeaking + 1) {
+ return mpHighShelf->getFrequency();
+ } else {
+ return mpPeakingFilters[band - 1].getFrequency();
+ }
+}
+
+uint32_t AudioEqualizer::getBandwidth(int band) const {
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band == 0 || band == mNumPeaking + 1) {
+ return 0;
+ } else {
+ return mpPeakingFilters[band - 1].getBandwidth();
+ }
+}
+
+void AudioEqualizer::getBandRange(int band, uint32_t & low,
+ uint32_t & high) const {
+ assert(band >= 0 && band < mNumPeaking + 2);
+ if (band == 0) {
+ low = 0;
+ high = mpLowShelf->getFrequency();
+ } else if (band == mNumPeaking + 1) {
+ low = mpHighShelf->getFrequency();
+ high = mSampleRate * 500;
+ } else {
+ mpPeakingFilters[band - 1].getBandRange(low, high);
+ }
+}
+
+const char * AudioEqualizer::getPresetName(int preset) const {
+ assert(preset < mNumPresets && preset >= PRESET_CUSTOM);
+ if (preset == PRESET_CUSTOM) {
+ return "Custom";
+ } else {
+ return mpPresets[preset].name;
+ }
+}
+
+int AudioEqualizer::getNumPresets() const {
+ return mNumPresets;
+}
+
+int AudioEqualizer::getPreset() const {
+ return mCurPreset;
+}
+
+void AudioEqualizer::setPreset(int preset) {
+ LOGV("AudioEqualizer::setPreset(preset=%d)", preset);
+ assert(preset < mNumPresets && preset >= 0);
+ const PresetConfig &presetCfg = mpPresets[preset];
+ for (int band = 0; band < (mNumPeaking + 2); ++band) {
+ const BandConfig & bandCfg = presetCfg.bandConfigs[band];
+ setGain(band, bandCfg.gain);
+ setFrequency(band, bandCfg.freq);
+ setBandwidth(band, bandCfg.bandwidth);
+ }
+ mCurPreset = preset;
+}
+
+void AudioEqualizer::commit(bool immediate) {
+ LOGV("AudioEqualizer::commit(immediate=%d)", immediate);
+ mpLowShelf->commit(immediate);
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].commit(immediate);
+ }
+ mpHighShelf->commit(immediate);
+}
+
+void AudioEqualizer::process(const audio_sample_t * pIn,
+ audio_sample_t * pOut,
+ int frameCount) {
+// LOGV("AudioEqualizer::process(frameCount=%d)", frameCount);
+ mpLowShelf->process(pIn, pOut, frameCount);
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].process(pIn, pOut, frameCount);
+ }
+ mpHighShelf->process(pIn, pOut, frameCount);
+}
+
+void AudioEqualizer::enable(bool immediate) {
+ LOGV("AudioEqualizer::enable(immediate=%d)", immediate);
+ mpLowShelf->enable(immediate);
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].enable(immediate);
+ }
+ mpHighShelf->enable(immediate);
+}
+
+void AudioEqualizer::disable(bool immediate) {
+ LOGV("AudioEqualizer::disable(immediate=%d)", immediate);
+ mpLowShelf->disable(immediate);
+ for (int i = 0; i < mNumPeaking; ++i) {
+ mpPeakingFilters[i].disable(immediate);
+ }
+ mpHighShelf->disable(immediate);
+}
+
+int AudioEqualizer::getMostRelevantBand(uint32_t targetFreq) const {
+ // First, find the two bands that the target frequency is between.
+ uint32_t low = mpLowShelf->getFrequency();
+ if (targetFreq <= low) {
+ return 0;
+ }
+ uint32_t high = mpHighShelf->getFrequency();
+ if (targetFreq >= high) {
+ return mNumPeaking + 1;
+ }
+ int band = mNumPeaking;
+ for (int i = 0; i < mNumPeaking; ++i) {
+ uint32_t freq = mpPeakingFilters[i].getFrequency();
+ if (freq >= targetFreq) {
+ high = freq;
+ band = i;
+ break;
+ }
+ low = freq;
+ }
+ // Now, low is right below the target and high is right above. See which one
+ // is closer on a log scale.
+ low = Effects_log2(low);
+ high = Effects_log2(high);
+ targetFreq = Effects_log2(targetFreq);
+ if (high - targetFreq < targetFreq - low) {
+ return band + 1;
+ } else {
+ return band;
+ }
+}
+
+
+AudioEqualizer::AudioEqualizer(void * pMem, int nBands, int nChannels,
+ int sampleRate, bool ownMem,
+ const PresetConfig * presets, int nPresets)
+ : mSampleRate(sampleRate)
+ , mpPresets(presets)
+ , mNumPresets(nPresets) {
+ assert(pMem != NULL);
+ assert(nPresets == 0 || nPresets > 0 && presets != NULL);
+ mpMem = ownMem ? pMem : NULL;
+
+ pMem = (char *) pMem + sizeof(AudioEqualizer);
+ mpLowShelf = new (pMem) AudioShelvingFilter(AudioShelvingFilter::kLowShelf,
+ nChannels, sampleRate);
+ pMem = (char *) pMem + sizeof(AudioShelvingFilter);
+ mpHighShelf = new (pMem) AudioShelvingFilter(AudioShelvingFilter::kHighShelf,
+ nChannels, sampleRate);
+ pMem = (char *) pMem + sizeof(AudioShelvingFilter);
+ mNumPeaking = nBands - 2;
+ if (mNumPeaking > 0) {
+ mpPeakingFilters = reinterpret_cast<AudioPeakingFilter *>(pMem);
+ for (int i = 0; i < mNumPeaking; ++i) {
+ new (&mpPeakingFilters[i]) AudioPeakingFilter(nChannels,
+ sampleRate);
+ }
+ }
+ reset();
+}
+
+}
diff --git a/media/libeffects/AudioEqualizer.h b/media/libeffects/AudioEqualizer.h
new file mode 100644
index 0000000..4028462
--- /dev/null
+++ b/media/libeffects/AudioEqualizer.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2009, 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 AUDIOEQUALIZER_H_
+#define AUDIOEQUALIZER_H_
+
+#include "AudioCommon.h"
+
+namespace android {
+
+class AudioShelvingFilter;
+class AudioPeakingFilter;
+
+// A parametric audio equalizer. Supports an arbitrary number of bands and
+// presets.
+// The EQ is composed of a low-shelf, zero or more peaking filters and a high
+// shelf, where each band has frequency and gain controls, and the peaking
+// filters have an additional bandwidth control.
+class AudioEqualizer {
+public:
+ // Configuration of a single band.
+ struct BandConfig {
+ // Gain in millibel.
+ int32_t gain;
+ // Frequency in millihertz.
+ uint32_t freq;
+ // Bandwidth in cents (ignored on shelving filters).
+ uint32_t bandwidth;
+ };
+
+ // Preset configuration.
+ struct PresetConfig {
+ // Human-readable name.
+ const char * name;
+ // An array of size nBands where each element is a configuration for the
+ // corresponding band.
+ const BandConfig * bandConfigs;
+ };
+
+ // This value is used when requesting current preset, and EQ is not using a
+ // preset.
+ static const int PRESET_CUSTOM = -1;
+
+ // Get the required memory size for an instance of this class.
+ // nBands Number of bands required in the instance.
+ static size_t GetInstanceSize(int nBands);
+
+ // Create an instance of this class.
+ // If succeeds, a respective call is expected to freeInstance(), regardless
+ // of who owns the context memory.
+ // pMem A memory buffer of at least the size returned by
+ // GetInstanceSize(), where the instance context is to be
+ // stored. If NULL, it will be automatically allocated (using
+ // malloc).
+ // nBands Number of bands. Must be >= 2.
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ // presets The presets configuration. May be NULL, but in that case the
+ // client is required not to call preset-related functions.
+ // This array is owned by the client and is not copied. It
+ // must be kept valid by the client as long as the instance is
+ // alive.
+ // nPresets Number of elements in the presets array.
+ // returns The instance if success. NULL if pMem is NULL and allocation
+ // failed.
+ static AudioEqualizer * CreateInstance(void * pMem, int nBands,
+ int nChannels,
+ int sampleRate,
+ const PresetConfig * presets,
+ int nPresets);
+
+ // Reconfiguration of the filter. Changes input/output format, but does not
+ // alter current parameter values. Causes reset of the delay lines.
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ void configure(int nChannels, int sampleRate);
+
+ // Resets the filter parameters to the following values:
+ // frequency: 0
+ // gain: 0
+ // bandwidth: 1200 cents.
+ // It also disables the filter. Does not clear the delay lines.
+ void reset();
+
+ // Clears delay lines. Does not alter parameter values.
+ void clear();
+
+ // Frees the object. Will free the memory if the object owned it, i.e. if
+ // a NULL pointer was passed to CreateInstance as pMem.
+ void free();
+
+ // Sets gain value. Actual change will only take place upon commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // band The band to set the gain for.
+ // millibel Gain value in millibel (1/100 of decibel).
+ void setGain(int band, int32_t millibel);
+
+ // Gets gain of a certain band. This is always the last value set (or
+ // default value after reset).
+ // band The band to get the gain for.
+ // returns Gain value in millibel (1/100 of decibel).
+ int32_t getGain(int band) const;
+
+ // Sets cutoff frequency value. Actual change will only take place upon
+ // commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // band The band to set the frequency for.
+ // millihertz Frequency value in mHz.
+ void setFrequency(int band, uint32_t millihertz);
+
+ // Gets frequency of a certain band. This is always the last value set (or
+ // default value after reset).
+ // band The band to get the frequency for.
+ // returns Frequency value in mHz.
+ uint32_t getFrequency(int band) const;
+
+ // Sets bandwidth value. Actual change will only take place upon commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // If called on the first or last band, this call is ignored.
+ // band The band to set the frequency for.
+ // cents Bandwidth value in cents (1/1200 octave).
+ void setBandwidth(int band, uint32_t cents);
+
+ // Gets bandwidth of a certain band. This is always the last value set (or
+ // default value after reset). For the first and last bands, 0 is always
+ // returned.
+ // band The band to get the bandwidth for.
+ // returns Bandwidth value in cents (1/1200 octave).
+ uint32_t getBandwidth(int band) const;
+
+ // Gets lower and upper boundaries of a band.
+ // For the low shelf, the low bound is 0 and the high bound is the band
+ // frequency.
+ // For the high shelf, the low bound is the band frequency and the high
+ // bound is Nyquist.
+ // For the peaking filters, they are the gain[dB]/2 points.
+ void getBandRange(int band, uint32_t & low, uint32_t & high) const;
+
+ // Gets a human-readable name for a preset ID. Will return "Custom" if
+ // PRESET_CUSTOM is passed.
+ // preset The preset ID. Must be less than number of presets.
+ const char * getPresetName(int preset) const;
+
+ // Gets the number of presets.
+ int getNumPresets() const;
+
+ // Gets the currently set preset ID.
+ // Will return PRESET_CUSTOM in case the EQ parameters have been modified
+ // manually since a preset was set.
+ int getPreset() const;
+
+ // Sets the current preset by ID.
+ // All the band parameters will be overridden.
+ // Change will not be applied until commit() is called.
+ // preset The preset ID. Must be less than number of presets.
+ // PRESET_CUSTOM is NOT a valid value here.
+ void setPreset(int preset);
+
+ // Applies all parameter changes done to this point in time.
+ // If the filter is disabled, the new parameters will take place when it is
+ // enabled again. Does not introduce artifacts, unless immediate is set.
+ // immediate Whether to apply change abruptly (ignored if filter is
+ // disabled).
+ void commit(bool immediate = false);
+
+ // Process a buffer of input data. The input and output should contain
+ // frameCount * nChannels interlaced samples. Processing can be done
+ // in-place, by passing the same buffer as both arguments.
+ // pIn Input buffer.
+ // pOut Output buffer.
+ // frameCount Number of frames to produce on each call to process().
+ void process(const audio_sample_t * pIn, audio_sample_t * pOut,
+ int frameCount);
+
+ // Enables the filter, so it would start processing input. Does not
+ // introduce artifacts, unless immediate is set.
+ // immediate Whether to apply change abruptly.
+ void enable(bool immediate = false);
+
+ // Disabled (bypasses) the filter. Does not introduce artifacts, unless
+ // immediate is set.
+ // immediate Whether to apply change abruptly.
+ void disable(bool immediate = false);
+
+ // Returns the band with the maximum influence on a given frequency.
+ // Result is unaffected by whether EQ is enabled or not, or by whether
+ // changes have been committed or not.
+ // targetFreq The target frequency, in millihertz.
+ int getMostRelevantBand(uint32_t targetFreq) const;
+
+private:
+ // Bottom frequency, in mHz.
+ static const int kMinFreq = 20000;
+ // Sample rate, in Hz.
+ int mSampleRate;
+ // Number of peaking filters. Total number of bands is +2.
+ int mNumPeaking;
+ // Preset configurations.
+ const PresetConfig * mpPresets;
+ // Number of elements in mpPresets;
+ int mNumPresets;
+ // Current preset.
+ int mCurPreset;
+
+ // Memory space to free when instance is deleted, or NULL if no memory is
+ // owned.
+ void * mpMem;
+ // The low-shelving filter.
+ AudioShelvingFilter * mpLowShelf;
+ // The high-shelving filter.
+ AudioShelvingFilter * mpHighShelf;
+ // An array of size mNumPeaking of peaking filters.
+ AudioPeakingFilter * mpPeakingFilters;
+
+ // Constructor. Resets the filter (see reset()). Must call init() doing
+ // anything else.
+ // pMem Memory buffer for bands.
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ // ownMem Whether pMem is owned by me.
+ // presets The presets configuration. May be NULL, but in that case the
+ // client is required not to call preset-related functions.
+ // This array is owned by the client and is not copied. It
+ // must be kept valid by the client as long as the instance is
+ // alive.
+ // nPresets Number of elements in the presets array.
+ AudioEqualizer(void * pMem, int nBands, int nChannels, int sampleRate,
+ bool ownMem, const PresetConfig * presets, int nPresets);
+};
+
+}
+
+#endif // AUDIOEQUALIZER_H_
diff --git a/media/libeffects/AudioFormatAdapter.h b/media/libeffects/AudioFormatAdapter.h
new file mode 100644
index 0000000..8aa5e65
--- /dev/null
+++ b/media/libeffects/AudioFormatAdapter.h
@@ -0,0 +1,184 @@
+/* /android/src/frameworks/base/media/libeffects/AudioFormatAdapter.h
+**
+** Copyright 2009, 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 AUDIOFORMATADAPTER_H_
+#define AUDIOFORMATADAPTER_H_
+
+#include <media/EffectApi.h>
+
+
+#define min(x,y) (((x) < (y)) ? (x) : (y))
+
+namespace android {
+
+// An adapter for an audio processor working on audio_sample_t samples with a
+// buffer override behavior to arbitrary sample formats and buffer behaviors.
+// The adapter may work on any processing class which has a processing function
+// with the following signature:
+// void process(const audio_sample_t * pIn,
+// audio_sample_t * pOut,
+// int frameCount);
+// It is assumed that the underlying processor works in S7.24 format and an
+// overwrite behavior.
+//
+// Usage is simple: just work with the processor normally, but instead of
+// calling its process() function directly, work with the process() function of
+// the adapter.
+// The adapter supports re-configuration to a different format on the fly.
+//
+// T The processor class.
+// bufSize The maximum number of samples (single channel) to process on a
+// single call to the underlying processor. Setting this to a small
+// number will save a little memory, but will cost function call
+// overhead, resulting from multiple calls to the underlying process()
+// per a single call to this class's process().
+template<class T, size_t bufSize>
+class AudioFormatAdapter {
+public:
+ // Configure the adapter.
+ // processor The underlying audio processor.
+ // nChannels Number of input and output channels. The adapter does not do
+ // channel conversion - this parameter must be in sync with the
+ // actual processor.
+ // pcmFormat The desired input/output sample format.
+ // behavior The desired behavior (overwrite or accumulate).
+ void configure(T & processor, int nChannels, uint8_t pcmFormat,
+ uint32_t behavior) {
+ mpProcessor = &processor;
+ mNumChannels = nChannels;
+ mPcmFormat = pcmFormat;
+ mBehavior = behavior;
+ mMaxSamplesPerCall = bufSize / nChannels;
+ }
+
+ // Process a block of samples.
+ // pIn A buffer of samples with the format specified on
+ // configure().
+ // pOut A buffer of samples with the format specified on
+ // configure(). May be the same as pIn.
+ // numSamples The number of multi-channel samples to process.
+ void process(const void * pIn, void * pOut, uint32_t numSamples) {
+ while (numSamples > 0) {
+ uint32_t numSamplesIter = min(numSamples, mMaxSamplesPerCall);
+ uint32_t nSamplesChannels = numSamplesIter * mNumChannels;
+ if (mPcmFormat == PCM_FORMAT_S7_24) {
+ if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) {
+ mpProcessor->process(
+ reinterpret_cast<const audio_sample_t *> (pIn),
+ reinterpret_cast<audio_sample_t *> (pOut),
+ numSamplesIter);
+ } else if (mBehavior == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
+ mpProcessor->process(
+ reinterpret_cast<const audio_sample_t *> (pIn),
+ mBuffer, numSamplesIter);
+ MixOutput(pOut, numSamplesIter);
+ } else {
+ assert(false);
+ }
+ pIn = reinterpret_cast<const audio_sample_t *> (pIn)
+ + nSamplesChannels;
+ pOut = reinterpret_cast<audio_sample_t *> (pOut)
+ + nSamplesChannels;
+ } else {
+ ConvertInput(pIn, nSamplesChannels);
+ mpProcessor->process(mBuffer, mBuffer, numSamplesIter);
+ ConvertOutput(pOut, nSamplesChannels);
+ }
+ numSamples -= numSamplesIter;
+ }
+ }
+
+private:
+ // The underlying processor.
+ T * mpProcessor;
+ // The number of input/output channels.
+ int mNumChannels;
+ // The desired PCM format.
+ uint8_t mPcmFormat;
+ // The desired buffer behavior.
+ uint32_t mBehavior;
+ // An intermediate buffer for processing.
+ audio_sample_t mBuffer[bufSize];
+ // The buffer size, divided by the number of channels - represents the
+ // maximum number of multi-channel samples that can be stored in the
+ // intermediate buffer.
+ size_t mMaxSamplesPerCall;
+
+ // Converts a buffer of input samples to audio_sample_t format.
+ // Output is written to the intermediate buffer.
+ // pIn The input buffer with the format designated in configure().
+ // When function exist will point to the next unread input
+ // sample.
+ // numSamples The number of single-channel samples to process.
+ void ConvertInput(const void *& pIn, uint32_t numSamples) {
+ if (mPcmFormat == PCM_FORMAT_S15) {
+ const int16_t * pIn16 = reinterpret_cast<const int16_t *>(pIn);
+ audio_sample_t * pOut = mBuffer;
+ while (numSamples-- > 0) {
+ *(pOut++) = s15_to_audio_sample_t(*(pIn16++));
+ }
+ pIn = pIn16;
+ } else {
+ assert(false);
+ }
+ }
+
+ // Converts audio_sample_t samples from the intermediate buffer to the
+ // output buffer, converting to the desired format and buffer behavior.
+ // pOut The buffer to write the output to.
+ // When function exist will point to the next output sample.
+ // numSamples The number of single-channel samples to process.
+ void ConvertOutput(void *& pOut, uint32_t numSamples) {
+ if (mPcmFormat == PCM_FORMAT_S15) {
+ const audio_sample_t * pIn = mBuffer;
+ int16_t * pOut16 = reinterpret_cast<int16_t *>(pOut);
+ if (mBehavior == EFFECT_BUFFER_ACCESS_WRITE) {
+ while (numSamples-- > 0) {
+ *(pOut16++) = audio_sample_t_to_s15_clip(*(pIn++));
+ }
+ } else if (mBehavior == EFFECT_BUFFER_ACCESS_ACCUMULATE) {
+ while (numSamples-- > 0) {
+ *(pOut16++) += audio_sample_t_to_s15_clip(*(pIn++));
+ }
+ } else {
+ assert(false);
+ }
+ pOut = pOut16;
+ } else {
+ assert(false);
+ }
+ }
+
+ // Accumulate data from the intermediate buffer to the output. Output is
+ // assumed to be of audio_sample_t type.
+ // pOut The buffer to mix the output to.
+ // When function exist will point to the next output sample.
+ // numSamples The number of single-channel samples to process.
+ void MixOutput(void *& pOut, uint32_t numSamples) {
+ const audio_sample_t * pIn = mBuffer;
+ audio_sample_t * pOut24 = reinterpret_cast<audio_sample_t *>(pOut);
+ numSamples *= mNumChannels;
+ while (numSamples-- > 0) {
+ *(pOut24++) += *(pIn++);
+ }
+ pOut = pOut24;
+ }
+};
+
+}
+
+#endif // AUDIOFORMATADAPTER_H_
diff --git a/media/libeffects/AudioHighShelfFilterCoef.inl b/media/libeffects/AudioHighShelfFilterCoef.inl
new file mode 100644
index 0000000..ebba139
--- /dev/null
+++ b/media/libeffects/AudioHighShelfFilterCoef.inl
@@ -0,0 +1,225 @@
+13679,
+21575,
+8921,
+32315056,
+-15582015,
+26172,
+37678,
+14797,
+31891096,
+-15192527,
+51020,
+64449,
+23945,
+31322988,
+-14685186,
+101817,
+106144,
+37744,
+30562882,
+-14031372,
+208996,
+162163,
+58536,
+29548538,
+-13201017,
+442996,
+207459,
+93300,
+28200792,
+-12167331,
+971423,
+128786,
+169690,
+26422744,
+-10915428,
+2200461,
+-465686,
+394986,
+24103317,
+-9455862,
+5119991,
+-2777199,
+1147245,
+21129473,
+-7842294,
+12120379,
+-10198160,
+3631544,
+17411837,
+-6188384,
+28834234,
+-31647135,
+11337795,
+12924960,
+-4672638,
+68037766,
+-88974388,
+33477255,
+7752680,
+-3516098,
+157369944,
+-232063160,
+92282129,
+2113926,
+-2925624,
+353720112,
+-567427144,
+237164112,
+-3659993,
+-3019871,
+769091151,
+-1309871949,
+570539430,
+-9202114,
+-3779302,
+66791,
+121706,
+55888,
+30571245,
+-14038415,
+120426,
+212178,
+94820,
+29559679,
+-13209886,
+217130,
+365165,
+157610,
+28215554,
+-12178243,
+391489,
+617016,
+255010,
+26442131,
+-10928431,
+705862,
+1015147,
+398457,
+24128430,
+-9470680,
+1272682,
+1605251,
+596102,
+21161334,
+-7858153,
+2294668,
+2386833,
+848523,
+17451072,
+-6203880,
+4137327,
+3198789,
+1155536,
+12971362,
+-4685798,
+7459675,
+3470266,
+1567219,
+7804818,
+-3524761,
+13449926,
+1738911,
+2347406,
+2169089,
+-2928116,
+24250455,
+-5211241,
+4358971,
+-3605298,
+-3015671,
+43724001,
+-23849570,
+9823315,
+-9151253,
+-3769277,
+78835150,
+-66542375,
+23686373,
+-14161143,
+-5040790,
+142141173,
+-156324261,
+56024234,
+-18451275,
+-6612656,
+256283057,
+-335606326,
+126341244,
+-21970004,
+-8270755,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
+16777216,
+33554432,
+16777216,
+-33554432,
+-16777216,
diff --git a/media/libeffects/AudioLowShelfFilterCoef.inl b/media/libeffects/AudioLowShelfFilterCoef.inl
new file mode 100644
index 0000000..b57deb4
--- /dev/null
+++ b/media/libeffects/AudioLowShelfFilterCoef.inl
@@ -0,0 +1,375 @@
+16212506,
+-32420574,
+16208068,
+32401411,
+-15662521,
+16356129,
+-32706246,
+16350118,
+32695525,
+-15939752,
+16464399,
+-32920670,
+16456274,
+32914686,
+-16149441,
+16546128,
+-33081289,
+16535165,
+33077955,
+-16307411,
+16608101,
+-33201422,
+16593328,
+33199569,
+-16426067,
+16655539,
+-33291174,
+16635647,
+33290147,
+-16514997,
+16692478,
+-33358171,
+16665715,
+33357608,
+-16581540,
+16722089,
+-33408149,
+16686099,
+33407850,
+-16631271,
+16746930,
+-33445409,
+16698549,
+33445267,
+-16668405,
+16769156,
+-33473168,
+16704138,
+33473133,
+-16696114,
+16790706,
+-33493827,
+16703348,
+33493886,
+-16716779,
+16813466,
+-33509166,
+16696111,
+33509342,
+-16732186,
+16839437,
+-33520498,
+16681802,
+33520852,
+-16743669,
+16870911,
+-33528765,
+16659191,
+33529424,
+-16752226,
+16910681,
+-33534607,
+16626337,
+33535807,
+-16758602,
+15667401,
+-31326224,
+15658825,
+31252161,
+-14623074,
+15945865,
+-31880007,
+15934146,
+31838205,
+-15144597,
+16157521,
+-32299091,
+16141578,
+32275604,
+-15545369,
+16318267,
+-32614903,
+16296651,
+32601755,
+-15850850,
+16440710,
+-32852157,
+16411473,
+32844820,
+-16082303,
+16534751,
+-33029985,
+16495281,
+33025910,
+-16256891,
+16608171,
+-33163043,
+16554957,
+33160803,
+-16388152,
+16667145,
+-33262468,
+16595477,
+33261275,
+-16486599,
+16716699,
+-33336671,
+16620252,
+33336105,
+-16560301,
+16761100,
+-33391976,
+16631379,
+33391836,
+-16615404,
+16804207,
+-33433103,
+16629806,
+33433341,
+-16656560,
+16849794,
+-33463551,
+16615399,
+33464251,
+-16687277,
+16901887,
+-33485857,
+16586933,
+33487271,
+-16710189,
+16965125,
+-33501781,
+16542000,
+33504415,
+-16727274,
+17045198,
+-33512384,
+16476824,
+33517183,
+-16740008,
+14635201,
+-29254376,
+14619184,
+28977711,
+-12753834,
+15157556,
+-30292825,
+15135285,
+30133938,
+-13674513,
+15561511,
+-31092298,
+15530817,
+31001860,
+-14405551,
+15872211,
+-31702342,
+15830187,
+31651218,
+-14976306,
+16111094,
+-32164834,
+16053843,
+32136101,
+-15416453,
+16295848,
+-32513802,
+16218140,
+32497757,
+-15752817,
+16440852,
+-32776179,
+16335665,
+32767326,
+-16008155,
+16557804,
+-32972907,
+16415715,
+32968179,
+-16201031,
+16656403,
+-33120052,
+16464758,
+33117802,
+-16346195,
+16745001,
+-33229805,
+16486810,
+33229247,
+-16455153,
+16831240,
+-33311306,
+16483692,
+33312252,
+-16536771,
+16922682,
+-33371278,
+16455145,
+33374070,
+-16597819,
+17027472,
+-33414465,
+16398818,
+33420110,
+-16643430,
+17155108,
+-33443875,
+16310110,
+33454398,
+-16677479,
+17317384,
+-33460760,
+16181887,
+33479933,
+-16702882,
+12792703,
+-25557388,
+12764716,
+24590507,
+-9747085,
+13706465,
+-27372621,
+13666215,
+26798296,
+-11169790,
+14439425,
+-28821830,
+14382518,
+28486469,
+-12380088,
+15018453,
+-29957273,
+14939030,
+29764018,
+-13373522,
+15472460,
+-30834757,
+15362688,
+30724568,
+-14168120,
+15828725,
+-31506123,
+15678118,
+31443928,
+-14791822,
+16111406,
+-32015988,
+15905901,
+31981391,
+-15274688,
+16341329,
+-32400984,
+16062061,
+32382398,
+-15644761,
+16536484,
+-32690238,
+16158133,
+32681354,
+-15926286,
+16712853,
+-32906337,
+16201432,
+32904128,
+-16139278,
+16885430,
+-33066336,
+16195306,
+33070090,
+-16299767,
+17069377,
+-33182599,
+16139282,
+33193711,
+-16420332,
+17281371,
+-33263294,
+16029039,
+33285785,
+-16510702,
+17541271,
+-33312390,
+15856243,
+33354359,
+-16578329,
+17874330,
+-33328902,
+15608287,
+33405430,
+-16628873,
+9881279,
+-19719268,
+9838084,
+16734303,
+-5927111,
+11264857,
+-22463447,
+11198784,
+20577584,
+-7572288,
+12460736,
+-24823046,
+12362697,
+23667359,
+-9201903,
+13459805,
+-26776851,
+13317799,
+26085683,
+-10691555,
+14276287,
+-28349256,
+14074406,
+27943899,
+-11978834,
+14936943,
+-29588248,
+14654011,
+29354533,
+-13047453,
+15473300,
+-30549299,
+15081036,
+30417203,
+-13909216,
+15917271,
+-31285788,
+15377817,
+31213972,
+-14589687,
+16299384,
+-31844320,
+15562006,
+31809683,
+-15118811,
+16648774,
+-32262999,
+15645414,
+32254329,
+-15525641,
+16994277,
+-32571090,
+15633607,
+32585895,
+-15835862,
+17366374,
+-32789019,
+15525801,
+32833003,
+-16070975,
+17799955,
+-32927834,
+15314895,
+33017107,
+-16248361,
+18338206,
+-32987318,
+14987686,
+33154246,
+-16381747,
+19038270,
+-32951545,
+14525592,
+33256392,
+-16481800,
diff --git a/media/libeffects/AudioPeakingFilter.cpp b/media/libeffects/AudioPeakingFilter.cpp
new file mode 100644
index 0000000..60fefe6
--- /dev/null
+++ b/media/libeffects/AudioPeakingFilter.cpp
@@ -0,0 +1,121 @@
+/* //device/include/server/AudioFlinger/AudioPeakingFilter.cpp
+ **
+ ** Copyright 2007, The Android Open Source Project
+ **
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ **
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ **
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ */
+
+#include "AudioPeakingFilter.h"
+#include "AudioCommon.h"
+#include "EffectsMath.h"
+
+#include <new>
+#include <assert.h>
+
+#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
+#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
+
+namespace android {
+// Format of the coefficient table:
+// kCoefTable[freq][gain][bw][coef]
+// freq - peak frequency, in octaves below Nyquist,from -9 to -1.
+// gain - gain, in millibel, starting at -9600, jumps of 1024, to 4736 millibel.
+// bw - bandwidth, starting at 1 cent, jumps of 1024, to 3073 cents.
+// coef - 0: b0
+// 1: b1
+// 2: b2
+// 3: -a1
+// 4: -a2
+static const size_t kInDims[3] = {9, 15, 4};
+static const audio_coef_t kCoefTable[9*15*4*5] = {
+#include "AudioPeakingFilterCoef.inl"
+};
+
+AudioCoefInterpolator AudioPeakingFilter::mCoefInterp(3, kInDims, 5, (const audio_coef_t*) kCoefTable);
+
+AudioPeakingFilter::AudioPeakingFilter(int nChannels, int sampleRate)
+ : mBiquad(nChannels, sampleRate) {
+ configure(nChannels, sampleRate);
+ reset();
+}
+
+void AudioPeakingFilter::configure(int nChannels, int sampleRate) {
+ mNiquistFreq = sampleRate * 500;
+ mFrequencyFactor = ((1ull) << 42) / mNiquistFreq;
+ mBiquad.configure(nChannels, sampleRate);
+ setFrequency(mNominalFrequency);
+ commit(true);
+}
+
+void AudioPeakingFilter::reset() {
+ setGain(0);
+ setFrequency(0);
+ setBandwidth(2400);
+ commit(true);
+}
+
+void AudioPeakingFilter::setFrequency(uint32_t millihertz) {
+ mNominalFrequency = millihertz;
+ if (UNLIKELY(millihertz > mNiquistFreq / 2)) {
+ millihertz = mNiquistFreq / 2;
+ }
+ uint32_t normFreq = static_cast<uint32_t>(
+ (static_cast<uint64_t>(millihertz) * mFrequencyFactor) >> 10);
+ if (LIKELY(normFreq > (1 << 23))) {
+ mFrequency = (Effects_log2(normFreq) - ((32-9) << 15)) << (FREQ_PRECISION_BITS - 15);
+ } else {
+ mFrequency = 0;
+ }
+}
+
+void AudioPeakingFilter::setGain(int32_t millibel) {
+ mGain = millibel + 9600;
+}
+
+void AudioPeakingFilter::setBandwidth(uint32_t cents) {
+ mBandwidth = cents - 1;
+}
+
+void AudioPeakingFilter::commit(bool immediate) {
+ audio_coef_t coefs[5];
+ int intCoord[3] = {
+ mFrequency >> FREQ_PRECISION_BITS,
+ mGain >> GAIN_PRECISION_BITS,
+ mBandwidth >> BANDWIDTH_PRECISION_BITS
+ };
+ uint32_t fracCoord[3] = {
+ mFrequency << (32 - FREQ_PRECISION_BITS),
+ static_cast<uint32_t>(mGain) << (32 - GAIN_PRECISION_BITS),
+ mBandwidth << (32 - BANDWIDTH_PRECISION_BITS)
+ };
+ mCoefInterp.getCoef(intCoord, fracCoord, coefs);
+ mBiquad.setCoefs(coefs, immediate);
+}
+
+void AudioPeakingFilter::getBandRange(uint32_t & low, uint32_t & high) const {
+ // Half bandwidth, in octaves, 15-bit precision
+ int32_t halfBW = (((mBandwidth + 1) / 2) << 15) / 1200;
+
+ low = static_cast<uint32_t>((static_cast<uint64_t>(mNominalFrequency) * Effects_exp2(-halfBW + (16 << 15))) >> 16);
+ if (UNLIKELY(halfBW >= (16 << 15))) {
+ high = mNiquistFreq;
+ } else {
+ high = static_cast<uint32_t>((static_cast<uint64_t>(mNominalFrequency) * Effects_exp2(halfBW + (16 << 15))) >> 16);
+ if (UNLIKELY(high > mNiquistFreq)) {
+ high = mNiquistFreq;
+ }
+ }
+}
+
+}
+
diff --git a/media/libeffects/AudioPeakingFilter.h b/media/libeffects/AudioPeakingFilter.h
new file mode 100644
index 0000000..d0f49c9
--- /dev/null
+++ b/media/libeffects/AudioPeakingFilter.h
@@ -0,0 +1,151 @@
+/* //device/include/server/AudioFlinger/AudioPeakingFilter.h
+**
+** Copyright 2009, 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_AUDIO_PEAKING_FILTER_H
+#define ANDROID_AUDIO_PEAKING_FILTER_H
+
+#include "AudioBiquadFilter.h"
+#include "AudioCoefInterpolator.h"
+
+namespace android {
+
+// A peaking audio filter, with unity skirt gain, and controllable peak
+// frequency, gain and bandwidth.
+// This filter is able to suppress introduce discontinuities and other artifacts
+// in the output, even when changing parameters abruptly.
+// Parameters can be set to any value - this class will make sure to clip them
+// when they are out of supported range.
+//
+// Implementation notes:
+// This class uses an underlying biquad filter whose parameters are determined
+// using a linear interpolation from a coefficient table, using a
+// AudioCoefInterpolator.
+// All is left for this class to do is mapping between high-level parameters to
+// fractional indices into the coefficient table.
+class AudioPeakingFilter {
+public:
+ // Constructor. Resets the filter (see reset()).
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ AudioPeakingFilter(int nChannels, int sampleRate);
+
+ // Reconfiguration of the filter. Changes input/output format, but does not
+ // alter current parameter values. Clears delay lines.
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ void configure(int nChannels, int sampleRate);
+
+ // Resets the filter parameters to the following values:
+ // frequency: 0
+ // gain: 0
+ // bandwidth: 1200 cents.
+ // It also disables the filter. Does not clear the delay lines.
+ void reset();
+
+ // Clears delay lines. Does not alter parameter values.
+ void clear() { mBiquad.clear(); }
+
+ // Sets gain value. Actual change will only take place upon commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // millibel Gain value in millibel (1/100 of decibel).
+ void setGain(int32_t millibel);
+
+ // Gets the gain, in millibel, as set.
+ int32_t getGain() const { return mGain - 9600; }
+
+ // Sets bandwidth value. Actual change will only take place upon commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // cents Bandwidth value in cents (1/1200 octave).
+ void setBandwidth(uint32_t cents);
+
+ // Gets the gain, in cents, as set.
+ uint32_t getBandwidth() const { return mBandwidth + 1; }
+
+ // Sets frequency value. Actual change will only take place upon commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // millihertz Frequency value in mHz.
+ void setFrequency(uint32_t millihertz);
+
+ // Gets the frequency, in mHz, as set.
+ uint32_t getFrequency() const { return mNominalFrequency; }
+
+ // Gets gain[dB]/2 points.
+ // Results in mHz, and are computed based on the nominal values set, not on
+ // possibly rounded or truncated actual values.
+ void getBandRange(uint32_t & low, uint32_t & high) const;
+
+ // Applies all parameter changes done to this point in time.
+ // If the filter is disabled, the new parameters will take place when it is
+ // enabled again. Does not introduce artifacts, unless immediate is set.
+ // immediate Whether to apply change abruptly (ignored if filter is
+ // disabled).
+ void commit(bool immediate = false);
+
+ // Process a buffer of input data. The input and output should contain
+ // frameCount * nChannels interlaced samples. Processing can be done
+ // in-place, by passing the same buffer as both arguments.
+ // in Input buffer.
+ // out Output buffer.
+ // frameCount Number of frames to produce.
+ void process(const audio_sample_t in[], audio_sample_t out[],
+ int frameCount) { mBiquad.process(in, out, frameCount); }
+
+ // Enables the filter, so it would start processing input. Does not
+ // introduce artifacts, unless immediate is set.
+ // immediate Whether to apply change abruptly.
+ void enable(bool immediate = false) { mBiquad.enable(immediate); }
+
+ // Disabled (bypasses) the filter. Does not introduce artifacts, unless
+ // immediate is set.
+ // immediate Whether to apply change abruptly.
+ void disable(bool immediate = false) { mBiquad.disable(immediate); }
+
+private:
+ // Precision for the mFrequency member.
+ static const int FREQ_PRECISION_BITS = 26;
+ // Precision for the mGain member.
+ static const int GAIN_PRECISION_BITS = 10;
+ // Precision for the mBandwidth member.
+ static const int BANDWIDTH_PRECISION_BITS = 10;
+
+ // Nyquist, in mHz.
+ uint32_t mNiquistFreq;
+ // Fractional index into the gain dimension of the coef table in
+ // GAIN_PRECISION_BITS precision.
+ int32_t mGain;
+ // Fractional index into the bandwidth dimension of the coef table in
+ // BANDWIDTH_PRECISION_BITS precision.
+ uint32_t mBandwidth;
+ // Fractional index into the frequency dimension of the coef table in
+ // FREQ_PRECISION_BITS precision.
+ uint32_t mFrequency;
+ // Nominal value of frequency, as set.
+ uint32_t mNominalFrequency;
+ // 1/Nyquist[mHz], in 42-bit precision (very small).
+ // Used for scaling the frequency.
+ uint32_t mFrequencyFactor;
+
+ // A biquad filter, used for the actual processing.
+ AudioBiquadFilter mBiquad;
+ // A coefficient interpolator, used for mapping the high level parameters to
+ // the low-level biquad coefficients.
+ static AudioCoefInterpolator mCoefInterp;
+};
+
+}
+
+#endif // ANDROID_AUDIO_PEAKING_FILTER_H
diff --git a/media/libeffects/AudioPeakingFilterCoef.inl b/media/libeffects/AudioPeakingFilterCoef.inl
new file mode 100644
index 0000000..374c6e1
--- /dev/null
+++ b/media/libeffects/AudioPeakingFilterCoef.inl
@@ -0,0 +1,2700 @@
+16769751,
+-33538871,
+16769751,
+33538871,
+-16762286,
+11468083,
+-22935566,
+11467915,
+22935566,
+-6158781,
+8532673,
+-17064763,
+8532412,
+17064763,
+-287869,
+6567366,
+-13134160,
+6567042,
+13134160,
+3642808,
+16773075,
+-33545518,
+16773075,
+33545518,
+-16768934,
+13349658,
+-26698459,
+13349304,
+26698459,
+-9921746,
+10923581,
+-21846147,
+10922977,
+21846147,
+-5069342,
+9009390,
+-18017641,
+9008590,
+18017641,
+-1240764,
+16774919,
+-33549207,
+16774919,
+33549207,
+-16772622,
+14686150,
+-29371047,
+14685450,
+29371047,
+-12594384,
+12933736,
+-25865697,
+12932448,
+25865697,
+-9088968,
+11350364,
+-22698482,
+11348545,
+22698482,
+-5921693,
+16775943,
+-33551252,
+16775941,
+33551252,
+-16774668,
+15549746,
+-31097569,
+15548408,
+31097569,
+-14320938,
+14404163,
+-28805197,
+14401577,
+28805197,
+-12028524,
+13261978,
+-26519626,
+13258147,
+26519626,
+-9742909,
+16776511,
+-33552387,
+16776508,
+33552387,
+-16775803,
+16074349,
+-32145600,
+16071856,
+32145600,
+-15368989,
+15374244,
+-30742933,
+15369268,
+30742933,
+-13966296,
+14629431,
+-29250695,
+14621814,
+29250695,
+-12474030,
+16776826,
+-33553017,
+16776822,
+33553017,
+-16776432,
+16381548,
+-32757900,
+16376968,
+32757900,
+-15981300,
+15972161,
+-31934402,
+15962842,
+31934402,
+-15157787,
+15518882,
+-31022614,
+15504316,
+31022614,
+-14245982,
+16777003,
+-33553366,
+16776995,
+33553366,
+-16776781,
+16558315,
+-33107660,
+16549969,
+33107660,
+-16331067,
+16326848,
+-32635910,
+16309677,
+32635910,
+-15859308,
+16064456,
+-32101133,
+16037281,
+32101133,
+-15324521,
+16777103,
+-33553559,
+16777088,
+33553559,
+-16776975,
+16660325,
+-33304885,
+16645187,
+33304885,
+-16528296,
+16535200,
+-33038436,
+16503858,
+33038436,
+-16261842,
+16391425,
+-32732273,
+16341464,
+32732273,
+-15955673,
+16777162,
+-33553667,
+16777136,
+33553667,
+-16777082,
+16721651,
+-33415288,
+16694267,
+33415288,
+-16638701,
+16661761,
+-33265997,
+16604862,
+33265997,
+-16489407,
+16592417,
+-33093137,
+16501343,
+33093137,
+-16316544,
+16777203,
+-33553726,
+16777155,
+33553726,
+-16777142,
+16763466,
+-33476836,
+16714001,
+33476836,
+-16700251,
+16748588,
+-33393565,
+16645605,
+33393565,
+-16616978,
+16731288,
+-33296733,
+16566071,
+33296733,
+-16520144,
+16777238,
+-33553759,
+16777152,
+33553759,
+-16777175,
+16800489,
+-33511071,
+16711212,
+33511071,
+-16734485,
+16825723,
+-33464740,
+16639647,
+33464740,
+-16688154,
+16855137,
+-33410736,
+16556228,
+33410736,
+-16634149,
+16777282,
+-33553778,
+16777127,
+33553778,
+-16777193,
+16845889,
+-33530088,
+16684830,
+33530088,
+-16753503,
+16920437,
+-33504347,
+16584541,
+33504347,
+-16727762,
+17007449,
+-33474302,
+16467484,
+33474302,
+-16697716,
+16777349,
+-33553788,
+16777070,
+33553788,
+-16777203,
+16915880,
+-33540645,
+16625396,
+33540645,
+-16764060,
+17066504,
+-33526354,
+16460481,
+33526354,
+-16749769,
+17242444,
+-33509662,
+16267849,
+33509662,
+-16733077,
+16777464,
+-33553793,
+16776961,
+33553793,
+-16777209,
+17035487,
+-33546503,
+16511647,
+33546503,
+-16769918,
+17316137,
+-33538572,
+16223067,
+33538572,
+-16761988,
+17644089,
+-33529306,
+15885848,
+33529306,
+-16752721,
+16777668,
+-33553796,
+16776760,
+33553796,
+-16777212,
+17247484,
+-33549752,
+16302900,
+33549752,
+-16773168,
+17758603,
+-33545353,
+15787381,
+33545353,
+-16768768,
+18356007,
+-33540211,
+15184835,
+33540211,
+-16763626,
+16762293,
+-33522062,
+16762293,
+33522062,
+-16747370,
+8711405,
+-17421242,
+8711149,
+17421242,
+-645338,
+5721250,
+-11441288,
+5720900,
+11441288,
+5335066,
+4082836,
+-8164655,
+4082434,
+8164655,
+8611946,
+16768936,
+-33535347,
+16768936,
+33535347,
+-16760656,
+11085056,
+-22167856,
+11084469,
+22167856,
+-5392309,
+8098223,
+-16194333,
+8097329,
+16194333,
+581664,
+6158323,
+-12314623,
+6157228,
+12314623,
+4461665,
+16772623,
+-33542719,
+16772622,
+33542719,
+-16768029,
+13058634,
+-26114055,
+13057388,
+26114055,
+-9338806,
+10523211,
+-21042742,
+10521116,
+21042742,
+-4267110,
+8576560,
+-17149081,
+8573812,
+17149081,
+-373156,
+16774670,
+-33546810,
+16774667,
+33546810,
+-16772120,
+14489725,
+-28974776,
+14487233,
+28974776,
+-12199742,
+12619509,
+-25232587,
+12614979,
+25232587,
+-8457271,
+10965151,
+-21922319,
+10958818,
+21922319,
+-5146753,
+16775805,
+-33549079,
+16775800,
+33549079,
+-16774390,
+15428102,
+-30849095,
+15423317,
+30849095,
+-14074202,
+14188157,
+-28364996,
+14178975,
+28364996,
+-11589916,
+12969900,
+-25924346,
+12956398,
+25924346,
+-9149082,
+16776437,
+-33550338,
+16776428,
+33550338,
+-16775648,
+16004216,
+-31997074,
+15995268,
+31997074,
+-15222267,
+15241233,
+-30462393,
+15223454,
+30462393,
+-13687471,
+14437070,
+-28844880,
+14409982,
+28844880,
+-12069836,
+16776789,
+-33551036,
+16776773,
+33551036,
+-16776347,
+16345158,
+-32671383,
+16328685,
+32671383,
+-15896627,
+15900462,
+-31765104,
+15867034,
+31765104,
+-14990280,
+15410846,
+-30767279,
+15358750,
+30767279,
+-13992380,
+16776990,
+-33551423,
+16776960,
+33551423,
+-16776734,
+16545156,
+-33057769,
+16515103,
+33057769,
+-16283043,
+16300504,
+-32536823,
+16238769,
+32536823,
+-15762058,
+16024071,
+-31948201,
+15926537,
+31948201,
+-15173391,
+16777109,
+-33551638,
+16777056,
+33551638,
+-16776949,
+16666542,
+-33276035,
+16611999,
+33276035,
+-16501325,
+16548270,
+-32981225,
+16435439,
+32981225,
+-16206493,
+16412621,
+-32643103,
+16232940,
+32643103,
+-15868346,
+16777189,
+-33551757,
+16777094,
+33551757,
+-16777068,
+16749778,
+-33398338,
+16651075,
+33398338,
+-16623637,
+16720233,
+-33232976,
+16515245,
+33232976,
+-16458262,
+16686059,
+-33041706,
+16358135,
+33041706,
+-16266978,
+16777261,
+-33551823,
+16777089,
+33551823,
+-16777134,
+16823703,
+-33466559,
+16645376,
+33466559,
+-16691863,
+16873974,
+-33374267,
+16502806,
+33374267,
+-16599564,
+16932398,
+-33267006,
+16337114,
+33267006,
+-16492295,
+16777348,
+-33551860,
+16777038,
+33551860,
+-16777170,
+16914465,
+-33504517,
+16592574,
+33504517,
+-16729824,
+17063236,
+-33453150,
+16392432,
+33453150,
+-16678453,
+17236595,
+-33393293,
+16159213,
+33393293,
+-16618592,
+16777483,
+-33551880,
+16776924,
+33551880,
+-16777191,
+17054436,
+-33525606,
+16473695,
+33525606,
+-16750914,
+17355321,
+-33497061,
+16144262,
+33497061,
+-16722367,
+17706453,
+-33463749,
+15759816,
+33463749,
+-16689053,
+16777713,
+-33551891,
+16776705,
+33551891,
+-16777202,
+17293646,
+-33537314,
+16246194,
+33537314,
+-16762623,
+17854571,
+-33521465,
+15669419,
+33521465,
+-16746773,
+18509706,
+-33502954,
+14995772,
+33502954,
+-16728261,
+16778120,
+-33551898,
+16776304,
+33551898,
+-16777208,
+17717639,
+-33543811,
+15828698,
+33543811,
+-16769121,
+18739501,
+-33535016,
+14798040,
+33535016,
+-16760325,
+19933534,
+-33524738,
+13593729,
+33524738,
+-16750047,
+16747397,
+-33484705,
+16747396,
+33484705,
+-16717577,
+5883112,
+-11762335,
+5882767,
+11762335,
+5011337,
+3448701,
+-6894903,
+3448279,
+6894903,
+9880236,
+2324286,
+-4646714,
+2323828,
+4646714,
+12129102,
+16760665,
+-33511232,
+16760663,
+33511232,
+-16744112,
+8276984,
+-16548106,
+8276108,
+16548106,
+224124,
+5337400,
+-10670406,
+5336221,
+10670406,
+6103596,
+3771525,
+-7539439,
+3770185,
+7539439,
+9235506,
+16768033,
+-33525963,
+16768030,
+33525963,
+-16758848,
+10689564,
+-21370649,
+10687524,
+21370649,
+-4599872,
+7666068,
+-15324466,
+7663015,
+15324466,
+1448133,
+5761266,
+-11515371,
+5757575,
+11515371,
+5258376,
+16772124,
+-33534139,
+16772118,
+33534139,
+-16767026,
+12751423,
+-25490780,
+12747036,
+25490780,
+-8721243,
+10113942,
+-20214533,
+10106682,
+20214533,
+-3443407,
+8145025,
+-16275741,
+8135620,
+16275741,
+496571,
+16774395,
+-33538675,
+16774385,
+33538675,
+-16771564,
+14280137,
+-28542819,
+14271281,
+28542819,
+-11774202,
+12292391,
+-24561476,
+12276485,
+24561476,
+-7791660,
+10572949,
+-21117532,
+10550945,
+21117532,
+-4346678,
+16775657,
+-33541192,
+16775639,
+33541192,
+-16774081,
+15299683,
+-30573051,
+15282579,
+30573051,
+-13805046,
+13964251,
+-27887539,
+13931690,
+27887539,
+-11118724,
+12672686,
+-25290241,
+12625174,
+25290241,
+-8520644,
+16776363,
+-33542588,
+16776330,
+33542588,
+-16775477,
+15935196,
+-31828699,
+15903092,
+31828699,
+-15061072,
+15112356,
+-30152153,
+15048881,
+30152153,
+-13384021,
+14253857,
+-28402950,
+14157649,
+28402950,
+-11634291,
+16776763,
+-33543362,
+16776704,
+33543362,
+-16776252,
+16319830,
+-32570615,
+16260598,
+32570615,
+-15803212,
+15851783,
+-31574208,
+15731938,
+31574208,
+-14806505,
+15339614,
+-30483871,
+15153441,
+30483871,
+-13715838,
+16777001,
+-33543791,
+16776896,
+33543791,
+-16776681,
+16557673,
+-32997208,
+16449476,
+32997208,
+-16229933,
+16326977,
+-32422299,
+16105089,
+32422299,
+-15654851,
+16067244,
+-31775024,
+15717353,
+31775024,
+-15007381,
+16777163,
+-33544029,
+16776972,
+33544029,
+-16776919,
+16722590,
+-33238660,
+16526083,
+33238660,
+-16471458,
+16664322,
+-32912610,
+16258203,
+32912610,
+-16145310,
+16597629,
+-32539419,
+15951593,
+32539419,
+-15772007,
+16777306,
+-33544162,
+16776962,
+33544162,
+-16777051,
+16869955,
+-33374105,
+16514205,
+33374105,
+-16606944,
+16969714,
+-33190996,
+16231282,
+33190996,
+-16423780,
+17084972,
+-32979442,
+15904406,
+32979442,
+-16212162,
+16777480,
+-33544235,
+16776860,
+33544235,
+-16777125,
+17051328,
+-33449703,
+16408452,
+33449703,
+-16682565,
+17347583,
+-33347437,
+16009901,
+33347437,
+-16580267,
+17691668,
+-33228659,
+15547002,
+33228659,
+-16461454,
+16777750,
+-33544275,
+16776632,
+33544275,
+-16777165,
+17331222,
+-33491780,
+16170648,
+33491780,
+-16724654,
+17931550,
+-33434840,
+15513363,
+33434840,
+-16667697,
+18630855,
+-33368512,
+14747710,
+33368512,
+-16601349,
+16778210,
+-33544298,
+16776194,
+33544298,
+-16777188,
+17809628,
+-33515162,
+15715631,
+33515162,
+-16748043,
+18929991,
+-33483514,
+14563611,
+33483514,
+-16716385,
+20237212,
+-33446587,
+13219451,
+33446587,
+-16679448,
+16779025,
+-33544310,
+16775392,
+33544310,
+-16777200,
+18657612,
+-33528145,
+14880634,
+33528145,
+-16761030,
+20699844,
+-33510571,
+12820822,
+33510571,
+-16743451,
+23084863,
+-33490047,
+10415274,
+33490047,
+-16722921,
+16717684,
+-33395091,
+16717682,
+33395091,
+-16658149,
+3567009,
+-7125006,
+3566590,
+7125006,
+9643617,
+1921926,
+-3838751,
+1921455,
+3838751,
+12933835,
+1248662,
+-2493824,
+1248170,
+2493824,
+14280384,
+16744147,
+-33447952,
+16744143,
+33447952,
+-16711074,
+5493785,
+-10973174,
+5492622,
+10973174,
+5790808,
+3173694,
+-6338342,
+3172292,
+6338342,
+10431230,
+2124754,
+-4242881,
+2123244,
+4242881,
+12529218,
+16758861,
+-33477342,
+16758855,
+33477342,
+-16740500,
+7843885,
+-15665884,
+7840892,
+15665884,
+1092439,
+4968649,
+-9921376,
+4964692,
+9921376,
+6843875,
+3478437,
+-6944043,
+3473981,
+6944043,
+9824798,
+16767035,
+-33493665,
+16767024,
+33493665,
+-16756842,
+10284421,
+-20536999,
+10277346,
+20536999,
+-3784550,
+7240254,
+-14452686,
+7229862,
+14452686,
+2307100,
+5379798,
+-10734231,
+5367379,
+10734231,
+6030039,
+16771575,
+-33502725,
+16771555,
+33502725,
+-16765913,
+12431046,
+-24816749,
+12415632,
+24816749,
+-8069462,
+9702049,
+-19355664,
+9676957,
+19355664,
+-2601790,
+7722611,
+-15394544,
+7690499,
+15394544,
+1364106,
+16774099,
+-33507752,
+16774063,
+33507752,
+-16770946,
+14062583,
+-28059903,
+14031160,
+28059903,
+-11316527,
+11962999,
+-23841519,
+11907273,
+23841519,
+-7093056,
+10188929,
+-20277142,
+10112667,
+20277142,
+-3524380,
+16775510,
+-33510541,
+16775445,
+33510541,
+-16773738,
+15175102,
+-30252637,
+15114019,
+30252637,
+-13511905,
+13753207,
+-27358123,
+13637911,
+27358123,
+-10613901,
+12400971,
+-24605416,
+12234119,
+24605416,
+-7857874,
+16776310,
+-33512088,
+16776193,
+33512088,
+-16775287,
+15888242,
+-31623221,
+15773117,
+31623221,
+-14884143,
+15028972,
+-29795608,
+14802570,
+29795608,
+-13054325,
+14142237,
+-27909578,
+13801000,
+27909578,
+-11166021,
+16776787,
+-33512946,
+16776575,
+33512946,
+-16776146,
+16345172,
+-32438302,
+16132251,
+32438302,
+-15700207,
+15905856,
+-31344484,
+15476429,
+31344484,
+-14605069,
+15428324,
+-30155514,
+14763558,
+30155514,
+-13414665,
+16777110,
+-33513422,
+16776729,
+33513422,
+-16776623,
+16668950,
+-32908744,
+16279482,
+32908744,
+-16171216,
+16555594,
+-32275015,
+15758344,
+32275015,
+-15536722,
+16428465,
+-31564284,
+15173886,
+31564284,
+-14825134,
+16777395,
+-33513686,
+16776708,
+33513686,
+-16776887,
+16961758,
+-33175594,
+16253845,
+33175594,
+-16438387,
+17158212,
+-32815329,
+15696692,
+32815329,
+-16077688,
+17382578,
+-32403880,
+15060381,
+32403880,
+-15665743,
+16777745,
+-33513832,
+16776505,
+33513832,
+-16777033,
+17323903,
+-33325470,
+16041757,
+33325470,
+-16588444,
+17911332,
+-33122874,
+15251488,
+33122874,
+-16385604,
+18589203,
+-32889086,
+14339546,
+32889086,
+-16151534,
+16778283,
+-33513913,
+16776048,
+33513913,
+-16777115,
+17883505,
+-33409180,
+15565966,
+33409180,
+-16672255,
+19078451,
+-33295944,
+14257648,
+33295944,
+-16558883,
+20465440,
+-33164510,
+12739067,
+33164510,
+-16427290,
+16779203,
+-33513958,
+16775173,
+33513958,
+-16777160,
+18840265,
+-33455789,
+14655871,
+33455789,
+-16718921,
+21075121,
+-33392715,
+12357866,
+33392715,
+-16655771,
+23677621,
+-33319266,
+9681828,
+33319266,
+-16582233,
+16780834,
+-33513983,
+16773567,
+33513983,
+-16777185,
+20536227,
+-33481696,
+12985848,
+33481696,
+-16744859,
+24614855,
+-33446630,
+8872112,
+33446630,
+-16709751,
+29373075,
+-33405721,
+4072934,
+33405721,
+-16668793,
+16658572,
+-33156710,
+16658568,
+33156710,
+-16539925,
+1995694,
+-3971702,
+1995225,
+3971702,
+12786296,
+1019334,
+-2028355,
+1018835,
+2028355,
+14739047,
+648397,
+-1290041,
+647886,
+1290041,
+15480933,
+16711208,
+-33261470,
+16711201,
+33261470,
+-16645192,
+3284873,
+-6536727,
+3283483,
+6536727,
+10208860,
+1752746,
+-3487071,
+1751198,
+3487071,
+13273272,
+1134254,
+-2255981,
+1132642,
+2255981,
+14510319,
+16740546,
+-33319859,
+16740534,
+33319859,
+-16703864,
+5119019,
+-10184853,
+5115113,
+10184853,
+6543083,
+2916766,
+-5800820,
+2912122,
+5800820,
+10948329,
+1940950,
+-3858260,
+1935979,
+3858260,
+12900288,
+16756866,
+-33352332,
+16756844,
+33352332,
+-16736493,
+7416141,
+-14750709,
+7405941,
+14750709,
+1955134,
+4618132,
+-9178604,
+4604884,
+9178604,
+7554200,
+3205731,
+-6365873,
+3190944,
+6365873,
+10380541,
+16765937,
+-33370369,
+16765897,
+33370369,
+-16754618,
+9875714,
+-19631961,
+9851238,
+19631961,
+-2949736,
+6828874,
+-13556870,
+6793592,
+13556870,
+3154751,
+5021920,
+-9953987,
+4980230,
+9953987,
+6775066,
+16770983,
+-33380381,
+16770911,
+33380381,
+-16764679,
+12107731,
+-24045066,
+12053679,
+24045066,
+-7384194,
+9304697,
+-18433704,
+9218200,
+18433704,
+-1745681,
+7330173,
+-14480925,
+7220819,
+14480925,
+2226224,
+16773804,
+-33385937,
+16773674,
+33385937,
+-16770261,
+13857067,
+-27469883,
+13745731,
+27469883,
+-10825583,
+11667230,
+-23028209,
+11472403,
+23028209,
+-6362417,
+9861509,
+-19365642,
+9597835,
+19365642,
+-2682128,
+16775405,
+-33389019,
+16775170,
+33389019,
+-16773358,
+15094166,
+-29826057,
+14876207,
+29826057,
+-13193157,
+13629575,
+-26722225,
+13221948,
+26722225,
+-10074307,
+12261304,
+-23822520,
+11676482,
+23822520,
+-7160571,
+16776358,
+-33390729,
+16775935,
+33390729,
+-16775076,
+15939973,
+-31315809,
+15527360,
+31315809,
+-14690117,
+15140254,
+-29331850,
+14333520,
+29331850,
+-12696558,
+14324552,
+-27308240,
+13115821,
+27308240,
+-10663157,
+16777004,
+-33391677,
+16776241,
+33391677,
+-16776029,
+16564519,
+-32208051,
+15799374,
+32208051,
+-15586676,
+16349720,
+-31011538,
+14811870,
+31011538,
+-14384374,
+16117884,
+-29720119,
+13746038,
+29720119,
+-13086705,
+16777574,
+-33392203,
+16776199,
+33392203,
+-16776558,
+17142623,
+-32725183,
+15740903,
+32725183,
+-16106310,
+17523746,
+-32028793,
+14660021,
+32028793,
+-15406551,
+17949452,
+-31250941,
+13452699,
+31250941,
+-14624935,
+16778273,
+-33392495,
+16775794,
+33392495,
+-16776851,
+17864511,
+-33019221,
+15314476,
+33019221,
+-16401771,
+19019582,
+-32622294,
+13760557,
+32622294,
+-16002923,
+20335886,
+-32169961,
+11989731,
+32169961,
+-15548401,
+16779350,
+-33392657,
+16774879,
+33392657,
+-16777014,
+18982972,
+-33184592,
+14362186,
+33184592,
+-16567942,
+21350554,
+-32961046,
+11769976,
+32961046,
+-16343314,
+24079688,
+-32703362,
+8781912,
+32703362,
+-16084383,
+16781190,
+-33392746,
+16773130,
+33392746,
+-16777104,
+20896303,
+-33277026,
+12541737,
+33277026,
+-16660824,
+25343199,
+-33151977,
+7969185,
+33151977,
+-16535169,
+30502384,
+-33006896,
+2664219,
+33006896,
+-16389387,
+16784451,
+-33392796,
+16769918,
+33392796,
+-16777154,
+24288258,
+-33328516,
+9201520,
+33328516,
+-16712562,
+32423187,
+-33258828,
+996567,
+33258828,
+-16642538,
+41895320,
+-33177686,
+-8557101,
+33177686,
+-16561003,
+16541595,
+-32447498,
+16541587,
+32447498,
+-16305966,
+1060925,
+-2080590,
+1060426,
+2080590,
+14655865,
+525478,
+-1030256,
+524962,
+1030256,
+15726776,
+330321,
+-647437,
+329800,
+647437,
+16117095,
+16645717,
+-32651734,
+16645703,
+32651734,
+-16514203,
+1820789,
+-3570095,
+1819248,
+3570095,
+13137179,
+924575,
+-1812018,
+922942,
+1812018,
+14929699,
+586684,
+-1149186,
+585016,
+1149186,
+15605516,
+16704036,
+-32766121,
+16704011,
+32766121,
+-16630831,
+3020875,
+-5921138,
+3016266,
+5921138,
+10740076,
+1597573,
+-3128764,
+1592487,
+3128764,
+13587156,
+1030124,
+-2015487,
+1024848,
+2015487,
+14722244,
+16736565,
+-32829909,
+16736521,
+32829909,
+-16695869,
+4762013,
+-9328185,
+4748922,
+9328185,
+7266281,
+2679566,
+-5241091,
+2664205,
+5241091,
+11433446,
+1773912,
+-3463620,
+1757564,
+3463620,
+13245740,
+16754673,
+-32865395,
+16754593,
+32865395,
+-16732050,
+7001772,
+-13700468,
+6967104,
+13700468,
+2808340,
+4293363,
+-8378312,
+4249089,
+8378312,
+8234764,
+2960061,
+-5758307,
+2911058,
+5758307,
+10906097,
+16764756,
+-32885110,
+16764611,
+32885110,
+-16752151,
+9480188,
+-18513215,
+9395722,
+18513215,
+-2098694,
+6453693,
+-12542171,
+6334194,
+12542171,
+3989330,
+4710641,
+-9103264,
+4570966,
+9103264,
+7495609,
+16770393,
+-32896054,
+16770133,
+32896054,
+-16763310,
+11816276,
+-22992949,
+11627131,
+22992949,
+-6666191,
+8975726,
+-17314789,
+8678280,
+17314789,
+-876790,
+7032408,
+-13430164,
+6660869,
+13430164,
+3083940,
+16773593,
+-32902127,
+16773124,
+32902127,
+-16769502,
+13735615,
+-26557052,
+13341720,
+26557052,
+-10300120,
+11528165,
+-21946606,
+10848400,
+21946606,
+-5599349,
+9752563,
+-18238110,
+8842853,
+18238110,
+-1818200,
+16775499,
+-32905496,
+16774654,
+32905496,
+-16772937,
+15200588,
+-29054957,
+14423589,
+29054957,
+-12846961,
+13857004,
+-25769995,
+12417855,
+25769995,
+-9497643,
+12624453,
+-22756500,
+10577873,
+22756500,
+-6425111,
+16776792,
+-32907365,
+16775267,
+32907365,
+-16774843,
+16366344,
+-30654089,
+14888294,
+30654089,
+-14477422,
+15978753,
+-28526295,
+13106406,
+28526295,
+-12307942,
+15588057,
+-26381456,
+11310242,
+26381456,
+-10121083,
+16777933,
+-32908402,
+16775183,
+32908402,
+-16775900,
+17493802,
+-31619287,
+14744943,
+31619287,
+-15461529,
+18212414,
+-30325234,
+12706927,
+30325234,
+-14142124,
+18982725,
+-28938081,
+10522286,
+28938081,
+-12727795,
+16779330,
+-32908977,
+16774372,
+32908977,
+-16776486,
+18928041,
+-32181280,
+13883707,
+32181280,
+-16034532,
+21163118,
+-31424334,
+10876855,
+31424334,
+-15262757,
+23650871,
+-30581814,
+7530076,
+30581814,
+-14403731,
+16781484,
+-32909296,
+16772543,
+32909296,
+-16776811,
+21161996,
+-32501674,
+11976424,
+32501674,
+-16361204,
+25812009,
+-32068975,
+6885234,
+32068975,
+-15920027,
+31103385,
+-31576594,
+1091831,
+31576594,
+-15418000,
+16785164,
+-32909473,
+16769043,
+32909473,
+-16776991,
+24988064,
+-32682139,
+8334356,
+32682139,
+-16545204,
+33795794,
+-32438043,
+-722252,
+32438043,
+-16296325,
+43946128,
+-32156738,
+-11159403,
+32156738,
+-16009510,
+16791687,
+-32909571,
+16762620,
+32909571,
+-16777091,
+31772521,
+-32783096,
+1652834,
+32783096,
+-16648139,
+47961229,
+-32646423,
+-14675225,
+32646423,
+-16508788,
+66751682,
+-32487785,
+-33627423,
+32487785,
+-16347043,
+16312500,
+-30141556,
+16312485,
+30141556,
+-15847769,
+547598,
+-1011354,
+547084,
+1011354,
+15682534,
+266448,
+-491849,
+265925,
+491849,
+16244843,
+166111,
+-306446,
+165584,
+306446,
+16445521,
+16516262,
+-30518049,
+16516236,
+30518049,
+-16255282,
+962487,
+-1776938,
+960857,
+1776938,
+14853872,
+474742,
+-875656,
+473062,
+875656,
+15829413,
+297520,
+-548176,
+295821,
+548176,
+16183875,
+16631492,
+-30730944,
+16631443,
+30730944,
+-16485719,
+1660146,
+-3062870,
+1655081,
+3062870,
+13461989,
+838172,
+-1543806,
+832831,
+1543806,
+15106213,
+530135,
+-974532,
+524691,
+974532,
+15722390,
+16696110,
+-30850307,
+16696022,
+30850307,
+-16614916,
+2776642,
+-5116472,
+2761387,
+5116472,
+11239187,
+1456845,
+-2676477,
+1440152,
+2676477,
+13880219,
+936151,
+-1713835,
+918891,
+1713835,
+14922174,
+16732191,
+-30916910,
+16732031,
+30916910,
+-16687006,
+4430219,
+-8145523,
+4386431,
+8145523,
+7960566,
+2467715,
+-4512857,
+2416966,
+4512857,
+11892535,
+1628113,
+-2958725,
+1574387,
+2958725,
+13574716,
+16752314,
+-30953973,
+16752025,
+30953973,
+-16727123,
+6622193,
+-12127616,
+6504644,
+12127616,
+3650379,
+4016541,
+-7285135,
+3868831,
+7285135,
+8891843,
+2762675,
+-4954883,
+2600451,
+4954883,
+11414089,
+16763575,
+-30974568,
+16763055,
+30974568,
+-16749415,
+9150431,
+-16639142,
+8859646,
+16639142,
+-1232861,
+6182181,
+-11049974,
+5778225,
+11049974,
+4816810,
+4518629,
+-7917532,
+4051247,
+7917532,
+8207341,
+16769973,
+-30986002,
+16769034,
+30986002,
+-16761791,
+11676269,
+-20964630,
+11015683,
+20964630,
+-5914736,
+8893418,
+-15489638,
+7872446,
+15489638,
+11352,
+7041383,
+-11845939,
+5780568,
+11845939,
+3955265,
+16773783,
+-30992347,
+16772092,
+30992347,
+-16768659,
+13953280,
+-24496534,
+12561577,
+24496534,
+-9737641,
+11970921,
+-19931025,
+9602265,
+19931025,
+-4795970,
+10413172,
+-16343421,
+7276820,
+16343421,
+-912775,
+16776368,
+-30995868,
+16773318,
+30995868,
+-16772470,
+16007790,
+-27021343,
+13239901,
+27021343,
+-12470475,
+15365527,
+-23700024,
+10287194,
+23700024,
+-8875505,
+14785947,
+-20702857,
+7622664,
+20702857,
+-5631395,
+16778650,
+-30997821,
+16773150,
+30997821,
+-16774583,
+18157056,
+-28659649,
+12863925,
+28659649,
+-14243764,
+19443806,
+-26476950,
+9214638,
+26476950,
+-11881228,
+20728681,
+-24297433,
+5570671,
+24297433,
+-9522136,
+16781445,
+-30998904,
+16771527,
+30998904,
+-16775756,
+20988060,
+-29656921,
+11112361,
+29656921,
+-15323204,
+25187743,
+-28317150,
+5462520,
+28317150,
+-13873047,
+29672124,
+-26886556,
+-570326,
+26886556,
+-12324582,
+16785752,
+-30999505,
+16767870,
+30999505,
+-16776406,
+25444300,
+-30240545,
+7287830,
+30240545,
+-15954914,
+34434980,
+-29452472,
+-2555854,
+29452472,
+-15101910,
+44441242,
+-28575379,
+-13511474,
+28575379,
+-14152552,
+16793112,
+-30999838,
+16760871,
+30999838,
+-16776767,
+33095506,
+-30574250,
+-2177,
+30574250,
+-16316113,
+50408034,
+-30122291,
+-17803902,
+30122291,
+-15826917,
+70153765,
+-29606811,
+-38107583,
+29606811,
+-15268966,
+16806158,
+-31000023,
+16748025,
+31000023,
+-16776967,
+46670155,
+-30762526,
+-13373037,
+30762526,
+-16519902,
+78789544,
+-30507092,
+-45768905,
+30507092,
+-16243423,
+115942747,
+-30211627,
+-83241918,
+30211627,
+-15923613,
+15872835,
+-22447559,
+15872807,
+22447559,
+-14968426,
+277754,
+-392434,
+277231,
+392434,
+16222231,
+133061,
+-187804,
+132533,
+187804,
+16511622,
+81763,
+-115256,
+81233,
+115256,
+16614220,
+16263303,
+-22999746,
+16263250,
+22999746,
+-15749337,
+494605,
+-698290,
+492927,
+698290,
+15789685,
+238776,
+-336475,
+237071,
+336475,
+16301369,
+147228,
+-207000,
+145514,
+207000,
+16484473,
+16488278,
+-23317877,
+16488181,
+23317877,
+-16199242,
+872378,
+-1229961,
+867049,
+1229961,
+15037788,
+426889,
+-599839,
+421411,
+599839,
+15928916,
+264840,
+-370629,
+259308,
+370629,
+16253068,
+16615785,
+-23498145,
+16615609,
+23498145,
+-16454179,
+1513757,
+-2129016,
+1497126,
+2129016,
+13766333,
+758261,
+-1060001,
+740806,
+1060001,
+15278149,
+475551,
+-659971,
+457789,
+659971,
+15843875,
+16687407,
+-23599332,
+16687089,
+23599332,
+-16597280,
+2557116,
+-3580647,
+2506684,
+3580647,
+11713416,
+1332007,
+-1845009,
+1277230,
+1845009,
+14167979,
+851272,
+-1163942,
+794791,
+1163942,
+15131154,
+16727486,
+-23655830,
+16726910,
+23655830,
+-16677180,
+4144749,
+-5758163,
+3998523,
+5758163,
+8633944,
+2297803,
+-3131069,
+2130198,
+3131069,
+12349216,
+1516025,
+-2019070,
+1339371,
+2019070,
+13921820,
+16749957,
+-23687282,
+16748918,
+23687282,
+-16721660,
+6342807,
+-8688774,
+5944975,
+8688774,
+4489434,
+3855722,
+-5104454,
+3363066,
+5104454,
+9558428,
+2678286,
+-3407564,
+2140738,
+3407564,
+11958192,
+16762736,
+-23704762,
+16760861,
+23704762,
+-16746380,
+9059948,
+-12106014,
+8060542,
+12106014,
+-343274,
+6231959,
+-7847669,
+4866322,
+7847669,
+5678936,
+4678573,
+-5508603,
+3111768,
+5508603,
+8986875,
+16770353,
+-23714468,
+16766970,
+23714468,
+-16760107,
+12100768,
+-15483427,
+9796104,
+15483427,
+-5119656,
+9659401,
+-11180047,
+6151573,
+11180047,
+966242,
+8066003,
+-8371376,
+3772911,
+8371376,
+4938302,
+16775520,
+-23719855,
+16769420,
+23719855,
+-16767725,
+15410647,
+-18317794,
+10494626,
+18317794,
+-9128056,
+14477439,
+-14624233,
+6204350,
+14624233,
+-3904573,
+13754127,
+-11761419,
+2879032,
+11761419,
+144058,
+16780083,
+-23722844,
+16769084,
+23722844,
+-16771951,
+19348947,
+-20387735,
+9483664,
+20387735,
+-12055395,
+21467038,
+-17637855,
+3476656,
+17637855,
+-8166478,
+23369301,
+-15168181,
+-1918253,
+15168181,
+-4673832,
+16785673,
+-23724501,
+16765839,
+23724501,
+-16774296,
+24868547,
+-21750945,
+5891934,
+21750945,
+-13983265,
+32392543,
+-19913847,
+-4230110,
+19913847,
+-11385217,
+39938641,
+-18071353,
+-14381888,
+18071353,
+-8779537,
+16794288,
+-23725421,
+16758525,
+23725421,
+-16775596,
+33739025,
+-22588636,
+-1793870,
+22588636,
+-15167940,
+50727371,
+-21448926,
+-20394010,
+21448926,
+-13556146,
+69082218,
+-20217540,
+-40490298,
+20217540,
+-11814703,
+16809008,
+-23725931,
+16744526,
+23725931,
+-16776318,
+49053594,
+-23081666,
+-16411189,
+23081666,
+-15865189,
+82824296,
+-22406908,
+-51136143,
+22406908,
+-14910937,
+121049915,
+-21643138,
+-90441895,
+21643138,
+-13830803,
+16835099,
+-23726214,
+16718835,
+23726214,
+-16776718,
+76261468,
+-23364505,
+-43219068,
+23364505,
+-16265184,
+140080603,
+-22976059,
+-107587549,
+22976059,
+-15715838,
+214348557,
+-22524014,
+-182494791,
+22524014,
+-15076550,
+15060971,
+0,
+15060916,
+0,
+-13344671,
+137715,
+0,
+137188,
+0,
+16502313,
+62494,
+0,
+61964,
+0,
+16652757,
+35499,
+0,
+34969,
+0,
+16706748,
+15779939,
+0,
+15779837,
+0,
+-14782560,
+247059,
+0,
+245356,
+0,
+16284801,
+112726,
+0,
+111009,
+0,
+16553481,
+64282,
+0,
+62560,
+0,
+16650375,
+16209124,
+0,
+16208934,
+0,
+-15640842,
+441483,
+0,
+436010,
+0,
+15899723,
+203401,
+0,
+197848,
+0,
+16375967,
+116794,
+0,
+111212,
+0,
+16549211,
+16457433,
+0,
+16457085,
+0,
+-16137302,
+783510,
+0,
+766083,
+0,
+15227623,
+367229,
+0,
+349349,
+0,
+16060638,
+213457,
+0,
+195409,
+0,
+16368349,
+16598556,
+0,
+16597923,
+0,
+-16419263,
+1374332,
+0,
+1319705,
+0,
+14083179,
+663683,
+0,
+606536,
+0,
+15506996,
+394077,
+0,
+335974,
+0,
+16047166,
+16678051,
+0,
+16676903,
+0,
+-16577738,
+2365010,
+0,
+2198183,
+0,
+12214023,
+1201479,
+0,
+1021183,
+0,
+14554554,
+739666,
+0,
+554025,
+0,
+15483525,
+16722789,
+0,
+16720714,
+0,
+-16666287,
+3953214,
+0,
+3464275,
+0,
+9359728,
+2180807,
+0,
+1624291,
+0,
+12972118,
+1423936,
+0,
+838564,
+0,
+14514716,
+16748282,
+0,
+16744535,
+0,
+-16715601,
+6353786,
+0,
+5003926,
+0,
+5419504,
+3973108,
+0,
+2314944,
+0,
+10489165,
+2837511,
+0,
+1032284,
+0,
+12907421,
+16763496,
+0,
+16756735,
+0,
+-16743015,
+9775978,
+0,
+6325602,
+0,
+675636,
+7269959,
+0,
+2584558,
+0,
+6922698,
+5878520,
+0,
+507384,
+0,
+10391313,
+16773826,
+0,
+16761629,
+0,
+-16758239,
+14526462,
+0,
+6429723,
+0,
+-4178968,
+13351086,
+0,
+1026117,
+0,
+2400012,
+12566846,
+0,
+-2579306,
+0,
+6789676,
+16782950,
+0,
+16760954,
+0,
+-16766688,
+21346996,
+0,
+3817102,
+0,
+-8386881,
+24548257,
+0,
+-5261828,
+0,
+-2509212,
+27136746,
+0,
+-12602908,
+0,
+2243378,
+16794129,
+0,
+16754463,
+0,
+-16771376,
+31942756,
+0,
+-3625011,
+0,
+-11540529,
+45048673,
+0,
+-21256423,
+0,
+-7015034,
+57646140,
+0,
+-38203817,
+0,
+-2665107,
+16811358,
+0,
+16739835,
+0,
+-16773977,
+49676415,
+0,
+-19243342,
+0,
+-13655857,
+82339984,
+0,
+-55005915,
+0,
+-10556853,
+118287496,
+0,
+-94363999,
+0,
+-7146281,
+16840799,
+0,
+16711837,
+0,
+-16775419,
+80691383,
+0,
+-48942961,
+0,
+-14971206,
+149858505,
+0,
+-120064524,
+0,
+-13016765,
+233520652,
+0,
+-206090695,
+0,
+-10652741,
+16892981,
+0,
+16660455,
+0,
+-16776220,
+136000868,
+0,
+-103472696,
+0,
+-15750956,
+271801469,
+0,
+-240442250,
+0,
+-14582003,
+446309601,
+0,
+-416452524,
+0,
+-13079862,
diff --git a/media/libeffects/AudioShelvingFilter.cpp b/media/libeffects/AudioShelvingFilter.cpp
new file mode 100644
index 0000000..d8abbd2
--- /dev/null
+++ b/media/libeffects/AudioShelvingFilter.cpp
@@ -0,0 +1,109 @@
+/* /android/src/frameworks/base/libs/audioflinger/AudioShelvingFilter.cpp
+**
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include "AudioShelvingFilter.h"
+#include "AudioCommon.h"
+#include "EffectsMath.h"
+
+#include <new>
+#include <assert.h>
+
+#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
+#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
+
+namespace android {
+// Format of the coefficient tables:
+// kCoefTable[freq][gain][coef]
+// freq - cutoff frequency, in octaves below Nyquist,from -10 to -6 in low
+// shelf, -2 to 0 in high shelf.
+// gain - gain, in millibel, starting at -9600, jumps of 1024, to 4736 millibel.
+// coef - 0: b0
+// 1: b1
+// 2: b2
+// 3: -a1
+// 4: -a2
+static const size_t kHiInDims[2] = {3, 15};
+static const audio_coef_t kHiCoefTable[3*15*5] = {
+#include "AudioHighShelfFilterCoef.inl"
+};
+static const size_t kLoInDims[2] = {5, 15};
+static const audio_coef_t kLoCoefTable[5*15*5] = {
+#include "AudioLowShelfFilterCoef.inl"
+};
+
+AudioCoefInterpolator AudioShelvingFilter::mHiCoefInterp(2, kHiInDims, 5, (const audio_coef_t*) kHiCoefTable);
+AudioCoefInterpolator AudioShelvingFilter::mLoCoefInterp(2, kLoInDims, 5, (const audio_coef_t*) kLoCoefTable);
+
+AudioShelvingFilter::AudioShelvingFilter(ShelfType type, int nChannels,
+ int sampleRate)
+ : mBiquad(nChannels, sampleRate)
+ , mType(type) {
+ configure(nChannels, sampleRate);
+}
+
+void AudioShelvingFilter::configure(int nChannels, int sampleRate) {
+ mNiquistFreq = sampleRate * 500;
+ mFrequencyFactor = ((1ull) << 42) / mNiquistFreq;
+ mBiquad.configure(nChannels, sampleRate);
+ setFrequency(mNominalFrequency);
+ commit(true);
+}
+
+void AudioShelvingFilter::reset() {
+ setGain(0);
+ setFrequency(mType == kLowShelf ? 0 : mNiquistFreq);
+ commit(true);
+}
+
+void AudioShelvingFilter::setFrequency(uint32_t millihertz) {
+ mNominalFrequency = millihertz;
+ if (UNLIKELY(millihertz > mNiquistFreq / 2)) {
+ millihertz = mNiquistFreq / 2;
+ }
+ uint32_t normFreq = static_cast<uint32_t>(
+ (static_cast<uint64_t>(millihertz) * mFrequencyFactor) >> 10);
+ uint32_t log2minFreq = (mType == kLowShelf ? (32-10) : (32-2));
+ if (LIKELY(normFreq > (1U << log2minFreq))) {
+ mFrequency = (Effects_log2(normFreq) - (log2minFreq << 15)) << (FREQ_PRECISION_BITS - 15);
+ } else {
+ mFrequency = 0;
+ }
+}
+
+void AudioShelvingFilter::setGain(int32_t millibel) {
+ mGain = millibel + 9600;
+}
+
+void AudioShelvingFilter::commit(bool immediate) {
+ audio_coef_t coefs[5];
+ int intCoord[2] = {
+ mFrequency >> FREQ_PRECISION_BITS,
+ mGain >> GAIN_PRECISION_BITS
+ };
+ uint32_t fracCoord[2] = {
+ mFrequency << (32 - FREQ_PRECISION_BITS),
+ static_cast<uint32_t>(mGain) << (32 - GAIN_PRECISION_BITS)
+ };
+ if (mType == kHighShelf) {
+ mHiCoefInterp.getCoef(intCoord, fracCoord, coefs);
+ } else {
+ mLoCoefInterp.getCoef(intCoord, fracCoord, coefs);
+ }
+ mBiquad.setCoefs(coefs, immediate);
+}
+
+}
diff --git a/media/libeffects/AudioShelvingFilter.h b/media/libeffects/AudioShelvingFilter.h
new file mode 100644
index 0000000..f72d793
--- /dev/null
+++ b/media/libeffects/AudioShelvingFilter.h
@@ -0,0 +1,146 @@
+/* /android/src/frameworks/base/libs/audioflinger/AudioShelvingFilter.h
+**
+** Copyright 2009, 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 AUDIO_SHELVING_FILTER_H
+#define AUDIO_SHELVING_FILTER_H
+
+#include "AudioBiquadFilter.h"
+#include "AudioCoefInterpolator.h"
+
+namespace android {
+
+// A shelving audio filter, with unity skirt gain, and controllable cutoff
+// frequency and gain.
+// This filter is able to suppress introduce discontinuities and other artifacts
+// in the output, even when changing parameters abruptly.
+// Parameters can be set to any value - this class will make sure to clip them
+// when they are out of supported range.
+//
+// Implementation notes:
+// This class uses an underlying biquad filter whose parameters are determined
+// using a linear interpolation from a coefficient table, using a
+// AudioCoefInterpolator.
+// All is left for this class to do is mapping between high-level parameters to
+// fractional indices into the coefficient table.
+class AudioShelvingFilter {
+public:
+ // Shelf type
+ enum ShelfType {
+ kLowShelf,
+ kHighShelf
+ };
+
+ // Constructor. Resets the filter (see reset()).
+ // type Type of the filter (high shelf or low shelf).
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ AudioShelvingFilter(ShelfType type, int nChannels, int sampleRate);
+
+ // Reconfiguration of the filter. Changes input/output format, but does not
+ // alter current parameter values. Clears delay lines.
+ // nChannels Number of input/output channels (interlaced).
+ // sampleRate The input/output sample rate, in Hz.
+ void configure(int nChannels, int sampleRate);
+
+ // Resets the filter parameters to the following values:
+ // frequency: 0
+ // gain: 0
+ // It also disables the filter. Does not clear the delay lines.
+ void reset();
+
+ // Clears delay lines. Does not alter parameter values.
+ void clear() { mBiquad.clear(); }
+
+ // Sets gain value. Actual change will only take place upon commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // millibel Gain value in millibel (1/100 of decibel).
+ void setGain(int32_t millibel);
+
+ // Gets the gain, in millibel, as set.
+ int32_t getGain() const { return mGain - 9600; }
+
+ // Sets cutoff frequency value. Actual change will only take place upon
+ // commit().
+ // This value will be remembered even if the filter is in disabled() state.
+ // millihertz Frequency value in mHz.
+ void setFrequency(uint32_t millihertz);
+
+ // Gets the frequency, in mHz, as set.
+ uint32_t getFrequency() const { return mNominalFrequency; }
+
+ // Applies all parameter changes done to this point in time.
+ // If the filter is disabled, the new parameters will take place when it is
+ // enabled again. Does not introduce artifacts, unless immediate is set.
+ // immediate Whether to apply change abruptly (ignored if filter is
+ // disabled).
+ void commit(bool immediate = false);
+
+ // Process a buffer of input data. The input and output should contain
+ // frameCount * nChannels interlaced samples. Processing can be done
+ // in-place, by passing the same buffer as both arguments.
+ // in Input buffer.
+ // out Output buffer.
+ // frameCount Number of frames to produce.
+ void process(const audio_sample_t in[], audio_sample_t out[],
+ int frameCount) { mBiquad.process(in, out, frameCount); }
+
+ // Enables the filter, so it would start processing input. Does not
+ // introduce artifacts, unless immediate is set.
+ // immediate Whether to apply change abruptly.
+ void enable(bool immediate = false) { mBiquad.enable(immediate); }
+
+ // Disabled (bypasses) the filter. Does not introduce artifacts, unless
+ // immediate is set.
+ // immediate Whether to apply change abruptly.
+ void disable(bool immediate = false) { mBiquad.disable(immediate); }
+
+private:
+ // Precision for the mFrequency member.
+ static const int FREQ_PRECISION_BITS = 26;
+ // Precision for the mGain member.
+ static const int GAIN_PRECISION_BITS = 10;
+
+ // Shelf type.
+ ShelfType mType;
+ // Nyquist, in mHz.
+ uint32_t mNiquistFreq;
+ // Fractional index into the gain dimension of the coef table in
+ // GAIN_PRECISION_BITS precision.
+ int32_t mGain;
+ // Fractional index into the frequency dimension of the coef table in
+ // FREQ_PRECISION_BITS precision.
+ uint32_t mFrequency;
+ // Nominal value of frequency, as set.
+ uint32_t mNominalFrequency;
+ // 1/Nyquist[mHz], in 42-bit precision (very small).
+ // Used for scaling the frequency.
+ uint32_t mFrequencyFactor;
+
+ // A biquad filter, used for the actual processing.
+ AudioBiquadFilter mBiquad;
+ // A coefficient interpolator, used for mapping the high level parameters to
+ // the low-level biquad coefficients. This one is used for the high shelf.
+ static AudioCoefInterpolator mHiCoefInterp;
+ // A coefficient interpolator, used for mapping the high level parameters to
+ // the low-level biquad coefficients. This one is used for the low shelf.
+ static AudioCoefInterpolator mLoCoefInterp;
+};
+
+}
+
+
+#endif // AUDIO_SHELVING_FILTER_H
diff --git a/media/libeffects/EffectEqualizer.cpp b/media/libeffects/EffectEqualizer.cpp
new file mode 100644
index 0000000..3a5da4d
--- /dev/null
+++ b/media/libeffects/EffectEqualizer.cpp
@@ -0,0 +1,605 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "Equalizer"
+#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
+//#define LOG_NDEBUG 0
+#include <cutils/log.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <new>
+#include "AudioEqualizer.h"
+#include "AudioBiquadFilter.h"
+#include "AudioFormatAdapter.h"
+#include <media/EffectEqualizerApi.h>
+
+// effect_interface_t interface implementation for equalizer effect
+extern "C" const struct effect_interface_s gEqualizerInterface;
+
+namespace android {
+namespace {
+
+// Google Graphic Equalizer UUID: e25aa840-543b-11df-98a5-0002a5d5c51b
+const effect_descriptor_t gEqualizerDescriptor = {
+ {0x0bed4300, 0xddd6, 0x11db, 0x8f34, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // type
+ {0xe25aa840, 0x543b, 0x11df, 0x98a5, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
+ EFFECT_API_VERSION,
+ (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_LAST),
+ "Graphic Equalizer",
+ "Google Inc.",
+};
+static int gEffectIndex;
+
+/////////////////// BEGIN EQ PRESETS ///////////////////////////////////////////
+const int kNumBands = 5;
+const uint32_t gFreqs[kNumBands] = { 50000, 125000, 900000, 3200000, 6300000 };
+const uint32_t gBandwidths[kNumBands] = { 0, 3600, 3600, 2400, 0 };
+
+const AudioEqualizer::BandConfig gBandsClassic[kNumBands] = {
+ { 300, gFreqs[0], gBandwidths[0] },
+ { 400, gFreqs[1], gBandwidths[1] },
+ { 0, gFreqs[2], gBandwidths[2] },
+ { 200, gFreqs[3], gBandwidths[3] },
+ { -300, gFreqs[4], gBandwidths[4] }
+};
+
+const AudioEqualizer::BandConfig gBandsJazz[kNumBands] = {
+ { -600, gFreqs[0], gBandwidths[0] },
+ { 200, gFreqs[1], gBandwidths[1] },
+ { 400, gFreqs[2], gBandwidths[2] },
+ { -400, gFreqs[3], gBandwidths[3] },
+ { -600, gFreqs[4], gBandwidths[4] }
+};
+
+const AudioEqualizer::BandConfig gBandsPop[kNumBands] = {
+ { 400, gFreqs[0], gBandwidths[0] },
+ { -400, gFreqs[1], gBandwidths[1] },
+ { 300, gFreqs[2], gBandwidths[2] },
+ { -400, gFreqs[3], gBandwidths[3] },
+ { 600, gFreqs[4], gBandwidths[4] }
+};
+
+const AudioEqualizer::BandConfig gBandsRock[kNumBands] = {
+ { 700, gFreqs[0], gBandwidths[0] },
+ { 400, gFreqs[1], gBandwidths[1] },
+ { -400, gFreqs[2], gBandwidths[2] },
+ { 400, gFreqs[3], gBandwidths[3] },
+ { 200, gFreqs[4], gBandwidths[4] }
+};
+
+const AudioEqualizer::PresetConfig gEqualizerPresets[] = {
+ { "Classic", gBandsClassic },
+ { "Jazz", gBandsJazz },
+ { "Pop", gBandsPop },
+ { "Rock", gBandsRock }
+};
+
+/////////////////// END EQ PRESETS /////////////////////////////////////////////
+
+static const size_t kBufferSize = 32;
+
+typedef AudioFormatAdapter<AudioEqualizer, kBufferSize> FormatAdapter;
+
+struct EqualizerContext {
+ const struct effect_interface_s *itfe;
+ effect_config_t config;
+ FormatAdapter adapter;
+ AudioEqualizer * pEqualizer;
+};
+
+
+//--- local function prototypes
+
+int Equalizer_init(EqualizerContext *pContext);
+int Equalizer_configure(EqualizerContext *pContext, effect_config_t *pConfig);
+int Equalizer_getParameter(AudioEqualizer * pEqualizer, int32_t *pParam, size_t *pValueSize, void *pValue);
+int Equalizer_setParameter(AudioEqualizer * pEqualizer, int32_t *pParam, void *pValue);
+
+
+//
+//--- Effect Library Interface Implementation
+//
+
+extern "C" int EffectQueryNumberEffects(int *pNumEffects) {
+ *pNumEffects = 1;
+ gEffectIndex = 0;
+ return 0;
+} /* end EffectQueryNumberEffects */
+
+extern "C" int EffectQueryNext(effect_descriptor_t *pDescriptor) {
+ if (pDescriptor == NULL) {
+ return -EINVAL;
+ }
+ if (gEffectIndex++ > 0) {
+ return -ENOENT;
+ }
+ memcpy(pDescriptor, &gEqualizerDescriptor, sizeof(effect_descriptor_t));
+ return 0;
+} /* end EffectQueryNext */
+
+extern "C" int EffectCreate(effect_uuid_t *uuid,
+ effect_interface_t *pInterface) {
+ int ret;
+ int i;
+
+ LOGV("EffectLibCreateEffect start");
+
+ if (pInterface == NULL || uuid == NULL) {
+ return -EINVAL;
+ }
+
+ if (memcmp(uuid, &gEqualizerDescriptor.uuid, sizeof(effect_uuid_t)) != 0) {
+ return -EINVAL;
+ }
+
+ EqualizerContext *pContext = new EqualizerContext;
+
+ pContext->itfe = &gEqualizerInterface;
+ pContext->pEqualizer = NULL;
+
+ ret = Equalizer_init(pContext);
+ if (ret < 0) {
+ LOGW("EffectLibCreateEffect() init failed");
+ delete pContext;
+ return ret;
+ }
+
+ *pInterface = (effect_interface_t)pContext;
+
+ LOGV("EffectLibCreateEffect %p", pContext);
+
+ return 0;
+
+} /* end EffectCreate */
+
+extern "C" int EffectRelease(effect_interface_t interface) {
+ EqualizerContext * pContext = (EqualizerContext *)interface;
+
+ LOGV("EffectLibReleaseEffect %p", interface);
+ if (pContext == NULL) {
+ return -EINVAL;
+ }
+
+ pContext->pEqualizer->free();
+ delete pContext;
+
+ return 0;
+} /* end EffectRelease */
+
+
+//
+//--- local functions
+//
+
+#define CHECK_ARG(cond) { \
+ if (!(cond)) { \
+ LOGV("Invalid argument: "#cond); \
+ return -EINVAL; \
+ } \
+}
+
+//----------------------------------------------------------------------------
+// Equalizer_configure()
+//----------------------------------------------------------------------------
+// Purpose: Set input and output audio configuration.
+//
+// Inputs:
+// pContext: effect engine context
+// pConfig: pointer to effect_config_t structure holding input and output
+// configuration parameters
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int Equalizer_configure(EqualizerContext *pContext, effect_config_t *pConfig)
+{
+ LOGV("Equalizer_configure start");
+
+ CHECK_ARG(pContext != NULL);
+ CHECK_ARG(pConfig != NULL);
+
+ CHECK_ARG(pConfig->inputCfg.samplingRate == pConfig->outputCfg.samplingRate);
+ CHECK_ARG(pConfig->inputCfg.channels == pConfig->outputCfg.channels);
+ CHECK_ARG(pConfig->inputCfg.format == pConfig->outputCfg.format);
+ CHECK_ARG((pConfig->inputCfg.channels == CHANNEL_MONO) || (pConfig->inputCfg.channels == CHANNEL_STEREO));
+ CHECK_ARG(pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_WRITE
+ || pConfig->outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
+ CHECK_ARG(pConfig->inputCfg.format == PCM_FORMAT_S7_24
+ || pConfig->inputCfg.format == PCM_FORMAT_S15);
+
+ int channelCount;
+ if (pConfig->inputCfg.channels == CHANNEL_MONO) {
+ channelCount = 1;
+ } else {
+ channelCount = 2;
+ }
+ CHECK_ARG(channelCount <= AudioBiquadFilter::MAX_CHANNELS);
+
+ pContext->pEqualizer->configure(channelCount,
+ pConfig->inputCfg.samplingRate);
+
+ pContext->adapter.configure(*pContext->pEqualizer, channelCount,
+ pConfig->inputCfg.format,
+ pConfig->outputCfg.accessMode);
+
+ return 0;
+} // end Equalizer_configure
+
+
+//----------------------------------------------------------------------------
+// Equalizer_init()
+//----------------------------------------------------------------------------
+// Purpose: Initialize engine with default configuration and creates
+// AudioEqualizer instance.
+//
+// Inputs:
+// pContext: effect engine context
+//
+// Outputs:
+//
+//----------------------------------------------------------------------------
+
+int Equalizer_init(EqualizerContext *pContext)
+{
+ int status;
+
+ LOGV("Equalizer_init start");
+
+ CHECK_ARG(pContext != NULL);
+
+ if (pContext->pEqualizer != NULL) {
+ pContext->pEqualizer->free();
+ }
+
+ pContext->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
+ pContext->config.inputCfg.channels = CHANNEL_STEREO;
+ pContext->config.inputCfg.format = PCM_FORMAT_S15;
+ pContext->config.inputCfg.samplingRate = 44100;
+ pContext->config.inputCfg.bufferProvider.getBuffer = NULL;
+ pContext->config.inputCfg.bufferProvider.releaseBuffer = NULL;
+ pContext->config.inputCfg.bufferProvider.cookie = NULL;
+ pContext->config.inputCfg.mask = EFFECT_CONFIG_ALL;
+ pContext->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
+ pContext->config.outputCfg.channels = CHANNEL_STEREO;
+ pContext->config.outputCfg.format = PCM_FORMAT_S15;
+ pContext->config.outputCfg.samplingRate = 44100;
+ pContext->config.outputCfg.bufferProvider.getBuffer = NULL;
+ pContext->config.outputCfg.bufferProvider.releaseBuffer = NULL;
+ pContext->config.outputCfg.bufferProvider.cookie = NULL;
+ pContext->config.outputCfg.mask = EFFECT_CONFIG_ALL;
+
+ pContext->pEqualizer = AudioEqualizer::CreateInstance(
+ NULL,
+ kNumBands,
+ AudioBiquadFilter::MAX_CHANNELS,
+ 44100,
+ gEqualizerPresets,
+ ARRAY_SIZE(gEqualizerPresets));
+
+ for (int i = 0; i < kNumBands; ++i) {
+ pContext->pEqualizer->setFrequency(i, gFreqs[i]);
+ pContext->pEqualizer->setBandwidth(i, gBandwidths[i]);
+ }
+
+ pContext->pEqualizer->enable(true);
+
+ Equalizer_configure(pContext, &pContext->config);
+
+ return 0;
+} // end Equalizer_init
+
+
+//----------------------------------------------------------------------------
+// Equalizer_getParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Get a Equalizer parameter
+//
+// Inputs:
+// pEqualizer - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to variable to hold retrieved value
+// pValueSize - pointer to value size: maximum size as input
+//
+// Outputs:
+// *pValue updated with parameter value
+// *pValueSize updated with actual value size
+//
+//
+// Side Effects:
+//
+//----------------------------------------------------------------------------
+
+int Equalizer_getParameter(AudioEqualizer * pEqualizer, int32_t *pParam, size_t *pValueSize, void *pValue)
+{
+ int status = 0;
+ int32_t param = *pParam++;
+ int32_t param2;
+ char *name;
+
+ switch (param) {
+ case EQ_PARAM_NUM_BANDS:
+ case EQ_PARAM_CUR_PRESET:
+ case EQ_PARAM_GET_NUM_OF_PRESETS:
+ if (*pValueSize < sizeof(int16_t)) {
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int16_t);
+ break;
+
+ case EQ_PARAM_LEVEL_RANGE:
+ case EQ_PARAM_BAND_FREQ_RANGE:
+ if (*pValueSize < 2 * sizeof(int32_t)) {
+ return -EINVAL;
+ }
+ *pValueSize = 2 * sizeof(int32_t);
+ break;
+ case EQ_PARAM_BAND_LEVEL:
+ case EQ_PARAM_GET_BAND:
+ case EQ_PARAM_CENTER_FREQ:
+ if (*pValueSize < sizeof(int32_t)) {
+ return -EINVAL;
+ }
+ *pValueSize = sizeof(int32_t);
+ break;
+
+ case EQ_PARAM_GET_PRESET_NAME:
+ break;
+
+ default:
+ return -EINVAL;
+ }
+
+ switch (param) {
+ case EQ_PARAM_NUM_BANDS:
+ *(int16_t *)pValue = kNumBands;
+ LOGV("Equalizer_getParameter() EQ_PARAM_NUM_BANDS %d", *(int16_t *)pValue);
+ break;
+
+ case EQ_PARAM_LEVEL_RANGE:
+ *(int32_t *)pValue = -9600;
+ *((int32_t *)pValue + 1) = 4800;
+ LOGV("Equalizer_getParameter() EQ_PARAM_LEVEL_RANGE min %d, max %d", *(int32_t *)pValue, *((int32_t *)pValue + 1));
+ break;
+
+ case EQ_PARAM_BAND_LEVEL:
+ param2 = *pParam;
+ if (param2 >= kNumBands) {
+ status = -EINVAL;
+ break;
+ }
+ *(int32_t *)pValue = pEqualizer->getGain(param2);
+ LOGV("Equalizer_getParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", param2, *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_CENTER_FREQ:
+ param2 = *pParam;
+ if (param2 >= kNumBands) {
+ status = -EINVAL;
+ break;
+ }
+ *(int32_t *)pValue = pEqualizer->getFrequency(param2);
+ LOGV("Equalizer_getParameter() EQ_PARAM_CENTER_FREQ band %d, frequency %d", param2, *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_BAND_FREQ_RANGE:
+ param2 = *pParam;
+ if (param2 >= kNumBands) {
+ status = -EINVAL;
+ break;
+ }
+ pEqualizer->getBandRange(param2, *(uint32_t *)pValue, *((uint32_t *)pValue + 1));
+ LOGV("Equalizer_getParameter() EQ_PARAM_BAND_FREQ_RANGE band %d, min %d, max %d", param2, *(int32_t *)pValue, *((int32_t *)pValue + 1));
+ break;
+
+ case EQ_PARAM_GET_BAND:
+ param2 = *pParam;
+ *(int32_t *)pValue = pEqualizer->getMostRelevantBand(param2);
+ LOGV("Equalizer_getParameter() EQ_PARAM_GET_BAND frequency %d, band %d", param2, *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_CUR_PRESET:
+ *(int16_t *)pValue = pEqualizer->getPreset();
+ LOGV("Equalizer_getParameter() EQ_PARAM_CUR_PRESET %d", *(int32_t *)pValue);
+ break;
+
+ case EQ_PARAM_GET_NUM_OF_PRESETS:
+ *(int16_t *)pValue = pEqualizer->getNumPresets();
+ LOGV("Equalizer_getParameter() EQ_PARAM_GET_NUM_OF_PRESETS %d", *(int16_t *)pValue);
+ break;
+
+ case EQ_PARAM_GET_PRESET_NAME:
+ param2 = *pParam;
+ if (param2 >= pEqualizer->getNumPresets()) {
+ status = -EINVAL;
+ break;
+ }
+ name = (char *)pValue;
+ strncpy(name, pEqualizer->getPresetName(param2), *pValueSize - 1);
+ name[*pValueSize - 1] = 0;
+ *pValueSize = strlen(name) + 1;
+ LOGV("Equalizer_getParameter() EQ_PARAM_GET_PRESET_NAME preset %d, name %s len %d", param2, gEqualizerPresets[param2].name, *pValueSize);
+ break;
+
+ default:
+ LOGV("Equalizer_getParameter() invalid param %d", param);
+ status = -EINVAL;
+ break;
+ }
+
+ return status;
+} // end Equalizer_getParameter
+
+
+//----------------------------------------------------------------------------
+// Equalizer_setParameter()
+//----------------------------------------------------------------------------
+// Purpose:
+// Set a Equalizer parameter
+//
+// Inputs:
+// pEqualizer - handle to instance data
+// pParam - pointer to parameter
+// pValue - pointer to value
+//
+// Outputs:
+//
+//
+// Side Effects:
+//
+//----------------------------------------------------------------------------
+
+int Equalizer_setParameter (AudioEqualizer * pEqualizer, int32_t *pParam, void *pValue)
+{
+ int status = 0;
+ int32_t preset;
+ int32_t band;
+ int32_t level;
+ int32_t param = *pParam++;
+
+
+ switch (param) {
+ case EQ_PARAM_CUR_PRESET:
+ preset = *(int16_t *)pValue;
+
+ LOGV("setParameter() EQ_PARAM_CUR_PRESET %d", preset);
+ if (preset >= pEqualizer->getNumPresets()) {
+ status = -EINVAL;
+ break;
+ }
+ pEqualizer->setPreset(preset);
+ pEqualizer->commit(true);
+ break;
+ case EQ_PARAM_BAND_LEVEL:
+ band = *pParam;
+ level = *(int32_t *)pValue;
+ LOGV("setParameter() EQ_PARAM_BAND_LEVEL band %d, level %d", band, level);
+ if (band >= kNumBands) {
+ status = -EINVAL;
+ break;
+ }
+ pEqualizer->setGain(band, level);
+ pEqualizer->commit(true);
+ break;
+ default:
+ LOGV("setParameter() invalid param %d", param);
+ break;
+ }
+
+ return status;
+} // end Equalizer_setParameter
+
+} // namespace
+} // namespace
+
+
+//
+//--- Effect Control Interface Implementation
+//
+
+extern "C" int Equalizer_process(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer)
+{
+ android::EqualizerContext * pContext = (android::EqualizerContext *) self;
+
+ if (pContext == NULL) {
+ return -EINVAL;
+ }
+ if (inBuffer == NULL || inBuffer->raw == NULL ||
+ outBuffer == NULL || outBuffer->raw == NULL ||
+ inBuffer->frameCount != outBuffer->frameCount) {
+ return -EINVAL;
+ }
+
+ pContext->adapter.process(inBuffer->raw, outBuffer->raw, outBuffer->frameCount);
+ return 0;
+} // end Equalizer_process
+
+extern "C" int Equalizer_command(effect_interface_t self, int cmdCode, int cmdSize,
+ void *pCmdData, int *replySize, void *pReplyData) {
+
+ android::EqualizerContext * pContext = (android::EqualizerContext *) self;
+ int retsize;
+
+ if (pContext == NULL) {
+ return -EINVAL;
+ }
+
+ android::AudioEqualizer * pEqualizer = pContext->pEqualizer;
+
+ LOGV("Equalizer_command command %d cmdSize %d",cmdCode, cmdSize);
+
+ switch (cmdCode) {
+ case EFFECT_CMD_INIT:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ *(int *) pReplyData = Equalizer_init(pContext);
+ break;
+ case EFFECT_CMD_CONFIGURE:
+ if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
+ || pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ *(int *) pReplyData = Equalizer_configure(pContext,
+ (effect_config_t *) pCmdData);
+ break;
+ case EFFECT_CMD_RESET:
+ Equalizer_configure(pContext, &pContext->config);
+ break;
+ case EFFECT_CMD_GET_PARAM: {
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL || *replySize < (int) (sizeof(effect_param_t) + sizeof(int32_t))) {
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *)pCmdData;
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + p->psize);
+ p = (effect_param_t *)pReplyData;
+ int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
+ p->status = android::Equalizer_getParameter(pEqualizer, (int32_t *)p->data, &p->vsize,
+ p->data + voffset);
+ *replySize = sizeof(effect_param_t) + voffset + p->vsize;
+ LOGV("Equalizer_command EFFECT_CMD_GET_PARAM *pCmdData %d, *replySize %d, *pReplyData %08x %08x",
+ *(int32_t *)((char *)pCmdData + sizeof(effect_param_t)), *replySize,
+ *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset),
+ *(int32_t *)((char *)pReplyData + sizeof(effect_param_t) + voffset + sizeof(int32_t)));
+
+ } break;
+ case EFFECT_CMD_SET_PARAM: {
+ LOGV("Equalizer_command EFFECT_CMD_SET_PARAM cmdSize %d pCmdData %p, *replySize %d, pReplyData %p", cmdSize, pCmdData, *replySize, pReplyData);
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL || *replySize != sizeof(int32_t)) {
+ return -EINVAL;
+ }
+ effect_param_t *p = (effect_param_t *) pCmdData;
+ *(int *)pReplyData = android::Equalizer_setParameter(pEqualizer, (int32_t *)p->data,
+ p->data + p->psize);
+ } break;
+ default:
+ LOGW("Equalizer_command invalid command %d",cmdCode);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+// effect_interface_t interface implementation for equalizer effect
+const struct effect_interface_s gEqualizerInterface = {
+ Equalizer_process,
+ Equalizer_command
+};
+
+
diff --git a/media/libeffects/EffectReverb.c b/media/libeffects/EffectReverb.c
new file mode 100644
index 0000000..3181504
--- /dev/null
+++ b/media/libeffects/EffectReverb.c
@@ -0,0 +1,2034 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "EffectReverb"
+//
+#define LOG_NDEBUG 0
+#include <cutils/log.h>
+
+#include <stdbool.h>
+#include "EffectReverb.h"
+#include "EffectsMath.h"
+
+static int gEffectIndex;
+
+// effect_interface_t interface implementation for reverb effect
+const struct effect_interface_s gReverbInterface = {
+ Reverb_Process,
+ Reverb_Command
+};
+
+// Google auxiliary environmental reverb UUID: 1f0ae2e0-4ef7-11df-bc09-0002a5d5c51b
+static const effect_descriptor_t gAuxEnvReverbDescriptor = {
+ {0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}},
+ {0x1f0ae2e0, 0x4ef7, 0x11df, 0xbc09, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ EFFECT_API_VERSION,
+ EFFECT_FLAG_TYPE_AUXILIARY,
+ "Aux Environmental Reverb",
+ "Google Inc."
+};
+
+// Google insert environmental reverb UUID: aa476040-6342-11df-91a4-0002a5d5c51b
+static const effect_descriptor_t gInsertEnvReverbDescriptor = {
+ {0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, {0x4e, 0x23, 0x4d, 0x06, 0x83, 0x9e}},
+ {0xaa476040, 0x6342, 0x11df, 0x91a4, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ EFFECT_API_VERSION,
+ EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST,
+ "Insert Environmental reverb",
+ "Google Inc."
+};
+
+// Google auxiliary preset reverb UUID: 63909320-53a6-11df-bdbd-0002a5d5c51b
+static const effect_descriptor_t gAuxPresetReverbDescriptor = {
+ {0x47382d60, 0xddd8, 0x4763, 0x11db, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ {0x63909320, 0x53a6, 0x11df, 0xbdbd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ EFFECT_API_VERSION,
+ EFFECT_FLAG_TYPE_AUXILIARY,
+ "Aux Preset Reverb",
+ "Google Inc."
+};
+
+// Google insert preset reverb UUID: d93dc6a0-6342-11df-b128-0002a5d5c51b
+static const effect_descriptor_t gInsertPresetReverbDescriptor = {
+ {0x47382d60, 0xddd8, 0x4763, 0x11db, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ {0xd93dc6a0, 0x6342, 0x11df, 0xb128, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ EFFECT_API_VERSION,
+ EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST,
+ "Insert Preset Reverb",
+ "Google Inc."
+};
+
+// gDescriptors contains pointers to all defined effect descriptor in this library
+static const effect_descriptor_t * const gDescriptors[] = {
+ &gAuxEnvReverbDescriptor,
+ &gInsertEnvReverbDescriptor,
+ &gAuxPresetReverbDescriptor,
+ &gInsertPresetReverbDescriptor,
+ NULL
+};
+
+/*----------------------------------------------------------------------------
+ * Effect API implementation
+ *--------------------------------------------------------------------------*/
+
+/*--- Effect Library Interface Implementation ---*/
+
+int EffectQueryNumberEffects(int *pNumEffects) {
+ *pNumEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *)
+ - 1;
+ gEffectIndex = 0;
+ return 0;
+}
+
+int EffectQueryNext(effect_descriptor_t *pDescriptor) {
+ if (pDescriptor == NULL) {
+ return -EINVAL;
+ }
+ if (gDescriptors[gEffectIndex] == NULL) {
+ return -ENOENT;
+ }
+ memcpy(pDescriptor, gDescriptors[gEffectIndex++],
+ sizeof(effect_descriptor_t));
+ return 0;
+}
+
+int EffectCreate(effect_uuid_t *uuid,
+ effect_interface_t *pInterface) {
+ int ret;
+ int i;
+ reverb_module_t *module;
+ const effect_descriptor_t *desc;
+ int aux = 0;
+ int preset = 0;
+
+ LOGV("EffectLibCreateEffect start");
+
+ if (pInterface == NULL || uuid == NULL) {
+ return -EINVAL;
+ }
+
+ for (i = 0; gDescriptors[i] != NULL; i++) {
+ desc = gDescriptors[i];
+ if (memcmp(uuid, &desc->uuid, sizeof(effect_uuid_t))
+ == 0) {
+ break;
+ }
+ }
+
+ if (gDescriptors[i] == NULL) {
+ return -ENOENT;
+ }
+
+ module = malloc(sizeof(reverb_module_t));
+
+ module->itfe = &gReverbInterface;
+
+ if (memcmp(&desc->type, SL_IID_PRESETREVERB, sizeof(effect_uuid_t)) == 0) {
+ preset = 1;
+ }
+ if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
+ aux = 1;
+ }
+ ret = Reverb_Init(module, aux, preset);
+ if (ret < 0) {
+ LOGW("EffectLibCreateEffect() init failed");
+ free(module);
+ return ret;
+ }
+
+ *pInterface = (effect_interface_t) module;
+
+ LOGV("EffectLibCreateEffect %p", module);
+
+ return 0;
+}
+
+int EffectRelease(effect_interface_t interface) {
+ reverb_module_t *pRvbModule = (reverb_module_t *)interface;
+
+ LOGV("EffectLibReleaseEffect %p", interface);
+ if (interface == NULL) {
+ return -EINVAL;
+ }
+
+ free(pRvbModule);
+ return 0;
+}
+
+
+/*--- Effect Control Interface Implementation ---*/
+
+static int Reverb_Process(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer) {
+ reverb_object_t *pReverb;
+ int16_t *pSrc, *pDst;
+ reverb_module_t *pRvbModule = (reverb_module_t *)self;
+
+ if (pRvbModule == NULL) {
+ return -EINVAL;
+ }
+
+ if (inBuffer == NULL || inBuffer->raw == NULL ||
+ outBuffer == NULL || outBuffer->raw == NULL ||
+ inBuffer->frameCount != outBuffer->frameCount) {
+ return -EINVAL;
+ }
+
+ pReverb = (reverb_object_t*) &pRvbModule->context;
+
+ //if bypassed or the preset forces the signal to be completely dry
+ if (pReverb->m_bBypass) {
+ if (inBuffer->raw != outBuffer->raw && !pReverb->m_Aux) {
+ memcpy(outBuffer->raw, inBuffer->raw, outBuffer->frameCount * NUM_OUTPUT_CHANNELS * sizeof(int16_t));
+ }
+ return 0;
+ }
+
+ if (pReverb->m_nNextRoom != pReverb->m_nCurrentRoom) {
+ ReverbUpdateRoom(pReverb, true);
+ }
+
+ pSrc = inBuffer->s16;
+ pDst = outBuffer->s16;
+ size_t numSamples = outBuffer->frameCount;
+ while (numSamples) {
+ uint32_t processedSamples;
+ if (numSamples > (uint32_t) pReverb->m_nUpdatePeriodInSamples) {
+ processedSamples = (uint32_t) pReverb->m_nUpdatePeriodInSamples;
+ } else {
+ processedSamples = numSamples;
+ }
+
+ /* increment update counter */
+ pReverb->m_nUpdateCounter += (int16_t) processedSamples;
+ /* check if update counter needs to be reset */
+ if (pReverb->m_nUpdateCounter >= pReverb->m_nUpdatePeriodInSamples) {
+ /* update interval has elapsed, so reset counter */
+ pReverb->m_nUpdateCounter -= pReverb->m_nUpdatePeriodInSamples;
+ ReverbUpdateXfade(pReverb, pReverb->m_nUpdatePeriodInSamples);
+
+ } /* end if m_nUpdateCounter >= update interval */
+
+ Reverb(pReverb, processedSamples, pDst, pSrc);
+
+ numSamples -= processedSamples;
+ if (pReverb->m_Aux) {
+ pDst += processedSamples;
+ } else {
+ pSrc += processedSamples * NUM_OUTPUT_CHANNELS;
+ }
+ }
+
+ return 0;
+}
+
+static int Reverb_Command(effect_interface_t self, int cmdCode, int cmdSize,
+ void *pCmdData, int *replySize, void *pReplyData) {
+ reverb_module_t *pRvbModule = (reverb_module_t *) self;
+ reverb_object_t *pReverb;
+ int retsize;
+
+ if (pRvbModule == NULL) {
+ return -EINVAL;
+ }
+
+ pReverb = (reverb_object_t*) &pRvbModule->context;
+
+ LOGV("Reverb_Command command %d cmdSize %d",cmdCode, cmdSize);
+
+ switch (cmdCode) {
+ case EFFECT_CMD_INIT:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ *(int *) pReplyData = Reverb_Init(pRvbModule, pReverb->m_Aux, pReverb->m_Preset);
+ break;
+ case EFFECT_CMD_CONFIGURE:
+ if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
+ || pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ *(int *) pReplyData = Reverb_Configure(pRvbModule,
+ (effect_config_t *)pCmdData, false);
+ break;
+ case EFFECT_CMD_RESET:
+ Reverb_Reset(pReverb, false);
+ break;
+ case EFFECT_CMD_GET_PARAM:
+ LOGV("Reverb_Command EFFECT_CMD_GET_PARAM pCmdData %p, *replySize %d, pReplyData: %p",pCmdData, *replySize, pReplyData);
+
+ if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
+ pReplyData == NULL || *replySize < (int) sizeof(effect_param_t)) {
+ return -EINVAL;
+ }
+ effect_param_t *rep = (effect_param_t *) pReplyData;
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(int32_t));
+ LOGV("Reverb_Command EFFECT_CMD_GET_PARAM param %d, replySize %d",*(int32_t *)rep->data, rep->vsize);
+ rep->status = Reverb_getParameter(pReverb, *(int32_t *)rep->data, &rep->vsize,
+ rep->data + sizeof(int32_t));
+ *replySize = sizeof(effect_param_t) + sizeof(int32_t) + rep->vsize;
+ break;
+ case EFFECT_CMD_SET_PARAM:
+ LOGV("Reverb_Command EFFECT_CMD_SET_PARAM cmdSize %d pCmdData %p, *replySize %d, pReplyData %p",
+ cmdSize, pCmdData, *replySize, pReplyData);
+ if (pCmdData == NULL || (cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)))
+ || pReplyData == NULL || *replySize != (int)sizeof(int32_t)) {
+ return -EINVAL;
+ }
+ effect_param_t *cmd = (effect_param_t *) pCmdData;
+ *(int *)pReplyData = Reverb_setParameter(pReverb, *(int32_t *)cmd->data,
+ cmd->vsize, cmd->data + sizeof(int32_t));
+ break;
+ default:
+ LOGW("Reverb_Command invalid command %d",cmdCode);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Reverb internal functions
+ *--------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+ * Reverb_Init()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Initialize reverb context and apply default parameters
+ *
+ * Inputs:
+ * pRvbModule - pointer to reverb effect module
+ * aux - indicates if the reverb is used as auxiliary (1) or insert (0)
+ * preset - indicates if the reverb is used in preset (1) or environmental (0) mode
+ *
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int Reverb_Init(reverb_module_t *pRvbModule, int aux, int preset) {
+ int ret;
+
+ LOGV("Reverb_Init module %p, aux: %d, preset: %d", pRvbModule,aux, preset);
+
+ memset(&pRvbModule->context, 0, sizeof(reverb_object_t));
+
+ pRvbModule->context.m_Aux = (uint16_t)aux;
+ pRvbModule->context.m_Preset = (uint16_t)preset;
+
+ pRvbModule->config.inputCfg.samplingRate = 44100;
+ if (aux) {
+ pRvbModule->config.inputCfg.channels = CHANNEL_MONO;
+ } else {
+ pRvbModule->config.inputCfg.channels = CHANNEL_STEREO;
+ }
+ pRvbModule->config.inputCfg.format = PCM_FORMAT_S15;
+ pRvbModule->config.inputCfg.bufferProvider.getBuffer = NULL;
+ pRvbModule->config.inputCfg.bufferProvider.releaseBuffer = NULL;
+ pRvbModule->config.inputCfg.bufferProvider.cookie = NULL;
+ pRvbModule->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
+ pRvbModule->config.inputCfg.mask = EFFECT_CONFIG_ALL;
+ pRvbModule->config.outputCfg.samplingRate = 44100;
+ pRvbModule->config.outputCfg.channels = CHANNEL_STEREO;
+ pRvbModule->config.outputCfg.format = PCM_FORMAT_S15;
+ pRvbModule->config.outputCfg.bufferProvider.getBuffer = NULL;
+ pRvbModule->config.outputCfg.bufferProvider.releaseBuffer = NULL;
+ pRvbModule->config.outputCfg.bufferProvider.cookie = NULL;
+ pRvbModule->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
+ pRvbModule->config.outputCfg.mask = EFFECT_CONFIG_ALL;
+
+ ret = Reverb_Configure(pRvbModule, &pRvbModule->config, true);
+ if (ret < 0) {
+ LOGV("Reverb_Init error %d on module %p", ret, pRvbModule);
+ }
+
+ return ret;
+}
+
+/*----------------------------------------------------------------------------
+ * Reverb_Init()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Set input and output audio configuration.
+ *
+ * Inputs:
+ * pRvbModule - pointer to reverb effect module
+ * pConfig - pointer to effect_config_t structure containing input
+ * and output audio parameters configuration
+ * init - true if called from init function
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int Reverb_Configure(reverb_module_t *pRvbModule, effect_config_t *pConfig,
+ bool init) {
+ reverb_object_t *pReverb = &pRvbModule->context;
+ int bufferSizeInSamples;
+ int updatePeriodInSamples;
+ int xfadePeriodInSamples;
+
+ // Check configuration compatibility with build options
+ if (pConfig->inputCfg.samplingRate
+ != pConfig->outputCfg.samplingRate
+ || pConfig->outputCfg.channels != OUTPUT_CHANNELS
+ || pConfig->inputCfg.format != PCM_FORMAT_S15
+ || pConfig->outputCfg.format != PCM_FORMAT_S15) {
+ LOGV("Reverb_Configure invalid config");
+ return -EINVAL;
+ }
+ if ((pReverb->m_Aux && (pConfig->inputCfg.channels != CHANNEL_MONO)) ||
+ (!pReverb->m_Aux && (pConfig->inputCfg.channels != CHANNEL_STEREO))) {
+ LOGV("Reverb_Configure invalid config");
+ return -EINVAL;
+ }
+
+ memcpy(&pRvbModule->config, pConfig, sizeof(effect_config_t));
+
+ pReverb->m_nSamplingRate = pRvbModule->config.outputCfg.samplingRate;
+
+ switch (pReverb->m_nSamplingRate) {
+ case 8000:
+ pReverb->m_nUpdatePeriodInBits = 5;
+ bufferSizeInSamples = 4096;
+ pReverb->m_nCosWT_5KHz = -23170;
+ break;
+ case 16000:
+ pReverb->m_nUpdatePeriodInBits = 6;
+ bufferSizeInSamples = 8192;
+ pReverb->m_nCosWT_5KHz = -12540;
+ break;
+ case 22050:
+ pReverb->m_nUpdatePeriodInBits = 7;
+ bufferSizeInSamples = 8192;
+ pReverb->m_nCosWT_5KHz = 4768;
+ break;
+ case 32000:
+ pReverb->m_nUpdatePeriodInBits = 7;
+ bufferSizeInSamples = 16384;
+ pReverb->m_nCosWT_5KHz = 18205;
+ break;
+ case 44100:
+ pReverb->m_nUpdatePeriodInBits = 8;
+ bufferSizeInSamples = 16384;
+ pReverb->m_nCosWT_5KHz = 24799;
+ break;
+ case 48000:
+ pReverb->m_nUpdatePeriodInBits = 8;
+ bufferSizeInSamples = 16384;
+ pReverb->m_nCosWT_5KHz = 25997;
+ break;
+ default:
+ LOGV("Reverb_Configure invalid sampling rate %d", pReverb->m_nSamplingRate);
+ return -EINVAL;
+ }
+
+ // Define a mask for circular addressing, so that array index
+ // can wraparound and stay in array boundary of 0, 1, ..., (buffer size -1)
+ // The buffer size MUST be a power of two
+ pReverb->m_nBufferMask = (int32_t) (bufferSizeInSamples - 1);
+ /* reverb parameters are updated every 2^(pReverb->m_nUpdatePeriodInBits) samples */
+ updatePeriodInSamples = (int32_t) (0x1L << pReverb->m_nUpdatePeriodInBits);
+ /*
+ calculate the update counter by bitwise ANDING with this value to
+ generate a 2^n modulo value
+ */
+ pReverb->m_nUpdatePeriodInSamples = (int32_t) updatePeriodInSamples;
+
+ xfadePeriodInSamples = (int32_t) (REVERB_XFADE_PERIOD_IN_SECONDS
+ * (double) pReverb->m_nSamplingRate);
+
+ // set xfade parameters
+ pReverb->m_nPhaseIncrement
+ = (int16_t) (65536 / ((int16_t) xfadePeriodInSamples
+ / (int16_t) updatePeriodInSamples));
+
+ if (init) {
+ ReverbReadInPresets(pReverb);
+
+ // for debugging purposes, allow noise generator
+ pReverb->m_bUseNoise = true;
+
+ // for debugging purposes, allow bypass
+ pReverb->m_bBypass = false;
+
+ pReverb->m_nNextRoom = 1;
+
+ pReverb->m_nNoise = (int16_t) 0xABCD;
+ }
+
+ Reverb_Reset(pReverb, init);
+
+ return 0;
+}
+
+/*----------------------------------------------------------------------------
+ * Reverb_Reset()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Reset internal states and clear delay lines.
+ *
+ * Inputs:
+ * pReverb - pointer to reverb context
+ * init - true if called from init function
+ *
+ * Outputs:
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void Reverb_Reset(reverb_object_t *pReverb, bool init) {
+ int bufferSizeInSamples = (int32_t) (pReverb->m_nBufferMask + 1);
+ int maxApSamples;
+ int maxDelaySamples;
+ int maxEarlySamples;
+ int ap1In;
+ int delay0In;
+ int delay1In;
+ int32_t i;
+ uint16_t nOffset;
+
+ maxApSamples = ((int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16);
+ maxDelaySamples = ((int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate)
+ >> 16);
+ maxEarlySamples = ((int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate)
+ >> 16);
+
+ ap1In = (AP0_IN + maxApSamples + GUARD);
+ delay0In = (ap1In + maxApSamples + GUARD);
+ delay1In = (delay0In + maxDelaySamples + GUARD);
+ // Define the max offsets for the end points of each section
+ // i.e., we don't expect a given section's taps to go beyond
+ // the following limits
+
+ pReverb->m_nEarly0in = (delay1In + maxDelaySamples + GUARD);
+ pReverb->m_nEarly1in = (pReverb->m_nEarly0in + maxEarlySamples + GUARD);
+
+ pReverb->m_sAp0.m_zApIn = AP0_IN;
+
+ pReverb->m_zD0In = delay0In;
+
+ pReverb->m_sAp1.m_zApIn = ap1In;
+
+ pReverb->m_zD1In = delay1In;
+
+ pReverb->m_zOutLpfL = 0;
+ pReverb->m_zOutLpfR = 0;
+
+ pReverb->m_nRevFbkR = 0;
+ pReverb->m_nRevFbkL = 0;
+
+ // set base index into circular buffer
+ pReverb->m_nBaseIndex = 0;
+
+ // clear the reverb delay line
+ for (i = 0; i < bufferSizeInSamples; i++) {
+ pReverb->m_nDelayLine[i] = 0;
+ }
+
+ ReverbUpdateRoom(pReverb, init);
+
+ pReverb->m_nUpdateCounter = 0;
+
+ pReverb->m_nPhase = -32768;
+
+ pReverb->m_nSin = 0;
+ pReverb->m_nCos = 0;
+ pReverb->m_nSinIncrement = 0;
+ pReverb->m_nCosIncrement = 0;
+
+ // set delay tap lengths
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD1Cross = pReverb->m_nDelay1Out - pReverb->m_nMaxExcursion
+ + nOffset;
+
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD0Cross = pReverb->m_nDelay0Out - pReverb->m_nMaxExcursion
+ - nOffset;
+
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD0Self = pReverb->m_nDelay0Out - pReverb->m_nMaxExcursion
+ - nOffset;
+
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD1Self = pReverb->m_nDelay1Out - pReverb->m_nMaxExcursion
+ + nOffset;
+}
+
+/*----------------------------------------------------------------------------
+ * Reverb_getParameter()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Get a Reverb parameter
+ *
+ * Inputs:
+ * pReverb - handle to instance data
+ * param - parameter
+ * pValue - pointer to variable to hold retrieved value
+ * pSize - pointer to value size: maximum size as input
+ *
+ * Outputs:
+ * *pValue updated with parameter value
+ * *pSize updated with actual value size
+ *
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+int Reverb_getParameter(reverb_object_t *pReverb, int32_t param, size_t *pSize,
+ void *pValue) {
+ int32_t *pValue32;
+ int16_t *pValue16;
+ t_reverb_properties *pProperties;
+ int32_t i;
+ int32_t temp;
+ int32_t temp2;
+ size_t size;
+
+ if (pReverb->m_Preset && param != REVERB_PARAM_PRESET) {
+ return -EINVAL;
+ }
+ if (!pReverb->m_Preset && param == REVERB_PARAM_PRESET) {
+ return -EINVAL;
+ }
+
+ switch (param) {
+ case REVERB_PARAM_ROOM_LEVEL:
+ case REVERB_PARAM_ROOM_HF_LEVEL:
+ case REVERB_PARAM_DECAY_HF_RATIO:
+ case REVERB_PARAM_REFLECTIONS_LEVEL:
+ case REVERB_PARAM_REVERB_LEVEL:
+ case REVERB_PARAM_DIFFUSION:
+ case REVERB_PARAM_DENSITY:
+ size = sizeof(int16_t);
+ break;
+
+ case REVERB_PARAM_BYPASS:
+ case REVERB_PARAM_PRESET:
+ case REVERB_PARAM_DECAY_TIME:
+ case REVERB_PARAM_REFLECTIONS_DELAY:
+ case REVERB_PARAM_REVERB_DELAY:
+ size = sizeof(int32_t);
+ break;
+
+ case REVERB_PARAM_PROPERTIES:
+ size = sizeof(t_reverb_properties);
+ break;
+
+ default:
+ return -EINVAL;
+ }
+
+ if (*pSize < size) {
+ return -EINVAL;
+ }
+ *pSize = size;
+ pValue32 = (int32_t *) pValue;
+ pValue16 = (int16_t *) pValue;
+ pProperties = (t_reverb_properties *) pValue;
+
+ switch (param) {
+ case REVERB_PARAM_BYPASS:
+ *(int32_t *) pValue = (int32_t) pReverb->m_bBypass;
+ break;
+ case REVERB_PARAM_PRESET:
+ *(int32_t *) pValue = (int8_t) pReverb->m_nCurrentRoom;
+ break;
+
+ case REVERB_PARAM_PROPERTIES:
+ pValue16 = &pProperties->roomLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_ROOM_LEVEL:
+ // Convert m_nRoomLpfFwd to millibels
+ temp = (pReverb->m_nRoomLpfFwd << 15)
+ / (32767 - pReverb->m_nRoomLpfFbk);
+ *pValue16 = Effects_Linear16ToMillibels(temp);
+
+ LOGV("get REVERB_PARAM_ROOM_LEVEL %d, gain %d, m_nRoomLpfFwd %d, m_nRoomLpfFbk %d", *pValue16, temp, pReverb->m_nRoomLpfFwd, pReverb->m_nRoomLpfFbk);
+
+ if (param == REVERB_PARAM_ROOM_LEVEL) {
+ break;
+ }
+ pValue16 = &pProperties->roomHFLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_ROOM_HF_LEVEL:
+ // The ratio between linear gain at 0Hz and at 5000Hz for the room low pass is:
+ // (1 + a1) / sqrt(a1^2 + 2*C*a1 + 1) where:
+ // - a1 is minus the LP feedback gain: -pReverb->m_nRoomLpfFbk
+ // - C is cos(2piWT) @ 5000Hz: pReverb->m_nCosWT_5KHz
+
+ temp = MULT_EG1_EG1(pReverb->m_nRoomLpfFbk, pReverb->m_nRoomLpfFbk);
+ LOGV("get REVERB_PARAM_ROOM_HF_LEVEL, a1^2 %d", temp);
+ temp2 = MULT_EG1_EG1(pReverb->m_nRoomLpfFbk, pReverb->m_nCosWT_5KHz)
+ << 1;
+ LOGV("get REVERB_PARAM_ROOM_HF_LEVEL, 2 Cos a1 %d", temp2);
+ temp = 32767 + temp - temp2;
+ LOGV("get REVERB_PARAM_ROOM_HF_LEVEL, a1^2 + 2 Cos a1 + 1 %d", temp);
+ temp = Effects_Sqrt(temp) * 181;
+ LOGV("get REVERB_PARAM_ROOM_HF_LEVEL, SQRT(a1^2 + 2 Cos a1 + 1) %d", temp);
+ temp = ((32767 - pReverb->m_nRoomLpfFbk) << 15) / temp;
+
+ LOGV("get REVERB_PARAM_ROOM_HF_LEVEL, gain %d, m_nRoomLpfFwd %d, m_nRoomLpfFbk %d", temp, pReverb->m_nRoomLpfFwd, pReverb->m_nRoomLpfFbk);
+
+ *pValue16 = Effects_Linear16ToMillibels(temp);
+
+ if (param == REVERB_PARAM_ROOM_HF_LEVEL) {
+ break;
+ }
+ pValue32 = &pProperties->decayTime;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DECAY_TIME:
+ // Calculate reverb feedback path gain
+ temp = (pReverb->m_nRvbLpfFwd << 15) / (32767 - pReverb->m_nRvbLpfFbk);
+ temp = Effects_Linear16ToMillibels(temp);
+
+ // Calculate decay time: g = -6000 d/DT , g gain in millibels, d reverb delay, DT decay time
+ temp = (-6000 * pReverb->m_nLateDelay) / temp;
+
+ // Convert samples to ms
+ *pValue32 = (temp * 1000) / pReverb->m_nSamplingRate;
+
+ LOGV("get REVERB_PARAM_DECAY_TIME, samples %d, ms %d", temp, *pValue32);
+
+ if (param == REVERB_PARAM_DECAY_TIME) {
+ break;
+ }
+ pValue16 = &pProperties->decayHFRatio;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DECAY_HF_RATIO:
+ // If r is the decay HF ratio (r = REVERB_PARAM_DECAY_HF_RATIO/1000) we have:
+ // DT_5000Hz = DT_0Hz * r
+ // and G_5000Hz = -6000 * d / DT_5000Hz and G_0Hz = -6000 * d / DT_0Hz in millibels so :
+ // r = G_0Hz/G_5000Hz in millibels
+ // The linear gain at 5000Hz is b0 / sqrt(a1^2 + 2*C*a1 + 1) where:
+ // - a1 is minus the LP feedback gain: -pReverb->m_nRvbLpfFbk
+ // - b0 is the LP forward gain: pReverb->m_nRvbLpfFwd
+ // - C is cos(2piWT) @ 5000Hz: pReverb->m_nCosWT_5KHz
+ if (pReverb->m_nRvbLpfFbk == 0) {
+ *pValue16 = 1000;
+ LOGV("get REVERB_PARAM_DECAY_HF_RATIO, pReverb->m_nRvbLpfFbk == 0, ratio %d", *pValue16);
+ } else {
+ temp = MULT_EG1_EG1(pReverb->m_nRvbLpfFbk, pReverb->m_nRvbLpfFbk);
+ temp2 = MULT_EG1_EG1(pReverb->m_nRvbLpfFbk, pReverb->m_nCosWT_5KHz)
+ << 1;
+ temp = 32767 + temp - temp2;
+ temp = Effects_Sqrt(temp) * 181;
+ temp = (pReverb->m_nRvbLpfFwd << 15) / temp;
+ // The linear gain at 0Hz is b0 / (a1 + 1)
+ temp2 = (pReverb->m_nRvbLpfFwd << 15) / (32767
+ - pReverb->m_nRvbLpfFbk);
+
+ temp = Effects_Linear16ToMillibels(temp);
+ temp2 = Effects_Linear16ToMillibels(temp2);
+ LOGV("get REVERB_PARAM_DECAY_HF_RATIO, gain 5KHz %d mB, gain DC %d mB", temp, temp2);
+
+ if (temp == 0)
+ temp = 1;
+ temp = (int16_t) ((1000 * temp2) / temp);
+ if (temp > 1000)
+ temp = 1000;
+
+ *pValue16 = temp;
+ LOGV("get REVERB_PARAM_DECAY_HF_RATIO, ratio %d", *pValue16);
+ }
+
+ if (param == REVERB_PARAM_DECAY_HF_RATIO) {
+ break;
+ }
+ pValue16 = &pProperties->reflectionsLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REFLECTIONS_LEVEL:
+ *pValue16 = Effects_Linear16ToMillibels(pReverb->m_nEarlyGain);
+
+ LOGV("get REVERB_PARAM_REFLECTIONS_LEVEL, %d", *pValue16);
+ if (param == REVERB_PARAM_REFLECTIONS_LEVEL) {
+ break;
+ }
+ pValue32 = &pProperties->reflectionsDelay;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REFLECTIONS_DELAY:
+ // convert samples to ms
+ *pValue32 = (pReverb->m_nEarlyDelay * 1000) / pReverb->m_nSamplingRate;
+
+ LOGV("get REVERB_PARAM_REFLECTIONS_DELAY, samples %d, ms %d", pReverb->m_nEarlyDelay, *pValue32);
+
+ if (param == REVERB_PARAM_REFLECTIONS_DELAY) {
+ break;
+ }
+ pValue16 = &pProperties->reverbLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REVERB_LEVEL:
+ // Convert linear gain to millibels
+ *pValue16 = Effects_Linear16ToMillibels(pReverb->m_nLateGain << 2);
+
+ LOGV("get REVERB_PARAM_REVERB_LEVEL %d", *pValue16);
+
+ if (param == REVERB_PARAM_REVERB_LEVEL) {
+ break;
+ }
+ pValue32 = &pProperties->reverbDelay;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REVERB_DELAY:
+ // convert samples to ms
+ *pValue32 = (pReverb->m_nLateDelay * 1000) / pReverb->m_nSamplingRate;
+
+ LOGV("get REVERB_PARAM_REVERB_DELAY, samples %d, ms %d", pReverb->m_nLateDelay, *pValue32);
+
+ if (param == REVERB_PARAM_REVERB_DELAY) {
+ break;
+ }
+ pValue16 = &pProperties->diffusion;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DIFFUSION:
+ temp = (int16_t) ((1000 * (pReverb->m_sAp0.m_nApGain - AP0_GAIN_BASE))
+ / AP0_GAIN_RANGE);
+
+ if (temp < 0)
+ temp = 0;
+ if (temp > 1000)
+ temp = 1000;
+
+ *pValue16 = temp;
+ LOGV("get REVERB_PARAM_DIFFUSION, %d, AP0 gain %d", *pValue16, pReverb->m_sAp0.m_nApGain);
+
+ if (param == REVERB_PARAM_DIFFUSION) {
+ break;
+ }
+ pValue16 = &pProperties->density;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DENSITY:
+ // Calculate AP delay in time units
+ temp = ((pReverb->m_sAp0.m_zApOut - pReverb->m_sAp0.m_zApIn) << 16)
+ / pReverb->m_nSamplingRate;
+
+ temp = (int16_t) ((1000 * (temp - AP0_TIME_BASE)) / AP0_TIME_RANGE);
+
+ if (temp < 0)
+ temp = 0;
+ if (temp > 1000)
+ temp = 1000;
+
+ *pValue16 = temp;
+
+ LOGV("get REVERB_PARAM_DENSITY, %d, AP0 delay smps %d", *pValue16, pReverb->m_sAp0.m_zApOut - pReverb->m_sAp0.m_zApIn);
+ break;
+
+ default:
+ break;
+ }
+
+ LOGV("Reverb_getParameter, context %p, param %d, value %d",
+ pReverb, param, *(int *)pValue);
+
+ return 0;
+} /* end Reverb_getParameter */
+
+/*----------------------------------------------------------------------------
+ * Reverb_setParameter()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Set a Reverb parameter
+ *
+ * Inputs:
+ * pReverb - handle to instance data
+ * param - parameter
+ * pValue - pointer to parameter value
+ * size - value size
+ *
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+int Reverb_setParameter(reverb_object_t *pReverb, int32_t param, size_t size,
+ void *pValue) {
+ int32_t value32;
+ int16_t value16;
+ t_reverb_properties *pProperties;
+ int32_t i;
+ int32_t temp;
+ int32_t temp2;
+ reverb_preset_t *pPreset;
+ int maxSamples;
+ int32_t averageDelay;
+ size_t paramSize;
+
+ LOGV("Reverb_setParameter, context %p, param %d, value16 %d, value32 %d",
+ pReverb, param, *(int16_t *)pValue, *(int32_t *)pValue);
+
+ if (pReverb->m_Preset && param != REVERB_PARAM_PRESET) {
+ return -EINVAL;
+ }
+ if (!pReverb->m_Preset && param == REVERB_PARAM_PRESET) {
+ return -EINVAL;
+ }
+
+ switch (param) {
+ case REVERB_PARAM_ROOM_LEVEL:
+ case REVERB_PARAM_ROOM_HF_LEVEL:
+ case REVERB_PARAM_DECAY_HF_RATIO:
+ case REVERB_PARAM_REFLECTIONS_LEVEL:
+ case REVERB_PARAM_REVERB_LEVEL:
+ case REVERB_PARAM_DIFFUSION:
+ case REVERB_PARAM_DENSITY:
+ paramSize = sizeof(int16_t);
+ break;
+
+ case REVERB_PARAM_BYPASS:
+ case REVERB_PARAM_PRESET:
+ case REVERB_PARAM_DECAY_TIME:
+ case REVERB_PARAM_REFLECTIONS_DELAY:
+ case REVERB_PARAM_REVERB_DELAY:
+ paramSize = sizeof(int32_t);
+ break;
+
+ case REVERB_PARAM_PROPERTIES:
+ paramSize = sizeof(t_reverb_properties);
+ break;
+
+ default:
+ return -EINVAL;
+ }
+
+ if (size != paramSize) {
+ return -EINVAL;
+ }
+
+ if (paramSize == sizeof(int16_t)) {
+ value16 = *(int16_t *) pValue;
+ } else if (paramSize == sizeof(int32_t)) {
+ value32 = *(int32_t *) pValue;
+ } else {
+ pProperties = (t_reverb_properties *) pValue;
+ }
+
+ pPreset = &pReverb->m_sPreset.m_sPreset[pReverb->m_nCurrentRoom];
+
+ switch (param) {
+ case REVERB_PARAM_BYPASS:
+ pReverb->m_bBypass = (uint16_t)value32;
+ break;
+ case REVERB_PARAM_PRESET:
+ if (value32 != REVERB_PRESET_LARGE_HALL && value32
+ != REVERB_PRESET_HALL && value32 != REVERB_PRESET_CHAMBER
+ && value32 != REVERB_PRESET_ROOM)
+ return -EINVAL;
+ pReverb->m_nNextRoom = (int16_t) value32;
+ break;
+
+ case REVERB_PARAM_PROPERTIES:
+ value16 = pProperties->roomLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_ROOM_LEVEL:
+ // Convert millibels to linear 16 bit signed => m_nRoomLpfFwd
+ if (value16 > 0)
+ return -EINVAL;
+
+ temp = Effects_MillibelsToLinear16(value16);
+
+ pReverb->m_nRoomLpfFwd
+ = MULT_EG1_EG1(temp, (32767 - pReverb->m_nRoomLpfFbk));
+
+ LOGV("REVERB_PARAM_ROOM_LEVEL, gain %d, new m_nRoomLpfFwd %d, m_nRoomLpfFbk %d", temp, pReverb->m_nRoomLpfFwd, pReverb->m_nRoomLpfFbk);
+ if (param == REVERB_PARAM_ROOM_LEVEL)
+ break;
+ value16 = pProperties->roomHFLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_ROOM_HF_LEVEL:
+
+ // Limit to 0 , -40dB range because of low pass implementation
+ if (value16 > 0 || value16 < -4000)
+ return -EINVAL;
+ // Convert attenuation @ 5000H expressed in millibels to => m_nRoomLpfFbk
+ // m_nRoomLpfFbk is -a1 where a1 is the solution of:
+ // a1^2 + 2*(C-dG^2)/(1-dG^2)*a1 + 1 = 0 where:
+ // - C is cos(2*pi*5000/Fs) (pReverb->m_nCosWT_5KHz)
+ // - dG is G0/Gf (G0 is the linear gain at DC and Gf is the wanted gain at 5000Hz)
+
+ // Save current DC gain m_nRoomLpfFwd / (32767 - m_nRoomLpfFbk) to keep it unchanged
+ // while changing HF level
+ temp2 = (pReverb->m_nRoomLpfFwd << 15) / (32767
+ - pReverb->m_nRoomLpfFbk);
+ if (value16 == 0) {
+ pReverb->m_nRoomLpfFbk = 0;
+ } else {
+ int32_t dG2, b, delta;
+
+ // dG^2
+ temp = Effects_MillibelsToLinear16(value16);
+ LOGV("REVERB_PARAM_ROOM_HF_LEVEL, HF gain %d", temp);
+ temp = (1 << 30) / temp;
+ LOGV("REVERB_PARAM_ROOM_HF_LEVEL, 1/ HF gain %d", temp);
+ dG2 = (int32_t) (((int64_t) temp * (int64_t) temp) >> 15);
+ LOGV("REVERB_PARAM_ROOM_HF_LEVEL, 1/ HF gain ^ 2 %d", dG2);
+ // b = 2*(C-dG^2)/(1-dG^2)
+ b = (int32_t) ((((int64_t) 1 << (15 + 1))
+ * ((int64_t) pReverb->m_nCosWT_5KHz - (int64_t) dG2))
+ / ((int64_t) 32767 - (int64_t) dG2));
+
+ // delta = b^2 - 4
+ delta = (int32_t) ((((int64_t) b * (int64_t) b) >> 15) - (1 << (15
+ + 2)));
+
+ LOGV_IF(delta > (1<<30), " delta overflow %d", delta);
+
+ LOGV("REVERB_PARAM_ROOM_HF_LEVEL, dG2 %d, b %d, delta %d, m_nCosWT_5KHz %d", dG2, b, delta, pReverb->m_nCosWT_5KHz);
+ // m_nRoomLpfFbk = -a1 = - (- b + sqrt(delta)) / 2
+ pReverb->m_nRoomLpfFbk = (b - Effects_Sqrt(delta) * 181) >> 1;
+ }
+ LOGV("REVERB_PARAM_ROOM_HF_LEVEL, olg DC gain %d new m_nRoomLpfFbk %d, old m_nRoomLpfFwd %d",
+ temp2, pReverb->m_nRoomLpfFbk, pReverb->m_nRoomLpfFwd);
+
+ pReverb->m_nRoomLpfFwd
+ = MULT_EG1_EG1(temp2, (32767 - pReverb->m_nRoomLpfFbk));
+ LOGV("REVERB_PARAM_ROOM_HF_LEVEL, new m_nRoomLpfFwd %d", pReverb->m_nRoomLpfFwd);
+
+ if (param == REVERB_PARAM_ROOM_HF_LEVEL)
+ break;
+ value32 = pProperties->decayTime;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DECAY_TIME:
+
+ // Convert milliseconds to => m_nRvbLpfFwd (function of m_nRvbLpfFbk)
+ // convert ms to samples
+ value32 = (value32 * pReverb->m_nSamplingRate) / 1000;
+ // 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
+ // Calculate attenuation for each round in late reverb given a total attenuation of -6000 millibels.
+ // g = -6000 d/DT , g gain in millibels, d reverb delay, DT decay time
+ averageDelay = pReverb->m_nLateDelay - pReverb->m_nMaxExcursion;
+ averageDelay += ((pReverb->m_sAp0.m_zApOut - pReverb->m_sAp0.m_zApIn)
+ + (pReverb->m_sAp1.m_zApOut - pReverb->m_sAp1.m_zApIn)) >> 1;
+
+ temp = (-6000 * averageDelay) / value32;
+ LOGV("REVERB_PARAM_DECAY_TIME, delay smps %d, DT smps %d, gain mB %d",averageDelay, value32, temp);
+ if (temp < -4000 || temp > -100)
+ return -EINVAL;
+
+ // calculate low pass gain by adding reverb input attenuation (pReverb->m_nLateGain) and substrating output
+ // xfade and sum gain (max +9dB)
+ temp -= Effects_Linear16ToMillibels(pReverb->m_nLateGain) + 900;
+ temp = Effects_MillibelsToLinear16(temp);
+
+ // DC gain (temp) = b0 / (1 + a1) = pReverb->m_nRvbLpfFwd / (32767 - pReverb->m_nRvbLpfFbk)
+ pReverb->m_nRvbLpfFwd
+ = MULT_EG1_EG1(temp, (32767 - pReverb->m_nRvbLpfFbk));
+
+ LOGV("REVERB_PARAM_DECAY_TIME, gain %d, new m_nRvbLpfFwd %d, old m_nRvbLpfFbk %d, reverb gain %d", temp, pReverb->m_nRvbLpfFwd, pReverb->m_nRvbLpfFbk, Effects_Linear16ToMillibels(pReverb->m_nLateGain));
+
+ if (param == REVERB_PARAM_DECAY_TIME)
+ break;
+ value16 = pProperties->decayHFRatio;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DECAY_HF_RATIO:
+
+ // We limit max value to 1000 because reverb filter is lowpass only
+ if (value16 < 100 || value16 > 1000)
+ return -EINVAL;
+ // Convert per mille to => m_nLpfFwd, m_nLpfFbk
+
+ // Save current DC gain m_nRoomLpfFwd / (32767 - m_nRoomLpfFbk) to keep it unchanged
+ // while changing HF level
+ temp2 = (pReverb->m_nRvbLpfFwd << 15) / (32767 - pReverb->m_nRvbLpfFbk);
+
+ if (value16 == 1000) {
+ pReverb->m_nRvbLpfFbk = 0;
+ } else {
+ int32_t dG2, b, delta;
+
+ temp = Effects_Linear16ToMillibels(temp2);
+ // G_5000Hz = G_DC * (1000/REVERB_PARAM_DECAY_HF_RATIO) in millibels
+
+ value32 = ((int32_t) 1000 << 15) / (int32_t) value16;
+ LOGV("REVERB_PARAM_DECAY_HF_RATIO, DC gain %d, DC gain mB %d, 1000/R %d", temp2, temp, value32);
+
+ temp = (int32_t) (((int64_t) temp * (int64_t) value32) >> 15);
+
+ if (temp < -4000) {
+ LOGV("REVERB_PARAM_DECAY_HF_RATIO HF gain overflow %d mB", temp);
+ temp = -4000;
+ }
+
+ temp = Effects_MillibelsToLinear16(temp);
+ LOGV("REVERB_PARAM_DECAY_HF_RATIO, HF gain %d", temp);
+ // dG^2
+ temp = (temp2 << 15) / temp;
+ dG2 = (int32_t) (((int64_t) temp * (int64_t) temp) >> 15);
+
+ // b = 2*(C-dG^2)/(1-dG^2)
+ b = (int32_t) ((((int64_t) 1 << (15 + 1))
+ * ((int64_t) pReverb->m_nCosWT_5KHz - (int64_t) dG2))
+ / ((int64_t) 32767 - (int64_t) dG2));
+
+ // delta = b^2 - 4
+ delta = (int32_t) ((((int64_t) b * (int64_t) b) >> 15) - (1 << (15
+ + 2)));
+
+ // m_nRoomLpfFbk = -a1 = - (- b + sqrt(delta)) / 2
+ pReverb->m_nRvbLpfFbk = (b - Effects_Sqrt(delta) * 181) >> 1;
+
+ LOGV("REVERB_PARAM_DECAY_HF_RATIO, dG2 %d, b %d, delta %d", dG2, b, delta);
+
+ }
+
+ LOGV("REVERB_PARAM_DECAY_HF_RATIO, gain %d, m_nRvbLpfFbk %d, m_nRvbLpfFwd %d", temp2, pReverb->m_nRvbLpfFbk, pReverb->m_nRvbLpfFwd);
+
+ pReverb->m_nRvbLpfFwd
+ = MULT_EG1_EG1(temp2, (32767 - pReverb->m_nRvbLpfFbk));
+
+ if (param == REVERB_PARAM_DECAY_HF_RATIO)
+ break;
+ value16 = pProperties->reflectionsLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REFLECTIONS_LEVEL:
+ // We limit max value to 0 because gain is limited to 0dB
+ if (value16 > 0 || value16 < -6000)
+ return -EINVAL;
+
+ // Convert millibels to linear 16 bit signed and recompute m_sEarlyL.m_nGain[i] and m_sEarlyR.m_nGain[i].
+ value16 = Effects_MillibelsToLinear16(value16);
+ for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) {
+ pReverb->m_sEarlyL.m_nGain[i]
+ = MULT_EG1_EG1(pPreset->m_sEarlyL.m_nGain[i],value16);
+ pReverb->m_sEarlyR.m_nGain[i]
+ = MULT_EG1_EG1(pPreset->m_sEarlyR.m_nGain[i],value16);
+ }
+ pReverb->m_nEarlyGain = value16;
+ LOGV("REVERB_PARAM_REFLECTIONS_LEVEL, m_nEarlyGain %d", pReverb->m_nEarlyGain);
+
+ if (param == REVERB_PARAM_REFLECTIONS_LEVEL)
+ break;
+ value32 = pProperties->reflectionsDelay;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REFLECTIONS_DELAY:
+ // We limit max value MAX_EARLY_TIME
+ // convert ms to time units
+ temp = (value32 * 65536) / 1000;
+ if (temp < 0 || temp > MAX_EARLY_TIME)
+ return -EINVAL;
+
+ maxSamples = (int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate)
+ >> 16;
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) {
+ temp2 = temp + (((int32_t) pPreset->m_sEarlyL.m_zDelay[i]
+ * pReverb->m_nSamplingRate) >> 16);
+ if (temp2 > maxSamples)
+ temp2 = maxSamples;
+ pReverb->m_sEarlyL.m_zDelay[i] = pReverb->m_nEarly0in + temp2;
+ temp2 = temp + (((int32_t) pPreset->m_sEarlyR.m_zDelay[i]
+ * pReverb->m_nSamplingRate) >> 16);
+ if (temp2 > maxSamples)
+ temp2 = maxSamples;
+ pReverb->m_sEarlyR.m_zDelay[i] = pReverb->m_nEarly1in + temp2;
+ }
+ pReverb->m_nEarlyDelay = temp;
+
+ LOGV("REVERB_PARAM_REFLECTIONS_DELAY, m_nEarlyDelay smps %d max smp delay %d", pReverb->m_nEarlyDelay, maxSamples);
+
+ // Convert milliseconds to sample count => m_nEarlyDelay
+ if (param == REVERB_PARAM_REFLECTIONS_DELAY)
+ break;
+ value16 = pProperties->reverbLevel;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REVERB_LEVEL:
+ // We limit max value to 0 because gain is limited to 0dB
+ if (value16 > 0 || value16 < -6000)
+ return -EINVAL;
+ // Convert millibels to linear 16 bits (gange 0 - 8191) => m_nLateGain.
+ pReverb->m_nLateGain = Effects_MillibelsToLinear16(value16) >> 2;
+
+ LOGV("REVERB_PARAM_REVERB_LEVEL, m_nLateGain %d", pReverb->m_nLateGain);
+
+ if (param == REVERB_PARAM_REVERB_LEVEL)
+ break;
+ value32 = pProperties->reverbDelay;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_REVERB_DELAY:
+ // We limit max value to MAX_DELAY_TIME
+ // convert ms to time units
+ temp = (value32 * 65536) / 1000;
+ if (temp < 0 || temp > MAX_DELAY_TIME)
+ return -EINVAL;
+
+ maxSamples = (int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate)
+ >> 16;
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ if ((temp + pReverb->m_nMaxExcursion) > maxSamples) {
+ temp = maxSamples - pReverb->m_nMaxExcursion;
+ }
+ if (temp < pReverb->m_nMaxExcursion) {
+ temp = pReverb->m_nMaxExcursion;
+ }
+
+ temp -= pReverb->m_nLateDelay;
+ pReverb->m_nDelay0Out += temp;
+ pReverb->m_nDelay1Out += temp;
+ pReverb->m_nLateDelay += temp;
+
+ LOGV("REVERB_PARAM_REVERB_DELAY, m_nLateDelay smps %d max smp delay %d", pReverb->m_nLateDelay, maxSamples);
+
+ // Convert milliseconds to sample count => m_nDelay1Out + m_nMaxExcursion
+ if (param == REVERB_PARAM_REVERB_DELAY)
+ break;
+
+ value16 = pProperties->diffusion;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DIFFUSION:
+ if (value16 < 0 || value16 > 1000)
+ return -EINVAL;
+
+ // Convert per mille to m_sAp0.m_nApGain, m_sAp1.m_nApGain
+ pReverb->m_sAp0.m_nApGain = AP0_GAIN_BASE + ((int32_t) value16
+ * AP0_GAIN_RANGE) / 1000;
+ pReverb->m_sAp1.m_nApGain = AP1_GAIN_BASE + ((int32_t) value16
+ * AP1_GAIN_RANGE) / 1000;
+
+ LOGV("REVERB_PARAM_DIFFUSION, m_sAp0.m_nApGain %d m_sAp1.m_nApGain %d", pReverb->m_sAp0.m_nApGain, pReverb->m_sAp1.m_nApGain);
+
+ if (param == REVERB_PARAM_DIFFUSION)
+ break;
+
+ value16 = pProperties->density;
+ /* FALL THROUGH */
+
+ case REVERB_PARAM_DENSITY:
+ if (value16 < 0 || value16 > 1000)
+ return -EINVAL;
+
+ // Convert per mille to m_sAp0.m_zApOut, m_sAp1.m_zApOut
+ maxSamples = (int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16;
+
+ temp = AP0_TIME_BASE + ((int32_t) value16 * AP0_TIME_RANGE) / 1000;
+ /*lint -e{702} shift for performance */
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ if (temp > maxSamples)
+ temp = maxSamples;
+ pReverb->m_sAp0.m_zApOut = (uint16_t) (pReverb->m_sAp0.m_zApIn + temp);
+
+ LOGV("REVERB_PARAM_DENSITY, Ap0 delay smps %d", temp);
+
+ temp = AP1_TIME_BASE + ((int32_t) value16 * AP1_TIME_RANGE) / 1000;
+ /*lint -e{702} shift for performance */
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ if (temp > maxSamples)
+ temp = maxSamples;
+ pReverb->m_sAp1.m_zApOut = (uint16_t) (pReverb->m_sAp1.m_zApIn + temp);
+
+ LOGV("Ap1 delay smps %d", temp);
+
+ break;
+
+ default:
+ break;
+ }
+ return 0;
+} /* end Reverb_setParameter */
+
+/*----------------------------------------------------------------------------
+ * ReverbUpdateXfade
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Update the xfade parameters as required
+ *
+ * Inputs:
+ * nNumSamplesToAdd - number of samples to write to buffer
+ *
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ * - xfade parameters will be changed
+ *
+ *----------------------------------------------------------------------------
+ */
+static int ReverbUpdateXfade(reverb_object_t *pReverb, int nNumSamplesToAdd) {
+ uint16_t nOffset;
+ int16_t tempCos;
+ int16_t tempSin;
+
+ if (pReverb->m_nXfadeCounter >= pReverb->m_nXfadeInterval) {
+ /* update interval has elapsed, so reset counter */
+ pReverb->m_nXfadeCounter = 0;
+
+ // Pin the sin,cos values to min / max values to ensure that the
+ // modulated taps' coefs are zero (thus no clicks)
+ if (pReverb->m_nPhaseIncrement > 0) {
+ // if phase increment > 0, then sin -> 1, cos -> 0
+ pReverb->m_nSin = 32767;
+ pReverb->m_nCos = 0;
+
+ // reset the phase to match the sin, cos values
+ pReverb->m_nPhase = 32767;
+
+ // modulate the cross taps because their tap coefs are zero
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD1Cross = pReverb->m_nDelay1Out
+ - pReverb->m_nMaxExcursion + nOffset;
+
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD0Cross = pReverb->m_nDelay0Out
+ - pReverb->m_nMaxExcursion - nOffset;
+ } else {
+ // if phase increment < 0, then sin -> 0, cos -> 1
+ pReverb->m_nSin = 0;
+ pReverb->m_nCos = 32767;
+
+ // reset the phase to match the sin, cos values
+ pReverb->m_nPhase = -32768;
+
+ // modulate the self taps because their tap coefs are zero
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD0Self = pReverb->m_nDelay0Out
+ - pReverb->m_nMaxExcursion - nOffset;
+
+ nOffset = ReverbCalculateNoise(pReverb);
+
+ pReverb->m_zD1Self = pReverb->m_nDelay1Out
+ - pReverb->m_nMaxExcursion + nOffset;
+
+ } // end if-else (pReverb->m_nPhaseIncrement > 0)
+
+ // Reverse the direction of the sin,cos so that the
+ // tap whose coef was previously increasing now decreases
+ // and vice versa
+ pReverb->m_nPhaseIncrement = -pReverb->m_nPhaseIncrement;
+
+ } // end if counter >= update interval
+
+ //compute what phase will be next time
+ pReverb->m_nPhase += pReverb->m_nPhaseIncrement;
+
+ //calculate what the new sin and cos need to reach by the next update
+ ReverbCalculateSinCos(pReverb->m_nPhase, &tempSin, &tempCos);
+
+ //calculate the per-sample increment required to get there by the next update
+ /*lint -e{702} shift for performance */
+ pReverb->m_nSinIncrement = (tempSin - pReverb->m_nSin)
+ >> pReverb->m_nUpdatePeriodInBits;
+
+ /*lint -e{702} shift for performance */
+ pReverb->m_nCosIncrement = (tempCos - pReverb->m_nCos)
+ >> pReverb->m_nUpdatePeriodInBits;
+
+ /* increment update counter */
+ pReverb->m_nXfadeCounter += (uint16_t) nNumSamplesToAdd;
+
+ return 0;
+
+} /* end ReverbUpdateXfade */
+
+/*----------------------------------------------------------------------------
+ * ReverbCalculateNoise
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Calculate a noise sample and limit its value
+ *
+ * Inputs:
+ * nMaxExcursion - noise value is limited to this value
+ * pnNoise - return new noise sample in this (not limited)
+ *
+ * Outputs:
+ * new limited noise value
+ *
+ * Side Effects:
+ * - *pnNoise noise value is updated
+ *
+ *----------------------------------------------------------------------------
+ */
+static uint16_t ReverbCalculateNoise(reverb_object_t *pReverb) {
+ int16_t nNoise = pReverb->m_nNoise;
+
+ // calculate new noise value
+ if (pReverb->m_bUseNoise) {
+ nNoise = (int16_t) (nNoise * 5 + 1);
+ } else {
+ nNoise = 0;
+ }
+
+ pReverb->m_nNoise = nNoise;
+ // return the limited noise value
+ return (pReverb->m_nMaxExcursion & nNoise);
+
+} /* end ReverbCalculateNoise */
+
+/*----------------------------------------------------------------------------
+ * ReverbCalculateSinCos
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Calculate a new sin and cosine value based on the given phase
+ *
+ * Inputs:
+ * nPhase - phase angle
+ * pnSin - input old value, output new value
+ * pnCos - input old value, output new value
+ *
+ * Outputs:
+ *
+ * Side Effects:
+ * - *pnSin, *pnCos are updated
+ *
+ *----------------------------------------------------------------------------
+ */
+static int ReverbCalculateSinCos(int16_t nPhase, int16_t *pnSin, int16_t *pnCos) {
+ int32_t nTemp;
+ int32_t nNetAngle;
+
+ // -1 <= nPhase < 1
+ // However, for the calculation, we need a value
+ // that ranges from -1/2 to +1/2, so divide the phase by 2
+ /*lint -e{702} shift for performance */
+ nNetAngle = nPhase >> 1;
+
+ /*
+ Implement the following
+ sin(x) = (2-4*c)*x^2 + c + x
+ cos(x) = (2-4*c)*x^2 + c - x
+
+ where c = 1/sqrt(2)
+ using the a0 + x*(a1 + x*a2) approach
+ */
+
+ /* limit the input "angle" to be between -0.5 and +0.5 */
+ if (nNetAngle > EG1_HALF) {
+ nNetAngle = EG1_HALF;
+ } else if (nNetAngle < EG1_MINUS_HALF) {
+ nNetAngle = EG1_MINUS_HALF;
+ }
+
+ /* calculate sin */
+ nTemp = EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle);
+ nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle);
+ *pnSin = (int16_t) SATURATE_EG1(nTemp);
+
+ /* calculate cos */
+ nTemp = -EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle);
+ nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle);
+ *pnCos = (int16_t) SATURATE_EG1(nTemp);
+
+ return 0;
+} /* end ReverbCalculateSinCos */
+
+/*----------------------------------------------------------------------------
+ * Reverb
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * apply reverb to the given signal
+ *
+ * Inputs:
+ * nNu
+ * pnSin - input old value, output new value
+ * pnCos - input old value, output new value
+ *
+ * Outputs:
+ * number of samples actually reverberated
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+static int Reverb(reverb_object_t *pReverb, int nNumSamplesToAdd,
+ short *pOutputBuffer, short *pInputBuffer) {
+ int32_t i;
+ int32_t nDelayOut0;
+ int32_t nDelayOut1;
+ uint16_t nBase;
+
+ uint32_t nAddr;
+ int32_t nTemp1;
+ int32_t nTemp2;
+ int32_t nApIn;
+ int32_t nApOut;
+
+ int32_t j;
+ int32_t nEarlyOut;
+
+ int32_t tempValue;
+
+ // get the base address
+ nBase = pReverb->m_nBaseIndex;
+
+ for (i = 0; i < nNumSamplesToAdd; i++) {
+ // ********** Left Allpass - start
+ nApIn = *pInputBuffer;
+ if (!pReverb->m_Aux) {
+ pInputBuffer++;
+ }
+ // store to early delay line
+ nAddr = CIRCULAR(nBase, pReverb->m_nEarly0in, pReverb->m_nBufferMask);
+ pReverb->m_nDelayLine[nAddr] = (short) nApIn;
+
+ // left input = (left dry * m_nLateGain) + right feedback from previous period
+
+ nApIn = SATURATE(nApIn + pReverb->m_nRevFbkR);
+ nApIn = MULT_EG1_EG1(nApIn, pReverb->m_nLateGain);
+
+ // fetch allpass delay line out
+ //nAddr = CIRCULAR(nBase, psAp0->m_zApOut, pReverb->m_nBufferMask);
+ nAddr
+ = CIRCULAR(nBase, pReverb->m_sAp0.m_zApOut, pReverb->m_nBufferMask);
+ nDelayOut0 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate allpass feedforward; subtract the feedforward result
+ nTemp1 = MULT_EG1_EG1(nApIn, pReverb->m_sAp0.m_nApGain);
+ nApOut = SATURATE(nDelayOut0 - nTemp1); // allpass output
+
+ // calculate allpass feedback; add the feedback result
+ nTemp1 = MULT_EG1_EG1(nApOut, pReverb->m_sAp0.m_nApGain);
+ nTemp1 = SATURATE(nApIn + nTemp1);
+
+ // inject into allpass delay
+ nAddr
+ = CIRCULAR(nBase, pReverb->m_sAp0.m_zApIn, pReverb->m_nBufferMask);
+ pReverb->m_nDelayLine[nAddr] = (short) nTemp1;
+
+ // inject allpass output into delay line
+ nAddr = CIRCULAR(nBase, pReverb->m_zD0In, pReverb->m_nBufferMask);
+ pReverb->m_nDelayLine[nAddr] = (short) nApOut;
+
+ // ********** Left Allpass - end
+
+ // ********** Right Allpass - start
+ nApIn = (*pInputBuffer++);
+ // store to early delay line
+ nAddr = CIRCULAR(nBase, pReverb->m_nEarly1in, pReverb->m_nBufferMask);
+ pReverb->m_nDelayLine[nAddr] = (short) nApIn;
+
+ // right input = (right dry * m_nLateGain) + left feedback from previous period
+ /*lint -e{702} use shift for performance */
+ nApIn = SATURATE(nApIn + pReverb->m_nRevFbkL);
+ nApIn = MULT_EG1_EG1(nApIn, pReverb->m_nLateGain);
+
+ // fetch allpass delay line out
+ nAddr
+ = CIRCULAR(nBase, pReverb->m_sAp1.m_zApOut, pReverb->m_nBufferMask);
+ nDelayOut1 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate allpass feedforward; subtract the feedforward result
+ nTemp1 = MULT_EG1_EG1(nApIn, pReverb->m_sAp1.m_nApGain);
+ nApOut = SATURATE(nDelayOut1 - nTemp1); // allpass output
+
+ // calculate allpass feedback; add the feedback result
+ nTemp1 = MULT_EG1_EG1(nApOut, pReverb->m_sAp1.m_nApGain);
+ nTemp1 = SATURATE(nApIn + nTemp1);
+
+ // inject into allpass delay
+ nAddr
+ = CIRCULAR(nBase, pReverb->m_sAp1.m_zApIn, pReverb->m_nBufferMask);
+ pReverb->m_nDelayLine[nAddr] = (short) nTemp1;
+
+ // inject allpass output into delay line
+ nAddr = CIRCULAR(nBase, pReverb->m_zD1In, pReverb->m_nBufferMask);
+ pReverb->m_nDelayLine[nAddr] = (short) nApOut;
+
+ // ********** Right Allpass - end
+
+ // ********** D0 output - start
+ // fetch delay line self out
+ nAddr = CIRCULAR(nBase, pReverb->m_zD0Self, pReverb->m_nBufferMask);
+ nDelayOut0 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate delay line self out
+ nTemp1 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nSin);
+
+ // fetch delay line cross out
+ nAddr = CIRCULAR(nBase, pReverb->m_zD1Cross, pReverb->m_nBufferMask);
+ nDelayOut0 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate delay line self out
+ nTemp2 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nCos);
+
+ // calculate unfiltered delay out
+ nDelayOut0 = SATURATE(nTemp1 + nTemp2);
+
+ // ********** D0 output - end
+
+ // ********** D1 output - start
+ // fetch delay line self out
+ nAddr = CIRCULAR(nBase, pReverb->m_zD1Self, pReverb->m_nBufferMask);
+ nDelayOut1 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate delay line self out
+ nTemp1 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nSin);
+
+ // fetch delay line cross out
+ nAddr = CIRCULAR(nBase, pReverb->m_zD0Cross, pReverb->m_nBufferMask);
+ nDelayOut1 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate delay line self out
+ nTemp2 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nCos);
+
+ // calculate unfiltered delay out
+ nDelayOut1 = SATURATE(nTemp1 + nTemp2);
+
+ // ********** D1 output - end
+
+ // ********** mixer and feedback - start
+ // sum is fedback to right input (R + L)
+ nDelayOut0 = (short) SATURATE(nDelayOut0 + nDelayOut1);
+
+ // difference is feedback to left input (R - L)
+ /*lint -e{685} lint complains that it can't saturate negative */
+ nDelayOut1 = (short) SATURATE(nDelayOut1 - nDelayOut0);
+
+ // ********** mixer and feedback - end
+
+ // calculate lowpass filter (mixer scale factor included in LPF feedforward)
+ nTemp1 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nRvbLpfFwd);
+
+ nTemp2 = MULT_EG1_EG1(pReverb->m_nRevFbkL, pReverb->m_nRvbLpfFbk);
+
+ // calculate filtered delay out and simultaneously update LPF state variable
+ // filtered delay output is stored in m_nRevFbkL
+ pReverb->m_nRevFbkL = (short) SATURATE(nTemp1 + nTemp2);
+
+ // calculate lowpass filter (mixer scale factor included in LPF feedforward)
+ nTemp1 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nRvbLpfFwd);
+
+ nTemp2 = MULT_EG1_EG1(pReverb->m_nRevFbkR, pReverb->m_nRvbLpfFbk);
+
+ // calculate filtered delay out and simultaneously update LPF state variable
+ // filtered delay output is stored in m_nRevFbkR
+ pReverb->m_nRevFbkR = (short) SATURATE(nTemp1 + nTemp2);
+
+ // ********** start early reflection generator, left
+ //psEarly = &(pReverb->m_sEarlyL);
+
+
+ for (j = 0; j < REVERB_MAX_NUM_REFLECTIONS; j++) {
+ // fetch delay line out
+ //nAddr = CIRCULAR(nBase, psEarly->m_zDelay[j], pReverb->m_nBufferMask);
+ nAddr
+ = CIRCULAR(nBase, pReverb->m_sEarlyL.m_zDelay[j], pReverb->m_nBufferMask);
+
+ nTemp1 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate reflection
+ //nTemp1 = MULT_EG1_EG1(nDelayOut0, psEarly->m_nGain[j]);
+ nTemp1 = MULT_EG1_EG1(nTemp1, pReverb->m_sEarlyL.m_nGain[j]);
+
+ nDelayOut0 = SATURATE(nDelayOut0 + nTemp1);
+
+ } // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
+
+ // apply lowpass to early reflections and reverb output
+ //nTemp1 = MULT_EG1_EG1(nEarlyOut, psEarly->m_nRvbLpfFwd);
+ nTemp1 = MULT_EG1_EG1(nDelayOut0, pReverb->m_nRoomLpfFwd);
+
+ //nTemp2 = MULT_EG1_EG1(psEarly->m_zLpf, psEarly->m_nLpfFbk);
+ nTemp2 = MULT_EG1_EG1(pReverb->m_zOutLpfL, pReverb->m_nRoomLpfFbk);
+
+ // calculate filtered out and simultaneously update LPF state variable
+ // filtered output is stored in m_zOutLpfL
+ pReverb->m_zOutLpfL = (short) SATURATE(nTemp1 + nTemp2);
+
+ //sum with output buffer
+ tempValue = *pOutputBuffer;
+ *pOutputBuffer++ = (short) SATURATE(tempValue+pReverb->m_zOutLpfL);
+
+ // ********** end early reflection generator, left
+
+ // ********** start early reflection generator, right
+ //psEarly = &(pReverb->m_sEarlyR);
+
+ for (j = 0; j < REVERB_MAX_NUM_REFLECTIONS; j++) {
+ // fetch delay line out
+ nAddr
+ = CIRCULAR(nBase, pReverb->m_sEarlyR.m_zDelay[j], pReverb->m_nBufferMask);
+ nTemp1 = pReverb->m_nDelayLine[nAddr];
+
+ // calculate reflection
+ nTemp1 = MULT_EG1_EG1(nTemp1, pReverb->m_sEarlyR.m_nGain[j]);
+
+ nDelayOut1 = SATURATE(nDelayOut1 + nTemp1);
+
+ } // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
+
+ // apply lowpass to early reflections
+ nTemp1 = MULT_EG1_EG1(nDelayOut1, pReverb->m_nRoomLpfFwd);
+
+ nTemp2 = MULT_EG1_EG1(pReverb->m_zOutLpfR, pReverb->m_nRoomLpfFbk);
+
+ // calculate filtered out and simultaneously update LPF state variable
+ // filtered output is stored in m_zOutLpfR
+ pReverb->m_zOutLpfR = (short) SATURATE(nTemp1 + nTemp2);
+
+ //sum with output buffer
+ tempValue = *pOutputBuffer;
+ *pOutputBuffer++ = (short) SATURATE(tempValue + pReverb->m_zOutLpfR);
+
+ // ********** end early reflection generator, right
+
+ // decrement base addr for next sample period
+ nBase--;
+
+ pReverb->m_nSin += pReverb->m_nSinIncrement;
+ pReverb->m_nCos += pReverb->m_nCosIncrement;
+
+ } // end for (i=0; i < nNumSamplesToAdd; i++)
+
+ // store the most up to date version
+ pReverb->m_nBaseIndex = nBase;
+
+ return 0;
+} /* end Reverb */
+
+/*----------------------------------------------------------------------------
+ * ReverbUpdateRoom
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Update the room's preset parameters as required
+ *
+ * Inputs:
+ *
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ * - reverb paramters (fbk, fwd, etc) will be changed
+ * - m_nCurrentRoom := m_nNextRoom
+ *----------------------------------------------------------------------------
+ */
+static int ReverbUpdateRoom(reverb_object_t *pReverb, bool fullUpdate) {
+ int temp;
+ int i;
+ int maxSamples;
+ int earlyDelay;
+ int earlyGain;
+
+ reverb_preset_t *pPreset =
+ &pReverb->m_sPreset.m_sPreset[pReverb->m_nNextRoom];
+
+ if (fullUpdate) {
+ pReverb->m_nRvbLpfFwd = pPreset->m_nRvbLpfFwd;
+ pReverb->m_nRvbLpfFbk = pPreset->m_nRvbLpfFbk;
+
+ pReverb->m_nEarlyGain = pPreset->m_nEarlyGain;
+ //stored as time based, convert to sample based
+ pReverb->m_nLateGain = pPreset->m_nLateGain;
+ pReverb->m_nRoomLpfFbk = pPreset->m_nRoomLpfFbk;
+ pReverb->m_nRoomLpfFwd = pPreset->m_nRoomLpfFwd;
+
+ // set the early reflections gains
+ earlyGain = pPreset->m_nEarlyGain;
+ for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) {
+ pReverb->m_sEarlyL.m_nGain[i]
+ = MULT_EG1_EG1(pPreset->m_sEarlyL.m_nGain[i],earlyGain);
+ pReverb->m_sEarlyR.m_nGain[i]
+ = MULT_EG1_EG1(pPreset->m_sEarlyR.m_nGain[i],earlyGain);
+ }
+
+ pReverb->m_nMaxExcursion = pPreset->m_nMaxExcursion;
+
+ pReverb->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain;
+ pReverb->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain;
+
+ // set the early reflections delay
+ earlyDelay = ((int) pPreset->m_nEarlyDelay * pReverb->m_nSamplingRate)
+ >> 16;
+ pReverb->m_nEarlyDelay = earlyDelay;
+ maxSamples = (int32_t) (MAX_EARLY_TIME * pReverb->m_nSamplingRate)
+ >> 16;
+ for (i = 0; i < REVERB_MAX_NUM_REFLECTIONS; i++) {
+ //stored as time based, convert to sample based
+ temp = earlyDelay + (((int) pPreset->m_sEarlyL.m_zDelay[i]
+ * pReverb->m_nSamplingRate) >> 16);
+ if (temp > maxSamples)
+ temp = maxSamples;
+ pReverb->m_sEarlyL.m_zDelay[i] = pReverb->m_nEarly0in + temp;
+ //stored as time based, convert to sample based
+ temp = earlyDelay + (((int) pPreset->m_sEarlyR.m_zDelay[i]
+ * pReverb->m_nSamplingRate) >> 16);
+ if (temp > maxSamples)
+ temp = maxSamples;
+ pReverb->m_sEarlyR.m_zDelay[i] = pReverb->m_nEarly1in + temp;
+ }
+
+ maxSamples = (int32_t) (MAX_DELAY_TIME * pReverb->m_nSamplingRate)
+ >> 16;
+ //stored as time based, convert to sample based
+ /*lint -e{702} shift for performance */
+ temp = (pPreset->m_nLateDelay * pReverb->m_nSamplingRate) >> 16;
+ if ((temp + pReverb->m_nMaxExcursion) > maxSamples) {
+ temp = maxSamples - pReverb->m_nMaxExcursion;
+ }
+ temp -= pReverb->m_nLateDelay;
+ pReverb->m_nDelay0Out += temp;
+ pReverb->m_nDelay1Out += temp;
+ pReverb->m_nLateDelay += temp;
+
+ maxSamples = (int32_t) (MAX_AP_TIME * pReverb->m_nSamplingRate) >> 16;
+ //stored as time based, convert to absolute sample value
+ temp = pPreset->m_nAp0_ApOut;
+ /*lint -e{702} shift for performance */
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ if (temp > maxSamples)
+ temp = maxSamples;
+ pReverb->m_sAp0.m_zApOut = (uint16_t) (pReverb->m_sAp0.m_zApIn + temp);
+
+ //stored as time based, convert to absolute sample value
+ temp = pPreset->m_nAp1_ApOut;
+ /*lint -e{702} shift for performance */
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ if (temp > maxSamples)
+ temp = maxSamples;
+ pReverb->m_sAp1.m_zApOut = (uint16_t) (pReverb->m_sAp1.m_zApIn + temp);
+ //gpsReverbObject->m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut;
+ }
+
+ //stored as time based, convert to sample based
+ temp = pPreset->m_nXfadeInterval;
+ /*lint -e{702} shift for performance */
+ temp = (temp * pReverb->m_nSamplingRate) >> 16;
+ pReverb->m_nXfadeInterval = (uint16_t) temp;
+ //gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval;
+ pReverb->m_nXfadeCounter = pReverb->m_nXfadeInterval + 1; // force update on first iteration
+
+
+ pReverb->m_nCurrentRoom = pReverb->m_nNextRoom;
+
+ return 0;
+
+} /* end ReverbUpdateRoom */
+
+/*----------------------------------------------------------------------------
+ * ReverbReadInPresets()
+ *----------------------------------------------------------------------------
+ * Purpose: sets global reverb preset bank to defaults
+ *
+ * Inputs:
+ *
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+ */
+static int ReverbReadInPresets(reverb_object_t *pReverb) {
+
+ int preset = 0;
+ int defaultPreset = 0;
+
+ //now init any remaining presets to defaults
+ for (defaultPreset = preset; defaultPreset < REVERB_MAX_ROOM_TYPE; defaultPreset++) {
+ reverb_preset_t *pPreset = &pReverb->m_sPreset.m_sPreset[defaultPreset];
+ if (defaultPreset == 0 || defaultPreset > REVERB_MAX_ROOM_TYPE - 1) {
+ pPreset->m_nRvbLpfFbk = 8307;
+ pPreset->m_nRvbLpfFwd = 14768;
+ pPreset->m_nEarlyGain = 27690;
+ pPreset->m_nEarlyDelay = 1311;
+ pPreset->m_nLateGain = 8191;
+ pPreset->m_nLateDelay = 3932;
+ pPreset->m_nRoomLpfFbk = 3692;
+ pPreset->m_nRoomLpfFwd = 24569;
+ pPreset->m_sEarlyL.m_zDelay[0] = 1376;
+ pPreset->m_sEarlyL.m_nGain[0] = 22152;
+ pPreset->m_sEarlyL.m_zDelay[1] = 2163;
+ pPreset->m_sEarlyL.m_nGain[1] = 17537;
+ pPreset->m_sEarlyL.m_zDelay[2] = 0;
+ pPreset->m_sEarlyL.m_nGain[2] = 14768;
+ pPreset->m_sEarlyL.m_zDelay[3] = 1835;
+ pPreset->m_sEarlyL.m_nGain[3] = 14307;
+ pPreset->m_sEarlyL.m_zDelay[4] = 0;
+ pPreset->m_sEarlyL.m_nGain[4] = 13384;
+ pPreset->m_sEarlyR.m_zDelay[0] = 721;
+ pPreset->m_sEarlyR.m_nGain[0] = 20306;
+ pPreset->m_sEarlyR.m_zDelay[1] = 2621;
+ pPreset->m_sEarlyR.m_nGain[1] = 17537;
+ pPreset->m_sEarlyR.m_zDelay[2] = 0;
+ pPreset->m_sEarlyR.m_nGain[2] = 14768;
+ pPreset->m_sEarlyR.m_zDelay[3] = 0;
+ pPreset->m_sEarlyR.m_nGain[3] = 16153;
+ pPreset->m_sEarlyR.m_zDelay[4] = 0;
+ pPreset->m_sEarlyR.m_nGain[4] = 13384;
+ pPreset->m_nMaxExcursion = 127;
+ pPreset->m_nXfadeInterval = 6388;
+ pPreset->m_nAp0_ApGain = 15691;
+ pPreset->m_nAp0_ApOut = 711;
+ pPreset->m_nAp1_ApGain = 16317;
+ pPreset->m_nAp1_ApOut = 1029;
+ pPreset->m_rfu4 = 0;
+ pPreset->m_rfu5 = 0;
+ pPreset->m_rfu6 = 0;
+ pPreset->m_rfu7 = 0;
+ pPreset->m_rfu8 = 0;
+ pPreset->m_rfu9 = 0;
+ pPreset->m_rfu10 = 0;
+ } else if (defaultPreset == 1) {
+ pPreset->m_nRvbLpfFbk = 6461;
+ pPreset->m_nRvbLpfFwd = 14307;
+ pPreset->m_nEarlyGain = 27690;
+ pPreset->m_nEarlyDelay = 1311;
+ pPreset->m_nLateGain = 8191;
+ pPreset->m_nLateDelay = 3932;
+ pPreset->m_nRoomLpfFbk = 3692;
+ pPreset->m_nRoomLpfFwd = 24569;
+ pPreset->m_sEarlyL.m_zDelay[0] = 1376;
+ pPreset->m_sEarlyL.m_nGain[0] = 22152;
+ pPreset->m_sEarlyL.m_zDelay[1] = 1462;
+ pPreset->m_sEarlyL.m_nGain[1] = 17537;
+ pPreset->m_sEarlyL.m_zDelay[2] = 0;
+ pPreset->m_sEarlyL.m_nGain[2] = 14768;
+ pPreset->m_sEarlyL.m_zDelay[3] = 1835;
+ pPreset->m_sEarlyL.m_nGain[3] = 14307;
+ pPreset->m_sEarlyL.m_zDelay[4] = 0;
+ pPreset->m_sEarlyL.m_nGain[4] = 13384;
+ pPreset->m_sEarlyR.m_zDelay[0] = 721;
+ pPreset->m_sEarlyR.m_nGain[0] = 20306;
+ pPreset->m_sEarlyR.m_zDelay[1] = 2621;
+ pPreset->m_sEarlyR.m_nGain[1] = 17537;
+ pPreset->m_sEarlyR.m_zDelay[2] = 0;
+ pPreset->m_sEarlyR.m_nGain[2] = 14768;
+ pPreset->m_sEarlyR.m_zDelay[3] = 0;
+ pPreset->m_sEarlyR.m_nGain[3] = 16153;
+ pPreset->m_sEarlyR.m_zDelay[4] = 0;
+ pPreset->m_sEarlyR.m_nGain[4] = 13384;
+ pPreset->m_nMaxExcursion = 127;
+ pPreset->m_nXfadeInterval = 6391;
+ pPreset->m_nAp0_ApGain = 15230;
+ pPreset->m_nAp0_ApOut = 708;
+ pPreset->m_nAp1_ApGain = 15547;
+ pPreset->m_nAp1_ApOut = 1023;
+ pPreset->m_rfu4 = 0;
+ pPreset->m_rfu5 = 0;
+ pPreset->m_rfu6 = 0;
+ pPreset->m_rfu7 = 0;
+ pPreset->m_rfu8 = 0;
+ pPreset->m_rfu9 = 0;
+ pPreset->m_rfu10 = 0;
+ } else if (defaultPreset == 2) {
+ pPreset->m_nRvbLpfFbk = 5077;
+ pPreset->m_nRvbLpfFwd = 12922;
+ pPreset->m_nEarlyGain = 27690;
+ pPreset->m_nEarlyDelay = 1311;
+ pPreset->m_nLateGain = 8191;
+ pPreset->m_nLateDelay = 3932;
+ pPreset->m_nRoomLpfFbk = 3692;
+ pPreset->m_nRoomLpfFwd = 21703;
+ pPreset->m_sEarlyL.m_zDelay[0] = 1376;
+ pPreset->m_sEarlyL.m_nGain[0] = 22152;
+ pPreset->m_sEarlyL.m_zDelay[1] = 1462;
+ pPreset->m_sEarlyL.m_nGain[1] = 17537;
+ pPreset->m_sEarlyL.m_zDelay[2] = 0;
+ pPreset->m_sEarlyL.m_nGain[2] = 14768;
+ pPreset->m_sEarlyL.m_zDelay[3] = 1835;
+ pPreset->m_sEarlyL.m_nGain[3] = 14307;
+ pPreset->m_sEarlyL.m_zDelay[4] = 0;
+ pPreset->m_sEarlyL.m_nGain[4] = 13384;
+ pPreset->m_sEarlyR.m_zDelay[0] = 721;
+ pPreset->m_sEarlyR.m_nGain[0] = 20306;
+ pPreset->m_sEarlyR.m_zDelay[1] = 2621;
+ pPreset->m_sEarlyR.m_nGain[1] = 17537;
+ pPreset->m_sEarlyR.m_zDelay[2] = 0;
+ pPreset->m_sEarlyR.m_nGain[2] = 14768;
+ pPreset->m_sEarlyR.m_zDelay[3] = 0;
+ pPreset->m_sEarlyR.m_nGain[3] = 16153;
+ pPreset->m_sEarlyR.m_zDelay[4] = 0;
+ pPreset->m_sEarlyR.m_nGain[4] = 13384;
+ pPreset->m_nMaxExcursion = 127;
+ pPreset->m_nXfadeInterval = 6449;
+ pPreset->m_nAp0_ApGain = 15691;
+ pPreset->m_nAp0_ApOut = 774;
+ pPreset->m_nAp1_ApGain = 16317;
+ pPreset->m_nAp1_ApOut = 1155;
+ pPreset->m_rfu4 = 0;
+ pPreset->m_rfu5 = 0;
+ pPreset->m_rfu6 = 0;
+ pPreset->m_rfu7 = 0;
+ pPreset->m_rfu8 = 0;
+ pPreset->m_rfu9 = 0;
+ pPreset->m_rfu10 = 0;
+ } else if (defaultPreset == 3) {
+ pPreset->m_nRvbLpfFbk = 5077;
+ pPreset->m_nRvbLpfFwd = 11076;
+ pPreset->m_nEarlyGain = 27690;
+ pPreset->m_nEarlyDelay = 1311;
+ pPreset->m_nLateGain = 8191;
+ pPreset->m_nLateDelay = 3932;
+ pPreset->m_nRoomLpfFbk = 3692;
+ pPreset->m_nRoomLpfFwd = 20474;
+ pPreset->m_sEarlyL.m_zDelay[0] = 1376;
+ pPreset->m_sEarlyL.m_nGain[0] = 22152;
+ pPreset->m_sEarlyL.m_zDelay[1] = 1462;
+ pPreset->m_sEarlyL.m_nGain[1] = 17537;
+ pPreset->m_sEarlyL.m_zDelay[2] = 0;
+ pPreset->m_sEarlyL.m_nGain[2] = 14768;
+ pPreset->m_sEarlyL.m_zDelay[3] = 1835;
+ pPreset->m_sEarlyL.m_nGain[3] = 14307;
+ pPreset->m_sEarlyL.m_zDelay[4] = 0;
+ pPreset->m_sEarlyL.m_nGain[4] = 13384;
+ pPreset->m_sEarlyR.m_zDelay[0] = 721;
+ pPreset->m_sEarlyR.m_nGain[0] = 20306;
+ pPreset->m_sEarlyR.m_zDelay[1] = 2621;
+ pPreset->m_sEarlyR.m_nGain[1] = 17537;
+ pPreset->m_sEarlyR.m_zDelay[2] = 0;
+ pPreset->m_sEarlyR.m_nGain[2] = 14768;
+ pPreset->m_sEarlyR.m_zDelay[3] = 0;
+ pPreset->m_sEarlyR.m_nGain[3] = 16153;
+ pPreset->m_sEarlyR.m_zDelay[4] = 0;
+ pPreset->m_sEarlyR.m_nGain[4] = 13384;
+ pPreset->m_nMaxExcursion = 127;
+ pPreset->m_nXfadeInterval = 6470; //6483;
+ pPreset->m_nAp0_ApGain = 14768;
+ pPreset->m_nAp0_ApOut = 792;
+ pPreset->m_nAp1_ApGain = 14777;
+ pPreset->m_nAp1_ApOut = 1191;
+ pPreset->m_rfu4 = 0;
+ pPreset->m_rfu5 = 0;
+ pPreset->m_rfu6 = 0;
+ pPreset->m_rfu7 = 0;
+ pPreset->m_rfu8 = 0;
+ pPreset->m_rfu9 = 0;
+ pPreset->m_rfu10 = 0;
+ }
+ }
+
+ return 0;
+}
diff --git a/media/libeffects/EffectReverb.h b/media/libeffects/EffectReverb.h
new file mode 100644
index 0000000..cd14891
--- /dev/null
+++ b/media/libeffects/EffectReverb.h
@@ -0,0 +1,429 @@
+/*
+ * Copyright (C) 2008 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_EFFECTREVERB_H_
+#define ANDROID_EFFECTREVERB_H_
+
+#include <media/EffectReverbApi.h>
+
+
+/*------------------------------------
+ * defines
+ *------------------------------------
+*/
+
+/*
+CIRCULAR() calculates the array index using modulo arithmetic.
+The "trick" is that modulo arithmetic is simplified by masking
+the effective address where the mask is (2^n)-1. This only works
+if the buffer size is a power of two.
+*/
+#define CIRCULAR(base,offset,size) (uint32_t)( \
+ ( \
+ ((int32_t)(base)) + ((int32_t)(offset)) \
+ ) \
+ & size \
+ )
+
+#define NUM_OUTPUT_CHANNELS 2
+#define OUTPUT_CHANNELS CHANNEL_STEREO
+
+#define REVERB_BUFFER_SIZE_IN_SAMPLES_MAX 16384
+
+#define REVERB_MAX_ROOM_TYPE 4 // any room numbers larger than this are invalid
+#define REVERB_MAX_NUM_REFLECTIONS 5 // max num reflections per channel
+
+
+// xfade parameters
+#define REVERB_XFADE_PERIOD_IN_SECONDS (double) (100.0 / 1000.0) // xfade once every this many seconds
+
+
+/**********/
+/* the entire synth uses various flags in a bit field */
+
+/* if flag is set, synth reset has been requested */
+#define REVERB_FLAG_RESET_IS_REQUESTED 0x01 /* bit 0 */
+#define MASK_REVERB_RESET_IS_REQUESTED 0x01
+#define MASK_REVERB_RESET_IS_NOT_REQUESTED (uint32_t)(~MASK_REVERB_RESET_IS_REQUESTED)
+
+/*
+by default, we always want to update ALL channel parameters
+when we reset the synth (e.g., during GM ON)
+*/
+#define DEFAULT_REVERB_FLAGS 0x0
+
+/* coefficients for generating sin, cos */
+#define REVERB_PAN_G2 4294940151 /* -0.82842712474619 = 2 - 4/sqrt(2) */
+/*
+int32_t nPanG1 = +1.0 for sin
+int32_t nPanG1 = -1.0 for cos
+*/
+#define REVERB_PAN_G0 23170 /* 0.707106781186547 = 1/sqrt(2) */
+
+/*************************************************************/
+// define the input injection points
+#define GUARD 5 // safety guard of this many samples
+
+#define MAX_AP_TIME (int) ((20*65536)/1000) // delay time in time units (65536th of sec)
+#define MAX_DELAY_TIME (int) ((65*65536)/1000) // delay time in time units
+#define MAX_EARLY_TIME (int) ((65*65536)/1000) // delay time in time units
+
+#define AP0_IN 0
+
+
+#define REVERB_DEFAULT_ROOM_NUMBER 1 // default preset number
+#define DEFAULT_AP0_GAIN 19400
+#define DEFAULT_AP1_GAIN -19400
+
+#define REVERB_DEFAULT_WET 32767
+#define REVERB_DEFAULT_DRY 0
+
+#define REVERB_WET_MAX 32767
+#define REVERB_WET_MIN 0
+#define REVERB_DRY_MAX 32767
+#define REVERB_DRY_MIN 0
+
+// constants for reverb density
+// The density expressed in permilles changes the Allpass delay in a linear manner in the range defined by
+// AP0_TIME_BASE to AP0_TIME_BASE + AP0_TIME_RANGE
+#define AP0_TIME_BASE (int)((9*65536)/1000)
+#define AP0_TIME_RANGE (int)((4*65536)/1000)
+#define AP1_TIME_BASE (int)((12*65536)/1000)
+#define AP1_TIME_RANGE (int)((8*65536)/1000)
+
+// constants for reverb diffusion
+// The diffusion expressed in permilles changes the Allpass gain in a linear manner in the range defined by
+// AP0_GAIN_BASE to AP0_GAIN_BASE + AP0_GAIN_RANGE
+#define AP0_GAIN_BASE (int)(9830)
+#define AP0_GAIN_RANGE (int)(19660-9830)
+#define AP1_GAIN_BASE (int)(6553)
+#define AP1_GAIN_RANGE (int)(22936-6553)
+
+
+/* parameters for each allpass */
+typedef struct
+{
+ uint16_t m_zApOut; // delay offset for ap out
+
+ int16_t m_nApGain; // gain for ap
+
+ uint16_t m_zApIn; // delay offset for ap in
+
+} allpass_object_t;
+
+
+/* parameters for early reflections */
+typedef struct
+{
+ uint16_t m_zDelay[REVERB_MAX_NUM_REFLECTIONS]; // delay offset for ap out
+
+ int16_t m_nGain[REVERB_MAX_NUM_REFLECTIONS]; // gain for ap
+
+} early_reflection_object_t;
+
+//demo
+typedef struct
+{
+ int16_t m_nRvbLpfFbk;
+ int16_t m_nRvbLpfFwd;
+ int16_t m_nRoomLpfFbk;
+ int16_t m_nRoomLpfFwd;
+
+ int16_t m_nEarlyGain;
+ int16_t m_nEarlyDelay;
+ int16_t m_nLateGain;
+ int16_t m_nLateDelay;
+
+ early_reflection_object_t m_sEarlyL;
+ early_reflection_object_t m_sEarlyR;
+
+ uint16_t m_nMaxExcursion; //28
+ int16_t m_nXfadeInterval;
+
+ int16_t m_nAp0_ApGain; //30
+ int16_t m_nAp0_ApOut;
+ int16_t m_nAp1_ApGain;
+ int16_t m_nAp1_ApOut;
+ int16_t m_nDiffusion;
+
+ int16_t m_rfu4;
+ int16_t m_rfu5;
+ int16_t m_rfu6;
+ int16_t m_rfu7;
+ int16_t m_rfu8;
+ int16_t m_rfu9;
+ int16_t m_rfu10; //43
+
+} reverb_preset_t;
+
+typedef struct
+{
+ reverb_preset_t m_sPreset[REVERB_MAX_ROOM_TYPE]; //array of presets
+
+} reverb_preset_bank_t;
+
+
+/* parameters for each reverb */
+typedef struct
+{
+ /* update counter keeps track of when synth params need updating */
+ /* only needs to be as large as REVERB_UPDATE_PERIOD_IN_SAMPLES */
+ int16_t m_nUpdateCounter;
+
+ uint16_t m_nBaseIndex; // base index for circular buffer
+
+ // reverb delay line offsets, allpass parameters, etc:
+
+ short m_nRevFbkR; // combine feedback reverb right out with dry left in
+ short m_zOutLpfL; // left reverb output
+
+ allpass_object_t m_sAp0; // allpass 0 (left channel)
+
+ uint16_t m_zD0In; // delay offset for delay line D0 in
+
+ short m_nRevFbkL; // combine feedback reverb left out with dry right in
+ short m_zOutLpfR; // right reverb output
+
+ allpass_object_t m_sAp1; // allpass 1 (right channel)
+
+ uint16_t m_zD1In; // delay offset for delay line D1 in
+
+ // delay output taps, notice criss cross order
+ uint16_t m_zD0Self; // self feeds forward d0 --> d0
+
+ uint16_t m_zD1Cross; // cross feeds across d1 --> d0
+
+ uint16_t m_zD1Self; // self feeds forward d1 --> d1
+
+ uint16_t m_zD0Cross; // cross feeds across d0 --> d1
+
+ int16_t m_nSin; // gain for self taps
+
+ int16_t m_nCos; // gain for cross taps
+
+ int16_t m_nSinIncrement; // increment for gain
+
+ int16_t m_nCosIncrement; // increment for gain
+
+ int16_t m_nRvbLpfFwd; // reverb feedback lpf forward gain (includes scaling for mixer)
+
+ int16_t m_nRvbLpfFbk; // reverb feedback lpf feedback gain
+
+ int16_t m_nRoomLpfFwd; // room lpf forward gain (includes scaling for mixer)
+
+ int16_t m_nRoomLpfFbk; // room lpf feedback gain
+
+ uint16_t m_nXfadeInterval; // update/xfade after this many samples
+
+ uint16_t m_nXfadeCounter; // keep track of when to xfade
+
+ int16_t m_nPhase; // -1 <= m_nPhase < 1
+ // but during sin,cos calculations
+ // use m_nPhase/2
+
+ int16_t m_nPhaseIncrement; // add this to m_nPhase each frame
+
+ int16_t m_nNoise; // random noise sample
+
+ uint16_t m_nMaxExcursion; // the taps can excurse +/- this amount
+
+ uint16_t m_bUseNoise; // if TRUE, use noise as input signal
+
+ uint16_t m_bBypass; // if TRUE, then bypass reverb and copy input to output
+
+ int16_t m_nCurrentRoom; // preset number for current room
+
+ int16_t m_nNextRoom; // preset number for next room
+
+ int16_t m_nEarlyGain; // gain for early (widen) signal
+ int16_t m_nEarlyDelay; // initial dealy for early (widen) signal
+ int16_t m_nEarly0in;
+ int16_t m_nEarly1in;
+ int16_t m_nLateGain; // gain for late reverb
+ int16_t m_nLateDelay;
+
+ int16_t m_nDiffusion;
+
+ early_reflection_object_t m_sEarlyL; // left channel early reflections
+ early_reflection_object_t m_sEarlyR; // right channel early reflections
+
+ short m_nDelayLine[REVERB_BUFFER_SIZE_IN_SAMPLES_MAX]; // one large delay line for all reverb elements
+
+ reverb_preset_t pPreset;
+
+ reverb_preset_bank_t m_sPreset;
+
+ //int8_t preset;
+ uint32_t m_nSamplingRate;
+ int32_t m_nUpdatePeriodInBits;
+ int32_t m_nBufferMask;
+ int32_t m_nUpdatePeriodInSamples;
+ int32_t m_nDelay0Out;
+ int32_t m_nDelay1Out;
+ int16_t m_nCosWT_5KHz;
+
+ uint16_t m_Aux; // if TRUE, is connected as auxiliary effect
+ uint16_t m_Preset; // if TRUE, expose preset revert interface
+
+} reverb_object_t;
+
+
+
+typedef struct reverb_module_s {
+ const struct effect_interface_s *itfe;
+ effect_config_t config;
+ reverb_object_t context;
+} reverb_module_t;
+
+/*------------------------------------
+ * Effect API
+ *------------------------------------
+*/
+int EffectQueryNumberEffects(int *pNumEffects);
+int EffectQueryNext(effect_descriptor_t *pDescriptor);
+int EffectCreate(effect_uuid_t *effectUID, effect_interface_t *pInterface);
+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_Command(effect_interface_t self, int cmdCode, int cmdSize, void *pCmdData, int *replySize, void *pReplyData);
+
+
+/*------------------------------------
+ * internal functions
+ *------------------------------------
+*/
+
+int Reverb_Init(reverb_module_t *pRvbModule, int aux, int preset);
+int Reverb_Configure(reverb_module_t *pRvbModule, effect_config_t *pConfig, bool init);
+void Reverb_Reset(reverb_object_t *pReverb, bool init);
+
+int Reverb_setParameter (reverb_object_t *pReverb, int32_t param, size_t size, void *pValue);
+int Reverb_getParameter(reverb_object_t *pReverb, int32_t param, size_t *pSize, void *pValue);
+
+/*----------------------------------------------------------------------------
+ * ReverbUpdateXfade
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Update the xfade parameters as required
+ *
+ * Inputs:
+ * nNumSamplesToAdd - number of samples to write to buffer
+ *
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ * - xfade parameters will be changed
+ *
+ *----------------------------------------------------------------------------
+*/
+static int ReverbUpdateXfade(reverb_object_t* pReverbData, int nNumSamplesToAdd);
+
+/*----------------------------------------------------------------------------
+ * ReverbCalculateNoise
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Calculate a noise sample and limit its value
+ *
+ * Inputs:
+ * Pointer to reverb context
+ *
+ * Outputs:
+ * new limited noise value
+ *
+ * Side Effects:
+ * - pReverbData->m_nNoise value is updated
+ *
+ *----------------------------------------------------------------------------
+*/
+static uint16_t ReverbCalculateNoise(reverb_object_t *pReverbData);
+
+/*----------------------------------------------------------------------------
+ * ReverbCalculateSinCos
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Calculate a new sin and cosine value based on the given phase
+ *
+ * Inputs:
+ * nPhase - phase angle
+ * pnSin - input old value, output new value
+ * pnCos - input old value, output new value
+ *
+ * Outputs:
+ *
+ * Side Effects:
+ * - *pnSin, *pnCos are updated
+ *
+ *----------------------------------------------------------------------------
+*/
+static int ReverbCalculateSinCos(int16_t nPhase, int16_t *pnSin, int16_t *pnCos);
+
+/*----------------------------------------------------------------------------
+ * Reverb
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * apply reverb to the given signal
+ *
+ * Inputs:
+ * nNu
+ * pnSin - input old value, output new value
+ * pnCos - input old value, output new value
+ *
+ * Outputs:
+ * number of samples actually reverberated
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+static int Reverb(reverb_object_t* pReverbData, int nNumSamplesToAdd, short *pOutputBuffer, short *pInputBuffer);
+
+/*----------------------------------------------------------------------------
+ * ReverbReadInPresets()
+ *----------------------------------------------------------------------------
+ * Purpose: sets global reverb preset bank to defaults
+ *
+ * Inputs:
+ *
+ * Outputs:
+ *
+ *----------------------------------------------------------------------------
+*/
+static int ReverbReadInPresets(reverb_object_t* pReverbData);
+
+
+/*----------------------------------------------------------------------------
+ * ReverbUpdateRoom
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Update the room's preset parameters as required
+ *
+ * Inputs:
+ *
+ * Outputs:
+ *
+ *
+ * Side Effects:
+ * - reverb paramters (fbk, fwd, etc) will be changed
+ * - m_nCurrentRoom := m_nNextRoom
+ *----------------------------------------------------------------------------
+*/
+static int ReverbUpdateRoom(reverb_object_t* pReverbData, bool fullUpdate);
+
+
+static int ReverbComputeConstants(reverb_object_t *pReverbData, uint32_t samplingRate);
+
+#endif /*ANDROID_EFFECTREVERB_H_*/
diff --git a/media/libeffects/EffectsFactory.c b/media/libeffects/EffectsFactory.c
new file mode 100644
index 0000000..07c4d80
--- /dev/null
+++ b/media/libeffects/EffectsFactory.c
@@ -0,0 +1,602 @@
+/*
+ * 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.
+ */
+
+#define LOG_TAG "EffectsFactory"
+//#define LOG_NDEBUG 0
+
+#include "EffectsFactory.h"
+#include <dlfcn.h>
+
+
+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 pthread_mutex_t gLibLock = PTHREAD_MUTEX_INITIALIZER; // controls access to gLibraryList
+static list_elem_t *gCurLib; // current library in enumeration process
+static list_elem_t *gCurEffect; // current effect in enumeration process
+
+static const char * const gEffectLibPath = "/system/lib/soundfx"; // path to built-in effect libraries
+static int gInitDone; // true is global initialization has been preformed
+
+/////////////////////////////////////////////////
+// Local functions prototypes
+/////////////////////////////////////////////////
+
+static int init();
+static int loadLibrary(const char *libPath, int *handle);
+static int unloadLibrary(int handle);
+static int numEffectModules();
+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);
+
+/////////////////////////////////////////////////
+// Effect Control Interface functions
+/////////////////////////////////////////////////
+
+int Effect_Process(effect_interface_t self, audio_buffer_t *inBuffer, audio_buffer_t *outBuffer)
+{
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+ effect_entry_t *fx = (effect_entry_t *)self;
+ pthread_mutex_lock(&gLibLock);
+ if (fx->lib == NULL) {
+ pthread_mutex_unlock(&gLibLock);
+ return -EPIPE;
+ }
+ pthread_mutex_lock(&fx->lib->lock);
+ pthread_mutex_unlock(&gLibLock);
+
+ ret = (*fx->subItfe)->process(fx->subItfe, inBuffer, outBuffer);
+ pthread_mutex_unlock(&fx->lib->lock);
+ return ret;
+}
+
+int Effect_Command(effect_interface_t self, int cmdCode, int cmdSize, void *pCmdData, int *replySize, void *pReplyData)
+{
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+ effect_entry_t *fx = (effect_entry_t *)self;
+ pthread_mutex_lock(&gLibLock);
+ if (fx->lib == NULL) {
+ pthread_mutex_unlock(&gLibLock);
+ return -EPIPE;
+ }
+ pthread_mutex_lock(&fx->lib->lock);
+ pthread_mutex_unlock(&gLibLock);
+
+ ret = (*fx->subItfe)->command(fx->subItfe, cmdCode, cmdSize, pCmdData, replySize, pReplyData);
+ pthread_mutex_unlock(&fx->lib->lock);
+ return ret;
+}
+
+const struct effect_interface_s gInterface = {
+ Effect_Process,
+ Effect_Command
+};
+
+/////////////////////////////////////////////////
+// Effect Factory Interface functions
+/////////////////////////////////////////////////
+
+int EffectQueryNumberEffects(int *pNumEffects)
+{
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+ if (pNumEffects == NULL) {
+ return -EINVAL;
+ }
+
+ pthread_mutex_lock(&gLibLock);
+ *pNumEffects = numEffectModules();
+ pthread_mutex_unlock(&gLibLock);
+ LOGV("EffectQueryNumberEffects(): %d", *pNumEffects);
+ return ret;
+}
+
+int EffectQueryNext(effect_descriptor_t *pDescriptor)
+{
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+ if (pDescriptor == NULL) {
+ return -EINVAL;
+ }
+
+ pthread_mutex_lock(&gLibLock);
+ ret = -ENOENT;
+ while (gCurLib) {
+ if (gCurEffect) {
+ memcpy(pDescriptor, gCurEffect->object, sizeof(effect_descriptor_t));
+ gCurEffect = gCurEffect->next;
+ ret = 0;
+ break;
+ } else {
+ gCurLib = gCurLib->next;
+ gCurEffect = ((lib_entry_t *)gCurLib->object)->effects;
+ }
+ }
+ char str[256];
+ dumpEffectDescriptor(pDescriptor, str, 256);
+ LOGV("EffectQueryNext() desc:%s", str);
+ pthread_mutex_unlock(&gLibLock);
+ return ret;
+}
+
+int EffectGetDescriptor(effect_uuid_t *uuid, effect_descriptor_t *pDescriptor)
+{
+ lib_entry_t *l = NULL;
+ effect_descriptor_t *d = NULL;
+
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+ if (pDescriptor == NULL || uuid == NULL) {
+ return -EINVAL;
+ }
+ pthread_mutex_lock(&gLibLock);
+ ret = findEffect(uuid, &l, &d);
+ if (ret == 0) {
+ memcpy(pDescriptor, d, sizeof(effect_descriptor_t));
+ }
+ pthread_mutex_unlock(&gLibLock);
+ return ret;
+}
+
+int EffectCreate(effect_uuid_t *uuid, effect_interface_t *pInterface)
+{
+ list_elem_t *e = gLibraryList;
+ lib_entry_t *l = NULL;
+ effect_descriptor_t *d = NULL;
+ effect_interface_t itfe;
+ effect_entry_t *fx;
+ int found = 0;
+ int ret;
+
+ if (uuid == NULL || pInterface == NULL) {
+ return -EINVAL;
+ }
+
+ LOGV("EffectCreate() UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
+ uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion,
+ uuid->clockSeq, uuid->node[0], uuid->node[1],uuid->node[2],
+ uuid->node[3],uuid->node[4],uuid->node[5]);
+
+ ret = init();
+
+ if (ret < 0) {
+ LOGW("EffectCreate() init error: %d", ret);
+ return ret;
+ }
+
+ pthread_mutex_lock(&gLibLock);
+
+ ret = findEffect(uuid, &l, &d);
+ if (ret < 0){
+ goto exit;
+ }
+
+ // create effect in library
+ ret = l->createFx(uuid, &itfe);
+ if (ret < 0) {
+ LOGW("EffectCreate() library %s: could not create fx %s", l->path, d->name);
+ goto exit;
+ }
+
+ // add entry to effect list
+ fx = (effect_entry_t *)malloc(sizeof(effect_entry_t));
+ fx->subItfe = itfe;
+ fx->itfe = (struct effect_interface_s *)&gInterface;
+ fx->lib = l;
+
+ e = (list_elem_t *)malloc(sizeof(list_elem_t));
+ e->object = fx;
+ e->next = gEffectList;
+ gEffectList = e;
+
+ *pInterface = (effect_interface_t)fx;
+
+ LOGV("EffectCreate() created entry %p with sub itfe %p in library %s", *pInterface, itfe, l->path);
+
+exit:
+ pthread_mutex_unlock(&gLibLock);
+ return ret;
+}
+
+int EffectRelease(effect_interface_t interface)
+{
+ effect_entry_t *fx;
+ list_elem_t *e1;
+ list_elem_t *e2;
+
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+
+ // remove effect from effect list
+ pthread_mutex_lock(&gLibLock);
+ e1 = gEffectList;
+ e2 = NULL;
+ while (e1) {
+ if (e1->object == interface) {
+ if (e2) {
+ e2->next = e1->next;
+ } else {
+ gEffectList = e1->next;
+ }
+ fx = (effect_entry_t *)e1->object;
+ free(e1);
+ break;
+ }
+ e2 = e1;
+ e1 = e1->next;
+ }
+ if (e1 == NULL) {
+ ret = -ENOENT;
+ goto exit;
+ }
+
+ // release effect in library
+ if (fx->lib == NULL) {
+ LOGW("EffectRelease() fx %p library already unloaded", interface);
+ } else {
+ pthread_mutex_lock(&fx->lib->lock);
+ fx->lib->releaseFx(fx->subItfe);
+ pthread_mutex_unlock(&fx->lib->lock);
+ }
+ free(fx);
+
+exit:
+ pthread_mutex_unlock(&gLibLock);
+ return ret;
+}
+
+int EffectLoadLibrary(const char *libPath, int *handle)
+{
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+ if (libPath == NULL || strnlen(libPath, PATH_MAX) >= PATH_MAX) {
+ return -EINVAL;
+ }
+ return loadLibrary(libPath, handle);
+}
+
+int EffectUnloadLibrary(int handle)
+{
+ int ret = init();
+ if (ret < 0) {
+ return ret;
+ }
+
+ return unloadLibrary(handle);
+}
+
+int EffectIsNullUuid(effect_uuid_t *uuid)
+{
+ if (memcmp(uuid, EFFECT_UUID_NULL, sizeof(effect_uuid_t))) {
+ return 0;
+ }
+ return 1;
+}
+
+/////////////////////////////////////////////////
+// Local functions
+/////////////////////////////////////////////////
+
+int init() {
+ struct dirent *ent;
+ DIR *dir = NULL;
+ char libpath[PATH_MAX];
+ int hdl;
+
+ if (gInitDone) {
+ return 0;
+ }
+
+ pthread_mutex_init(&gLibLock, NULL);
+
+ // load built-in libraries
+ dir = opendir(gEffectLibPath);
+ if (dir == NULL) {
+ return -ENODEV;
+ }
+ while ((ent = readdir(dir)) != NULL) {
+ LOGV("init() reading file %s", ent->d_name);
+ if ((strlen(ent->d_name) < 3) ||
+ strncmp(ent->d_name, "lib", 3) != 0 ||
+ strncmp(ent->d_name + strlen(ent->d_name) - 3, ".so", 3) != 0) {
+ continue;
+ }
+ strcpy(libpath, gEffectLibPath);
+ strcat(libpath, "/");
+ strcat(libpath, ent->d_name);
+ if (loadLibrary(libpath, &hdl) < 0) {
+ LOGW("init() failed to load library %s",libpath);
+ }
+ }
+ closedir(dir);
+
+ gInitDone = 1;
+ LOGV("init() done");
+ return 0;
+}
+
+
+int loadLibrary(const char *libPath, int *handle)
+{
+ void *hdl;
+ effect_QueryNumberEffects_t queryNumFx;
+ effect_QueryNextEffect_t queryFx;
+ effect_CreateEffect_t createFx;
+ effect_ReleaseEffect_t releaseFx;
+ int numFx;
+ int fx;
+ int ret;
+ list_elem_t *e, *descHead = NULL;
+ lib_entry_t *l;
+
+ if (handle == NULL) {
+ return -EINVAL;
+ }
+
+ *handle = 0;
+
+ hdl = dlopen(libPath, RTLD_NOW);
+ if (hdl == 0) {
+ LOGW("could open lib %s", libPath);
+ return -ENODEV;
+ }
+
+ // Check functions availability
+ queryNumFx = (effect_QueryNumberEffects_t)dlsym(hdl, "EffectQueryNumberEffects");
+ if (queryNumFx == NULL) {
+ LOGW("could not get EffectQueryNumberEffects from lib %s", libPath);
+ ret = -ENODEV;
+ goto error;
+ }
+ queryFx = (effect_QueryNextEffect_t)dlsym(hdl, "EffectQueryNext");
+ if (queryFx == NULL) {
+ LOGW("could not get EffectQueryNext from lib %s", libPath);
+ ret = -ENODEV;
+ goto error;
+ }
+ createFx = (effect_CreateEffect_t)dlsym(hdl, "EffectCreate");
+ if (createFx == NULL) {
+ LOGW("could not get EffectCreate from lib %s", libPath);
+ ret = -ENODEV;
+ goto error;
+ }
+ releaseFx = (effect_ReleaseEffect_t)dlsym(hdl, "EffectRelease");
+ if (releaseFx == NULL) {
+ LOGW("could not get EffectRelease from lib %s", libPath);
+ ret = -ENODEV;
+ goto error;
+ }
+
+ // load effect descriptors
+ ret = queryNumFx(&numFx);
+ if (ret) {
+ goto error;
+ }
+
+ for (fx = 0; fx < numFx; fx++) {
+ effect_descriptor_t *d = malloc(sizeof(effect_descriptor_t));
+ if (d == NULL) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ ret = queryFx(d);
+ if (ret == 0) {
+#if (LOG_NDEBUG==0)
+ char s[256];
+ dumpEffectDescriptor(d, s, 256);
+ LOGV("loadLibrary() read descriptor %p:%s",d, s);
+#endif
+ if (d->apiVersion != EFFECT_API_VERSION) {
+ LOGW("Bad API version %04x on lib %s", d->apiVersion, libPath);
+ free(d);
+ continue;
+ }
+ e = malloc(sizeof(list_elem_t));
+ if (e == NULL) {
+ free(d);
+ ret = -ENOMEM;
+ goto error;
+ }
+ e->object = d;
+ e->next = descHead;
+ descHead = e;
+ } else {
+ LOGW("Error querying effect # %d on lib %s", fx, libPath);
+ }
+ }
+ // add entry for library in gLibraryList
+ l = malloc(sizeof(lib_entry_t));
+ l->handle = hdl;
+ strncpy(l->path, libPath, PATH_MAX);
+ l->createFx = createFx;
+ l->releaseFx = releaseFx;
+ l->effects = descHead;
+ pthread_mutex_init(&l->lock, NULL);
+
+ e = malloc(sizeof(list_elem_t));
+ pthread_mutex_lock(&gLibLock);
+ e->next = gLibraryList;
+ e->object = l;
+ gLibraryList = e;
+ pthread_mutex_unlock(&gLibLock);
+ LOGV("loadLibrary() linked library %p", l);
+
+ *handle = (int)hdl;
+
+ return 0;
+
+error:
+ LOGW("loadLibrary() error: %d on lib: %s", ret, libPath);
+ while (descHead) {
+ free(descHead->object);
+ e = descHead->next;
+ free(descHead);
+ descHead = e;;
+ }
+ dlclose(hdl);
+ return ret;
+}
+
+int unloadLibrary(int handle)
+{
+ void *hdl;
+ int ret;
+ list_elem_t *el1, *el2;
+ lib_entry_t *l;
+ effect_entry_t *fx;
+
+ pthread_mutex_lock(&gLibLock);
+ el1 = gLibraryList;
+ el2 = NULL;
+ while (el1) {
+ l = (lib_entry_t *)el1->object;
+ if (handle == (int)l->handle) {
+ if (el2) {
+ el2->next = el1->next;
+ } else {
+ gLibraryList = el1->next;
+ }
+ free(el1);
+ break;
+ }
+ el2 = el1;
+ el1 = el1->next;
+ }
+ pthread_mutex_unlock(&gLibLock);
+ if (el1 == NULL) {
+ return -ENOENT;
+ }
+
+ // clear effect descriptor list
+ el1 = l->effects;
+ while (el1) {
+ free(el1->object);
+ el2 = el1->next;
+ free(el1);
+ el1 = el2;
+ }
+
+ // disable all effects from this library
+ pthread_mutex_lock(&l->lock);
+ el1 = gEffectList;
+ while (el1) {
+ fx = (effect_entry_t *)el1->object;
+ if (fx->lib == l) {
+ fx->lib = NULL;
+ }
+ el1 = el1->next;
+ }
+ pthread_mutex_unlock(&l->lock);
+
+ dlclose(l->handle);
+ free(l);
+ return 0;
+}
+
+
+
+int numEffectModules() {
+ list_elem_t *e = gLibraryList;
+ int cnt = 0;
+
+ // Reset pointers for EffectQueryNext()
+ gCurLib = e;
+ if (e) {
+ gCurEffect = ((lib_entry_t *)e->object)->effects;
+ }
+ while (e) {
+ lib_entry_t *l = (lib_entry_t *)e->object;
+ list_elem_t *efx = l->effects;
+ while (efx) {
+ cnt++;
+ efx = efx->next;
+ }
+ e = e->next;
+ }
+ return cnt;
+}
+
+int findEffect(effect_uuid_t *uuid, lib_entry_t **lib, effect_descriptor_t **desc)
+{
+ list_elem_t *e = gLibraryList;
+ lib_entry_t *l = NULL;
+ effect_descriptor_t *d = NULL;
+ int found = 0;
+ int ret = 0;
+
+ while (e && !found) {
+ l = (lib_entry_t *)e->object;
+ list_elem_t *efx = l->effects;
+ while (efx) {
+ d = (effect_descriptor_t *)efx->object;
+ if (memcmp(&d->uuid, uuid, sizeof(effect_uuid_t)) == 0) {
+ found = 1;
+ break;
+ }
+ efx = efx->next;
+ }
+ e = e->next;
+ }
+ if (!found) {
+ LOGV("findEffect() effect not found");
+ ret = -ENOENT;
+ } else {
+ LOGV("findEffect() found effect: %s in lib %s", d->name, l->path);
+ *lib = l;
+ *desc = d;
+ }
+
+ return ret;
+}
+
+void dumpEffectDescriptor(effect_descriptor_t *desc, char *str, size_t len) {
+ char s[256];
+
+ snprintf(str, len, "\nEffect Descriptor %p:\n", desc);
+ sprintf(s, "- UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
+ desc->uuid.timeLow, desc->uuid.timeMid, desc->uuid.timeHiAndVersion,
+ desc->uuid.clockSeq, desc->uuid.node[0], desc->uuid.node[1],desc->uuid.node[2],
+ desc->uuid.node[3],desc->uuid.node[4],desc->uuid.node[5]);
+ strncat(str, s, len);
+ sprintf(s, "- TYPE: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
+ desc->type.timeLow, desc->type.timeMid, desc->type.timeHiAndVersion,
+ desc->type.clockSeq, desc->type.node[0], desc->type.node[1],desc->type.node[2],
+ desc->type.node[3],desc->type.node[4],desc->type.node[5]);
+ strncat(str, s, len);
+ sprintf(s, "- apiVersion: %04X\n- flags: %08X\n",
+ desc->apiVersion, desc->flags);
+ strncat(str, s, len);
+ sprintf(s, "- name: %s\n", desc->name);
+ strncat(str, s, len);
+ sprintf(s, "- implementor: %s\n", desc->implementor);
+ strncat(str, s, len);
+}
+
diff --git a/media/libeffects/EffectsFactory.h b/media/libeffects/EffectsFactory.h
new file mode 100644
index 0000000..17ad3f0
--- /dev/null
+++ b/media/libeffects/EffectsFactory.h
@@ -0,0 +1,55 @@
+/*
+ * 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_EFFECTSFACTORY_H_
+#define ANDROID_EFFECTSFACTORY_H_
+
+#include <cutils/log.h>
+#include <pthread.h>
+#include <dirent.h>
+#include <media/EffectFactoryApi.h>
+
+
+#if __cplusplus
+extern "C" {
+#endif
+
+typedef struct list_elem_s {
+ void *object;
+ struct list_elem_s *next;
+} list_elem_t;
+
+typedef struct lib_entry_s {
+ char path[PATH_MAX];
+ void *handle;
+ effect_CreateEffect_t createFx;
+ effect_ReleaseEffect_t releaseFx;
+ list_elem_t *effects; //list of effect_descriptor_t
+ pthread_mutex_t lock;
+} lib_entry_t;
+
+typedef struct effect_entry_s {
+ struct effect_interface_s *itfe;
+ effect_interface_t subItfe;
+ lib_entry_t *lib;
+} effect_entry_t;
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+
+#endif /*ANDROID_EFFECTSFACTORY_H_*/
diff --git a/media/libeffects/EffectsMath.c b/media/libeffects/EffectsMath.c
new file mode 100644
index 0000000..41ec662
--- /dev/null
+++ b/media/libeffects/EffectsMath.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#define LOG_TAG "EFFECTSMATH"
+//#define LOG_NDEBUG 0
+#include <cutils/log.h>
+#include <assert.h>
+
+#include "EffectsMath.h"
+
+// gLogTab contains pre-calculated values of log2(1 + ai5*2^-1 + ai4*2^-2 + ai3*2^-3 + ai2*2^-4 + ai1*2^-5 + ai0*2^-6)
+// for integers in the range 0 to 63 (i = ai5*2^5 + ai4*2^4 + ai3*2^3 + ai2*2^2 + ai1*2^1 + ai0*2^0)
+// It is used for a better than piece wise approximation of lin to log2 conversion
+
+static const uint16_t gLogTab[] =
+{
+ 0, 733, 1455, 2166,
+ 2866, 3556, 4236, 4907,
+ 5568, 6220, 6863, 7498,
+ 8124, 8742, 9352, 9954,
+ 10549, 11136, 11716, 12289,
+ 12855, 13415, 13968, 14514,
+ 15055, 15589, 16117, 16639,
+ 17156, 17667, 18173, 18673,
+ 19168, 19658, 20143, 20623,
+ 21098, 21568, 22034, 22495,
+ 22952, 23404, 23852, 24296,
+ 24736, 25172, 25604, 26031,
+ 26455, 26876, 27292, 27705,
+ 28114, 28520, 28922, 29321,
+ 29717, 30109, 30498, 30884,
+ 31267, 31647, 32024, 32397,
+ 32768
+};
+
+int32_t Effects_log2(uint32_t x) {
+ int32_t exp = 31 - __builtin_clz(x);
+ uint32_t segStart = x >> (exp - 6);
+ uint32_t i = segStart & 0x3F;
+ int32_t log = (int32_t)gLogTab[i];
+ int32_t logEnd = (int32_t)gLogTab[i+1];
+ segStart <<= exp - 6;
+
+ return (exp << 15) + log + (((x - segStart) * (logEnd - log)) >> (exp - 6));
+}
+
+// gExpTab[i] = (2^(i>>6)) << 22
+static const uint32_t gExpTab[] = {
+ 4194304, 4239977, 4286147, 4332820,
+ 4380002, 4427697, 4475911, 4524651,
+ 4573921, 4623728, 4674077, 4724974,
+ 4776426, 4828438, 4881016, 4934167,
+ 4987896, 5042211, 5097117, 5152621,
+ 5208729, 5265449, 5322786, 5380747,
+ 5439339, 5498570, 5558445, 5618973,
+ 5680159, 5742012, 5804539, 5867746,
+ 5931642, 5996233, 6061528, 6127533,
+ 6194258, 6261709, 6329894, 6398822,
+ 6468501, 6538938, 6610143, 6682122,
+ 6754886, 6828442, 6902799, 6977965,
+ 7053950, 7130763, 7208412, 7286906,
+ 7366255, 7446469, 7527555, 7609525,
+ 7692387, 7776152, 7860829, 7946428,
+ 8032959, 8120432, 8208857, 8298246,
+ 8388608
+};
+
+
+uint32_t Effects_exp2(int32_t x) {
+ int32_t i = x >> 15;
+ assert(i < 32);
+ x &= (1 << 15) - 1;
+ int32_t j = x >> 9;
+ x &= (1 << 9) - 1;
+ uint32_t exp = gExpTab[j];
+ uint32_t expEnd = gExpTab[j+1];
+
+ return ((exp << 9) + (expEnd - exp) * x) >> (31 - i);
+}
+
+
+int16_t Effects_MillibelsToLinear16 (int32_t nGain)
+{
+ nGain = ((nGain + MB_TO_LIN_K1) << 15 ) / MB_TO_LIN_K2;
+ uint32_t exp2 = Effects_exp2(nGain);
+
+ if (exp2 > 32767) exp2 = 32767;
+
+ return (int16_t)exp2;
+}
+
+
+int16_t Effects_Linear16ToMillibels (int32_t nGain)
+{
+ return (int16_t)(((MB_TO_LIN_K2*Effects_log2(nGain))>>15)-MB_TO_LIN_K1);
+}
+
+
+int32_t Effects_Sqrt(int32_t in)
+{
+ int32_t tmp;
+ int32_t out = 0;
+ int32_t i;
+ int32_t j;
+
+
+ if (in == 0) return 0;
+
+ if (in >= 0x10000000)
+ {
+ out = 0x4000;
+ in -= 0x10000000;
+ }
+
+ j = 32 - __builtin_clz(in);
+
+ if (j & 1) j++;
+ j >>= 1;
+
+ for (i = j; i > 0; i--) {
+ tmp = (out << i) + (1 << ((i - 1)*2));
+ if (in >= tmp)
+ {
+ out += 1 << (i-1);
+ in -= tmp;
+ }
+ }
+
+ return out;
+}
+
diff --git a/media/libeffects/EffectsMath.h b/media/libeffects/EffectsMath.h
new file mode 100644
index 0000000..2a44399
--- /dev/null
+++ b/media/libeffects/EffectsMath.h
@@ -0,0 +1,424 @@
+/*
+ * Copyright (C) 2008 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_EFFECTSMATH_H_
+#define ANDROID_EFFECTSMATH_H_
+
+#include <stdint.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+/** coefs for pan, generates sin, cos */
+#define COEFF_PAN_G2 -27146 /* -0.82842712474619 = 2 - 4/sqrt(2) */
+#define COEFF_PAN_G0 23170 /* 0.707106781186547 = 1/sqrt(2) */
+
+/*
+coefficients for approximating
+2^x = gn2toX0 + gn2toX1*x + gn2toX2*x^2 + gn2toX3*x^3
+where x is a int.frac number representing number of octaves.
+Actually, we approximate only the 2^(frac) using the power series
+and implement the 2^(int) as a shift, so that
+2^x == 2^(int.frac) == 2^(int) * 2^(fract)
+ == (gn2toX0 + gn2toX1*x + gn2toX2*x^2 + gn2toX3*x^3) << (int)
+
+The gn2toX.. were generated using a best fit for a 3rd
+order polynomial, instead of taking the coefficients from
+a truncated Taylor (or Maclaurin?) series.
+*/
+
+#define GN2_TO_X0 32768 /* 1 */
+#define GN2_TO_X1 22833 /* 0.696807861328125 */
+#define GN2_TO_X2 7344 /* 0.22412109375 */
+#define GN2_TO_X3 2588 /* 0.0789794921875 */
+
+/*----------------------------------------------------------------------------
+ * Fixed Point Math
+ *----------------------------------------------------------------------------
+ * These macros are used for fixed point multiplies. If the processor
+ * supports fixed point multiplies, replace these macros with inline
+ * assembly code to improve performance.
+ *----------------------------------------------------------------------------
+*/
+
+/* Fixed point multiply 0.15 x 0.15 = 0.15 returned as 32-bits */
+#define FMUL_15x15(a,b) \
+ /*lint -e(704) <avoid multiply for performance>*/ \
+ (((int32_t)(a) * (int32_t)(b)) >> 15)
+
+/* Fixed point multiply 0.7 x 0.7 = 0.15 returned as 32-bits */
+#define FMUL_7x7(a,b) \
+ /*lint -e(704) <avoid multiply for performance>*/ \
+ (((int32_t)(a) * (int32_t)(b) ) << 1)
+
+/* Fixed point multiply 0.8 x 0.8 = 0.15 returned as 32-bits */
+#define FMUL_8x8(a,b) \
+ /*lint -e(704) <avoid multiply for performance>*/ \
+ (((int32_t)(a) * (int32_t)(b) ) >> 1)
+
+/* Fixed point multiply 0.8 x 1.15 = 0.15 returned as 32-bits */
+#define FMUL_8x15(a,b) \
+ /*lint -e(704) <avoid divide for performance>*/ \
+ (((int32_t)((a) << 7) * (int32_t)(b)) >> 15)
+
+/* macros for fractional phase accumulator */
+/*
+Note: changed the _U32 to _I32 on 03/14/02. This should not
+affect the phase calculations, and should allow us to reuse these
+macros for other audio sample related math.
+*/
+#define HARDWARE_BIT_WIDTH 32
+
+#define NUM_PHASE_INT_BITS 1
+#define NUM_PHASE_FRAC_BITS 15
+
+#define PHASE_FRAC_MASK (uint32_t) ((0x1L << NUM_PHASE_FRAC_BITS) -1)
+
+#define GET_PHASE_INT_PART(x) (uint32_t)((uint32_t)(x) >> NUM_PHASE_FRAC_BITS)
+#define GET_PHASE_FRAC_PART(x) (uint32_t)((uint32_t)(x) & PHASE_FRAC_MASK)
+
+#define DEFAULT_PHASE_FRAC 0
+#define DEFAULT_PHASE_INT 0
+
+/*
+Linear interpolation calculates:
+output = (1-frac) * sample[n] + (frac) * sample[n+1]
+
+where conceptually 0 <= frac < 1
+
+For a fixed point implementation, frac is actually an integer value
+with an implied binary point one position to the left. The value of
+one (unity) is given by PHASE_ONE
+one half and one quarter are useful for 4-point linear interp.
+*/
+#define PHASE_ONE (int32_t) (0x1L << NUM_PHASE_FRAC_BITS)
+
+/*
+ Multiply the signed audio sample by the unsigned fraction.
+- a is the signed audio sample
+- b is the unsigned fraction (cast to signed int as long as coef
+ uses (n-1) or less bits, where n == hardware bit width)
+*/
+#define MULT_AUDIO_COEF(audio,coef) /*lint -e704 <avoid divide for performance>*/ \
+ (int32_t)( \
+ ( \
+ ((int32_t)(audio)) * ((int32_t)(coef)) \
+ ) \
+ >> NUM_PHASE_FRAC_BITS \
+ ) \
+ /* lint +704 <restore checking>*/
+
+/* wet / dry calculation macros */
+#define NUM_WET_DRY_FRAC_BITS 7 // 15
+#define NUM_WET_DRY_INT_BITS 9 // 1
+
+/* define a 1.0 */
+#define WET_DRY_ONE (int32_t) ((0x1L << NUM_WET_DRY_FRAC_BITS))
+#define WET_DRY_MINUS_ONE (int32_t) (~WET_DRY_ONE)
+#define WET_DRY_FULL_SCALE (int32_t) (WET_DRY_ONE - 1)
+
+#define MULT_AUDIO_WET_DRY_COEF(audio,coef) /*lint -e(702) <avoid divide for performance>*/ \
+ (int32_t)( \
+ ( \
+ ((int32_t)(audio)) * ((int32_t)(coef)) \
+ ) \
+ >> NUM_WET_DRY_FRAC_BITS \
+ )
+
+/* Envelope 1 (EG1) calculation macros */
+#define NUM_EG1_INT_BITS 1
+#define NUM_EG1_FRAC_BITS 15
+
+/* the max positive gain used in the synth for EG1 */
+/* SYNTH_FULL_SCALE_EG1_GAIN must match the value in the dls2eas
+converter, otherwise, the values we read from the .eas file are bogus. */
+#define SYNTH_FULL_SCALE_EG1_GAIN (int32_t) ((0x1L << NUM_EG1_FRAC_BITS) -1)
+
+/* define a 1.0 */
+#define EG1_ONE (int32_t) ((0x1L << NUM_EG1_FRAC_BITS))
+#define EG1_MINUS_ONE (int32_t) (~SYNTH_FULL_SCALE_EG1_GAIN)
+
+#define EG1_HALF (int32_t) (EG1_ONE/2)
+#define EG1_MINUS_HALF (int32_t) (EG1_MINUS_ONE/2)
+
+/*
+We implement the EG1 using a linear gain value, which means that the
+attack segment is handled by incrementing (adding) the linear gain.
+However, EG1 treats the Decay, Sustain, and Release differently than
+the Attack portion. For Decay, Sustain, and Release, the gain is
+linear on dB scale, which is equivalent to exponential damping on
+a linear scale. Because we use a linear gain for EG1, we implement
+the Decay and Release as multiplication (instead of incrementing
+as we did for the attack segment).
+Therefore, we need the following macro to implement the multiplication
+(i.e., exponential damping) during the Decay and Release segments of
+the EG1
+*/
+#define MULT_EG1_EG1(gain,damping) /*lint -e(704) <avoid divide for performance>*/ \
+ (int32_t)( \
+ ( \
+ ((int32_t)(gain)) * ((int32_t)(damping)) \
+ ) \
+ >> NUM_EG1_FRAC_BITS \
+ )
+
+// Use the following macro specifically for the filter, when multiplying
+// the b1 coefficient. The 0 <= |b1| < 2, which therefore might overflow
+// in certain conditions because we store b1 as a 1.15 value.
+// Instead, we could store b1 as b1p (b1' == b1 "prime") where
+// b1p == b1/2, thus ensuring no potential overflow for b1p because
+// 0 <= |b1p| < 1
+// However, during the filter calculation, we must account for the fact
+// that we are using b1p instead of b1, and thereby multiply by
+// an extra factor of 2. Rather than multiply by an extra factor of 2,
+// we can instead shift the result right by one less, hence the
+// modified shift right value of (NUM_EG1_FRAC_BITS -1)
+#define MULT_EG1_EG1_X2(gain,damping) /*lint -e(702) <avoid divide for performance>*/ \
+ (int32_t)( \
+ ( \
+ ((int32_t)(gain)) * ((int32_t)(damping)) \
+ ) \
+ >> (NUM_EG1_FRAC_BITS -1) \
+ )
+
+#define SATURATE_EG1(x) /*lint -e{734} saturation operation */ \
+ ((int32_t)(x) > SYNTH_FULL_SCALE_EG1_GAIN) ? (SYNTH_FULL_SCALE_EG1_GAIN) : \
+ ((int32_t)(x) < EG1_MINUS_ONE) ? (EG1_MINUS_ONE) : (x);
+
+
+/* use "digital cents" == "dents" instead of cents */
+/* we coudl re-use the phase frac macros, but if we do,
+we must change the phase macros to cast to _I32 instead of _U32,
+because using a _U32 cast causes problems when shifting the exponent
+for the 2^x calculation, because right shift a negative values MUST
+be sign extended, or else the 2^x calculation is wrong */
+
+/* use "digital cents" == "dents" instead of cents */
+#define NUM_DENTS_FRAC_BITS 12
+#define NUM_DENTS_INT_BITS (HARDWARE_BIT_WIDTH - NUM_DENTS_FRAC_BITS)
+
+#define DENTS_FRAC_MASK (int32_t) ((0x1L << NUM_DENTS_FRAC_BITS) -1)
+
+#define GET_DENTS_INT_PART(x) /*lint -e(704) <avoid divide for performance>*/ \
+ (int32_t)((int32_t)(x) >> NUM_DENTS_FRAC_BITS)
+
+#define GET_DENTS_FRAC_PART(x) (int32_t)((int32_t)(x) & DENTS_FRAC_MASK)
+
+#define DENTS_ONE (int32_t) (0x1L << NUM_DENTS_FRAC_BITS)
+
+/* use CENTS_TO_DENTS to convert a value in cents to dents */
+#define CENTS_TO_DENTS (int32_t) (DENTS_ONE * (0x1L << NUM_EG1_FRAC_BITS) / 1200L) \
+
+
+/*
+For gain, the LFO generates a value that modulates in terms
+of dB. However, we use a linear gain value, so we must convert
+the LFO value in dB to a linear gain. Normally, we would use
+linear gain = 10^x, where x = LFO value in dB / 20.
+Instead, we implement 10^x using our 2^x approximation.
+because
+
+ 10^x = 2^(log2(10^x)) = 2^(x * log2(10))
+
+so we need to multiply by log2(10) which is just a constant.
+Ah, but just wait -- our 2^x actually doesn't exactly implement
+2^x, but it actually assumes that the input is in cents, and within
+the 2^x approximation converts its input from cents to octaves
+by dividing its input by 1200.
+
+So, in order to convert the LFO gain value in dB to something
+that our existing 2^x approximation can use, multiply the LFO gain
+by log2(10) * 1200 / 20
+
+The divide by 20 helps convert dB to linear gain, and we might
+as well incorporate that operation into this conversion.
+Of course, we need to keep some fractional bits, so multiply
+the constant by NUM_EG1_FRAC_BITS
+*/
+
+/* use LFO_GAIN_TO_CENTS to convert the LFO gain value to cents */
+#if 0
+#define DOUBLE_LOG2_10 (double) (3.32192809488736) /* log2(10) */
+
+#define DOUBLE_LFO_GAIN_TO_CENTS (double) \
+ ( \
+ (DOUBLE_LOG2_10) * \
+ 1200.0 / \
+ 20.0 \
+ )
+
+#define LFO_GAIN_TO_CENTS (int32_t) \
+ ( \
+ DOUBLE_LFO_GAIN_TO_CENTS * \
+ (0x1L << NUM_EG1_FRAC_BITS) \
+ )
+#endif
+
+#define LFO_GAIN_TO_CENTS (int32_t) (1671981156L >> (23 - NUM_EG1_FRAC_BITS))
+
+
+#define MULT_DENTS_COEF(dents,coef) /*lint -e704 <avoid divide for performance>*/ \
+ (int32_t)( \
+ ( \
+ ((int32_t)(dents)) * ((int32_t)(coef)) \
+ ) \
+ >> NUM_DENTS_FRAC_BITS \
+ ) \
+ /* lint +e704 <restore checking>*/
+
+
+/* we use 16-bits in the PC per audio sample */
+#define BITS_PER_AUDIO_SAMPLE 16
+
+/* we define 1 as 1.0 - 1 LSbit */
+#define DISTORTION_ONE (int32_t)((0x1L << (BITS_PER_AUDIO_SAMPLE-1)) -1)
+#define DISTORTION_MINUS_ONE (int32_t)(~DISTORTION_ONE)
+
+/* drive coef is given as int.frac */
+#define NUM_DRIVE_COEF_INT_BITS 1
+#define NUM_DRIVE_COEF_FRAC_BITS 4
+
+#define MULT_AUDIO_DRIVE(audio,drive) /*lint -e(702) <avoid divide for performance>*/ \
+ (int32_t) ( \
+ ( \
+ ((int32_t)(audio)) * ((int32_t)(drive)) \
+ ) \
+ >> NUM_DRIVE_COEF_FRAC_BITS \
+ )
+
+#define MULT_AUDIO_AUDIO(audio1,audio2) /*lint -e(702) <avoid divide for performance>*/ \
+ (int32_t) ( \
+ ( \
+ ((int32_t)(audio1)) * ((int32_t)(audio2)) \
+ ) \
+ >> (BITS_PER_AUDIO_SAMPLE-1) \
+ )
+
+#define SATURATE(x) \
+ ((((int32_t)(x)) > DISTORTION_ONE) ? (DISTORTION_ONE) : \
+ (((int32_t)(x)) < DISTORTION_MINUS_ONE) ? (DISTORTION_MINUS_ONE) : ((int32_t)(x)));
+
+
+/*----------------------------------------------------------------------------
+ * Effects_log2()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Fixed-point log2 function.
+ *
+ * Inputs:
+ * Input is interpreted as an integer (should not be 0).
+ *
+ * Outputs:
+ * Output is in 15-bit precision.
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+int32_t Effects_log2(uint32_t x);
+
+/*----------------------------------------------------------------------------
+ * Effects_exp2()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Fixed-point radix-2 exponent.
+ *
+ * Inputs:
+ * Input is in 15-bit precision. Must be non-negative and less than 32.
+ *
+ * Outputs:
+ * Output is an integer.
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+uint32_t Effects_exp2(int32_t x);
+
+/*----------------------------------------------------------------------------
+ * Effects_MillibelsToLinear16()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Transform gain in millibels to linear gain multiplier:
+ *
+ * mB = 2000*log(lin/32767)
+ * => lin = 2^((mB+2000*log(32767))/2000*log(2))
+ * => lin = Effects_exp2(((mB + K1) << 15) / K2)
+ * with:
+ * K1 = 2000*log(32767) and K2 = 2000*log(2)
+ *
+ * Inputs:
+ * nGain - log scale value in millibels.
+ *
+ * Outputs:
+ * Returns a 16-bit linear value approximately equal to 2^(nGain/1024)
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+#define MB_TO_LIN_K1 9031
+#define MB_TO_LIN_K2 602
+int16_t Effects_MillibelsToLinear16 (int32_t nGain);
+
+/*----------------------------------------------------------------------------
+ * Effects_Linear16ToMillibels()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Transform linear gain multiplier to millibels
+ * mB = 2000*log(lin/32767)
+ * = 2000*log(2)*log2(lin)-2000*log(32767)
+ * => mB = K1*Effects_log2(lin) + K2
+ * with:
+ * K1 = 2000*log(2) and K2 = -2000*log(32767)
+ *
+ * Inputs:
+ * nGain - linear multiplier ranging form 0 to 32767 (corresponding to [0 1] gain range).
+ *
+ * Outputs:
+ * Returns a 16-bit log value expressed in milllibels.
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+int16_t Effects_Linear16ToMillibels (int32_t nGain);
+
+/*----------------------------------------------------------------------------
+ * Effects_Sqrt()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Returns the square root of the argument given.
+ *
+ * Inputs:
+ * in - positive number in the range 0 - 2^28
+ *
+ * Outputs:
+ * Returned value: square root of in.
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+*/
+int32_t Effects_Sqrt(int32_t in);
+
+#if __cplusplus
+} // extern "C"
+#endif
+
+#endif /*ANDROID_EFFECTSMATH_H_*/
+
