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> 89 T min(const T& a, const T& b) 90 { 91 return a < b ? a : b; 92 } 93 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 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 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 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 178 void AudioMixer::CopyBufferProvider::reset() 179 { 180 if (mBuffer.frameCount != 0) { 181 mTrackBufferProvider->releaseBuffer(&mBuffer); 182 } 183 mConsumed = 0; 184 } 185 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 278 AudioMixer::DownmixerBufferProvider::~DownmixerBufferProvider() 279 { 280 ALOGV("~DownmixerBufferProvider (%p)", this); 281 EffectRelease(mDownmixHandle); 282 mDownmixHandle = NULL; 283 } 284 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. */ 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 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 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 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 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 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 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 428 void AudioMixer::setLog(NBLog::Writer *log) 429 { 430 mState.mLog = log; 431 } 432 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 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. 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 */ 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 1015 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 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 1042 void AudioMixer::process(int64_t pts) 1043 { 1044 mState.hook(&mState, pts); 1045 } 1046 1047 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 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 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 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 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 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 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 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 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 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 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 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 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> 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> 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> 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> 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> 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> 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 */ 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 */ 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 */ 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
