Merge "Isolate references to outputTracks/mOutputTracks"
diff --git a/core/java/android/view/HardwareLayer.java b/core/java/android/view/HardwareLayer.java
index 49450bd..a97167b 100644
--- a/core/java/android/view/HardwareLayer.java
+++ b/core/java/android/view/HardwareLayer.java
@@ -167,7 +167,7 @@
/**
* Specifies the display list to use to refresh the layer.
- *
+ *
* @param displayList The display list containing the drawing commands to
* execute in this layer
* @param dirtyRect The dirty region of the layer that needs to be redrawn
diff --git a/core/java/android/view/TextureView.java b/core/java/android/view/TextureView.java
index c1e9946..fc02cc1 100644
--- a/core/java/android/view/TextureView.java
+++ b/core/java/android/view/TextureView.java
@@ -315,7 +315,7 @@
}
@Override
- HardwareLayer getHardwareLayer(boolean immediateRefresh) {
+ HardwareLayer getHardwareLayer() {
if (mLayer == null) {
if (mAttachInfo == null || mAttachInfo.mHardwareRenderer == null) {
return null;
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index c982d7a..9457067 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -10221,7 +10221,7 @@
if (mAttachInfo.mHardwareRenderer != null &&
mAttachInfo.mHardwareRenderer.isEnabled() &&
mAttachInfo.mHardwareRenderer.validate()) {
- getHardwareLayer(true);
+ getHardwareLayer();
}
break;
case LAYER_TYPE_SOFTWARE:
@@ -10243,7 +10243,7 @@
*
* @return A HardwareLayer ready to render, or null if an error occurred.
*/
- HardwareLayer getHardwareLayer(boolean immediateRefresh) {
+ HardwareLayer getHardwareLayer() {
if (mAttachInfo == null || mAttachInfo.mHardwareRenderer == null ||
!mAttachInfo.mHardwareRenderer.isEnabled()) {
return null;
@@ -10273,33 +10273,8 @@
return null;
}
- if (!immediateRefresh) {
- mHardwareLayer.redraw(getDisplayList(), mLocalDirtyRect);
- mLocalDirtyRect.setEmpty();
- } else {
- HardwareCanvas currentCanvas = mAttachInfo.mHardwareCanvas;
- final HardwareCanvas canvas = mHardwareLayer.start(currentCanvas);
-
- // Make sure all the GPU resources have been properly allocated
- if (canvas == null) {
- mHardwareLayer.end(currentCanvas);
- return null;
- }
-
- mAttachInfo.mHardwareCanvas = canvas;
- try {
- canvas.setViewport(width, height);
- canvas.onPreDraw(mLocalDirtyRect);
- mLocalDirtyRect.setEmpty();
-
- canvas.drawDisplayList(getDisplayList(), mRight - mLeft, mBottom - mTop, null,
- DisplayList.FLAG_CLIP_CHILDREN);
- } finally {
- canvas.onPostDraw();
- mHardwareLayer.end(currentCanvas);
- mAttachInfo.mHardwareCanvas = currentCanvas;
- }
- }
+ mHardwareLayer.redraw(getDisplayList(), mLocalDirtyRect);
+ mLocalDirtyRect.setEmpty();
}
return mHardwareLayer;
@@ -11266,7 +11241,7 @@
if (hasNoCache) {
boolean layerRendered = false;
if (layerType == LAYER_TYPE_HARDWARE) {
- final HardwareLayer layer = getHardwareLayer(false);
+ final HardwareLayer layer = getHardwareLayer();
if (layer != null && layer.isValid()) {
mLayerPaint.setAlpha((int) (alpha * 255));
((HardwareCanvas) canvas).drawHardwareLayer(layer, 0, 0, mLayerPaint);
diff --git a/core/tests/benchmarks/README b/core/tests/benchmarks/README
new file mode 100644
index 0000000..0a41bcc
--- /dev/null
+++ b/core/tests/benchmarks/README
@@ -0,0 +1,8 @@
+
+These benchmarks use the Caliper benchmark framework, and can be
+run on a remote device using Vogar:
+
+http://code.google.com/p/caliper/
+http://code.google.com/p/vogar/
+
+$ vogar --benchmark path/to/Benchmark.java
diff --git a/core/tests/benchmarks/src/android/os/ParcelArrayBenchmark.java b/core/tests/benchmarks/src/android/os/ParcelArrayBenchmark.java
new file mode 100644
index 0000000..21cfb09
--- /dev/null
+++ b/core/tests/benchmarks/src/android/os/ParcelArrayBenchmark.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.os;
+
+import com.google.caliper.Param;
+import com.google.caliper.SimpleBenchmark;
+
+public class ParcelArrayBenchmark extends SimpleBenchmark {
+
+ @Param({ "1", "10", "100", "1000" })
+ private int mSize;
+
+ private Parcel mWriteParcel;
+
+ private byte[] mByteArray;
+ private int[] mIntArray;
+ private long[] mLongArray;
+
+ private Parcel mByteParcel;
+ private Parcel mIntParcel;
+ private Parcel mLongParcel;
+
+ @Override
+ protected void setUp() {
+ mWriteParcel = Parcel.obtain();
+
+ mByteArray = new byte[mSize];
+ mIntArray = new int[mSize];
+ mLongArray = new long[mSize];
+
+ mByteParcel = Parcel.obtain();
+ mByteParcel.writeByteArray(mByteArray);
+ mIntParcel = Parcel.obtain();
+ mIntParcel.writeIntArray(mIntArray);
+ mLongParcel = Parcel.obtain();
+ mLongParcel.writeLongArray(mLongArray);
+ }
+
+ @Override
+ protected void tearDown() {
+ mWriteParcel.recycle();
+ mWriteParcel = null;
+ }
+
+ public void timeWriteByteArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mWriteParcel.setDataPosition(0);
+ mWriteParcel.writeByteArray(mByteArray);
+ }
+ }
+
+ public void timeCreateByteArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mByteParcel.setDataPosition(0);
+ mByteParcel.createByteArray();
+ }
+ }
+
+ public void timeReadByteArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mByteParcel.setDataPosition(0);
+ mByteParcel.readByteArray(mByteArray);
+ }
+ }
+
+ public void timeWriteIntArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mWriteParcel.setDataPosition(0);
+ mWriteParcel.writeIntArray(mIntArray);
+ }
+ }
+
+ public void timeCreateIntArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mIntParcel.setDataPosition(0);
+ mIntParcel.createIntArray();
+ }
+ }
+
+ public void timeReadIntArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mIntParcel.setDataPosition(0);
+ mIntParcel.readIntArray(mIntArray);
+ }
+ }
+
+ public void timeWriteLongArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mWriteParcel.setDataPosition(0);
+ mWriteParcel.writeLongArray(mLongArray);
+ }
+ }
+
+ public void timeCreateLongArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mLongParcel.setDataPosition(0);
+ mLongParcel.createLongArray();
+ }
+ }
+
+ public void timeReadLongArray(int reps) {
+ for (int i = 0; i < reps; i++) {
+ mLongParcel.setDataPosition(0);
+ mLongParcel.readLongArray(mLongArray);
+ }
+ }
+
+}
diff --git a/core/tests/benchmarks/src/android/os/ParcelBenchmark.java b/core/tests/benchmarks/src/android/os/ParcelBenchmark.java
new file mode 100644
index 0000000..6a7b7c8
--- /dev/null
+++ b/core/tests/benchmarks/src/android/os/ParcelBenchmark.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.os;
+
+import com.google.caliper.SimpleBenchmark;
+
+public class ParcelBenchmark extends SimpleBenchmark {
+
+ private Parcel mParcel;
+
+ @Override
+ protected void setUp() {
+ mParcel = Parcel.obtain();
+ }
+
+ @Override
+ protected void tearDown() {
+ mParcel.recycle();
+ mParcel = null;
+ }
+
+ public void timeWriteByte(int reps) {
+ final byte val = 0xF;
+ for (int i = 0; i < reps; i++) {
+ mParcel.writeByte(val);
+ }
+ }
+
+ public void timeReadByte(int reps) {
+ mParcel.setDataCapacity(reps);
+ for (int i = 0; i < reps; i++) {
+ mParcel.readByte();
+ }
+ }
+
+ public void timeWriteInt(int reps) {
+ final int val = 0xF;
+ for (int i = 0; i < reps; i++) {
+ mParcel.writeInt(val);
+ }
+ }
+
+ public void timeReadInt(int reps) {
+ mParcel.setDataCapacity(reps << 2);
+ for (int i = 0; i < reps; i++) {
+ mParcel.readInt();
+ }
+ }
+
+ public void timeWriteLong(int reps) {
+ final long val = 0xF;
+ for (int i = 0; i < reps; i++) {
+ mParcel.writeLong(val);
+ }
+ }
+
+ public void timeReadLong(int reps) {
+ mParcel.setDataCapacity(reps << 3);
+ for (int i = 0; i < reps; i++) {
+ mParcel.readLong();
+ }
+ }
+}
diff --git a/media/libeffects/downmix/Android.mk b/media/libeffects/downmix/Android.mk
new file mode 100644
index 0000000..0348e1e
--- /dev/null
+++ b/media/libeffects/downmix/Android.mk
@@ -0,0 +1,28 @@
+LOCAL_PATH:= $(call my-dir)
+
+# Multichannel downmix effect library
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ EffectDownmix.c
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils
+
+LOCAL_MODULE:= libdownmix
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/soundfx
+
+ifeq ($(TARGET_OS)-$(TARGET_SIMULATOR),linux-true)
+LOCAL_LDLIBS += -ldl
+endif
+
+LOCAL_C_INCLUDES := \
+ system/media/audio_effects/include \
+ system/media/audio_utils/include
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/media/libeffects/downmix/EffectDownmix.c b/media/libeffects/downmix/EffectDownmix.c
new file mode 100644
index 0000000..a325172
--- /dev/null
+++ b/media/libeffects/downmix/EffectDownmix.c
@@ -0,0 +1,889 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "EffectDownmix"
+#define LOG_NDEBUG 0
+#include <cutils/log.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include "EffectDownmix.h"
+
+#define MINUS_3_DB_IN_Q19_12 2896 // -3dB = 0.707 * 2^12 = 2896
+
+// effect_handle_t interface implementation for downmix effect
+const struct effect_interface_s gDownmixInterface = {
+ Downmix_Process,
+ Downmix_Command,
+ Downmix_GetDescriptor,
+ NULL /* no process_reverse function, no reference stream needed */
+};
+
+audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
+ tag : AUDIO_EFFECT_LIBRARY_TAG,
+ version : EFFECT_LIBRARY_API_VERSION,
+ name : "Downmix Library",
+ implementor : "The Android Open Source Project",
+ query_num_effects : DownmixLib_QueryNumberEffects,
+ query_effect : DownmixLib_QueryEffect,
+ create_effect : DownmixLib_Create,
+ release_effect : DownmixLib_Release,
+ get_descriptor : DownmixLib_GetDescriptor,
+};
+
+
+// AOSP insert downmix UUID: 93f04452-e4fe-41cc-91f9-e475b6d1d69f
+static const effect_descriptor_t gDownmixDescriptor = {
+ EFFECT_UIID_DOWNMIX__, //type
+ {0x93f04452, 0xe4fe, 0x41cc, 0x91f9, {0xe4, 0x75, 0xb6, 0xd1, 0xd6, 0x9f}}, // uuid
+ EFFECT_CONTROL_API_VERSION,
+ EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST,
+ 0, //FIXME what value should be reported? // cpu load
+ 0, //FIXME what value should be reported? // memory usage
+ "Multichannel Downmix To Stereo", // human readable effect name
+ "The Android Open Source Project" // human readable effect implementor name
+};
+
+// gDescriptors contains pointers to all defined effect descriptor in this library
+static const effect_descriptor_t * const gDescriptors[] = {
+ &gDownmixDescriptor
+};
+
+// number of effects in this library
+const int kNbEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);
+
+
+/*----------------------------------------------------------------------------
+ * Effect API implementation
+ *--------------------------------------------------------------------------*/
+
+/*--- Effect Library Interface Implementation ---*/
+
+int32_t DownmixLib_QueryNumberEffects(uint32_t *pNumEffects) {
+ ALOGV("DownmixLib_QueryNumberEffects()");
+ *pNumEffects = kNbEffects;
+ return 0;
+}
+
+int32_t DownmixLib_QueryEffect(uint32_t index, effect_descriptor_t *pDescriptor) {
+ ALOGV("DownmixLib_QueryEffect() index=%d", index);
+ if (pDescriptor == NULL) {
+ return -EINVAL;
+ }
+ if (index >= (uint32_t)kNbEffects) {
+ return -EINVAL;
+ }
+ memcpy(pDescriptor, gDescriptors[index], sizeof(effect_descriptor_t));
+ return 0;
+}
+
+
+int32_t DownmixLib_Create(const effect_uuid_t *uuid,
+ int32_t sessionId,
+ int32_t ioId,
+ effect_handle_t *pHandle) {
+ int ret;
+ int i;
+ downmix_module_t *module;
+ const effect_descriptor_t *desc;
+
+ ALOGV("DownmixLib_Create()");
+
+ if (pHandle == NULL || uuid == NULL) {
+ return -EINVAL;
+ }
+
+ for (i = 0 ; i < kNbEffects ; i++) {
+ desc = gDescriptors[i];
+ if (memcmp(uuid, &desc->uuid, sizeof(effect_uuid_t)) == 0) {
+ break;
+ }
+ }
+
+ if (i == kNbEffects) {
+ return -ENOENT;
+ }
+
+ module = malloc(sizeof(downmix_module_t));
+
+ module->itfe = &gDownmixInterface;
+
+ module->context.state = DOWNMIX_STATE_UNINITIALIZED;
+
+ ret = Downmix_Init(module);
+ if (ret < 0) {
+ ALOGW("DownmixLib_Create() init failed");
+ free(module);
+ return ret;
+ }
+
+ *pHandle = (effect_handle_t) module;
+
+ ALOGV("DownmixLib_Create() %p , size %d", module, sizeof(downmix_module_t));
+
+ return 0;
+}
+
+
+int32_t DownmixLib_Release(effect_handle_t handle) {
+ downmix_module_t *pDwmModule = (downmix_module_t *)handle;
+
+ ALOGV("DownmixLib_Release() %p", handle);
+ if (handle == NULL) {
+ return -EINVAL;
+ }
+
+ pDwmModule->context.state = DOWNMIX_STATE_UNINITIALIZED;
+
+ free(pDwmModule);
+ return 0;
+}
+
+
+int32_t DownmixLib_GetDescriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) {
+ ALOGV("DownmixLib_GetDescriptor()");
+ int i;
+
+ if (pDescriptor == NULL || uuid == NULL){
+ ALOGE("DownmixLib_Create() called with NULL pointer");
+ return -EINVAL;
+ }
+ ALOGV("DownmixLib_GetDescriptor() nb effects=%d", kNbEffects);
+ for (i = 0; i < kNbEffects; i++) {
+ ALOGV("DownmixLib_GetDescriptor() i=%d", i);
+ if (memcmp(uuid, &gDescriptors[i]->uuid, sizeof(effect_uuid_t)) == 0) {
+ memcpy(pDescriptor, gDescriptors[i], sizeof(effect_descriptor_t));
+ ALOGV("EffectGetDescriptor - UUID matched downmix type %d, UUID = %x",
+ i, gDescriptors[i]->uuid.timeLow);
+ return 0;
+ }
+ }
+
+ return -EINVAL;
+}
+
+
+/*--- Effect Control Interface Implementation ---*/
+
+static int Downmix_Process(effect_handle_t self,
+ audio_buffer_t *inBuffer, audio_buffer_t *outBuffer) {
+
+ downmix_object_t *pDownmixer;
+ int16_t *pSrc, *pDst;
+ downmix_module_t *pDwmModule = (downmix_module_t *)self;
+
+ if (pDwmModule == NULL) {
+ return -EINVAL;
+ }
+
+ if (inBuffer == NULL || inBuffer->raw == NULL ||
+ outBuffer == NULL || outBuffer->raw == NULL ||
+ inBuffer->frameCount != outBuffer->frameCount) {
+ return -EINVAL;
+ }
+
+ pDownmixer = (downmix_object_t*) &pDwmModule->context;
+
+ if (pDownmixer->state == DOWNMIX_STATE_UNINITIALIZED) {
+ ALOGE("Downmix_Process error: trying to use an uninitialized downmixer");
+ return -EINVAL;
+ } else if (pDownmixer->state == DOWNMIX_STATE_INITIALIZED) {
+ ALOGE("Downmix_Process error: trying to use a non-configured downmixer");
+ return -ENODATA;
+ }
+
+ pSrc = inBuffer->s16;
+ pDst = outBuffer->s16;
+ size_t numFrames = outBuffer->frameCount;
+
+ const bool accumulate =
+ (pDwmModule->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
+
+ switch(pDownmixer->type) {
+
+ case DOWNMIX_TYPE_STRIP:
+ if (accumulate) {
+ while (numFrames) {
+ pDst[0] = clamp16(pDst[0] + pSrc[0]);
+ pDst[1] = clamp16(pDst[1] + pSrc[1]);
+ pSrc += pDownmixer->input_channel_count;
+ pDst += 2;
+ numFrames--;
+ }
+ } else {
+ while (numFrames) {
+ pDst[0] = pSrc[0];
+ pDst[1] = pSrc[1];
+ pSrc += pDownmixer->input_channel_count;
+ pDst += 2;
+ numFrames--;
+ }
+ }
+ break;
+
+ case DOWNMIX_TYPE_FOLD:
+ // optimize for the common formats
+ switch(pDwmModule->config.inputCfg.channels) {
+ case AUDIO_CHANNEL_OUT_QUAD:
+ Downmix_foldFromQuad(pSrc, pDst, numFrames, accumulate);
+ break;
+ case AUDIO_CHANNEL_OUT_SURROUND:
+ Downmix_foldFromSurround(pSrc, pDst, numFrames, accumulate);
+ break;
+ case AUDIO_CHANNEL_OUT_5POINT1:
+ Downmix_foldFrom5Point1(pSrc, pDst, numFrames, accumulate);
+ break;
+ case AUDIO_CHANNEL_OUT_7POINT1:
+ Downmix_foldFrom7Point1(pSrc, pDst, numFrames, accumulate);
+ break;
+ default:
+ // FIXME implement generic downmix
+ ALOGE("Multichannel configurations other than quad, 4.0, 5.1 and 7.1 are not supported");
+ break;
+ }
+ break;
+
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+
+static int Downmix_Command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
+ void *pCmdData, uint32_t *replySize, void *pReplyData) {
+
+ downmix_module_t *pDwmModule = (downmix_module_t *) self;
+ downmix_object_t *pDownmixer;
+ int retsize;
+
+ if (pDwmModule == NULL || pDwmModule->context.state == DOWNMIX_STATE_UNINITIALIZED) {
+ return -EINVAL;
+ }
+
+ pDownmixer = (downmix_object_t*) &pDwmModule->context;
+
+ ALOGV("Downmix_Command command %d cmdSize %d",cmdCode, cmdSize);
+
+ switch (cmdCode) {
+ case EFFECT_CMD_INIT:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ *(int *) pReplyData = Downmix_Init(pDwmModule);
+ break;
+
+ case EFFECT_CMD_SET_CONFIG:
+ if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
+ || pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ *(int *) pReplyData = Downmix_Configure(pDwmModule,
+ (effect_config_t *)pCmdData, false);
+ break;
+
+ case EFFECT_CMD_RESET:
+ Downmix_Reset(pDownmixer, false);
+ break;
+
+ case EFFECT_CMD_GET_PARAM:
+ ALOGV("Downmix_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) + 2 * sizeof(int32_t)) {
+ return -EINVAL;
+ }
+ effect_param_t *rep = (effect_param_t *) pReplyData;
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(int32_t));
+ ALOGV("Downmix_Command EFFECT_CMD_GET_PARAM param %d, replySize %d",
+ *(int32_t *)rep->data, rep->vsize);
+ rep->status = Downmix_getParameter(pDownmixer, *(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:
+ ALOGV("Downmix_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 = Downmix_setParameter(pDownmixer, *(int32_t *)cmd->data,
+ cmd->vsize, cmd->data + sizeof(int32_t));
+ break;
+
+ case EFFECT_CMD_SET_PARAM_DEFERRED:
+ //FIXME implement
+ ALOGW("Downmix_Command command EFFECT_CMD_SET_PARAM_DEFERRED not supported, FIXME");
+ break;
+
+ case EFFECT_CMD_SET_PARAM_COMMIT:
+ //FIXME implement
+ ALOGW("Downmix_Command command EFFECT_CMD_SET_PARAM_COMMIT not supported, FIXME");
+ break;
+
+ case EFFECT_CMD_ENABLE:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ if (pDownmixer->state != DOWNMIX_STATE_INITIALIZED) {
+ return -ENOSYS;
+ }
+ pDownmixer->state = DOWNMIX_STATE_ACTIVE;
+ ALOGV("EFFECT_CMD_ENABLE() OK");
+ *(int *)pReplyData = 0;
+ break;
+
+ case EFFECT_CMD_DISABLE:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ return -EINVAL;
+ }
+ if (pDownmixer->state != DOWNMIX_STATE_ACTIVE) {
+ return -ENOSYS;
+ }
+ pDownmixer->state = DOWNMIX_STATE_INITIALIZED;
+ ALOGV("EFFECT_CMD_DISABLE() OK");
+ *(int *)pReplyData = 0;
+ break;
+
+ case EFFECT_CMD_SET_DEVICE:
+ if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) {
+ return -EINVAL;
+ }
+ // FIXME change type if playing on headset vs speaker
+ ALOGV("Downmix_Command EFFECT_CMD_SET_DEVICE: 0x%08x", *(uint32_t *)pCmdData);
+ break;
+
+ case EFFECT_CMD_SET_VOLUME: {
+ // audio output is always stereo => 2 channel volumes
+ if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t) * 2) {
+ return -EINVAL;
+ }
+ // FIXME change volume
+ ALOGW("Downmix_Command command EFFECT_CMD_SET_VOLUME not supported, FIXME");
+ float left = (float)(*(uint32_t *)pCmdData) / (1 << 24);
+ float right = (float)(*((uint32_t *)pCmdData + 1)) / (1 << 24);
+ ALOGV("Downmix_Command EFFECT_CMD_SET_VOLUME: left %f, right %f ", left, right);
+ break;
+ }
+
+ case EFFECT_CMD_SET_AUDIO_MODE:
+ if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) {
+ return -EINVAL;
+ }
+ ALOGV("Downmix_Command EFFECT_CMD_SET_AUDIO_MODE: %d", *(uint32_t *)pCmdData);
+ break;
+
+ case EFFECT_CMD_SET_CONFIG_REVERSE:
+ case EFFECT_CMD_SET_INPUT_DEVICE:
+ // these commands are ignored by a downmix effect
+ break;
+
+ default:
+ ALOGW("Downmix_Command invalid command %d",cmdCode);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+
+int Downmix_GetDescriptor(effect_handle_t self, effect_descriptor_t *pDescriptor)
+{
+ downmix_module_t *pDwnmxModule = (downmix_module_t *) self;
+
+ if (pDwnmxModule == NULL ||
+ pDwnmxModule->context.state == DOWNMIX_STATE_UNINITIALIZED) {
+ return -EINVAL;
+ }
+
+ memcpy(pDescriptor, &gDownmixDescriptor, sizeof(effect_descriptor_t));
+
+ return 0;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix internal functions
+ *--------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+ * Downmix_Init()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Initialize downmix context and apply default parameters
+ *
+ * Inputs:
+ * pDwmModule pointer to downmix effect module
+ *
+ * Outputs:
+ *
+ * Returns:
+ * 0 indicates success
+ *
+ * Side Effects:
+ * updates:
+ * pDwmModule->context.type
+ * pDwmModule->context.apply_volume_correction
+ * pDwmModule->config.inputCfg
+ * pDwmModule->config.outputCfg
+ * pDwmModule->config.inputCfg.samplingRate
+ * pDwmModule->config.outputCfg.samplingRate
+ * pDwmModule->context.state
+ * doesn't set:
+ * pDwmModule->itfe
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int Downmix_Init(downmix_module_t *pDwmModule) {
+
+ ALOGV("Downmix_Init module %p", pDwmModule);
+ int ret = 0;
+
+ memset(&pDwmModule->context, 0, sizeof(downmix_object_t));
+
+ pDwmModule->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
+ pDwmModule->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+ pDwmModule->config.inputCfg.channels = AUDIO_CHANNEL_OUT_7POINT1;
+ pDwmModule->config.inputCfg.bufferProvider.getBuffer = NULL;
+ pDwmModule->config.inputCfg.bufferProvider.releaseBuffer = NULL;
+ pDwmModule->config.inputCfg.bufferProvider.cookie = NULL;
+ pDwmModule->config.inputCfg.mask = EFFECT_CONFIG_ALL;
+
+ pDwmModule->config.inputCfg.samplingRate = 44100;
+ pDwmModule->config.outputCfg.samplingRate = pDwmModule->config.inputCfg.samplingRate;
+
+ // set a default value for the access mode, but should be overwritten by caller
+ pDwmModule->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
+ pDwmModule->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+ pDwmModule->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
+ pDwmModule->config.outputCfg.bufferProvider.getBuffer = NULL;
+ pDwmModule->config.outputCfg.bufferProvider.releaseBuffer = NULL;
+ pDwmModule->config.outputCfg.bufferProvider.cookie = NULL;
+ pDwmModule->config.outputCfg.mask = EFFECT_CONFIG_ALL;
+
+ ret = Downmix_Configure(pDwmModule, &pDwmModule->config, true);
+ if (ret != 0) {
+ ALOGV("Downmix_Init error %d on module %p", ret, pDwmModule);
+ } else {
+ pDwmModule->context.state = DOWNMIX_STATE_INITIALIZED;
+ }
+
+ return ret;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_Configure()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Set input and output audio configuration.
+ *
+ * Inputs:
+ * pDwmModule pointer to downmix effect module
+ * pConfig pointer to effect_config_t structure containing input
+ * and output audio parameters configuration
+ * init true if called from init function
+ *
+ * Outputs:
+ *
+ * Returns:
+ * 0 indicates success
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int Downmix_Configure(downmix_module_t *pDwmModule, effect_config_t *pConfig, bool init) {
+
+ downmix_object_t *pDownmixer = &pDwmModule->context;
+
+ // Check configuration compatibility with build options, and effect capabilities
+ if (pConfig->inputCfg.samplingRate != pConfig->outputCfg.samplingRate
+ || pConfig->outputCfg.channels != DOWNMIX_OUTPUT_CHANNELS
+ || pConfig->inputCfg.format != AUDIO_FORMAT_PCM_16_BIT
+ || pConfig->outputCfg.format != AUDIO_FORMAT_PCM_16_BIT) {
+ ALOGE("Downmix_Configure error: invalid config");
+ return -EINVAL;
+ }
+
+ memcpy(&pDwmModule->config, pConfig, sizeof(effect_config_t));
+
+ if (init) {
+ pDownmixer->type = DOWNMIX_TYPE_FOLD;
+ pDownmixer->apply_volume_correction = false;
+ pDownmixer->input_channel_count = 8; // matches default input of AUDIO_CHANNEL_OUT_7POINT1
+ } else {
+ // when configuring the effect, do not allow a blank channel mask
+ if (pConfig->inputCfg.channels == 0) {
+ ALOGE("Downmix_Configure error: input channel mask can't be 0");
+ return -EINVAL;
+ }
+ pDownmixer->input_channel_count = popcount(pConfig->inputCfg.channels);
+ }
+
+ Downmix_Reset(pDownmixer, init);
+
+ return 0;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_Reset()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Reset internal states.
+ *
+ * Inputs:
+ * pDownmixer pointer to downmix context
+ * init true if called from init function
+ *
+ * Outputs:
+*
+ * Returns:
+ * 0 indicates success
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int Downmix_Reset(downmix_object_t *pDownmixer, bool init) {
+ // nothing to do here
+ return 0;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_setParameter()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Set a Downmix parameter
+ *
+ * Inputs:
+ * pDownmixer handle to instance data
+ * param parameter
+ * pValue pointer to parameter value
+ * size value size
+ *
+ * Outputs:
+ *
+ * Returns:
+ * 0 indicates success
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+int Downmix_setParameter(downmix_object_t *pDownmixer, int32_t param, size_t size, void *pValue) {
+
+ int16_t value16;
+ ALOGV("Downmix_setParameter, context %p, param %d, value16 %d, value32 %d",
+ pDownmixer, param, *(int16_t *)pValue, *(int32_t *)pValue);
+
+ switch (param) {
+
+ case DOWNMIX_PARAM_TYPE:
+ if (size != sizeof(downmix_type_t)) {
+ ALOGE("Downmix_setParameter(DOWNMIX_PARAM_TYPE) invalid size %d, should be %d",
+ size, sizeof(downmix_type_t));
+ return -EINVAL;
+ }
+ value16 = *(int16_t *)pValue;
+ ALOGV("set DOWNMIX_PARAM_TYPE, type %d", value16);
+ if (!((value16 > DOWNMIX_TYPE_INVALID) && (value16 < DOWNMIX_TYPE_LAST))) {
+ ALOGE("Downmix_setParameter invalid DOWNMIX_PARAM_TYPE value %d", value16);
+ return -EINVAL;
+ } else {
+ pDownmixer->type = (downmix_type_t) value16;
+ break;
+
+ default:
+ ALOGE("Downmix_setParameter unknown parameter %d", param);
+ return -EINVAL;
+ }
+}
+
+ return 0;
+} /* end Downmix_setParameter */
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_getParameter()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * Get a Downmix parameter
+ *
+ * Inputs:
+ * pDownmixer 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
+ *
+ * Returns:
+ * 0 indicates success
+ *
+ * Side Effects:
+ *
+ *----------------------------------------------------------------------------
+ */
+int Downmix_getParameter(downmix_object_t *pDownmixer, int32_t param, size_t *pSize, void *pValue) {
+ int16_t *pValue16;
+
+ switch (param) {
+
+ case DOWNMIX_PARAM_TYPE:
+ if (*pSize < sizeof(int16_t)) {
+ ALOGE("Downmix_getParameter invalid parameter size %d for DOWNMIX_PARAM_TYPE", *pSize);
+ return -EINVAL;
+ }
+ pValue16 = (int16_t *)pValue;
+ *pValue16 = (int16_t) pDownmixer->type;
+ *pSize = sizeof(int16_t);
+ ALOGV("Downmix_getParameter DOWNMIX_PARAM_TYPE is %d", *pValue16);
+ break;
+
+ default:
+ ALOGE("Downmix_getParameter unknown parameter %d", param);
+ return -EINVAL;
+ }
+
+ return 0;
+} /* end Downmix_getParameter */
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_foldFromQuad()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * downmix a quad signal to stereo
+ *
+ * Inputs:
+ * pSrc quad audio samples to downmix
+ * numFrames the number of quad frames to downmix
+ *
+ * Outputs:
+ * pDst downmixed stereo audio samples
+ *
+ *----------------------------------------------------------------------------
+ */
+void Downmix_foldFromQuad(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
+ // sample at index 0 is FL
+ // sample at index 1 is FR
+ // sample at index 2 is RL
+ // sample at index 3 is RR
+ if (accumulate) {
+ while (numFrames) {
+ // FL + RL
+ pDst[0] = clamp16(pDst[0] + pSrc[0] + pSrc[2]);
+ // FR + RR
+ pDst[1] = clamp16(pDst[1] + pSrc[1] + pSrc[3]);
+ pSrc += 4;
+ pDst += 2;
+ numFrames--;
+ }
+ } else { // same code as above but without adding and clamping pDst[i] to itself
+ while (numFrames) {
+ // FL + RL
+ pDst[0] = clamp16(pSrc[0] + pSrc[2]);
+ // FR + RR
+ pDst[1] = clamp16(pSrc[1] + pSrc[3]);
+ pSrc += 4;
+ pDst += 2;
+ numFrames--;
+ }
+ }
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_foldFromSurround()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * downmix a "surround sound" (mono rear) signal to stereo
+ *
+ * Inputs:
+ * pSrc surround signal to downmix
+ * numFrames the number of surround frames to downmix
+ *
+ * Outputs:
+ * pDst downmixed stereo audio samples
+ *
+ *----------------------------------------------------------------------------
+ */
+void Downmix_foldFromSurround(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
+ int32_t lt, rt, centerPlusRearContrib; // samples in Q19.12 format
+ // sample at index 0 is FL
+ // sample at index 1 is FR
+ // sample at index 2 is FC
+ // sample at index 3 is RC
+ if (accumulate) {
+ while (numFrames) {
+ // centerPlusRearContrib = FC(-3dB) + RC(-3dB)
+ centerPlusRearContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12) + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
+ // FL + centerPlusRearContrib
+ lt = (pSrc[0] << 12) + centerPlusRearContrib;
+ // FR + centerPlusRearContrib
+ rt = (pSrc[1] << 12) + centerPlusRearContrib;
+ pDst[0] = clamp16(pDst[0] + (lt >> 12));
+ pDst[1] = clamp16(pDst[1] + (rt >> 12));
+ pSrc += 4;
+ pDst += 2;
+ numFrames--;
+ }
+ } else { // same code as above but without adding and clamping pDst[i] to itself
+ while (numFrames) {
+ // centerPlusRearContrib = FC(-3dB) + RC(-3dB)
+ centerPlusRearContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12) + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
+ // FL + centerPlusRearContrib
+ lt = (pSrc[0] << 12) + centerPlusRearContrib;
+ // FR + centerPlusRearContrib
+ rt = (pSrc[1] << 12) + centerPlusRearContrib;
+ pDst[0] = clamp16(lt >> 12);
+ pDst[1] = clamp16(rt >> 12);
+ pSrc += 4;
+ pDst += 2;
+ numFrames--;
+ }
+ }
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_foldFrom5Point1()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * downmix a 5.1 signal to stereo
+ *
+ * Inputs:
+ * pSrc 5.1 audio samples to downmix
+ * numFrames the number of 5.1 frames to downmix
+ *
+ * Outputs:
+ * pDst downmixed stereo audio samples
+ *
+ *----------------------------------------------------------------------------
+ */
+void Downmix_foldFrom5Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
+ int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
+ // sample at index 0 is FL
+ // sample at index 1 is FR
+ // sample at index 2 is FC
+ // sample at index 3 is LFE
+ // sample at index 4 is RL
+ // sample at index 5 is RR
+ if (accumulate) {
+ while (numFrames) {
+ // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
+ centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
+ + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
+ // FL + centerPlusLfeContrib + RL
+ lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);
+ // FR + centerPlusLfeContrib + RR
+ rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);
+ pDst[0] = clamp16(pDst[0] + (lt >> 12));
+ pDst[1] = clamp16(pDst[1] + (rt >> 12));
+ pSrc += 6;
+ pDst += 2;
+ numFrames--;
+ }
+ } else { // same code as above but without adding and clamping pDst[i] to itself
+ while (numFrames) {
+ // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
+ centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
+ + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
+ // FL + centerPlusLfeContrib + RL
+ lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);
+ // FR + centerPlusLfeContrib + RR
+ rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);
+ pDst[0] = clamp16(lt >> 12);
+ pDst[1] = clamp16(rt >> 12);
+ pSrc += 6;
+ pDst += 2;
+ numFrames--;
+ }
+ }
+}
+
+
+/*----------------------------------------------------------------------------
+ * Downmix_foldFrom7Point1()
+ *----------------------------------------------------------------------------
+ * Purpose:
+ * downmix a 7.1 signal to stereo
+ *
+ * Inputs:
+ * pSrc 7.1 audio samples to downmix
+ * numFrames the number of 7.1 frames to downmix
+ *
+ * Outputs:
+ * pDst downmixed stereo audio samples
+ *
+ *----------------------------------------------------------------------------
+ */
+void Downmix_foldFrom7Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
+ int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
+ // sample at index 0 is FL
+ // sample at index 1 is FR
+ // sample at index 2 is FC
+ // sample at index 3 is LFE
+ // sample at index 4 is RL
+ // sample at index 5 is RR
+ // sample at index 6 is SL
+ // sample at index 7 is SR
+ if (accumulate) {
+ while (numFrames) {
+ // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
+ centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
+ + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
+ // FL + centerPlusLfeContrib + SL + RL
+ lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);
+ // FR + centerPlusLfeContrib + SR + RR
+ rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);
+ pDst[0] = clamp16(lt >> 12);
+ pDst[1] = clamp16(rt >> 12);
+ pSrc += 8;
+ pDst += 2;
+ numFrames--;
+ }
+ } else { // same code as above but without adding and clamping pDst[i] to itself
+ while (numFrames) {
+ // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
+ centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
+ + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
+ // FL + centerPlusLfeContrib + SL + RL
+ lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);
+ // FR + centerPlusLfeContrib + SR + RR
+ rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);
+ pDst[0] = clamp16(pDst[0] + (lt >> 12));
+ pDst[1] = clamp16(pDst[1] + (rt >> 12));
+ pSrc += 8;
+ pDst += 2;
+ numFrames--;
+ }
+ }
+}
+
diff --git a/media/libeffects/downmix/EffectDownmix.h b/media/libeffects/downmix/EffectDownmix.h
new file mode 100644
index 0000000..4176b5a
--- /dev/null
+++ b/media/libeffects/downmix/EffectDownmix.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_EFFECTDOWNMIX_H_
+#define ANDROID_EFFECTDOWNMIX_H_
+
+#include <audio_effects/effect_downmix.h>
+#include <audio_utils/primitives.h>
+#include <system/audio.h>
+
+/*------------------------------------
+ * definitions
+ *------------------------------------
+*/
+
+#define DOWNMIX_OUTPUT_CHANNELS AUDIO_CHANNEL_OUT_STEREO
+
+typedef enum {
+ DOWNMIX_STATE_UNINITIALIZED,
+ DOWNMIX_STATE_INITIALIZED,
+ DOWNMIX_STATE_ACTIVE,
+} downmix_state_t;
+
+/* parameters for each downmixer */
+typedef struct {
+ downmix_state_t state;
+ downmix_type_t type;
+ bool apply_volume_correction;
+ uint8_t input_channel_count;
+} downmix_object_t;
+
+
+typedef struct downmix_module_s {
+ const struct effect_interface_s *itfe;
+ effect_config_t config;
+ downmix_object_t context;
+} downmix_module_t;
+
+
+/*------------------------------------
+ * Effect API
+ *------------------------------------
+*/
+int32_t DownmixLib_QueryNumberEffects(uint32_t *pNumEffects);
+int32_t DownmixLib_QueryEffect(uint32_t index,
+ effect_descriptor_t *pDescriptor);
+int32_t DownmixLib_Create(const effect_uuid_t *uuid,
+ int32_t sessionId,
+ int32_t ioId,
+ effect_handle_t *pHandle);
+int32_t DownmixLib_Release(effect_handle_t handle);
+int32_t DownmixLib_GetDescriptor(const effect_uuid_t *uuid,
+ effect_descriptor_t *pDescriptor);
+
+static int Downmix_Process(effect_handle_t self,
+ audio_buffer_t *inBuffer,
+ audio_buffer_t *outBuffer);
+static int Downmix_Command(effect_handle_t self,
+ uint32_t cmdCode,
+ uint32_t cmdSize,
+ void *pCmdData,
+ uint32_t *replySize,
+ void *pReplyData);
+static int Downmix_GetDescriptor(effect_handle_t self,
+ effect_descriptor_t *pDescriptor);
+
+
+/*------------------------------------
+ * internal functions
+ *------------------------------------
+*/
+int Downmix_Init(downmix_module_t *pDwmModule);
+int Downmix_Configure(downmix_module_t *pDwmModule, effect_config_t *pConfig, bool init);
+int Downmix_Reset(downmix_object_t *pDownmixer, bool init);
+int Downmix_setParameter(downmix_object_t *pDownmixer, int32_t param, size_t size, void *pValue);
+int Downmix_getParameter(downmix_object_t *pDownmixer, int32_t param, size_t *pSize, void *pValue);
+
+void Downmix_foldFromQuad(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
+void Downmix_foldFromSurround(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
+void Downmix_foldFrom5Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
+void Downmix_foldFrom7Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);
+
+#endif /*ANDROID_EFFECTDOWNMIX_H_*/