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