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