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