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