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