1 /*
2 * Copyright (C) 2014 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_effect_equalizer"
18 //#define LOG_NDEBUG 0
19
20 #include <cutils/list.h>
21 #include <cutils/log.h>
22 #include <tinyalsa/asoundlib.h>
23 #include <sound/audio_effects.h>
24 #include <audio_effects/effect_equalizer.h>
25
26 #include "effect_api.h"
27 #include "equalizer.h"
28
29 /* Offload equalizer UUID: a0dac280-401c-11e3-9379-0002a5d5c51b */
30 const effect_descriptor_t equalizer_descriptor = {
31 {0x0bed4300, 0xddd6, 0x11db, 0x8f34, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // type
32 {0xa0dac280, 0x401c, 0x11e3, 0x9379, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
33 EFFECT_CONTROL_API_VERSION,
34 (EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_HW_ACC_TUNNEL | EFFECT_FLAG_VOLUME_CTRL),
35 0, /* TODO */
36 1,
37 "MSM offload equalizer",
38 "The Android Open Source Project",
39 };
40
41 static const char *equalizer_preset_names[] = {
42 "Normal",
43 "Classical",
44 "Dance",
45 "Flat",
46 "Folk",
47 "Heavy Metal",
48 "Hip Hop",
49 "Jazz",
50 "Pop",
51 "Rock"
52 };
53
54 static const uint32_t equalizer_band_freq_range[NUM_EQ_BANDS][2] = {
55 {30000, 120000},
56 {120001, 460000},
57 {460001, 1800000},
58 {1800001, 7000000},
59 {7000001, 20000000}};
60
61 static const int16_t equalizer_band_presets_level[] = {
62 3, 0, 0, 0, 3, /* Normal Preset */
63 5, 3, -2, 4, 4, /* Classical Preset */
64 6, 0, 2, 4, 1, /* Dance Preset */
65 0, 0, 0, 0, 0, /* Flat Preset */
66 3, 0, 0, 2, -1, /* Folk Preset */
67 4, 1, 9, 3, 0, /* Heavy Metal Preset */
68 5, 3, 0, 1, 3, /* Hip Hop Preset */
69 4, 2, -2, 2, 5, /* Jazz Preset */
70 -1, 2, 5, 1, -2, /* Pop Preset */
71 5, 3, -1, 3, 5}; /* Rock Preset */
72
73 const uint16_t equalizer_band_presets_freq[NUM_EQ_BANDS] = {
74 60, /* Frequencies in Hz */
75 230,
76 910,
77 3600,
78 14000
79 };
80
81 /*
82 * Equalizer operations
83 */
84
equalizer_get_band_level(equalizer_context_t * context,int32_t band)85 int equalizer_get_band_level(equalizer_context_t *context, int32_t band)
86 {
87 ALOGV("%s: band: %d level: %d", __func__, band,
88 context->band_levels[band] * 100);
89 return context->band_levels[band] * 100;
90 }
91
equalizer_set_band_level(equalizer_context_t * context,int32_t band,int32_t level)92 int equalizer_set_band_level(equalizer_context_t *context, int32_t band,
93 int32_t level)
94 {
95 ALOGV("%s: band: %d, level: %d", __func__, band, level);
96 if (level > 0) {
97 level = (int)((level+50)/100);
98 } else {
99 level = (int)((level-50)/100);
100 }
101 context->band_levels[band] = level;
102 context->preset = PRESET_CUSTOM;
103
104 offload_eq_set_preset(&(context->offload_eq), PRESET_CUSTOM);
105 offload_eq_set_bands_level(&(context->offload_eq),
106 NUM_EQ_BANDS,
107 equalizer_band_presets_freq,
108 context->band_levels);
109 if (context->ctl)
110 offload_eq_send_params(context->ctl, &context->offload_eq,
111 OFFLOAD_SEND_EQ_ENABLE_FLAG |
112 OFFLOAD_SEND_EQ_BANDS_LEVEL);
113 return 0;
114 }
115
equalizer_get_center_frequency(equalizer_context_t * context __unused,int32_t band)116 int equalizer_get_center_frequency(equalizer_context_t *context __unused, int32_t band)
117 {
118 ALOGV("%s: band: %d", __func__, band);
119 return (equalizer_band_freq_range[band][0] +
120 equalizer_band_freq_range[band][1]) / 2;
121 }
122
equalizer_get_band_freq_range(equalizer_context_t * context __unused,int32_t band,uint32_t * low,uint32_t * high)123 int equalizer_get_band_freq_range(equalizer_context_t *context __unused, int32_t band,
124 uint32_t *low, uint32_t *high)
125 {
126 ALOGV("%s: band: %d", __func__, band);
127 *low = equalizer_band_freq_range[band][0];
128 *high = equalizer_band_freq_range[band][1];
129 return 0;
130 }
131
equalizer_get_band(equalizer_context_t * context __unused,uint32_t freq)132 int equalizer_get_band(equalizer_context_t *context __unused, uint32_t freq)
133 {
134 int i;
135
136 ALOGV("%s: freq: %d", __func__, freq);
137 for (i = 0; i < NUM_EQ_BANDS; i++) {
138 if (freq <= equalizer_band_freq_range[i][1]) {
139 return i;
140 }
141 }
142 return NUM_EQ_BANDS - 1;
143 }
144
equalizer_get_preset(equalizer_context_t * context)145 int equalizer_get_preset(equalizer_context_t *context)
146 {
147 ALOGV("%s: preset: %d", __func__, context->preset);
148 return context->preset;
149 }
150
equalizer_set_preset(equalizer_context_t * context,int preset)151 int equalizer_set_preset(equalizer_context_t *context, int preset)
152 {
153 int i;
154
155 ALOGV("%s: preset: %d", __func__, preset);
156 context->preset = preset;
157 for (i=0; i<NUM_EQ_BANDS; i++)
158 context->band_levels[i] =
159 equalizer_band_presets_level[i + preset * NUM_EQ_BANDS];
160
161 offload_eq_set_preset(&(context->offload_eq), preset);
162 offload_eq_set_bands_level(&(context->offload_eq),
163 NUM_EQ_BANDS,
164 equalizer_band_presets_freq,
165 context->band_levels);
166 if(context->ctl)
167 offload_eq_send_params(context->ctl, &context->offload_eq,
168 OFFLOAD_SEND_EQ_ENABLE_FLAG |
169 OFFLOAD_SEND_EQ_PRESET);
170 return 0;
171 }
172
equalizer_get_preset_name(equalizer_context_t * context __unused,int32_t preset)173 const char * equalizer_get_preset_name(equalizer_context_t *context __unused,
174 int32_t preset)
175 {
176 ALOGV("%s: preset: %s", __func__, equalizer_preset_names[preset]);
177 if (preset == PRESET_CUSTOM) {
178 return "Custom";
179 } else {
180 return equalizer_preset_names[preset];
181 }
182 }
183
equalizer_get_num_presets(equalizer_context_t * context __unused)184 int equalizer_get_num_presets(equalizer_context_t *context __unused)
185 {
186 ALOGV("%s: presets_num: %zu", __func__,
187 sizeof(equalizer_preset_names)/sizeof(char *));
188 return sizeof(equalizer_preset_names)/sizeof(char *);
189 }
190
equalizer_get_parameter(effect_context_t * context,effect_param_t * p,uint32_t * size)191 int equalizer_get_parameter(effect_context_t *context, effect_param_t *p,
192 uint32_t *size)
193 {
194 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
195 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
196 int32_t *param_tmp = (int32_t *)p->data;
197 int32_t param = *param_tmp++;
198 int32_t param2;
199 char *name;
200 void *value = p->data + voffset;
201 int i;
202
203 ALOGV("%s", __func__);
204
205 p->status = 0;
206
207 switch (param) {
208 case EQ_PARAM_NUM_BANDS:
209 case EQ_PARAM_CUR_PRESET:
210 case EQ_PARAM_GET_NUM_OF_PRESETS:
211 case EQ_PARAM_BAND_LEVEL:
212 case EQ_PARAM_GET_BAND:
213 if (p->vsize < sizeof(int16_t))
214 p->status = -EINVAL;
215 p->vsize = sizeof(int16_t);
216 break;
217
218 case EQ_PARAM_LEVEL_RANGE:
219 if (p->vsize < 2 * sizeof(int16_t))
220 p->status = -EINVAL;
221 p->vsize = 2 * sizeof(int16_t);
222 break;
223 case EQ_PARAM_BAND_FREQ_RANGE:
224 if (p->vsize < 2 * sizeof(int32_t))
225 p->status = -EINVAL;
226 p->vsize = 2 * sizeof(int32_t);
227 break;
228
229 case EQ_PARAM_CENTER_FREQ:
230 if (p->vsize < sizeof(int32_t))
231 p->status = -EINVAL;
232 p->vsize = sizeof(int32_t);
233 break;
234
235 case EQ_PARAM_GET_PRESET_NAME:
236 break;
237
238 case EQ_PARAM_PROPERTIES:
239 if (p->vsize < (2 + NUM_EQ_BANDS) * sizeof(uint16_t))
240 p->status = -EINVAL;
241 p->vsize = (2 + NUM_EQ_BANDS) * sizeof(uint16_t);
242 break;
243
244 default:
245 p->status = -EINVAL;
246 }
247
248 *size = sizeof(effect_param_t) + voffset + p->vsize;
249
250 if (p->status != 0)
251 return 0;
252
253 switch (param) {
254 case EQ_PARAM_NUM_BANDS:
255 ALOGV("%s: EQ_PARAM_NUM_BANDS", __func__);
256 *(uint16_t *)value = (uint16_t)NUM_EQ_BANDS;
257 break;
258
259 case EQ_PARAM_LEVEL_RANGE:
260 ALOGV("%s: EQ_PARAM_LEVEL_RANGE", __func__);
261 *(int16_t *)value = -1500;
262 *((int16_t *)value + 1) = 1500;
263 break;
264
265 case EQ_PARAM_BAND_LEVEL:
266 ALOGV("%s: EQ_PARAM_BAND_LEVEL", __func__);
267 param2 = *param_tmp;
268 if (param2 < 0 || param2 >= NUM_EQ_BANDS) {
269 p->status = -EINVAL;
270 if (param2 < 0) {
271 android_errorWriteLog(0x534e4554, "32438598");
272 ALOGW("\tERROR EQ_PARAM_BAND_LEVEL band %d", param2);
273 }
274 break;
275 }
276 *(int16_t *)value = (int16_t)equalizer_get_band_level(eq_ctxt, param2);
277 break;
278
279 case EQ_PARAM_CENTER_FREQ:
280 ALOGV("%s: EQ_PARAM_CENTER_FREQ", __func__);
281 param2 = *param_tmp;
282 if (param2 < 0 || param2 >= NUM_EQ_BANDS) {
283 p->status = -EINVAL;
284 if (param2 < 0) {
285 android_errorWriteLog(0x534e4554, "32436341");
286 ALOGW("\tERROR EQ_PARAM_CENTER_FREQ band %d", param2);
287 }
288 break;
289 }
290 *(int32_t *)value = equalizer_get_center_frequency(eq_ctxt, param2);
291 break;
292
293 case EQ_PARAM_BAND_FREQ_RANGE:
294 ALOGV("%s: EQ_PARAM_BAND_FREQ_RANGE", __func__);
295 param2 = *param_tmp;
296 if (param2 < 0 || param2 >= NUM_EQ_BANDS) {
297 p->status = -EINVAL;
298 if (param2 < 0) {
299 android_errorWriteLog(0x534e4554, "32247948");
300 ALOGW("\tERROR EQ_PARAM_BAND_FREQ_RANGE band %d", param2);
301 }
302 break;
303 }
304 equalizer_get_band_freq_range(eq_ctxt, param2, (uint32_t *)value,
305 ((uint32_t *)value + 1));
306 break;
307
308 case EQ_PARAM_GET_BAND:
309 ALOGV("%s: EQ_PARAM_GET_BAND", __func__);
310 param2 = *param_tmp;
311 *(uint16_t *)value = (uint16_t)equalizer_get_band(eq_ctxt, param2);
312 break;
313
314 case EQ_PARAM_CUR_PRESET:
315 ALOGV("%s: EQ_PARAM_CUR_PRESET", __func__);
316 *(uint16_t *)value = (uint16_t)equalizer_get_preset(eq_ctxt);
317 break;
318
319 case EQ_PARAM_GET_NUM_OF_PRESETS:
320 ALOGV("%s: EQ_PARAM_GET_NUM_OF_PRESETS", __func__);
321 *(uint16_t *)value = (uint16_t)equalizer_get_num_presets(eq_ctxt);
322 break;
323
324 case EQ_PARAM_GET_PRESET_NAME:
325 ALOGV("%s: EQ_PARAM_GET_PRESET_NAME", __func__);
326 param2 = *param_tmp;
327 ALOGV("param2: %d", param2);
328 if ((param2 < 0 && param2 != PRESET_CUSTOM) ||
329 param2 >= equalizer_get_num_presets(eq_ctxt)) {
330 p->status = -EINVAL;
331 if (param2 < 0) {
332 android_errorWriteLog(0x534e4554, "32588016");
333 ALOGW("\tERROR EQ_PARAM_GET_PRESET_NAME preset %d", param2);
334 }
335 break;
336 }
337
338 if (p->vsize < 1) {
339 p->status = -EINVAL;
340 android_errorWriteLog(0x534e4554, "37536407");
341 break;
342 }
343
344 name = (char *)value;
345 strlcpy(name, equalizer_get_preset_name(eq_ctxt, param2), p->vsize - 1);
346 name[p->vsize - 1] = 0;
347 p->vsize = strlen(name) + 1;
348 break;
349
350 case EQ_PARAM_PROPERTIES: {
351 ALOGV("%s: EQ_PARAM_PROPERTIES", __func__);
352 int16_t *prop = (int16_t *)value;
353 prop[0] = (int16_t)equalizer_get_preset(eq_ctxt);
354 prop[1] = (int16_t)NUM_EQ_BANDS;
355 for (i = 0; i < NUM_EQ_BANDS; i++) {
356 prop[2 + i] = (int16_t)equalizer_get_band_level(eq_ctxt, i);
357 }
358 } break;
359
360 default:
361 p->status = -EINVAL;
362 break;
363 }
364
365 return 0;
366 }
367
equalizer_set_parameter(effect_context_t * context,effect_param_t * p,uint32_t size __unused)368 int equalizer_set_parameter(effect_context_t *context, effect_param_t *p,
369 uint32_t size __unused)
370 {
371 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
372 int voffset = ((p->psize - 1) / sizeof(int32_t) + 1) * sizeof(int32_t);
373 void *value = p->data + voffset;
374 uint32_t vsize = p->vsize;
375 int32_t *param_tmp = (int32_t *)p->data;
376 int32_t param = *param_tmp++;
377 int32_t preset;
378 int32_t band;
379 int32_t level;
380 int i;
381
382 ALOGV("%s", __func__);
383
384 p->status = 0;
385
386 switch (param) {
387 case EQ_PARAM_CUR_PRESET:
388 ALOGV("EQ_PARAM_CUR_PRESET");
389 if (vsize < sizeof(int16_t)) {
390 p->status = -EINVAL;
391 break;
392 }
393 preset = (int32_t)(*(uint16_t *)value);
394
395 if ((preset >= equalizer_get_num_presets(eq_ctxt)) || (preset < 0)) {
396 p->status = -EINVAL;
397 break;
398 }
399 equalizer_set_preset(eq_ctxt, preset);
400 break;
401 case EQ_PARAM_BAND_LEVEL:
402 ALOGV("EQ_PARAM_BAND_LEVEL");
403 if (vsize < sizeof(int16_t)) {
404 p->status = -EINVAL;
405 break;
406 }
407 band = *param_tmp;
408 level = (int32_t)(*(int16_t *)value);
409 if (band < 0 || band >= NUM_EQ_BANDS) {
410 p->status = -EINVAL;
411 if (band < 0) {
412 android_errorWriteLog(0x534e4554, "32585400");
413 ALOGW("\tERROR EQ_PARAM_BAND_LEVEL band %d", band);
414 }
415 break;
416 }
417 equalizer_set_band_level(eq_ctxt, band, level);
418 break;
419 case EQ_PARAM_PROPERTIES: {
420 ALOGV("EQ_PARAM_PROPERTIES");
421 if (vsize < sizeof(int16_t)) {
422 p->status = -EINVAL;
423 break;
424 }
425 int16_t *prop = (int16_t *)value;
426 if ((int)prop[0] >= equalizer_get_num_presets(eq_ctxt)) {
427 p->status = -EINVAL;
428 break;
429 }
430 if (prop[0] >= 0) {
431 equalizer_set_preset(eq_ctxt, (int)prop[0]);
432 } else {
433 if (vsize < (2 + NUM_EQ_BANDS) * sizeof(int16_t)) {
434 android_errorWriteLog(0x534e4554, "37563371");
435 ALOGE("\tERROR EQ_PARAM_PROPERTIES valueSize %u < %u",
436 vsize, (unsigned int)((2 + NUM_EQ_BANDS) * sizeof(int16_t)));
437 p->status = -EINVAL;
438 break;
439 }
440 if ((int)prop[1] != NUM_EQ_BANDS) {
441 p->status = -EINVAL;
442 break;
443 }
444 for (i = 0; i < NUM_EQ_BANDS; i++) {
445 equalizer_set_band_level(eq_ctxt, i, (int)prop[2 + i]);
446 }
447 }
448 } break;
449 default:
450 p->status = -EINVAL;
451 break;
452 }
453
454 return 0;
455 }
456
equalizer_set_device(effect_context_t * context,uint32_t device)457 int equalizer_set_device(effect_context_t *context, uint32_t device)
458 {
459 ALOGV("%s: device: %d", __func__, device);
460 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
461 eq_ctxt->device = device;
462 offload_eq_set_device(&(eq_ctxt->offload_eq), device);
463 return 0;
464 }
465
equalizer_reset(effect_context_t * context)466 int equalizer_reset(effect_context_t *context)
467 {
468 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
469
470 return 0;
471 }
472
equalizer_init(effect_context_t * context)473 int equalizer_init(effect_context_t *context)
474 {
475 ALOGV("%s", __func__);
476 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
477
478 context->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
479 context->config.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
480 context->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
481 context->config.inputCfg.samplingRate = 44100;
482 context->config.inputCfg.bufferProvider.getBuffer = NULL;
483 context->config.inputCfg.bufferProvider.releaseBuffer = NULL;
484 context->config.inputCfg.bufferProvider.cookie = NULL;
485 context->config.inputCfg.mask = EFFECT_CONFIG_ALL;
486 context->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
487 context->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
488 context->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
489 context->config.outputCfg.samplingRate = 44100;
490 context->config.outputCfg.bufferProvider.getBuffer = NULL;
491 context->config.outputCfg.bufferProvider.releaseBuffer = NULL;
492 context->config.outputCfg.bufferProvider.cookie = NULL;
493 context->config.outputCfg.mask = EFFECT_CONFIG_ALL;
494
495 set_config(context, &context->config);
496
497 memset(&(eq_ctxt->offload_eq), 0, sizeof(struct eq_params));
498 offload_eq_set_preset(&(eq_ctxt->offload_eq), INVALID_PRESET);
499
500 return 0;
501 }
502
equalizer_enable(effect_context_t * context)503 int equalizer_enable(effect_context_t *context)
504 {
505 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
506
507 ALOGV("%s", __func__);
508
509 if (!offload_eq_get_enable_flag(&(eq_ctxt->offload_eq))) {
510 offload_eq_set_enable_flag(&(eq_ctxt->offload_eq), true);
511 if (eq_ctxt->ctl)
512 offload_eq_send_params(eq_ctxt->ctl, &eq_ctxt->offload_eq,
513 OFFLOAD_SEND_EQ_ENABLE_FLAG |
514 OFFLOAD_SEND_EQ_BANDS_LEVEL);
515 }
516 return 0;
517 }
518
equalizer_disable(effect_context_t * context)519 int equalizer_disable(effect_context_t *context)
520 {
521 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
522
523 ALOGV("%s", __func__);
524 if (offload_eq_get_enable_flag(&(eq_ctxt->offload_eq))) {
525 offload_eq_set_enable_flag(&(eq_ctxt->offload_eq), false);
526 if (eq_ctxt->ctl)
527 offload_eq_send_params(eq_ctxt->ctl, &eq_ctxt->offload_eq,
528 OFFLOAD_SEND_EQ_ENABLE_FLAG);
529 }
530 return 0;
531 }
532
equalizer_start(effect_context_t * context,output_context_t * output)533 int equalizer_start(effect_context_t *context, output_context_t *output)
534 {
535 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
536
537 ALOGV("%s: %p", __func__, output->ctl);
538 eq_ctxt->ctl = output->ctl;
539 if (offload_eq_get_enable_flag(&(eq_ctxt->offload_eq)))
540 if (eq_ctxt->ctl)
541 offload_eq_send_params(eq_ctxt->ctl, &eq_ctxt->offload_eq,
542 OFFLOAD_SEND_EQ_ENABLE_FLAG |
543 OFFLOAD_SEND_EQ_BANDS_LEVEL);
544 return 0;
545 }
546
equalizer_stop(effect_context_t * context,output_context_t * output __unused)547 int equalizer_stop(effect_context_t *context, output_context_t *output __unused)
548 {
549 equalizer_context_t *eq_ctxt = (equalizer_context_t *)context;
550
551 ALOGV("%s", __func__);
552 eq_ctxt->ctl = NULL;
553 return 0;
554 }
555