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