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