AudioMixer.cpp revision d192e5f15c395daa87f4f198154379ee7c93d528
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 <stdint.h> 22#include <string.h> 23#include <stdlib.h> 24#include <sys/types.h> 25 26#include <utils/Errors.h> 27#include <utils/Log.h> 28 29#include <cutils/bitops.h> 30#include <cutils/compiler.h> 31#include <utils/Debug.h> 32 33#include <system/audio.h> 34 35#include <audio_utils/primitives.h> 36#include <common_time/local_clock.h> 37#include <common_time/cc_helper.h> 38 39#include <media/EffectsFactoryApi.h> 40 41#include "AudioMixer.h" 42 43namespace android { 44 45// ---------------------------------------------------------------------------- 46AudioMixer::DownmixerBufferProvider::DownmixerBufferProvider() : AudioBufferProvider(), 47 mTrackBufferProvider(NULL), mDownmixHandle(NULL) 48{ 49} 50 51AudioMixer::DownmixerBufferProvider::~DownmixerBufferProvider() 52{ 53 ALOGV("AudioMixer deleting DownmixerBufferProvider (%p)", this); 54 EffectRelease(mDownmixHandle); 55} 56 57status_t AudioMixer::DownmixerBufferProvider::getNextBuffer(AudioBufferProvider::Buffer *pBuffer, 58 int64_t pts) { 59 //ALOGV("DownmixerBufferProvider::getNextBuffer()"); 60 if (this->mTrackBufferProvider != NULL) { 61 status_t res = mTrackBufferProvider->getNextBuffer(pBuffer, pts); 62 if (res == OK) { 63 mDownmixConfig.inputCfg.buffer.frameCount = pBuffer->frameCount; 64 mDownmixConfig.inputCfg.buffer.raw = pBuffer->raw; 65 mDownmixConfig.outputCfg.buffer.frameCount = pBuffer->frameCount; 66 mDownmixConfig.outputCfg.buffer.raw = mDownmixConfig.inputCfg.buffer.raw; 67 // in-place so overwrite the buffer contents, has been set in prepareTrackForDownmix() 68 //mDownmixConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE; 69 70 res = (*mDownmixHandle)->process(mDownmixHandle, 71 &mDownmixConfig.inputCfg.buffer, &mDownmixConfig.outputCfg.buffer); 72 //ALOGV("getNextBuffer is downmixing"); 73 } 74 return res; 75 } else { 76 ALOGE("DownmixerBufferProvider::getNextBuffer() error: NULL track buffer provider"); 77 return NO_INIT; 78 } 79} 80 81void AudioMixer::DownmixerBufferProvider::releaseBuffer(AudioBufferProvider::Buffer *pBuffer) { 82 //ALOGV("DownmixerBufferProvider::releaseBuffer()"); 83 if (this->mTrackBufferProvider != NULL) { 84 mTrackBufferProvider->releaseBuffer(pBuffer); 85 } else { 86 ALOGE("DownmixerBufferProvider::releaseBuffer() error: NULL track buffer provider"); 87 } 88} 89 90 91// ---------------------------------------------------------------------------- 92bool AudioMixer::isMultichannelCapable = false; 93 94effect_descriptor_t AudioMixer::dwnmFxDesc; 95 96// Ensure mConfiguredNames bitmask is initialized properly on all architectures. 97// The value of 1 << x is undefined in C when x >= 32. 98 99AudioMixer::AudioMixer(size_t frameCount, uint32_t sampleRate, uint32_t maxNumTracks) 100 : mTrackNames(0), mConfiguredNames((maxNumTracks >= 32 ? 0 : 1 << maxNumTracks) - 1), 101 mSampleRate(sampleRate) 102{ 103 // AudioMixer is not yet capable of multi-channel beyond stereo 104 COMPILE_TIME_ASSERT_FUNCTION_SCOPE(2 == MAX_NUM_CHANNELS); 105 106 ALOG_ASSERT(maxNumTracks <= MAX_NUM_TRACKS, "maxNumTracks %u > MAX_NUM_TRACKS %u", 107 maxNumTracks, MAX_NUM_TRACKS); 108 109 LocalClock lc; 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.reserved 120 121 // FIXME Most of the following initialization is probably redundant since 122 // tracks[i] should only be referenced if (mTrackNames & (1 << i)) != 0 123 // and mTrackNames is initially 0. However, leave it here until that's verified. 124 track_t* t = mState.tracks; 125 for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) { 126 t->resampler = NULL; 127 t->downmixerBufferProvider = NULL; 128 t++; 129 } 130 131 // find multichannel downmix effect if we have to play multichannel content 132 uint32_t numEffects = 0; 133 int ret = EffectQueryNumberEffects(&numEffects); 134 if (ret != 0) { 135 ALOGE("AudioMixer() error %d querying number of effects", ret); 136 return; 137 } 138 ALOGV("EffectQueryNumberEffects() numEffects=%d", numEffects); 139 140 for (uint32_t i = 0 ; i < numEffects ; i++) { 141 if (EffectQueryEffect(i, &dwnmFxDesc) == 0) { 142 ALOGV("effect %d is called %s", i, dwnmFxDesc.name); 143 if (memcmp(&dwnmFxDesc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0) { 144 ALOGI("found effect \"%s\" from %s", 145 dwnmFxDesc.name, dwnmFxDesc.implementor); 146 isMultichannelCapable = true; 147 break; 148 } 149 } 150 } 151 ALOGE_IF(!isMultichannelCapable, "unable to find downmix effect"); 152} 153 154AudioMixer::~AudioMixer() 155{ 156 track_t* t = mState.tracks; 157 for (unsigned i=0 ; i < MAX_NUM_TRACKS ; i++) { 158 delete t->resampler; 159 delete t->downmixerBufferProvider; 160 t++; 161 } 162 delete [] mState.outputTemp; 163 delete [] mState.resampleTemp; 164} 165 166int AudioMixer::getTrackName(audio_channel_mask_t channelMask, int sessionId) 167{ 168 uint32_t names = (~mTrackNames) & mConfiguredNames; 169 if (names != 0) { 170 int n = __builtin_ctz(names); 171 ALOGV("add track (%d)", n); 172 mTrackNames |= 1 << n; 173 // assume default parameters for the track, except where noted below 174 track_t* t = &mState.tracks[n]; 175 t->needs = 0; 176 t->volume[0] = UNITY_GAIN; 177 t->volume[1] = UNITY_GAIN; 178 // no initialization needed 179 // t->prevVolume[0] 180 // t->prevVolume[1] 181 t->volumeInc[0] = 0; 182 t->volumeInc[1] = 0; 183 t->auxLevel = 0; 184 t->auxInc = 0; 185 // no initialization needed 186 // t->prevAuxLevel 187 // t->frameCount 188 t->channelCount = 2; 189 t->enabled = false; 190 t->format = 16; 191 t->channelMask = AUDIO_CHANNEL_OUT_STEREO; 192 t->sessionId = sessionId; 193 // setBufferProvider(name, AudioBufferProvider *) is required before enable(name) 194 t->bufferProvider = NULL; 195 t->buffer.raw = NULL; 196 // no initialization needed 197 // t->buffer.frameCount 198 t->hook = NULL; 199 t->in = NULL; 200 t->resampler = NULL; 201 t->sampleRate = mSampleRate; 202 // setParameter(name, TRACK, MAIN_BUFFER, mixBuffer) is required before enable(name) 203 t->mainBuffer = NULL; 204 t->auxBuffer = NULL; 205 t->downmixerBufferProvider = NULL; 206 207 status_t status = initTrackDownmix(&mState.tracks[n], n, channelMask); 208 if (status == OK) { 209 return TRACK0 + n; 210 } 211 ALOGE("AudioMixer::getTrackName(0x%x) failed, error preparing track for downmix", 212 channelMask); 213 } 214 return -1; 215} 216 217void AudioMixer::invalidateState(uint32_t mask) 218{ 219 if (mask) { 220 mState.needsChanged |= mask; 221 mState.hook = process__validate; 222 } 223 } 224 225status_t AudioMixer::initTrackDownmix(track_t* pTrack, int trackNum, audio_channel_mask_t mask) 226{ 227 uint32_t channelCount = popcount(mask); 228 ALOG_ASSERT((channelCount <= MAX_NUM_CHANNELS_TO_DOWNMIX) && channelCount); 229 status_t status = OK; 230 if (channelCount > MAX_NUM_CHANNELS) { 231 pTrack->channelMask = mask; 232 pTrack->channelCount = channelCount; 233 ALOGV("initTrackDownmix(track=%d, mask=0x%x) calls prepareTrackForDownmix()", 234 trackNum, mask); 235 status = prepareTrackForDownmix(pTrack, trackNum); 236 } else { 237 unprepareTrackForDownmix(pTrack, trackNum); 238 } 239 return status; 240} 241 242void AudioMixer::unprepareTrackForDownmix(track_t* pTrack, int trackName) { 243 ALOGV("AudioMixer::unprepareTrackForDownmix(%d)", trackName); 244 245 if (pTrack->downmixerBufferProvider != NULL) { 246 // this track had previously been configured with a downmixer, delete it 247 ALOGV(" deleting old downmixer"); 248 pTrack->bufferProvider = pTrack->downmixerBufferProvider->mTrackBufferProvider; 249 delete pTrack->downmixerBufferProvider; 250 pTrack->downmixerBufferProvider = NULL; 251 } else { 252 ALOGV(" nothing to do, no downmixer to delete"); 253 } 254} 255 256status_t AudioMixer::prepareTrackForDownmix(track_t* pTrack, int trackName) 257{ 258 ALOGV("AudioMixer::prepareTrackForDownmix(%d) with mask 0x%x", trackName, pTrack->channelMask); 259 260 // discard the previous downmixer if there was one 261 unprepareTrackForDownmix(pTrack, trackName); 262 263 DownmixerBufferProvider* pDbp = new DownmixerBufferProvider(); 264 int32_t status; 265 266 if (!isMultichannelCapable) { 267 ALOGE("prepareTrackForDownmix(%d) fails: mixer doesn't support multichannel content", 268 trackName); 269 goto noDownmixForActiveTrack; 270 } 271 272 if (EffectCreate(&dwnmFxDesc.uuid, 273 pTrack->sessionId /*sessionId*/, -2 /*ioId not relevant here, using random value*/, 274 &pDbp->mDownmixHandle/*pHandle*/) != 0) { 275 ALOGE("prepareTrackForDownmix(%d) fails: error creating downmixer effect", trackName); 276 goto noDownmixForActiveTrack; 277 } 278 279 // channel input configuration will be overridden per-track 280 pDbp->mDownmixConfig.inputCfg.channels = pTrack->channelMask; 281 pDbp->mDownmixConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; 282 pDbp->mDownmixConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 283 pDbp->mDownmixConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 284 pDbp->mDownmixConfig.inputCfg.samplingRate = pTrack->sampleRate; 285 pDbp->mDownmixConfig.outputCfg.samplingRate = pTrack->sampleRate; 286 pDbp->mDownmixConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; 287 pDbp->mDownmixConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE; 288 // input and output buffer provider, and frame count will not be used as the downmix effect 289 // process() function is called directly (see DownmixerBufferProvider::getNextBuffer()) 290 pDbp->mDownmixConfig.inputCfg.mask = EFFECT_CONFIG_SMP_RATE | EFFECT_CONFIG_CHANNELS | 291 EFFECT_CONFIG_FORMAT | EFFECT_CONFIG_ACC_MODE; 292 pDbp->mDownmixConfig.outputCfg.mask = pDbp->mDownmixConfig.inputCfg.mask; 293 294 {// scope for local variables that are not used in goto label "noDownmixForActiveTrack" 295 int cmdStatus; 296 uint32_t replySize = sizeof(int); 297 298 // Configure and enable downmixer 299 status = (*pDbp->mDownmixHandle)->command(pDbp->mDownmixHandle, 300 EFFECT_CMD_SET_CONFIG /*cmdCode*/, sizeof(effect_config_t) /*cmdSize*/, 301 &pDbp->mDownmixConfig /*pCmdData*/, 302 &replySize /*replySize*/, &cmdStatus /*pReplyData*/); 303 if ((status != 0) || (cmdStatus != 0)) { 304 ALOGE("error %d while configuring downmixer for track %d", status, trackName); 305 goto noDownmixForActiveTrack; 306 } 307 replySize = sizeof(int); 308 status = (*pDbp->mDownmixHandle)->command(pDbp->mDownmixHandle, 309 EFFECT_CMD_ENABLE /*cmdCode*/, 0 /*cmdSize*/, NULL /*pCmdData*/, 310 &replySize /*replySize*/, &cmdStatus /*pReplyData*/); 311 if ((status != 0) || (cmdStatus != 0)) { 312 ALOGE("error %d while enabling downmixer for track %d", status, trackName); 313 goto noDownmixForActiveTrack; 314 } 315 316 // Set downmix type 317 // parameter size rounded for padding on 32bit boundary 318 const int psizePadded = ((sizeof(downmix_params_t) - 1)/sizeof(int) + 1) * sizeof(int); 319 const int downmixParamSize = 320 sizeof(effect_param_t) + psizePadded + sizeof(downmix_type_t); 321 effect_param_t * const param = (effect_param_t *) malloc(downmixParamSize); 322 param->psize = sizeof(downmix_params_t); 323 const downmix_params_t downmixParam = DOWNMIX_PARAM_TYPE; 324 memcpy(param->data, &downmixParam, param->psize); 325 const downmix_type_t downmixType = DOWNMIX_TYPE_FOLD; 326 param->vsize = sizeof(downmix_type_t); 327 memcpy(param->data + psizePadded, &downmixType, param->vsize); 328 329 status = (*pDbp->mDownmixHandle)->command(pDbp->mDownmixHandle, 330 EFFECT_CMD_SET_PARAM /* cmdCode */, downmixParamSize/* cmdSize */, 331 param /*pCmndData*/, &replySize /*replySize*/, &cmdStatus /*pReplyData*/); 332 333 free(param); 334 335 if ((status != 0) || (cmdStatus != 0)) { 336 ALOGE("error %d while setting downmix type for track %d", status, trackName); 337 goto noDownmixForActiveTrack; 338 } else { 339 ALOGV("downmix type set to %d for track %d", (int) downmixType, trackName); 340 } 341 }// end of scope for local variables that are not used in goto label "noDownmixForActiveTrack" 342 343 // initialization successful: 344 // - keep track of the real buffer provider in case it was set before 345 pDbp->mTrackBufferProvider = pTrack->bufferProvider; 346 // - we'll use the downmix effect integrated inside this 347 // track's buffer provider, and we'll use it as the track's buffer provider 348 pTrack->downmixerBufferProvider = pDbp; 349 pTrack->bufferProvider = pDbp; 350 351 return NO_ERROR; 352 353noDownmixForActiveTrack: 354 delete pDbp; 355 pTrack->downmixerBufferProvider = NULL; 356 return NO_INIT; 357} 358 359void AudioMixer::deleteTrackName(int name) 360{ 361 ALOGV("AudioMixer::deleteTrackName(%d)", name); 362 name -= TRACK0; 363 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name); 364 ALOGV("deleteTrackName(%d)", name); 365 track_t& track(mState.tracks[ name ]); 366 if (track.enabled) { 367 track.enabled = false; 368 invalidateState(1<<name); 369 } 370 // delete the resampler 371 delete track.resampler; 372 track.resampler = NULL; 373 // delete the downmixer 374 unprepareTrackForDownmix(&mState.tracks[name], name); 375 376 mTrackNames &= ~(1<<name); 377} 378 379void AudioMixer::enable(int name) 380{ 381 name -= TRACK0; 382 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name); 383 track_t& track = mState.tracks[name]; 384 385 if (!track.enabled) { 386 track.enabled = true; 387 ALOGV("enable(%d)", name); 388 invalidateState(1 << name); 389 } 390} 391 392void AudioMixer::disable(int name) 393{ 394 name -= TRACK0; 395 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name); 396 track_t& track = mState.tracks[name]; 397 398 if (track.enabled) { 399 track.enabled = false; 400 ALOGV("disable(%d)", name); 401 invalidateState(1 << name); 402 } 403} 404 405void AudioMixer::setParameter(int name, int target, int param, void *value) 406{ 407 name -= TRACK0; 408 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name); 409 track_t& track = mState.tracks[name]; 410 411 int valueInt = (int)value; 412 int32_t *valueBuf = (int32_t *)value; 413 414 switch (target) { 415 416 case TRACK: 417 switch (param) { 418 case CHANNEL_MASK: { 419 audio_channel_mask_t mask = (audio_channel_mask_t) value; 420 if (track.channelMask != mask) { 421 uint32_t channelCount = popcount(mask); 422 ALOG_ASSERT((channelCount <= MAX_NUM_CHANNELS_TO_DOWNMIX) && channelCount); 423 track.channelMask = mask; 424 track.channelCount = channelCount; 425 // the mask has changed, does this track need a downmixer? 426 initTrackDownmix(&mState.tracks[name], name, mask); 427 ALOGV("setParameter(TRACK, CHANNEL_MASK, %x)", mask); 428 invalidateState(1 << name); 429 } 430 } break; 431 case MAIN_BUFFER: 432 if (track.mainBuffer != valueBuf) { 433 track.mainBuffer = valueBuf; 434 ALOGV("setParameter(TRACK, MAIN_BUFFER, %p)", valueBuf); 435 invalidateState(1 << name); 436 } 437 break; 438 case AUX_BUFFER: 439 if (track.auxBuffer != valueBuf) { 440 track.auxBuffer = valueBuf; 441 ALOGV("setParameter(TRACK, AUX_BUFFER, %p)", valueBuf); 442 invalidateState(1 << name); 443 } 444 break; 445 case FORMAT: 446 ALOG_ASSERT(valueInt == AUDIO_FORMAT_PCM_16_BIT); 447 break; 448 // FIXME do we want to support setting the downmix type from AudioFlinger? 449 // for a specific track? or per mixer? 450 /* case DOWNMIX_TYPE: 451 break */ 452 default: 453 LOG_FATAL("bad param"); 454 } 455 break; 456 457 case RESAMPLE: 458 switch (param) { 459 case SAMPLE_RATE: 460 ALOG_ASSERT(valueInt > 0, "bad sample rate %d", valueInt); 461 if (track.setResampler(uint32_t(valueInt), mSampleRate)) { 462 ALOGV("setParameter(RESAMPLE, SAMPLE_RATE, %u)", 463 uint32_t(valueInt)); 464 invalidateState(1 << name); 465 } 466 break; 467 case RESET: 468 track.resetResampler(); 469 invalidateState(1 << name); 470 break; 471 case REMOVE: 472 delete track.resampler; 473 track.resampler = NULL; 474 track.sampleRate = mSampleRate; 475 invalidateState(1 << name); 476 break; 477 default: 478 LOG_FATAL("bad param"); 479 } 480 break; 481 482 case RAMP_VOLUME: 483 case VOLUME: 484 switch (param) { 485 case VOLUME0: 486 case VOLUME1: 487 if (track.volume[param-VOLUME0] != valueInt) { 488 ALOGV("setParameter(VOLUME, VOLUME0/1: %04x)", valueInt); 489 track.prevVolume[param-VOLUME0] = track.volume[param-VOLUME0] << 16; 490 track.volume[param-VOLUME0] = valueInt; 491 if (target == VOLUME) { 492 track.prevVolume[param-VOLUME0] = valueInt << 16; 493 track.volumeInc[param-VOLUME0] = 0; 494 } else { 495 int32_t d = (valueInt<<16) - track.prevVolume[param-VOLUME0]; 496 int32_t volInc = d / int32_t(mState.frameCount); 497 track.volumeInc[param-VOLUME0] = volInc; 498 if (volInc == 0) { 499 track.prevVolume[param-VOLUME0] = valueInt << 16; 500 } 501 } 502 invalidateState(1 << name); 503 } 504 break; 505 case AUXLEVEL: 506 //ALOG_ASSERT(0 <= valueInt && valueInt <= MAX_GAIN_INT, "bad aux level %d", valueInt); 507 if (track.auxLevel != valueInt) { 508 ALOGV("setParameter(VOLUME, AUXLEVEL: %04x)", valueInt); 509 track.prevAuxLevel = track.auxLevel << 16; 510 track.auxLevel = valueInt; 511 if (target == VOLUME) { 512 track.prevAuxLevel = valueInt << 16; 513 track.auxInc = 0; 514 } else { 515 int32_t d = (valueInt<<16) - track.prevAuxLevel; 516 int32_t volInc = d / int32_t(mState.frameCount); 517 track.auxInc = volInc; 518 if (volInc == 0) { 519 track.prevAuxLevel = valueInt << 16; 520 } 521 } 522 invalidateState(1 << name); 523 } 524 break; 525 default: 526 LOG_FATAL("bad param"); 527 } 528 break; 529 530 default: 531 LOG_FATAL("bad target"); 532 } 533} 534 535bool AudioMixer::track_t::setResampler(uint32_t value, uint32_t devSampleRate) 536{ 537 if (value != devSampleRate || resampler != NULL) { 538 if (sampleRate != value) { 539 sampleRate = value; 540 if (resampler == NULL) { 541 ALOGV("creating resampler from track %d Hz to device %d Hz", value, devSampleRate); 542 AudioResampler::src_quality quality; 543 // force lowest quality level resampler if use case isn't music or video 544 // FIXME this is flawed for dynamic sample rates, as we choose the resampler 545 // quality level based on the initial ratio, but that could change later. 546 // Should have a way to distinguish tracks with static ratios vs. dynamic ratios. 547 if (!((value == 44100 && devSampleRate == 48000) || 548 (value == 48000 && devSampleRate == 44100))) { 549 quality = AudioResampler::LOW_QUALITY; 550 } else { 551 quality = AudioResampler::DEFAULT_QUALITY; 552 } 553 resampler = AudioResampler::create( 554 format, 555 // the resampler sees the number of channels after the downmixer, if any 556 downmixerBufferProvider != NULL ? MAX_NUM_CHANNELS : channelCount, 557 devSampleRate, quality); 558 resampler->setLocalTimeFreq(sLocalTimeFreq); 559 } 560 return true; 561 } 562 } 563 return false; 564} 565 566inline 567void AudioMixer::track_t::adjustVolumeRamp(bool aux) 568{ 569 for (uint32_t i=0 ; i<MAX_NUM_CHANNELS ; i++) { 570 if (((volumeInc[i]>0) && (((prevVolume[i]+volumeInc[i])>>16) >= volume[i])) || 571 ((volumeInc[i]<0) && (((prevVolume[i]+volumeInc[i])>>16) <= volume[i]))) { 572 volumeInc[i] = 0; 573 prevVolume[i] = volume[i]<<16; 574 } 575 } 576 if (aux) { 577 if (((auxInc>0) && (((prevAuxLevel+auxInc)>>16) >= auxLevel)) || 578 ((auxInc<0) && (((prevAuxLevel+auxInc)>>16) <= auxLevel))) { 579 auxInc = 0; 580 prevAuxLevel = auxLevel<<16; 581 } 582 } 583} 584 585size_t AudioMixer::getUnreleasedFrames(int name) const 586{ 587 name -= TRACK0; 588 if (uint32_t(name) < MAX_NUM_TRACKS) { 589 return mState.tracks[name].getUnreleasedFrames(); 590 } 591 return 0; 592} 593 594void AudioMixer::setBufferProvider(int name, AudioBufferProvider* bufferProvider) 595{ 596 name -= TRACK0; 597 ALOG_ASSERT(uint32_t(name) < MAX_NUM_TRACKS, "bad track name %d", name); 598 599 if (mState.tracks[name].downmixerBufferProvider != NULL) { 600 // update required? 601 if (mState.tracks[name].downmixerBufferProvider->mTrackBufferProvider != bufferProvider) { 602 ALOGV("AudioMixer::setBufferProvider(%p) for downmix", bufferProvider); 603 // setting the buffer provider for a track that gets downmixed consists in: 604 // 1/ setting the buffer provider to the "downmix / buffer provider" wrapper 605 // so it's the one that gets called when the buffer provider is needed, 606 mState.tracks[name].bufferProvider = mState.tracks[name].downmixerBufferProvider; 607 // 2/ saving the buffer provider for the track so the wrapper can use it 608 // when it downmixes. 609 mState.tracks[name].downmixerBufferProvider->mTrackBufferProvider = bufferProvider; 610 } 611 } else { 612 mState.tracks[name].bufferProvider = bufferProvider; 613 } 614} 615 616 617 618void AudioMixer::process(int64_t pts) 619{ 620 mState.hook(&mState, pts); 621} 622 623 624void AudioMixer::process__validate(state_t* state, int64_t pts) 625{ 626 ALOGW_IF(!state->needsChanged, 627 "in process__validate() but nothing's invalid"); 628 629 uint32_t changed = state->needsChanged; 630 state->needsChanged = 0; // clear the validation flag 631 632 // recompute which tracks are enabled / disabled 633 uint32_t enabled = 0; 634 uint32_t disabled = 0; 635 while (changed) { 636 const int i = 31 - __builtin_clz(changed); 637 const uint32_t mask = 1<<i; 638 changed &= ~mask; 639 track_t& t = state->tracks[i]; 640 (t.enabled ? enabled : disabled) |= mask; 641 } 642 state->enabledTracks &= ~disabled; 643 state->enabledTracks |= enabled; 644 645 // compute everything we need... 646 int countActiveTracks = 0; 647 bool all16BitsStereoNoResample = true; 648 bool resampling = false; 649 bool volumeRamp = false; 650 uint32_t en = state->enabledTracks; 651 while (en) { 652 const int i = 31 - __builtin_clz(en); 653 en &= ~(1<<i); 654 655 countActiveTracks++; 656 track_t& t = state->tracks[i]; 657 uint32_t n = 0; 658 n |= NEEDS_CHANNEL_1 + t.channelCount - 1; 659 n |= NEEDS_FORMAT_16; 660 n |= t.doesResample() ? NEEDS_RESAMPLE_ENABLED : NEEDS_RESAMPLE_DISABLED; 661 if (t.auxLevel != 0 && t.auxBuffer != NULL) { 662 n |= NEEDS_AUX_ENABLED; 663 } 664 665 if (t.volumeInc[0]|t.volumeInc[1]) { 666 volumeRamp = true; 667 } else if (!t.doesResample() && t.volumeRL == 0) { 668 n |= NEEDS_MUTE_ENABLED; 669 } 670 t.needs = n; 671 672 if ((n & NEEDS_MUTE__MASK) == NEEDS_MUTE_ENABLED) { 673 t.hook = track__nop; 674 } else { 675 if ((n & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED) { 676 all16BitsStereoNoResample = false; 677 } 678 if ((n & NEEDS_RESAMPLE__MASK) == NEEDS_RESAMPLE_ENABLED) { 679 all16BitsStereoNoResample = false; 680 resampling = true; 681 t.hook = track__genericResample; 682 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2, 683 "Track %d needs downmix + resample", i); 684 } else { 685 if ((n & NEEDS_CHANNEL_COUNT__MASK) == NEEDS_CHANNEL_1){ 686 t.hook = track__16BitsMono; 687 all16BitsStereoNoResample = false; 688 } 689 if ((n & NEEDS_CHANNEL_COUNT__MASK) >= NEEDS_CHANNEL_2){ 690 t.hook = track__16BitsStereo; 691 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2, 692 "Track %d needs downmix", i); 693 } 694 } 695 } 696 } 697 698 // select the processing hooks 699 state->hook = process__nop; 700 if (countActiveTracks) { 701 if (resampling) { 702 if (!state->outputTemp) { 703 state->outputTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount]; 704 } 705 if (!state->resampleTemp) { 706 state->resampleTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount]; 707 } 708 state->hook = process__genericResampling; 709 } else { 710 if (state->outputTemp) { 711 delete [] state->outputTemp; 712 state->outputTemp = NULL; 713 } 714 if (state->resampleTemp) { 715 delete [] state->resampleTemp; 716 state->resampleTemp = NULL; 717 } 718 state->hook = process__genericNoResampling; 719 if (all16BitsStereoNoResample && !volumeRamp) { 720 if (countActiveTracks == 1) { 721 state->hook = process__OneTrack16BitsStereoNoResampling; 722 } 723 } 724 } 725 } 726 727 ALOGV("mixer configuration change: %d activeTracks (%08x) " 728 "all16BitsStereoNoResample=%d, resampling=%d, volumeRamp=%d", 729 countActiveTracks, state->enabledTracks, 730 all16BitsStereoNoResample, resampling, volumeRamp); 731 732 state->hook(state, pts); 733 734 // Now that the volume ramp has been done, set optimal state and 735 // track hooks for subsequent mixer process 736 if (countActiveTracks) { 737 bool allMuted = true; 738 uint32_t en = state->enabledTracks; 739 while (en) { 740 const int i = 31 - __builtin_clz(en); 741 en &= ~(1<<i); 742 track_t& t = state->tracks[i]; 743 if (!t.doesResample() && t.volumeRL == 0) 744 { 745 t.needs |= NEEDS_MUTE_ENABLED; 746 t.hook = track__nop; 747 } else { 748 allMuted = false; 749 } 750 } 751 if (allMuted) { 752 state->hook = process__nop; 753 } else if (all16BitsStereoNoResample) { 754 if (countActiveTracks == 1) { 755 state->hook = process__OneTrack16BitsStereoNoResampling; 756 } 757 } 758 } 759} 760 761 762void AudioMixer::track__genericResample(track_t* t, int32_t* out, size_t outFrameCount, int32_t* temp, int32_t* aux) 763{ 764 t->resampler->setSampleRate(t->sampleRate); 765 766 // ramp gain - resample to temp buffer and scale/mix in 2nd step 767 if (aux != NULL) { 768 // always resample with unity gain when sending to auxiliary buffer to be able 769 // to apply send level after resampling 770 // TODO: modify each resampler to support aux channel? 771 t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN); 772 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t)); 773 t->resampler->resample(temp, outFrameCount, t->bufferProvider); 774 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) { 775 volumeRampStereo(t, out, outFrameCount, temp, aux); 776 } else { 777 volumeStereo(t, out, outFrameCount, temp, aux); 778 } 779 } else { 780 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) { 781 t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN); 782 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t)); 783 t->resampler->resample(temp, outFrameCount, t->bufferProvider); 784 volumeRampStereo(t, out, outFrameCount, temp, aux); 785 } 786 787 // constant gain 788 else { 789 t->resampler->setVolume(t->volume[0], t->volume[1]); 790 t->resampler->resample(out, outFrameCount, t->bufferProvider); 791 } 792 } 793} 794 795void AudioMixer::track__nop(track_t* t, int32_t* out, size_t outFrameCount, int32_t* temp, int32_t* aux) 796{ 797} 798 799void AudioMixer::volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux) 800{ 801 int32_t vl = t->prevVolume[0]; 802 int32_t vr = t->prevVolume[1]; 803 const int32_t vlInc = t->volumeInc[0]; 804 const int32_t vrInc = t->volumeInc[1]; 805 806 //ALOGD("[0] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 807 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 808 // (vl + vlInc*frameCount)/65536.0f, frameCount); 809 810 // ramp volume 811 if (CC_UNLIKELY(aux != NULL)) { 812 int32_t va = t->prevAuxLevel; 813 const int32_t vaInc = t->auxInc; 814 int32_t l; 815 int32_t r; 816 817 do { 818 l = (*temp++ >> 12); 819 r = (*temp++ >> 12); 820 *out++ += (vl >> 16) * l; 821 *out++ += (vr >> 16) * r; 822 *aux++ += (va >> 17) * (l + r); 823 vl += vlInc; 824 vr += vrInc; 825 va += vaInc; 826 } while (--frameCount); 827 t->prevAuxLevel = va; 828 } else { 829 do { 830 *out++ += (vl >> 16) * (*temp++ >> 12); 831 *out++ += (vr >> 16) * (*temp++ >> 12); 832 vl += vlInc; 833 vr += vrInc; 834 } while (--frameCount); 835 } 836 t->prevVolume[0] = vl; 837 t->prevVolume[1] = vr; 838 t->adjustVolumeRamp(aux != NULL); 839} 840 841void AudioMixer::volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux) 842{ 843 const int16_t vl = t->volume[0]; 844 const int16_t vr = t->volume[1]; 845 846 if (CC_UNLIKELY(aux != NULL)) { 847 const int16_t va = t->auxLevel; 848 do { 849 int16_t l = (int16_t)(*temp++ >> 12); 850 int16_t r = (int16_t)(*temp++ >> 12); 851 out[0] = mulAdd(l, vl, out[0]); 852 int16_t a = (int16_t)(((int32_t)l + r) >> 1); 853 out[1] = mulAdd(r, vr, out[1]); 854 out += 2; 855 aux[0] = mulAdd(a, va, aux[0]); 856 aux++; 857 } while (--frameCount); 858 } else { 859 do { 860 int16_t l = (int16_t)(*temp++ >> 12); 861 int16_t r = (int16_t)(*temp++ >> 12); 862 out[0] = mulAdd(l, vl, out[0]); 863 out[1] = mulAdd(r, vr, out[1]); 864 out += 2; 865 } while (--frameCount); 866 } 867} 868 869void AudioMixer::track__16BitsStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux) 870{ 871 const int16_t *in = static_cast<const int16_t *>(t->in); 872 873 if (CC_UNLIKELY(aux != NULL)) { 874 int32_t l; 875 int32_t r; 876 // ramp gain 877 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) { 878 int32_t vl = t->prevVolume[0]; 879 int32_t vr = t->prevVolume[1]; 880 int32_t va = t->prevAuxLevel; 881 const int32_t vlInc = t->volumeInc[0]; 882 const int32_t vrInc = t->volumeInc[1]; 883 const int32_t vaInc = t->auxInc; 884 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 885 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 886 // (vl + vlInc*frameCount)/65536.0f, frameCount); 887 888 do { 889 l = (int32_t)*in++; 890 r = (int32_t)*in++; 891 *out++ += (vl >> 16) * l; 892 *out++ += (vr >> 16) * r; 893 *aux++ += (va >> 17) * (l + r); 894 vl += vlInc; 895 vr += vrInc; 896 va += vaInc; 897 } while (--frameCount); 898 899 t->prevVolume[0] = vl; 900 t->prevVolume[1] = vr; 901 t->prevAuxLevel = va; 902 t->adjustVolumeRamp(true); 903 } 904 905 // constant gain 906 else { 907 const uint32_t vrl = t->volumeRL; 908 const int16_t va = (int16_t)t->auxLevel; 909 do { 910 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 911 int16_t a = (int16_t)(((int32_t)in[0] + in[1]) >> 1); 912 in += 2; 913 out[0] = mulAddRL(1, rl, vrl, out[0]); 914 out[1] = mulAddRL(0, rl, vrl, out[1]); 915 out += 2; 916 aux[0] = mulAdd(a, va, aux[0]); 917 aux++; 918 } while (--frameCount); 919 } 920 } else { 921 // ramp gain 922 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) { 923 int32_t vl = t->prevVolume[0]; 924 int32_t vr = t->prevVolume[1]; 925 const int32_t vlInc = t->volumeInc[0]; 926 const int32_t vrInc = t->volumeInc[1]; 927 928 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 929 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 930 // (vl + vlInc*frameCount)/65536.0f, frameCount); 931 932 do { 933 *out++ += (vl >> 16) * (int32_t) *in++; 934 *out++ += (vr >> 16) * (int32_t) *in++; 935 vl += vlInc; 936 vr += vrInc; 937 } while (--frameCount); 938 939 t->prevVolume[0] = vl; 940 t->prevVolume[1] = vr; 941 t->adjustVolumeRamp(false); 942 } 943 944 // constant gain 945 else { 946 const uint32_t vrl = t->volumeRL; 947 do { 948 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 949 in += 2; 950 out[0] = mulAddRL(1, rl, vrl, out[0]); 951 out[1] = mulAddRL(0, rl, vrl, out[1]); 952 out += 2; 953 } while (--frameCount); 954 } 955 } 956 t->in = in; 957} 958 959void AudioMixer::track__16BitsMono(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, int32_t* aux) 960{ 961 const int16_t *in = static_cast<int16_t const *>(t->in); 962 963 if (CC_UNLIKELY(aux != NULL)) { 964 // ramp gain 965 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) { 966 int32_t vl = t->prevVolume[0]; 967 int32_t vr = t->prevVolume[1]; 968 int32_t va = t->prevAuxLevel; 969 const int32_t vlInc = t->volumeInc[0]; 970 const int32_t vrInc = t->volumeInc[1]; 971 const int32_t vaInc = t->auxInc; 972 973 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 974 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 975 // (vl + vlInc*frameCount)/65536.0f, frameCount); 976 977 do { 978 int32_t l = *in++; 979 *out++ += (vl >> 16) * l; 980 *out++ += (vr >> 16) * l; 981 *aux++ += (va >> 16) * l; 982 vl += vlInc; 983 vr += vrInc; 984 va += vaInc; 985 } while (--frameCount); 986 987 t->prevVolume[0] = vl; 988 t->prevVolume[1] = vr; 989 t->prevAuxLevel = va; 990 t->adjustVolumeRamp(true); 991 } 992 // constant gain 993 else { 994 const int16_t vl = t->volume[0]; 995 const int16_t vr = t->volume[1]; 996 const int16_t va = (int16_t)t->auxLevel; 997 do { 998 int16_t l = *in++; 999 out[0] = mulAdd(l, vl, out[0]); 1000 out[1] = mulAdd(l, vr, out[1]); 1001 out += 2; 1002 aux[0] = mulAdd(l, va, aux[0]); 1003 aux++; 1004 } while (--frameCount); 1005 } 1006 } else { 1007 // ramp gain 1008 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) { 1009 int32_t vl = t->prevVolume[0]; 1010 int32_t vr = t->prevVolume[1]; 1011 const int32_t vlInc = t->volumeInc[0]; 1012 const int32_t vrInc = t->volumeInc[1]; 1013 1014 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 1015 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 1016 // (vl + vlInc*frameCount)/65536.0f, frameCount); 1017 1018 do { 1019 int32_t l = *in++; 1020 *out++ += (vl >> 16) * l; 1021 *out++ += (vr >> 16) * l; 1022 vl += vlInc; 1023 vr += vrInc; 1024 } while (--frameCount); 1025 1026 t->prevVolume[0] = vl; 1027 t->prevVolume[1] = vr; 1028 t->adjustVolumeRamp(false); 1029 } 1030 // constant gain 1031 else { 1032 const int16_t vl = t->volume[0]; 1033 const int16_t vr = t->volume[1]; 1034 do { 1035 int16_t l = *in++; 1036 out[0] = mulAdd(l, vl, out[0]); 1037 out[1] = mulAdd(l, vr, out[1]); 1038 out += 2; 1039 } while (--frameCount); 1040 } 1041 } 1042 t->in = in; 1043} 1044 1045// no-op case 1046void AudioMixer::process__nop(state_t* state, int64_t pts) 1047{ 1048 uint32_t e0 = state->enabledTracks; 1049 size_t bufSize = state->frameCount * sizeof(int16_t) * MAX_NUM_CHANNELS; 1050 while (e0) { 1051 // process by group of tracks with same output buffer to 1052 // avoid multiple memset() on same buffer 1053 uint32_t e1 = e0, e2 = e0; 1054 int i = 31 - __builtin_clz(e1); 1055 track_t& t1 = state->tracks[i]; 1056 e2 &= ~(1<<i); 1057 while (e2) { 1058 i = 31 - __builtin_clz(e2); 1059 e2 &= ~(1<<i); 1060 track_t& t2 = state->tracks[i]; 1061 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) { 1062 e1 &= ~(1<<i); 1063 } 1064 } 1065 e0 &= ~(e1); 1066 1067 memset(t1.mainBuffer, 0, bufSize); 1068 1069 while (e1) { 1070 i = 31 - __builtin_clz(e1); 1071 e1 &= ~(1<<i); 1072 t1 = state->tracks[i]; 1073 size_t outFrames = state->frameCount; 1074 while (outFrames) { 1075 t1.buffer.frameCount = outFrames; 1076 int64_t outputPTS = calculateOutputPTS( 1077 t1, pts, state->frameCount - outFrames); 1078 t1.bufferProvider->getNextBuffer(&t1.buffer, outputPTS); 1079 if (t1.buffer.raw == NULL) break; 1080 outFrames -= t1.buffer.frameCount; 1081 t1.bufferProvider->releaseBuffer(&t1.buffer); 1082 } 1083 } 1084 } 1085} 1086 1087// generic code without resampling 1088void AudioMixer::process__genericNoResampling(state_t* state, int64_t pts) 1089{ 1090 int32_t outTemp[BLOCKSIZE * MAX_NUM_CHANNELS] __attribute__((aligned(32))); 1091 1092 // acquire each track's buffer 1093 uint32_t enabledTracks = state->enabledTracks; 1094 uint32_t e0 = enabledTracks; 1095 while (e0) { 1096 const int i = 31 - __builtin_clz(e0); 1097 e0 &= ~(1<<i); 1098 track_t& t = state->tracks[i]; 1099 t.buffer.frameCount = state->frameCount; 1100 t.bufferProvider->getNextBuffer(&t.buffer, pts); 1101 t.frameCount = t.buffer.frameCount; 1102 t.in = t.buffer.raw; 1103 // t.in == NULL can happen if the track was flushed just after having 1104 // been enabled for mixing. 1105 if (t.in == NULL) 1106 enabledTracks &= ~(1<<i); 1107 } 1108 1109 e0 = enabledTracks; 1110 while (e0) { 1111 // process by group of tracks with same output buffer to 1112 // optimize cache use 1113 uint32_t e1 = e0, e2 = e0; 1114 int j = 31 - __builtin_clz(e1); 1115 track_t& t1 = state->tracks[j]; 1116 e2 &= ~(1<<j); 1117 while (e2) { 1118 j = 31 - __builtin_clz(e2); 1119 e2 &= ~(1<<j); 1120 track_t& t2 = state->tracks[j]; 1121 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) { 1122 e1 &= ~(1<<j); 1123 } 1124 } 1125 e0 &= ~(e1); 1126 // this assumes output 16 bits stereo, no resampling 1127 int32_t *out = t1.mainBuffer; 1128 size_t numFrames = 0; 1129 do { 1130 memset(outTemp, 0, sizeof(outTemp)); 1131 e2 = e1; 1132 while (e2) { 1133 const int i = 31 - __builtin_clz(e2); 1134 e2 &= ~(1<<i); 1135 track_t& t = state->tracks[i]; 1136 size_t outFrames = BLOCKSIZE; 1137 int32_t *aux = NULL; 1138 if (CC_UNLIKELY((t.needs & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED)) { 1139 aux = t.auxBuffer + numFrames; 1140 } 1141 while (outFrames) { 1142 size_t inFrames = (t.frameCount > outFrames)?outFrames:t.frameCount; 1143 if (inFrames) { 1144 t.hook(&t, outTemp + (BLOCKSIZE-outFrames)*MAX_NUM_CHANNELS, inFrames, state->resampleTemp, aux); 1145 t.frameCount -= inFrames; 1146 outFrames -= inFrames; 1147 if (CC_UNLIKELY(aux != NULL)) { 1148 aux += inFrames; 1149 } 1150 } 1151 if (t.frameCount == 0 && outFrames) { 1152 t.bufferProvider->releaseBuffer(&t.buffer); 1153 t.buffer.frameCount = (state->frameCount - numFrames) - (BLOCKSIZE - outFrames); 1154 int64_t outputPTS = calculateOutputPTS( 1155 t, pts, numFrames + (BLOCKSIZE - outFrames)); 1156 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS); 1157 t.in = t.buffer.raw; 1158 if (t.in == NULL) { 1159 enabledTracks &= ~(1<<i); 1160 e1 &= ~(1<<i); 1161 break; 1162 } 1163 t.frameCount = t.buffer.frameCount; 1164 } 1165 } 1166 } 1167 ditherAndClamp(out, outTemp, BLOCKSIZE); 1168 out += BLOCKSIZE; 1169 numFrames += BLOCKSIZE; 1170 } while (numFrames < state->frameCount); 1171 } 1172 1173 // release each track's buffer 1174 e0 = enabledTracks; 1175 while (e0) { 1176 const int i = 31 - __builtin_clz(e0); 1177 e0 &= ~(1<<i); 1178 track_t& t = state->tracks[i]; 1179 t.bufferProvider->releaseBuffer(&t.buffer); 1180 } 1181} 1182 1183 1184// generic code with resampling 1185void AudioMixer::process__genericResampling(state_t* state, int64_t pts) 1186{ 1187 // this const just means that local variable outTemp doesn't change 1188 int32_t* const outTemp = state->outputTemp; 1189 const size_t size = sizeof(int32_t) * MAX_NUM_CHANNELS * state->frameCount; 1190 1191 size_t numFrames = state->frameCount; 1192 1193 uint32_t e0 = state->enabledTracks; 1194 while (e0) { 1195 // process by group of tracks with same output buffer 1196 // to optimize cache use 1197 uint32_t e1 = e0, e2 = e0; 1198 int j = 31 - __builtin_clz(e1); 1199 track_t& t1 = state->tracks[j]; 1200 e2 &= ~(1<<j); 1201 while (e2) { 1202 j = 31 - __builtin_clz(e2); 1203 e2 &= ~(1<<j); 1204 track_t& t2 = state->tracks[j]; 1205 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) { 1206 e1 &= ~(1<<j); 1207 } 1208 } 1209 e0 &= ~(e1); 1210 int32_t *out = t1.mainBuffer; 1211 memset(outTemp, 0, size); 1212 while (e1) { 1213 const int i = 31 - __builtin_clz(e1); 1214 e1 &= ~(1<<i); 1215 track_t& t = state->tracks[i]; 1216 int32_t *aux = NULL; 1217 if (CC_UNLIKELY((t.needs & NEEDS_AUX__MASK) == NEEDS_AUX_ENABLED)) { 1218 aux = t.auxBuffer; 1219 } 1220 1221 // this is a little goofy, on the resampling case we don't 1222 // acquire/release the buffers because it's done by 1223 // the resampler. 1224 if ((t.needs & NEEDS_RESAMPLE__MASK) == NEEDS_RESAMPLE_ENABLED) { 1225 t.resampler->setPTS(pts); 1226 t.hook(&t, outTemp, numFrames, state->resampleTemp, aux); 1227 } else { 1228 1229 size_t outFrames = 0; 1230 1231 while (outFrames < numFrames) { 1232 t.buffer.frameCount = numFrames - outFrames; 1233 int64_t outputPTS = calculateOutputPTS(t, pts, outFrames); 1234 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS); 1235 t.in = t.buffer.raw; 1236 // t.in == NULL can happen if the track was flushed just after having 1237 // been enabled for mixing. 1238 if (t.in == NULL) break; 1239 1240 if (CC_UNLIKELY(aux != NULL)) { 1241 aux += outFrames; 1242 } 1243 t.hook(&t, outTemp + outFrames*MAX_NUM_CHANNELS, t.buffer.frameCount, state->resampleTemp, aux); 1244 outFrames += t.buffer.frameCount; 1245 t.bufferProvider->releaseBuffer(&t.buffer); 1246 } 1247 } 1248 } 1249 ditherAndClamp(out, outTemp, numFrames); 1250 } 1251} 1252 1253// one track, 16 bits stereo without resampling is the most common case 1254void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t* state, 1255 int64_t pts) 1256{ 1257 // This method is only called when state->enabledTracks has exactly 1258 // one bit set. The asserts below would verify this, but are commented out 1259 // since the whole point of this method is to optimize performance. 1260 //ALOG_ASSERT(0 != state->enabledTracks, "no tracks enabled"); 1261 const int i = 31 - __builtin_clz(state->enabledTracks); 1262 //ALOG_ASSERT((1 << i) == state->enabledTracks, "more than 1 track enabled"); 1263 const track_t& t = state->tracks[i]; 1264 1265 AudioBufferProvider::Buffer& b(t.buffer); 1266 1267 int32_t* out = t.mainBuffer; 1268 size_t numFrames = state->frameCount; 1269 1270 const int16_t vl = t.volume[0]; 1271 const int16_t vr = t.volume[1]; 1272 const uint32_t vrl = t.volumeRL; 1273 while (numFrames) { 1274 b.frameCount = numFrames; 1275 int64_t outputPTS = calculateOutputPTS(t, pts, out - t.mainBuffer); 1276 t.bufferProvider->getNextBuffer(&b, outputPTS); 1277 const int16_t *in = b.i16; 1278 1279 // in == NULL can happen if the track was flushed just after having 1280 // been enabled for mixing. 1281 if (in == NULL || ((unsigned long)in & 3)) { 1282 memset(out, 0, numFrames*MAX_NUM_CHANNELS*sizeof(int16_t)); 1283 ALOGE_IF(((unsigned long)in & 3), "process stereo track: input buffer alignment pb: buffer %p track %d, channels %d, needs %08x", 1284 in, i, t.channelCount, t.needs); 1285 return; 1286 } 1287 size_t outFrames = b.frameCount; 1288 1289 if (CC_UNLIKELY(uint32_t(vl) > UNITY_GAIN || uint32_t(vr) > UNITY_GAIN)) { 1290 // volume is boosted, so we might need to clamp even though 1291 // we process only one track. 1292 do { 1293 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1294 in += 2; 1295 int32_t l = mulRL(1, rl, vrl) >> 12; 1296 int32_t r = mulRL(0, rl, vrl) >> 12; 1297 // clamping... 1298 l = clamp16(l); 1299 r = clamp16(r); 1300 *out++ = (r<<16) | (l & 0xFFFF); 1301 } while (--outFrames); 1302 } else { 1303 do { 1304 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1305 in += 2; 1306 int32_t l = mulRL(1, rl, vrl) >> 12; 1307 int32_t r = mulRL(0, rl, vrl) >> 12; 1308 *out++ = (r<<16) | (l & 0xFFFF); 1309 } while (--outFrames); 1310 } 1311 numFrames -= b.frameCount; 1312 t.bufferProvider->releaseBuffer(&b); 1313 } 1314} 1315 1316#if 0 1317// 2 tracks is also a common case 1318// NEVER used in current implementation of process__validate() 1319// only use if the 2 tracks have the same output buffer 1320void AudioMixer::process__TwoTracks16BitsStereoNoResampling(state_t* state, 1321 int64_t pts) 1322{ 1323 int i; 1324 uint32_t en = state->enabledTracks; 1325 1326 i = 31 - __builtin_clz(en); 1327 const track_t& t0 = state->tracks[i]; 1328 AudioBufferProvider::Buffer& b0(t0.buffer); 1329 1330 en &= ~(1<<i); 1331 i = 31 - __builtin_clz(en); 1332 const track_t& t1 = state->tracks[i]; 1333 AudioBufferProvider::Buffer& b1(t1.buffer); 1334 1335 const int16_t *in0; 1336 const int16_t vl0 = t0.volume[0]; 1337 const int16_t vr0 = t0.volume[1]; 1338 size_t frameCount0 = 0; 1339 1340 const int16_t *in1; 1341 const int16_t vl1 = t1.volume[0]; 1342 const int16_t vr1 = t1.volume[1]; 1343 size_t frameCount1 = 0; 1344 1345 //FIXME: only works if two tracks use same buffer 1346 int32_t* out = t0.mainBuffer; 1347 size_t numFrames = state->frameCount; 1348 const int16_t *buff = NULL; 1349 1350 1351 while (numFrames) { 1352 1353 if (frameCount0 == 0) { 1354 b0.frameCount = numFrames; 1355 int64_t outputPTS = calculateOutputPTS(t0, pts, 1356 out - t0.mainBuffer); 1357 t0.bufferProvider->getNextBuffer(&b0, outputPTS); 1358 if (b0.i16 == NULL) { 1359 if (buff == NULL) { 1360 buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount]; 1361 } 1362 in0 = buff; 1363 b0.frameCount = numFrames; 1364 } else { 1365 in0 = b0.i16; 1366 } 1367 frameCount0 = b0.frameCount; 1368 } 1369 if (frameCount1 == 0) { 1370 b1.frameCount = numFrames; 1371 int64_t outputPTS = calculateOutputPTS(t1, pts, 1372 out - t0.mainBuffer); 1373 t1.bufferProvider->getNextBuffer(&b1, outputPTS); 1374 if (b1.i16 == NULL) { 1375 if (buff == NULL) { 1376 buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount]; 1377 } 1378 in1 = buff; 1379 b1.frameCount = numFrames; 1380 } else { 1381 in1 = b1.i16; 1382 } 1383 frameCount1 = b1.frameCount; 1384 } 1385 1386 size_t outFrames = frameCount0 < frameCount1?frameCount0:frameCount1; 1387 1388 numFrames -= outFrames; 1389 frameCount0 -= outFrames; 1390 frameCount1 -= outFrames; 1391 1392 do { 1393 int32_t l0 = *in0++; 1394 int32_t r0 = *in0++; 1395 l0 = mul(l0, vl0); 1396 r0 = mul(r0, vr0); 1397 int32_t l = *in1++; 1398 int32_t r = *in1++; 1399 l = mulAdd(l, vl1, l0) >> 12; 1400 r = mulAdd(r, vr1, r0) >> 12; 1401 // clamping... 1402 l = clamp16(l); 1403 r = clamp16(r); 1404 *out++ = (r<<16) | (l & 0xFFFF); 1405 } while (--outFrames); 1406 1407 if (frameCount0 == 0) { 1408 t0.bufferProvider->releaseBuffer(&b0); 1409 } 1410 if (frameCount1 == 0) { 1411 t1.bufferProvider->releaseBuffer(&b1); 1412 } 1413 } 1414 1415 delete [] buff; 1416} 1417#endif 1418 1419int64_t AudioMixer::calculateOutputPTS(const track_t& t, int64_t basePTS, 1420 int outputFrameIndex) 1421{ 1422 if (AudioBufferProvider::kInvalidPTS == basePTS) 1423 return AudioBufferProvider::kInvalidPTS; 1424 1425 return basePTS + ((outputFrameIndex * sLocalTimeFreq) / t.sampleRate); 1426} 1427 1428/*static*/ uint64_t AudioMixer::sLocalTimeFreq; 1429/*static*/ pthread_once_t AudioMixer::sOnceControl = PTHREAD_ONCE_INIT; 1430 1431/*static*/ void AudioMixer::sInitRoutine() 1432{ 1433 LocalClock lc; 1434 sLocalTimeFreq = lc.getLocalFreq(); 1435} 1436 1437// ---------------------------------------------------------------------------- 1438}; // namespace android 1439