• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "offload_visualizer"
18 /*#define LOG_NDEBUG 0*/
19 #include <assert.h>
20 #include <math.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <time.h>
24 #include <sys/prctl.h>
25 
26 #include <cutils/list.h>
27 #include <cutils/log.h>
28 #include <system/thread_defs.h>
29 #include <tinyalsa/asoundlib.h>
30 #include <audio_effects/effect_visualizer.h>
31 
32 
33 enum {
34     EFFECT_STATE_UNINITIALIZED,
35     EFFECT_STATE_INITIALIZED,
36     EFFECT_STATE_ACTIVE,
37 };
38 
39 typedef struct effect_context_s effect_context_t;
40 typedef struct output_context_s output_context_t;
41 
42 /* effect specific operations. Only the init() and process() operations must be defined.
43  * Others are optional.
44  */
45 typedef struct effect_ops_s {
46     int (*init)(effect_context_t *context);
47     int (*release)(effect_context_t *context);
48     int (*reset)(effect_context_t *context);
49     int (*enable)(effect_context_t *context);
50     int (*disable)(effect_context_t *context);
51     int (*start)(effect_context_t *context, output_context_t *output);
52     int (*stop)(effect_context_t *context, output_context_t *output);
53     int (*process)(effect_context_t *context, audio_buffer_t *in, audio_buffer_t *out);
54     int (*set_parameter)(effect_context_t *context, effect_param_t *param, uint32_t size);
55     int (*get_parameter)(effect_context_t *context, effect_param_t *param, uint32_t *size);
56     int (*command)(effect_context_t *context, uint32_t cmdCode, uint32_t cmdSize,
57             void *pCmdData, uint32_t *replySize, void *pReplyData);
58 } effect_ops_t;
59 
60 struct effect_context_s {
61     const struct effect_interface_s *itfe;
62     struct listnode effects_list_node;  /* node in created_effects_list */
63     struct listnode output_node;  /* node in output_context_t.effects_list */
64     effect_config_t config;
65     const effect_descriptor_t *desc;
66     audio_io_handle_t out_handle;  /* io handle of the output the effect is attached to */
67     uint32_t state;
68     bool offload_enabled;  /* when offload is enabled we process VISUALIZER_CMD_CAPTURE command.
69                               Otherwise non offloaded visualizer has already processed the command
70                               and we must not overwrite the reply. */
71     effect_ops_t ops;
72 };
73 
74 typedef struct output_context_s {
75     struct listnode outputs_list_node;  /* node in active_outputs_list */
76     audio_io_handle_t handle; /* io handle */
77     struct listnode effects_list; /* list of effects attached to this output */
78 } output_context_t;
79 
80 
81 /* maximum time since last capture buffer update before resetting capture buffer. This means
82   that the framework has stopped playing audio and we must start returning silence */
83 #define MAX_STALL_TIME_MS 1000
84 
85 #define CAPTURE_BUF_SIZE 65536 /* "64k should be enough for everyone" */
86 
87 #define DISCARD_MEASUREMENTS_TIME_MS 2000 /* discard measurements older than this number of ms */
88 
89 /* maximum number of buffers for which we keep track of the measurements */
90 #define MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS 25 /* note: buffer index is stored in uint8_t */
91 
92 typedef struct buffer_stats_s {
93     bool is_valid;
94     uint16_t peak_u16; /* the positive peak of the absolute value of the samples in a buffer */
95     float rms_squared; /* the average square of the samples in a buffer */
96 } buffer_stats_t;
97 
98 typedef struct visualizer_context_s {
99     effect_context_t common;
100 
101     uint32_t capture_idx;
102     uint32_t capture_size;
103     uint32_t scaling_mode;
104     uint32_t last_capture_idx;
105     uint32_t latency;
106     struct timespec buffer_update_time;
107     uint8_t capture_buf[CAPTURE_BUF_SIZE];
108     /* for measurements */
109     uint8_t channel_count; /* to avoid recomputing it every time a buffer is processed */
110     uint32_t meas_mode;
111     uint8_t meas_wndw_size_in_buffers;
112     uint8_t meas_buffer_idx;
113     buffer_stats_t past_meas[MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS];
114 } visualizer_context_t;
115 
116 
117 extern const struct effect_interface_s effect_interface;
118 
119 /* Offload visualizer UUID: 7a8044a0-1a71-11e3-a184-0002a5d5c51b */
120 const effect_descriptor_t visualizer_descriptor = {
121         {0xe46b26a0, 0xdddd, 0x11db, 0x8afd, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
122         {0x7a8044a0, 0x1a71, 0x11e3, 0xa184, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
123         EFFECT_CONTROL_API_VERSION,
124         (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_HW_ACC_TUNNEL ),
125         0, /* TODO */
126         1,
127         "QCOM MSM offload visualizer",
128         "The Android Open Source Project",
129 };
130 
131 const effect_descriptor_t *descriptors[] = {
132         &visualizer_descriptor,
133         NULL,
134 };
135 
136 
137 pthread_once_t once = PTHREAD_ONCE_INIT;
138 int init_status;
139 
140 /* list of created effects. Updated by visualizer_hal_start_output()
141  * and visualizer_hal_stop_output() */
142 struct listnode created_effects_list;
143 /* list of active output streams. Updated by visualizer_hal_start_output()
144  * and visualizer_hal_stop_output() */
145 struct listnode active_outputs_list;
146 
147 /* thread capturing PCM from Proxy port and calling the process function on each enabled effect
148  * attached to an active output stream */
149 pthread_t capture_thread;
150 /* lock must be held when modifying or accessing created_effects_list or active_outputs_list */
151 pthread_mutex_t lock;
152 /* thread_lock must be held when starting or stopping the capture thread.
153  * Locking order: thread_lock -> lock */
154 pthread_mutex_t thread_lock;
155 /* cond is signaled when an output is started or stopped or an effect is enabled or disable: the
156  * capture thread will reevaluate the capture and effect rocess conditions. */
157 pthread_cond_t cond;
158 /* true when requesting the capture thread to exit */
159 bool exit_thread;
160 /* 0 if the capture thread was created successfully */
161 int thread_status;
162 
163 
164 #define DSP_OUTPUT_LATENCY_MS 0 /* Fudge factor for latency after capture point in audio DSP */
165 
166 /* Retry for delay for mixer open */
167 #define RETRY_NUMBER 10
168 #define RETRY_US 500000
169 
170 #define MIXER_CARD 0
171 #define SOUND_CARD 0
172 #define CAPTURE_DEVICE 8
173 
174 /* Proxy port supports only MMAP read and those fixed parameters*/
175 #define AUDIO_CAPTURE_CHANNEL_COUNT 2
176 #define AUDIO_CAPTURE_SMP_RATE 48000
177 #define AUDIO_CAPTURE_PERIOD_SIZE (768)
178 #define AUDIO_CAPTURE_PERIOD_COUNT 32
179 
180 struct pcm_config pcm_config_capture = {
181     .channels = AUDIO_CAPTURE_CHANNEL_COUNT,
182     .rate = AUDIO_CAPTURE_SMP_RATE,
183     .period_size = AUDIO_CAPTURE_PERIOD_SIZE,
184     .period_count = AUDIO_CAPTURE_PERIOD_COUNT,
185     .format = PCM_FORMAT_S16_LE,
186     .start_threshold = AUDIO_CAPTURE_PERIOD_SIZE / 4,
187     .stop_threshold = INT_MAX,
188     .avail_min = AUDIO_CAPTURE_PERIOD_SIZE / 4,
189 };
190 
191 
192 /*
193  *  Local functions
194  */
195 
init_once()196 static void init_once() {
197     list_init(&created_effects_list);
198     list_init(&active_outputs_list);
199 
200     pthread_mutex_init(&lock, NULL);
201     pthread_mutex_init(&thread_lock, NULL);
202     pthread_cond_init(&cond, NULL);
203     exit_thread = false;
204     thread_status = -1;
205 
206     init_status = 0;
207 }
208 
lib_init()209 int lib_init() {
210     pthread_once(&once, init_once);
211     return init_status;
212 }
213 
effect_exists(effect_context_t * context)214 bool effect_exists(effect_context_t *context) {
215     struct listnode *node;
216 
217     list_for_each(node, &created_effects_list) {
218         effect_context_t *fx_ctxt = node_to_item(node,
219                                                      effect_context_t,
220                                                      effects_list_node);
221         if (fx_ctxt == context) {
222             return true;
223         }
224     }
225     return false;
226 }
227 
get_output(audio_io_handle_t output)228 output_context_t *get_output(audio_io_handle_t output) {
229     struct listnode *node;
230 
231     list_for_each(node, &active_outputs_list) {
232         output_context_t *out_ctxt = node_to_item(node,
233                                                   output_context_t,
234                                                   outputs_list_node);
235         if (out_ctxt->handle == output) {
236             return out_ctxt;
237         }
238     }
239     return NULL;
240 }
241 
add_effect_to_output(output_context_t * output,effect_context_t * context)242 void add_effect_to_output(output_context_t * output, effect_context_t *context) {
243     struct listnode *fx_node;
244 
245     list_for_each(fx_node, &output->effects_list) {
246         effect_context_t *fx_ctxt = node_to_item(fx_node,
247                                                      effect_context_t,
248                                                      output_node);
249         if (fx_ctxt == context)
250             return;
251     }
252     list_add_tail(&output->effects_list, &context->output_node);
253     if (context->ops.start)
254         context->ops.start(context, output);
255 }
256 
remove_effect_from_output(output_context_t * output,effect_context_t * context)257 void remove_effect_from_output(output_context_t * output, effect_context_t *context) {
258     struct listnode *fx_node;
259 
260     list_for_each(fx_node, &output->effects_list) {
261         effect_context_t *fx_ctxt = node_to_item(fx_node,
262                                                      effect_context_t,
263                                                      output_node);
264         if (fx_ctxt == context) {
265             if (context->ops.stop)
266                 context->ops.stop(context, output);
267             list_remove(&context->output_node);
268             return;
269         }
270     }
271 }
272 
effects_enabled()273 bool effects_enabled() {
274     struct listnode *out_node;
275 
276     list_for_each(out_node, &active_outputs_list) {
277         struct listnode *fx_node;
278         output_context_t *out_ctxt = node_to_item(out_node,
279                                                   output_context_t,
280                                                   outputs_list_node);
281 
282         list_for_each(fx_node, &out_ctxt->effects_list) {
283             effect_context_t *fx_ctxt = node_to_item(fx_node,
284                                                          effect_context_t,
285                                                          output_node);
286             if (fx_ctxt->state == EFFECT_STATE_ACTIVE && fx_ctxt->ops.process != NULL)
287                 return true;
288         }
289     }
290     return false;
291 }
292 
configure_proxy_capture(struct mixer * mixer,int value)293 int configure_proxy_capture(struct mixer *mixer, int value) {
294     const char *proxy_ctl_name = "AFE_PCM_RX Audio Mixer MultiMedia4";
295     struct mixer_ctl *ctl;
296 
297     ctl = mixer_get_ctl_by_name(mixer, proxy_ctl_name);
298     if (ctl == NULL) {
299         ALOGW("%s: could not get %s ctl", __func__, proxy_ctl_name);
300         return -EINVAL;
301     }
302     if (mixer_ctl_set_value(ctl, 0, value) != 0)
303         ALOGW("%s: error setting value %d on %s ", __func__, value, proxy_ctl_name);
304 
305     return 0;
306 }
307 
308 
capture_thread_loop(void * arg)309 void *capture_thread_loop(void *arg)
310 {
311     int16_t data[AUDIO_CAPTURE_PERIOD_SIZE * AUDIO_CAPTURE_CHANNEL_COUNT * sizeof(int16_t)];
312     audio_buffer_t buf;
313     buf.frameCount = AUDIO_CAPTURE_PERIOD_SIZE;
314     buf.s16 = data;
315     bool capture_enabled = false;
316     struct mixer *mixer;
317     struct pcm *pcm = NULL;
318     int ret;
319     int retry_num = 0;
320 
321     ALOGD("thread enter");
322 
323     prctl(PR_SET_NAME, (unsigned long)"visualizer capture", 0, 0, 0);
324 
325     pthread_mutex_lock(&lock);
326 
327     mixer = mixer_open(MIXER_CARD);
328     while (mixer == NULL && retry_num < RETRY_NUMBER) {
329         usleep(RETRY_US);
330         mixer = mixer_open(MIXER_CARD);
331         retry_num++;
332     }
333     if (mixer == NULL) {
334         pthread_mutex_unlock(&lock);
335         return NULL;
336     }
337 
338     for (;;) {
339         if (exit_thread) {
340             break;
341         }
342         if (effects_enabled()) {
343             if (!capture_enabled) {
344                 ret = configure_proxy_capture(mixer, 1);
345                 if (ret == 0) {
346                     pcm = pcm_open(SOUND_CARD, CAPTURE_DEVICE,
347                                    PCM_IN|PCM_MMAP|PCM_NOIRQ, &pcm_config_capture);
348                     if (pcm && !pcm_is_ready(pcm)) {
349                         ALOGW("%s: %s", __func__, pcm_get_error(pcm));
350                         pcm_close(pcm);
351                         pcm = NULL;
352                         configure_proxy_capture(mixer, 0);
353                     } else {
354                         capture_enabled = true;
355                         ALOGD("%s: capture ENABLED", __func__);
356                     }
357                 }
358             }
359         } else {
360             if (capture_enabled) {
361                 if (pcm != NULL)
362                     pcm_close(pcm);
363                 configure_proxy_capture(mixer, 0);
364                 ALOGD("%s: capture DISABLED", __func__);
365                 capture_enabled = false;
366             }
367             pthread_cond_wait(&cond, &lock);
368         }
369         if (!capture_enabled)
370             continue;
371 
372         pthread_mutex_unlock(&lock);
373         ret = pcm_mmap_read(pcm, data, sizeof(data));
374         pthread_mutex_lock(&lock);
375 
376         if (ret == 0) {
377             struct listnode *out_node;
378 
379             list_for_each(out_node, &active_outputs_list) {
380                 output_context_t *out_ctxt = node_to_item(out_node,
381                                                           output_context_t,
382                                                           outputs_list_node);
383                 struct listnode *fx_node;
384 
385                 list_for_each(fx_node, &out_ctxt->effects_list) {
386                     effect_context_t *fx_ctxt = node_to_item(fx_node,
387                                                                 effect_context_t,
388                                                                 output_node);
389                     if (fx_ctxt->ops.process != NULL)
390                         fx_ctxt->ops.process(fx_ctxt, &buf, &buf);
391                 }
392             }
393         } else {
394             ALOGW("%s: read status %d %s", __func__, ret, pcm_get_error(pcm));
395         }
396     }
397 
398     if (capture_enabled) {
399         if (pcm != NULL)
400             pcm_close(pcm);
401         configure_proxy_capture(mixer, 0);
402     }
403     mixer_close(mixer);
404     pthread_mutex_unlock(&lock);
405 
406     ALOGD("thread exit");
407 
408     return NULL;
409 }
410 
411 /*
412  * Interface from audio HAL
413  */
414 
415 __attribute__ ((visibility ("default")))
visualizer_hal_start_output(audio_io_handle_t output,int pcm_id)416 int visualizer_hal_start_output(audio_io_handle_t output, int pcm_id) {
417     int ret;
418     struct listnode *node;
419 
420     ALOGV("%s output %d pcm_id %d", __func__, output, pcm_id);
421 
422     if (lib_init() != 0)
423         return init_status;
424 
425     pthread_mutex_lock(&thread_lock);
426     pthread_mutex_lock(&lock);
427     if (get_output(output) != NULL) {
428         ALOGW("%s output already started", __func__);
429         ret = -ENOSYS;
430         goto exit;
431     }
432 
433     output_context_t *out_ctxt = (output_context_t *)malloc(sizeof(output_context_t));
434     if (out_ctxt == NULL) {
435         ALOGE("%s fail to allocate memory", __func__);
436         ret = -ENOMEM;
437         goto exit;
438     }
439     out_ctxt->handle = output;
440     list_init(&out_ctxt->effects_list);
441 
442     list_for_each(node, &created_effects_list) {
443         effect_context_t *fx_ctxt = node_to_item(node,
444                                                      effect_context_t,
445                                                      effects_list_node);
446         if (fx_ctxt->out_handle == output) {
447             if (fx_ctxt->ops.start)
448                 fx_ctxt->ops.start(fx_ctxt, out_ctxt);
449             list_add_tail(&out_ctxt->effects_list, &fx_ctxt->output_node);
450         }
451     }
452     if (list_empty(&active_outputs_list)) {
453         exit_thread = false;
454         thread_status = pthread_create(&capture_thread, (const pthread_attr_t *) NULL,
455                         capture_thread_loop, NULL);
456     }
457     list_add_tail(&active_outputs_list, &out_ctxt->outputs_list_node);
458     pthread_cond_signal(&cond);
459 
460 exit:
461     pthread_mutex_unlock(&lock);
462     pthread_mutex_unlock(&thread_lock);
463     return ret;
464 }
465 
466 __attribute__ ((visibility ("default")))
visualizer_hal_stop_output(audio_io_handle_t output,int pcm_id)467 int visualizer_hal_stop_output(audio_io_handle_t output, int pcm_id) {
468     int ret;
469     struct listnode *node;
470     struct listnode *fx_node;
471     output_context_t *out_ctxt;
472 
473     ALOGV("%s output %d pcm_id %d", __func__, output, pcm_id);
474 
475     if (lib_init() != 0)
476         return init_status;
477 
478     pthread_mutex_lock(&thread_lock);
479     pthread_mutex_lock(&lock);
480 
481     out_ctxt = get_output(output);
482     if (out_ctxt == NULL) {
483         ALOGW("%s output not started", __func__);
484         ret = -ENOSYS;
485         goto exit;
486     }
487     list_for_each(fx_node, &out_ctxt->effects_list) {
488         effect_context_t *fx_ctxt = node_to_item(fx_node,
489                                                  effect_context_t,
490                                                  output_node);
491         if (fx_ctxt->ops.stop)
492             fx_ctxt->ops.stop(fx_ctxt, out_ctxt);
493     }
494     list_remove(&out_ctxt->outputs_list_node);
495     pthread_cond_signal(&cond);
496 
497     if (list_empty(&active_outputs_list)) {
498         if (thread_status == 0) {
499             exit_thread = true;
500             pthread_cond_signal(&cond);
501             pthread_mutex_unlock(&lock);
502             pthread_join(capture_thread, (void **) NULL);
503             pthread_mutex_lock(&lock);
504             thread_status = -1;
505         }
506     }
507 
508     free(out_ctxt);
509 
510 exit:
511     pthread_mutex_unlock(&lock);
512     pthread_mutex_unlock(&thread_lock);
513     return ret;
514 }
515 
516 
517 /*
518  * Effect operations
519  */
520 
set_config(effect_context_t * context,effect_config_t * config)521 int set_config(effect_context_t *context, effect_config_t *config)
522 {
523     if (config->inputCfg.samplingRate != config->outputCfg.samplingRate) return -EINVAL;
524     if (config->inputCfg.channels != config->outputCfg.channels) return -EINVAL;
525     if (config->inputCfg.format != config->outputCfg.format) return -EINVAL;
526     if (config->inputCfg.channels != AUDIO_CHANNEL_OUT_STEREO) return -EINVAL;
527     if (config->outputCfg.accessMode != EFFECT_BUFFER_ACCESS_WRITE &&
528             config->outputCfg.accessMode != EFFECT_BUFFER_ACCESS_ACCUMULATE) return -EINVAL;
529     if (config->inputCfg.format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
530 
531     context->config = *config;
532 
533     if (context->ops.reset)
534         context->ops.reset(context);
535 
536     return 0;
537 }
538 
get_config(effect_context_t * context,effect_config_t * config)539 void get_config(effect_context_t *context, effect_config_t *config)
540 {
541     *config = context->config;
542 }
543 
544 
545 /*
546  * Visualizer operations
547  */
548 
visualizer_get_delta_time_ms_from_updated_time(visualizer_context_t * visu_ctxt)549 uint32_t visualizer_get_delta_time_ms_from_updated_time(visualizer_context_t* visu_ctxt) {
550     uint32_t delta_ms = 0;
551     if (visu_ctxt->buffer_update_time.tv_sec != 0) {
552         struct timespec ts;
553         if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
554             time_t secs = ts.tv_sec - visu_ctxt->buffer_update_time.tv_sec;
555             long nsec = ts.tv_nsec - visu_ctxt->buffer_update_time.tv_nsec;
556             if (nsec < 0) {
557                 --secs;
558                 nsec += 1000000000;
559             }
560             delta_ms = secs * 1000 + nsec / 1000000;
561         }
562     }
563     return delta_ms;
564 }
565 
visualizer_reset(effect_context_t * context)566 int visualizer_reset(effect_context_t *context)
567 {
568     visualizer_context_t * visu_ctxt = (visualizer_context_t *)context;
569 
570     visu_ctxt->capture_idx = 0;
571     visu_ctxt->last_capture_idx = 0;
572     visu_ctxt->buffer_update_time.tv_sec = 0;
573     visu_ctxt->latency = DSP_OUTPUT_LATENCY_MS;
574     memset(visu_ctxt->capture_buf, 0x80, CAPTURE_BUF_SIZE);
575     return 0;
576 }
577 
visualizer_init(effect_context_t * context)578 int visualizer_init(effect_context_t *context)
579 {
580     int32_t i;
581 
582     visualizer_context_t * visu_ctxt = (visualizer_context_t *)context;
583 
584     context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
585     context->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
586     context->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
587     context->config.inputCfg.samplingRate = 44100;
588     context->config.inputCfg.bufferProvider.getBuffer = NULL;
589     context->config.inputCfg.bufferProvider.releaseBuffer = NULL;
590     context->config.inputCfg.bufferProvider.cookie = NULL;
591     context->config.inputCfg.mask = EFFECT_CONFIG_ALL;
592     context->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
593     context->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
594     context->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
595     context->config.outputCfg.samplingRate = 44100;
596     context->config.outputCfg.bufferProvider.getBuffer = NULL;
597     context->config.outputCfg.bufferProvider.releaseBuffer = NULL;
598     context->config.outputCfg.bufferProvider.cookie = NULL;
599     context->config.outputCfg.mask = EFFECT_CONFIG_ALL;
600 
601     visu_ctxt->capture_size = VISUALIZER_CAPTURE_SIZE_MAX;
602     visu_ctxt->scaling_mode = VISUALIZER_SCALING_MODE_NORMALIZED;
603 
604     // measurement initialization
605     visu_ctxt->channel_count = popcount(context->config.inputCfg.channels);
606     visu_ctxt->meas_mode = MEASUREMENT_MODE_NONE;
607     visu_ctxt->meas_wndw_size_in_buffers = MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS;
608     visu_ctxt->meas_buffer_idx = 0;
609     for (i=0 ; i<visu_ctxt->meas_wndw_size_in_buffers ; i++) {
610         visu_ctxt->past_meas[i].is_valid = false;
611         visu_ctxt->past_meas[i].peak_u16 = 0;
612         visu_ctxt->past_meas[i].rms_squared = 0;
613     }
614 
615     set_config(context, &context->config);
616 
617     return 0;
618 }
619 
visualizer_get_parameter(effect_context_t * context,effect_param_t * p,uint32_t * size)620 int visualizer_get_parameter(effect_context_t *context, effect_param_t *p, uint32_t *size)
621 {
622     visualizer_context_t *visu_ctxt = (visualizer_context_t *)context;
623 
624     p->status = 0;
625     *size = sizeof(effect_param_t) + sizeof(uint32_t);
626     if (p->psize != sizeof(uint32_t)) {
627         p->status = -EINVAL;
628         return 0;
629     }
630     switch (*(uint32_t *)p->data) {
631     case VISUALIZER_PARAM_CAPTURE_SIZE:
632         ALOGV("%s get capture_size = %d", __func__, visu_ctxt->capture_size);
633         *((uint32_t *)p->data + 1) = visu_ctxt->capture_size;
634         p->vsize = sizeof(uint32_t);
635         *size += sizeof(uint32_t);
636         break;
637     case VISUALIZER_PARAM_SCALING_MODE:
638         ALOGV("%s get scaling_mode = %d", __func__, visu_ctxt->scaling_mode);
639         *((uint32_t *)p->data + 1) = visu_ctxt->scaling_mode;
640         p->vsize = sizeof(uint32_t);
641         *size += sizeof(uint32_t);
642         break;
643     case VISUALIZER_PARAM_MEASUREMENT_MODE:
644         ALOGV("%s get meas_mode = %d", __func__, visu_ctxt->meas_mode);
645         *((uint32_t *)p->data + 1) = visu_ctxt->meas_mode;
646         p->vsize = sizeof(uint32_t);
647         *size += sizeof(uint32_t);
648         break;
649     default:
650         p->status = -EINVAL;
651     }
652     return 0;
653 }
654 
visualizer_set_parameter(effect_context_t * context,effect_param_t * p,uint32_t size)655 int visualizer_set_parameter(effect_context_t *context, effect_param_t *p, uint32_t size)
656 {
657     visualizer_context_t *visu_ctxt = (visualizer_context_t *)context;
658 
659     if (p->psize != sizeof(uint32_t) || p->vsize != sizeof(uint32_t))
660         return -EINVAL;
661 
662     switch (*(uint32_t *)p->data) {
663     case VISUALIZER_PARAM_CAPTURE_SIZE:
664         visu_ctxt->capture_size = *((uint32_t *)p->data + 1);
665         ALOGV("%s set capture_size = %d", __func__, visu_ctxt->capture_size);
666         break;
667     case VISUALIZER_PARAM_SCALING_MODE:
668         visu_ctxt->scaling_mode = *((uint32_t *)p->data + 1);
669         ALOGV("%s set scaling_mode = %d", __func__, visu_ctxt->scaling_mode);
670         break;
671     case VISUALIZER_PARAM_LATENCY:
672         /* Ignore latency as we capture at DSP output
673          * visu_ctxt->latency = *((uint32_t *)p->data + 1); */
674         ALOGV("%s set latency = %d", __func__, visu_ctxt->latency);
675         break;
676     case VISUALIZER_PARAM_MEASUREMENT_MODE:
677         visu_ctxt->meas_mode = *((uint32_t *)p->data + 1);
678         ALOGV("%s set meas_mode = %d", __func__, visu_ctxt->meas_mode);
679         break;
680     default:
681         return -EINVAL;
682     }
683     return 0;
684 }
685 
686 /* Real process function called from capture thread. Called with lock held */
visualizer_process(effect_context_t * context,audio_buffer_t * inBuffer,audio_buffer_t * outBuffer)687 int visualizer_process(effect_context_t *context,
688                        audio_buffer_t *inBuffer,
689                        audio_buffer_t *outBuffer)
690 {
691     visualizer_context_t *visu_ctxt = (visualizer_context_t *)context;
692 
693     if (!effect_exists(context))
694         return -EINVAL;
695 
696     if (inBuffer == NULL || inBuffer->raw == NULL ||
697         outBuffer == NULL || outBuffer->raw == NULL ||
698         inBuffer->frameCount != outBuffer->frameCount ||
699         inBuffer->frameCount == 0) {
700         return -EINVAL;
701     }
702 
703     // perform measurements if needed
704     if (visu_ctxt->meas_mode & MEASUREMENT_MODE_PEAK_RMS) {
705         // find the peak and RMS squared for the new buffer
706         uint32_t inIdx;
707         int16_t max_sample = 0;
708         float rms_squared_acc = 0;
709         for (inIdx = 0 ; inIdx < inBuffer->frameCount * visu_ctxt->channel_count ; inIdx++) {
710             if (inBuffer->s16[inIdx] > max_sample) {
711                 max_sample = inBuffer->s16[inIdx];
712             } else if (-inBuffer->s16[inIdx] > max_sample) {
713                 max_sample = -inBuffer->s16[inIdx];
714             }
715             rms_squared_acc += (inBuffer->s16[inIdx] * inBuffer->s16[inIdx]);
716         }
717         // store the measurement
718         visu_ctxt->past_meas[visu_ctxt->meas_buffer_idx].peak_u16 = (uint16_t)max_sample;
719         visu_ctxt->past_meas[visu_ctxt->meas_buffer_idx].rms_squared =
720                 rms_squared_acc / (inBuffer->frameCount * visu_ctxt->channel_count);
721         visu_ctxt->past_meas[visu_ctxt->meas_buffer_idx].is_valid = true;
722         if (++visu_ctxt->meas_buffer_idx >= visu_ctxt->meas_wndw_size_in_buffers) {
723             visu_ctxt->meas_buffer_idx = 0;
724         }
725     }
726 
727     /* all code below assumes stereo 16 bit PCM output and input */
728     int32_t shift;
729 
730     if (visu_ctxt->scaling_mode == VISUALIZER_SCALING_MODE_NORMALIZED) {
731         /* derive capture scaling factor from peak value in current buffer
732          * this gives more interesting captures for display. */
733         shift = 32;
734         int len = inBuffer->frameCount * 2;
735         int i;
736         for (i = 0; i < len; i++) {
737             int32_t smp = inBuffer->s16[i];
738             if (smp < 0) smp = -smp - 1; /* take care to keep the max negative in range */
739             int32_t clz = __builtin_clz(smp);
740             if (shift > clz) shift = clz;
741         }
742         /* A maximum amplitude signal will have 17 leading zeros, which we want to
743          * translate to a shift of 8 (for converting 16 bit to 8 bit) */
744         shift = 25 - shift;
745         /* Never scale by less than 8 to avoid returning unaltered PCM signal. */
746         if (shift < 3) {
747             shift = 3;
748         }
749         /* add one to combine the division by 2 needed after summing
750          * left and right channels below */
751         shift++;
752     } else {
753         assert(visu_ctxt->scaling_mode == VISUALIZER_SCALING_MODE_AS_PLAYED);
754         shift = 9;
755     }
756 
757     uint32_t capt_idx;
758     uint32_t in_idx;
759     uint8_t *buf = visu_ctxt->capture_buf;
760     for (in_idx = 0, capt_idx = visu_ctxt->capture_idx;
761          in_idx < inBuffer->frameCount;
762          in_idx++, capt_idx++) {
763         if (capt_idx >= CAPTURE_BUF_SIZE) {
764             /* wrap around */
765             capt_idx = 0;
766         }
767         int32_t smp = inBuffer->s16[2 * in_idx] + inBuffer->s16[2 * in_idx + 1];
768         smp = smp >> shift;
769         buf[capt_idx] = ((uint8_t)smp)^0x80;
770     }
771 
772     /* XXX the following two should really be atomic, though it probably doesn't
773      * matter much for visualization purposes */
774     visu_ctxt->capture_idx = capt_idx;
775     /* update last buffer update time stamp */
776     if (clock_gettime(CLOCK_MONOTONIC, &visu_ctxt->buffer_update_time) < 0) {
777         visu_ctxt->buffer_update_time.tv_sec = 0;
778     }
779 
780     if (context->state != EFFECT_STATE_ACTIVE) {
781         ALOGV("%s DONE inactive", __func__);
782         return -ENODATA;
783     }
784 
785     return 0;
786 }
787 
visualizer_command(effect_context_t * context,uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)788 int visualizer_command(effect_context_t * context, uint32_t cmdCode, uint32_t cmdSize,
789         void *pCmdData, uint32_t *replySize, void *pReplyData)
790 {
791     visualizer_context_t * visu_ctxt = (visualizer_context_t *)context;
792 
793     switch (cmdCode) {
794     case VISUALIZER_CMD_CAPTURE:
795         if (pReplyData == NULL || *replySize != visu_ctxt->capture_size) {
796             ALOGV("%s VISUALIZER_CMD_CAPTURE error *replySize %d context->capture_size %d",
797                   __func__, *replySize, visu_ctxt->capture_size);
798             return -EINVAL;
799         }
800 
801         if (!context->offload_enabled)
802             break;
803 
804         if (context->state == EFFECT_STATE_ACTIVE) {
805             int32_t latency_ms = visu_ctxt->latency;
806             const uint32_t delta_ms = visualizer_get_delta_time_ms_from_updated_time(visu_ctxt);
807             latency_ms -= delta_ms;
808             if (latency_ms < 0) {
809                 latency_ms = 0;
810             }
811             const uint32_t delta_smp = context->config.inputCfg.samplingRate * latency_ms / 1000;
812 
813             int32_t capture_point = visu_ctxt->capture_idx - visu_ctxt->capture_size - delta_smp;
814             int32_t capture_size = visu_ctxt->capture_size;
815             if (capture_point < 0) {
816                 int32_t size = -capture_point;
817                 if (size > capture_size)
818                     size = capture_size;
819 
820                 memcpy(pReplyData,
821                        visu_ctxt->capture_buf + CAPTURE_BUF_SIZE + capture_point,
822                        size);
823                 pReplyData = (void *)((size_t)pReplyData + size);
824                 capture_size -= size;
825                 capture_point = 0;
826             }
827             memcpy(pReplyData,
828                    visu_ctxt->capture_buf + capture_point,
829                    capture_size);
830 
831 
832             /* if audio framework has stopped playing audio although the effect is still
833              * active we must clear the capture buffer to return silence */
834             if ((visu_ctxt->last_capture_idx == visu_ctxt->capture_idx) &&
835                     (visu_ctxt->buffer_update_time.tv_sec != 0)) {
836                 if (delta_ms > MAX_STALL_TIME_MS) {
837                     ALOGV("%s capture going to idle", __func__);
838                     visu_ctxt->buffer_update_time.tv_sec = 0;
839                     memset(pReplyData, 0x80, visu_ctxt->capture_size);
840                 }
841             }
842             visu_ctxt->last_capture_idx = visu_ctxt->capture_idx;
843         } else {
844             memset(pReplyData, 0x80, visu_ctxt->capture_size);
845         }
846         break;
847 
848     case VISUALIZER_CMD_MEASURE: {
849         uint16_t peak_u16 = 0;
850         float sum_rms_squared = 0.0f;
851         uint8_t nb_valid_meas = 0;
852         /* reset measurements if last measurement was too long ago (which implies stored
853          * measurements aren't relevant anymore and shouldn't bias the new one) */
854         const int32_t delay_ms = visualizer_get_delta_time_ms_from_updated_time(visu_ctxt);
855         if (delay_ms > DISCARD_MEASUREMENTS_TIME_MS) {
856             uint32_t i;
857             ALOGV("Discarding measurements, last measurement is %dms old", delay_ms);
858             for (i=0 ; i<visu_ctxt->meas_wndw_size_in_buffers ; i++) {
859                 visu_ctxt->past_meas[i].is_valid = false;
860                 visu_ctxt->past_meas[i].peak_u16 = 0;
861                 visu_ctxt->past_meas[i].rms_squared = 0;
862             }
863             visu_ctxt->meas_buffer_idx = 0;
864         } else {
865             /* only use actual measurements, otherwise the first RMS measure happening before
866              * MEASUREMENT_WINDOW_MAX_SIZE_IN_BUFFERS have been played will always be artificially
867              * low */
868             uint32_t i;
869             for (i=0 ; i < visu_ctxt->meas_wndw_size_in_buffers ; i++) {
870                 if (visu_ctxt->past_meas[i].is_valid) {
871                     if (visu_ctxt->past_meas[i].peak_u16 > peak_u16) {
872                         peak_u16 = visu_ctxt->past_meas[i].peak_u16;
873                     }
874                     sum_rms_squared += visu_ctxt->past_meas[i].rms_squared;
875                     nb_valid_meas++;
876                 }
877             }
878         }
879         float rms = nb_valid_meas == 0 ? 0.0f : sqrtf(sum_rms_squared / nb_valid_meas);
880         int32_t* p_int_reply_data = (int32_t*)pReplyData;
881         /* convert from I16 sample values to mB and write results */
882         if (rms < 0.000016f) {
883             p_int_reply_data[MEASUREMENT_IDX_RMS] = -9600; //-96dB
884         } else {
885             p_int_reply_data[MEASUREMENT_IDX_RMS] = (int32_t) (2000 * log10(rms / 32767.0f));
886         }
887         if (peak_u16 == 0) {
888             p_int_reply_data[MEASUREMENT_IDX_PEAK] = -9600; //-96dB
889         } else {
890             p_int_reply_data[MEASUREMENT_IDX_PEAK] = (int32_t) (2000 * log10(peak_u16 / 32767.0f));
891         }
892         ALOGV("VISUALIZER_CMD_MEASURE peak=%d (%dmB), rms=%.1f (%dmB)",
893                 peak_u16, p_int_reply_data[MEASUREMENT_IDX_PEAK],
894                 rms, p_int_reply_data[MEASUREMENT_IDX_RMS]);
895         }
896         break;
897 
898     default:
899         ALOGW("%s invalid command %d", __func__, cmdCode);
900         return -EINVAL;
901     }
902     return 0;
903 }
904 
905 
906 /*
907  * Effect Library Interface Implementation
908  */
909 
effect_lib_create(const effect_uuid_t * uuid,int32_t sessionId,int32_t ioId,effect_handle_t * pHandle)910 int effect_lib_create(const effect_uuid_t *uuid,
911                          int32_t sessionId,
912                          int32_t ioId,
913                          effect_handle_t *pHandle) {
914     int ret;
915     int i;
916 
917     if (lib_init() != 0)
918         return init_status;
919 
920     if (pHandle == NULL || uuid == NULL)
921         return -EINVAL;
922 
923     for (i = 0; descriptors[i] != NULL; i++) {
924         if (memcmp(uuid, &descriptors[i]->uuid, sizeof(effect_uuid_t)) == 0)
925             break;
926     }
927 
928     if (descriptors[i] == NULL)
929         return -EINVAL;
930 
931     effect_context_t *context;
932     if (memcmp(uuid, &visualizer_descriptor.uuid, sizeof(effect_uuid_t)) == 0) {
933         visualizer_context_t *visu_ctxt = (visualizer_context_t *)calloc(1,
934                                                                      sizeof(visualizer_context_t));
935         if (visu_ctxt == NULL) {
936             ALOGE("%s fail to allocate memory", __func__);
937             return -ENOMEM;
938         }
939         context = (effect_context_t *)visu_ctxt;
940         context->ops.init = visualizer_init;
941         context->ops.reset = visualizer_reset;
942         context->ops.process = visualizer_process;
943         context->ops.set_parameter = visualizer_set_parameter;
944         context->ops.get_parameter = visualizer_get_parameter;
945         context->ops.command = visualizer_command;
946         context->desc = &visualizer_descriptor;
947     } else {
948         return -EINVAL;
949     }
950 
951     context->itfe = &effect_interface;
952     context->state = EFFECT_STATE_UNINITIALIZED;
953     context->out_handle = (audio_io_handle_t)ioId;
954 
955     ret = context->ops.init(context);
956     if (ret < 0) {
957         ALOGW("%s init failed", __func__);
958         free(context);
959         return ret;
960     }
961 
962     context->state = EFFECT_STATE_INITIALIZED;
963 
964     pthread_mutex_lock(&lock);
965     list_add_tail(&created_effects_list, &context->effects_list_node);
966     output_context_t *out_ctxt = get_output(ioId);
967     if (out_ctxt != NULL)
968         add_effect_to_output(out_ctxt, context);
969     pthread_mutex_unlock(&lock);
970 
971     *pHandle = (effect_handle_t)context;
972 
973     ALOGV("%s created context %p", __func__, context);
974 
975     return 0;
976 
977 }
978 
effect_lib_release(effect_handle_t handle)979 int effect_lib_release(effect_handle_t handle) {
980     effect_context_t *context = (effect_context_t *)handle;
981     int status;
982 
983     if (lib_init() != 0)
984         return init_status;
985 
986     ALOGV("%s context %p", __func__, handle);
987     pthread_mutex_lock(&lock);
988     status = -EINVAL;
989     if (effect_exists(context)) {
990         output_context_t *out_ctxt = get_output(context->out_handle);
991         if (out_ctxt != NULL)
992             remove_effect_from_output(out_ctxt, context);
993         list_remove(&context->effects_list_node);
994         if (context->ops.release)
995             context->ops.release(context);
996         free(context);
997         status = 0;
998     }
999     pthread_mutex_unlock(&lock);
1000 
1001     return status;
1002 }
1003 
effect_lib_get_descriptor(const effect_uuid_t * uuid,effect_descriptor_t * descriptor)1004 int effect_lib_get_descriptor(const effect_uuid_t *uuid,
1005                                 effect_descriptor_t *descriptor) {
1006     int i;
1007 
1008     if (lib_init() != 0)
1009         return init_status;
1010 
1011     if (descriptor == NULL || uuid == NULL) {
1012         ALOGV("%s called with NULL pointer", __func__);
1013         return -EINVAL;
1014     }
1015 
1016     for (i = 0; descriptors[i] != NULL; i++) {
1017         if (memcmp(uuid, &descriptors[i]->uuid, sizeof(effect_uuid_t)) == 0) {
1018             *descriptor = *descriptors[i];
1019             return 0;
1020         }
1021     }
1022 
1023     return  -EINVAL;
1024 }
1025 
1026 /*
1027  * Effect Control Interface Implementation
1028  */
1029 
1030  /* Stub function for effect interface: never called for offloaded effects */
effect_process(effect_handle_t self,audio_buffer_t * inBuffer,audio_buffer_t * outBuffer)1031 int effect_process(effect_handle_t self,
1032                        audio_buffer_t *inBuffer,
1033                        audio_buffer_t *outBuffer)
1034 {
1035     effect_context_t * context = (effect_context_t *)self;
1036     int status = 0;
1037 
1038     ALOGW("%s Called ?????", __func__);
1039 
1040     pthread_mutex_lock(&lock);
1041     if (!effect_exists(context)) {
1042         status = -EINVAL;
1043         goto exit;
1044     }
1045 
1046     if (context->state != EFFECT_STATE_ACTIVE) {
1047         status = -EINVAL;
1048         goto exit;
1049     }
1050 
1051 exit:
1052     pthread_mutex_unlock(&lock);
1053     return status;
1054 }
1055 
effect_command(effect_handle_t self,uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)1056 int effect_command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
1057         void *pCmdData, uint32_t *replySize, void *pReplyData)
1058 {
1059 
1060     effect_context_t * context = (effect_context_t *)self;
1061     int retsize;
1062     int status = 0;
1063 
1064     pthread_mutex_lock(&lock);
1065 
1066     if (!effect_exists(context)) {
1067         status = -EINVAL;
1068         goto exit;
1069     }
1070 
1071     if (context == NULL || context->state == EFFECT_STATE_UNINITIALIZED) {
1072         status = -EINVAL;
1073         goto exit;
1074     }
1075 
1076 //    ALOGV_IF(cmdCode != VISUALIZER_CMD_CAPTURE,
1077 //             "%s command %d cmdSize %d", __func__, cmdCode, cmdSize);
1078 
1079     switch (cmdCode) {
1080     case EFFECT_CMD_INIT:
1081         if (pReplyData == NULL || *replySize != sizeof(int)) {
1082             status = -EINVAL;
1083             goto exit;
1084         }
1085         if (context->ops.init)
1086             *(int *) pReplyData = context->ops.init(context);
1087         else
1088             *(int *) pReplyData = 0;
1089         break;
1090     case EFFECT_CMD_SET_CONFIG:
1091         if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
1092                 || pReplyData == NULL || *replySize != sizeof(int)) {
1093             status = -EINVAL;
1094             goto exit;
1095         }
1096         *(int *) pReplyData = set_config(context, (effect_config_t *) pCmdData);
1097         break;
1098     case EFFECT_CMD_GET_CONFIG:
1099         if (pReplyData == NULL ||
1100             *replySize != sizeof(effect_config_t)) {
1101             status = -EINVAL;
1102             goto exit;
1103         }
1104         if (!context->offload_enabled) {
1105             status = -EINVAL;
1106             goto exit;
1107         }
1108 
1109         get_config(context, (effect_config_t *)pReplyData);
1110         break;
1111     case EFFECT_CMD_RESET:
1112         if (context->ops.reset)
1113             context->ops.reset(context);
1114         break;
1115     case EFFECT_CMD_ENABLE:
1116         if (pReplyData == NULL || *replySize != sizeof(int)) {
1117             status = -EINVAL;
1118             goto exit;
1119         }
1120         if (context->state != EFFECT_STATE_INITIALIZED) {
1121             status = -ENOSYS;
1122             goto exit;
1123         }
1124         context->state = EFFECT_STATE_ACTIVE;
1125         if (context->ops.enable)
1126             context->ops.enable(context);
1127         pthread_cond_signal(&cond);
1128         ALOGV("%s EFFECT_CMD_ENABLE", __func__);
1129         *(int *)pReplyData = 0;
1130         break;
1131     case EFFECT_CMD_DISABLE:
1132         if (pReplyData == NULL || *replySize != sizeof(int)) {
1133             status = -EINVAL;
1134             goto exit;
1135         }
1136         if (context->state != EFFECT_STATE_ACTIVE) {
1137             status = -ENOSYS;
1138             goto exit;
1139         }
1140         context->state = EFFECT_STATE_INITIALIZED;
1141         if (context->ops.disable)
1142             context->ops.disable(context);
1143         pthread_cond_signal(&cond);
1144         ALOGV("%s EFFECT_CMD_DISABLE", __func__);
1145         *(int *)pReplyData = 0;
1146         break;
1147     case EFFECT_CMD_GET_PARAM: {
1148         if (pCmdData == NULL ||
1149             cmdSize != (int)(sizeof(effect_param_t) + sizeof(uint32_t)) ||
1150             pReplyData == NULL ||
1151             *replySize < (int)(sizeof(effect_param_t) + sizeof(uint32_t) + sizeof(uint32_t))) {
1152             status = -EINVAL;
1153             goto exit;
1154         }
1155         if (!context->offload_enabled) {
1156             status = -EINVAL;
1157             goto exit;
1158         }
1159         memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(uint32_t));
1160         effect_param_t *p = (effect_param_t *)pReplyData;
1161         if (context->ops.get_parameter)
1162             context->ops.get_parameter(context, p, replySize);
1163         } break;
1164     case EFFECT_CMD_SET_PARAM: {
1165         if (pCmdData == NULL ||
1166             cmdSize != (int)(sizeof(effect_param_t) + sizeof(uint32_t) + sizeof(uint32_t)) ||
1167             pReplyData == NULL || *replySize != sizeof(int32_t)) {
1168             status = -EINVAL;
1169             goto exit;
1170         }
1171         *(int32_t *)pReplyData = 0;
1172         effect_param_t *p = (effect_param_t *)pCmdData;
1173         if (context->ops.set_parameter)
1174             *(int32_t *)pReplyData = context->ops.set_parameter(context, p, *replySize);
1175 
1176         } break;
1177     case EFFECT_CMD_SET_DEVICE:
1178     case EFFECT_CMD_SET_VOLUME:
1179     case EFFECT_CMD_SET_AUDIO_MODE:
1180         break;
1181 
1182     case EFFECT_CMD_OFFLOAD: {
1183         output_context_t *out_ctxt;
1184 
1185         if (cmdSize != sizeof(effect_offload_param_t) || pCmdData == NULL
1186                 || pReplyData == NULL || *replySize != sizeof(int)) {
1187             ALOGV("%s EFFECT_CMD_OFFLOAD bad format", __func__);
1188             status = -EINVAL;
1189             break;
1190         }
1191 
1192         effect_offload_param_t* offload_param = (effect_offload_param_t*)pCmdData;
1193 
1194         ALOGV("%s EFFECT_CMD_OFFLOAD offload %d output %d",
1195               __func__, offload_param->isOffload, offload_param->ioHandle);
1196 
1197         *(int *)pReplyData = 0;
1198 
1199         context->offload_enabled = offload_param->isOffload;
1200         if (context->out_handle == offload_param->ioHandle)
1201             break;
1202 
1203         out_ctxt = get_output(context->out_handle);
1204         if (out_ctxt != NULL)
1205             remove_effect_from_output(out_ctxt, context);
1206 
1207         context->out_handle = offload_param->ioHandle;
1208         out_ctxt = get_output(offload_param->ioHandle);
1209         if (out_ctxt != NULL)
1210             add_effect_to_output(out_ctxt, context);
1211 
1212         } break;
1213 
1214 
1215     default:
1216         if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY && context->ops.command)
1217             status = context->ops.command(context, cmdCode, cmdSize,
1218                                           pCmdData, replySize, pReplyData);
1219         else {
1220             ALOGW("%s invalid command %d", __func__, cmdCode);
1221             status = -EINVAL;
1222         }
1223         break;
1224     }
1225 
1226 exit:
1227     pthread_mutex_unlock(&lock);
1228 
1229 //    ALOGV_IF(cmdCode != VISUALIZER_CMD_CAPTURE,"%s DONE", __func__);
1230     return status;
1231 }
1232 
1233 /* Effect Control Interface Implementation: get_descriptor */
effect_get_descriptor(effect_handle_t self,effect_descriptor_t * descriptor)1234 int effect_get_descriptor(effect_handle_t   self,
1235                                     effect_descriptor_t *descriptor)
1236 {
1237     effect_context_t *context = (effect_context_t *)self;
1238 
1239     if (!effect_exists(context))
1240         return -EINVAL;
1241 
1242     if (descriptor == NULL)
1243         return -EINVAL;
1244 
1245     *descriptor = *context->desc;
1246 
1247     return 0;
1248 }
1249 
1250 /* effect_handle_t interface implementation for visualizer effect */
1251 const struct effect_interface_s effect_interface = {
1252         effect_process,
1253         effect_command,
1254         effect_get_descriptor,
1255         NULL,
1256 };
1257 
1258 __attribute__ ((visibility ("default")))
1259 audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
1260     tag : AUDIO_EFFECT_LIBRARY_TAG,
1261     version : EFFECT_LIBRARY_API_VERSION,
1262     name : "Visualizer Library",
1263     implementor : "The Android Open Source Project",
1264     create_effect : effect_lib_create,
1265     release_effect : effect_lib_release,
1266     get_descriptor : effect_lib_get_descriptor,
1267 };
1268