AudioMixer.cpp revision ef7c7fbd0e3fb36af14cd7d39f64c949031516a5
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].mReformatBufferProvider != NULL) { 754 mState.tracks[name].mReformatBufferProvider->reset(); 755 } else if (mState.tracks[name].downmixerBufferProvider != NULL) { 756 } 757 758 mState.tracks[name].mInputBufferProvider = bufferProvider; 759 reconfigureBufferProviders(&mState.tracks[name]); 760} 761 762 763void AudioMixer::process(int64_t pts) 764{ 765 mState.hook(&mState, pts); 766} 767 768 769void AudioMixer::process__validate(state_t* state, int64_t pts) 770{ 771 ALOGW_IF(!state->needsChanged, 772 "in process__validate() but nothing's invalid"); 773 774 uint32_t changed = state->needsChanged; 775 state->needsChanged = 0; // clear the validation flag 776 777 // recompute which tracks are enabled / disabled 778 uint32_t enabled = 0; 779 uint32_t disabled = 0; 780 while (changed) { 781 const int i = 31 - __builtin_clz(changed); 782 const uint32_t mask = 1<<i; 783 changed &= ~mask; 784 track_t& t = state->tracks[i]; 785 (t.enabled ? enabled : disabled) |= mask; 786 } 787 state->enabledTracks &= ~disabled; 788 state->enabledTracks |= enabled; 789 790 // compute everything we need... 791 int countActiveTracks = 0; 792 bool all16BitsStereoNoResample = true; 793 bool resampling = false; 794 bool volumeRamp = false; 795 uint32_t en = state->enabledTracks; 796 while (en) { 797 const int i = 31 - __builtin_clz(en); 798 en &= ~(1<<i); 799 800 countActiveTracks++; 801 track_t& t = state->tracks[i]; 802 uint32_t n = 0; 803 // FIXME can overflow (mask is only 3 bits) 804 n |= NEEDS_CHANNEL_1 + t.channelCount - 1; 805 if (t.doesResample()) { 806 n |= NEEDS_RESAMPLE; 807 } 808 if (t.auxLevel != 0 && t.auxBuffer != NULL) { 809 n |= NEEDS_AUX; 810 } 811 812 if (t.volumeInc[0]|t.volumeInc[1]) { 813 volumeRamp = true; 814 } else if (!t.doesResample() && t.volumeRL == 0) { 815 n |= NEEDS_MUTE; 816 } 817 t.needs = n; 818 819 if (n & NEEDS_MUTE) { 820 t.hook = track__nop; 821 } else { 822 if (n & NEEDS_AUX) { 823 all16BitsStereoNoResample = false; 824 } 825 if (n & NEEDS_RESAMPLE) { 826 all16BitsStereoNoResample = false; 827 resampling = true; 828 t.hook = track__genericResample; 829 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2, 830 "Track %d needs downmix + resample", i); 831 } else { 832 if ((n & NEEDS_CHANNEL_COUNT__MASK) == NEEDS_CHANNEL_1){ 833 t.hook = track__16BitsMono; 834 all16BitsStereoNoResample = false; 835 } 836 if ((n & NEEDS_CHANNEL_COUNT__MASK) >= NEEDS_CHANNEL_2){ 837 t.hook = track__16BitsStereo; 838 ALOGV_IF((n & NEEDS_CHANNEL_COUNT__MASK) > NEEDS_CHANNEL_2, 839 "Track %d needs downmix", i); 840 } 841 } 842 } 843 } 844 845 // select the processing hooks 846 state->hook = process__nop; 847 if (countActiveTracks > 0) { 848 if (resampling) { 849 if (!state->outputTemp) { 850 state->outputTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount]; 851 } 852 if (!state->resampleTemp) { 853 state->resampleTemp = new int32_t[MAX_NUM_CHANNELS * state->frameCount]; 854 } 855 state->hook = process__genericResampling; 856 } else { 857 if (state->outputTemp) { 858 delete [] state->outputTemp; 859 state->outputTemp = NULL; 860 } 861 if (state->resampleTemp) { 862 delete [] state->resampleTemp; 863 state->resampleTemp = NULL; 864 } 865 state->hook = process__genericNoResampling; 866 if (all16BitsStereoNoResample && !volumeRamp) { 867 if (countActiveTracks == 1) { 868 state->hook = process__OneTrack16BitsStereoNoResampling; 869 } 870 } 871 } 872 } 873 874 ALOGV("mixer configuration change: %d activeTracks (%08x) " 875 "all16BitsStereoNoResample=%d, resampling=%d, volumeRamp=%d", 876 countActiveTracks, state->enabledTracks, 877 all16BitsStereoNoResample, resampling, volumeRamp); 878 879 state->hook(state, pts); 880 881 // Now that the volume ramp has been done, set optimal state and 882 // track hooks for subsequent mixer process 883 if (countActiveTracks > 0) { 884 bool allMuted = true; 885 uint32_t en = state->enabledTracks; 886 while (en) { 887 const int i = 31 - __builtin_clz(en); 888 en &= ~(1<<i); 889 track_t& t = state->tracks[i]; 890 if (!t.doesResample() && t.volumeRL == 0) { 891 t.needs |= NEEDS_MUTE; 892 t.hook = track__nop; 893 } else { 894 allMuted = false; 895 } 896 } 897 if (allMuted) { 898 state->hook = process__nop; 899 } else if (all16BitsStereoNoResample) { 900 if (countActiveTracks == 1) { 901 state->hook = process__OneTrack16BitsStereoNoResampling; 902 } 903 } 904 } 905} 906 907 908void AudioMixer::track__genericResample(track_t* t, int32_t* out, size_t outFrameCount, 909 int32_t* temp, int32_t* aux) 910{ 911 t->resampler->setSampleRate(t->sampleRate); 912 913 // ramp gain - resample to temp buffer and scale/mix in 2nd step 914 if (aux != NULL) { 915 // always resample with unity gain when sending to auxiliary buffer to be able 916 // to apply send level after resampling 917 // TODO: modify each resampler to support aux channel? 918 t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN); 919 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t)); 920 t->resampler->resample(temp, outFrameCount, t->bufferProvider); 921 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) { 922 volumeRampStereo(t, out, outFrameCount, temp, aux); 923 } else { 924 volumeStereo(t, out, outFrameCount, temp, aux); 925 } 926 } else { 927 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) { 928 t->resampler->setVolume(UNITY_GAIN, UNITY_GAIN); 929 memset(temp, 0, outFrameCount * MAX_NUM_CHANNELS * sizeof(int32_t)); 930 t->resampler->resample(temp, outFrameCount, t->bufferProvider); 931 volumeRampStereo(t, out, outFrameCount, temp, aux); 932 } 933 934 // constant gain 935 else { 936 t->resampler->setVolume(t->volume[0], t->volume[1]); 937 t->resampler->resample(out, outFrameCount, t->bufferProvider); 938 } 939 } 940} 941 942void AudioMixer::track__nop(track_t* t __unused, int32_t* out __unused, 943 size_t outFrameCount __unused, int32_t* temp __unused, int32_t* aux __unused) 944{ 945} 946 947void AudioMixer::volumeRampStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, 948 int32_t* aux) 949{ 950 int32_t vl = t->prevVolume[0]; 951 int32_t vr = t->prevVolume[1]; 952 const int32_t vlInc = t->volumeInc[0]; 953 const int32_t vrInc = t->volumeInc[1]; 954 955 //ALOGD("[0] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 956 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 957 // (vl + vlInc*frameCount)/65536.0f, frameCount); 958 959 // ramp volume 960 if (CC_UNLIKELY(aux != NULL)) { 961 int32_t va = t->prevAuxLevel; 962 const int32_t vaInc = t->auxInc; 963 int32_t l; 964 int32_t r; 965 966 do { 967 l = (*temp++ >> 12); 968 r = (*temp++ >> 12); 969 *out++ += (vl >> 16) * l; 970 *out++ += (vr >> 16) * r; 971 *aux++ += (va >> 17) * (l + r); 972 vl += vlInc; 973 vr += vrInc; 974 va += vaInc; 975 } while (--frameCount); 976 t->prevAuxLevel = va; 977 } else { 978 do { 979 *out++ += (vl >> 16) * (*temp++ >> 12); 980 *out++ += (vr >> 16) * (*temp++ >> 12); 981 vl += vlInc; 982 vr += vrInc; 983 } while (--frameCount); 984 } 985 t->prevVolume[0] = vl; 986 t->prevVolume[1] = vr; 987 t->adjustVolumeRamp(aux != NULL); 988} 989 990void AudioMixer::volumeStereo(track_t* t, int32_t* out, size_t frameCount, int32_t* temp, 991 int32_t* aux) 992{ 993 const int16_t vl = t->volume[0]; 994 const int16_t vr = t->volume[1]; 995 996 if (CC_UNLIKELY(aux != NULL)) { 997 const int16_t va = t->auxLevel; 998 do { 999 int16_t l = (int16_t)(*temp++ >> 12); 1000 int16_t r = (int16_t)(*temp++ >> 12); 1001 out[0] = mulAdd(l, vl, out[0]); 1002 int16_t a = (int16_t)(((int32_t)l + r) >> 1); 1003 out[1] = mulAdd(r, vr, out[1]); 1004 out += 2; 1005 aux[0] = mulAdd(a, va, aux[0]); 1006 aux++; 1007 } while (--frameCount); 1008 } else { 1009 do { 1010 int16_t l = (int16_t)(*temp++ >> 12); 1011 int16_t r = (int16_t)(*temp++ >> 12); 1012 out[0] = mulAdd(l, vl, out[0]); 1013 out[1] = mulAdd(r, vr, out[1]); 1014 out += 2; 1015 } while (--frameCount); 1016 } 1017} 1018 1019void AudioMixer::track__16BitsStereo(track_t* t, int32_t* out, size_t frameCount, 1020 int32_t* temp __unused, int32_t* aux) 1021{ 1022 const int16_t *in = static_cast<const int16_t *>(t->in); 1023 1024 if (CC_UNLIKELY(aux != NULL)) { 1025 int32_t l; 1026 int32_t r; 1027 // ramp gain 1028 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) { 1029 int32_t vl = t->prevVolume[0]; 1030 int32_t vr = t->prevVolume[1]; 1031 int32_t va = t->prevAuxLevel; 1032 const int32_t vlInc = t->volumeInc[0]; 1033 const int32_t vrInc = t->volumeInc[1]; 1034 const int32_t vaInc = t->auxInc; 1035 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 1036 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 1037 // (vl + vlInc*frameCount)/65536.0f, frameCount); 1038 1039 do { 1040 l = (int32_t)*in++; 1041 r = (int32_t)*in++; 1042 *out++ += (vl >> 16) * l; 1043 *out++ += (vr >> 16) * r; 1044 *aux++ += (va >> 17) * (l + r); 1045 vl += vlInc; 1046 vr += vrInc; 1047 va += vaInc; 1048 } while (--frameCount); 1049 1050 t->prevVolume[0] = vl; 1051 t->prevVolume[1] = vr; 1052 t->prevAuxLevel = va; 1053 t->adjustVolumeRamp(true); 1054 } 1055 1056 // constant gain 1057 else { 1058 const uint32_t vrl = t->volumeRL; 1059 const int16_t va = (int16_t)t->auxLevel; 1060 do { 1061 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1062 int16_t a = (int16_t)(((int32_t)in[0] + in[1]) >> 1); 1063 in += 2; 1064 out[0] = mulAddRL(1, rl, vrl, out[0]); 1065 out[1] = mulAddRL(0, rl, vrl, out[1]); 1066 out += 2; 1067 aux[0] = mulAdd(a, va, aux[0]); 1068 aux++; 1069 } while (--frameCount); 1070 } 1071 } else { 1072 // ramp gain 1073 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) { 1074 int32_t vl = t->prevVolume[0]; 1075 int32_t vr = t->prevVolume[1]; 1076 const int32_t vlInc = t->volumeInc[0]; 1077 const int32_t vrInc = t->volumeInc[1]; 1078 1079 // ALOGD("[1] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 1080 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 1081 // (vl + vlInc*frameCount)/65536.0f, frameCount); 1082 1083 do { 1084 *out++ += (vl >> 16) * (int32_t) *in++; 1085 *out++ += (vr >> 16) * (int32_t) *in++; 1086 vl += vlInc; 1087 vr += vrInc; 1088 } while (--frameCount); 1089 1090 t->prevVolume[0] = vl; 1091 t->prevVolume[1] = vr; 1092 t->adjustVolumeRamp(false); 1093 } 1094 1095 // constant gain 1096 else { 1097 const uint32_t vrl = t->volumeRL; 1098 do { 1099 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1100 in += 2; 1101 out[0] = mulAddRL(1, rl, vrl, out[0]); 1102 out[1] = mulAddRL(0, rl, vrl, out[1]); 1103 out += 2; 1104 } while (--frameCount); 1105 } 1106 } 1107 t->in = in; 1108} 1109 1110void AudioMixer::track__16BitsMono(track_t* t, int32_t* out, size_t frameCount, 1111 int32_t* temp __unused, int32_t* aux) 1112{ 1113 const int16_t *in = static_cast<int16_t const *>(t->in); 1114 1115 if (CC_UNLIKELY(aux != NULL)) { 1116 // ramp gain 1117 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1]|t->auxInc)) { 1118 int32_t vl = t->prevVolume[0]; 1119 int32_t vr = t->prevVolume[1]; 1120 int32_t va = t->prevAuxLevel; 1121 const int32_t vlInc = t->volumeInc[0]; 1122 const int32_t vrInc = t->volumeInc[1]; 1123 const int32_t vaInc = t->auxInc; 1124 1125 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 1126 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 1127 // (vl + vlInc*frameCount)/65536.0f, frameCount); 1128 1129 do { 1130 int32_t l = *in++; 1131 *out++ += (vl >> 16) * l; 1132 *out++ += (vr >> 16) * l; 1133 *aux++ += (va >> 16) * l; 1134 vl += vlInc; 1135 vr += vrInc; 1136 va += vaInc; 1137 } while (--frameCount); 1138 1139 t->prevVolume[0] = vl; 1140 t->prevVolume[1] = vr; 1141 t->prevAuxLevel = va; 1142 t->adjustVolumeRamp(true); 1143 } 1144 // constant gain 1145 else { 1146 const int16_t vl = t->volume[0]; 1147 const int16_t vr = t->volume[1]; 1148 const int16_t va = (int16_t)t->auxLevel; 1149 do { 1150 int16_t l = *in++; 1151 out[0] = mulAdd(l, vl, out[0]); 1152 out[1] = mulAdd(l, vr, out[1]); 1153 out += 2; 1154 aux[0] = mulAdd(l, va, aux[0]); 1155 aux++; 1156 } while (--frameCount); 1157 } 1158 } else { 1159 // ramp gain 1160 if (CC_UNLIKELY(t->volumeInc[0]|t->volumeInc[1])) { 1161 int32_t vl = t->prevVolume[0]; 1162 int32_t vr = t->prevVolume[1]; 1163 const int32_t vlInc = t->volumeInc[0]; 1164 const int32_t vrInc = t->volumeInc[1]; 1165 1166 // ALOGD("[2] %p: inc=%f, v0=%f, v1=%d, final=%f, count=%d", 1167 // t, vlInc/65536.0f, vl/65536.0f, t->volume[0], 1168 // (vl + vlInc*frameCount)/65536.0f, frameCount); 1169 1170 do { 1171 int32_t l = *in++; 1172 *out++ += (vl >> 16) * l; 1173 *out++ += (vr >> 16) * l; 1174 vl += vlInc; 1175 vr += vrInc; 1176 } while (--frameCount); 1177 1178 t->prevVolume[0] = vl; 1179 t->prevVolume[1] = vr; 1180 t->adjustVolumeRamp(false); 1181 } 1182 // constant gain 1183 else { 1184 const int16_t vl = t->volume[0]; 1185 const int16_t vr = t->volume[1]; 1186 do { 1187 int16_t l = *in++; 1188 out[0] = mulAdd(l, vl, out[0]); 1189 out[1] = mulAdd(l, vr, out[1]); 1190 out += 2; 1191 } while (--frameCount); 1192 } 1193 } 1194 t->in = in; 1195} 1196 1197// no-op case 1198void AudioMixer::process__nop(state_t* state, int64_t pts) 1199{ 1200 uint32_t e0 = state->enabledTracks; 1201 size_t sampleCount = state->frameCount * MAX_NUM_CHANNELS; 1202 while (e0) { 1203 // process by group of tracks with same output buffer to 1204 // avoid multiple memset() on same buffer 1205 uint32_t e1 = e0, e2 = e0; 1206 int i = 31 - __builtin_clz(e1); 1207 { 1208 track_t& t1 = state->tracks[i]; 1209 e2 &= ~(1<<i); 1210 while (e2) { 1211 i = 31 - __builtin_clz(e2); 1212 e2 &= ~(1<<i); 1213 track_t& t2 = state->tracks[i]; 1214 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) { 1215 e1 &= ~(1<<i); 1216 } 1217 } 1218 e0 &= ~(e1); 1219 1220 memset(t1.mainBuffer, 0, sampleCount 1221 * audio_bytes_per_sample(t1.mMixerFormat)); 1222 } 1223 1224 while (e1) { 1225 i = 31 - __builtin_clz(e1); 1226 e1 &= ~(1<<i); 1227 { 1228 track_t& t3 = state->tracks[i]; 1229 size_t outFrames = state->frameCount; 1230 while (outFrames) { 1231 t3.buffer.frameCount = outFrames; 1232 int64_t outputPTS = calculateOutputPTS( 1233 t3, pts, state->frameCount - outFrames); 1234 t3.bufferProvider->getNextBuffer(&t3.buffer, outputPTS); 1235 if (t3.buffer.raw == NULL) break; 1236 outFrames -= t3.buffer.frameCount; 1237 t3.bufferProvider->releaseBuffer(&t3.buffer); 1238 } 1239 } 1240 } 1241 } 1242} 1243 1244// generic code without resampling 1245void AudioMixer::process__genericNoResampling(state_t* state, int64_t pts) 1246{ 1247 int32_t outTemp[BLOCKSIZE * MAX_NUM_CHANNELS] __attribute__((aligned(32))); 1248 1249 // acquire each track's buffer 1250 uint32_t enabledTracks = state->enabledTracks; 1251 uint32_t e0 = enabledTracks; 1252 while (e0) { 1253 const int i = 31 - __builtin_clz(e0); 1254 e0 &= ~(1<<i); 1255 track_t& t = state->tracks[i]; 1256 t.buffer.frameCount = state->frameCount; 1257 t.bufferProvider->getNextBuffer(&t.buffer, pts); 1258 t.frameCount = t.buffer.frameCount; 1259 t.in = t.buffer.raw; 1260 } 1261 1262 e0 = enabledTracks; 1263 while (e0) { 1264 // process by group of tracks with same output buffer to 1265 // optimize cache use 1266 uint32_t e1 = e0, e2 = e0; 1267 int j = 31 - __builtin_clz(e1); 1268 track_t& t1 = state->tracks[j]; 1269 e2 &= ~(1<<j); 1270 while (e2) { 1271 j = 31 - __builtin_clz(e2); 1272 e2 &= ~(1<<j); 1273 track_t& t2 = state->tracks[j]; 1274 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) { 1275 e1 &= ~(1<<j); 1276 } 1277 } 1278 e0 &= ~(e1); 1279 // this assumes output 16 bits stereo, no resampling 1280 int32_t *out = t1.mainBuffer; 1281 size_t numFrames = 0; 1282 do { 1283 memset(outTemp, 0, sizeof(outTemp)); 1284 e2 = e1; 1285 while (e2) { 1286 const int i = 31 - __builtin_clz(e2); 1287 e2 &= ~(1<<i); 1288 track_t& t = state->tracks[i]; 1289 size_t outFrames = BLOCKSIZE; 1290 int32_t *aux = NULL; 1291 if (CC_UNLIKELY(t.needs & NEEDS_AUX)) { 1292 aux = t.auxBuffer + numFrames; 1293 } 1294 while (outFrames) { 1295 // t.in == NULL can happen if the track was flushed just after having 1296 // been enabled for mixing. 1297 if (t.in == NULL) { 1298 enabledTracks &= ~(1<<i); 1299 e1 &= ~(1<<i); 1300 break; 1301 } 1302 size_t inFrames = (t.frameCount > outFrames)?outFrames:t.frameCount; 1303 if (inFrames > 0) { 1304 t.hook(&t, outTemp + (BLOCKSIZE-outFrames)*MAX_NUM_CHANNELS, inFrames, 1305 state->resampleTemp, aux); 1306 t.frameCount -= inFrames; 1307 outFrames -= inFrames; 1308 if (CC_UNLIKELY(aux != NULL)) { 1309 aux += inFrames; 1310 } 1311 } 1312 if (t.frameCount == 0 && outFrames) { 1313 t.bufferProvider->releaseBuffer(&t.buffer); 1314 t.buffer.frameCount = (state->frameCount - numFrames) - 1315 (BLOCKSIZE - outFrames); 1316 int64_t outputPTS = calculateOutputPTS( 1317 t, pts, numFrames + (BLOCKSIZE - outFrames)); 1318 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS); 1319 t.in = t.buffer.raw; 1320 if (t.in == NULL) { 1321 enabledTracks &= ~(1<<i); 1322 e1 &= ~(1<<i); 1323 break; 1324 } 1325 t.frameCount = t.buffer.frameCount; 1326 } 1327 } 1328 } 1329 switch (t1.mMixerFormat) { 1330 case AUDIO_FORMAT_PCM_FLOAT: 1331 memcpy_to_float_from_q4_27(reinterpret_cast<float *>(out), outTemp, BLOCKSIZE * 2); 1332 out += BLOCKSIZE * 2; // output is 2 floats/frame. 1333 break; 1334 case AUDIO_FORMAT_PCM_16_BIT: 1335 ditherAndClamp(out, outTemp, BLOCKSIZE); 1336 out += BLOCKSIZE; // output is 1 int32_t (2 int16_t samples)/frame 1337 break; 1338 default: 1339 LOG_ALWAYS_FATAL("bad mixer format: %d", t1.mMixerFormat); 1340 } 1341 numFrames += BLOCKSIZE; 1342 } while (numFrames < state->frameCount); 1343 } 1344 1345 // release each track's buffer 1346 e0 = enabledTracks; 1347 while (e0) { 1348 const int i = 31 - __builtin_clz(e0); 1349 e0 &= ~(1<<i); 1350 track_t& t = state->tracks[i]; 1351 t.bufferProvider->releaseBuffer(&t.buffer); 1352 } 1353} 1354 1355 1356// generic code with resampling 1357void AudioMixer::process__genericResampling(state_t* state, int64_t pts) 1358{ 1359 // this const just means that local variable outTemp doesn't change 1360 int32_t* const outTemp = state->outputTemp; 1361 const size_t size = sizeof(int32_t) * MAX_NUM_CHANNELS * state->frameCount; 1362 1363 size_t numFrames = state->frameCount; 1364 1365 uint32_t e0 = state->enabledTracks; 1366 while (e0) { 1367 // process by group of tracks with same output buffer 1368 // to optimize cache use 1369 uint32_t e1 = e0, e2 = e0; 1370 int j = 31 - __builtin_clz(e1); 1371 track_t& t1 = state->tracks[j]; 1372 e2 &= ~(1<<j); 1373 while (e2) { 1374 j = 31 - __builtin_clz(e2); 1375 e2 &= ~(1<<j); 1376 track_t& t2 = state->tracks[j]; 1377 if (CC_UNLIKELY(t2.mainBuffer != t1.mainBuffer)) { 1378 e1 &= ~(1<<j); 1379 } 1380 } 1381 e0 &= ~(e1); 1382 int32_t *out = t1.mainBuffer; 1383 memset(outTemp, 0, size); 1384 while (e1) { 1385 const int i = 31 - __builtin_clz(e1); 1386 e1 &= ~(1<<i); 1387 track_t& t = state->tracks[i]; 1388 int32_t *aux = NULL; 1389 if (CC_UNLIKELY(t.needs & NEEDS_AUX)) { 1390 aux = t.auxBuffer; 1391 } 1392 1393 // this is a little goofy, on the resampling case we don't 1394 // acquire/release the buffers because it's done by 1395 // the resampler. 1396 if (t.needs & NEEDS_RESAMPLE) { 1397 t.resampler->setPTS(pts); 1398 t.hook(&t, outTemp, numFrames, state->resampleTemp, aux); 1399 } else { 1400 1401 size_t outFrames = 0; 1402 1403 while (outFrames < numFrames) { 1404 t.buffer.frameCount = numFrames - outFrames; 1405 int64_t outputPTS = calculateOutputPTS(t, pts, outFrames); 1406 t.bufferProvider->getNextBuffer(&t.buffer, outputPTS); 1407 t.in = t.buffer.raw; 1408 // t.in == NULL can happen if the track was flushed just after having 1409 // been enabled for mixing. 1410 if (t.in == NULL) break; 1411 1412 if (CC_UNLIKELY(aux != NULL)) { 1413 aux += outFrames; 1414 } 1415 t.hook(&t, outTemp + outFrames*MAX_NUM_CHANNELS, t.buffer.frameCount, 1416 state->resampleTemp, aux); 1417 outFrames += t.buffer.frameCount; 1418 t.bufferProvider->releaseBuffer(&t.buffer); 1419 } 1420 } 1421 } 1422 switch (t1.mMixerFormat) { 1423 case AUDIO_FORMAT_PCM_FLOAT: 1424 memcpy_to_float_from_q4_27(reinterpret_cast<float*>(out), outTemp, numFrames*2); 1425 break; 1426 case AUDIO_FORMAT_PCM_16_BIT: 1427 ditherAndClamp(out, outTemp, numFrames); 1428 break; 1429 default: 1430 LOG_ALWAYS_FATAL("bad mixer format: %d", t1.mMixerFormat); 1431 } 1432 } 1433} 1434 1435// one track, 16 bits stereo without resampling is the most common case 1436void AudioMixer::process__OneTrack16BitsStereoNoResampling(state_t* state, 1437 int64_t pts) 1438{ 1439 // This method is only called when state->enabledTracks has exactly 1440 // one bit set. The asserts below would verify this, but are commented out 1441 // since the whole point of this method is to optimize performance. 1442 //ALOG_ASSERT(0 != state->enabledTracks, "no tracks enabled"); 1443 const int i = 31 - __builtin_clz(state->enabledTracks); 1444 //ALOG_ASSERT((1 << i) == state->enabledTracks, "more than 1 track enabled"); 1445 const track_t& t = state->tracks[i]; 1446 1447 AudioBufferProvider::Buffer& b(t.buffer); 1448 1449 int32_t* out = t.mainBuffer; 1450 size_t numFrames = state->frameCount; 1451 1452 const int16_t vl = t.volume[0]; 1453 const int16_t vr = t.volume[1]; 1454 const uint32_t vrl = t.volumeRL; 1455 while (numFrames) { 1456 b.frameCount = numFrames; 1457 int64_t outputPTS = calculateOutputPTS(t, pts, out - t.mainBuffer); 1458 t.bufferProvider->getNextBuffer(&b, outputPTS); 1459 const int16_t *in = b.i16; 1460 1461 // in == NULL can happen if the track was flushed just after having 1462 // been enabled for mixing. 1463 if (in == NULL || ((unsigned long)in & 3)) { 1464 memset(out, 0, numFrames*MAX_NUM_CHANNELS*sizeof(int16_t)); 1465 ALOGE_IF(((unsigned long)in & 3), "process stereo track: input buffer alignment pb: " 1466 "buffer %p track %d, channels %d, needs %08x", 1467 in, i, t.channelCount, t.needs); 1468 return; 1469 } 1470 size_t outFrames = b.frameCount; 1471 1472 switch (t.mMixerFormat) { 1473 case AUDIO_FORMAT_PCM_FLOAT: { 1474 float *fout = reinterpret_cast<float*>(out); 1475 do { 1476 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1477 in += 2; 1478 int32_t l = mulRL(1, rl, vrl); 1479 int32_t r = mulRL(0, rl, vrl); 1480 *fout++ = float_from_q4_27(l); 1481 *fout++ = float_from_q4_27(r); 1482 // Note: In case of later int16_t sink output, 1483 // conversion and clamping is done by memcpy_to_i16_from_float(). 1484 } while (--outFrames); 1485 } break; 1486 case AUDIO_FORMAT_PCM_16_BIT: 1487 if (CC_UNLIKELY(uint32_t(vl) > UNITY_GAIN || uint32_t(vr) > UNITY_GAIN)) { 1488 // volume is boosted, so we might need to clamp even though 1489 // we process only one track. 1490 do { 1491 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1492 in += 2; 1493 int32_t l = mulRL(1, rl, vrl) >> 12; 1494 int32_t r = mulRL(0, rl, vrl) >> 12; 1495 // clamping... 1496 l = clamp16(l); 1497 r = clamp16(r); 1498 *out++ = (r<<16) | (l & 0xFFFF); 1499 } while (--outFrames); 1500 } else { 1501 do { 1502 uint32_t rl = *reinterpret_cast<const uint32_t *>(in); 1503 in += 2; 1504 int32_t l = mulRL(1, rl, vrl) >> 12; 1505 int32_t r = mulRL(0, rl, vrl) >> 12; 1506 *out++ = (r<<16) | (l & 0xFFFF); 1507 } while (--outFrames); 1508 } 1509 break; 1510 default: 1511 LOG_ALWAYS_FATAL("bad mixer format: %d", t.mMixerFormat); 1512 } 1513 numFrames -= b.frameCount; 1514 t.bufferProvider->releaseBuffer(&b); 1515 } 1516} 1517 1518#if 0 1519// 2 tracks is also a common case 1520// NEVER used in current implementation of process__validate() 1521// only use if the 2 tracks have the same output buffer 1522void AudioMixer::process__TwoTracks16BitsStereoNoResampling(state_t* state, 1523 int64_t pts) 1524{ 1525 int i; 1526 uint32_t en = state->enabledTracks; 1527 1528 i = 31 - __builtin_clz(en); 1529 const track_t& t0 = state->tracks[i]; 1530 AudioBufferProvider::Buffer& b0(t0.buffer); 1531 1532 en &= ~(1<<i); 1533 i = 31 - __builtin_clz(en); 1534 const track_t& t1 = state->tracks[i]; 1535 AudioBufferProvider::Buffer& b1(t1.buffer); 1536 1537 const int16_t *in0; 1538 const int16_t vl0 = t0.volume[0]; 1539 const int16_t vr0 = t0.volume[1]; 1540 size_t frameCount0 = 0; 1541 1542 const int16_t *in1; 1543 const int16_t vl1 = t1.volume[0]; 1544 const int16_t vr1 = t1.volume[1]; 1545 size_t frameCount1 = 0; 1546 1547 //FIXME: only works if two tracks use same buffer 1548 int32_t* out = t0.mainBuffer; 1549 size_t numFrames = state->frameCount; 1550 const int16_t *buff = NULL; 1551 1552 1553 while (numFrames) { 1554 1555 if (frameCount0 == 0) { 1556 b0.frameCount = numFrames; 1557 int64_t outputPTS = calculateOutputPTS(t0, pts, 1558 out - t0.mainBuffer); 1559 t0.bufferProvider->getNextBuffer(&b0, outputPTS); 1560 if (b0.i16 == NULL) { 1561 if (buff == NULL) { 1562 buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount]; 1563 } 1564 in0 = buff; 1565 b0.frameCount = numFrames; 1566 } else { 1567 in0 = b0.i16; 1568 } 1569 frameCount0 = b0.frameCount; 1570 } 1571 if (frameCount1 == 0) { 1572 b1.frameCount = numFrames; 1573 int64_t outputPTS = calculateOutputPTS(t1, pts, 1574 out - t0.mainBuffer); 1575 t1.bufferProvider->getNextBuffer(&b1, outputPTS); 1576 if (b1.i16 == NULL) { 1577 if (buff == NULL) { 1578 buff = new int16_t[MAX_NUM_CHANNELS * state->frameCount]; 1579 } 1580 in1 = buff; 1581 b1.frameCount = numFrames; 1582 } else { 1583 in1 = b1.i16; 1584 } 1585 frameCount1 = b1.frameCount; 1586 } 1587 1588 size_t outFrames = frameCount0 < frameCount1?frameCount0:frameCount1; 1589 1590 numFrames -= outFrames; 1591 frameCount0 -= outFrames; 1592 frameCount1 -= outFrames; 1593 1594 do { 1595 int32_t l0 = *in0++; 1596 int32_t r0 = *in0++; 1597 l0 = mul(l0, vl0); 1598 r0 = mul(r0, vr0); 1599 int32_t l = *in1++; 1600 int32_t r = *in1++; 1601 l = mulAdd(l, vl1, l0) >> 12; 1602 r = mulAdd(r, vr1, r0) >> 12; 1603 // clamping... 1604 l = clamp16(l); 1605 r = clamp16(r); 1606 *out++ = (r<<16) | (l & 0xFFFF); 1607 } while (--outFrames); 1608 1609 if (frameCount0 == 0) { 1610 t0.bufferProvider->releaseBuffer(&b0); 1611 } 1612 if (frameCount1 == 0) { 1613 t1.bufferProvider->releaseBuffer(&b1); 1614 } 1615 } 1616 1617 delete [] buff; 1618} 1619#endif 1620 1621int64_t AudioMixer::calculateOutputPTS(const track_t& t, int64_t basePTS, 1622 int outputFrameIndex) 1623{ 1624 if (AudioBufferProvider::kInvalidPTS == basePTS) { 1625 return AudioBufferProvider::kInvalidPTS; 1626 } 1627 1628 return basePTS + ((outputFrameIndex * sLocalTimeFreq) / t.sampleRate); 1629} 1630 1631/*static*/ uint64_t AudioMixer::sLocalTimeFreq; 1632/*static*/ pthread_once_t AudioMixer::sOnceControl = PTHREAD_ONCE_INIT; 1633 1634/*static*/ void AudioMixer::sInitRoutine() 1635{ 1636 LocalClock lc; 1637 sLocalTimeFreq = lc.getLocalFreq(); 1638 1639 // find multichannel downmix effect if we have to play multichannel content 1640 uint32_t numEffects = 0; 1641 int ret = EffectQueryNumberEffects(&numEffects); 1642 if (ret != 0) { 1643 ALOGE("AudioMixer() error %d querying number of effects", ret); 1644 return; 1645 } 1646 ALOGV("EffectQueryNumberEffects() numEffects=%d", numEffects); 1647 1648 for (uint32_t i = 0 ; i < numEffects ; i++) { 1649 if (EffectQueryEffect(i, &sDwnmFxDesc) == 0) { 1650 ALOGV("effect %d is called %s", i, sDwnmFxDesc.name); 1651 if (memcmp(&sDwnmFxDesc.type, EFFECT_UIID_DOWNMIX, sizeof(effect_uuid_t)) == 0) { 1652 ALOGI("found effect \"%s\" from %s", 1653 sDwnmFxDesc.name, sDwnmFxDesc.implementor); 1654 sIsMultichannelCapable = true; 1655 break; 1656 } 1657 } 1658 } 1659 ALOGW_IF(!sIsMultichannelCapable, "unable to find downmix effect"); 1660} 1661 1662// ---------------------------------------------------------------------------- 1663}; // namespace android 1664