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