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