merge in klp-release history after reset to klp-dev
diff --git a/Android.mk b/Android.mk
index 1c5c5b3..1228876 100644
--- a/Android.mk
+++ b/Android.mk
@@ -7,6 +7,7 @@
else
include $(MY_LOCAL_PATH)/hal/Android.mk
include $(MY_LOCAL_PATH)/voice_processing/Android.mk
+include $(MY_LOCAL_PATH)/visualizer/Android.mk
endif
endif
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index 4f92ea3..c2997c6 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -29,6 +29,7 @@
#include <sys/time.h>
#include <stdlib.h>
#include <math.h>
+#include <dlfcn.h>
#include <sys/resource.h>
#include <sys/prctl.h>
@@ -797,6 +798,10 @@
return -EINVAL;
}
+ if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD &&
+ adev->visualizer_stop_output != NULL)
+ adev->visualizer_stop_output(out->handle);
+
/* 1. Get and set stream specific mixer controls */
disable_audio_route(adev, uc_info, true);
@@ -863,6 +868,9 @@
}
if (out->offload_callback)
compress_nonblock(out->compr, out->non_blocking);
+
+ if (adev->visualizer_start_output != NULL)
+ adev->visualizer_start_output(out->handle);
}
ALOGV("%s: exit", __func__);
return 0;
@@ -1742,6 +1750,7 @@
out->sample_rate = config->sample_rate;
out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
+ out->handle = handle;
/* Init use case and pcm_config */
if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT &&
@@ -2263,6 +2272,22 @@
*device = NULL;
return -EINVAL;
}
+
+ if (access(VISUALIZER_LIBRARY_PATH, R_OK) == 0) {
+ adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW);
+ if (adev->visualizer_lib == NULL) {
+ ALOGE("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH);
+ } else {
+ ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH);
+ adev->visualizer_start_output =
+ (int (*)(audio_io_handle_t))dlsym(adev->visualizer_lib,
+ "visualizer_hal_start_output");
+ adev->visualizer_stop_output =
+ (int (*)(audio_io_handle_t))dlsym(adev->visualizer_lib,
+ "visualizer_hal_stop_output");
+ }
+ }
+
*device = &adev->device.common;
ALOGV("%s: exit", __func__);
diff --git a/hal/audio_hw.h b/hal/audio_hw.h
index 2c7fffd..717c0a6 100644
--- a/hal/audio_hw.h
+++ b/hal/audio_hw.h
@@ -25,6 +25,8 @@
#include <audio_route/audio_route.h>
+#define VISUALIZER_LIBRARY_PATH "/system/lib/soundfx/libqcomvisualizer.so"
+
/* Flags used to initialize acdb_settings variable that goes to ACDB library */
#define DMIC_FLAG 0x00000002
#define TTY_MODE_OFF 0x00000010
@@ -110,6 +112,7 @@
audio_channel_mask_t supported_channel_masks[MAX_SUPPORTED_CHANNEL_MASKS + 1];
bool muted;
uint64_t written; /* total frames written, not cleared when entering standby */
+ audio_io_handle_t handle;
int non_blocking;
int playback_started;
@@ -187,6 +190,10 @@
bool speaker_lr_swap;
void *platform;
+
+ void *visualizer_lib;
+ int (*visualizer_start_output)(audio_io_handle_t);
+ int (*visualizer_stop_output)(audio_io_handle_t);
};
/*
diff --git a/visualizer/Android.mk b/visualizer/Android.mk
new file mode 100644
index 0000000..3c92044
--- /dev/null
+++ b/visualizer/Android.mk
@@ -0,0 +1,36 @@
+# Copyright 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ offload_visualizer.c
+
+LOCAL_CFLAGS+= -O2 -fvisibility=hidden
+
+LOCAL_SHARED_LIBRARIES := \
+ libcutils \
+ liblog \
+ libtinyalsa
+
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/soundfx
+LOCAL_MODULE:= libqcomvisualizer
+
+LOCAL_C_INCLUDES := \
+ external/tinyalsa/include \
+ $(call include-path-for, audio-effects)
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/visualizer/MODULE_LICENSE_APACHE2 b/visualizer/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/visualizer/MODULE_LICENSE_APACHE2
diff --git a/visualizer/NOTICE b/visualizer/NOTICE
new file mode 100644
index 0000000..ad6ed94
--- /dev/null
+++ b/visualizer/NOTICE
@@ -0,0 +1,190 @@
+
+ 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.
+
+ 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.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
diff --git a/visualizer/offload_visualizer.c b/visualizer/offload_visualizer.c
new file mode 100644
index 0000000..75ce4a5
--- /dev/null
+++ b/visualizer/offload_visualizer.c
@@ -0,0 +1,1121 @@
+/*
+ * 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 "offload_visualizer"
+/*#define LOG_NDEBUG 0*/
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/prctl.h>
+
+#include <cutils/list.h>
+#include <cutils/log.h>
+#include <system/thread_defs.h>
+#include <tinyalsa/asoundlib.h>
+#include <audio_effects/effect_visualizer.h>
+
+
+enum {
+ EFFECT_STATE_UNINITIALIZED,
+ EFFECT_STATE_INITIALIZED,
+ EFFECT_STATE_ACTIVE,
+};
+
+typedef struct effect_context_s effect_context_t;
+
+/* effect specific operations. Only the init() and process() operations must be defined.
+ * Others are optional.
+ */
+typedef struct effect_ops_s {
+ int (*init)(effect_context_t *context);
+ int (*release)(effect_context_t *context);
+ int (*reset)(effect_context_t *context);
+ int (*enable)(effect_context_t *context);
+ int (*disable)(effect_context_t *context);
+ int (*process)(effect_context_t *context, audio_buffer_t *in, audio_buffer_t *out);
+ int (*set_parameter)(effect_context_t *context, effect_param_t *param, uint32_t size);
+ int (*get_parameter)(effect_context_t *context, effect_param_t *param, uint32_t *size);
+ int (*command)(effect_context_t *context, uint32_t cmdCode, uint32_t cmdSize,
+ void *pCmdData, uint32_t *replySize, void *pReplyData);
+} effect_ops_t;
+
+struct effect_context_s {
+ const struct effect_interface_s *itfe;
+ struct listnode effects_list_node; /* node in created_effects_list */
+ struct listnode output_node; /* node in output_context_t.effects_list */
+ effect_config_t config;
+ const effect_descriptor_t *desc;
+ audio_io_handle_t out_handle; /* io handle of the output the effect is attached to */
+ uint32_t state;
+ bool offload_enabled; /* when offload is enabled we process VISUALIZER_CMD_CAPTURE command.
+ Otherwise non offloaded visualizer has already processed the command
+ and we must not overwrite the reply. */
+ effect_ops_t ops;
+};
+
+typedef struct output_context_s {
+ struct listnode outputs_list_node; /* node in active_outputs_list */
+ audio_io_handle_t handle; /* io handle */
+ struct listnode effects_list; /* list of effects attached to this output */
+} output_context_t;
+
+
+/* maximum time since last capture buffer update before resetting capture buffer. This means
+ that the framework has stopped playing audio and we must start returning silence */
+#define MAX_STALL_TIME_MS 1000
+
+#define CAPTURE_BUF_SIZE 65536 /* "64k should be enough for everyone" */
+
+
+typedef struct visualizer_context_s {
+ effect_context_t common;
+
+ uint32_t capture_idx;
+ uint32_t capture_size;
+ uint32_t scaling_mode;
+ uint32_t last_capture_idx;
+ uint32_t latency;
+ struct timespec buffer_update_time;
+ uint8_t capture_buf[CAPTURE_BUF_SIZE];
+} visualizer_context_t;
+
+
+extern const struct effect_interface_s effect_interface;
+
+/* Offload visualizer UUID: 7a8044a0-1a71-11e3-a184-0002a5d5c51b */
+const effect_descriptor_t visualizer_descriptor = {
+ {0xe46b26a0, 0xdddd, 0x11db, 0x8afd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ {0x7a8044a0, 0x1a71, 0x11e3, 0xa184, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
+ EFFECT_CONTROL_API_VERSION,
+ (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_HW_ACC_TUNNEL ),
+ 0, /* TODO */
+ 1,
+ "QCOM MSM offload visualizer",
+ "The Android Open Source Project",
+};
+
+const effect_descriptor_t *descriptors[] = {
+ &visualizer_descriptor,
+ NULL,
+};
+
+
+pthread_once_t once = PTHREAD_ONCE_INIT;
+int init_status;
+
+/* list of created effects. Updated by visualizer_hal_start_output()
+ * and visualizer_hal_stop_output() */
+struct listnode created_effects_list;
+/* list of active output streams. Updated by visualizer_hal_start_output()
+ * and visualizer_hal_stop_output() */
+struct listnode active_outputs_list;
+
+/* thread capturing PCM from Proxy port and calling the process function on each enabled effect
+ * attached to an active output stream */
+pthread_t capture_thread;
+/* lock must be held when modifying or accessing created_effects_list or active_outputs_list */
+pthread_mutex_t lock;
+/* thread_lock must be held when starting or stopping the capture thread.
+ * Locking order: thread_lock -> lock */
+pthread_mutex_t thread_lock;
+/* cond is signaled when an output is started or stopped or an effect is enabled or disable: the
+ * capture thread will reevaluate the capture and effect rocess conditions. */
+pthread_cond_t cond;
+/* true when requesting the capture thread to exit */
+bool exit_thread;
+/* 0 if the capture thread was created successfully */
+int thread_status;
+
+
+#define DSP_OUTPUT_LATENCY_MS 0 /* Fudge factor for latency after capture point in audio DSP */
+
+/* Retry for delay for mixer open */
+#define RETRY_NUMBER 10
+#define RETRY_US 500000
+
+#define MIXER_CARD 0
+#define SOUND_CARD 0
+#define CAPTURE_DEVICE 8
+
+/* Proxy port supports only MMAP read and those fixed parameters*/
+#define AUDIO_CAPTURE_CHANNEL_COUNT 2
+#define AUDIO_CAPTURE_SMP_RATE 48000
+#define AUDIO_CAPTURE_PERIOD_SIZE (768)
+#define AUDIO_CAPTURE_PERIOD_COUNT 32
+
+struct pcm_config pcm_config_capture = {
+ .channels = AUDIO_CAPTURE_CHANNEL_COUNT,
+ .rate = AUDIO_CAPTURE_SMP_RATE,
+ .period_size = AUDIO_CAPTURE_PERIOD_SIZE,
+ .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
+ .format = PCM_FORMAT_S16_LE,
+ .start_threshold = AUDIO_CAPTURE_PERIOD_SIZE / 4,
+ .stop_threshold = INT_MAX,
+ .avail_min = AUDIO_CAPTURE_PERIOD_SIZE / 4,
+};
+
+
+/*
+ * Local functions
+ */
+
+static void init_once() {
+ list_init(&created_effects_list);
+ list_init(&active_outputs_list);
+
+ pthread_mutex_init(&lock, NULL);
+ pthread_mutex_init(&thread_lock, NULL);
+ pthread_cond_init(&cond, NULL);
+ exit_thread = false;
+ thread_status = -1;
+
+ init_status = 0;
+}
+
+int lib_init() {
+ pthread_once(&once, init_once);
+ return init_status;
+}
+
+bool effect_exists(effect_context_t *context) {
+ struct listnode *node;
+
+ list_for_each(node, &created_effects_list) {
+ effect_context_t *fx_ctxt = node_to_item(node,
+ effect_context_t,
+ effects_list_node);
+ if (fx_ctxt == context) {
+ return true;
+ }
+ }
+ return false;
+}
+
+output_context_t *get_output(audio_io_handle_t output) {
+ struct listnode *node;
+
+ list_for_each(node, &active_outputs_list) {
+ output_context_t *out_ctxt = node_to_item(node,
+ output_context_t,
+ outputs_list_node);
+ if (out_ctxt->handle == output) {
+ return out_ctxt;
+ }
+ }
+ return NULL;
+}
+
+void add_effect_to_output(output_context_t * output, effect_context_t *context) {
+ struct listnode *fx_node;
+
+ list_for_each(fx_node, &output->effects_list) {
+ effect_context_t *fx_ctxt = node_to_item(fx_node,
+ effect_context_t,
+ output_node);
+ if (fx_ctxt == context)
+ return;
+ }
+ list_add_tail(&output->effects_list, &context->output_node);
+}
+
+void remove_effect_from_output(output_context_t * output, effect_context_t *context) {
+ struct listnode *fx_node;
+
+ list_for_each(fx_node, &output->effects_list) {
+ effect_context_t *fx_ctxt = node_to_item(fx_node,
+ effect_context_t,
+ output_node);
+ if (fx_ctxt == context) {
+ list_remove(&context->output_node);
+ return;
+ }
+ }
+}
+
+bool effects_enabled() {
+ struct listnode *out_node;
+
+ list_for_each(out_node, &active_outputs_list) {
+ struct listnode *fx_node;
+ output_context_t *out_ctxt = node_to_item(out_node,
+ output_context_t,
+ outputs_list_node);
+
+ list_for_each(fx_node, &out_ctxt->effects_list) {
+ effect_context_t *fx_ctxt = node_to_item(fx_node,
+ effect_context_t,
+ output_node);
+ if (fx_ctxt->state == EFFECT_STATE_ACTIVE)
+ return true;
+ }
+ }
+ return false;
+}
+
+int configure_proxy_capture(struct mixer *mixer, int value) {
+ const char *proxy_ctl_name = "AFE_PCM_RX Audio Mixer MultiMedia4";
+ struct mixer_ctl *ctl;
+
+ ctl = mixer_get_ctl_by_name(mixer, proxy_ctl_name);
+ if (ctl == NULL) {
+ ALOGW("%s: could not get %s ctl", __func__, proxy_ctl_name);
+ return -EINVAL;
+ }
+ if (mixer_ctl_set_value(ctl, 0, value) != 0)
+ ALOGW("%s: error setting value %d on %s ", __func__, value, proxy_ctl_name);
+
+ return 0;
+}
+
+
+void *capture_thread_loop(void *arg)
+{
+ int16_t data[AUDIO_CAPTURE_PERIOD_SIZE * AUDIO_CAPTURE_CHANNEL_COUNT * sizeof(int16_t)];
+ audio_buffer_t buf;
+ buf.frameCount = AUDIO_CAPTURE_PERIOD_SIZE;
+ buf.s16 = data;
+ bool capture_enabled = false;
+ struct mixer *mixer;
+ struct pcm *pcm = NULL;
+ int ret;
+ int retry_num = 0;
+
+ ALOGD("thread enter");
+
+ prctl(PR_SET_NAME, (unsigned long)"visualizer capture", 0, 0, 0);
+
+ pthread_mutex_lock(&lock);
+
+ mixer = mixer_open(MIXER_CARD);
+ while (mixer == NULL && retry_num < RETRY_NUMBER) {
+ usleep(RETRY_US);
+ mixer = mixer_open(MIXER_CARD);
+ retry_num++;
+ }
+ if (mixer == NULL) {
+ pthread_mutex_unlock(&lock);
+ return NULL;
+ }
+
+ for (;;) {
+ if (exit_thread) {
+ break;
+ }
+ if (effects_enabled()) {
+ if (!capture_enabled) {
+ ret = configure_proxy_capture(mixer, 1);
+ if (ret == 0) {
+ pcm = pcm_open(SOUND_CARD, CAPTURE_DEVICE,
+ PCM_IN|PCM_MMAP|PCM_NOIRQ, &pcm_config_capture);
+ if (pcm && !pcm_is_ready(pcm)) {
+ ALOGW("%s: %s", __func__, pcm_get_error(pcm));
+ pcm_close(pcm);
+ pcm = NULL;
+ configure_proxy_capture(mixer, 0);
+ } else {
+ capture_enabled = true;
+ ALOGD("%s: capture ENABLED", __func__);
+ }
+ }
+ }
+ } else {
+ if (capture_enabled) {
+ if (pcm != NULL)
+ pcm_close(pcm);
+ configure_proxy_capture(mixer, 0);
+ ALOGD("%s: capture DISABLED", __func__);
+ capture_enabled = false;
+ }
+ pthread_cond_wait(&cond, &lock);
+ }
+ if (!capture_enabled)
+ continue;
+
+ pthread_mutex_unlock(&lock);
+ ret = pcm_mmap_read(pcm, data, sizeof(data));
+ pthread_mutex_lock(&lock);
+
+ if (ret == 0) {
+ struct listnode *out_node;
+
+ list_for_each(out_node, &active_outputs_list) {
+ output_context_t *out_ctxt = node_to_item(out_node,
+ output_context_t,
+ outputs_list_node);
+ struct listnode *fx_node;
+
+ list_for_each(fx_node, &out_ctxt->effects_list) {
+ effect_context_t *fx_ctxt = node_to_item(fx_node,
+ effect_context_t,
+ output_node);
+ fx_ctxt->ops.process(fx_ctxt, &buf, &buf);
+ }
+ }
+ } else {
+ ALOGW("%s: read status %d %s", __func__, ret, pcm_get_error(pcm));
+ }
+ }
+
+ if (capture_enabled) {
+ if (pcm != NULL)
+ pcm_close(pcm);
+ configure_proxy_capture(mixer, 0);
+ }
+ mixer_close(mixer);
+ pthread_mutex_unlock(&lock);
+
+ ALOGD("thread exit");
+
+ return NULL;
+}
+
+/*
+ * Interface from audio HAL
+ */
+
+__attribute__ ((visibility ("default")))
+int visualizer_hal_start_output(audio_io_handle_t output) {
+ int ret;
+ struct listnode *node;
+
+ ALOGV("%s", __func__);
+
+ if (lib_init() != 0)
+ return init_status;
+
+ pthread_mutex_lock(&thread_lock);
+ pthread_mutex_lock(&lock);
+ if (get_output(output) != NULL) {
+ ALOGW("%s output already started", __func__);
+ ret = -ENOSYS;
+ goto exit;
+ }
+
+ output_context_t *out_ctxt = (output_context_t *)malloc(sizeof(output_context_t));
+ out_ctxt->handle = output;
+ list_init(&out_ctxt->effects_list);
+
+ list_for_each(node, &created_effects_list) {
+ effect_context_t *fx_ctxt = node_to_item(node,
+ effect_context_t,
+ effects_list_node);
+ if (fx_ctxt->out_handle == output) {
+ list_add_tail(&out_ctxt->effects_list, &fx_ctxt->output_node);
+ }
+ }
+ if (list_empty(&active_outputs_list)) {
+ exit_thread = false;
+ thread_status = pthread_create(&capture_thread, (const pthread_attr_t *) NULL,
+ capture_thread_loop, NULL);
+ }
+ list_add_tail(&active_outputs_list, &out_ctxt->outputs_list_node);
+ pthread_cond_signal(&cond);
+
+exit:
+ pthread_mutex_unlock(&lock);
+ pthread_mutex_unlock(&thread_lock);
+ return ret;
+}
+
+__attribute__ ((visibility ("default")))
+int visualizer_hal_stop_output(audio_io_handle_t output) {
+ int ret;
+ struct listnode *node;
+ output_context_t *out_ctxt;
+
+ ALOGV("%s", __func__);
+
+ if (lib_init() != 0)
+ return init_status;
+
+ pthread_mutex_lock(&thread_lock);
+ pthread_mutex_lock(&lock);
+
+ out_ctxt = get_output(output);
+ if (out_ctxt == NULL) {
+ ALOGW("%s output not started", __func__);
+ ret = -ENOSYS;
+ goto exit;
+ }
+
+ list_remove(&out_ctxt->outputs_list_node);
+ pthread_cond_signal(&cond);
+
+ if (list_empty(&active_outputs_list)) {
+ if (thread_status == 0) {
+ exit_thread = true;
+ pthread_cond_signal(&cond);
+ pthread_mutex_unlock(&lock);
+ pthread_join(capture_thread, (void **) NULL);
+ pthread_mutex_lock(&lock);
+ thread_status = -1;
+ }
+ }
+
+ free(out_ctxt);
+
+exit:
+ pthread_mutex_unlock(&lock);
+ pthread_mutex_unlock(&thread_lock);
+ return ret;
+}
+
+
+/*
+ * Effect operations
+ */
+
+int set_config(effect_context_t *context, effect_config_t *config)
+{
+ if (config->inputCfg.samplingRate != config->outputCfg.samplingRate) return -EINVAL;
+ if (config->inputCfg.channels != config->outputCfg.channels) return -EINVAL;
+ if (config->inputCfg.format != config->outputCfg.format) return -EINVAL;
+ if (config->inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) return -EINVAL;
+ if (config->outputCfg.accessMode != EFFECT_BUFFER_ACCESS_WRITE &&
+ config->outputCfg.accessMode != EFFECT_BUFFER_ACCESS_ACCUMULATE) return -EINVAL;
+ if (config->inputCfg.format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
+
+ context->config = *config;
+
+ if (context->ops.reset)
+ context->ops.reset(context);
+
+ return 0;
+}
+
+void get_config(effect_context_t *context, effect_config_t *config)
+{
+ *config = context->config;
+}
+
+
+/*
+ * Visualizer operations
+ */
+
+int visualizer_reset(effect_context_t *context)
+{
+ visualizer_context_t * visu_ctxt = (visualizer_context_t *)context;
+
+ visu_ctxt->capture_idx = 0;
+ visu_ctxt->last_capture_idx = 0;
+ visu_ctxt->buffer_update_time.tv_sec = 0;
+ visu_ctxt->latency = DSP_OUTPUT_LATENCY_MS;
+ memset(visu_ctxt->capture_buf, 0x80, CAPTURE_BUF_SIZE);
+ return 0;
+}
+
+int visualizer_init(effect_context_t *context)
+{
+ visualizer_context_t * visu_ctxt = (visualizer_context_t *)context;
+
+ context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
+ context->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
+ context->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+ context->config.inputCfg.samplingRate = 44100;
+ context->config.inputCfg.bufferProvider.getBuffer = NULL;
+ context->config.inputCfg.bufferProvider.releaseBuffer = NULL;
+ context->config.inputCfg.bufferProvider.cookie = NULL;
+ context->config.inputCfg.mask = EFFECT_CONFIG_ALL;
+ context->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
+ context->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
+ context->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
+ context->config.outputCfg.samplingRate = 44100;
+ context->config.outputCfg.bufferProvider.getBuffer = NULL;
+ context->config.outputCfg.bufferProvider.releaseBuffer = NULL;
+ context->config.outputCfg.bufferProvider.cookie = NULL;
+ context->config.outputCfg.mask = EFFECT_CONFIG_ALL;
+
+ visu_ctxt->capture_size = VISUALIZER_CAPTURE_SIZE_MAX;
+ visu_ctxt->scaling_mode = VISUALIZER_SCALING_MODE_NORMALIZED;
+
+ set_config(context, &context->config);
+
+ return 0;
+}
+
+int visualizer_get_parameter(effect_context_t *context, effect_param_t *p, uint32_t *size)
+{
+ visualizer_context_t *visu_ctxt = (visualizer_context_t *)context;
+
+ p->status = 0;
+ *size = sizeof(effect_param_t) + sizeof(uint32_t);
+ if (p->psize != sizeof(uint32_t)) {
+ p->status = -EINVAL;
+ return 0;
+ }
+ switch (*(uint32_t *)p->data) {
+ case VISUALIZER_PARAM_CAPTURE_SIZE:
+ ALOGV("%s get capture_size = %d", __func__, visu_ctxt->capture_size);
+ *((uint32_t *)p->data + 1) = visu_ctxt->capture_size;
+ p->vsize = sizeof(uint32_t);
+ *size += sizeof(uint32_t);
+ break;
+ case VISUALIZER_PARAM_SCALING_MODE:
+ ALOGV("%s get scaling_mode = %d", __func__, visu_ctxt->scaling_mode);
+ *((uint32_t *)p->data + 1) = visu_ctxt->scaling_mode;
+ p->vsize = sizeof(uint32_t);
+ *size += sizeof(uint32_t);
+ break;
+ default:
+ p->status = -EINVAL;
+ }
+ return 0;
+}
+
+int visualizer_set_parameter(effect_context_t *context, effect_param_t *p, uint32_t size)
+{
+ visualizer_context_t *visu_ctxt = (visualizer_context_t *)context;
+
+ if (p->psize != sizeof(uint32_t) || p->vsize != sizeof(uint32_t))
+ return -EINVAL;
+
+ switch (*(uint32_t *)p->data) {
+ case VISUALIZER_PARAM_CAPTURE_SIZE:
+ visu_ctxt->capture_size = *((uint32_t *)p->data + 1);
+ ALOGV("%s set capture_size = %d", __func__, visu_ctxt->capture_size);
+ break;
+ case VISUALIZER_PARAM_SCALING_MODE:
+ visu_ctxt->scaling_mode = *((uint32_t *)p->data + 1);
+ ALOGV("%s set scaling_mode = %d", __func__, visu_ctxt->scaling_mode);
+ break;
+ case VISUALIZER_PARAM_LATENCY:
+ /* Ignore latency as we capture at DSP output
+ * visu_ctxt->latency = *((uint32_t *)p->data + 1); */
+ ALOGV("%s set latency = %d", __func__, visu_ctxt->latency);
+ break;
+ default:
+ return -EINVAL;
+ }
+ return 0;
+}
+
+/* Real process function called from capture thread. Called with lock held */
+int visualizer_process(effect_context_t *context,
+ audio_buffer_t *inBuffer,
+ audio_buffer_t *outBuffer)
+{
+ visualizer_context_t *visu_ctxt = (visualizer_context_t *)context;
+
+ if (!effect_exists(context))
+ return -EINVAL;
+
+ if (inBuffer == NULL || inBuffer->raw == NULL ||
+ outBuffer == NULL || outBuffer->raw == NULL ||
+ inBuffer->frameCount != outBuffer->frameCount ||
+ inBuffer->frameCount == 0) {
+ return -EINVAL;
+ }
+
+ /* all code below assumes stereo 16 bit PCM output and input */
+ int32_t shift;
+
+ if (visu_ctxt->scaling_mode == VISUALIZER_SCALING_MODE_NORMALIZED) {
+ /* derive capture scaling factor from peak value in current buffer
+ * this gives more interesting captures for display. */
+ shift = 32;
+ int len = inBuffer->frameCount * 2;
+ int i;
+ for (i = 0; i < len; i++) {
+ int32_t smp = inBuffer->s16[i];
+ if (smp < 0) smp = -smp - 1; /* take care to keep the max negative in range */
+ int32_t clz = __builtin_clz(smp);
+ if (shift > clz) shift = clz;
+ }
+ /* A maximum amplitude signal will have 17 leading zeros, which we want to
+ * translate to a shift of 8 (for converting 16 bit to 8 bit) */
+ shift = 25 - shift;
+ /* Never scale by less than 8 to avoid returning unaltered PCM signal. */
+ if (shift < 3) {
+ shift = 3;
+ }
+ /* add one to combine the division by 2 needed after summing
+ * left and right channels below */
+ shift++;
+ } else {
+ assert(visu_ctxt->scaling_mode == VISUALIZER_SCALING_MODE_AS_PLAYED);
+ shift = 9;
+ }
+
+ uint32_t capt_idx;
+ uint32_t in_idx;
+ uint8_t *buf = visu_ctxt->capture_buf;
+ for (in_idx = 0, capt_idx = visu_ctxt->capture_idx;
+ in_idx < inBuffer->frameCount;
+ in_idx++, capt_idx++) {
+ if (capt_idx >= CAPTURE_BUF_SIZE) {
+ /* wrap around */
+ capt_idx = 0;
+ }
+ int32_t smp = inBuffer->s16[2 * in_idx] + inBuffer->s16[2 * in_idx + 1];
+ smp = smp >> shift;
+ buf[capt_idx] = ((uint8_t)smp)^0x80;
+ }
+
+ /* XXX the following two should really be atomic, though it probably doesn't
+ * matter much for visualization purposes */
+ visu_ctxt->capture_idx = capt_idx;
+ /* update last buffer update time stamp */
+ if (clock_gettime(CLOCK_MONOTONIC, &visu_ctxt->buffer_update_time) < 0) {
+ visu_ctxt->buffer_update_time.tv_sec = 0;
+ }
+
+ if (context->state != EFFECT_STATE_ACTIVE) {
+ ALOGV("%s DONE inactive", __func__);
+ return -ENODATA;
+ }
+
+ return 0;
+}
+
+int visualizer_command(effect_context_t * context, uint32_t cmdCode, uint32_t cmdSize,
+ void *pCmdData, uint32_t *replySize, void *pReplyData)
+{
+ visualizer_context_t * visu_ctxt = (visualizer_context_t *)context;
+
+ switch (cmdCode) {
+ case VISUALIZER_CMD_CAPTURE:
+ if (pReplyData == NULL || *replySize != visu_ctxt->capture_size) {
+ ALOGV("%s VISUALIZER_CMD_CAPTURE error *replySize %d context->capture_size %d",
+ __func__, *replySize, visu_ctxt->capture_size);
+ return -EINVAL;
+ }
+
+ if (!context->offload_enabled)
+ break;
+
+ if (context->state == EFFECT_STATE_ACTIVE) {
+ int32_t latency_ms = visu_ctxt->latency;
+ uint32_t delta_ms = 0;
+ if (visu_ctxt->buffer_update_time.tv_sec != 0) {
+ struct timespec ts;
+ if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
+ time_t secs = ts.tv_sec - visu_ctxt->buffer_update_time.tv_sec;
+ long nsec = ts.tv_nsec - visu_ctxt->buffer_update_time.tv_nsec;
+ if (nsec < 0) {
+ --secs;
+ nsec += 1000000000;
+ }
+ delta_ms = secs * 1000 + nsec / 1000000;
+ latency_ms -= delta_ms;
+ if (latency_ms < 0)
+ latency_ms = 0;
+ }
+ }
+ uint32_t delta_smp = context->config.inputCfg.samplingRate * latency_ms / 1000;
+
+ int32_t capture_point = visu_ctxt->capture_idx - visu_ctxt->capture_size - delta_smp;
+ int32_t capture_size = visu_ctxt->capture_size;
+ if (capture_point < 0) {
+ int32_t size = -capture_point;
+ if (size > capture_size)
+ size = capture_size;
+
+ memcpy(pReplyData,
+ visu_ctxt->capture_buf + CAPTURE_BUF_SIZE + capture_point,
+ size);
+ pReplyData = (void *)((size_t)pReplyData + size);
+ capture_size -= size;
+ capture_point = 0;
+ }
+ memcpy(pReplyData,
+ visu_ctxt->capture_buf + capture_point,
+ capture_size);
+
+
+ /* if audio framework has stopped playing audio although the effect is still
+ * active we must clear the capture buffer to return silence */
+ if ((visu_ctxt->last_capture_idx == visu_ctxt->capture_idx) &&
+ (visu_ctxt->buffer_update_time.tv_sec != 0)) {
+ if (delta_ms > MAX_STALL_TIME_MS) {
+ ALOGV("%s capture going to idle", __func__);
+ visu_ctxt->buffer_update_time.tv_sec = 0;
+ memset(pReplyData, 0x80, visu_ctxt->capture_size);
+ }
+ }
+ visu_ctxt->last_capture_idx = visu_ctxt->capture_idx;
+ } else {
+ memset(pReplyData, 0x80, visu_ctxt->capture_size);
+ }
+ break;
+
+ default:
+ ALOGW("%s invalid command %d", __func__, cmdCode);
+ return -EINVAL;
+ }
+ return 0;
+}
+
+
+/*
+ * Effect Library Interface Implementation
+ */
+
+int effect_lib_create(const effect_uuid_t *uuid,
+ int32_t sessionId,
+ int32_t ioId,
+ effect_handle_t *pHandle) {
+ int ret;
+ int i;
+
+ if (lib_init() != 0)
+ return init_status;
+
+ if (pHandle == NULL || uuid == NULL)
+ return -EINVAL;
+
+ for (i = 0; descriptors[i] != NULL; i++) {
+ if (memcmp(uuid, &descriptors[i]->uuid, sizeof(effect_uuid_t)) == 0)
+ break;
+ }
+
+ if (descriptors[i] == NULL)
+ return -EINVAL;
+
+ effect_context_t *context;
+ if (memcmp(uuid, &visualizer_descriptor.uuid, sizeof(effect_uuid_t)) == 0) {
+ visualizer_context_t *visu_ctxt = (visualizer_context_t *)calloc(1,
+ sizeof(visualizer_context_t));
+ context = (effect_context_t *)visu_ctxt;
+ context->ops.init = visualizer_init;
+ context->ops.reset = visualizer_reset;
+ context->ops.process = visualizer_process;
+ context->ops.set_parameter = visualizer_set_parameter;
+ context->ops.get_parameter = visualizer_get_parameter;
+ context->ops.command = visualizer_command;
+ } else {
+ return -EINVAL;
+ }
+
+ context->itfe = &effect_interface;
+ context->state = EFFECT_STATE_UNINITIALIZED;
+ context->out_handle = (audio_io_handle_t)ioId;
+ context->desc = &visualizer_descriptor;
+
+ ret = context->ops.init(context);
+ if (ret < 0) {
+ ALOGW("%s init failed", __func__);
+ free(context);
+ return ret;
+ }
+
+ context->state = EFFECT_STATE_INITIALIZED;
+
+ pthread_mutex_lock(&lock);
+ list_add_tail(&created_effects_list, &context->effects_list_node);
+ output_context_t *out_ctxt = get_output(ioId);
+ if (out_ctxt != NULL)
+ add_effect_to_output(out_ctxt, context);
+ pthread_mutex_unlock(&lock);
+
+ *pHandle = (effect_handle_t)context;
+
+ ALOGV("%s created context %p", __func__, context);
+
+ return 0;
+
+}
+
+int effect_lib_release(effect_handle_t handle) {
+ effect_context_t *context = (effect_context_t *)handle;
+ int status;
+
+ if (lib_init() != 0)
+ return init_status;
+
+ ALOGV("%s context %p", __func__, handle);
+ pthread_mutex_lock(&lock);
+ status = -EINVAL;
+ if (effect_exists(context)) {
+ output_context_t *out_ctxt = get_output(context->out_handle);
+ if (out_ctxt != NULL)
+ remove_effect_from_output(out_ctxt, context);
+ list_remove(&context->effects_list_node);
+ if (context->ops.release)
+ context->ops.release(context);
+ free(context);
+ status = 0;
+ }
+ pthread_mutex_unlock(&lock);
+
+ return status;
+}
+
+int effect_lib_get_descriptor(const effect_uuid_t *uuid,
+ effect_descriptor_t *descriptor) {
+ int i;
+
+ if (lib_init() != 0)
+ return init_status;
+
+ if (descriptor == NULL || uuid == NULL) {
+ ALOGV("%s called with NULL pointer", __func__);
+ return -EINVAL;
+ }
+
+ for (i = 0; descriptors[i] != NULL; i++) {
+ if (memcmp(uuid, &descriptors[i]->uuid, sizeof(effect_uuid_t)) == 0) {
+ *descriptor = *descriptors[i];
+ return 0;
+ }
+ }
+
+ return -EINVAL;
+}
+
+/*
+ * Effect Control Interface Implementation
+ */
+
+ /* Stub function for effect interface: never called for offloaded effects */
+int effect_process(effect_handle_t self,
+ audio_buffer_t *inBuffer,
+ audio_buffer_t *outBuffer)
+{
+ effect_context_t * context = (effect_context_t *)self;
+ int status = 0;
+
+ ALOGW("%s Called ?????", __func__);
+
+ pthread_mutex_lock(&lock);
+ if (!effect_exists(context)) {
+ status = -EINVAL;
+ goto exit;
+ }
+
+ if (context->state != EFFECT_STATE_ACTIVE) {
+ status = -EINVAL;
+ goto exit;
+ }
+
+exit:
+ pthread_mutex_unlock(&lock);
+ return status;
+}
+
+int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
+ void *pCmdData, uint32_t *replySize, void *pReplyData)
+{
+
+ effect_context_t * context = (effect_context_t *)self;
+ int retsize;
+ int status = 0;
+
+ pthread_mutex_lock(&lock);
+
+ if (!effect_exists(context)) {
+ status = -EINVAL;
+ goto exit;
+ }
+
+ if (context == NULL || context->state == EFFECT_STATE_UNINITIALIZED) {
+ status = -EINVAL;
+ goto exit;
+ }
+
+// ALOGV_IF(cmdCode != VISUALIZER_CMD_CAPTURE,
+// "%s command %d cmdSize %d", __func__, cmdCode, cmdSize);
+
+ switch (cmdCode) {
+ case EFFECT_CMD_INIT:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ status = -EINVAL;
+ goto exit;
+ }
+ if (context->ops.init)
+ *(int *) pReplyData = context->ops.init(context);
+ else
+ *(int *) pReplyData = 0;
+ break;
+ case EFFECT_CMD_SET_CONFIG:
+ if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
+ || pReplyData == NULL || *replySize != sizeof(int)) {
+ status = -EINVAL;
+ goto exit;
+ }
+ *(int *) pReplyData = set_config(context, (effect_config_t *) pCmdData);
+ break;
+ case EFFECT_CMD_GET_CONFIG:
+ if (pReplyData == NULL ||
+ *replySize != sizeof(effect_config_t)) {
+ status = -EINVAL;
+ goto exit;
+ }
+ if (!context->offload_enabled) {
+ status = -EINVAL;
+ goto exit;
+ }
+
+ get_config(context, (effect_config_t *)pReplyData);
+ break;
+ case EFFECT_CMD_RESET:
+ if (context->ops.reset)
+ context->ops.reset(context);
+ break;
+ case EFFECT_CMD_ENABLE:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ status = -EINVAL;
+ goto exit;
+ }
+ if (context->state != EFFECT_STATE_INITIALIZED) {
+ status = -ENOSYS;
+ goto exit;
+ }
+ context->state = EFFECT_STATE_ACTIVE;
+ if (context->ops.enable)
+ context->ops.enable(context);
+ pthread_cond_signal(&cond);
+ ALOGV("%s EFFECT_CMD_ENABLE", __func__);
+ *(int *)pReplyData = 0;
+ break;
+ case EFFECT_CMD_DISABLE:
+ if (pReplyData == NULL || *replySize != sizeof(int)) {
+ status = -EINVAL;
+ goto exit;
+ }
+ if (context->state != EFFECT_STATE_ACTIVE) {
+ status = -ENOSYS;
+ goto exit;
+ }
+ context->state = EFFECT_STATE_INITIALIZED;
+ if (context->ops.disable)
+ context->ops.disable(context);
+ pthread_cond_signal(&cond);
+ ALOGV("%s EFFECT_CMD_DISABLE", __func__);
+ *(int *)pReplyData = 0;
+ break;
+ case EFFECT_CMD_GET_PARAM: {
+ if (pCmdData == NULL ||
+ cmdSize != (int)(sizeof(effect_param_t) + sizeof(uint32_t)) ||
+ pReplyData == NULL ||
+ *replySize < (int)(sizeof(effect_param_t) + sizeof(uint32_t) + sizeof(uint32_t))) {
+ status = -EINVAL;
+ goto exit;
+ }
+ if (!context->offload_enabled) {
+ status = -EINVAL;
+ goto exit;
+ }
+ memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(uint32_t));
+ effect_param_t *p = (effect_param_t *)pReplyData;
+ if (context->ops.get_parameter)
+ context->ops.get_parameter(context, p, replySize);
+ } break;
+ case EFFECT_CMD_SET_PARAM: {
+ if (pCmdData == NULL ||
+ cmdSize != (int)(sizeof(effect_param_t) + sizeof(uint32_t) + sizeof(uint32_t)) ||
+ pReplyData == NULL || *replySize != sizeof(int32_t)) {
+ status = -EINVAL;
+ goto exit;
+ }
+ *(int32_t *)pReplyData = 0;
+ effect_param_t *p = (effect_param_t *)pCmdData;
+ if (context->ops.set_parameter)
+ *(int32_t *)pReplyData = context->ops.set_parameter(context, p, *replySize);
+
+ } break;
+ case EFFECT_CMD_SET_DEVICE:
+ case EFFECT_CMD_SET_VOLUME:
+ case EFFECT_CMD_SET_AUDIO_MODE:
+ break;
+
+ case EFFECT_CMD_OFFLOAD: {
+ output_context_t *out_ctxt;
+
+ if (cmdSize != sizeof(effect_offload_param_t) || pCmdData == NULL
+ || pReplyData == NULL || *replySize != sizeof(int)) {
+ ALOGV("%s EFFECT_CMD_OFFLOAD bad format", __func__);
+ status = -EINVAL;
+ break;
+ }
+
+ effect_offload_param_t* offload_param = (effect_offload_param_t*)pCmdData;
+
+ ALOGV("%s EFFECT_CMD_OFFLOAD offload %d output %d",
+ __func__, offload_param->isOffload, offload_param->ioHandle);
+
+ *(int *)pReplyData = 0;
+
+ context->offload_enabled = offload_param->isOffload;
+ if (context->out_handle == offload_param->ioHandle)
+ break;
+
+ out_ctxt = get_output(context->out_handle);
+ if (out_ctxt != NULL)
+ remove_effect_from_output(out_ctxt, context);
+ out_ctxt = get_output(offload_param->ioHandle);
+ if (out_ctxt != NULL)
+ add_effect_to_output(out_ctxt, context);
+
+ context->out_handle = offload_param->ioHandle;
+
+ } break;
+
+
+ default:
+ if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY && context->ops.command)
+ status = context->ops.command(context, cmdCode, cmdSize,
+ pCmdData, replySize, pReplyData);
+ else {
+ ALOGW("%s invalid command %d", __func__, cmdCode);
+ status = -EINVAL;
+ }
+ break;
+ }
+
+exit:
+ pthread_mutex_unlock(&lock);
+
+// ALOGV_IF(cmdCode != VISUALIZER_CMD_CAPTURE,"%s DONE", __func__);
+ return status;
+}
+
+/* Effect Control Interface Implementation: get_descriptor */
+int effect_get_descriptor(effect_handle_t self,
+ effect_descriptor_t *descriptor)
+{
+ effect_context_t *context = (effect_context_t *)self;
+
+ if (!effect_exists(context))
+ return -EINVAL;
+
+ if (descriptor == NULL)
+ return -EINVAL;
+
+ *descriptor = *context->desc;
+
+ return 0;
+}
+
+/* effect_handle_t interface implementation for visualizer effect */
+const struct effect_interface_s effect_interface = {
+ effect_process,
+ effect_command,
+ effect_get_descriptor,
+ NULL,
+};
+
+__attribute__ ((visibility ("default")))
+audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
+ tag : AUDIO_EFFECT_LIBRARY_TAG,
+ version : EFFECT_LIBRARY_API_VERSION,
+ name : "Visualizer Library",
+ implementor : "The Android Open Source Project",
+ create_effect : effect_lib_create,
+ release_effect : effect_lib_release,
+ get_descriptor : effect_lib_get_descriptor,
+};