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