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