hal: Add support for ssr audio feature
Update audio HAL to support surround sound recording (5.1 channels)
Change-Id: I5b24340251b55ad5c602f2de0a0b4c7672ba729b
diff --git a/hal/Android.mk b/hal/Android.mk
index cfd41de..7d681ce 100644
--- a/hal/Android.mk
+++ b/hal/Android.mk
@@ -53,6 +53,12 @@
LOCAL_SRC_FILES += audio_extn/usb.c
endif
+ifneq ($(strip $(AUDIO_FEATURE_DISABLED_SSR)),true)
+ LOCAL_CFLAGS += -DSSR_ENABLED
+ LOCAL_SRC_FILES += audio_extn/ssr.c
+ LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/mm-audio/surround_sound/
+endif
+
LOCAL_SHARED_LIBRARIES := \
liblog \
libcutils \
@@ -60,7 +66,6 @@
libaudioroute \
libdl
-
LOCAL_C_INCLUDES += \
external/tinyalsa/include \
$(call include-path-for, audio-route) \
diff --git a/hal/audio_extn/audio_extn.c b/hal/audio_extn/audio_extn.c
index 6f094c0..2389f00 100644
--- a/hal/audio_extn/audio_extn.c
+++ b/hal/audio_extn/audio_extn.c
@@ -51,6 +51,14 @@
struct str_parms *parms);
#endif
+#ifndef SSR_ENABLED
+#define audio_extn_ssr_get_parameters(query, reply) (0)
+#else
+void audio_extn_ssr_get_parameters(struct str_parms *query,
+
+ struct str_parms *reply);
+#endif
+
#ifndef ANC_HEADSET_ENABLED
#define audio_extn_set_anc_parameters(parms) (0)
#else
@@ -195,5 +203,7 @@
struct str_parms *reply)
{
audio_extn_get_afe_proxy_parameters(query, reply);
- ALOGD("%s: exit: returns %s", __func__, str_parms_to_str(reply));
+ audio_extn_ssr_get_parameters(query, reply);
+
+ ALOGD("%s: returns %s", __func__, str_parms_to_str(reply));
}
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index 858faaf..ee03f5a 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -65,4 +65,20 @@
bool audio_extn_usb_is_proxy_inuse();
#endif
+#ifndef SSR_ENABLED
+#define audio_extn_ssr_init(adev, in) (0)
+#define audio_extn_ssr_deinit() (0)
+#define audio_extn_ssr_update_enabled(adev) (0)
+#define audio_extn_ssr_get_enabled() (0)
+#define audio_extn_ssr_read(stream, buffer, bytes) (0)
+#else
+int32_t audio_extn_ssr_init(struct audio_device *adev,
+ struct stream_in *in);
+int32_t audio_extn_ssr_deinit();
+int32_t audio_extn_ssr_update_enabled(struct audio_device *adev);
+bool audio_extn_ssr_get_enabled();
+int32_t audio_extn_ssr_read(struct audio_stream_in *stream,
+ void *buffer, size_t bytes);
+#endif
+
#endif /* AUDIO_EXTN_H */
diff --git a/hal/audio_extn/ssr.c b/hal/audio_extn/ssr.c
new file mode 100644
index 0000000..efd92ea
--- /dev/null
+++ b/hal/audio_extn/ssr.c
@@ -0,0 +1,619 @@
+/*
+ * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Copyright (C) 2013 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 "audio_hw_ssr"
+/*#define LOG_NDEBUG 0*/
+#define LOG_NDDEBUG 0
+
+#include <errno.h>
+#include <cutils/properties.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <cutils/str_parms.h>
+#include <cutils/log.h>
+
+#include "audio_hw.h"
+#include "platform.h"
+#include "platform_api.h"
+#include "surround_filters_interface.h"
+
+#ifdef SSR_ENABLED
+#define COEFF_ARRAY_SIZE 4
+#define FILT_SIZE ((512+1)* 6) /* # ((FFT bins)/2+1)*numOutputs */
+#define SSR_FRAME_SIZE 512
+#define SSR_INPUT_FRAME_SIZE (SSR_FRAME_SIZE * 4)
+#define SSR_OUTPUT_FRAME_SIZE (SSR_FRAME_SIZE * 6)
+#define SSR_CHANNEL_COUNT 4
+#define SSR_PERIOD_SIZE 256
+#define SSR_PERIOD_COUNT 8
+
+#define SURROUND_FILE_1R "/system/etc/surround_sound/filter1r.pcm"
+#define SURROUND_FILE_2R "/system/etc/surround_sound/filter2r.pcm"
+#define SURROUND_FILE_3R "/system/etc/surround_sound/filter3r.pcm"
+#define SURROUND_FILE_4R "/system/etc/surround_sound/filter4r.pcm"
+
+#define SURROUND_FILE_1I "/system/etc/surround_sound/filter1i.pcm"
+#define SURROUND_FILE_2I "/system/etc/surround_sound/filter2i.pcm"
+#define SURROUND_FILE_3I "/system/etc/surround_sound/filter3i.pcm"
+#define SURROUND_FILE_4I "/system/etc/surround_sound/filter4i.pcm"
+#define AUDIO_PARAMETER_KEY_SSR "ssr"
+#define LIB_SURROUND_PROC "libsurround_proc.so"
+
+typedef int (*surround_filters_init_t)(void *, int, int, Word16 **,
+ Word16 **, int, int, int, Profiler *);
+typedef void (*surround_filters_release_t)(void *);
+typedef int (*surround_filters_set_channel_map_t)(void *, const int *);
+typedef void (*surround_filters_intl_process_t)(void *, Word16 *, Word16 *);
+
+struct ssr_module {
+ FILE *fp_4ch;
+ FILE *fp_6ch;
+ int16_t **real_coeffs;
+ int16_t **imag_coeffs;
+ void *surround_obj;
+
+ int16_t *surround_input_buffer;
+ int16_t *surround_output_buffer;
+ int surround_input_bufferIdx;
+ int surround_output_bufferIdx;
+ bool is_ssr_enabled;
+
+ void *surround_filters_handle;
+ surround_filters_init_t surround_filters_init;
+ surround_filters_release_t surround_filters_release;
+ surround_filters_set_channel_map_t surround_filters_set_channel_map;
+ surround_filters_intl_process_t surround_filters_intl_process;
+};
+
+static int32_t ssr_init_surround_sound_lib(unsigned long buffersize);
+static int32_t ssr_read_coeffs_from_file();
+
+static struct ssr_module ssrmod = {
+ .fp_4ch = NULL,
+ .fp_6ch= NULL,
+ .real_coeffs = NULL,
+ .imag_coeffs = NULL,
+ .surround_obj = NULL,
+ .surround_output_buffer = NULL,
+ .surround_input_buffer = NULL,
+ .surround_output_bufferIdx = 0,
+ .surround_input_bufferIdx= 0,
+ .is_ssr_enabled = 0,
+
+ .surround_filters_handle = NULL,
+ .surround_filters_init = NULL,
+ .surround_filters_release = NULL,
+ .surround_filters_set_channel_map = NULL,
+ .surround_filters_intl_process = NULL,
+};
+
+/* Use AAC/DTS channel mapping as default channel mapping: C,FL,FR,Ls,Rs,LFE */
+static const int chan_map[] = { 1, 2, 4, 3, 0, 5};
+
+/* Rotine to read coeffs from File and updates real and imaginary
+ coeff array member variable */
+static int32_t ssr_read_coeffs_from_file()
+{
+ FILE *flt1r;
+ FILE *flt2r;
+ FILE *flt3r;
+ FILE *flt4r;
+ FILE *flt1i;
+ FILE *flt2i;
+ FILE *flt3i;
+ FILE *flt4i;
+ int i;
+
+ if ( (flt1r = fopen(SURROUND_FILE_1R, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter co-efficient "
+ "file %s", __func__, SURROUND_FILE_1R);
+ return -EINVAL;
+ }
+
+ if ( (flt2r = fopen(SURROUND_FILE_2R, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_2R);
+ return -EINVAL;
+ }
+
+ if ( (flt3r = fopen(SURROUND_FILE_3R, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_3R);
+ return -EINVAL;
+ }
+
+ if ( (flt4r = fopen(SURROUND_FILE_4R, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_4R);
+ return -EINVAL;
+ }
+
+ if ( (flt1i = fopen(SURROUND_FILE_1I, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_1I);
+ return -EINVAL;
+ }
+
+ if ( (flt2i = fopen(SURROUND_FILE_2I, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_2I);
+ return -EINVAL;
+ }
+
+ if ( (flt3i = fopen(SURROUND_FILE_3I, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_3I);
+ return -EINVAL;
+ }
+
+ if ( (flt4i = fopen(SURROUND_FILE_4I, "rb")) == NULL ) {
+ ALOGE("%s: Cannot open filter "
+ "co-efficient file %s", __func__, SURROUND_FILE_4I);
+ return -EINVAL;
+ }
+ ALOGV("%s: readCoeffsFromFile all filter "
+ "files opened", __func__);
+
+ for (i=0; i<COEFF_ARRAY_SIZE; i++) {
+ ssrmod.real_coeffs[i] = (Word16 *)calloc(FILT_SIZE, sizeof(Word16));
+ }
+ for (i=0; i<COEFF_ARRAY_SIZE; i++) {
+ ssrmod.imag_coeffs[i] = (Word16 *)calloc(FILT_SIZE, sizeof(Word16));
+ }
+
+ /* Read real co-efficients */
+ if (NULL != ssrmod.real_coeffs[0]) {
+ fread(ssrmod.real_coeffs[0], sizeof(int16), FILT_SIZE, flt1r);
+ }
+ if (NULL != ssrmod.real_coeffs[0]) {
+ fread(ssrmod.real_coeffs[1], sizeof(int16), FILT_SIZE, flt2r);
+ }
+ if (NULL != ssrmod.real_coeffs[0]) {
+ fread(ssrmod.real_coeffs[2], sizeof(int16), FILT_SIZE, flt3r);
+ }
+ if (NULL != ssrmod.real_coeffs[0]) {
+ fread(ssrmod.real_coeffs[3], sizeof(int16), FILT_SIZE, flt4r);
+ }
+
+ /* read imaginary co-efficients */
+ if (NULL != ssrmod.imag_coeffs[0]) {
+ fread(ssrmod.imag_coeffs[0], sizeof(int16), FILT_SIZE, flt1i);
+ }
+ if (NULL != ssrmod.imag_coeffs[0]) {
+ fread(ssrmod.imag_coeffs[1], sizeof(int16), FILT_SIZE, flt2i);
+ }
+ if (NULL != ssrmod.imag_coeffs[0]) {
+ fread(ssrmod.imag_coeffs[2], sizeof(int16), FILT_SIZE, flt3i);
+ }
+ if (NULL != ssrmod.imag_coeffs[0]) {
+ fread(ssrmod.imag_coeffs[3], sizeof(int16), FILT_SIZE, flt4i);
+ }
+
+ fclose(flt1r);
+ fclose(flt2r);
+ fclose(flt3r);
+ fclose(flt4r);
+ fclose(flt1i);
+ fclose(flt2i);
+ fclose(flt3i);
+ fclose(flt4i);
+
+ return 0;
+}
+
+static int32_t ssr_init_surround_sound_lib(unsigned long buffersize)
+{
+ /* sub_woofer channel assignment: default as first
+ microphone input channel */
+ int sub_woofer = 0;
+ /* frequency upper bound for sub_woofer:
+ frequency=(low_freq-1)/FFT_SIZE*samplingRate, default as 4 */
+ int low_freq = 4;
+ /* frequency upper bound for spatial processing:
+ frequency=(high_freq-1)/FFT_SIZE*samplingRate, default as 100 */
+ int high_freq = 100;
+ int i, ret = 0;
+
+ ssrmod.surround_input_bufferIdx = 0;
+ ssrmod.surround_output_bufferIdx = 0;
+
+ if ( ssrmod.surround_obj ) {
+ ALOGE("%s: ola filter library is already initialized", __func__);
+ return 0;
+ }
+
+ /* Allocate memory for input buffer */
+ ssrmod.surround_input_buffer = (Word16 *) calloc(2 * SSR_INPUT_FRAME_SIZE,
+ sizeof(Word16));
+ if ( !ssrmod.surround_input_buffer ) {
+ ALOGE("%s: Memory allocation failure. Not able to allocate "
+ "memory for surroundInputBuffer", __func__);
+ goto init_fail;
+ }
+
+ /* Allocate memory for output buffer */
+ ssrmod.surround_output_buffer = (Word16 *) calloc(2 * SSR_OUTPUT_FRAME_SIZE,
+ sizeof(Word16));
+ if ( !ssrmod.surround_output_buffer ) {
+ ALOGE("%s: Memory allocation failure. Not able to "
+ "allocate memory for surroundOutputBuffer", __func__);
+ goto init_fail;
+ }
+
+ /* Allocate memory for real and imag coeffs array */
+ ssrmod.real_coeffs = (Word16 **) calloc(COEFF_ARRAY_SIZE, sizeof(Word16 *));
+ if ( !ssrmod.real_coeffs ) {
+ ALOGE("%s: Memory allocation failure during real "
+ "Coefficient array", __func__);
+ goto init_fail;
+ }
+
+ ssrmod.imag_coeffs = (Word16 **) calloc(COEFF_ARRAY_SIZE, sizeof(Word16 *));
+ if ( !ssrmod.imag_coeffs ) {
+ ALOGE("%s: Memory allocation failure during imaginary "
+ "Coefficient array", __func__);
+ goto init_fail;
+ }
+
+ if( ssr_read_coeffs_from_file() != 0) {
+ ALOGE("%s: Error while loading coeffs from file", __func__);
+ goto init_fail;
+ }
+
+ ssrmod.surround_filters_handle = dlopen(LIB_SURROUND_PROC, RTLD_NOW);
+ if (ssrmod.surround_filters_handle == NULL) {
+ ALOGE("%s: DLOPEN failed for %s", __func__, LIB_SURROUND_PROC);
+ } else {
+ ALOGV("%s: DLOPEN successful for %s", __func__, LIB_SURROUND_PROC);
+ ssrmod.surround_filters_init = (surround_filters_init_t)
+ dlsym(ssrmod.surround_filters_handle, "surround_filters_init");
+
+ ssrmod.surround_filters_release = (surround_filters_release_t)
+ dlsym(ssrmod.surround_filters_handle, "surround_filters_release");
+
+ ssrmod.surround_filters_set_channel_map = (surround_filters_set_channel_map_t)
+ dlsym(ssrmod.surround_filters_handle, "surround_filters_set_channel_map");
+
+ ssrmod.surround_filters_intl_process = (surround_filters_intl_process_t)
+ dlsym(ssrmod.surround_filters_handle, "surround_filters_intl_process");
+
+ if (!ssrmod.surround_filters_init ||
+ !ssrmod.surround_filters_release ||
+ !ssrmod.surround_filters_set_channel_map ||
+ !ssrmod.surround_filters_intl_process){
+ ALOGW("%s: Could not find the one of the symbols from %s",
+ __func__, LIB_SURROUND_PROC);
+ goto init_fail;
+ }
+ }
+
+ /* calculate the size of data to allocate for surround_obj */
+ ret = ssrmod.surround_filters_init(NULL,
+ 6, // Num output channel
+ 4, // Num input channel
+ ssrmod.real_coeffs, // Coeffs hardcoded in header
+ ssrmod.imag_coeffs, // Coeffs hardcoded in header
+ sub_woofer,
+ low_freq,
+ high_freq,
+ NULL);
+
+ if ( ret > 0 ) {
+ ALOGV("%s: Allocating surroundObj size is %d", __func__, ret);
+ ssrmod.surround_obj = (void *)malloc(ret);
+ memset(ssrmod.surround_obj,0,ret);
+ if (NULL != ssrmod.surround_obj) {
+ /* initialize after allocating the memory for surround_obj */
+ ret = ssrmod.surround_filters_init(ssrmod.surround_obj,
+ 6,
+ 4,
+ ssrmod.real_coeffs,
+ ssrmod.imag_coeffs,
+ sub_woofer,
+ low_freq,
+ high_freq,
+ NULL);
+ if (0 != ret) {
+ ALOGE("%s: surround_filters_init failed with ret:%d",__func__, ret);
+ ssrmod.surround_filters_release(ssrmod.surround_obj);
+ goto init_fail;
+ }
+ } else {
+ ALOGE("%s: Allocationg surround_obj failed", __func__);
+ goto init_fail;
+ }
+ } else {
+ ALOGE("%s: surround_filters_init(surround_obj=Null) "
+ "failed with ret: %d", __func__, ret);
+ goto init_fail;
+ }
+
+ (void) ssrmod.surround_filters_set_channel_map(ssrmod.surround_obj, chan_map);
+
+ return 0;
+
+init_fail:
+ if (ssrmod.surround_obj) {
+ free(ssrmod.surround_obj);
+ ssrmod.surround_obj = NULL;
+ }
+ if (ssrmod.surround_output_buffer) {
+ free(ssrmod.surround_output_buffer);
+ ssrmod.surround_output_buffer = NULL;
+ }
+ if (ssrmod.surround_input_buffer) {
+ free(ssrmod.surround_input_buffer);
+ ssrmod.surround_input_buffer = NULL;
+ }
+ if (ssrmod.real_coeffs){
+ for (i =0; i<COEFF_ARRAY_SIZE; i++ ) {
+ if (ssrmod.real_coeffs[i]) {
+ free(ssrmod.real_coeffs[i]);
+ ssrmod.real_coeffs[i] = NULL;
+ }
+ }
+ free(ssrmod.real_coeffs);
+ ssrmod.real_coeffs = NULL;
+ }
+ if (ssrmod.imag_coeffs){
+ for (i =0; i<COEFF_ARRAY_SIZE; i++ ) {
+ if (ssrmod.imag_coeffs[i]) {
+ free(ssrmod.imag_coeffs[i]);
+ ssrmod.imag_coeffs[i] = NULL;
+ }
+ }
+ free(ssrmod.imag_coeffs);
+ ssrmod.imag_coeffs = NULL;
+ }
+
+ return -ENOMEM;
+}
+
+int32_t audio_extn_ssr_update_enabled(struct audio_device *adev)
+{
+ char ssr_enabled[PROPERTY_VALUE_MAX] = "false";
+
+ property_get("ro.qc.sdk.audio.ssr",ssr_enabled,"0");
+ if (!strncmp("true", ssr_enabled, 4)) {
+ ALOGD("%s: surround sound recording is supported", __func__);
+ ssrmod.is_ssr_enabled = true;
+ } else {
+ ALOGD("%s: surround sound recording is not supported", __func__);
+ ssrmod.is_ssr_enabled = false;
+ }
+ return 0;
+}
+
+bool audio_extn_ssr_get_enabled()
+{
+ ALOGV("%s: is_ssr_enabled:%d", __func__, ssrmod.is_ssr_enabled);
+ return (ssrmod.is_ssr_enabled ? true: false);
+}
+
+int32_t audio_extn_ssr_init(struct audio_device *adev,
+ struct stream_in *in)
+{
+ uint32_t ret;
+ char c_multi_ch_dump[128] = {0};
+ uint32_t buffer_size;
+
+ ALOGD("%s: ssr case ", __func__);
+ in->config.channels = SSR_CHANNEL_COUNT;
+ in->config.period_size = SSR_PERIOD_SIZE;
+ in->config.period_count = SSR_PERIOD_COUNT;
+
+ buffer_size = (SSR_PERIOD_SIZE)*(SSR_PERIOD_COUNT);
+ ALOGD("%s: buffer_size: %d", __func__, buffer_size);
+
+ ret = ssr_init_surround_sound_lib(buffer_size);
+ if (0 != ret) {
+ ALOGE("%s: initSurroundSoundLibrary failed: %d "
+ "handle->bufferSize:%d", __func__, ret, buffer_size);
+ return ret;
+ }
+
+ property_get("ssr.pcmdump",c_multi_ch_dump,"0");
+ if (0 == strncmp("true",c_multi_ch_dump, sizeof("ssr.dump-pcm"))) {
+ /* Remember to change file system permission of data(e.g. chmod 777 data/),
+ otherwise, fopen may fail */
+ if ( !ssrmod.fp_4ch)
+ ssrmod.fp_4ch = fopen("/data/media/0/4ch_ssr.pcm", "wb");
+ if ( !ssrmod.fp_6ch)
+ ssrmod.fp_6ch = fopen("/data/media/0/6ch_ssr.pcm", "wb");
+ if ((!ssrmod.fp_4ch) || (!ssrmod.fp_6ch))
+ ALOGE("%s: mfp_4ch or mfp_6ch open failed: mfp_4ch:%p mfp_6ch:%p",
+ __func__, ssrmod.fp_4ch, ssrmod.fp_6ch);
+ }
+
+ return 0;
+}
+
+int32_t audio_extn_ssr_deinit()
+{
+ int i;
+
+ if (ssrmod.surround_obj) {
+ ALOGD("%s: entry", __func__);
+ ssrmod.surround_filters_release(ssrmod.surround_obj);
+ if (ssrmod.surround_obj)
+ free(ssrmod.surround_obj);
+ ssrmod.surround_obj = NULL;
+ if (ssrmod.real_coeffs){
+ for (i =0; i<COEFF_ARRAY_SIZE; i++ ) {
+ if (ssrmod.real_coeffs[i]) {
+ free(ssrmod.real_coeffs[i]);
+ ssrmod.real_coeffs[i] = NULL;
+ }
+ }
+ free(ssrmod.real_coeffs);
+ ssrmod.real_coeffs = NULL;
+ }
+ if (ssrmod.imag_coeffs){
+ for (i =0; i<COEFF_ARRAY_SIZE; i++ ) {
+ if (ssrmod.imag_coeffs[i]) {
+ free(ssrmod.imag_coeffs[i]);
+ ssrmod.imag_coeffs[i] = NULL;
+ }
+ }
+ free(ssrmod.imag_coeffs);
+ ssrmod.imag_coeffs = NULL;
+ }
+ if (ssrmod.surround_output_buffer){
+ free(ssrmod.surround_output_buffer);
+ ssrmod.surround_output_buffer = NULL;
+ }
+ if (ssrmod.surround_input_buffer) {
+ free(ssrmod.surround_input_buffer);
+ ssrmod.surround_input_buffer = NULL;
+ }
+
+ if ( ssrmod.fp_4ch ) fclose(ssrmod.fp_4ch);
+ if ( ssrmod.fp_6ch ) fclose(ssrmod.fp_6ch);
+ }
+
+ if(ssrmod.surround_filters_handle)
+ {
+ dlclose(ssrmod.surround_filters_handle);
+ ssrmod.surround_filters_handle = NULL;
+ }
+ ALOGD("%s: exit", __func__);
+
+ return 0;
+}
+
+int32_t audio_extn_ssr_read(struct audio_stream_in *stream,
+ void *buffer, size_t bytes)
+{
+ int processed = 0;
+ int processed_pending;
+ void *buffer_start = buffer;
+ unsigned period_bytes;
+ unsigned period_samples;
+ int read_pending, n;
+ size_t read_bytes = 0;
+ int samples = bytes >> 1;
+
+ struct stream_in *in = (struct stream_in *)stream;
+ struct audio_device *adev = in->dev;
+
+ period_bytes = in->config.period_size;
+ ALOGD("%s: period_size: %d", __func__, in->config.period_size);
+ period_samples = period_bytes >> 1;
+
+ if (!ssrmod.surround_obj)
+ return -ENOMEM;
+
+ do {
+ if (ssrmod.surround_output_bufferIdx > 0) {
+ ALOGV("%s: copy processed output "
+ "to buffer, surround_output_bufferIdx = %d",
+ __func__, ssrmod.surround_output_bufferIdx);
+ /* Copy processed output to buffer */
+ processed_pending = ssrmod.surround_output_bufferIdx;
+ if (processed_pending > (samples - processed)) {
+ processed_pending = (samples - processed);
+ }
+ memcpy(buffer, ssrmod.surround_output_buffer, processed_pending * sizeof(Word16));
+ buffer = (char*)buffer + processed_pending * sizeof(Word16);
+ processed += processed_pending;
+ if (ssrmod.surround_output_bufferIdx > processed_pending) {
+ /* Shift leftover samples to beginning of the buffer */
+ memcpy(&ssrmod.surround_output_buffer[0],
+ &ssrmod.surround_output_buffer[processed_pending],
+ (ssrmod.surround_output_bufferIdx - processed_pending) * sizeof(Word16));
+ }
+ ssrmod.surround_output_bufferIdx -= processed_pending;
+ }
+
+ if (processed >= samples) {
+ ALOGV("%s: done processing buffer, "
+ "processed = %d", __func__, processed);
+ /* Done processing this buffer */
+ break;
+ }
+
+ /* Fill input buffer until there is enough to process */
+ read_pending = SSR_INPUT_FRAME_SIZE - ssrmod.surround_input_bufferIdx;
+ read_bytes = ssrmod.surround_input_bufferIdx;
+ while (in->pcm && read_pending > 0) {
+ n = pcm_read(in->pcm, &ssrmod.surround_input_buffer[read_bytes],
+ period_bytes);
+ ALOGV("%s: pcm_read() returned n = %d buffer:%p size:%d", __func__,
+ n, &ssrmod.surround_input_buffer[read_bytes], period_bytes);
+ if (n && n != -EAGAIN) {
+ /* Recovery part of pcm_read. TODO:split recovery */
+ return (ssize_t)n;
+ }
+ else if (n < 0) {
+ /* Recovery is part of pcm_write. TODO split is later */
+ return (ssize_t)n;
+ }
+ else {
+ read_pending -= period_samples;
+ read_bytes += period_samples;
+ }
+ }
+
+
+ if (ssrmod.fp_4ch) {
+ fwrite( ssrmod.surround_input_buffer, 1,
+ SSR_INPUT_FRAME_SIZE * sizeof(Word16), ssrmod.fp_4ch);
+ }
+
+ /* apply ssr libs to conver 4ch to 6ch */
+ ssrmod.surround_filters_intl_process(ssrmod.surround_obj,
+ &ssrmod.surround_output_buffer[ssrmod.surround_output_bufferIdx],
+ (Word16 *)ssrmod.surround_input_buffer);
+
+ /* Shift leftover samples to beginning of input buffer */
+ if (read_pending < 0) {
+ memcpy(&ssrmod.surround_input_buffer[0],
+ &ssrmod.surround_input_buffer[SSR_INPUT_FRAME_SIZE],
+ (-read_pending) * sizeof(Word16));
+ }
+ ssrmod.surround_input_bufferIdx = -read_pending;
+
+ if (ssrmod.fp_6ch) {
+ fwrite( &ssrmod.surround_output_buffer[ssrmod.surround_output_bufferIdx],
+ 1, SSR_OUTPUT_FRAME_SIZE * sizeof(Word16), ssrmod.fp_6ch);
+ }
+
+ ssrmod.surround_output_bufferIdx += SSR_OUTPUT_FRAME_SIZE;
+ ALOGV("%s: do_while loop: processed=%d, samples=%d\n", __func__, processed, samples);
+ } while (in->pcm && processed < samples);
+ read_bytes = processed * sizeof(Word16);
+ buffer = buffer_start;
+
+ return 0;
+}
+
+void audio_extn_ssr_get_parameters(struct str_parms *query,
+ struct str_parms *reply)
+{
+ int ret, val;
+ char value[32]={0};
+
+ ret = str_parms_get_str(query, AUDIO_PARAMETER_KEY_SSR, value, sizeof(value));
+
+ if (ret >= 0) {
+ memcpy(value, "true", 4);
+ str_parms_add_str(reply, AUDIO_PARAMETER_KEY_SSR, value);
+ }
+}
+#endif /* SSR_ENABLED */
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index a101cfb..abda10c 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -774,7 +774,7 @@
{
if (format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
- if ((channel_count < 1) || (channel_count > 2)) return -EINVAL;
+ if ((channel_count < 1) || (channel_count > 6)) return -EINVAL;
switch (sample_rate) {
case 8000:
@@ -1223,7 +1223,10 @@
}
if (in->pcm) {
- ret = pcm_read(in->pcm, buffer, bytes);
+ if (audio_extn_ssr_get_enabled() && popcount(in->channel_mask) == 6)
+ ret = audio_extn_ssr_read(stream, buffer, bytes);
+ else
+ ret = pcm_read(in->pcm, buffer, bytes);
}
/*
@@ -1610,14 +1613,19 @@
/* Update config params with the requested sample rate and channels */
in->usecase = USECASE_AUDIO_RECORD;
in->config = pcm_config_audio_capture;
- in->config.channels = channel_count;
in->config.rate = config->sample_rate;
- frame_size = audio_stream_frame_size((struct audio_stream *)in);
- buffer_size = get_input_buffer_size(config->sample_rate,
- config->format,
- channel_count);
- in->config.period_size = buffer_size / frame_size;
+ if (audio_extn_ssr_get_enabled()&& channel_count == 6) {
+ if(audio_extn_ssr_init(adev, in))
+ ALOGE("%s: audio_extn_ssr_init failed", __func__);
+ } else {
+ in->config.channels = channel_count;
+ frame_size = audio_stream_frame_size((struct audio_stream *)in);
+ buffer_size = get_input_buffer_size(config->sample_rate,
+ config->format,
+ channel_count);
+ in->config.period_size = buffer_size / frame_size;
+ }
*stream_in = &in->stream;
ALOGV("%s: exit", __func__);
@@ -1632,9 +1640,13 @@
static void adev_close_input_stream(struct audio_hw_device *dev,
struct audio_stream_in *stream)
{
+ struct stream_in *in = (struct stream_in *)stream;
ALOGV("%s", __func__);
in_standby(&stream->common);
+ if (audio_extn_ssr_get_enabled() && (popcount(in->channel_mask) == 6)) {
+ audio_extn_ssr_deinit();
+ }
free(stream);
return;
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index bb732f6..dc3857b 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -171,6 +171,7 @@
[SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
[SND_DEVICE_IN_CAPTURE_FM] = "capture-fm",
[SND_DEVICE_IN_AANC_HANDSET_MIC] = "aanc-handset-mic",
+ [SND_DEVICE_IN_QUAD_MIC] = "quad-mic",
};
/* ACDB IDs (audio DSP path configuration IDs) for each sound device */
@@ -225,6 +226,7 @@
[SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
[SND_DEVICE_IN_CAPTURE_FM] = 0,
[SND_DEVICE_IN_AANC_HANDSET_MIC] = 104,
+ [SND_DEVICE_IN_QUAD_MIC] = 46,
/* TODO: Update with proper acdb ids */
[SND_DEVICE_IN_VOICE_REC_DMIC] = 62,
[SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 6,
@@ -357,6 +359,9 @@
/* init usb */
audio_extn_usb_init(adev);
+ /* Read one time ssr property */
+ audio_extn_ssr_update_enabled(adev);
+
return my_data;
}
@@ -792,7 +797,10 @@
!(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
!(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
- snd_device = SND_DEVICE_IN_HANDSET_MIC;
+ if (audio_extn_ssr_get_enabled() && channel_count == 6)
+ snd_device = SND_DEVICE_IN_QUAD_MIC;
+ else
+ snd_device = SND_DEVICE_IN_HANDSET_MIC;
} else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
snd_device = SND_DEVICE_IN_SPEAKER_MIC;
} else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
diff --git a/hal/msm8974/platform.h b/hal/msm8974/platform.h
index d34aa41..bc1e784 100644
--- a/hal/msm8974/platform.h
+++ b/hal/msm8974/platform.h
@@ -104,6 +104,7 @@
SND_DEVICE_IN_USB_HEADSET_MIC,
SND_DEVICE_IN_CAPTURE_FM,
SND_DEVICE_IN_AANC_HANDSET_MIC,
+ SND_DEVICE_IN_QUAD_MIC,
SND_DEVICE_IN_END,
SND_DEVICE_MAX = SND_DEVICE_IN_END,