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