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