1 /*
2 * Copyright (C) 2012 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 "EffectDownmix"
18 //#define LOG_NDEBUG 0
19 #include <log/log.h>
20 #include <inttypes.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <stdbool.h>
24 #include "EffectDownmix.h"
25
26 // Do not submit with DOWNMIX_TEST_CHANNEL_INDEX defined, strictly for testing
27 //#define DOWNMIX_TEST_CHANNEL_INDEX 0
28 // Do not submit with DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER defined, strictly for testing
29 //#define DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER 0
30
31 #define MINUS_3_DB_IN_Q19_12 2896 // -3dB = 0.707 * 2^12 = 2896
32
33 // subset of possible audio_channel_mask_t values, and AUDIO_CHANNEL_OUT_* renamed to CHANNEL_MASK_*
34 typedef enum {
35 CHANNEL_MASK_QUAD_BACK = AUDIO_CHANNEL_OUT_QUAD_BACK,
36 CHANNEL_MASK_QUAD_SIDE = AUDIO_CHANNEL_OUT_QUAD_SIDE,
37 CHANNEL_MASK_5POINT1_BACK = AUDIO_CHANNEL_OUT_5POINT1_BACK,
38 CHANNEL_MASK_5POINT1_SIDE = AUDIO_CHANNEL_OUT_5POINT1_SIDE,
39 CHANNEL_MASK_7POINT1 = AUDIO_CHANNEL_OUT_7POINT1,
40 } downmix_input_channel_mask_t;
41
42 // effect_handle_t interface implementation for downmix effect
43 const struct effect_interface_s gDownmixInterface = {
44 Downmix_Process,
45 Downmix_Command,
46 Downmix_GetDescriptor,
47 NULL /* no process_reverse function, no reference stream needed */
48 };
49
50 // This is the only symbol that needs to be exported
51 __attribute__ ((visibility ("default")))
52 audio_effect_library_t AUDIO_EFFECT_LIBRARY_INFO_SYM = {
53 .tag = AUDIO_EFFECT_LIBRARY_TAG,
54 .version = EFFECT_LIBRARY_API_VERSION,
55 .name = "Downmix Library",
56 .implementor = "The Android Open Source Project",
57 .create_effect = DownmixLib_Create,
58 .release_effect = DownmixLib_Release,
59 .get_descriptor = DownmixLib_GetDescriptor,
60 };
61
62
63 // AOSP insert downmix UUID: 93f04452-e4fe-41cc-91f9-e475b6d1d69f
64 static const effect_descriptor_t gDownmixDescriptor = {
65 EFFECT_UIID_DOWNMIX__, //type
66 {0x93f04452, 0xe4fe, 0x41cc, 0x91f9, {0xe4, 0x75, 0xb6, 0xd1, 0xd6, 0x9f}}, // uuid
67 EFFECT_CONTROL_API_VERSION,
68 EFFECT_FLAG_TYPE_INSERT | EFFECT_FLAG_INSERT_FIRST,
69 0, //FIXME what value should be reported? // cpu load
70 0, //FIXME what value should be reported? // memory usage
71 "Multichannel Downmix To Stereo", // human readable effect name
72 "The Android Open Source Project" // human readable effect implementor name
73 };
74
75 // gDescriptors contains pointers to all defined effect descriptor in this library
76 static const effect_descriptor_t * const gDescriptors[] = {
77 &gDownmixDescriptor
78 };
79
80 // number of effects in this library
81 const int kNbEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);
82
83
84 /*----------------------------------------------------------------------------
85 * Test code
86 *--------------------------------------------------------------------------*/
87 #ifdef DOWNMIX_TEST_CHANNEL_INDEX
88 // strictly for testing, logs the indices of the channels for a given mask,
89 // uses the same code as Downmix_foldGeneric()
Downmix_testIndexComputation(uint32_t mask)90 void Downmix_testIndexComputation(uint32_t mask) {
91 ALOGI("Testing index computation for 0x%" PRIx32 ":", mask);
92 // check against unsupported channels
93 if (mask & kUnsupported) {
94 ALOGE("Unsupported channels (top or front left/right of center)");
95 return;
96 }
97 // verify has FL/FR
98 if ((mask & AUDIO_CHANNEL_OUT_STEREO) != AUDIO_CHANNEL_OUT_STEREO) {
99 ALOGE("Front channels must be present");
100 return;
101 }
102 // verify uses SIDE as a pair (ok if not using SIDE at all)
103 bool hasSides = false;
104 if ((mask & kSides) != 0) {
105 if ((mask & kSides) != kSides) {
106 ALOGE("Side channels must be used as a pair");
107 return;
108 }
109 hasSides = true;
110 }
111 // verify uses BACK as a pair (ok if not using BACK at all)
112 bool hasBacks = false;
113 if ((mask & kBacks) != 0) {
114 if ((mask & kBacks) != kBacks) {
115 ALOGE("Back channels must be used as a pair");
116 return;
117 }
118 hasBacks = true;
119 }
120
121 const int numChan = audio_channel_count_from_out_mask(mask);
122 const bool hasFC = ((mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) == AUDIO_CHANNEL_OUT_FRONT_CENTER);
123 const bool hasLFE =
124 ((mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) == AUDIO_CHANNEL_OUT_LOW_FREQUENCY);
125 const bool hasBC = ((mask & AUDIO_CHANNEL_OUT_BACK_CENTER) == AUDIO_CHANNEL_OUT_BACK_CENTER);
126 // compute at what index each channel is: samples will be in the following order:
127 // FL FR FC LFE BL BR BC SL SR
128 // when a channel is not present, its index is set to the same as the index of the preceding
129 // channel
130 const int indexFC = hasFC ? 2 : 1; // front center
131 const int indexLFE = hasLFE ? indexFC + 1 : indexFC; // low frequency
132 const int indexBL = hasBacks ? indexLFE + 1 : indexLFE; // back left
133 const int indexBR = hasBacks ? indexBL + 1 : indexBL; // back right
134 const int indexBC = hasBC ? indexBR + 1 : indexBR; // back center
135 const int indexSL = hasSides ? indexBC + 1 : indexBC; // side left
136 const int indexSR = hasSides ? indexSL + 1 : indexSL; // side right
137
138 ALOGI(" FL FR FC LFE BL BR BC SL SR");
139 ALOGI(" %d %d %d %d %d %d %d %d %d",
140 0, 1, indexFC, indexLFE, indexBL, indexBR, indexBC, indexSL, indexSR);
141 }
142 #endif
143
Downmix_validChannelMask(uint32_t mask)144 static bool Downmix_validChannelMask(uint32_t mask)
145 {
146 if (!mask) {
147 return false;
148 }
149 // check against unsupported channels
150 if (mask & kUnsupported) {
151 ALOGE("Unsupported channels (top or front left/right of center)");
152 return false;
153 }
154 // verify has FL/FR
155 if ((mask & AUDIO_CHANNEL_OUT_STEREO) != AUDIO_CHANNEL_OUT_STEREO) {
156 ALOGE("Front channels must be present");
157 return false;
158 }
159 // verify uses SIDE as a pair (ok if not using SIDE at all)
160 if ((mask & kSides) != 0) {
161 if ((mask & kSides) != kSides) {
162 ALOGE("Side channels must be used as a pair");
163 return false;
164 }
165 }
166 // verify uses BACK as a pair (ok if not using BACK at all)
167 if ((mask & kBacks) != 0) {
168 if ((mask & kBacks) != kBacks) {
169 ALOGE("Back channels must be used as a pair");
170 return false;
171 }
172 }
173 return true;
174 }
175
176 /*----------------------------------------------------------------------------
177 * Effect API implementation
178 *--------------------------------------------------------------------------*/
179
180 /*--- Effect Library Interface Implementation ---*/
181
DownmixLib_Create(const effect_uuid_t * uuid,int32_t sessionId __unused,int32_t ioId __unused,effect_handle_t * pHandle)182 int32_t DownmixLib_Create(const effect_uuid_t *uuid,
183 int32_t sessionId __unused,
184 int32_t ioId __unused,
185 effect_handle_t *pHandle) {
186 int ret;
187 int i;
188 downmix_module_t *module;
189 const effect_descriptor_t *desc;
190
191 ALOGV("DownmixLib_Create()");
192
193 #ifdef DOWNMIX_TEST_CHANNEL_INDEX
194 // should work (won't log an error)
195 ALOGI("DOWNMIX_TEST_CHANNEL_INDEX: should work:");
196 Downmix_testIndexComputation(AUDIO_CHANNEL_OUT_FRONT_LEFT | AUDIO_CHANNEL_OUT_FRONT_RIGHT |
197 AUDIO_CHANNEL_OUT_LOW_FREQUENCY | AUDIO_CHANNEL_OUT_BACK_CENTER);
198 Downmix_testIndexComputation(CHANNEL_MASK_QUAD_SIDE | CHANNEL_MASK_QUAD_BACK);
199 Downmix_testIndexComputation(CHANNEL_MASK_5POINT1_SIDE | AUDIO_CHANNEL_OUT_BACK_CENTER);
200 Downmix_testIndexComputation(CHANNEL_MASK_5POINT1_BACK | AUDIO_CHANNEL_OUT_BACK_CENTER);
201 // shouldn't work (will log an error, won't display channel indices)
202 ALOGI("DOWNMIX_TEST_CHANNEL_INDEX: should NOT work:");
203 Downmix_testIndexComputation(AUDIO_CHANNEL_OUT_FRONT_LEFT | AUDIO_CHANNEL_OUT_FRONT_RIGHT |
204 AUDIO_CHANNEL_OUT_LOW_FREQUENCY | AUDIO_CHANNEL_OUT_BACK_LEFT);
205 Downmix_testIndexComputation(AUDIO_CHANNEL_OUT_FRONT_LEFT | AUDIO_CHANNEL_OUT_FRONT_RIGHT |
206 AUDIO_CHANNEL_OUT_LOW_FREQUENCY | AUDIO_CHANNEL_OUT_SIDE_LEFT);
207 Downmix_testIndexComputation(AUDIO_CHANNEL_OUT_FRONT_LEFT |
208 AUDIO_CHANNEL_OUT_BACK_LEFT | AUDIO_CHANNEL_OUT_BACK_RIGHT);
209 Downmix_testIndexComputation(AUDIO_CHANNEL_OUT_FRONT_LEFT |
210 AUDIO_CHANNEL_OUT_SIDE_LEFT | AUDIO_CHANNEL_OUT_SIDE_RIGHT);
211 #endif
212
213 if (pHandle == NULL || uuid == NULL) {
214 return -EINVAL;
215 }
216
217 for (i = 0 ; i < kNbEffects ; i++) {
218 desc = gDescriptors[i];
219 if (memcmp(uuid, &desc->uuid, sizeof(effect_uuid_t)) == 0) {
220 break;
221 }
222 }
223
224 if (i == kNbEffects) {
225 return -ENOENT;
226 }
227
228 module = malloc(sizeof(downmix_module_t));
229
230 module->itfe = &gDownmixInterface;
231
232 module->context.state = DOWNMIX_STATE_UNINITIALIZED;
233
234 ret = Downmix_Init(module);
235 if (ret < 0) {
236 ALOGW("DownmixLib_Create() init failed");
237 free(module);
238 return ret;
239 }
240
241 *pHandle = (effect_handle_t) module;
242
243 ALOGV("DownmixLib_Create() %p , size %zu", module, sizeof(downmix_module_t));
244
245 return 0;
246 }
247
248
DownmixLib_Release(effect_handle_t handle)249 int32_t DownmixLib_Release(effect_handle_t handle) {
250 downmix_module_t *pDwmModule = (downmix_module_t *)handle;
251
252 ALOGV("DownmixLib_Release() %p", handle);
253 if (handle == NULL) {
254 return -EINVAL;
255 }
256
257 pDwmModule->context.state = DOWNMIX_STATE_UNINITIALIZED;
258
259 free(pDwmModule);
260 return 0;
261 }
262
263
DownmixLib_GetDescriptor(const effect_uuid_t * uuid,effect_descriptor_t * pDescriptor)264 int32_t DownmixLib_GetDescriptor(const effect_uuid_t *uuid, effect_descriptor_t *pDescriptor) {
265 ALOGV("DownmixLib_GetDescriptor()");
266 int i;
267
268 if (pDescriptor == NULL || uuid == NULL){
269 ALOGE("DownmixLib_Create() called with NULL pointer");
270 return -EINVAL;
271 }
272 ALOGV("DownmixLib_GetDescriptor() nb effects=%d", kNbEffects);
273 for (i = 0; i < kNbEffects; i++) {
274 ALOGV("DownmixLib_GetDescriptor() i=%d", i);
275 if (memcmp(uuid, &gDescriptors[i]->uuid, sizeof(effect_uuid_t)) == 0) {
276 memcpy(pDescriptor, gDescriptors[i], sizeof(effect_descriptor_t));
277 ALOGV("EffectGetDescriptor - UUID matched downmix type %d, UUID = %" PRIx32,
278 i, gDescriptors[i]->uuid.timeLow);
279 return 0;
280 }
281 }
282
283 return -EINVAL;
284 }
285
286
287 /*--- Effect Control Interface Implementation ---*/
288
Downmix_Process(effect_handle_t self,audio_buffer_t * inBuffer,audio_buffer_t * outBuffer)289 static int Downmix_Process(effect_handle_t self,
290 audio_buffer_t *inBuffer, audio_buffer_t *outBuffer) {
291
292 downmix_object_t *pDownmixer;
293 int16_t *pSrc, *pDst;
294 downmix_module_t *pDwmModule = (downmix_module_t *)self;
295
296 if (pDwmModule == NULL) {
297 return -EINVAL;
298 }
299
300 if (inBuffer == NULL || inBuffer->raw == NULL ||
301 outBuffer == NULL || outBuffer->raw == NULL ||
302 inBuffer->frameCount != outBuffer->frameCount) {
303 return -EINVAL;
304 }
305
306 pDownmixer = (downmix_object_t*) &pDwmModule->context;
307
308 if (pDownmixer->state == DOWNMIX_STATE_UNINITIALIZED) {
309 ALOGE("Downmix_Process error: trying to use an uninitialized downmixer");
310 return -EINVAL;
311 } else if (pDownmixer->state == DOWNMIX_STATE_INITIALIZED) {
312 ALOGE("Downmix_Process error: trying to use a non-configured downmixer");
313 return -ENODATA;
314 }
315
316 pSrc = inBuffer->s16;
317 pDst = outBuffer->s16;
318 size_t numFrames = outBuffer->frameCount;
319
320 const bool accumulate =
321 (pDwmModule->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);
322 const uint32_t downmixInputChannelMask = pDwmModule->config.inputCfg.channels;
323
324 switch(pDownmixer->type) {
325
326 case DOWNMIX_TYPE_STRIP:
327 if (accumulate) {
328 while (numFrames) {
329 pDst[0] = clamp16(pDst[0] + pSrc[0]);
330 pDst[1] = clamp16(pDst[1] + pSrc[1]);
331 pSrc += pDownmixer->input_channel_count;
332 pDst += 2;
333 numFrames--;
334 }
335 } else {
336 while (numFrames) {
337 pDst[0] = pSrc[0];
338 pDst[1] = pSrc[1];
339 pSrc += pDownmixer->input_channel_count;
340 pDst += 2;
341 numFrames--;
342 }
343 }
344 break;
345
346 case DOWNMIX_TYPE_FOLD:
347 #ifdef DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER
348 // bypass the optimized downmix routines for the common formats
349 if (!Downmix_foldGeneric(
350 downmixInputChannelMask, pSrc, pDst, numFrames, accumulate)) {
351 ALOGE("Multichannel configuration 0x%" PRIx32 " is not supported", downmixInputChannelMask);
352 return -EINVAL;
353 }
354 break;
355 #endif
356 // optimize for the common formats
357 switch((downmix_input_channel_mask_t)downmixInputChannelMask) {
358 case CHANNEL_MASK_QUAD_BACK:
359 case CHANNEL_MASK_QUAD_SIDE:
360 Downmix_foldFromQuad(pSrc, pDst, numFrames, accumulate);
361 break;
362 case CHANNEL_MASK_5POINT1_BACK:
363 case CHANNEL_MASK_5POINT1_SIDE:
364 Downmix_foldFrom5Point1(pSrc, pDst, numFrames, accumulate);
365 break;
366 case CHANNEL_MASK_7POINT1:
367 Downmix_foldFrom7Point1(pSrc, pDst, numFrames, accumulate);
368 break;
369 default:
370 if (!Downmix_foldGeneric(
371 downmixInputChannelMask, pSrc, pDst, numFrames, accumulate)) {
372 ALOGE("Multichannel configuration 0x%" PRIx32 " is not supported", downmixInputChannelMask);
373 return -EINVAL;
374 }
375 break;
376 }
377 break;
378
379 default:
380 return -EINVAL;
381 }
382
383 return 0;
384 }
385
386
Downmix_Command(effect_handle_t self,uint32_t cmdCode,uint32_t cmdSize,void * pCmdData,uint32_t * replySize,void * pReplyData)387 static int Downmix_Command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,
388 void *pCmdData, uint32_t *replySize, void *pReplyData) {
389
390 downmix_module_t *pDwmModule = (downmix_module_t *) self;
391 downmix_object_t *pDownmixer;
392 int retsize;
393
394 if (pDwmModule == NULL || pDwmModule->context.state == DOWNMIX_STATE_UNINITIALIZED) {
395 return -EINVAL;
396 }
397
398 pDownmixer = (downmix_object_t*) &pDwmModule->context;
399
400 ALOGV("Downmix_Command command %" PRIu32 " cmdSize %" PRIu32, cmdCode, cmdSize);
401
402 switch (cmdCode) {
403 case EFFECT_CMD_INIT:
404 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
405 return -EINVAL;
406 }
407 *(int *) pReplyData = Downmix_Init(pDwmModule);
408 break;
409
410 case EFFECT_CMD_SET_CONFIG:
411 if (pCmdData == NULL || cmdSize != sizeof(effect_config_t)
412 || pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
413 return -EINVAL;
414 }
415 *(int *) pReplyData = Downmix_Configure(pDwmModule,
416 (effect_config_t *)pCmdData, false);
417 break;
418
419 case EFFECT_CMD_RESET:
420 Downmix_Reset(pDownmixer, false);
421 break;
422
423 case EFFECT_CMD_GET_PARAM:
424 ALOGV("Downmix_Command EFFECT_CMD_GET_PARAM pCmdData %p, *replySize %" PRIu32 ", pReplyData: %p",
425 pCmdData, *replySize, pReplyData);
426 if (pCmdData == NULL || cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)) ||
427 pReplyData == NULL || replySize == NULL ||
428 *replySize < (int) sizeof(effect_param_t) + 2 * sizeof(int32_t)) {
429 return -EINVAL;
430 }
431 effect_param_t *rep = (effect_param_t *) pReplyData;
432 memcpy(pReplyData, pCmdData, sizeof(effect_param_t) + sizeof(int32_t));
433 ALOGV("Downmix_Command EFFECT_CMD_GET_PARAM param %" PRId32 ", replySize %" PRIu32,
434 *(int32_t *)rep->data, rep->vsize);
435 rep->status = Downmix_getParameter(pDownmixer, *(int32_t *)rep->data, &rep->vsize,
436 rep->data + sizeof(int32_t));
437 *replySize = sizeof(effect_param_t) + sizeof(int32_t) + rep->vsize;
438 break;
439
440 case EFFECT_CMD_SET_PARAM:
441 ALOGV("Downmix_Command EFFECT_CMD_SET_PARAM cmdSize %d pCmdData %p, *replySize %" PRIu32
442 ", pReplyData %p", cmdSize, pCmdData, *replySize, pReplyData);
443 if (pCmdData == NULL || (cmdSize < (int)(sizeof(effect_param_t) + sizeof(int32_t)))
444 || pReplyData == NULL || replySize == NULL || *replySize != (int)sizeof(int32_t)) {
445 return -EINVAL;
446 }
447 effect_param_t *cmd = (effect_param_t *) pCmdData;
448 *(int *)pReplyData = Downmix_setParameter(pDownmixer, *(int32_t *)cmd->data,
449 cmd->vsize, cmd->data + sizeof(int32_t));
450 break;
451
452 case EFFECT_CMD_SET_PARAM_DEFERRED:
453 //FIXME implement
454 ALOGW("Downmix_Command command EFFECT_CMD_SET_PARAM_DEFERRED not supported, FIXME");
455 break;
456
457 case EFFECT_CMD_SET_PARAM_COMMIT:
458 //FIXME implement
459 ALOGW("Downmix_Command command EFFECT_CMD_SET_PARAM_COMMIT not supported, FIXME");
460 break;
461
462 case EFFECT_CMD_ENABLE:
463 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
464 return -EINVAL;
465 }
466 if (pDownmixer->state != DOWNMIX_STATE_INITIALIZED) {
467 return -ENOSYS;
468 }
469 pDownmixer->state = DOWNMIX_STATE_ACTIVE;
470 ALOGV("EFFECT_CMD_ENABLE() OK");
471 *(int *)pReplyData = 0;
472 break;
473
474 case EFFECT_CMD_DISABLE:
475 if (pReplyData == NULL || replySize == NULL || *replySize != sizeof(int)) {
476 return -EINVAL;
477 }
478 if (pDownmixer->state != DOWNMIX_STATE_ACTIVE) {
479 return -ENOSYS;
480 }
481 pDownmixer->state = DOWNMIX_STATE_INITIALIZED;
482 ALOGV("EFFECT_CMD_DISABLE() OK");
483 *(int *)pReplyData = 0;
484 break;
485
486 case EFFECT_CMD_SET_DEVICE:
487 if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) {
488 return -EINVAL;
489 }
490 // FIXME change type if playing on headset vs speaker
491 ALOGV("Downmix_Command EFFECT_CMD_SET_DEVICE: 0x%08" PRIx32, *(uint32_t *)pCmdData);
492 break;
493
494 case EFFECT_CMD_SET_VOLUME: {
495 // audio output is always stereo => 2 channel volumes
496 if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t) * 2) {
497 return -EINVAL;
498 }
499 // FIXME change volume
500 ALOGW("Downmix_Command command EFFECT_CMD_SET_VOLUME not supported, FIXME");
501 float left = (float)(*(uint32_t *)pCmdData) / (1 << 24);
502 float right = (float)(*((uint32_t *)pCmdData + 1)) / (1 << 24);
503 ALOGV("Downmix_Command EFFECT_CMD_SET_VOLUME: left %f, right %f ", left, right);
504 break;
505 }
506
507 case EFFECT_CMD_SET_AUDIO_MODE:
508 if (pCmdData == NULL || cmdSize != (int)sizeof(uint32_t)) {
509 return -EINVAL;
510 }
511 ALOGV("Downmix_Command EFFECT_CMD_SET_AUDIO_MODE: %" PRIu32, *(uint32_t *)pCmdData);
512 break;
513
514 case EFFECT_CMD_SET_CONFIG_REVERSE:
515 case EFFECT_CMD_SET_INPUT_DEVICE:
516 // these commands are ignored by a downmix effect
517 break;
518
519 default:
520 ALOGW("Downmix_Command invalid command %" PRIu32, cmdCode);
521 return -EINVAL;
522 }
523
524 return 0;
525 }
526
527
Downmix_GetDescriptor(effect_handle_t self,effect_descriptor_t * pDescriptor)528 int Downmix_GetDescriptor(effect_handle_t self, effect_descriptor_t *pDescriptor)
529 {
530 downmix_module_t *pDwnmxModule = (downmix_module_t *) self;
531
532 if (pDwnmxModule == NULL ||
533 pDwnmxModule->context.state == DOWNMIX_STATE_UNINITIALIZED) {
534 return -EINVAL;
535 }
536
537 memcpy(pDescriptor, &gDownmixDescriptor, sizeof(effect_descriptor_t));
538
539 return 0;
540 }
541
542
543 /*----------------------------------------------------------------------------
544 * Downmix internal functions
545 *--------------------------------------------------------------------------*/
546
547 /*----------------------------------------------------------------------------
548 * Downmix_Init()
549 *----------------------------------------------------------------------------
550 * Purpose:
551 * Initialize downmix context and apply default parameters
552 *
553 * Inputs:
554 * pDwmModule pointer to downmix effect module
555 *
556 * Outputs:
557 *
558 * Returns:
559 * 0 indicates success
560 *
561 * Side Effects:
562 * updates:
563 * pDwmModule->context.type
564 * pDwmModule->context.apply_volume_correction
565 * pDwmModule->config.inputCfg
566 * pDwmModule->config.outputCfg
567 * pDwmModule->config.inputCfg.samplingRate
568 * pDwmModule->config.outputCfg.samplingRate
569 * pDwmModule->context.state
570 * doesn't set:
571 * pDwmModule->itfe
572 *
573 *----------------------------------------------------------------------------
574 */
575
Downmix_Init(downmix_module_t * pDwmModule)576 int Downmix_Init(downmix_module_t *pDwmModule) {
577
578 ALOGV("Downmix_Init module %p", pDwmModule);
579 int ret = 0;
580
581 memset(&pDwmModule->context, 0, sizeof(downmix_object_t));
582
583 pDwmModule->config.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
584 pDwmModule->config.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
585 pDwmModule->config.inputCfg.channels = AUDIO_CHANNEL_OUT_7POINT1;
586 pDwmModule->config.inputCfg.bufferProvider.getBuffer = NULL;
587 pDwmModule->config.inputCfg.bufferProvider.releaseBuffer = NULL;
588 pDwmModule->config.inputCfg.bufferProvider.cookie = NULL;
589 pDwmModule->config.inputCfg.mask = EFFECT_CONFIG_ALL;
590
591 pDwmModule->config.inputCfg.samplingRate = 44100;
592 pDwmModule->config.outputCfg.samplingRate = pDwmModule->config.inputCfg.samplingRate;
593
594 // set a default value for the access mode, but should be overwritten by caller
595 pDwmModule->config.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
596 pDwmModule->config.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
597 pDwmModule->config.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO;
598 pDwmModule->config.outputCfg.bufferProvider.getBuffer = NULL;
599 pDwmModule->config.outputCfg.bufferProvider.releaseBuffer = NULL;
600 pDwmModule->config.outputCfg.bufferProvider.cookie = NULL;
601 pDwmModule->config.outputCfg.mask = EFFECT_CONFIG_ALL;
602
603 ret = Downmix_Configure(pDwmModule, &pDwmModule->config, true);
604 if (ret != 0) {
605 ALOGV("Downmix_Init error %d on module %p", ret, pDwmModule);
606 } else {
607 pDwmModule->context.state = DOWNMIX_STATE_INITIALIZED;
608 }
609
610 return ret;
611 }
612
613
614 /*----------------------------------------------------------------------------
615 * Downmix_Configure()
616 *----------------------------------------------------------------------------
617 * Purpose:
618 * Set input and output audio configuration.
619 *
620 * Inputs:
621 * pDwmModule pointer to downmix effect module
622 * pConfig pointer to effect_config_t structure containing input
623 * and output audio parameters configuration
624 * init true if called from init function
625 *
626 * Outputs:
627 *
628 * Returns:
629 * 0 indicates success
630 *
631 * Side Effects:
632 *
633 *----------------------------------------------------------------------------
634 */
635
Downmix_Configure(downmix_module_t * pDwmModule,effect_config_t * pConfig,bool init)636 int Downmix_Configure(downmix_module_t *pDwmModule, effect_config_t *pConfig, bool init) {
637
638 downmix_object_t *pDownmixer = &pDwmModule->context;
639
640 // Check configuration compatibility with build options, and effect capabilities
641 if (pConfig->inputCfg.samplingRate != pConfig->outputCfg.samplingRate
642 || pConfig->outputCfg.channels != DOWNMIX_OUTPUT_CHANNELS
643 || pConfig->inputCfg.format != AUDIO_FORMAT_PCM_16_BIT
644 || pConfig->outputCfg.format != AUDIO_FORMAT_PCM_16_BIT) {
645 ALOGE("Downmix_Configure error: invalid config");
646 return -EINVAL;
647 }
648
649 if (&pDwmModule->config != pConfig) {
650 memcpy(&pDwmModule->config, pConfig, sizeof(effect_config_t));
651 }
652
653 if (init) {
654 pDownmixer->type = DOWNMIX_TYPE_FOLD;
655 pDownmixer->apply_volume_correction = false;
656 pDownmixer->input_channel_count = 8; // matches default input of AUDIO_CHANNEL_OUT_7POINT1
657 } else {
658 // when configuring the effect, do not allow a blank or unsupported channel mask
659 if (!Downmix_validChannelMask(pConfig->inputCfg.channels)) {
660 ALOGE("Downmix_Configure error: input channel mask(0x%x) not supported",
661 pConfig->inputCfg.channels);
662 return -EINVAL;
663 }
664 pDownmixer->input_channel_count =
665 audio_channel_count_from_out_mask(pConfig->inputCfg.channels);
666 }
667
668 Downmix_Reset(pDownmixer, init);
669
670 return 0;
671 }
672
673
674 /*----------------------------------------------------------------------------
675 * Downmix_Reset()
676 *----------------------------------------------------------------------------
677 * Purpose:
678 * Reset internal states.
679 *
680 * Inputs:
681 * pDownmixer pointer to downmix context
682 * init true if called from init function
683 *
684 * Outputs:
685 *
686 * Returns:
687 * 0 indicates success
688 *
689 * Side Effects:
690 *
691 *----------------------------------------------------------------------------
692 */
693
Downmix_Reset(downmix_object_t * pDownmixer __unused,bool init __unused)694 int Downmix_Reset(downmix_object_t *pDownmixer __unused, bool init __unused) {
695 // nothing to do here
696 return 0;
697 }
698
699
700 /*----------------------------------------------------------------------------
701 * Downmix_setParameter()
702 *----------------------------------------------------------------------------
703 * Purpose:
704 * Set a Downmix parameter
705 *
706 * Inputs:
707 * pDownmixer handle to instance data
708 * param parameter
709 * pValue pointer to parameter value
710 * size value size
711 *
712 * Outputs:
713 *
714 * Returns:
715 * 0 indicates success
716 *
717 * Side Effects:
718 *
719 *----------------------------------------------------------------------------
720 */
Downmix_setParameter(downmix_object_t * pDownmixer,int32_t param,uint32_t size,void * pValue)721 int Downmix_setParameter(downmix_object_t *pDownmixer, int32_t param, uint32_t size, void *pValue) {
722
723 int16_t value16;
724 ALOGV("Downmix_setParameter, context %p, param %" PRId32 ", value16 %" PRId16 ", value32 %" PRId32,
725 pDownmixer, param, *(int16_t *)pValue, *(int32_t *)pValue);
726
727 switch (param) {
728
729 case DOWNMIX_PARAM_TYPE:
730 if (size != sizeof(downmix_type_t)) {
731 ALOGE("Downmix_setParameter(DOWNMIX_PARAM_TYPE) invalid size %" PRIu32 ", should be %zu",
732 size, sizeof(downmix_type_t));
733 return -EINVAL;
734 }
735 value16 = *(int16_t *)pValue;
736 ALOGV("set DOWNMIX_PARAM_TYPE, type %" PRId16, value16);
737 if (!((value16 > DOWNMIX_TYPE_INVALID) && (value16 <= DOWNMIX_TYPE_LAST))) {
738 ALOGE("Downmix_setParameter invalid DOWNMIX_PARAM_TYPE value %" PRId16, value16);
739 return -EINVAL;
740 } else {
741 pDownmixer->type = (downmix_type_t) value16;
742 break;
743
744 default:
745 ALOGE("Downmix_setParameter unknown parameter %" PRId32, param);
746 return -EINVAL;
747 }
748 }
749
750 return 0;
751 } /* end Downmix_setParameter */
752
753
754 /*----------------------------------------------------------------------------
755 * Downmix_getParameter()
756 *----------------------------------------------------------------------------
757 * Purpose:
758 * Get a Downmix parameter
759 *
760 * Inputs:
761 * pDownmixer handle to instance data
762 * param parameter
763 * pValue pointer to variable to hold retrieved value
764 * pSize pointer to value size: maximum size as input
765 *
766 * Outputs:
767 * *pValue updated with parameter value
768 * *pSize updated with actual value size
769 *
770 * Returns:
771 * 0 indicates success
772 *
773 * Side Effects:
774 *
775 *----------------------------------------------------------------------------
776 */
Downmix_getParameter(downmix_object_t * pDownmixer,int32_t param,uint32_t * pSize,void * pValue)777 int Downmix_getParameter(downmix_object_t *pDownmixer, int32_t param, uint32_t *pSize, void *pValue) {
778 int16_t *pValue16;
779
780 switch (param) {
781
782 case DOWNMIX_PARAM_TYPE:
783 if (*pSize < sizeof(int16_t)) {
784 ALOGE("Downmix_getParameter invalid parameter size %" PRIu32 " for DOWNMIX_PARAM_TYPE", *pSize);
785 return -EINVAL;
786 }
787 pValue16 = (int16_t *)pValue;
788 *pValue16 = (int16_t) pDownmixer->type;
789 *pSize = sizeof(int16_t);
790 ALOGV("Downmix_getParameter DOWNMIX_PARAM_TYPE is %" PRId16, *pValue16);
791 break;
792
793 default:
794 ALOGE("Downmix_getParameter unknown parameter %" PRId16, param);
795 return -EINVAL;
796 }
797
798 return 0;
799 } /* end Downmix_getParameter */
800
801
802 /*----------------------------------------------------------------------------
803 * Downmix_foldFromQuad()
804 *----------------------------------------------------------------------------
805 * Purpose:
806 * downmix a quad signal to stereo
807 *
808 * Inputs:
809 * pSrc quad audio samples to downmix
810 * numFrames the number of quad frames to downmix
811 * accumulate whether to mix (when true) the result of the downmix with the contents of pDst,
812 * or overwrite pDst (when false)
813 *
814 * Outputs:
815 * pDst downmixed stereo audio samples
816 *
817 *----------------------------------------------------------------------------
818 */
Downmix_foldFromQuad(int16_t * pSrc,int16_t * pDst,size_t numFrames,bool accumulate)819 void Downmix_foldFromQuad(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
820 // sample at index 0 is FL
821 // sample at index 1 is FR
822 // sample at index 2 is RL
823 // sample at index 3 is RR
824 if (accumulate) {
825 while (numFrames) {
826 // FL + RL
827 pDst[0] = clamp16(pDst[0] + ((pSrc[0] + pSrc[2]) >> 1));
828 // FR + RR
829 pDst[1] = clamp16(pDst[1] + ((pSrc[1] + pSrc[3]) >> 1));
830 pSrc += 4;
831 pDst += 2;
832 numFrames--;
833 }
834 } else { // same code as above but without adding and clamping pDst[i] to itself
835 while (numFrames) {
836 // FL + RL
837 pDst[0] = clamp16((pSrc[0] + pSrc[2]) >> 1);
838 // FR + RR
839 pDst[1] = clamp16((pSrc[1] + pSrc[3]) >> 1);
840 pSrc += 4;
841 pDst += 2;
842 numFrames--;
843 }
844 }
845 }
846
847
848 /*----------------------------------------------------------------------------
849 * Downmix_foldFrom5Point1()
850 *----------------------------------------------------------------------------
851 * Purpose:
852 * downmix a 5.1 signal to stereo
853 *
854 * Inputs:
855 * pSrc 5.1 audio samples to downmix
856 * numFrames the number of 5.1 frames to downmix
857 * accumulate whether to mix (when true) the result of the downmix with the contents of pDst,
858 * or overwrite pDst (when false)
859 *
860 * Outputs:
861 * pDst downmixed stereo audio samples
862 *
863 *----------------------------------------------------------------------------
864 */
Downmix_foldFrom5Point1(int16_t * pSrc,int16_t * pDst,size_t numFrames,bool accumulate)865 void Downmix_foldFrom5Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
866 int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
867 // sample at index 0 is FL
868 // sample at index 1 is FR
869 // sample at index 2 is FC
870 // sample at index 3 is LFE
871 // sample at index 4 is RL
872 // sample at index 5 is RR
873 // code is mostly duplicated between the two values of accumulate to avoid repeating the test
874 // for every sample
875 if (accumulate) {
876 while (numFrames) {
877 // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
878 centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
879 + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
880 // FL + centerPlusLfeContrib + RL
881 lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);
882 // FR + centerPlusLfeContrib + RR
883 rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);
884 // accumulate in destination
885 pDst[0] = clamp16(pDst[0] + (lt >> 13));
886 pDst[1] = clamp16(pDst[1] + (rt >> 13));
887 pSrc += 6;
888 pDst += 2;
889 numFrames--;
890 }
891 } else { // same code as above but without adding and clamping pDst[i] to itself
892 while (numFrames) {
893 // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
894 centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
895 + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
896 // FL + centerPlusLfeContrib + RL
897 lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);
898 // FR + centerPlusLfeContrib + RR
899 rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);
900 // store in destination
901 pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
902 pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
903 pSrc += 6;
904 pDst += 2;
905 numFrames--;
906 }
907 }
908 }
909
910
911 /*----------------------------------------------------------------------------
912 * Downmix_foldFrom7Point1()
913 *----------------------------------------------------------------------------
914 * Purpose:
915 * downmix a 7.1 signal to stereo
916 *
917 * Inputs:
918 * pSrc 7.1 audio samples to downmix
919 * numFrames the number of 7.1 frames to downmix
920 * accumulate whether to mix (when true) the result of the downmix with the contents of pDst,
921 * or overwrite pDst (when false)
922 *
923 * Outputs:
924 * pDst downmixed stereo audio samples
925 *
926 *----------------------------------------------------------------------------
927 */
Downmix_foldFrom7Point1(int16_t * pSrc,int16_t * pDst,size_t numFrames,bool accumulate)928 void Downmix_foldFrom7Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
929 int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format
930 // sample at index 0 is FL
931 // sample at index 1 is FR
932 // sample at index 2 is FC
933 // sample at index 3 is LFE
934 // sample at index 4 is RL
935 // sample at index 5 is RR
936 // sample at index 6 is SL
937 // sample at index 7 is SR
938 // code is mostly duplicated between the two values of accumulate to avoid repeating the test
939 // for every sample
940 if (accumulate) {
941 while (numFrames) {
942 // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
943 centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
944 + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
945 // FL + centerPlusLfeContrib + SL + RL
946 lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);
947 // FR + centerPlusLfeContrib + SR + RR
948 rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);
949 //accumulate in destination
950 pDst[0] = clamp16(pDst[0] + (lt >> 13));
951 pDst[1] = clamp16(pDst[1] + (rt >> 13));
952 pSrc += 8;
953 pDst += 2;
954 numFrames--;
955 }
956 } else { // same code as above but without adding and clamping pDst[i] to itself
957 while (numFrames) {
958 // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)
959 centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)
960 + (pSrc[3] * MINUS_3_DB_IN_Q19_12);
961 // FL + centerPlusLfeContrib + SL + RL
962 lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);
963 // FR + centerPlusLfeContrib + SR + RR
964 rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);
965 // store in destination
966 pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
967 pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
968 pSrc += 8;
969 pDst += 2;
970 numFrames--;
971 }
972 }
973 }
974
975
976 /*----------------------------------------------------------------------------
977 * Downmix_foldGeneric()
978 *----------------------------------------------------------------------------
979 * Purpose:
980 * downmix to stereo a multichannel signal whose format is:
981 * - has FL/FR
982 * - if using AUDIO_CHANNEL_OUT_SIDE*, it contains both left and right
983 * - if using AUDIO_CHANNEL_OUT_BACK*, it contains both left and right
984 * - doesn't use any of the AUDIO_CHANNEL_OUT_TOP* channels
985 * - doesn't use any of the AUDIO_CHANNEL_OUT_FRONT_*_OF_CENTER channels
986 * Only handles channel masks not enumerated in downmix_input_channel_mask_t
987 *
988 * Inputs:
989 * mask the channel mask of pSrc
990 * pSrc multichannel audio buffer to downmix
991 * numFrames the number of multichannel frames to downmix
992 * accumulate whether to mix (when true) the result of the downmix with the contents of pDst,
993 * or overwrite pDst (when false)
994 *
995 * Outputs:
996 * pDst downmixed stereo audio samples
997 *
998 * Returns: false if multichannel format is not supported
999 *
1000 *----------------------------------------------------------------------------
1001 */
Downmix_foldGeneric(uint32_t mask,int16_t * pSrc,int16_t * pDst,size_t numFrames,bool accumulate)1002 bool Downmix_foldGeneric(
1003 uint32_t mask, int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {
1004
1005 if (!Downmix_validChannelMask(mask)) {
1006 return false;
1007 }
1008
1009 const bool hasSides = (mask & kSides) != 0;
1010 const bool hasBacks = (mask & kBacks) != 0;
1011
1012 const int numChan = audio_channel_count_from_out_mask(mask);
1013 const bool hasFC = ((mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) == AUDIO_CHANNEL_OUT_FRONT_CENTER);
1014 const bool hasLFE =
1015 ((mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) == AUDIO_CHANNEL_OUT_LOW_FREQUENCY);
1016 const bool hasBC = ((mask & AUDIO_CHANNEL_OUT_BACK_CENTER) == AUDIO_CHANNEL_OUT_BACK_CENTER);
1017 // compute at what index each channel is: samples will be in the following order:
1018 // FL FR FC LFE BL BR BC SL SR
1019 // when a channel is not present, its index is set to the same as the index of the preceding
1020 // channel
1021 const int indexFC = hasFC ? 2 : 1; // front center
1022 const int indexLFE = hasLFE ? indexFC + 1 : indexFC; // low frequency
1023 const int indexBL = hasBacks ? indexLFE + 1 : indexLFE; // back left
1024 const int indexBR = hasBacks ? indexBL + 1 : indexBL; // back right
1025 const int indexBC = hasBC ? indexBR + 1 : indexBR; // back center
1026 const int indexSL = hasSides ? indexBC + 1 : indexBC; // side left
1027 const int indexSR = hasSides ? indexSL + 1 : indexSL; // side right
1028
1029 int32_t lt, rt, centersLfeContrib; // samples in Q19.12 format
1030 // code is mostly duplicated between the two values of accumulate to avoid repeating the test
1031 // for every sample
1032 if (accumulate) {
1033 while (numFrames) {
1034 // compute contribution of FC, BC and LFE
1035 centersLfeContrib = 0;
1036 if (hasFC) { centersLfeContrib += pSrc[indexFC]; }
1037 if (hasLFE) { centersLfeContrib += pSrc[indexLFE]; }
1038 if (hasBC) { centersLfeContrib += pSrc[indexBC]; }
1039 centersLfeContrib *= MINUS_3_DB_IN_Q19_12;
1040 // always has FL/FR
1041 lt = (pSrc[0] << 12);
1042 rt = (pSrc[1] << 12);
1043 // mix in sides and backs
1044 if (hasSides) {
1045 lt += pSrc[indexSL] << 12;
1046 rt += pSrc[indexSR] << 12;
1047 }
1048 if (hasBacks) {
1049 lt += pSrc[indexBL] << 12;
1050 rt += pSrc[indexBR] << 12;
1051 }
1052 lt += centersLfeContrib;
1053 rt += centersLfeContrib;
1054 // accumulate in destination
1055 pDst[0] = clamp16(pDst[0] + (lt >> 13));
1056 pDst[1] = clamp16(pDst[1] + (rt >> 13));
1057 pSrc += numChan;
1058 pDst += 2;
1059 numFrames--;
1060 }
1061 } else {
1062 while (numFrames) {
1063 // compute contribution of FC, BC and LFE
1064 centersLfeContrib = 0;
1065 if (hasFC) { centersLfeContrib += pSrc[indexFC]; }
1066 if (hasLFE) { centersLfeContrib += pSrc[indexLFE]; }
1067 if (hasBC) { centersLfeContrib += pSrc[indexBC]; }
1068 centersLfeContrib *= MINUS_3_DB_IN_Q19_12;
1069 // always has FL/FR
1070 lt = (pSrc[0] << 12);
1071 rt = (pSrc[1] << 12);
1072 // mix in sides and backs
1073 if (hasSides) {
1074 lt += pSrc[indexSL] << 12;
1075 rt += pSrc[indexSR] << 12;
1076 }
1077 if (hasBacks) {
1078 lt += pSrc[indexBL] << 12;
1079 rt += pSrc[indexBR] << 12;
1080 }
1081 lt += centersLfeContrib;
1082 rt += centersLfeContrib;
1083 // store in destination
1084 pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above
1085 pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above
1086 pSrc += numChan;
1087 pDst += 2;
1088 numFrames--;
1089 }
1090 }
1091 return true;
1092 }
1093