1 /*
2 **
3 ** Copyright 2007, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #define LOG_TAG "AudioMixer"
19 //#define LOG_NDEBUG 0
20
21 #include "Configuration.h"
22 #include <stdint.h>
23 #include <string.h>
24 #include <stdlib.h>
25 #include <math.h>
26 #include <sys/types.h>
27
28 #include <utils/Errors.h>
29 #include <utils/Log.h>
30
31 #include <cutils/bitops.h>
32 #include <cutils/compiler.h>
33 #include <utils/Debug.h>
34
35 #include <system/audio.h>
36
37 #include <audio_utils/primitives.h>
38 #include <audio_utils/format.h>
39 #include <common_time/local_clock.h>
40 #include <common_time/cc_helper.h>
41
42 #include <media/EffectsFactoryApi.h>
43 #include <audio_effects/effect_downmix.h>
44
45 #include "AudioMixerOps.h"
46 #include "AudioMixer.h"
47
48 // The FCC_2 macro refers to the Fixed Channel Count of 2 for the legacy integer mixer.
49 #ifndef FCC_2
50 #define FCC_2 2
51 #endif
52
53 // Look for MONO_HACK for any Mono hack involving legacy mono channel to
54 // stereo channel conversion.
55
56 /* VERY_VERY_VERBOSE_LOGGING will show exactly which process hook and track hook is
57 * being used. This is a considerable amount of log spam, so don't enable unless you
58 * are verifying the hook based code.
59 */
60 //#define VERY_VERY_VERBOSE_LOGGING
61 #ifdef VERY_VERY_VERBOSE_LOGGING
62 #define ALOGVV ALOGV
63 //define ALOGVV printf // for test-mixer.cpp
64 #else
65 #define ALOGVV(a...) do { } while (0)
66 #endif
67
68 #ifndef ARRAY_SIZE
69 #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
70 #endif
71
72 // Set kUseNewMixer to true to use the new mixer engine. Otherwise the
73 // original code will be used. This is false for now.
74 static const bool kUseNewMixer = false;
75
76 // Set kUseFloat to true to allow floating input into the mixer engine.
77 // If kUseNewMixer is false, this is ignored or may be overridden internally
78 // because of downmix/upmix support.
79 static const bool kUseFloat = true;
80
81 // Set to default copy buffer size in frames for input processing.
82 static const size_t kCopyBufferFrameCount = 256;
83
84 namespace android {
85
86 // ----------------------------------------------------------------------------
87
88 template <typename T>
min(const T & a,const T & b)89 T min(const T& a, const T& b)
90 {
91 return a < b ? a : b;
92 }
93
CopyBufferProvider(size_t inputFrameSize,size_t outputFrameSize,size_t bufferFrameCount)94 AudioMixer::CopyBufferProvider::CopyBufferProvider(size_t inputFrameSize,
95 size_t outputFrameSize, size_t bufferFrameCount) :
96 mInputFrameSize(inputFrameSize),
97 mOutputFrameSize(outputFrameSize),
98 mLocalBufferFrameCount(bufferFrameCount),
99 mLocalBufferData(NULL),
100 mConsumed(0)
101 {
102 ALOGV("CopyBufferProvider(%p)(%zu, %zu, %zu)", this,
103 inputFrameSize, outputFrameSize, bufferFrameCount);
104 LOG_ALWAYS_FATAL_IF(inputFrameSize < outputFrameSize && bufferFrameCount == 0,
105 "Requires local buffer if inputFrameSize(%zu) < outputFrameSize(%zu)",
106 inputFrameSize, outputFrameSize);
107 if (mLocalBufferFrameCount) {
108 (void)posix_memalign(&mLocalBufferData, 32, mLocalBufferFrameCount * mOutputFrameSize);
109 }
110 mBuffer.frameCount = 0;
111 }
112
~CopyBufferProvider()113 AudioMixer::CopyBufferProvider::~CopyBufferProvider()
114 {
115 ALOGV("~CopyBufferProvider(%p)", this);
116 if (mBuffer.frameCount != 0) {
117 mTrackBufferProvider->releaseBuffer(&mBuffer);
118 }
119 free(mLocalBufferData);
120 }
121
getNextBuffer(AudioBufferProvider::Buffer * pBuffer,int64_t pts)122 status_t AudioMixer::CopyBufferProvider::getNextBuffer(AudioBufferProvider::Buffer *pBuffer,
123 int64_t pts)
124 {
125 //ALOGV("CopyBufferProvider(%p)::getNextBuffer(%p (%zu), %lld)",
126 // this, pBuffer, pBuffer->frameCount, pts);
127 if (mLocalBufferFrameCount == 0) {
128 status_t res = mTrackBufferProvider->getNextBuffer(pBuffer, pts);
129 if (res == OK) {
130 copyFrames(pBuffer->raw, pBuffer->raw, pBuffer->frameCount);
131 }
132 return res;
133 }
134 if (mBuffer.frameCount == 0) {
135 mBuffer.frameCount = pBuffer->frameCount;
136 status_t res = mTrackBufferProvider->getNextBuffer(&mBuffer, pts);
137 // At one time an upstream buffer provider had
138 // res == OK and mBuffer.frameCount == 0, doesn't seem to happen now 7/18/2014.
139 //
140 // By API spec, if res != OK, then mBuffer.frameCount == 0.
141 // but there may be improper implementations.
142 ALOG_ASSERT(res == OK || mBuffer.frameCount == 0);
143 if (res != OK || mBuffer.frameCount == 0) { // not needed by API spec, but to be safe.
144 pBuffer->raw = NULL;
145 pBuffer->frameCount = 0;
146 return res;
147 }
148 mConsumed = 0;
149 }
150 ALOG_ASSERT(mConsumed < mBuffer.frameCount);
151 size_t count = min(mLocalBufferFrameCount, mBuffer.frameCount - mConsumed);
152 count = min(count, pBuffer->frameCount);
153 pBuffer->raw = mLocalBufferData;
154 pBuffer->frameCount = count;
155 copyFrames(pBuffer->raw, (uint8_t*)mBuffer.raw + mConsumed * mInputFrameSize,
156 pBuffer->frameCount);
157 return OK;
158 }
159
releaseBuffer(AudioBufferProvider::Buffer * pBuffer)160 void AudioMixer::CopyBufferProvider::releaseBuffer(AudioBufferProvider::Buffer *pBuffer)
161 {
162 //ALOGV("CopyBufferProvider(%p)::releaseBuffer(%p(%zu))",
163 // this, pBuffer, pBuffer->frameCount);
164 if (mLocalBufferFrameCount == 0) {
165 mTrackBufferProvider->releaseBuffer(pBuffer);
166 return;
167 }
168 // LOG_ALWAYS_FATAL_IF(pBuffer->frameCount == 0, "Invalid framecount");
169 mConsumed += pBuffer->frameCount; // TODO: update for efficiency to reuse existing content
170 if (mConsumed != 0 && mConsumed >= mBuffer.frameCount) {
171 mTrackBufferProvider->releaseBuffer(&mBuffer);
172 ALOG_ASSERT(mBuffer.frameCount == 0);
173 }
174 pBuffer->raw = NULL;
175 pBuffer->frameCount = 0;
176 }
177
reset()178 void AudioMixer::CopyBufferProvider::reset()
179 {
180 if (mBuffer.frameCount != 0) {
181 mTrackBufferProvider->releaseBuffer(&mBuffer);
182 }
183 mConsumed = 0;
184 }
185
DownmixerBufferProvider(audio_channel_mask_t inputChannelMask,audio_channel_mask_t outputChannelMask,audio_format_t format,uint32_t sampleRate,int32_t sessionId,size_t bufferFrameCount)186 AudioMixer::DownmixerBufferProvider::DownmixerBufferProvider(
187 audio_channel_mask_t inputChannelMask,
188 audio_channel_mask_t outputChannelMask, audio_format_t format,
189 uint32_t sampleRate, int32_t sessionId, size_t bufferFrameCount) :
190 CopyBufferProvider(
191 audio_bytes_per_sample(format) * audio_channel_count_from_out_mask(inputChannelMask),
192 audio_bytes_per_sample(format) * audio_channel_count_from_out_mask(outputChannelMask),
193 bufferFrameCount) // set bufferFrameCount to 0 to do in-place
194 {
195 ALOGV("DownmixerBufferProvider(%p)(%#x, %#x, %#x %u %d)",
196 this, inputChannelMask, outputChannelMask, format,
197 sampleRate, sessionId);
198 if (!sIsMultichannelCapable
199 || EffectCreate(&sDwnmFxDesc.uuid,
200 sessionId,
201 SESSION_ID_INVALID_AND_IGNORED,
202 &mDownmixHandle) != 0) {
203 ALOGE("DownmixerBufferProvider() error creating downmixer effect");
204 mDownmixHandle = NULL;
205 return;
206 }
207 // channel input configuration will be overridden per-track
208 mDownmixConfig.inputCfg.channels = inputChannelMask; // FIXME: Should be bits
209 mDownmixConfig.outputCfg.channels = outputChannelMask; // FIXME: should be bits
210 mDownmixConfig.inputCfg.format = format;
211 mDownmixConfig.outputCfg.format = format;
212 mDownmixConfig.inputCfg.samplingRate = sampleRate;
213 mDownmixConfig.outputCfg.samplingRate = sampleRate;
214 mDownmixConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
215 mDownmixConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
216 // input and output buffer provider, and frame count will not be used as the downmix effect
217 // process() function is called directly (see DownmixerBufferProvider::getNextBuffer())
218 mDownmixConfig.inputCfg.mask = EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS |
219 EFFECT_CONFIG_FORMAT | EFFECT_CONFIG_ACC_MODE;
220 mDownmixConfig.outputCfg.mask = mDownmixConfig.inputCfg.mask;
221
222 int cmdStatus;
223 uint32_t replySize = sizeof(int);
224
225 // Configure downmixer
226 status_t status = (*mDownmixHandle)->command(mDownmixHandle,
227 EFFECT_CMD_SET_CONFIG /*cmdCode*/, sizeof(effect_config_t) /*cmdSize*/,
228 &mDownmixConfig /*pCmdData*/,
229 &replySize, &cmdStatus /*pReplyData*/);
230 if (status != 0 || cmdStatus != 0) {
231 ALOGE("DownmixerBufferProvider() error %d cmdStatus %d while configuring downmixer",
232 status, cmdStatus);
233 EffectRelease(mDownmixHandle);
234 mDownmixHandle = NULL;
235 return;
236 }
237
238 // Enable downmixer
239 replySize = sizeof(int);
240 status = (*mDownmixHandle)->command(mDownmixHandle,
241 EFFECT_CMD_ENABLE /*cmdCode*/, 0 /*cmdSize*/, NULL /*pCmdData*/,
242 &replySize, &cmdStatus /*pReplyData*/);
243 if (status != 0 || cmdStatus != 0) {
244 ALOGE("DownmixerBufferProvider() error %d cmdStatus %d while enabling downmixer",
245 status, cmdStatus);
246 EffectRelease(mDownmixHandle);
247 mDownmixHandle = NULL;
248 return;
249 }
250
251 // Set downmix type
252 // parameter size rounded for padding on 32bit boundary
253 const int psizePadded = ((sizeof(downmix_params_t) - 1)/sizeof(int) + 1) * sizeof(int);
254 const int downmixParamSize =
255 sizeof(effect_param_t) + psizePadded + sizeof(downmix_type_t);
256 effect_param_t * const param = (effect_param_t *) malloc(downmixParamSize);
257 param->psize = sizeof(downmix_params_t);
258 const downmix_params_t downmixParam = DOWNMIX_PARAM_TYPE;
259 memcpy(param->data, &downmixParam, param->psize);
260 const downmix_type_t downmixType = DOWNMIX_TYPE_FOLD;
261 param->vsize = sizeof(downmix_type_t);
262 memcpy(param->data + psizePadded, &downmixType, param->vsize);
263 replySize = sizeof(int);
264 status = (*mDownmixHandle)->command(mDownmixHandle,
265 EFFECT_CMD_SET_PARAM /* cmdCode */, downmixParamSize /* cmdSize */,
266 param /*pCmdData*/, &replySize, &cmdStatus /*pReplyData*/);
267 free(param);
268 if (status != 0 || cmdStatus != 0) {
269 ALOGE("DownmixerBufferProvider() error %d cmdStatus %d while setting downmix type",
270 status, cmdStatus);
271 EffectRelease(mDownmixHandle);
272 mDownmixHandle = NULL;
273 return;
274 }
275 ALOGV("DownmixerBufferProvider() downmix type set to %d", (int) downmixType);
276 }
277
~DownmixerBufferProvider()278 AudioMixer::DownmixerBufferProvider::~DownmixerBufferProvider()
279 {
280 ALOGV("~DownmixerBufferProvider (%p)", this);
281 EffectRelease(mDownmixHandle);
282 mDownmixHandle = NULL;
283 }
284
copyFrames(void * dst,const void * src,size_t frames)285 void AudioMixer::DownmixerBufferProvider::copyFrames(void *dst, const void *src, size_t frames)
286 {
287 mDownmixConfig.inputCfg.buffer.frameCount = frames;
288 mDownmixConfig.inputCfg.buffer.raw = const_cast<void *>(src);
289 mDownmixConfig.outputCfg.buffer.frameCount = frames;
290 mDownmixConfig.outputCfg.buffer.raw = dst;
291 // may be in-place if src == dst.
292 status_t res = (*mDownmixHandle)->process(mDownmixHandle,
293 &mDownmixConfig.inputCfg.buffer, &mDownmixConfig.outputCfg.buffer);
294 ALOGE_IF(res != OK, "DownmixBufferProvider error %d", res);
295 }
296
297 /* call once in a pthread_once handler. */
init()298 /*static*/ status_t AudioMixer::DownmixerBufferProvider::init()
299 {
300 // find multichannel downmix effect if we have to play multichannel content
301 uint32_t numEffects = 0;
302 int ret = EffectQueryNumberEffects(&numEffects);
303 if (ret != 0) {
304 ALOGE("AudioMixer() error %d querying number of effects", ret);
305 return NO_INIT;
306 }
307 ALOGV("EffectQueryNumberEffects() numEffects=%d", numEffects);
308
309 for (uint32_t i = 0 ; i < numEffects ; i++) {
310 if (EffectQueryEffect(i, &sDwnmFxDesc) == 0) {
311 ALOGV("effect %d is called %s", i, sDwnmFxDesc.name);
312 if (memcmp(&sDwnmFxDesc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0) {
313 ALOGI("found effect \"%s\" from %s",
314 sDwnmFxDesc.name, sDwnmFxDesc.implementor);
315 sIsMultichannelCapable = true;
316 break;
317 }
318 }
319 }
320 ALOGW_IF(!sIsMultichannelCapable, "unable to find downmix effect");
321 return NO_INIT;
322 }
323
324 /*static*/ bool AudioMixer::DownmixerBufferProvider::sIsMultichannelCapable = false;
325 /*static*/ effect_descriptor_t AudioMixer::DownmixerBufferProvider::sDwnmFxDesc;
326
RemixBufferProvider(audio_channel_mask_t inputChannelMask,audio_channel_mask_t outputChannelMask,audio_format_t format,size_t bufferFrameCount)327 AudioMixer::RemixBufferProvider::RemixBufferProvider(audio_channel_mask_t inputChannelMask,
328 audio_channel_mask_t outputChannelMask, audio_format_t format,
329 size_t bufferFrameCount) :
330 CopyBufferProvider(
331 audio_bytes_per_sample(format)
332 * audio_channel_count_from_out_mask(inputChannelMask),
333 audio_bytes_per_sample(format)
334 * audio_channel_count_from_out_mask(outputChannelMask),
335 bufferFrameCount),
336 mFormat(format),
337 mSampleSize(audio_bytes_per_sample(format)),
338 mInputChannels(audio_channel_count_from_out_mask(inputChannelMask)),
339 mOutputChannels(audio_channel_count_from_out_mask(outputChannelMask))
340 {
341 ALOGV("RemixBufferProvider(%p)(%#x, %#x, %#x) %zu %zu",
342 this, format, inputChannelMask, outputChannelMask,
343 mInputChannels, mOutputChannels);
344 // TODO: consider channel representation in index array formulation
345 // We ignore channel representation, and just use the bits.
346 memcpy_by_index_array_initialization(mIdxAry, ARRAY_SIZE(mIdxAry),
347 audio_channel_mask_get_bits(outputChannelMask),
348 audio_channel_mask_get_bits(inputChannelMask));
349 }
350
copyFrames(void * dst,const void * src,size_t frames)351 void AudioMixer::RemixBufferProvider::copyFrames(void *dst, const void *src, size_t frames)
352 {
353 memcpy_by_index_array(dst, mOutputChannels,
354 src, mInputChannels, mIdxAry, mSampleSize, frames);
355 }
356
ReformatBufferProvider(int32_t channels,audio_format_t inputFormat,audio_format_t outputFormat,size_t bufferFrameCount)357 AudioMixer::ReformatBufferProvider::ReformatBufferProvider(int32_t channels,
358 audio_format_t inputFormat, audio_format_t outputFormat,
359 size_t bufferFrameCount) :
360 CopyBufferProvider(
361 channels * audio_bytes_per_sample(inputFormat),
362 channels * audio_bytes_per_sample(outputFormat),
363 bufferFrameCount),
364 mChannels(channels),
365 mInputFormat(inputFormat),
366 mOutputFormat(outputFormat)
367 {
368 ALOGV("ReformatBufferProvider(%p)(%d, %#x, %#x)", this, channels, inputFormat, outputFormat);
369 }
370
copyFrames(void * dst,const void * src,size_t frames)371 void AudioMixer::ReformatBufferProvider::copyFrames(void *dst, const void *src, size_t frames)
372 {
373 memcpy_by_audio_format(dst, mOutputFormat, src, mInputFormat, frames * mChannels);
374 }
375
376 // ----------------------------------------------------------------------------
377
378 // Ensure mConfiguredNames bitmask is initialized properly on all architectures.
379 // The value of 1 << x is undefined in C when x >= 32.
380
AudioMixer(size_t frameCount,uint32_t sampleRate,uint32_t maxNumTracks)381 AudioMixer::AudioMixer(size_t frameCount, uint32_t sampleRate, uint32_t maxNumTracks)
382 : mTrackNames(0), mConfiguredNames((maxNumTracks >= 32 ? 0 : 1 << maxNumTracks) - 1),
383 mSampleRate(sampleRate)
384 {
385 ALOG_ASSERT(maxNumTracks <= MAX_NUM_TRACKS, "maxNumTracks %u > MAX_NUM_TRACKS %u",
386 maxNumTracks, MAX_NUM_TRACKS);
387
388 // AudioMixer is not yet capable of more than 32 active track inputs
389 ALOG_ASSERT(32 >= MAX_NUM_TRACKS, "bad MAX_NUM_TRACKS %d", MAX_NUM_TRACKS);
390
391 pthread_once(&sOnceControl, &sInitRoutine);
392
393 mState.enabledTracks= 0;
394 mState.needsChanged = 0;
395 mState.frameCount = frameCount;
396 mState.hook = process__nop;
397 mState.outputTemp = NULL;
398 mState.resampleTemp = NULL;
399 mState.mLog = &mDummyLog;
400 // mState.reserved
401
402 // FIXME Most of the following initialization is probably redundant since
403 // tracks[i] should only be referenced if (mTrackNames & (1 << i)) != 0
404 // and mTrackNames is initially 0. However, leave it here until that's verified.
405 track_t* t = mState.tracks;
406 for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) {
407 t->resampler = NULL;
408 t->downmixerBufferProvider = NULL;
409 t->mReformatBufferProvider = NULL;
410 t++;
411 }
412
413 }
414
~AudioMixer()415 AudioMixer::~AudioMixer()
416 {
417 track_t* t = mState.tracks;
418 for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) {
419 delete t->resampler;
420 delete t->downmixerBufferProvider;
421 delete t->mReformatBufferProvider;
422 t++;
423 }
424 delete [] mState.outputTemp;
425 delete [] mState.resampleTemp;
426 }
427
setLog(NBLog::Writer * log)428 void AudioMixer::setLog(NBLog::Writer *log)
429 {
430 mState.mLog = log;
431 }
432
getTrackName(audio_channel_mask_t channelMask,audio_format_t format,int sessionId)433 int AudioMixer::getTrackName(audio_channel_mask_t channelMask,
434 audio_format_t format, int sessionId)
435 {
436 if (!isValidPcmTrackFormat(format)) {
437 ALOGE("AudioMixer::getTrackName invalid format (%#x)", format);
438 return -1;
439 }
440 uint32_t names = (~mTrackNames) & mConfiguredNames;
441 if (names != 0) {
442 int n = __builtin_ctz(names);
443 ALOGV("add track (%d)", n);
444 // assume default parameters for the track, except where noted below
445 track_t* t = &mState.tracks[n];
446 t->needs = 0;
447
448 // Integer volume.
449 // Currently integer volume is kept for the legacy integer mixer.
450 // Will be removed when the legacy mixer path is removed.
451 t->volume[0] = UNITY_GAIN_INT;
452 t->volume[1] = UNITY_GAIN_INT;
453 t->prevVolume[0] = UNITY_GAIN_INT << 16;
454 t->prevVolume[1] = UNITY_GAIN_INT << 16;
455 t->volumeInc[0] = 0;
456 t->volumeInc[1] = 0;
457 t->auxLevel = 0;
458 t->auxInc = 0;
459 t->prevAuxLevel = 0;
460
461 // Floating point volume.
462 t->mVolume[0] = UNITY_GAIN_FLOAT;
463 t->mVolume[1] = UNITY_GAIN_FLOAT;
464 t->mPrevVolume[0] = UNITY_GAIN_FLOAT;
465 t->mPrevVolume[1] = UNITY_GAIN_FLOAT;
466 t->mVolumeInc[0] = 0.;
467 t->mVolumeInc[1] = 0.;
468 t->mAuxLevel = 0.;
469 t->mAuxInc = 0.;
470 t->mPrevAuxLevel = 0.;
471
472 // no initialization needed
473 // t->frameCount
474 t->channelCount = audio_channel_count_from_out_mask(channelMask);
475 t->enabled = false;
476 ALOGV_IF(audio_channel_mask_get_bits(channelMask) != AUDIO_CHANNEL_OUT_STEREO,
477 "Non-stereo channel mask: %d\n", channelMask);
478 t->channelMask = channelMask;
479 t->sessionId = sessionId;
480 // setBufferProvider(name, AudioBufferProvider *) is required before enable(name)
481 t->bufferProvider = NULL;
482 t->buffer.raw = NULL;
483 // no initialization needed
484 // t->buffer.frameCount
485 t->hook = NULL;
486 t->in = NULL;
487 t->resampler = NULL;
488 t->sampleRate = mSampleRate;
489 // setParameter(name, TRACK, MAIN_BUFFER, mixBuffer) is required before enable(name)
490 t->mainBuffer = NULL;
491 t->auxBuffer = NULL;
492 t->mInputBufferProvider = NULL;
493 t->mReformatBufferProvider = NULL;
494 t->downmixerBufferProvider = NULL;
495 t->mMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
496 t->mFormat = format;
497 t->mMixerInFormat = kUseFloat && kUseNewMixer
498 ? AUDIO_FORMAT_PCM_FLOAT : AUDIO_FORMAT_PCM_16_BIT;
499 t->mMixerChannelMask = audio_channel_mask_from_representation_and_bits(
500 AUDIO_CHANNEL_REPRESENTATION_POSITION, AUDIO_CHANNEL_OUT_STEREO);
501 t->mMixerChannelCount = audio_channel_count_from_out_mask(t->mMixerChannelMask);
502 // Check the downmixing (or upmixing) requirements.
503 status_t status = initTrackDownmix(t, n);
504 if (status != OK) {
505 ALOGE("AudioMixer::getTrackName invalid channelMask (%#x)", channelMask);
506 return -1;
507 }
508 // initTrackDownmix() may change the input format requirement.
509 // If you desire floating point input to the mixer, it may change
510 // to integer because the downmixer requires integer to process.
511 ALOGVV("mMixerFormat:%#x mMixerInFormat:%#x\n", t->mMixerFormat, t->mMixerInFormat);
512 prepareTrackForReformat(t, n);
513 mTrackNames |= 1 << n;
514 return TRACK0 + n;
515 }
516 ALOGE("AudioMixer::getTrackName out of available tracks");
517 return -1;
518 }
519
invalidateState(uint32_t mask)520 void AudioMixer::invalidateState(uint32_t mask)
521 {
522 if (mask != 0) {
523 mState.needsChanged |= mask;
524 mState.hook = process__validate;
525 }
526 }
527
528 // Called when channel masks have changed for a track name
529 // TODO: Fix Downmixbufferprofider not to (possibly) change mixer input format,
530 // which will simplify this logic.
setChannelMasks(int name,audio_channel_mask_t trackChannelMask,audio_channel_mask_t mixerChannelMask)531 bool AudioMixer::setChannelMasks(int name,
532 audio_channel_mask_t trackChannelMask, audio_channel_mask_t mixerChannelMask) {
533 track_t &track = mState.tracks[name];
534
535 if (trackChannelMask == track.channelMask
536 && mixerChannelMask == track.mMixerChannelMask) {
537 return false; // no need to change
538 }
539 // always recompute for both channel masks even if only one has changed.
540 const uint32_t trackChannelCount = audio_channel_count_from_out_mask(trackChannelMask);
541 const uint32_t mixerChannelCount = audio_channel_count_from_out_mask(mixerChannelMask);
542 const bool mixerChannelCountChanged = track.mMixerChannelCount != mixerChannelCount;
543
544 ALOG_ASSERT((trackChannelCount <= MAX_NUM_CHANNELS_TO_DOWNMIX)
545 && trackChannelCount
546 && mixerChannelCount);
547 track.channelMask = trackChannelMask;
548 track.channelCount = trackChannelCount;
549 track.mMixerChannelMask = mixerChannelMask;
550 track.mMixerChannelCount = mixerChannelCount;
551
552 // channel masks have changed, does this track need a downmixer?
553 // update to try using our desired format (if we aren't already using it)
554 const audio_format_t prevMixerInFormat = track.mMixerInFormat;
555 track.mMixerInFormat = kUseFloat && kUseNewMixer
556 ? AUDIO_FORMAT_PCM_FLOAT : AUDIO_FORMAT_PCM_16_BIT;
557 const status_t status = initTrackDownmix(&mState.tracks[name], name);
558 ALOGE_IF(status != OK,
559 "initTrackDownmix error %d, track channel mask %#x, mixer channel mask %#x",
560 status, track.channelMask, track.mMixerChannelMask);
561
562 const bool mixerInFormatChanged = prevMixerInFormat != track.mMixerInFormat;
563 if (mixerInFormatChanged) {
564 prepareTrackForReformat(&track, name); // because of downmixer, track format may change!
565 }
566
567 if (track.resampler && (mixerInFormatChanged || mixerChannelCountChanged)) {
568 // resampler input format or channels may have changed.
569 const uint32_t resetToSampleRate = track.sampleRate;
570 delete track.resampler;
571 track.resampler = NULL;
572 track.sampleRate = mSampleRate; // without resampler, track rate is device sample rate.
573 // recreate the resampler with updated format, channels, saved sampleRate.
574 track.setResampler(resetToSampleRate /*trackSampleRate*/, mSampleRate /*devSampleRate*/);
575 }
576 return true;
577 }
578
initTrackDownmix(track_t * pTrack,int trackName)579 status_t AudioMixer::initTrackDownmix(track_t* pTrack, int trackName)
580 {
581 // Only remix (upmix or downmix) if the track and mixer/device channel masks
582 // are not the same and not handled internally, as mono -> stereo currently is.
583 if (pTrack->channelMask != pTrack->mMixerChannelMask
584 && !(pTrack->channelMask == AUDIO_CHANNEL_OUT_MONO
585 && pTrack->mMixerChannelMask == AUDIO_CHANNEL_OUT_STEREO)) {
586 return prepareTrackForDownmix(pTrack, trackName);
587 }
588 // no remix necessary
589 unprepareTrackForDownmix(pTrack, trackName);
590 return NO_ERROR;
591 }
592
unprepareTrackForDownmix(track_t * pTrack,int trackName __unused)593 void AudioMixer::unprepareTrackForDownmix(track_t* pTrack, int trackName __unused) {
594 ALOGV("AudioMixer::unprepareTrackForDownmix(%d)", trackName);
595
596 if (pTrack->downmixerBufferProvider != NULL) {
597 // this track had previously been configured with a downmixer, delete it
598 ALOGV(" deleting old downmixer");
599 delete pTrack->downmixerBufferProvider;
600 pTrack->downmixerBufferProvider = NULL;
601 reconfigureBufferProviders(pTrack);
602 } else {
603 ALOGV(" nothing to do, no downmixer to delete");
604 }
605 }
606
prepareTrackForDownmix(track_t * pTrack,int trackName)607 status_t AudioMixer::prepareTrackForDownmix(track_t* pTrack, int trackName)
608 {
609 ALOGV("AudioMixer::prepareTrackForDownmix(%d) with mask 0x%x", trackName, pTrack->channelMask);
610
611 // discard the previous downmixer if there was one
612 unprepareTrackForDownmix(pTrack, trackName);
613 if (DownmixerBufferProvider::isMultichannelCapable()) {
614 DownmixerBufferProvider* pDbp = new DownmixerBufferProvider(pTrack->channelMask,
615 pTrack->mMixerChannelMask,
616 AUDIO_FORMAT_PCM_16_BIT /* TODO: use pTrack->mMixerInFormat, now only PCM 16 */,
617 pTrack->sampleRate, pTrack->sessionId, kCopyBufferFrameCount);
618
619 if (pDbp->isValid()) { // if constructor completed properly
620 pTrack->mMixerInFormat = AUDIO_FORMAT_PCM_16_BIT; // PCM 16 bit required for downmix
621 pTrack->downmixerBufferProvider = pDbp;
622 reconfigureBufferProviders(pTrack);
623 return NO_ERROR;
624 }
625 delete pDbp;
626 }
627
628 // Effect downmixer does not accept the channel conversion. Let's use our remixer.
629 RemixBufferProvider* pRbp = new RemixBufferProvider(pTrack->channelMask,
630 pTrack->mMixerChannelMask, pTrack->mMixerInFormat, kCopyBufferFrameCount);
631 // Remix always finds a conversion whereas Downmixer effect above may fail.
632 pTrack->downmixerBufferProvider = pRbp;
633 reconfigureBufferProviders(pTrack);
634 return NO_ERROR;
635 }
636
unprepareTrackForReformat(track_t * pTrack,int trackName __unused)637 void AudioMixer::unprepareTrackForReformat(track_t* pTrack, int trackName __unused) {
638 ALOGV("AudioMixer::unprepareTrackForReformat(%d)", trackName);
639 if (pTrack->mReformatBufferProvider != NULL) {
640 delete pTrack->mReformatBufferProvider;
641 pTrack->mReformatBufferProvider = NULL;
642 reconfigureBufferProviders(pTrack);
643 }
644 }
645
prepareTrackForReformat(track_t * pTrack,int trackName)646 status_t AudioMixer::prepareTrackForReformat(track_t* pTrack, int trackName)
647 {
648 ALOGV("AudioMixer::prepareTrackForReformat(%d) with format %#x", trackName, pTrack->mFormat);
649 // discard the previous reformatter if there was one
650 unprepareTrackForReformat(pTrack, trackName);
651 // only configure reformatter if needed
652 if (pTrack->mFormat != pTrack->mMixerInFormat) {
653 pTrack->mReformatBufferProvider = new ReformatBufferProvider(
654 audio_channel_count_from_out_mask(pTrack->channelMask),
655 pTrack->mFormat, pTrack->mMixerInFormat,
656 kCopyBufferFrameCount);
657 reconfigureBufferProviders(pTrack);
658 }
659 return NO_ERROR;
660 }
661
reconfigureBufferProviders(track_t * pTrack)662 void AudioMixer::reconfigureBufferProviders(track_t* pTrack)
663 {
664 pTrack->bufferProvider = pTrack->mInputBufferProvider;
665 if (pTrack->mReformatBufferProvider) {
666 pTrack->mReformatBufferProvider->setBufferProvider(pTrack->bufferProvider);
667 pTrack->bufferProvider = pTrack->mReformatBufferProvider;
668 }
669 if (pTrack->downmixerBufferProvider) {
670 pTrack->downmixerBufferProvider->setBufferProvider(pTrack->bufferProvider);
671 pTrack->bufferProvider = pTrack->downmixerBufferProvider;
672 }
673 }
674
deleteTrackName(int name)675 void AudioMixer::deleteTrackName(int name)
676 {
677 ALOGV("AudioMixer::deleteTrackName(%d)", name);
678 name -= TRACK0;
679 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
680 ALOGV("deleteTrackName(%d)", name);
681 track_t& track(mState.tracks[ name ]);
682 if (track.enabled) {
683 track.enabled = false;
684 invalidateState(1<<name);
685 }
686 // delete the resampler
687 delete track.resampler;
688 track.resampler = NULL;
689 // delete the downmixer
690 unprepareTrackForDownmix(&mState.tracks[name], name);
691 // delete the reformatter
692 unprepareTrackForReformat(&mState.tracks[name], name);
693
694 mTrackNames &= ~(1<<name);
695 }
696
enable(int name)697 void AudioMixer::enable(int name)
698 {
699 name -= TRACK0;
700 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
701 track_t& track = mState.tracks[name];
702
703 if (!track.enabled) {
704 track.enabled = true;
705 ALOGV("enable(%d)", name);
706 invalidateState(1 << name);
707 }
708 }
709
disable(int name)710 void AudioMixer::disable(int name)
711 {
712 name -= TRACK0;
713 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
714 track_t& track = mState.tracks[name];
715
716 if (track.enabled) {
717 track.enabled = false;
718 ALOGV("disable(%d)", name);
719 invalidateState(1 << name);
720 }
721 }
722
723 /* Sets the volume ramp variables for the AudioMixer.
724 *
725 * The volume ramp variables are used to transition from the previous
726 * volume to the set volume. ramp controls the duration of the transition.
727 * Its value is typically one state framecount period, but may also be 0,
728 * meaning "immediate."
729 *
730 * FIXME: 1) Volume ramp is enabled only if there is a nonzero integer increment
731 * even if there is a nonzero floating point increment (in that case, the volume
732 * change is immediate). This restriction should be changed when the legacy mixer
733 * is removed (see #2).
734 * FIXME: 2) Integer volume variables are used for Legacy mixing and should be removed
735 * when no longer needed.
736 *
737 * @param newVolume set volume target in floating point [0.0, 1.0].
738 * @param ramp number of frames to increment over. if ramp is 0, the volume
739 * should be set immediately. Currently ramp should not exceed 65535 (frames).
740 * @param pIntSetVolume pointer to the U4.12 integer target volume, set on return.
741 * @param pIntPrevVolume pointer to the U4.28 integer previous volume, set on return.
742 * @param pIntVolumeInc pointer to the U4.28 increment per output audio frame, set on return.
743 * @param pSetVolume pointer to the float target volume, set on return.
744 * @param pPrevVolume pointer to the float previous volume, set on return.
745 * @param pVolumeInc pointer to the float increment per output audio frame, set on return.
746 * @return true if the volume has changed, false if volume is same.
747 */
setVolumeRampVariables(float newVolume,int32_t ramp,int16_t * pIntSetVolume,int32_t * pIntPrevVolume,int32_t * pIntVolumeInc,float * pSetVolume,float * pPrevVolume,float * pVolumeInc)748 static inline bool setVolumeRampVariables(float newVolume, int32_t ramp,
749 int16_t *pIntSetVolume, int32_t *pIntPrevVolume, int32_t *pIntVolumeInc,
750 float *pSetVolume, float *pPrevVolume, float *pVolumeInc) {
751 if (newVolume == *pSetVolume) {
752 return false;
753 }
754 /* set the floating point volume variables */
755 if (ramp != 0) {
756 *pVolumeInc = (newVolume - *pSetVolume) / ramp;
757 *pPrevVolume = *pSetVolume;
758 } else {
759 *pVolumeInc = 0;
760 *pPrevVolume = newVolume;
761 }
762 *pSetVolume = newVolume;
763
764 /* set the legacy integer volume variables */
765 int32_t intVolume = newVolume * AudioMixer::UNITY_GAIN_INT;
766 if (intVolume > AudioMixer::UNITY_GAIN_INT) {
767 intVolume = AudioMixer::UNITY_GAIN_INT;
768 } else if (intVolume < 0) {
769 ALOGE("negative volume %.7g", newVolume);
770 intVolume = 0; // should never happen, but for safety check.
771 }
772 if (intVolume == *pIntSetVolume) {
773 *pIntVolumeInc = 0;
774 /* TODO: integer/float workaround: ignore floating volume ramp */
775 *pVolumeInc = 0;
776 *pPrevVolume = newVolume;
777 return true;
778 }
779 if (ramp != 0) {
780 *pIntVolumeInc = ((intVolume - *pIntSetVolume) << 16) / ramp;
781 *pIntPrevVolume = (*pIntVolumeInc == 0 ? intVolume : *pIntSetVolume) << 16;
782 } else {
783 *pIntVolumeInc = 0;
784 *pIntPrevVolume = intVolume << 16;
785 }
786 *pIntSetVolume = intVolume;
787 return true;
788 }
789
setParameter(int name,int target,int param,void * value)790 void AudioMixer::setParameter(int name, int target, int param, void *value)
791 {
792 name -= TRACK0;
793 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
794 track_t& track = mState.tracks[name];
795
796 int valueInt = static_cast<int>(reinterpret_cast<uintptr_t>(value));
797 int32_t *valueBuf = reinterpret_cast<int32_t*>(value);
798
799 switch (target) {
800
801 case TRACK:
802 switch (param) {
803 case CHANNEL_MASK: {
804 const audio_channel_mask_t trackChannelMask =
805 static_cast<audio_channel_mask_t>(valueInt);
806 if (setChannelMasks(name, trackChannelMask, track.mMixerChannelMask)) {
807 ALOGV("setParameter(TRACK, CHANNEL_MASK, %x)", trackChannelMask);
808 invalidateState(1 << name);
809 }
810 } break;
811 case MAIN_BUFFER:
812 if (track.mainBuffer != valueBuf) {
813 track.mainBuffer = valueBuf;
814 ALOGV("setParameter(TRACK, MAIN_BUFFER, %p)", valueBuf);
815 invalidateState(1 << name);
816 }
817 break;
818 case AUX_BUFFER:
819 if (track.auxBuffer != valueBuf) {
820 track.auxBuffer = valueBuf;
821 ALOGV("setParameter(TRACK, AUX_BUFFER, %p)", valueBuf);
822 invalidateState(1 << name);
823 }
824 break;
825 case FORMAT: {
826 audio_format_t format = static_cast<audio_format_t>(valueInt);
827 if (track.mFormat != format) {
828 ALOG_ASSERT(audio_is_linear_pcm(format), "Invalid format %#x", format);
829 track.mFormat = format;
830 ALOGV("setParameter(TRACK, FORMAT, %#x)", format);
831 prepareTrackForReformat(&track, name);
832 invalidateState(1 << name);
833 }
834 } break;
835 // FIXME do we want to support setting the downmix type from AudioFlinger?
836 // for a specific track? or per mixer?
837 /* case DOWNMIX_TYPE:
838 break */
839 case MIXER_FORMAT: {
840 audio_format_t format = static_cast<audio_format_t>(valueInt);
841 if (track.mMixerFormat != format) {
842 track.mMixerFormat = format;
843 ALOGV("setParameter(TRACK, MIXER_FORMAT, %#x)", format);
844 }
845 } break;
846 case MIXER_CHANNEL_MASK: {
847 const audio_channel_mask_t mixerChannelMask =
848 static_cast<audio_channel_mask_t>(valueInt);
849 if (setChannelMasks(name, track.channelMask, mixerChannelMask)) {
850 ALOGV("setParameter(TRACK, MIXER_CHANNEL_MASK, %#x)", mixerChannelMask);
851 invalidateState(1 << name);
852 }
853 } break;
854 default:
855 LOG_ALWAYS_FATAL("setParameter track: bad param %d", param);
856 }
857 break;
858
859 case RESAMPLE:
860 switch (param) {
861 case SAMPLE_RATE:
862 ALOG_ASSERT(valueInt > 0, "bad sample rate %d", valueInt);
863 if (track.setResampler(uint32_t(valueInt), mSampleRate)) {
864 ALOGV("setParameter(RESAMPLE, SAMPLE_RATE, %u)",
865 uint32_t(valueInt));
866 invalidateState(1 << name);
867 }
868 break;
869 case RESET:
870 track.resetResampler();
871 invalidateState(1 << name);
872 break;
873 case REMOVE:
874 delete track.resampler;
875 track.resampler = NULL;
876 track.sampleRate = mSampleRate;
877 invalidateState(1 << name);
878 break;
879 default:
880 LOG_ALWAYS_FATAL("setParameter resample: bad param %d", param);
881 }
882 break;
883
884 case RAMP_VOLUME:
885 case VOLUME:
886 switch (param) {
887 case AUXLEVEL:
888 if (setVolumeRampVariables(*reinterpret_cast<float*>(value),
889 target == RAMP_VOLUME ? mState.frameCount : 0,
890 &track.auxLevel, &track.prevAuxLevel, &track.auxInc,
891 &track.mAuxLevel, &track.mPrevAuxLevel, &track.mAuxInc)) {
892 ALOGV("setParameter(%s, AUXLEVEL: %04x)",
893 target == VOLUME ? "VOLUME" : "RAMP_VOLUME", track.auxLevel);
894 invalidateState(1 << name);
895 }
896 break;
897 default:
898 if ((unsigned)param >= VOLUME0 && (unsigned)param < VOLUME0 + MAX_NUM_VOLUMES) {
899 if (setVolumeRampVariables(*reinterpret_cast<float*>(value),
900 target == RAMP_VOLUME ? mState.frameCount : 0,
901 &track.volume[param - VOLUME0], &track.prevVolume[param - VOLUME0],
902 &track.volumeInc[param - VOLUME0],
903 &track.mVolume[param - VOLUME0], &track.mPrevVolume[param - VOLUME0],
904 &track.mVolumeInc[param - VOLUME0])) {
905 ALOGV("setParameter(%s, VOLUME%d: %04x)",
906 target == VOLUME ? "VOLUME" : "RAMP_VOLUME", param - VOLUME0,
907 track.volume[param - VOLUME0]);
908 invalidateState(1 << name);
909 }
910 } else {
911 LOG_ALWAYS_FATAL("setParameter volume: bad param %d", param);
912 }
913 }
914 break;
915
916 default:
917 LOG_ALWAYS_FATAL("setParameter: bad target %d", target);
918 }
919 }
920
setResampler(uint32_t trackSampleRate,uint32_t devSampleRate)921 bool AudioMixer::track_t::setResampler(uint32_t trackSampleRate, uint32_t devSampleRate)
922 {
923 if (trackSampleRate != devSampleRate || resampler != NULL) {
924 if (sampleRate != trackSampleRate) {
925 sampleRate = trackSampleRate;
926 if (resampler == NULL) {
927 ALOGV("Creating resampler from track %d Hz to device %d Hz",
928 trackSampleRate, devSampleRate);
929 AudioResampler::src_quality quality;
930 // force lowest quality level resampler if use case isn't music or video
931 // FIXME this is flawed for dynamic sample rates, as we choose the resampler
932 // quality level based on the initial ratio, but that could change later.
933 // Should have a way to distinguish tracks with static ratios vs. dynamic ratios.
934 if (!((trackSampleRate == 44100 && devSampleRate == 48000) ||
935 (trackSampleRate == 48000 && devSampleRate == 44100))) {
936 quality = AudioResampler::DYN_LOW_QUALITY;
937 } else {
938 quality = AudioResampler::DEFAULT_QUALITY;
939 }
940
941 // TODO: Remove MONO_HACK. Resampler sees #channels after the downmixer
942 // but if none exists, it is the channel count (1 for mono).
943 const int resamplerChannelCount = downmixerBufferProvider != NULL
944 ? mMixerChannelCount : channelCount;
945 ALOGVV("Creating resampler:"
946 " format(%#x) channels(%d) devSampleRate(%u) quality(%d)\n",
947 mMixerInFormat, resamplerChannelCount, devSampleRate, quality);
948 resampler = AudioResampler::create(
949 mMixerInFormat,
950 resamplerChannelCount,
951 devSampleRate, quality);
952 resampler->setLocalTimeFreq(sLocalTimeFreq);
953 }
954 return true;
955 }
956 }
957 return false;
958 }
959
960 /* Checks to see if the volume ramp has completed and clears the increment
961 * variables appropriately.
962 *
963 * FIXME: There is code to handle int/float ramp variable switchover should it not
964 * complete within a mixer buffer processing call, but it is preferred to avoid switchover
965 * due to precision issues. The switchover code is included for legacy code purposes
966 * and can be removed once the integer volume is removed.
967 *
968 * It is not sufficient to clear only the volumeInc integer variable because
969 * if one channel requires ramping, all channels are ramped.
970 *
971 * There is a bit of duplicated code here, but it keeps backward compatibility.
972 */
adjustVolumeRamp(bool aux,bool useFloat)973 inline void AudioMixer::track_t::adjustVolumeRamp(bool aux, bool useFloat)
974 {
975 if (useFloat) {
976 for (uint32_t i = 0; i < MAX_NUM_VOLUMES; i++) {
977 if (mVolumeInc[i] != 0 && fabs(mVolume[i] - mPrevVolume[i]) <= fabs(mVolumeInc[i])) {
978 volumeInc[i] = 0;
979 prevVolume[i] = volume[i] << 16;
980 mVolumeInc[i] = 0.;
981 mPrevVolume[i] = mVolume[i];
982 } else {
983 //ALOGV("ramp: %f %f %f", mVolume[i], mPrevVolume[i], mVolumeInc[i]);
984 prevVolume[i] = u4_28_from_float(mPrevVolume[i]);
985 }
986 }
987 } else {
988 for (uint32_t i = 0; i < MAX_NUM_VOLUMES; i++) {
989 if (((volumeInc[i]>0) && (((prevVolume[i]+volumeInc[i])>>16) >= volume[i])) ||
990 ((volumeInc[i]<0) && (((prevVolume[i]+volumeInc[i])>>16) <= volume[i]))) {
991 volumeInc[i] = 0;
992 prevVolume[i] = volume[i] << 16;
993 mVolumeInc[i] = 0.;
994 mPrevVolume[i] = mVolume[i];
995 } else {
996 //ALOGV("ramp: %d %d %d", volume[i] << 16, prevVolume[i], volumeInc[i]);
997 mPrevVolume[i] = float_from_u4_28(prevVolume[i]);
998 }
999 }
1000 }
1001 /* TODO: aux is always integer regardless of output buffer type */
1002 if (aux) {
1003 if (((auxInc>0) && (((prevAuxLevel+auxInc)>>16) >= auxLevel)) ||
1004 ((auxInc<0) && (((prevAuxLevel+auxInc)>>16) <= auxLevel))) {
1005 auxInc = 0;
1006 prevAuxLevel = auxLevel << 16;
1007 mAuxInc = 0.;
1008 mPrevAuxLevel = mAuxLevel;
1009 } else {
1010 //ALOGV("aux ramp: %d %d %d", auxLevel << 16, prevAuxLevel, auxInc);
1011 }
1012 }
1013 }
1014
getUnreleasedFrames(int name) const1015 size_t AudioMixer::getUnreleasedFrames(int name) const
1016 {
1017 name -= TRACK0;
1018 if (uint32_t(name) < MAX_NUM_TRACKS) {
1019 return mState.tracks[name].getUnreleasedFrames();
1020 }
1021 return 0;
1022 }
1023
setBufferProvider(int name,AudioBufferProvider * bufferProvider)1024 void AudioMixer::setBufferProvider(int name, AudioBufferProvider* bufferProvider)
1025 {
1026 name -= TRACK0;
1027 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name);
1028
1029 if (mState.tracks[name].mInputBufferProvider == bufferProvider) {
1030 return; // don't reset any buffer providers if identical.
1031 }
1032 if (mState.tracks[name].mReformatBufferProvider != NULL) {
1033 mState.tracks[name].mReformatBufferProvider->reset();
1034 } else if (mState.tracks[name].downmixerBufferProvider != NULL) {
1035 }
1036
1037 mState.tracks[name].mInputBufferProvider = bufferProvider;
1038 reconfigureBufferProviders(&mState.tracks[name]);
1039 }
1040
1041
process(int64_t pts)1042 void AudioMixer::process(int64_t pts)
1043 {
1044 mState.hook(&mState, pts);
1045 }
1046
1047
process__validate(state_t * state,int64_t pts)1048 void AudioMixer::process__validate(state_t* state, int64_t pts)
1049 {
1050 ALOGW_IF(!state->needsChanged,
1051 "in process__validate() but nothing's invalid");
1052
1053 uint32_t changed = state->needsChanged;
1054 state->needsChanged = 0; // clear the validation flag
1055
1056 // recompute which tracks are enabled / disabled
1057 uint32_t enabled = 0;
1058 uint32_t disabled = 0;
1059 while (changed) {
1060 const int i = 31 - __builtin_clz(changed);
1061 const uint32_t mask = 1<<i;
1062 changed &= ~mask;
1063 track_t& t = state->tracks[i];
1064 (t.enabled ? enabled : disabled) |= mask;
1065 }
1066 state->enabledTracks &= ~disabled;
1067 state->enabledTracks |= enabled;
1068
1069 // compute everything we need...
1070 int countActiveTracks = 0;
1071 // TODO: fix all16BitsStereNoResample logic to
1072 // either properly handle muted tracks (it should ignore them)
1073 // or remove altogether as an obsolete optimization.
1074 bool all16BitsStereoNoResample = true;
1075 bool resampling = false;
1076 bool volumeRamp = false;
1077 uint32_t en = state->enabledTracks;
1078 while (en) {
1079 const int i = 31 - __builtin_clz(en);
1080 en &= ~(1<<i);
1081
1082 countActiveTracks++;
1083 track_t& t = state->tracks[i];
1084 uint32_t n = 0;
1085 // FIXME can overflow (mask is only 3 bits)
1086 n |= NEEDS_CHANNEL_1 + t.channelCount - 1;
1087 if (t.doesResample()) {
1088 n |= NEEDS_RESAMPLE;
1089 }
1090 if (t.auxLevel != 0 && t.auxBuffer != NULL) {
1091 n |= NEEDS_AUX;
1092 }
1093
1094 if (t.volumeInc[0]|t.volumeInc[1]) {
1095 volumeRamp = true;
1096 } else if (!t.doesResample() && t.volumeRL == 0) {
1097 n |= NEEDS_MUTE;
1098 }
1099 t.needs = n;
1100
1101 if (n & NEEDS_MUTE) {
1102 t.hook = track__nop;
1103 } else {
1104 if (n & NEEDS_AUX) {
1105 all16BitsStereoNoResample = false;
1106 }
1107 if (n & NEEDS_RESAMPLE) {
1108 all16BitsStereoNoResample = false;
1109 resampling = true;
1110 t.hook = getTrackHook(TRACKTYPE_RESAMPLE, t.mMixerChannelCount,
1111 t.mMixerInFormat, t.mMixerFormat);
1112 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2,
1113 "Track %d needs downmix + resample", i);
1114 } else {
1115 if ((n & NEEDS_CHANNEL_COUNT__MASK) == NEEDS_CHANNEL_1){
1116 t.hook = getTrackHook(
1117 t.mMixerChannelCount == 2 // TODO: MONO_HACK.
1118 ? TRACKTYPE_NORESAMPLEMONO : TRACKTYPE_NORESAMPLE,
1119 t.mMixerChannelCount,
1120 t.mMixerInFormat, t.mMixerFormat);
1121 all16BitsStereoNoResample = false;
1122 }
1123 if ((n & NEEDS_CHANNEL_COUNT__MASK) >= NEEDS_CHANNEL_2){
1124 t.hook = getTrackHook(TRACKTYPE_NORESAMPLE, t.mMixerChannelCount,
1125 t.mMixerInFormat, t.mMixerFormat);
1126 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2,
1127 "Track %d needs downmix", i);
1128 }
1129 }
1130 }
1131 }
1132
1133 // select the processing hooks
1134 state->hook = process__nop;
1135 if (countActiveTracks > 0) {
1136 if (resampling) {
1137 if (!state->outputTemp) {
1138 state->outputTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount];
1139 }
1140 if (!state->resampleTemp) {
1141 state->resampleTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount];
1142 }
1143 state->hook = process__genericResampling;
1144 } else {
1145 if (state->outputTemp) {
1146 delete [] state->outputTemp;
1147 state->outputTemp = NULL;
1148 }
1149 if (state->resampleTemp) {
1150 delete [] state->resampleTemp;
1151 state->resampleTemp = NULL;
1152 }
1153 state->hook = process__genericNoResampling;
1154 if (all16BitsStereoNoResample && !volumeRamp) {
1155 if (countActiveTracks == 1) {
1156 const int i = 31 - __builtin_clz(state->enabledTracks);
1157 track_t& t = state->tracks[i];
1158 if ((t.needs & NEEDS_MUTE) == 0) {
1159 // The check prevents a muted track from acquiring a process hook.
1160 //
1161 // This is dangerous if the track is MONO as that requires
1162 // special case handling due to implicit channel duplication.
1163 // Stereo or Multichannel should actually be fine here.
1164 state->hook = getProcessHook(PROCESSTYPE_NORESAMPLEONETRACK,
1165 t.mMixerChannelCount, t.mMixerInFormat, t.mMixerFormat);
1166 }
1167 }
1168 }
1169 }
1170 }
1171
1172 ALOGV("mixer configuration change: %d activeTracks (%08x) "
1173 "all16BitsStereoNoResample=%d, resampling=%d, volumeRamp=%d",
1174 countActiveTracks, state->enabledTracks,
1175 all16BitsStereoNoResample, resampling, volumeRamp);
1176
1177 state->hook(state, pts);
1178
1179 // Now that the volume ramp has been done, set optimal state and
1180 // track hooks for subsequent mixer process
1181 if (countActiveTracks > 0) {
1182 bool allMuted = true;
1183 uint32_t en = state->enabledTracks;
1184 while (en) {
1185 const int i = 31 - __builtin_clz(en);
1186 en &= ~(1<<i);
1187 track_t& t = state->tracks[i];
1188 if (!t.doesResample() && t.volumeRL == 0) {
1189 t.needs |= NEEDS_MUTE;
1190 t.hook = track__nop;
1191 } else {
1192 allMuted = false;
1193 }
1194 }
1195 if (allMuted) {
1196 state->hook = process__nop;
1197 } else if (all16BitsStereoNoResample) {
1198 if (countActiveTracks == 1) {
1199 const int i = 31 - __builtin_clz(state->enabledTracks);
1200 track_t& t = state->tracks[i];
1201 // Muted single tracks handled by allMuted above.
1202 state->hook = getProcessHook(PROCESSTYPE_NORESAMPLEONETRACK,
1203 t.mMixerChannelCount, t.mMixerInFormat, t.mMixerFormat);
1204 }
1205 }
1206 }
1207 }
1208
1209
track__genericResample(track_t * t,int32_t * out,size_t outFrameCount,int32_t * temp,int32_t * aux)1210 void AudioMixer::track__genericResample(track_t* t, int32_t* out, size_t outFrameCount,
1211 int32_t* temp, int32_t* aux)
1212 {
1213 ALOGVV("track__genericResample\n");
1214 t->resampler->setSampleRate(t->sampleRate);
1215
1216 // ramp gain - resample to temp buffer and scale/mix in 2nd step
1217 if (aux != NULL) {
1218 // always resample with unity gain when sending to auxiliary buffer to be able
1219 // to apply send level after resampling
1220 t->resampler->setVolume(UNITY_GAIN_FLOAT, UNITY_GAIN_FLOAT);
1221 memset(temp, 0, outFrameCount * t->mMixerChannelCount * sizeof(int32_t));
1222 t->resampler->resample(temp, outFrameCount, t->bufferProvider);
1223 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
1224 volumeRampStereo(t, out, outFrameCount, temp, aux);
1225 } else {
1226 volumeStereo(t, out, outFrameCount, temp, aux);
1227 }
1228 } else {
1229 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
1230 t->resampler->setVolume(UNITY_GAIN_FLOAT, UNITY_GAIN_FLOAT);
1231 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t));
1232 t->resampler->resample(temp, outFrameCount, t->bufferProvider);
1233 volumeRampStereo(t, out, outFrameCount, temp, aux);
1234 }
1235
1236 // constant gain
1237 else {
1238 t->resampler->setVolume(t->mVolume[0], t->mVolume[1]);
1239 t->resampler->resample(out, outFrameCount, t->bufferProvider);
1240 }
1241 }
1242 }
1243
track__nop(track_t * t __unused,int32_t * out __unused,size_t outFrameCount __unused,int32_t * temp __unused,int32_t * aux __unused)1244 void AudioMixer::track__nop(track_t* t __unused, int32_t* out __unused,
1245 size_t outFrameCount __unused, int32_t* temp __unused, int32_t* aux __unused)
1246 {
1247 }
1248
volumeRampStereo(track_t * t,int32_t * out,size_t frameCount,int32_t * temp,int32_t * aux)1249 void AudioMixer::volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp,
1250 int32_t* aux)
1251 {
1252 int32_t vl = t->prevVolume[0];
1253 int32_t vr = t->prevVolume[1];
1254 const int32_t vlInc = t->volumeInc[0];
1255 const int32_t vrInc = t->volumeInc[1];
1256
1257 //ALOGD("[0] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
1258 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
1259 // (vl + vlInc*frameCount)/65536.0f, frameCount);
1260
1261 // ramp volume
1262 if (CC_UNLIKELY(aux != NULL)) {
1263 int32_t va = t->prevAuxLevel;
1264 const int32_t vaInc = t->auxInc;
1265 int32_t l;
1266 int32_t r;
1267
1268 do {
1269 l = (*temp++ >> 12);
1270 r = (*temp++ >> 12);
1271 *out++ += (vl >> 16) * l;
1272 *out++ += (vr >> 16) * r;
1273 *aux++ += (va >> 17) * (l + r);
1274 vl += vlInc;
1275 vr += vrInc;
1276 va += vaInc;
1277 } while (--frameCount);
1278 t->prevAuxLevel = va;
1279 } else {
1280 do {
1281 *out++ += (vl >> 16) * (*temp++ >> 12);
1282 *out++ += (vr >> 16) * (*temp++ >> 12);
1283 vl += vlInc;
1284 vr += vrInc;
1285 } while (--frameCount);
1286 }
1287 t->prevVolume[0] = vl;
1288 t->prevVolume[1] = vr;
1289 t->adjustVolumeRamp(aux != NULL);
1290 }
1291
volumeStereo(track_t * t,int32_t * out,size_t frameCount,int32_t * temp,int32_t * aux)1292 void AudioMixer::volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp,
1293 int32_t* aux)
1294 {
1295 const int16_t vl = t->volume[0];
1296 const int16_t vr = t->volume[1];
1297
1298 if (CC_UNLIKELY(aux != NULL)) {
1299 const int16_t va = t->auxLevel;
1300 do {
1301 int16_t l = (int16_t)(*temp++ >> 12);
1302 int16_t r = (int16_t)(*temp++ >> 12);
1303 out[0] = mulAdd(l, vl, out[0]);
1304 int16_t a = (int16_t)(((int32_t)l + r) >> 1);
1305 out[1] = mulAdd(r, vr, out[1]);
1306 out += 2;
1307 aux[0] = mulAdd(a, va, aux[0]);
1308 aux++;
1309 } while (--frameCount);
1310 } else {
1311 do {
1312 int16_t l = (int16_t)(*temp++ >> 12);
1313 int16_t r = (int16_t)(*temp++ >> 12);
1314 out[0] = mulAdd(l, vl, out[0]);
1315 out[1] = mulAdd(r, vr, out[1]);
1316 out += 2;
1317 } while (--frameCount);
1318 }
1319 }
1320
track__16BitsStereo(track_t * t,int32_t * out,size_t frameCount,int32_t * temp __unused,int32_t * aux)1321 void AudioMixer::track__16BitsStereo(track_t* t, int32_t* out, size_t frameCount,
1322 int32_t* temp __unused, int32_t* aux)
1323 {
1324 ALOGVV("track__16BitsStereo\n");
1325 const int16_t *in = static_cast<const int16_t *>(t->in);
1326
1327 if (CC_UNLIKELY(aux != NULL)) {
1328 int32_t l;
1329 int32_t r;
1330 // ramp gain
1331 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
1332 int32_t vl = t->prevVolume[0];
1333 int32_t vr = t->prevVolume[1];
1334 int32_t va = t->prevAuxLevel;
1335 const int32_t vlInc = t->volumeInc[0];
1336 const int32_t vrInc = t->volumeInc[1];
1337 const int32_t vaInc = t->auxInc;
1338 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
1339 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
1340 // (vl + vlInc*frameCount)/65536.0f, frameCount);
1341
1342 do {
1343 l = (int32_t)*in++;
1344 r = (int32_t)*in++;
1345 *out++ += (vl >> 16) * l;
1346 *out++ += (vr >> 16) * r;
1347 *aux++ += (va >> 17) * (l + r);
1348 vl += vlInc;
1349 vr += vrInc;
1350 va += vaInc;
1351 } while (--frameCount);
1352
1353 t->prevVolume[0] = vl;
1354 t->prevVolume[1] = vr;
1355 t->prevAuxLevel = va;
1356 t->adjustVolumeRamp(true);
1357 }
1358
1359 // constant gain
1360 else {
1361 const uint32_t vrl = t->volumeRL;
1362 const int16_t va = (int16_t)t->auxLevel;
1363 do {
1364 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1365 int16_t a = (int16_t)(((int32_t)in[0] + in[1]) >> 1);
1366 in += 2;
1367 out[0] = mulAddRL(1, rl, vrl, out[0]);
1368 out[1] = mulAddRL(0, rl, vrl, out[1]);
1369 out += 2;
1370 aux[0] = mulAdd(a, va, aux[0]);
1371 aux++;
1372 } while (--frameCount);
1373 }
1374 } else {
1375 // ramp gain
1376 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
1377 int32_t vl = t->prevVolume[0];
1378 int32_t vr = t->prevVolume[1];
1379 const int32_t vlInc = t->volumeInc[0];
1380 const int32_t vrInc = t->volumeInc[1];
1381
1382 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
1383 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
1384 // (vl + vlInc*frameCount)/65536.0f, frameCount);
1385
1386 do {
1387 *out++ += (vl >> 16) * (int32_t) *in++;
1388 *out++ += (vr >> 16) * (int32_t) *in++;
1389 vl += vlInc;
1390 vr += vrInc;
1391 } while (--frameCount);
1392
1393 t->prevVolume[0] = vl;
1394 t->prevVolume[1] = vr;
1395 t->adjustVolumeRamp(false);
1396 }
1397
1398 // constant gain
1399 else {
1400 const uint32_t vrl = t->volumeRL;
1401 do {
1402 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1403 in += 2;
1404 out[0] = mulAddRL(1, rl, vrl, out[0]);
1405 out[1] = mulAddRL(0, rl, vrl, out[1]);
1406 out += 2;
1407 } while (--frameCount);
1408 }
1409 }
1410 t->in = in;
1411 }
1412
track__16BitsMono(track_t * t,int32_t * out,size_t frameCount,int32_t * temp __unused,int32_t * aux)1413 void AudioMixer::track__16BitsMono(track_t* t, int32_t* out, size_t frameCount,
1414 int32_t* temp __unused, int32_t* aux)
1415 {
1416 ALOGVV("track__16BitsMono\n");
1417 const int16_t *in = static_cast<int16_t const *>(t->in);
1418
1419 if (CC_UNLIKELY(aux != NULL)) {
1420 // ramp gain
1421 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) {
1422 int32_t vl = t->prevVolume[0];
1423 int32_t vr = t->prevVolume[1];
1424 int32_t va = t->prevAuxLevel;
1425 const int32_t vlInc = t->volumeInc[0];
1426 const int32_t vrInc = t->volumeInc[1];
1427 const int32_t vaInc = t->auxInc;
1428
1429 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
1430 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
1431 // (vl + vlInc*frameCount)/65536.0f, frameCount);
1432
1433 do {
1434 int32_t l = *in++;
1435 *out++ += (vl >> 16) * l;
1436 *out++ += (vr >> 16) * l;
1437 *aux++ += (va >> 16) * l;
1438 vl += vlInc;
1439 vr += vrInc;
1440 va += vaInc;
1441 } while (--frameCount);
1442
1443 t->prevVolume[0] = vl;
1444 t->prevVolume[1] = vr;
1445 t->prevAuxLevel = va;
1446 t->adjustVolumeRamp(true);
1447 }
1448 // constant gain
1449 else {
1450 const int16_t vl = t->volume[0];
1451 const int16_t vr = t->volume[1];
1452 const int16_t va = (int16_t)t->auxLevel;
1453 do {
1454 int16_t l = *in++;
1455 out[0] = mulAdd(l, vl, out[0]);
1456 out[1] = mulAdd(l, vr, out[1]);
1457 out += 2;
1458 aux[0] = mulAdd(l, va, aux[0]);
1459 aux++;
1460 } while (--frameCount);
1461 }
1462 } else {
1463 // ramp gain
1464 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) {
1465 int32_t vl = t->prevVolume[0];
1466 int32_t vr = t->prevVolume[1];
1467 const int32_t vlInc = t->volumeInc[0];
1468 const int32_t vrInc = t->volumeInc[1];
1469
1470 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d",
1471 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0],
1472 // (vl + vlInc*frameCount)/65536.0f, frameCount);
1473
1474 do {
1475 int32_t l = *in++;
1476 *out++ += (vl >> 16) * l;
1477 *out++ += (vr >> 16) * l;
1478 vl += vlInc;
1479 vr += vrInc;
1480 } while (--frameCount);
1481
1482 t->prevVolume[0] = vl;
1483 t->prevVolume[1] = vr;
1484 t->adjustVolumeRamp(false);
1485 }
1486 // constant gain
1487 else {
1488 const int16_t vl = t->volume[0];
1489 const int16_t vr = t->volume[1];
1490 do {
1491 int16_t l = *in++;
1492 out[0] = mulAdd(l, vl, out[0]);
1493 out[1] = mulAdd(l, vr, out[1]);
1494 out += 2;
1495 } while (--frameCount);
1496 }
1497 }
1498 t->in = in;
1499 }
1500
1501 // no-op case
process__nop(state_t * state,int64_t pts)1502 void AudioMixer::process__nop(state_t* state, int64_t pts)
1503 {
1504 ALOGVV("process__nop\n");
1505 uint32_t e0 = state->enabledTracks;
1506 while (e0) {
1507 // process by group of tracks with same output buffer to
1508 // avoid multiple memset() on same buffer
1509 uint32_t e1 = e0, e2 = e0;
1510 int i = 31 - __builtin_clz(e1);
1511 {
1512 track_t& t1 = state->tracks[i];
1513 e2 &= ~(1<<i);
1514 while (e2) {
1515 i = 31 - __builtin_clz(e2);
1516 e2 &= ~(1<<i);
1517 track_t& t2 = state->tracks[i];
1518 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
1519 e1 &= ~(1<<i);
1520 }
1521 }
1522 e0 &= ~(e1);
1523
1524 memset(t1.mainBuffer, 0, state->frameCount * t1.mMixerChannelCount
1525 * audio_bytes_per_sample(t1.mMixerFormat));
1526 }
1527
1528 while (e1) {
1529 i = 31 - __builtin_clz(e1);
1530 e1 &= ~(1<<i);
1531 {
1532 track_t& t3 = state->tracks[i];
1533 size_t outFrames = state->frameCount;
1534 while (outFrames) {
1535 t3.buffer.frameCount = outFrames;
1536 int64_t outputPTS = calculateOutputPTS(
1537 t3, pts, state->frameCount - outFrames);
1538 t3.bufferProvider->getNextBuffer(&t3.buffer, outputPTS);
1539 if (t3.buffer.raw == NULL) break;
1540 outFrames -= t3.buffer.frameCount;
1541 t3.bufferProvider->releaseBuffer(&t3.buffer);
1542 }
1543 }
1544 }
1545 }
1546 }
1547
1548 // generic code without resampling
process__genericNoResampling(state_t * state,int64_t pts)1549 void AudioMixer::process__genericNoResampling(state_t* state, int64_t pts)
1550 {
1551 ALOGVV("process__genericNoResampling\n");
1552 int32_t outTemp[BLOCKSIZE * MAX_NUM_CHANNELS] __attribute__((aligned(32)));
1553
1554 // acquire each track's buffer
1555 uint32_t enabledTracks = state->enabledTracks;
1556 uint32_t e0 = enabledTracks;
1557 while (e0) {
1558 const int i = 31 - __builtin_clz(e0);
1559 e0 &= ~(1<<i);
1560 track_t& t = state->tracks[i];
1561 t.buffer.frameCount = state->frameCount;
1562 t.bufferProvider->getNextBuffer(&t.buffer, pts);
1563 t.frameCount = t.buffer.frameCount;
1564 t.in = t.buffer.raw;
1565 }
1566
1567 e0 = enabledTracks;
1568 while (e0) {
1569 // process by group of tracks with same output buffer to
1570 // optimize cache use
1571 uint32_t e1 = e0, e2 = e0;
1572 int j = 31 - __builtin_clz(e1);
1573 track_t& t1 = state->tracks[j];
1574 e2 &= ~(1<<j);
1575 while (e2) {
1576 j = 31 - __builtin_clz(e2);
1577 e2 &= ~(1<<j);
1578 track_t& t2 = state->tracks[j];
1579 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
1580 e1 &= ~(1<<j);
1581 }
1582 }
1583 e0 &= ~(e1);
1584 // this assumes output 16 bits stereo, no resampling
1585 int32_t *out = t1.mainBuffer;
1586 size_t numFrames = 0;
1587 do {
1588 memset(outTemp, 0, sizeof(outTemp));
1589 e2 = e1;
1590 while (e2) {
1591 const int i = 31 - __builtin_clz(e2);
1592 e2 &= ~(1<<i);
1593 track_t& t = state->tracks[i];
1594 size_t outFrames = BLOCKSIZE;
1595 int32_t *aux = NULL;
1596 if (CC_UNLIKELY(t.needs & NEEDS_AUX)) {
1597 aux = t.auxBuffer + numFrames;
1598 }
1599 while (outFrames) {
1600 // t.in == NULL can happen if the track was flushed just after having
1601 // been enabled for mixing.
1602 if (t.in == NULL) {
1603 enabledTracks &= ~(1<<i);
1604 e1 &= ~(1<<i);
1605 break;
1606 }
1607 size_t inFrames = (t.frameCount > outFrames)?outFrames:t.frameCount;
1608 if (inFrames > 0) {
1609 t.hook(&t, outTemp + (BLOCKSIZE - outFrames) * t.mMixerChannelCount,
1610 inFrames, state->resampleTemp, aux);
1611 t.frameCount -= inFrames;
1612 outFrames -= inFrames;
1613 if (CC_UNLIKELY(aux != NULL)) {
1614 aux += inFrames;
1615 }
1616 }
1617 if (t.frameCount == 0 && outFrames) {
1618 t.bufferProvider->releaseBuffer(&t.buffer);
1619 t.buffer.frameCount = (state->frameCount - numFrames) -
1620 (BLOCKSIZE - outFrames);
1621 int64_t outputPTS = calculateOutputPTS(
1622 t, pts, numFrames + (BLOCKSIZE - outFrames));
1623 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS);
1624 t.in = t.buffer.raw;
1625 if (t.in == NULL) {
1626 enabledTracks &= ~(1<<i);
1627 e1 &= ~(1<<i);
1628 break;
1629 }
1630 t.frameCount = t.buffer.frameCount;
1631 }
1632 }
1633 }
1634
1635 convertMixerFormat(out, t1.mMixerFormat, outTemp, t1.mMixerInFormat,
1636 BLOCKSIZE * t1.mMixerChannelCount);
1637 // TODO: fix ugly casting due to choice of out pointer type
1638 out = reinterpret_cast<int32_t*>((uint8_t*)out
1639 + BLOCKSIZE * t1.mMixerChannelCount
1640 * audio_bytes_per_sample(t1.mMixerFormat));
1641 numFrames += BLOCKSIZE;
1642 } while (numFrames < state->frameCount);
1643 }
1644
1645 // release each track's buffer
1646 e0 = enabledTracks;
1647 while (e0) {
1648 const int i = 31 - __builtin_clz(e0);
1649 e0 &= ~(1<<i);
1650 track_t& t = state->tracks[i];
1651 t.bufferProvider->releaseBuffer(&t.buffer);
1652 }
1653 }
1654
1655
1656 // generic code with resampling
process__genericResampling(state_t * state,int64_t pts)1657 void AudioMixer::process__genericResampling(state_t* state, int64_t pts)
1658 {
1659 ALOGVV("process__genericResampling\n");
1660 // this const just means that local variable outTemp doesn't change
1661 int32_t* const outTemp = state->outputTemp;
1662 size_t numFrames = state->frameCount;
1663
1664 uint32_t e0 = state->enabledTracks;
1665 while (e0) {
1666 // process by group of tracks with same output buffer
1667 // to optimize cache use
1668 uint32_t e1 = e0, e2 = e0;
1669 int j = 31 - __builtin_clz(e1);
1670 track_t& t1 = state->tracks[j];
1671 e2 &= ~(1<<j);
1672 while (e2) {
1673 j = 31 - __builtin_clz(e2);
1674 e2 &= ~(1<<j);
1675 track_t& t2 = state->tracks[j];
1676 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) {
1677 e1 &= ~(1<<j);
1678 }
1679 }
1680 e0 &= ~(e1);
1681 int32_t *out = t1.mainBuffer;
1682 memset(outTemp, 0, sizeof(*outTemp) * t1.mMixerChannelCount * state->frameCount);
1683 while (e1) {
1684 const int i = 31 - __builtin_clz(e1);
1685 e1 &= ~(1<<i);
1686 track_t& t = state->tracks[i];
1687 int32_t *aux = NULL;
1688 if (CC_UNLIKELY(t.needs & NEEDS_AUX)) {
1689 aux = t.auxBuffer;
1690 }
1691
1692 // this is a little goofy, on the resampling case we don't
1693 // acquire/release the buffers because it's done by
1694 // the resampler.
1695 if (t.needs & NEEDS_RESAMPLE) {
1696 t.resampler->setPTS(pts);
1697 t.hook(&t, outTemp, numFrames, state->resampleTemp, aux);
1698 } else {
1699
1700 size_t outFrames = 0;
1701
1702 while (outFrames < numFrames) {
1703 t.buffer.frameCount = numFrames - outFrames;
1704 int64_t outputPTS = calculateOutputPTS(t, pts, outFrames);
1705 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS);
1706 t.in = t.buffer.raw;
1707 // t.in == NULL can happen if the track was flushed just after having
1708 // been enabled for mixing.
1709 if (t.in == NULL) break;
1710
1711 if (CC_UNLIKELY(aux != NULL)) {
1712 aux += outFrames;
1713 }
1714 t.hook(&t, outTemp + outFrames * t.mMixerChannelCount, t.buffer.frameCount,
1715 state->resampleTemp, aux);
1716 outFrames += t.buffer.frameCount;
1717 t.bufferProvider->releaseBuffer(&t.buffer);
1718 }
1719 }
1720 }
1721 convertMixerFormat(out, t1.mMixerFormat,
1722 outTemp, t1.mMixerInFormat, numFrames * t1.mMixerChannelCount);
1723 }
1724 }
1725
1726 // one track, 16 bits stereo without resampling is the most common case
process__OneTrack16BitsStereoNoResampling(state_t * state,int64_t pts)1727 void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t* state,
1728 int64_t pts)
1729 {
1730 ALOGVV("process__OneTrack16BitsStereoNoResampling\n");
1731 // This method is only called when state->enabledTracks has exactly
1732 // one bit set. The asserts below would verify this, but are commented out
1733 // since the whole point of this method is to optimize performance.
1734 //ALOG_ASSERT(0 != state->enabledTracks, "no tracks enabled");
1735 const int i = 31 - __builtin_clz(state->enabledTracks);
1736 //ALOG_ASSERT((1 << i) == state->enabledTracks, "more than 1 track enabled");
1737 const track_t& t = state->tracks[i];
1738
1739 AudioBufferProvider::Buffer& b(t.buffer);
1740
1741 int32_t* out = t.mainBuffer;
1742 float *fout = reinterpret_cast<float*>(out);
1743 size_t numFrames = state->frameCount;
1744
1745 const int16_t vl = t.volume[0];
1746 const int16_t vr = t.volume[1];
1747 const uint32_t vrl = t.volumeRL;
1748 while (numFrames) {
1749 b.frameCount = numFrames;
1750 int64_t outputPTS = calculateOutputPTS(t, pts, out - t.mainBuffer);
1751 t.bufferProvider->getNextBuffer(&b, outputPTS);
1752 const int16_t *in = b.i16;
1753
1754 // in == NULL can happen if the track was flushed just after having
1755 // been enabled for mixing.
1756 if (in == NULL || (((uintptr_t)in) & 3)) {
1757 memset(out, 0, numFrames
1758 * t.mMixerChannelCount * audio_bytes_per_sample(t.mMixerFormat));
1759 ALOGE_IF((((uintptr_t)in) & 3),
1760 "process__OneTrack16BitsStereoNoResampling: misaligned buffer"
1761 " %p track %d, channels %d, needs %08x, volume %08x vfl %f vfr %f",
1762 in, i, t.channelCount, t.needs, vrl, t.mVolume[0], t.mVolume[1]);
1763 return;
1764 }
1765 size_t outFrames = b.frameCount;
1766
1767 switch (t.mMixerFormat) {
1768 case AUDIO_FORMAT_PCM_FLOAT:
1769 do {
1770 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1771 in += 2;
1772 int32_t l = mulRL(1, rl, vrl);
1773 int32_t r = mulRL(0, rl, vrl);
1774 *fout++ = float_from_q4_27(l);
1775 *fout++ = float_from_q4_27(r);
1776 // Note: In case of later int16_t sink output,
1777 // conversion and clamping is done by memcpy_to_i16_from_float().
1778 } while (--outFrames);
1779 break;
1780 case AUDIO_FORMAT_PCM_16_BIT:
1781 if (CC_UNLIKELY(uint32_t(vl) > UNITY_GAIN_INT || uint32_t(vr) > UNITY_GAIN_INT)) {
1782 // volume is boosted, so we might need to clamp even though
1783 // we process only one track.
1784 do {
1785 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1786 in += 2;
1787 int32_t l = mulRL(1, rl, vrl) >> 12;
1788 int32_t r = mulRL(0, rl, vrl) >> 12;
1789 // clamping...
1790 l = clamp16(l);
1791 r = clamp16(r);
1792 *out++ = (r<<16) | (l & 0xFFFF);
1793 } while (--outFrames);
1794 } else {
1795 do {
1796 uint32_t rl = *reinterpret_cast<const uint32_t *>(in);
1797 in += 2;
1798 int32_t l = mulRL(1, rl, vrl) >> 12;
1799 int32_t r = mulRL(0, rl, vrl) >> 12;
1800 *out++ = (r<<16) | (l & 0xFFFF);
1801 } while (--outFrames);
1802 }
1803 break;
1804 default:
1805 LOG_ALWAYS_FATAL("bad mixer format: %d", t.mMixerFormat);
1806 }
1807 numFrames -= b.frameCount;
1808 t.bufferProvider->releaseBuffer(&b);
1809 }
1810 }
1811
calculateOutputPTS(const track_t & t,int64_t basePTS,int outputFrameIndex)1812 int64_t AudioMixer::calculateOutputPTS(const track_t& t, int64_t basePTS,
1813 int outputFrameIndex)
1814 {
1815 if (AudioBufferProvider::kInvalidPTS == basePTS) {
1816 return AudioBufferProvider::kInvalidPTS;
1817 }
1818
1819 return basePTS + ((outputFrameIndex * sLocalTimeFreq) / t.sampleRate);
1820 }
1821
1822 /*static*/ uint64_t AudioMixer::sLocalTimeFreq;
1823 /*static*/ pthread_once_t AudioMixer::sOnceControl = PTHREAD_ONCE_INIT;
1824
sInitRoutine()1825 /*static*/ void AudioMixer::sInitRoutine()
1826 {
1827 LocalClock lc;
1828 sLocalTimeFreq = lc.getLocalFreq(); // for the resampler
1829
1830 DownmixerBufferProvider::init(); // for the downmixer
1831 }
1832
1833 /* TODO: consider whether this level of optimization is necessary.
1834 * Perhaps just stick with a single for loop.
1835 */
1836
1837 // Needs to derive a compile time constant (constexpr). Could be targeted to go
1838 // to a MONOVOL mixtype based on MAX_NUM_VOLUMES, but that's an unnecessary complication.
1839 #define MIXTYPE_MONOVOL(mixtype) (mixtype == MIXTYPE_MULTI ? MIXTYPE_MULTI_MONOVOL : \
1840 mixtype == MIXTYPE_MULTI_SAVEONLY ? MIXTYPE_MULTI_SAVEONLY_MONOVOL : mixtype)
1841
1842 /* MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
1843 * TO: int32_t (Q4.27) or float
1844 * TI: int32_t (Q4.27) or int16_t (Q0.15) or float
1845 * TA: int32_t (Q4.27)
1846 */
1847 template <int MIXTYPE,
1848 typename TO, typename TI, typename TV, typename TA, typename TAV>
volumeRampMulti(uint32_t channels,TO * out,size_t frameCount,const TI * in,TA * aux,TV * vol,const TV * volinc,TAV * vola,TAV volainc)1849 static void volumeRampMulti(uint32_t channels, TO* out, size_t frameCount,
1850 const TI* in, TA* aux, TV *vol, const TV *volinc, TAV *vola, TAV volainc)
1851 {
1852 switch (channels) {
1853 case 1:
1854 volumeRampMulti<MIXTYPE, 1>(out, frameCount, in, aux, vol, volinc, vola, volainc);
1855 break;
1856 case 2:
1857 volumeRampMulti<MIXTYPE, 2>(out, frameCount, in, aux, vol, volinc, vola, volainc);
1858 break;
1859 case 3:
1860 volumeRampMulti<MIXTYPE_MONOVOL(MIXTYPE), 3>(out,
1861 frameCount, in, aux, vol, volinc, vola, volainc);
1862 break;
1863 case 4:
1864 volumeRampMulti<MIXTYPE_MONOVOL(MIXTYPE), 4>(out,
1865 frameCount, in, aux, vol, volinc, vola, volainc);
1866 break;
1867 case 5:
1868 volumeRampMulti<MIXTYPE_MONOVOL(MIXTYPE), 5>(out,
1869 frameCount, in, aux, vol, volinc, vola, volainc);
1870 break;
1871 case 6:
1872 volumeRampMulti<MIXTYPE_MONOVOL(MIXTYPE), 6>(out,
1873 frameCount, in, aux, vol, volinc, vola, volainc);
1874 break;
1875 case 7:
1876 volumeRampMulti<MIXTYPE_MONOVOL(MIXTYPE), 7>(out,
1877 frameCount, in, aux, vol, volinc, vola, volainc);
1878 break;
1879 case 8:
1880 volumeRampMulti<MIXTYPE_MONOVOL(MIXTYPE), 8>(out,
1881 frameCount, in, aux, vol, volinc, vola, volainc);
1882 break;
1883 }
1884 }
1885
1886 /* MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
1887 * TO: int32_t (Q4.27) or float
1888 * TI: int32_t (Q4.27) or int16_t (Q0.15) or float
1889 * TA: int32_t (Q4.27)
1890 */
1891 template <int MIXTYPE,
1892 typename TO, typename TI, typename TV, typename TA, typename TAV>
volumeMulti(uint32_t channels,TO * out,size_t frameCount,const TI * in,TA * aux,const TV * vol,TAV vola)1893 static void volumeMulti(uint32_t channels, TO* out, size_t frameCount,
1894 const TI* in, TA* aux, const TV *vol, TAV vola)
1895 {
1896 switch (channels) {
1897 case 1:
1898 volumeMulti<MIXTYPE, 1>(out, frameCount, in, aux, vol, vola);
1899 break;
1900 case 2:
1901 volumeMulti<MIXTYPE, 2>(out, frameCount, in, aux, vol, vola);
1902 break;
1903 case 3:
1904 volumeMulti<MIXTYPE_MONOVOL(MIXTYPE), 3>(out, frameCount, in, aux, vol, vola);
1905 break;
1906 case 4:
1907 volumeMulti<MIXTYPE_MONOVOL(MIXTYPE), 4>(out, frameCount, in, aux, vol, vola);
1908 break;
1909 case 5:
1910 volumeMulti<MIXTYPE_MONOVOL(MIXTYPE), 5>(out, frameCount, in, aux, vol, vola);
1911 break;
1912 case 6:
1913 volumeMulti<MIXTYPE_MONOVOL(MIXTYPE), 6>(out, frameCount, in, aux, vol, vola);
1914 break;
1915 case 7:
1916 volumeMulti<MIXTYPE_MONOVOL(MIXTYPE), 7>(out, frameCount, in, aux, vol, vola);
1917 break;
1918 case 8:
1919 volumeMulti<MIXTYPE_MONOVOL(MIXTYPE), 8>(out, frameCount, in, aux, vol, vola);
1920 break;
1921 }
1922 }
1923
1924 /* MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
1925 * USEFLOATVOL (set to true if float volume is used)
1926 * ADJUSTVOL (set to true if volume ramp parameters needs adjustment afterwards)
1927 * TO: int32_t (Q4.27) or float
1928 * TI: int32_t (Q4.27) or int16_t (Q0.15) or float
1929 * TA: int32_t (Q4.27)
1930 */
1931 template <int MIXTYPE, bool USEFLOATVOL, bool ADJUSTVOL,
1932 typename TO, typename TI, typename TA>
volumeMix(TO * out,size_t outFrames,const TI * in,TA * aux,bool ramp,AudioMixer::track_t * t)1933 void AudioMixer::volumeMix(TO *out, size_t outFrames,
1934 const TI *in, TA *aux, bool ramp, AudioMixer::track_t *t)
1935 {
1936 if (USEFLOATVOL) {
1937 if (ramp) {
1938 volumeRampMulti<MIXTYPE>(t->mMixerChannelCount, out, outFrames, in, aux,
1939 t->mPrevVolume, t->mVolumeInc, &t->prevAuxLevel, t->auxInc);
1940 if (ADJUSTVOL) {
1941 t->adjustVolumeRamp(aux != NULL, true);
1942 }
1943 } else {
1944 volumeMulti<MIXTYPE>(t->mMixerChannelCount, out, outFrames, in, aux,
1945 t->mVolume, t->auxLevel);
1946 }
1947 } else {
1948 if (ramp) {
1949 volumeRampMulti<MIXTYPE>(t->mMixerChannelCount, out, outFrames, in, aux,
1950 t->prevVolume, t->volumeInc, &t->prevAuxLevel, t->auxInc);
1951 if (ADJUSTVOL) {
1952 t->adjustVolumeRamp(aux != NULL);
1953 }
1954 } else {
1955 volumeMulti<MIXTYPE>(t->mMixerChannelCount, out, outFrames, in, aux,
1956 t->volume, t->auxLevel);
1957 }
1958 }
1959 }
1960
1961 /* This process hook is called when there is a single track without
1962 * aux buffer, volume ramp, or resampling.
1963 * TODO: Update the hook selection: this can properly handle aux and ramp.
1964 *
1965 * MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
1966 * TO: int32_t (Q4.27) or float
1967 * TI: int32_t (Q4.27) or int16_t (Q0.15) or float
1968 * TA: int32_t (Q4.27)
1969 */
1970 template <int MIXTYPE, typename TO, typename TI, typename TA>
process_NoResampleOneTrack(state_t * state,int64_t pts)1971 void AudioMixer::process_NoResampleOneTrack(state_t* state, int64_t pts)
1972 {
1973 ALOGVV("process_NoResampleOneTrack\n");
1974 // CLZ is faster than CTZ on ARM, though really not sure if true after 31 - clz.
1975 const int i = 31 - __builtin_clz(state->enabledTracks);
1976 ALOG_ASSERT((1 << i) == state->enabledTracks, "more than 1 track enabled");
1977 track_t *t = &state->tracks[i];
1978 const uint32_t channels = t->mMixerChannelCount;
1979 TO* out = reinterpret_cast<TO*>(t->mainBuffer);
1980 TA* aux = reinterpret_cast<TA*>(t->auxBuffer);
1981 const bool ramp = t->needsRamp();
1982
1983 for (size_t numFrames = state->frameCount; numFrames; ) {
1984 AudioBufferProvider::Buffer& b(t->buffer);
1985 // get input buffer
1986 b.frameCount = numFrames;
1987 const int64_t outputPTS = calculateOutputPTS(*t, pts, state->frameCount - numFrames);
1988 t->bufferProvider->getNextBuffer(&b, outputPTS);
1989 const TI *in = reinterpret_cast<TI*>(b.raw);
1990
1991 // in == NULL can happen if the track was flushed just after having
1992 // been enabled for mixing.
1993 if (in == NULL || (((uintptr_t)in) & 3)) {
1994 memset(out, 0, numFrames
1995 * channels * audio_bytes_per_sample(t->mMixerFormat));
1996 ALOGE_IF((((uintptr_t)in) & 3), "process_NoResampleOneTrack: bus error: "
1997 "buffer %p track %p, channels %d, needs %#x",
1998 in, t, t->channelCount, t->needs);
1999 return;
2000 }
2001
2002 const size_t outFrames = b.frameCount;
2003 volumeMix<MIXTYPE, is_same<TI, float>::value, false> (
2004 out, outFrames, in, aux, ramp, t);
2005
2006 out += outFrames * channels;
2007 if (aux != NULL) {
2008 aux += channels;
2009 }
2010 numFrames -= b.frameCount;
2011
2012 // release buffer
2013 t->bufferProvider->releaseBuffer(&b);
2014 }
2015 if (ramp) {
2016 t->adjustVolumeRamp(aux != NULL, is_same<TI, float>::value);
2017 }
2018 }
2019
2020 /* This track hook is called to do resampling then mixing,
2021 * pulling from the track's upstream AudioBufferProvider.
2022 *
2023 * MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
2024 * TO: int32_t (Q4.27) or float
2025 * TI: int32_t (Q4.27) or int16_t (Q0.15) or float
2026 * TA: int32_t (Q4.27)
2027 */
2028 template <int MIXTYPE, typename TO, typename TI, typename TA>
track__Resample(track_t * t,TO * out,size_t outFrameCount,TO * temp,TA * aux)2029 void AudioMixer::track__Resample(track_t* t, TO* out, size_t outFrameCount, TO* temp, TA* aux)
2030 {
2031 ALOGVV("track__Resample\n");
2032 t->resampler->setSampleRate(t->sampleRate);
2033 const bool ramp = t->needsRamp();
2034 if (ramp || aux != NULL) {
2035 // if ramp: resample with unity gain to temp buffer and scale/mix in 2nd step.
2036 // if aux != NULL: resample with unity gain to temp buffer then apply send level.
2037
2038 t->resampler->setVolume(UNITY_GAIN_FLOAT, UNITY_GAIN_FLOAT);
2039 memset(temp, 0, outFrameCount * t->mMixerChannelCount * sizeof(TO));
2040 t->resampler->resample((int32_t*)temp, outFrameCount, t->bufferProvider);
2041
2042 volumeMix<MIXTYPE, is_same<TI, float>::value, true>(
2043 out, outFrameCount, temp, aux, ramp, t);
2044
2045 } else { // constant volume gain
2046 t->resampler->setVolume(t->mVolume[0], t->mVolume[1]);
2047 t->resampler->resample((int32_t*)out, outFrameCount, t->bufferProvider);
2048 }
2049 }
2050
2051 /* This track hook is called to mix a track, when no resampling is required.
2052 * The input buffer should be present in t->in.
2053 *
2054 * MIXTYPE (see AudioMixerOps.h MIXTYPE_* enumeration)
2055 * TO: int32_t (Q4.27) or float
2056 * TI: int32_t (Q4.27) or int16_t (Q0.15) or float
2057 * TA: int32_t (Q4.27)
2058 */
2059 template <int MIXTYPE, typename TO, typename TI, typename TA>
track__NoResample(track_t * t,TO * out,size_t frameCount,TO * temp __unused,TA * aux)2060 void AudioMixer::track__NoResample(track_t* t, TO* out, size_t frameCount,
2061 TO* temp __unused, TA* aux)
2062 {
2063 ALOGVV("track__NoResample\n");
2064 const TI *in = static_cast<const TI *>(t->in);
2065
2066 volumeMix<MIXTYPE, is_same<TI, float>::value, true>(
2067 out, frameCount, in, aux, t->needsRamp(), t);
2068
2069 // MIXTYPE_MONOEXPAND reads a single input channel and expands to NCHAN output channels.
2070 // MIXTYPE_MULTI reads NCHAN input channels and places to NCHAN output channels.
2071 in += (MIXTYPE == MIXTYPE_MONOEXPAND) ? frameCount : frameCount * t->mMixerChannelCount;
2072 t->in = in;
2073 }
2074
2075 /* The Mixer engine generates either int32_t (Q4_27) or float data.
2076 * We use this function to convert the engine buffers
2077 * to the desired mixer output format, either int16_t (Q.15) or float.
2078 */
convertMixerFormat(void * out,audio_format_t mixerOutFormat,void * in,audio_format_t mixerInFormat,size_t sampleCount)2079 void AudioMixer::convertMixerFormat(void *out, audio_format_t mixerOutFormat,
2080 void *in, audio_format_t mixerInFormat, size_t sampleCount)
2081 {
2082 switch (mixerInFormat) {
2083 case AUDIO_FORMAT_PCM_FLOAT:
2084 switch (mixerOutFormat) {
2085 case AUDIO_FORMAT_PCM_FLOAT:
2086 memcpy(out, in, sampleCount * sizeof(float)); // MEMCPY. TODO optimize out
2087 break;
2088 case AUDIO_FORMAT_PCM_16_BIT:
2089 memcpy_to_i16_from_float((int16_t*)out, (float*)in, sampleCount);
2090 break;
2091 default:
2092 LOG_ALWAYS_FATAL("bad mixerOutFormat: %#x", mixerOutFormat);
2093 break;
2094 }
2095 break;
2096 case AUDIO_FORMAT_PCM_16_BIT:
2097 switch (mixerOutFormat) {
2098 case AUDIO_FORMAT_PCM_FLOAT:
2099 memcpy_to_float_from_q4_27((float*)out, (int32_t*)in, sampleCount);
2100 break;
2101 case AUDIO_FORMAT_PCM_16_BIT:
2102 // two int16_t are produced per iteration
2103 ditherAndClamp((int32_t*)out, (int32_t*)in, sampleCount >> 1);
2104 break;
2105 default:
2106 LOG_ALWAYS_FATAL("bad mixerOutFormat: %#x", mixerOutFormat);
2107 break;
2108 }
2109 break;
2110 default:
2111 LOG_ALWAYS_FATAL("bad mixerInFormat: %#x", mixerInFormat);
2112 break;
2113 }
2114 }
2115
2116 /* Returns the proper track hook to use for mixing the track into the output buffer.
2117 */
getTrackHook(int trackType,uint32_t channelCount,audio_format_t mixerInFormat,audio_format_t mixerOutFormat __unused)2118 AudioMixer::hook_t AudioMixer::getTrackHook(int trackType, uint32_t channelCount,
2119 audio_format_t mixerInFormat, audio_format_t mixerOutFormat __unused)
2120 {
2121 if (!kUseNewMixer && channelCount == FCC_2 && mixerInFormat == AUDIO_FORMAT_PCM_16_BIT) {
2122 switch (trackType) {
2123 case TRACKTYPE_NOP:
2124 return track__nop;
2125 case TRACKTYPE_RESAMPLE:
2126 return track__genericResample;
2127 case TRACKTYPE_NORESAMPLEMONO:
2128 return track__16BitsMono;
2129 case TRACKTYPE_NORESAMPLE:
2130 return track__16BitsStereo;
2131 default:
2132 LOG_ALWAYS_FATAL("bad trackType: %d", trackType);
2133 break;
2134 }
2135 }
2136 LOG_ALWAYS_FATAL_IF(channelCount > MAX_NUM_CHANNELS);
2137 switch (trackType) {
2138 case TRACKTYPE_NOP:
2139 return track__nop;
2140 case TRACKTYPE_RESAMPLE:
2141 switch (mixerInFormat) {
2142 case AUDIO_FORMAT_PCM_FLOAT:
2143 return (AudioMixer::hook_t)
2144 track__Resample<MIXTYPE_MULTI, float /*TO*/, float /*TI*/, int32_t /*TA*/>;
2145 case AUDIO_FORMAT_PCM_16_BIT:
2146 return (AudioMixer::hook_t)\
2147 track__Resample<MIXTYPE_MULTI, int32_t, int16_t, int32_t>;
2148 default:
2149 LOG_ALWAYS_FATAL("bad mixerInFormat: %#x", mixerInFormat);
2150 break;
2151 }
2152 break;
2153 case TRACKTYPE_NORESAMPLEMONO:
2154 switch (mixerInFormat) {
2155 case AUDIO_FORMAT_PCM_FLOAT:
2156 return (AudioMixer::hook_t)
2157 track__NoResample<MIXTYPE_MONOEXPAND, float, float, int32_t>;
2158 case AUDIO_FORMAT_PCM_16_BIT:
2159 return (AudioMixer::hook_t)
2160 track__NoResample<MIXTYPE_MONOEXPAND, int32_t, int16_t, int32_t>;
2161 default:
2162 LOG_ALWAYS_FATAL("bad mixerInFormat: %#x", mixerInFormat);
2163 break;
2164 }
2165 break;
2166 case TRACKTYPE_NORESAMPLE:
2167 switch (mixerInFormat) {
2168 case AUDIO_FORMAT_PCM_FLOAT:
2169 return (AudioMixer::hook_t)
2170 track__NoResample<MIXTYPE_MULTI, float, float, int32_t>;
2171 case AUDIO_FORMAT_PCM_16_BIT:
2172 return (AudioMixer::hook_t)
2173 track__NoResample<MIXTYPE_MULTI, int32_t, int16_t, int32_t>;
2174 default:
2175 LOG_ALWAYS_FATAL("bad mixerInFormat: %#x", mixerInFormat);
2176 break;
2177 }
2178 break;
2179 default:
2180 LOG_ALWAYS_FATAL("bad trackType: %d", trackType);
2181 break;
2182 }
2183 return NULL;
2184 }
2185
2186 /* Returns the proper process hook for mixing tracks. Currently works only for
2187 * PROCESSTYPE_NORESAMPLEONETRACK, a mix involving one track, no resampling.
2188 *
2189 * TODO: Due to the special mixing considerations of duplicating to
2190 * a stereo output track, the input track cannot be MONO. This should be
2191 * prevented by the caller.
2192 */
getProcessHook(int processType,uint32_t channelCount,audio_format_t mixerInFormat,audio_format_t mixerOutFormat)2193 AudioMixer::process_hook_t AudioMixer::getProcessHook(int processType, uint32_t channelCount,
2194 audio_format_t mixerInFormat, audio_format_t mixerOutFormat)
2195 {
2196 if (processType != PROCESSTYPE_NORESAMPLEONETRACK) { // Only NORESAMPLEONETRACK
2197 LOG_ALWAYS_FATAL("bad processType: %d", processType);
2198 return NULL;
2199 }
2200 if (!kUseNewMixer && channelCount == FCC_2 && mixerInFormat == AUDIO_FORMAT_PCM_16_BIT) {
2201 return process__OneTrack16BitsStereoNoResampling;
2202 }
2203 LOG_ALWAYS_FATAL_IF(channelCount > MAX_NUM_CHANNELS);
2204 switch (mixerInFormat) {
2205 case AUDIO_FORMAT_PCM_FLOAT:
2206 switch (mixerOutFormat) {
2207 case AUDIO_FORMAT_PCM_FLOAT:
2208 return process_NoResampleOneTrack<MIXTYPE_MULTI_SAVEONLY,
2209 float /*TO*/, float /*TI*/, int32_t /*TA*/>;
2210 case AUDIO_FORMAT_PCM_16_BIT:
2211 return process_NoResampleOneTrack<MIXTYPE_MULTI_SAVEONLY,
2212 int16_t, float, int32_t>;
2213 default:
2214 LOG_ALWAYS_FATAL("bad mixerOutFormat: %#x", mixerOutFormat);
2215 break;
2216 }
2217 break;
2218 case AUDIO_FORMAT_PCM_16_BIT:
2219 switch (mixerOutFormat) {
2220 case AUDIO_FORMAT_PCM_FLOAT:
2221 return process_NoResampleOneTrack<MIXTYPE_MULTI_SAVEONLY,
2222 float, int16_t, int32_t>;
2223 case AUDIO_FORMAT_PCM_16_BIT:
2224 return process_NoResampleOneTrack<MIXTYPE_MULTI_SAVEONLY,
2225 int16_t, int16_t, int32_t>;
2226 default:
2227 LOG_ALWAYS_FATAL("bad mixerOutFormat: %#x", mixerOutFormat);
2228 break;
2229 }
2230 break;
2231 default:
2232 LOG_ALWAYS_FATAL("bad mixerInFormat: %#x", mixerInFormat);
2233 break;
2234 }
2235 return NULL;
2236 }
2237
2238 // ----------------------------------------------------------------------------
2239 }; // namespace android
2240