1 /* 2 ** 3 ** Copyright 2012, 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 19 #define LOG_TAG "AudioFlinger" 20 //#define LOG_NDEBUG 0 21 22 #include "Configuration.h" 23 #include <utils/Log.h> 24 #include <audio_utils/primitives.h> 25 #include <private/media/AudioEffectShared.h> 26 #include <media/audiohal/EffectHalInterface.h> 27 #include <media/audiohal/EffectsFactoryHalInterface.h> 28 #include <system/audio_effects/effect_visualizer.h> 29 30 #include "AudioFlinger.h" 31 #include "ServiceUtilities.h" 32 33 // ---------------------------------------------------------------------------- 34 35 // Note: the following macro is used for extremely verbose logging message. In 36 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to 37 // 0; but one side effect of this is to turn all LOGV's as well. Some messages 38 // are so verbose that we want to suppress them even when we have ALOG_ASSERT 39 // turned on. Do not uncomment the #def below unless you really know what you 40 // are doing and want to see all of the extremely verbose messages. 41 //#define VERY_VERY_VERBOSE_LOGGING 42 #ifdef VERY_VERY_VERBOSE_LOGGING 43 #define ALOGVV ALOGV 44 #else 45 #define ALOGVV(a...) do { } while(0) 46 #endif 47 48 #define min(a, b) ((a) < (b) ? (a) : (b)) 49 50 namespace android { 51 52 // ---------------------------------------------------------------------------- 53 // EffectModule implementation 54 // ---------------------------------------------------------------------------- 55 56 #undef LOG_TAG 57 #define LOG_TAG "AudioFlinger::EffectModule" 58 59 AudioFlinger::EffectModule::EffectModule(ThreadBase *thread, 60 const wp<AudioFlinger::EffectChain>& chain, 61 effect_descriptor_t *desc, 62 int id, 63 audio_session_t sessionId, 64 bool pinned) 65 : mPinned(pinned), 66 mThread(thread), mChain(chain), mId(id), mSessionId(sessionId), 67 mDescriptor(*desc), 68 // mConfig is set by configure() and not used before then 69 mStatus(NO_INIT), mState(IDLE), 70 // mMaxDisableWaitCnt is set by configure() and not used before then 71 // mDisableWaitCnt is set by process() and updateState() and not used before then 72 mSuspended(false), 73 mAudioFlinger(thread->mAudioFlinger) 74 { 75 ALOGV("Constructor %p pinned %d", this, pinned); 76 int lStatus; 77 78 // create effect engine from effect factory 79 mStatus = -ENODEV; 80 sp<AudioFlinger> audioFlinger = mAudioFlinger.promote(); 81 if (audioFlinger != 0) { 82 sp<EffectsFactoryHalInterface> effectsFactory = audioFlinger->getEffectsFactory(); 83 if (effectsFactory != 0) { 84 mStatus = effectsFactory->createEffect( 85 &desc->uuid, sessionId, thread->id(), &mEffectInterface); 86 } 87 } 88 89 if (mStatus != NO_ERROR) { 90 return; 91 } 92 lStatus = init(); 93 if (lStatus < 0) { 94 mStatus = lStatus; 95 goto Error; 96 } 97 98 setOffloaded(thread->type() == ThreadBase::OFFLOAD, thread->id()); 99 ALOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface.get()); 100 101 return; 102 Error: 103 mEffectInterface.clear(); 104 ALOGV("Constructor Error %d", mStatus); 105 } 106 107 AudioFlinger::EffectModule::~EffectModule() 108 { 109 ALOGV("Destructor %p", this); 110 if (mEffectInterface != 0) { 111 ALOGW("EffectModule %p destructor called with unreleased interface", this); 112 release_l(); 113 } 114 115 } 116 117 status_t AudioFlinger::EffectModule::addHandle(EffectHandle *handle) 118 { 119 status_t status; 120 121 Mutex::Autolock _l(mLock); 122 int priority = handle->priority(); 123 size_t size = mHandles.size(); 124 EffectHandle *controlHandle = NULL; 125 size_t i; 126 for (i = 0; i < size; i++) { 127 EffectHandle *h = mHandles[i]; 128 if (h == NULL || h->disconnected()) { 129 continue; 130 } 131 // first non destroyed handle is considered in control 132 if (controlHandle == NULL) { 133 controlHandle = h; 134 } 135 if (h->priority() <= priority) { 136 break; 137 } 138 } 139 // if inserted in first place, move effect control from previous owner to this handle 140 if (i == 0) { 141 bool enabled = false; 142 if (controlHandle != NULL) { 143 enabled = controlHandle->enabled(); 144 controlHandle->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/); 145 } 146 handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/); 147 status = NO_ERROR; 148 } else { 149 status = ALREADY_EXISTS; 150 } 151 ALOGV("addHandle() %p added handle %p in position %zu", this, handle, i); 152 mHandles.insertAt(handle, i); 153 return status; 154 } 155 156 ssize_t AudioFlinger::EffectModule::removeHandle(EffectHandle *handle) 157 { 158 Mutex::Autolock _l(mLock); 159 return removeHandle_l(handle); 160 } 161 162 ssize_t AudioFlinger::EffectModule::removeHandle_l(EffectHandle *handle) 163 { 164 size_t size = mHandles.size(); 165 size_t i; 166 for (i = 0; i < size; i++) { 167 if (mHandles[i] == handle) { 168 break; 169 } 170 } 171 if (i == size) { 172 ALOGW("%s %p handle not found %p", __FUNCTION__, this, handle); 173 return BAD_VALUE; 174 } 175 ALOGV("removeHandle_l() %p removed handle %p in position %zu", this, handle, i); 176 177 mHandles.removeAt(i); 178 // if removed from first place, move effect control from this handle to next in line 179 if (i == 0) { 180 EffectHandle *h = controlHandle_l(); 181 if (h != NULL) { 182 h->setControl(true /*hasControl*/, true /*signal*/ , handle->enabled() /*enabled*/); 183 } 184 } 185 186 // Prevent calls to process() and other functions on effect interface from now on. 187 // The effect engine will be released by the destructor when the last strong reference on 188 // this object is released which can happen after next process is called. 189 if (mHandles.size() == 0 && !mPinned) { 190 mState = DESTROYED; 191 mEffectInterface->close(); 192 } 193 194 return mHandles.size(); 195 } 196 197 // must be called with EffectModule::mLock held 198 AudioFlinger::EffectHandle *AudioFlinger::EffectModule::controlHandle_l() 199 { 200 // the first valid handle in the list has control over the module 201 for (size_t i = 0; i < mHandles.size(); i++) { 202 EffectHandle *h = mHandles[i]; 203 if (h != NULL && !h->disconnected()) { 204 return h; 205 } 206 } 207 208 return NULL; 209 } 210 211 // unsafe method called when the effect parent thread has been destroyed 212 ssize_t AudioFlinger::EffectModule::disconnectHandle(EffectHandle *handle, bool unpinIfLast) 213 { 214 ALOGV("disconnect() %p handle %p", this, handle); 215 Mutex::Autolock _l(mLock); 216 ssize_t numHandles = removeHandle_l(handle); 217 if ((numHandles == 0) && (!mPinned || unpinIfLast)) { 218 AudioSystem::unregisterEffect(mId); 219 sp<AudioFlinger> af = mAudioFlinger.promote(); 220 if (af != 0) { 221 mLock.unlock(); 222 af->updateOrphanEffectChains(this); 223 mLock.lock(); 224 } 225 } 226 return numHandles; 227 } 228 229 bool AudioFlinger::EffectModule::updateState() { 230 Mutex::Autolock _l(mLock); 231 232 bool started = false; 233 switch (mState) { 234 case RESTART: 235 reset_l(); 236 // FALL THROUGH 237 238 case STARTING: 239 // clear auxiliary effect input buffer for next accumulation 240 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 241 memset(mConfig.inputCfg.buffer.raw, 242 0, 243 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t)); 244 } 245 if (start_l() == NO_ERROR) { 246 mState = ACTIVE; 247 started = true; 248 } else { 249 mState = IDLE; 250 } 251 break; 252 case STOPPING: 253 if (stop_l() == NO_ERROR) { 254 mDisableWaitCnt = mMaxDisableWaitCnt; 255 } else { 256 mDisableWaitCnt = 1; // will cause immediate transition to IDLE 257 } 258 mState = STOPPED; 259 break; 260 case STOPPED: 261 // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the 262 // turn off sequence. 263 if (--mDisableWaitCnt == 0) { 264 reset_l(); 265 mState = IDLE; 266 } 267 break; 268 default: //IDLE , ACTIVE, DESTROYED 269 break; 270 } 271 272 return started; 273 } 274 275 void AudioFlinger::EffectModule::process() 276 { 277 Mutex::Autolock _l(mLock); 278 279 if (mState == DESTROYED || mEffectInterface == 0 || mInBuffer == 0 || mOutBuffer == 0) { 280 return; 281 } 282 283 if (isProcessEnabled()) { 284 // do 32 bit to 16 bit conversion for auxiliary effect input buffer 285 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 286 ditherAndClamp(mConfig.inputCfg.buffer.s32, 287 mConfig.inputCfg.buffer.s32, 288 mConfig.inputCfg.buffer.frameCount/2); 289 } 290 int ret; 291 if (isProcessImplemented()) { 292 // do the actual processing in the effect engine 293 ret = mEffectInterface->process(); 294 } else { 295 if (mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) { 296 size_t frameCnt = mConfig.inputCfg.buffer.frameCount * FCC_2; //always stereo here 297 int16_t *in = mConfig.inputCfg.buffer.s16; 298 int16_t *out = mConfig.outputCfg.buffer.s16; 299 300 if (mConfig.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE) { 301 for (size_t i = 0; i < frameCnt; i++) { 302 out[i] = clamp16((int32_t)out[i] + (int32_t)in[i]); 303 } 304 } else { 305 memcpy(mConfig.outputCfg.buffer.raw, mConfig.inputCfg.buffer.raw, 306 frameCnt * sizeof(int16_t)); 307 } 308 } 309 ret = -ENODATA; 310 } 311 // force transition to IDLE state when engine is ready 312 if (mState == STOPPED && ret == -ENODATA) { 313 mDisableWaitCnt = 1; 314 } 315 316 // clear auxiliary effect input buffer for next accumulation 317 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 318 memset(mConfig.inputCfg.buffer.raw, 0, 319 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t)); 320 } 321 } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT && 322 mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) { 323 // If an insert effect is idle and input buffer is different from output buffer, 324 // accumulate input onto output 325 sp<EffectChain> chain = mChain.promote(); 326 if (chain != 0 && chain->activeTrackCnt() != 0) { 327 size_t frameCnt = mConfig.inputCfg.buffer.frameCount * FCC_2; //always stereo here 328 int16_t *in = mConfig.inputCfg.buffer.s16; 329 int16_t *out = mConfig.outputCfg.buffer.s16; 330 for (size_t i = 0; i < frameCnt; i++) { 331 out[i] = clamp16((int32_t)out[i] + (int32_t)in[i]); 332 } 333 } 334 } 335 } 336 337 void AudioFlinger::EffectModule::reset_l() 338 { 339 if (mStatus != NO_ERROR || mEffectInterface == 0) { 340 return; 341 } 342 mEffectInterface->command(EFFECT_CMD_RESET, 0, NULL, 0, NULL); 343 } 344 345 status_t AudioFlinger::EffectModule::configure() 346 { 347 status_t status; 348 sp<ThreadBase> thread; 349 uint32_t size; 350 audio_channel_mask_t channelMask; 351 352 if (mEffectInterface == 0) { 353 status = NO_INIT; 354 goto exit; 355 } 356 357 thread = mThread.promote(); 358 if (thread == 0) { 359 status = DEAD_OBJECT; 360 goto exit; 361 } 362 363 // TODO: handle configuration of effects replacing track process 364 channelMask = thread->channelMask(); 365 mConfig.outputCfg.channels = channelMask; 366 367 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 368 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO; 369 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; 370 ALOGV("Overriding auxiliary effect input as MONO and output as STEREO"); 371 } else { 372 mConfig.inputCfg.channels = channelMask; 373 // TODO: Update this logic when multichannel effects are implemented. 374 // For offloaded tracks consider mono output as stereo for proper effect initialization 375 if (channelMask == AUDIO_CHANNEL_OUT_MONO) { 376 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; 377 mConfig.outputCfg.channels = AUDIO_CHANNEL_OUT_STEREO; 378 ALOGV("Overriding effect input and output as STEREO"); 379 } 380 } 381 382 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 383 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 384 mConfig.inputCfg.samplingRate = thread->sampleRate(); 385 mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate; 386 mConfig.inputCfg.bufferProvider.cookie = NULL; 387 mConfig.inputCfg.bufferProvider.getBuffer = NULL; 388 mConfig.inputCfg.bufferProvider.releaseBuffer = NULL; 389 mConfig.outputCfg.bufferProvider.cookie = NULL; 390 mConfig.outputCfg.bufferProvider.getBuffer = NULL; 391 mConfig.outputCfg.bufferProvider.releaseBuffer = NULL; 392 mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; 393 // Insert effect: 394 // - in session AUDIO_SESSION_OUTPUT_MIX or AUDIO_SESSION_OUTPUT_STAGE, 395 // always overwrites output buffer: input buffer == output buffer 396 // - in other sessions: 397 // last effect in the chain accumulates in output buffer: input buffer != output buffer 398 // other effect: overwrites output buffer: input buffer == output buffer 399 // Auxiliary effect: 400 // accumulates in output buffer: input buffer != output buffer 401 // Therefore: accumulate <=> input buffer != output buffer 402 if (mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) { 403 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE; 404 } else { 405 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE; 406 } 407 mConfig.inputCfg.mask = EFFECT_CONFIG_ALL; 408 mConfig.outputCfg.mask = EFFECT_CONFIG_ALL; 409 mConfig.inputCfg.buffer.frameCount = thread->frameCount(); 410 mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount; 411 if (mInBuffer != 0) { 412 mInBuffer->setFrameCount(mConfig.inputCfg.buffer.frameCount); 413 } 414 if (mOutBuffer != 0) { 415 mOutBuffer->setFrameCount(mConfig.outputCfg.buffer.frameCount); 416 } 417 418 ALOGV("configure() %p thread %p buffer %p framecount %zu", 419 this, thread.get(), mConfig.inputCfg.buffer.raw, mConfig.inputCfg.buffer.frameCount); 420 421 status_t cmdStatus; 422 size = sizeof(int); 423 status = mEffectInterface->command(EFFECT_CMD_SET_CONFIG, 424 sizeof(effect_config_t), 425 &mConfig, 426 &size, 427 &cmdStatus); 428 if (status == 0) { 429 status = cmdStatus; 430 } 431 432 if (status == 0 && 433 (memcmp(&mDescriptor.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0)) { 434 uint32_t buf32[sizeof(effect_param_t) / sizeof(uint32_t) + 2]; 435 effect_param_t *p = (effect_param_t *)buf32; 436 437 p->psize = sizeof(uint32_t); 438 p->vsize = sizeof(uint32_t); 439 size = sizeof(int); 440 *(int32_t *)p->data = VISUALIZER_PARAM_LATENCY; 441 442 uint32_t latency = 0; 443 PlaybackThread *pbt = thread->mAudioFlinger->checkPlaybackThread_l(thread->mId); 444 if (pbt != NULL) { 445 latency = pbt->latency_l(); 446 } 447 448 *((int32_t *)p->data + 1)= latency; 449 mEffectInterface->command(EFFECT_CMD_SET_PARAM, 450 sizeof(effect_param_t) + 8, 451 &buf32, 452 &size, 453 &cmdStatus); 454 } 455 456 mMaxDisableWaitCnt = (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate) / 457 (1000 * mConfig.outputCfg.buffer.frameCount); 458 459 exit: 460 mStatus = status; 461 return status; 462 } 463 464 status_t AudioFlinger::EffectModule::init() 465 { 466 Mutex::Autolock _l(mLock); 467 if (mEffectInterface == 0) { 468 return NO_INIT; 469 } 470 status_t cmdStatus; 471 uint32_t size = sizeof(status_t); 472 status_t status = mEffectInterface->command(EFFECT_CMD_INIT, 473 0, 474 NULL, 475 &size, 476 &cmdStatus); 477 if (status == 0) { 478 status = cmdStatus; 479 } 480 return status; 481 } 482 483 void AudioFlinger::EffectModule::addEffectToHal_l() 484 { 485 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC || 486 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) { 487 sp<ThreadBase> thread = mThread.promote(); 488 if (thread != 0) { 489 sp<StreamHalInterface> stream = thread->stream(); 490 if (stream != 0) { 491 status_t result = stream->addEffect(mEffectInterface); 492 ALOGE_IF(result != OK, "Error when adding effect: %d", result); 493 } 494 } 495 } 496 } 497 498 // start() must be called with PlaybackThread::mLock or EffectChain::mLock held 499 status_t AudioFlinger::EffectModule::start() 500 { 501 sp<EffectChain> chain; 502 status_t status; 503 { 504 Mutex::Autolock _l(mLock); 505 status = start_l(); 506 if (status == NO_ERROR) { 507 chain = mChain.promote(); 508 } 509 } 510 if (chain != 0) { 511 chain->resetVolume_l(); 512 } 513 return status; 514 } 515 516 status_t AudioFlinger::EffectModule::start_l() 517 { 518 if (mEffectInterface == 0) { 519 return NO_INIT; 520 } 521 if (mStatus != NO_ERROR) { 522 return mStatus; 523 } 524 status_t cmdStatus; 525 uint32_t size = sizeof(status_t); 526 status_t status = mEffectInterface->command(EFFECT_CMD_ENABLE, 527 0, 528 NULL, 529 &size, 530 &cmdStatus); 531 if (status == 0) { 532 status = cmdStatus; 533 } 534 if (status == 0) { 535 addEffectToHal_l(); 536 } 537 return status; 538 } 539 540 status_t AudioFlinger::EffectModule::stop() 541 { 542 Mutex::Autolock _l(mLock); 543 return stop_l(); 544 } 545 546 status_t AudioFlinger::EffectModule::stop_l() 547 { 548 if (mEffectInterface == 0) { 549 return NO_INIT; 550 } 551 if (mStatus != NO_ERROR) { 552 return mStatus; 553 } 554 status_t cmdStatus = NO_ERROR; 555 uint32_t size = sizeof(status_t); 556 status_t status = mEffectInterface->command(EFFECT_CMD_DISABLE, 557 0, 558 NULL, 559 &size, 560 &cmdStatus); 561 if (status == NO_ERROR) { 562 status = cmdStatus; 563 } 564 if (status == NO_ERROR) { 565 status = remove_effect_from_hal_l(); 566 } 567 return status; 568 } 569 570 // must be called with EffectChain::mLock held 571 void AudioFlinger::EffectModule::release_l() 572 { 573 if (mEffectInterface != 0) { 574 remove_effect_from_hal_l(); 575 // release effect engine 576 mEffectInterface->close(); 577 mEffectInterface.clear(); 578 } 579 } 580 581 status_t AudioFlinger::EffectModule::remove_effect_from_hal_l() 582 { 583 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC || 584 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) { 585 sp<ThreadBase> thread = mThread.promote(); 586 if (thread != 0) { 587 sp<StreamHalInterface> stream = thread->stream(); 588 if (stream != 0) { 589 status_t result = stream->removeEffect(mEffectInterface); 590 ALOGE_IF(result != OK, "Error when removing effect: %d", result); 591 } 592 } 593 } 594 return NO_ERROR; 595 } 596 597 // round up delta valid if value and divisor are positive. 598 template <typename T> 599 static T roundUpDelta(const T &value, const T &divisor) { 600 T remainder = value % divisor; 601 return remainder == 0 ? 0 : divisor - remainder; 602 } 603 604 status_t AudioFlinger::EffectModule::command(uint32_t cmdCode, 605 uint32_t cmdSize, 606 void *pCmdData, 607 uint32_t *replySize, 608 void *pReplyData) 609 { 610 Mutex::Autolock _l(mLock); 611 ALOGVV("command(), cmdCode: %d, mEffectInterface: %p", cmdCode, mEffectInterface.get()); 612 613 if (mState == DESTROYED || mEffectInterface == 0) { 614 return NO_INIT; 615 } 616 if (mStatus != NO_ERROR) { 617 return mStatus; 618 } 619 if (cmdCode == EFFECT_CMD_GET_PARAM && 620 (sizeof(effect_param_t) > cmdSize || 621 ((effect_param_t *)pCmdData)->psize > cmdSize 622 - sizeof(effect_param_t))) { 623 android_errorWriteLog(0x534e4554, "32438594"); 624 android_errorWriteLog(0x534e4554, "33003822"); 625 return -EINVAL; 626 } 627 if (cmdCode == EFFECT_CMD_GET_PARAM && 628 (*replySize < sizeof(effect_param_t) || 629 ((effect_param_t *)pCmdData)->psize > *replySize - sizeof(effect_param_t))) { 630 android_errorWriteLog(0x534e4554, "29251553"); 631 return -EINVAL; 632 } 633 if (cmdCode == EFFECT_CMD_GET_PARAM && 634 (sizeof(effect_param_t) > *replySize 635 || ((effect_param_t *)pCmdData)->psize > *replySize 636 - sizeof(effect_param_t) 637 || ((effect_param_t *)pCmdData)->vsize > *replySize 638 - sizeof(effect_param_t) 639 - ((effect_param_t *)pCmdData)->psize 640 || roundUpDelta(((effect_param_t *)pCmdData)->psize, (uint32_t)sizeof(int)) > 641 *replySize 642 - sizeof(effect_param_t) 643 - ((effect_param_t *)pCmdData)->psize 644 - ((effect_param_t *)pCmdData)->vsize)) { 645 ALOGV("\tLVM_ERROR : EFFECT_CMD_GET_PARAM: reply size inconsistent"); 646 android_errorWriteLog(0x534e4554, "32705438"); 647 return -EINVAL; 648 } 649 if ((cmdCode == EFFECT_CMD_SET_PARAM 650 || cmdCode == EFFECT_CMD_SET_PARAM_DEFERRED) && // DEFERRED not generally used 651 (sizeof(effect_param_t) > cmdSize 652 || ((effect_param_t *)pCmdData)->psize > cmdSize 653 - sizeof(effect_param_t) 654 || ((effect_param_t *)pCmdData)->vsize > cmdSize 655 - sizeof(effect_param_t) 656 - ((effect_param_t *)pCmdData)->psize 657 || roundUpDelta(((effect_param_t *)pCmdData)->psize, (uint32_t)sizeof(int)) > 658 cmdSize 659 - sizeof(effect_param_t) 660 - ((effect_param_t *)pCmdData)->psize 661 - ((effect_param_t *)pCmdData)->vsize)) { 662 android_errorWriteLog(0x534e4554, "30204301"); 663 return -EINVAL; 664 } 665 status_t status = mEffectInterface->command(cmdCode, 666 cmdSize, 667 pCmdData, 668 replySize, 669 pReplyData); 670 if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) { 671 uint32_t size = (replySize == NULL) ? 0 : *replySize; 672 for (size_t i = 1; i < mHandles.size(); i++) { 673 EffectHandle *h = mHandles[i]; 674 if (h != NULL && !h->disconnected()) { 675 h->commandExecuted(cmdCode, cmdSize, pCmdData, size, pReplyData); 676 } 677 } 678 } 679 return status; 680 } 681 682 status_t AudioFlinger::EffectModule::setEnabled(bool enabled) 683 { 684 Mutex::Autolock _l(mLock); 685 return setEnabled_l(enabled); 686 } 687 688 // must be called with EffectModule::mLock held 689 status_t AudioFlinger::EffectModule::setEnabled_l(bool enabled) 690 { 691 692 ALOGV("setEnabled %p enabled %d", this, enabled); 693 694 if (enabled != isEnabled()) { 695 status_t status = AudioSystem::setEffectEnabled(mId, enabled); 696 if (enabled && status != NO_ERROR) { 697 return status; 698 } 699 700 switch (mState) { 701 // going from disabled to enabled 702 case IDLE: 703 mState = STARTING; 704 break; 705 case STOPPED: 706 mState = RESTART; 707 break; 708 case STOPPING: 709 mState = ACTIVE; 710 break; 711 712 // going from enabled to disabled 713 case RESTART: 714 mState = STOPPED; 715 break; 716 case STARTING: 717 mState = IDLE; 718 break; 719 case ACTIVE: 720 mState = STOPPING; 721 break; 722 case DESTROYED: 723 return NO_ERROR; // simply ignore as we are being destroyed 724 } 725 for (size_t i = 1; i < mHandles.size(); i++) { 726 EffectHandle *h = mHandles[i]; 727 if (h != NULL && !h->disconnected()) { 728 h->setEnabled(enabled); 729 } 730 } 731 } 732 return NO_ERROR; 733 } 734 735 bool AudioFlinger::EffectModule::isEnabled() const 736 { 737 switch (mState) { 738 case RESTART: 739 case STARTING: 740 case ACTIVE: 741 return true; 742 case IDLE: 743 case STOPPING: 744 case STOPPED: 745 case DESTROYED: 746 default: 747 return false; 748 } 749 } 750 751 bool AudioFlinger::EffectModule::isProcessEnabled() const 752 { 753 if (mStatus != NO_ERROR) { 754 return false; 755 } 756 757 switch (mState) { 758 case RESTART: 759 case ACTIVE: 760 case STOPPING: 761 case STOPPED: 762 return true; 763 case IDLE: 764 case STARTING: 765 case DESTROYED: 766 default: 767 return false; 768 } 769 } 770 771 void AudioFlinger::EffectModule::setInBuffer(const sp<EffectBufferHalInterface>& buffer) { 772 if (buffer != 0) { 773 mConfig.inputCfg.buffer.raw = buffer->audioBuffer()->raw; 774 buffer->setFrameCount(mConfig.inputCfg.buffer.frameCount); 775 } else { 776 mConfig.inputCfg.buffer.raw = NULL; 777 } 778 mInBuffer = buffer; 779 mEffectInterface->setInBuffer(buffer); 780 } 781 782 void AudioFlinger::EffectModule::setOutBuffer(const sp<EffectBufferHalInterface>& buffer) { 783 if (buffer != 0) { 784 mConfig.outputCfg.buffer.raw = buffer->audioBuffer()->raw; 785 buffer->setFrameCount(mConfig.outputCfg.buffer.frameCount); 786 } else { 787 mConfig.outputCfg.buffer.raw = NULL; 788 } 789 mOutBuffer = buffer; 790 mEffectInterface->setOutBuffer(buffer); 791 } 792 793 status_t AudioFlinger::EffectModule::setVolume(uint32_t *left, uint32_t *right, bool controller) 794 { 795 Mutex::Autolock _l(mLock); 796 if (mStatus != NO_ERROR) { 797 return mStatus; 798 } 799 status_t status = NO_ERROR; 800 // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume 801 // if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set) 802 if (isProcessEnabled() && 803 ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL || 804 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND)) { 805 uint32_t volume[2]; 806 uint32_t *pVolume = NULL; 807 uint32_t size = sizeof(volume); 808 volume[0] = *left; 809 volume[1] = *right; 810 if (controller) { 811 pVolume = volume; 812 } 813 status = mEffectInterface->command(EFFECT_CMD_SET_VOLUME, 814 size, 815 volume, 816 &size, 817 pVolume); 818 if (controller && status == NO_ERROR && size == sizeof(volume)) { 819 *left = volume[0]; 820 *right = volume[1]; 821 } 822 } 823 return status; 824 } 825 826 status_t AudioFlinger::EffectModule::setDevice(audio_devices_t device) 827 { 828 if (device == AUDIO_DEVICE_NONE) { 829 return NO_ERROR; 830 } 831 832 Mutex::Autolock _l(mLock); 833 if (mStatus != NO_ERROR) { 834 return mStatus; 835 } 836 status_t status = NO_ERROR; 837 if ((mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) { 838 status_t cmdStatus; 839 uint32_t size = sizeof(status_t); 840 uint32_t cmd = audio_is_output_devices(device) ? EFFECT_CMD_SET_DEVICE : 841 EFFECT_CMD_SET_INPUT_DEVICE; 842 status = mEffectInterface->command(cmd, 843 sizeof(uint32_t), 844 &device, 845 &size, 846 &cmdStatus); 847 } 848 return status; 849 } 850 851 status_t AudioFlinger::EffectModule::setMode(audio_mode_t mode) 852 { 853 Mutex::Autolock _l(mLock); 854 if (mStatus != NO_ERROR) { 855 return mStatus; 856 } 857 status_t status = NO_ERROR; 858 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) { 859 status_t cmdStatus; 860 uint32_t size = sizeof(status_t); 861 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_MODE, 862 sizeof(audio_mode_t), 863 &mode, 864 &size, 865 &cmdStatus); 866 if (status == NO_ERROR) { 867 status = cmdStatus; 868 } 869 } 870 return status; 871 } 872 873 status_t AudioFlinger::EffectModule::setAudioSource(audio_source_t source) 874 { 875 Mutex::Autolock _l(mLock); 876 if (mStatus != NO_ERROR) { 877 return mStatus; 878 } 879 status_t status = NO_ERROR; 880 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_SOURCE_MASK) == EFFECT_FLAG_AUDIO_SOURCE_IND) { 881 uint32_t size = 0; 882 status = mEffectInterface->command(EFFECT_CMD_SET_AUDIO_SOURCE, 883 sizeof(audio_source_t), 884 &source, 885 &size, 886 NULL); 887 } 888 return status; 889 } 890 891 void AudioFlinger::EffectModule::setSuspended(bool suspended) 892 { 893 Mutex::Autolock _l(mLock); 894 mSuspended = suspended; 895 } 896 897 bool AudioFlinger::EffectModule::suspended() const 898 { 899 Mutex::Autolock _l(mLock); 900 return mSuspended; 901 } 902 903 bool AudioFlinger::EffectModule::purgeHandles() 904 { 905 bool enabled = false; 906 Mutex::Autolock _l(mLock); 907 for (size_t i = 0; i < mHandles.size(); i++) { 908 EffectHandle *handle = mHandles[i]; 909 if (handle != NULL && !handle->disconnected()) { 910 if (handle->hasControl()) { 911 enabled = handle->enabled(); 912 } 913 } 914 } 915 return enabled; 916 } 917 918 status_t AudioFlinger::EffectModule::setOffloaded(bool offloaded, audio_io_handle_t io) 919 { 920 Mutex::Autolock _l(mLock); 921 if (mStatus != NO_ERROR) { 922 return mStatus; 923 } 924 status_t status = NO_ERROR; 925 if ((mDescriptor.flags & EFFECT_FLAG_OFFLOAD_SUPPORTED) != 0) { 926 status_t cmdStatus; 927 uint32_t size = sizeof(status_t); 928 effect_offload_param_t cmd; 929 930 cmd.isOffload = offloaded; 931 cmd.ioHandle = io; 932 status = mEffectInterface->command(EFFECT_CMD_OFFLOAD, 933 sizeof(effect_offload_param_t), 934 &cmd, 935 &size, 936 &cmdStatus); 937 if (status == NO_ERROR) { 938 status = cmdStatus; 939 } 940 mOffloaded = (status == NO_ERROR) ? offloaded : false; 941 } else { 942 if (offloaded) { 943 status = INVALID_OPERATION; 944 } 945 mOffloaded = false; 946 } 947 ALOGV("setOffloaded() offloaded %d io %d status %d", offloaded, io, status); 948 return status; 949 } 950 951 bool AudioFlinger::EffectModule::isOffloaded() const 952 { 953 Mutex::Autolock _l(mLock); 954 return mOffloaded; 955 } 956 957 String8 effectFlagsToString(uint32_t flags) { 958 String8 s; 959 960 s.append("conn. mode: "); 961 switch (flags & EFFECT_FLAG_TYPE_MASK) { 962 case EFFECT_FLAG_TYPE_INSERT: s.append("insert"); break; 963 case EFFECT_FLAG_TYPE_AUXILIARY: s.append("auxiliary"); break; 964 case EFFECT_FLAG_TYPE_REPLACE: s.append("replace"); break; 965 case EFFECT_FLAG_TYPE_PRE_PROC: s.append("preproc"); break; 966 case EFFECT_FLAG_TYPE_POST_PROC: s.append("postproc"); break; 967 default: s.append("unknown/reserved"); break; 968 } 969 s.append(", "); 970 971 s.append("insert pref: "); 972 switch (flags & EFFECT_FLAG_INSERT_MASK) { 973 case EFFECT_FLAG_INSERT_ANY: s.append("any"); break; 974 case EFFECT_FLAG_INSERT_FIRST: s.append("first"); break; 975 case EFFECT_FLAG_INSERT_LAST: s.append("last"); break; 976 case EFFECT_FLAG_INSERT_EXCLUSIVE: s.append("exclusive"); break; 977 default: s.append("unknown/reserved"); break; 978 } 979 s.append(", "); 980 981 s.append("volume mgmt: "); 982 switch (flags & EFFECT_FLAG_VOLUME_MASK) { 983 case EFFECT_FLAG_VOLUME_NONE: s.append("none"); break; 984 case EFFECT_FLAG_VOLUME_CTRL: s.append("implements control"); break; 985 case EFFECT_FLAG_VOLUME_IND: s.append("requires indication"); break; 986 default: s.append("unknown/reserved"); break; 987 } 988 s.append(", "); 989 990 uint32_t devind = flags & EFFECT_FLAG_DEVICE_MASK; 991 if (devind) { 992 s.append("device indication: "); 993 switch (devind) { 994 case EFFECT_FLAG_DEVICE_IND: s.append("requires updates"); break; 995 default: s.append("unknown/reserved"); break; 996 } 997 s.append(", "); 998 } 999 1000 s.append("input mode: "); 1001 switch (flags & EFFECT_FLAG_INPUT_MASK) { 1002 case EFFECT_FLAG_INPUT_DIRECT: s.append("direct"); break; 1003 case EFFECT_FLAG_INPUT_PROVIDER: s.append("provider"); break; 1004 case EFFECT_FLAG_INPUT_BOTH: s.append("direct+provider"); break; 1005 default: s.append("not set"); break; 1006 } 1007 s.append(", "); 1008 1009 s.append("output mode: "); 1010 switch (flags & EFFECT_FLAG_OUTPUT_MASK) { 1011 case EFFECT_FLAG_OUTPUT_DIRECT: s.append("direct"); break; 1012 case EFFECT_FLAG_OUTPUT_PROVIDER: s.append("provider"); break; 1013 case EFFECT_FLAG_OUTPUT_BOTH: s.append("direct+provider"); break; 1014 default: s.append("not set"); break; 1015 } 1016 s.append(", "); 1017 1018 uint32_t accel = flags & EFFECT_FLAG_HW_ACC_MASK; 1019 if (accel) { 1020 s.append("hardware acceleration: "); 1021 switch (accel) { 1022 case EFFECT_FLAG_HW_ACC_SIMPLE: s.append("non-tunneled"); break; 1023 case EFFECT_FLAG_HW_ACC_TUNNEL: s.append("tunneled"); break; 1024 default: s.append("unknown/reserved"); break; 1025 } 1026 s.append(", "); 1027 } 1028 1029 uint32_t modeind = flags & EFFECT_FLAG_AUDIO_MODE_MASK; 1030 if (modeind) { 1031 s.append("mode indication: "); 1032 switch (modeind) { 1033 case EFFECT_FLAG_AUDIO_MODE_IND: s.append("required"); break; 1034 default: s.append("unknown/reserved"); break; 1035 } 1036 s.append(", "); 1037 } 1038 1039 uint32_t srcind = flags & EFFECT_FLAG_AUDIO_SOURCE_MASK; 1040 if (srcind) { 1041 s.append("source indication: "); 1042 switch (srcind) { 1043 case EFFECT_FLAG_AUDIO_SOURCE_IND: s.append("required"); break; 1044 default: s.append("unknown/reserved"); break; 1045 } 1046 s.append(", "); 1047 } 1048 1049 if (flags & EFFECT_FLAG_OFFLOAD_MASK) { 1050 s.append("offloadable, "); 1051 } 1052 1053 int len = s.length(); 1054 if (s.length() > 2) { 1055 (void) s.lockBuffer(len); 1056 s.unlockBuffer(len - 2); 1057 } 1058 return s; 1059 } 1060 1061 1062 void AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args __unused) 1063 { 1064 const size_t SIZE = 256; 1065 char buffer[SIZE]; 1066 String8 result; 1067 1068 snprintf(buffer, SIZE, "\tEffect ID %d:\n", mId); 1069 result.append(buffer); 1070 1071 bool locked = AudioFlinger::dumpTryLock(mLock); 1072 // failed to lock - AudioFlinger is probably deadlocked 1073 if (!locked) { 1074 result.append("\t\tCould not lock Fx mutex:\n"); 1075 } 1076 1077 result.append("\t\tSession Status State Engine:\n"); 1078 snprintf(buffer, SIZE, "\t\t%05d %03d %03d %p\n", 1079 mSessionId, mStatus, mState, mEffectInterface.get()); 1080 result.append(buffer); 1081 1082 result.append("\t\tDescriptor:\n"); 1083 snprintf(buffer, SIZE, "\t\t- UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n", 1084 mDescriptor.uuid.timeLow, mDescriptor.uuid.timeMid, mDescriptor.uuid.timeHiAndVersion, 1085 mDescriptor.uuid.clockSeq, mDescriptor.uuid.node[0], mDescriptor.uuid.node[1], 1086 mDescriptor.uuid.node[2], 1087 mDescriptor.uuid.node[3],mDescriptor.uuid.node[4],mDescriptor.uuid.node[5]); 1088 result.append(buffer); 1089 snprintf(buffer, SIZE, "\t\t- TYPE: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n", 1090 mDescriptor.type.timeLow, mDescriptor.type.timeMid, 1091 mDescriptor.type.timeHiAndVersion, 1092 mDescriptor.type.clockSeq, mDescriptor.type.node[0], mDescriptor.type.node[1], 1093 mDescriptor.type.node[2], 1094 mDescriptor.type.node[3],mDescriptor.type.node[4],mDescriptor.type.node[5]); 1095 result.append(buffer); 1096 snprintf(buffer, SIZE, "\t\t- apiVersion: %08X\n\t\t- flags: %08X (%s)\n", 1097 mDescriptor.apiVersion, 1098 mDescriptor.flags, 1099 effectFlagsToString(mDescriptor.flags).string()); 1100 result.append(buffer); 1101 snprintf(buffer, SIZE, "\t\t- name: %s\n", 1102 mDescriptor.name); 1103 result.append(buffer); 1104 snprintf(buffer, SIZE, "\t\t- implementor: %s\n", 1105 mDescriptor.implementor); 1106 result.append(buffer); 1107 1108 result.append("\t\t- Input configuration:\n"); 1109 result.append("\t\t\tFrames Smp rate Channels Format Buffer\n"); 1110 snprintf(buffer, SIZE, "\t\t\t%05zu %05d %08x %6d (%s) %p\n", 1111 mConfig.inputCfg.buffer.frameCount, 1112 mConfig.inputCfg.samplingRate, 1113 mConfig.inputCfg.channels, 1114 mConfig.inputCfg.format, 1115 formatToString((audio_format_t)mConfig.inputCfg.format).c_str(), 1116 mConfig.inputCfg.buffer.raw); 1117 result.append(buffer); 1118 1119 result.append("\t\t- Output configuration:\n"); 1120 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n"); 1121 snprintf(buffer, SIZE, "\t\t\t%p %05zu %05d %08x %d (%s)\n", 1122 mConfig.outputCfg.buffer.raw, 1123 mConfig.outputCfg.buffer.frameCount, 1124 mConfig.outputCfg.samplingRate, 1125 mConfig.outputCfg.channels, 1126 mConfig.outputCfg.format, 1127 formatToString((audio_format_t)mConfig.outputCfg.format).c_str()); 1128 result.append(buffer); 1129 1130 snprintf(buffer, SIZE, "\t\t%zu Clients:\n", mHandles.size()); 1131 result.append(buffer); 1132 result.append("\t\t\t Pid Priority Ctrl Locked client server\n"); 1133 for (size_t i = 0; i < mHandles.size(); ++i) { 1134 EffectHandle *handle = mHandles[i]; 1135 if (handle != NULL && !handle->disconnected()) { 1136 handle->dumpToBuffer(buffer, SIZE); 1137 result.append(buffer); 1138 } 1139 } 1140 1141 write(fd, result.string(), result.length()); 1142 1143 if (locked) { 1144 mLock.unlock(); 1145 } 1146 } 1147 1148 // ---------------------------------------------------------------------------- 1149 // EffectHandle implementation 1150 // ---------------------------------------------------------------------------- 1151 1152 #undef LOG_TAG 1153 #define LOG_TAG "AudioFlinger::EffectHandle" 1154 1155 AudioFlinger::EffectHandle::EffectHandle(const sp<EffectModule>& effect, 1156 const sp<AudioFlinger::Client>& client, 1157 const sp<IEffectClient>& effectClient, 1158 int32_t priority) 1159 : BnEffect(), 1160 mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL), 1161 mPriority(priority), mHasControl(false), mEnabled(false), mDisconnected(false) 1162 { 1163 ALOGV("constructor %p", this); 1164 1165 if (client == 0) { 1166 return; 1167 } 1168 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int); 1169 mCblkMemory = client->heap()->allocate(EFFECT_PARAM_BUFFER_SIZE + bufOffset); 1170 if (mCblkMemory == 0 || 1171 (mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->pointer())) == NULL) { 1172 ALOGE("not enough memory for Effect size=%zu", EFFECT_PARAM_BUFFER_SIZE + 1173 sizeof(effect_param_cblk_t)); 1174 mCblkMemory.clear(); 1175 return; 1176 } 1177 new(mCblk) effect_param_cblk_t(); 1178 mBuffer = (uint8_t *)mCblk + bufOffset; 1179 } 1180 1181 AudioFlinger::EffectHandle::~EffectHandle() 1182 { 1183 ALOGV("Destructor %p", this); 1184 disconnect(false); 1185 } 1186 1187 status_t AudioFlinger::EffectHandle::initCheck() 1188 { 1189 return mClient == 0 || mCblkMemory != 0 ? OK : NO_MEMORY; 1190 } 1191 1192 status_t AudioFlinger::EffectHandle::enable() 1193 { 1194 AutoMutex _l(mLock); 1195 ALOGV("enable %p", this); 1196 sp<EffectModule> effect = mEffect.promote(); 1197 if (effect == 0 || mDisconnected) { 1198 return DEAD_OBJECT; 1199 } 1200 if (!mHasControl) { 1201 return INVALID_OPERATION; 1202 } 1203 1204 if (mEnabled) { 1205 return NO_ERROR; 1206 } 1207 1208 mEnabled = true; 1209 1210 sp<ThreadBase> thread = effect->thread().promote(); 1211 if (thread != 0) { 1212 thread->checkSuspendOnEffectEnabled(effect, true, effect->sessionId()); 1213 } 1214 1215 // checkSuspendOnEffectEnabled() can suspend this same effect when enabled 1216 if (effect->suspended()) { 1217 return NO_ERROR; 1218 } 1219 1220 status_t status = effect->setEnabled(true); 1221 if (status != NO_ERROR) { 1222 if (thread != 0) { 1223 thread->checkSuspendOnEffectEnabled(effect, false, effect->sessionId()); 1224 } 1225 mEnabled = false; 1226 } else { 1227 if (thread != 0) { 1228 if (thread->type() == ThreadBase::OFFLOAD || thread->type() == ThreadBase::MMAP) { 1229 Mutex::Autolock _l(thread->mLock); 1230 thread->broadcast_l(); 1231 } 1232 if (!effect->isOffloadable()) { 1233 if (thread->type() == ThreadBase::OFFLOAD) { 1234 PlaybackThread *t = (PlaybackThread *)thread.get(); 1235 t->invalidateTracks(AUDIO_STREAM_MUSIC); 1236 } 1237 if (effect->sessionId() == AUDIO_SESSION_OUTPUT_MIX) { 1238 thread->mAudioFlinger->onNonOffloadableGlobalEffectEnable(); 1239 } 1240 } 1241 } 1242 } 1243 return status; 1244 } 1245 1246 status_t AudioFlinger::EffectHandle::disable() 1247 { 1248 ALOGV("disable %p", this); 1249 AutoMutex _l(mLock); 1250 sp<EffectModule> effect = mEffect.promote(); 1251 if (effect == 0 || mDisconnected) { 1252 return DEAD_OBJECT; 1253 } 1254 if (!mHasControl) { 1255 return INVALID_OPERATION; 1256 } 1257 1258 if (!mEnabled) { 1259 return NO_ERROR; 1260 } 1261 mEnabled = false; 1262 1263 if (effect->suspended()) { 1264 return NO_ERROR; 1265 } 1266 1267 status_t status = effect->setEnabled(false); 1268 1269 sp<ThreadBase> thread = effect->thread().promote(); 1270 if (thread != 0) { 1271 thread->checkSuspendOnEffectEnabled(effect, false, effect->sessionId()); 1272 if (thread->type() == ThreadBase::OFFLOAD || thread->type() == ThreadBase::MMAP) { 1273 Mutex::Autolock _l(thread->mLock); 1274 thread->broadcast_l(); 1275 } 1276 } 1277 1278 return status; 1279 } 1280 1281 void AudioFlinger::EffectHandle::disconnect() 1282 { 1283 ALOGV("%s %p", __FUNCTION__, this); 1284 disconnect(true); 1285 } 1286 1287 void AudioFlinger::EffectHandle::disconnect(bool unpinIfLast) 1288 { 1289 AutoMutex _l(mLock); 1290 ALOGV("disconnect(%s) %p", unpinIfLast ? "true" : "false", this); 1291 if (mDisconnected) { 1292 if (unpinIfLast) { 1293 android_errorWriteLog(0x534e4554, "32707507"); 1294 } 1295 return; 1296 } 1297 mDisconnected = true; 1298 sp<ThreadBase> thread; 1299 { 1300 sp<EffectModule> effect = mEffect.promote(); 1301 if (effect != 0) { 1302 thread = effect->thread().promote(); 1303 } 1304 } 1305 if (thread != 0) { 1306 thread->disconnectEffectHandle(this, unpinIfLast); 1307 } else { 1308 ALOGW("%s Effect handle %p disconnected after thread destruction", __FUNCTION__, this); 1309 // try to cleanup as much as we can 1310 sp<EffectModule> effect = mEffect.promote(); 1311 if (effect != 0) { 1312 effect->disconnectHandle(this, unpinIfLast); 1313 } 1314 } 1315 1316 if (mClient != 0) { 1317 if (mCblk != NULL) { 1318 // unlike ~TrackBase(), mCblk is never a local new, so don't delete 1319 mCblk->~effect_param_cblk_t(); // destroy our shared-structure. 1320 } 1321 mCblkMemory.clear(); // free the shared memory before releasing the heap it belongs to 1322 // Client destructor must run with AudioFlinger client mutex locked 1323 Mutex::Autolock _l(mClient->audioFlinger()->mClientLock); 1324 mClient.clear(); 1325 } 1326 } 1327 1328 status_t AudioFlinger::EffectHandle::command(uint32_t cmdCode, 1329 uint32_t cmdSize, 1330 void *pCmdData, 1331 uint32_t *replySize, 1332 void *pReplyData) 1333 { 1334 ALOGVV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p", 1335 cmdCode, mHasControl, mEffect.unsafe_get()); 1336 1337 if (cmdCode == EFFECT_CMD_ENABLE) { 1338 if (*replySize < sizeof(int)) { 1339 android_errorWriteLog(0x534e4554, "32095713"); 1340 return BAD_VALUE; 1341 } 1342 *(int *)pReplyData = NO_ERROR; 1343 *replySize = sizeof(int); 1344 return enable(); 1345 } else if (cmdCode == EFFECT_CMD_DISABLE) { 1346 if (*replySize < sizeof(int)) { 1347 android_errorWriteLog(0x534e4554, "32095713"); 1348 return BAD_VALUE; 1349 } 1350 *(int *)pReplyData = NO_ERROR; 1351 *replySize = sizeof(int); 1352 return disable(); 1353 } 1354 1355 AutoMutex _l(mLock); 1356 sp<EffectModule> effect = mEffect.promote(); 1357 if (effect == 0 || mDisconnected) { 1358 return DEAD_OBJECT; 1359 } 1360 // only get parameter command is permitted for applications not controlling the effect 1361 if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) { 1362 return INVALID_OPERATION; 1363 } 1364 if (mClient == 0) { 1365 return INVALID_OPERATION; 1366 } 1367 1368 // handle commands that are not forwarded transparently to effect engine 1369 if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) { 1370 if (*replySize < sizeof(int)) { 1371 android_errorWriteLog(0x534e4554, "32095713"); 1372 return BAD_VALUE; 1373 } 1374 *(int *)pReplyData = NO_ERROR; 1375 *replySize = sizeof(int); 1376 1377 // No need to trylock() here as this function is executed in the binder thread serving a 1378 // particular client process: no risk to block the whole media server process or mixer 1379 // threads if we are stuck here 1380 Mutex::Autolock _l(mCblk->lock); 1381 // keep local copy of index in case of client corruption b/32220769 1382 const uint32_t clientIndex = mCblk->clientIndex; 1383 const uint32_t serverIndex = mCblk->serverIndex; 1384 if (clientIndex > EFFECT_PARAM_BUFFER_SIZE || 1385 serverIndex > EFFECT_PARAM_BUFFER_SIZE) { 1386 mCblk->serverIndex = 0; 1387 mCblk->clientIndex = 0; 1388 return BAD_VALUE; 1389 } 1390 status_t status = NO_ERROR; 1391 effect_param_t *param = NULL; 1392 for (uint32_t index = serverIndex; index < clientIndex;) { 1393 int *p = (int *)(mBuffer + index); 1394 const int size = *p++; 1395 if (size < 0 1396 || size > EFFECT_PARAM_BUFFER_SIZE 1397 || ((uint8_t *)p + size) > mBuffer + clientIndex) { 1398 ALOGW("command(): invalid parameter block size"); 1399 status = BAD_VALUE; 1400 break; 1401 } 1402 1403 // copy to local memory in case of client corruption b/32220769 1404 param = (effect_param_t *)realloc(param, size); 1405 if (param == NULL) { 1406 ALOGW("command(): out of memory"); 1407 status = NO_MEMORY; 1408 break; 1409 } 1410 memcpy(param, p, size); 1411 1412 int reply = 0; 1413 uint32_t rsize = sizeof(reply); 1414 status_t ret = effect->command(EFFECT_CMD_SET_PARAM, 1415 size, 1416 param, 1417 &rsize, 1418 &reply); 1419 1420 // verify shared memory: server index shouldn't change; client index can't go back. 1421 if (serverIndex != mCblk->serverIndex 1422 || clientIndex > mCblk->clientIndex) { 1423 android_errorWriteLog(0x534e4554, "32220769"); 1424 status = BAD_VALUE; 1425 break; 1426 } 1427 1428 // stop at first error encountered 1429 if (ret != NO_ERROR) { 1430 status = ret; 1431 *(int *)pReplyData = reply; 1432 break; 1433 } else if (reply != NO_ERROR) { 1434 *(int *)pReplyData = reply; 1435 break; 1436 } 1437 index += size; 1438 } 1439 free(param); 1440 mCblk->serverIndex = 0; 1441 mCblk->clientIndex = 0; 1442 return status; 1443 } 1444 1445 return effect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData); 1446 } 1447 1448 void AudioFlinger::EffectHandle::setControl(bool hasControl, bool signal, bool enabled) 1449 { 1450 ALOGV("setControl %p control %d", this, hasControl); 1451 1452 mHasControl = hasControl; 1453 mEnabled = enabled; 1454 1455 if (signal && mEffectClient != 0) { 1456 mEffectClient->controlStatusChanged(hasControl); 1457 } 1458 } 1459 1460 void AudioFlinger::EffectHandle::commandExecuted(uint32_t cmdCode, 1461 uint32_t cmdSize, 1462 void *pCmdData, 1463 uint32_t replySize, 1464 void *pReplyData) 1465 { 1466 if (mEffectClient != 0) { 1467 mEffectClient->commandExecuted(cmdCode, cmdSize, pCmdData, replySize, pReplyData); 1468 } 1469 } 1470 1471 1472 1473 void AudioFlinger::EffectHandle::setEnabled(bool enabled) 1474 { 1475 if (mEffectClient != 0) { 1476 mEffectClient->enableStatusChanged(enabled); 1477 } 1478 } 1479 1480 status_t AudioFlinger::EffectHandle::onTransact( 1481 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 1482 { 1483 return BnEffect::onTransact(code, data, reply, flags); 1484 } 1485 1486 1487 void AudioFlinger::EffectHandle::dumpToBuffer(char* buffer, size_t size) 1488 { 1489 bool locked = mCblk != NULL && AudioFlinger::dumpTryLock(mCblk->lock); 1490 1491 snprintf(buffer, size, "\t\t\t%5d %5d %3s %3s %5u %5u\n", 1492 (mClient == 0) ? getpid_cached : mClient->pid(), 1493 mPriority, 1494 mHasControl ? "yes" : "no", 1495 locked ? "yes" : "no", 1496 mCblk ? mCblk->clientIndex : 0, 1497 mCblk ? mCblk->serverIndex : 0 1498 ); 1499 1500 if (locked) { 1501 mCblk->lock.unlock(); 1502 } 1503 } 1504 1505 #undef LOG_TAG 1506 #define LOG_TAG "AudioFlinger::EffectChain" 1507 1508 AudioFlinger::EffectChain::EffectChain(ThreadBase *thread, 1509 audio_session_t sessionId) 1510 : mThread(thread), mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0), 1511 mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX), 1512 mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX) 1513 { 1514 mStrategy = AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); 1515 if (thread == NULL) { 1516 return; 1517 } 1518 mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) / 1519 thread->frameCount(); 1520 } 1521 1522 AudioFlinger::EffectChain::~EffectChain() 1523 { 1524 } 1525 1526 // getEffectFromDesc_l() must be called with ThreadBase::mLock held 1527 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromDesc_l( 1528 effect_descriptor_t *descriptor) 1529 { 1530 size_t size = mEffects.size(); 1531 1532 for (size_t i = 0; i < size; i++) { 1533 if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) { 1534 return mEffects[i]; 1535 } 1536 } 1537 return 0; 1538 } 1539 1540 // getEffectFromId_l() must be called with ThreadBase::mLock held 1541 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromId_l(int id) 1542 { 1543 size_t size = mEffects.size(); 1544 1545 for (size_t i = 0; i < size; i++) { 1546 // by convention, return first effect if id provided is 0 (0 is never a valid id) 1547 if (id == 0 || mEffects[i]->id() == id) { 1548 return mEffects[i]; 1549 } 1550 } 1551 return 0; 1552 } 1553 1554 // getEffectFromType_l() must be called with ThreadBase::mLock held 1555 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromType_l( 1556 const effect_uuid_t *type) 1557 { 1558 size_t size = mEffects.size(); 1559 1560 for (size_t i = 0; i < size; i++) { 1561 if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) { 1562 return mEffects[i]; 1563 } 1564 } 1565 return 0; 1566 } 1567 1568 void AudioFlinger::EffectChain::clearInputBuffer() 1569 { 1570 Mutex::Autolock _l(mLock); 1571 sp<ThreadBase> thread = mThread.promote(); 1572 if (thread == 0) { 1573 ALOGW("clearInputBuffer(): cannot promote mixer thread"); 1574 return; 1575 } 1576 clearInputBuffer_l(thread); 1577 } 1578 1579 // Must be called with EffectChain::mLock locked 1580 void AudioFlinger::EffectChain::clearInputBuffer_l(const sp<ThreadBase>& thread) 1581 { 1582 if (mInBuffer == NULL) { 1583 return; 1584 } 1585 // TODO: This will change in the future, depending on multichannel 1586 // and sample format changes for effects. 1587 // Currently effects processing is only available for stereo, AUDIO_FORMAT_PCM_16_BIT 1588 // (4 bytes frame size) 1589 const size_t frameSize = 1590 audio_bytes_per_sample(AUDIO_FORMAT_PCM_16_BIT) * min(FCC_2, thread->channelCount()); 1591 memset(mInBuffer->audioBuffer()->raw, 0, thread->frameCount() * frameSize); 1592 mInBuffer->commit(); 1593 } 1594 1595 // Must be called with EffectChain::mLock locked 1596 void AudioFlinger::EffectChain::process_l() 1597 { 1598 sp<ThreadBase> thread = mThread.promote(); 1599 if (thread == 0) { 1600 ALOGW("process_l(): cannot promote mixer thread"); 1601 return; 1602 } 1603 bool isGlobalSession = (mSessionId == AUDIO_SESSION_OUTPUT_MIX) || 1604 (mSessionId == AUDIO_SESSION_OUTPUT_STAGE); 1605 // never process effects when: 1606 // - on an OFFLOAD thread 1607 // - no more tracks are on the session and the effect tail has been rendered 1608 bool doProcess = (thread->type() != ThreadBase::OFFLOAD) 1609 && (thread->type() != ThreadBase::MMAP); 1610 if (!isGlobalSession) { 1611 bool tracksOnSession = (trackCnt() != 0); 1612 1613 if (!tracksOnSession && mTailBufferCount == 0) { 1614 doProcess = false; 1615 } 1616 1617 if (activeTrackCnt() == 0) { 1618 // if no track is active and the effect tail has not been rendered, 1619 // the input buffer must be cleared here as the mixer process will not do it 1620 if (tracksOnSession || mTailBufferCount > 0) { 1621 clearInputBuffer_l(thread); 1622 if (mTailBufferCount > 0) { 1623 mTailBufferCount--; 1624 } 1625 } 1626 } 1627 } 1628 1629 size_t size = mEffects.size(); 1630 if (doProcess) { 1631 // Only the input and output buffers of the chain can be external, 1632 // and 'update' / 'commit' do nothing for allocated buffers, thus 1633 // it's not needed to consider any other buffers here. 1634 mInBuffer->update(); 1635 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) { 1636 mOutBuffer->update(); 1637 } 1638 for (size_t i = 0; i < size; i++) { 1639 mEffects[i]->process(); 1640 } 1641 mInBuffer->commit(); 1642 if (mInBuffer->audioBuffer()->raw != mOutBuffer->audioBuffer()->raw) { 1643 mOutBuffer->commit(); 1644 } 1645 } 1646 bool doResetVolume = false; 1647 for (size_t i = 0; i < size; i++) { 1648 doResetVolume = mEffects[i]->updateState() || doResetVolume; 1649 } 1650 if (doResetVolume) { 1651 resetVolume_l(); 1652 } 1653 } 1654 1655 // createEffect_l() must be called with ThreadBase::mLock held 1656 status_t AudioFlinger::EffectChain::createEffect_l(sp<EffectModule>& effect, 1657 ThreadBase *thread, 1658 effect_descriptor_t *desc, 1659 int id, 1660 audio_session_t sessionId, 1661 bool pinned) 1662 { 1663 Mutex::Autolock _l(mLock); 1664 effect = new EffectModule(thread, this, desc, id, sessionId, pinned); 1665 status_t lStatus = effect->status(); 1666 if (lStatus == NO_ERROR) { 1667 lStatus = addEffect_ll(effect); 1668 } 1669 if (lStatus != NO_ERROR) { 1670 effect.clear(); 1671 } 1672 return lStatus; 1673 } 1674 1675 // addEffect_l() must be called with ThreadBase::mLock held 1676 status_t AudioFlinger::EffectChain::addEffect_l(const sp<EffectModule>& effect) 1677 { 1678 Mutex::Autolock _l(mLock); 1679 return addEffect_ll(effect); 1680 } 1681 // addEffect_l() must be called with ThreadBase::mLock and EffectChain::mLock held 1682 status_t AudioFlinger::EffectChain::addEffect_ll(const sp<EffectModule>& effect) 1683 { 1684 effect_descriptor_t desc = effect->desc(); 1685 uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK; 1686 1687 effect->setChain(this); 1688 sp<ThreadBase> thread = mThread.promote(); 1689 if (thread == 0) { 1690 return NO_INIT; 1691 } 1692 effect->setThread(thread); 1693 1694 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 1695 // Auxiliary effects are inserted at the beginning of mEffects vector as 1696 // they are processed first and accumulated in chain input buffer 1697 mEffects.insertAt(effect, 0); 1698 1699 // the input buffer for auxiliary effect contains mono samples in 1700 // 32 bit format. This is to avoid saturation in AudoMixer 1701 // accumulation stage. Saturation is done in EffectModule::process() before 1702 // calling the process in effect engine 1703 size_t numSamples = thread->frameCount(); 1704 sp<EffectBufferHalInterface> halBuffer; 1705 status_t result = EffectBufferHalInterface::allocate( 1706 numSamples * sizeof(int32_t), &halBuffer); 1707 if (result != OK) return result; 1708 effect->setInBuffer(halBuffer); 1709 // auxiliary effects output samples to chain input buffer for further processing 1710 // by insert effects 1711 effect->setOutBuffer(mInBuffer); 1712 } else { 1713 // Insert effects are inserted at the end of mEffects vector as they are processed 1714 // after track and auxiliary effects. 1715 // Insert effect order as a function of indicated preference: 1716 // if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if 1717 // another effect is present 1718 // else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the 1719 // last effect claiming first position 1720 // else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the 1721 // first effect claiming last position 1722 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last 1723 // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is 1724 // already present 1725 1726 size_t size = mEffects.size(); 1727 size_t idx_insert = size; 1728 ssize_t idx_insert_first = -1; 1729 ssize_t idx_insert_last = -1; 1730 1731 for (size_t i = 0; i < size; i++) { 1732 effect_descriptor_t d = mEffects[i]->desc(); 1733 uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK; 1734 uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK; 1735 if (iMode == EFFECT_FLAG_TYPE_INSERT) { 1736 // check invalid effect chaining combinations 1737 if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE || 1738 iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) { 1739 ALOGW("addEffect_l() could not insert effect %s: exclusive conflict with %s", 1740 desc.name, d.name); 1741 return INVALID_OPERATION; 1742 } 1743 // remember position of first insert effect and by default 1744 // select this as insert position for new effect 1745 if (idx_insert == size) { 1746 idx_insert = i; 1747 } 1748 // remember position of last insert effect claiming 1749 // first position 1750 if (iPref == EFFECT_FLAG_INSERT_FIRST) { 1751 idx_insert_first = i; 1752 } 1753 // remember position of first insert effect claiming 1754 // last position 1755 if (iPref == EFFECT_FLAG_INSERT_LAST && 1756 idx_insert_last == -1) { 1757 idx_insert_last = i; 1758 } 1759 } 1760 } 1761 1762 // modify idx_insert from first position if needed 1763 if (insertPref == EFFECT_FLAG_INSERT_LAST) { 1764 if (idx_insert_last != -1) { 1765 idx_insert = idx_insert_last; 1766 } else { 1767 idx_insert = size; 1768 } 1769 } else { 1770 if (idx_insert_first != -1) { 1771 idx_insert = idx_insert_first + 1; 1772 } 1773 } 1774 1775 // always read samples from chain input buffer 1776 effect->setInBuffer(mInBuffer); 1777 1778 // if last effect in the chain, output samples to chain 1779 // output buffer, otherwise to chain input buffer 1780 if (idx_insert == size) { 1781 if (idx_insert != 0) { 1782 mEffects[idx_insert-1]->setOutBuffer(mInBuffer); 1783 mEffects[idx_insert-1]->configure(); 1784 } 1785 effect->setOutBuffer(mOutBuffer); 1786 } else { 1787 effect->setOutBuffer(mInBuffer); 1788 } 1789 mEffects.insertAt(effect, idx_insert); 1790 1791 ALOGV("addEffect_l() effect %p, added in chain %p at rank %zu", effect.get(), this, 1792 idx_insert); 1793 } 1794 effect->configure(); 1795 return NO_ERROR; 1796 } 1797 1798 // removeEffect_l() must be called with ThreadBase::mLock held 1799 size_t AudioFlinger::EffectChain::removeEffect_l(const sp<EffectModule>& effect, 1800 bool release) 1801 { 1802 Mutex::Autolock _l(mLock); 1803 size_t size = mEffects.size(); 1804 uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK; 1805 1806 for (size_t i = 0; i < size; i++) { 1807 if (effect == mEffects[i]) { 1808 // calling stop here will remove pre-processing effect from the audio HAL. 1809 // This is safe as we hold the EffectChain mutex which guarantees that we are not in 1810 // the middle of a read from audio HAL 1811 if (mEffects[i]->state() == EffectModule::ACTIVE || 1812 mEffects[i]->state() == EffectModule::STOPPING) { 1813 mEffects[i]->stop(); 1814 } 1815 if (release) { 1816 mEffects[i]->release_l(); 1817 } 1818 1819 if (type != EFFECT_FLAG_TYPE_AUXILIARY) { 1820 if (i == size - 1 && i != 0) { 1821 mEffects[i - 1]->setOutBuffer(mOutBuffer); 1822 mEffects[i - 1]->configure(); 1823 } 1824 } 1825 mEffects.removeAt(i); 1826 ALOGV("removeEffect_l() effect %p, removed from chain %p at rank %zu", effect.get(), 1827 this, i); 1828 1829 break; 1830 } 1831 } 1832 1833 return mEffects.size(); 1834 } 1835 1836 // setDevice_l() must be called with ThreadBase::mLock held 1837 void AudioFlinger::EffectChain::setDevice_l(audio_devices_t device) 1838 { 1839 size_t size = mEffects.size(); 1840 for (size_t i = 0; i < size; i++) { 1841 mEffects[i]->setDevice(device); 1842 } 1843 } 1844 1845 // setMode_l() must be called with ThreadBase::mLock held 1846 void AudioFlinger::EffectChain::setMode_l(audio_mode_t mode) 1847 { 1848 size_t size = mEffects.size(); 1849 for (size_t i = 0; i < size; i++) { 1850 mEffects[i]->setMode(mode); 1851 } 1852 } 1853 1854 // setAudioSource_l() must be called with ThreadBase::mLock held 1855 void AudioFlinger::EffectChain::setAudioSource_l(audio_source_t source) 1856 { 1857 size_t size = mEffects.size(); 1858 for (size_t i = 0; i < size; i++) { 1859 mEffects[i]->setAudioSource(source); 1860 } 1861 } 1862 1863 // setVolume_l() must be called with ThreadBase::mLock or EffectChain::mLock held 1864 bool AudioFlinger::EffectChain::setVolume_l(uint32_t *left, uint32_t *right, bool force) 1865 { 1866 uint32_t newLeft = *left; 1867 uint32_t newRight = *right; 1868 bool hasControl = false; 1869 int ctrlIdx = -1; 1870 size_t size = mEffects.size(); 1871 1872 // first update volume controller 1873 for (size_t i = size; i > 0; i--) { 1874 if (mEffects[i - 1]->isProcessEnabled() && 1875 (mEffects[i - 1]->desc().flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL) { 1876 ctrlIdx = i - 1; 1877 hasControl = true; 1878 break; 1879 } 1880 } 1881 1882 if (!force && ctrlIdx == mVolumeCtrlIdx && 1883 *left == mLeftVolume && *right == mRightVolume) { 1884 if (hasControl) { 1885 *left = mNewLeftVolume; 1886 *right = mNewRightVolume; 1887 } 1888 return hasControl; 1889 } 1890 1891 mVolumeCtrlIdx = ctrlIdx; 1892 mLeftVolume = newLeft; 1893 mRightVolume = newRight; 1894 1895 // second get volume update from volume controller 1896 if (ctrlIdx >= 0) { 1897 mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true); 1898 mNewLeftVolume = newLeft; 1899 mNewRightVolume = newRight; 1900 } 1901 // then indicate volume to all other effects in chain. 1902 // Pass altered volume to effects before volume controller 1903 // and requested volume to effects after controller 1904 uint32_t lVol = newLeft; 1905 uint32_t rVol = newRight; 1906 1907 for (size_t i = 0; i < size; i++) { 1908 if ((int)i == ctrlIdx) { 1909 continue; 1910 } 1911 // this also works for ctrlIdx == -1 when there is no volume controller 1912 if ((int)i > ctrlIdx) { 1913 lVol = *left; 1914 rVol = *right; 1915 } 1916 mEffects[i]->setVolume(&lVol, &rVol, false); 1917 } 1918 *left = newLeft; 1919 *right = newRight; 1920 1921 return hasControl; 1922 } 1923 1924 // resetVolume_l() must be called with ThreadBase::mLock or EffectChain::mLock held 1925 void AudioFlinger::EffectChain::resetVolume_l() 1926 { 1927 if ((mLeftVolume != UINT_MAX) && (mRightVolume != UINT_MAX)) { 1928 uint32_t left = mLeftVolume; 1929 uint32_t right = mRightVolume; 1930 (void)setVolume_l(&left, &right, true); 1931 } 1932 } 1933 1934 void AudioFlinger::EffectChain::syncHalEffectsState() 1935 { 1936 Mutex::Autolock _l(mLock); 1937 for (size_t i = 0; i < mEffects.size(); i++) { 1938 if (mEffects[i]->state() == EffectModule::ACTIVE || 1939 mEffects[i]->state() == EffectModule::STOPPING) { 1940 mEffects[i]->addEffectToHal_l(); 1941 } 1942 } 1943 } 1944 1945 static void dumpInOutBuffer( 1946 char *dump, size_t dumpSize, bool isInput, EffectBufferHalInterface *buffer) { 1947 if (buffer == nullptr) { 1948 snprintf(dump, dumpSize, "%p", buffer); 1949 } else if (buffer->externalData() != nullptr) { 1950 snprintf(dump, dumpSize, "%p -> %p", 1951 isInput ? buffer->externalData() : buffer->audioBuffer()->raw, 1952 isInput ? buffer->audioBuffer()->raw : buffer->externalData()); 1953 } else { 1954 snprintf(dump, dumpSize, "%p", buffer->audioBuffer()->raw); 1955 } 1956 } 1957 1958 void AudioFlinger::EffectChain::dump(int fd, const Vector<String16>& args) 1959 { 1960 const size_t SIZE = 256; 1961 char buffer[SIZE]; 1962 String8 result; 1963 1964 size_t numEffects = mEffects.size(); 1965 snprintf(buffer, SIZE, " %zu effects for session %d\n", numEffects, mSessionId); 1966 result.append(buffer); 1967 1968 if (numEffects) { 1969 bool locked = AudioFlinger::dumpTryLock(mLock); 1970 // failed to lock - AudioFlinger is probably deadlocked 1971 if (!locked) { 1972 result.append("\tCould not lock mutex:\n"); 1973 } 1974 1975 char inBufferStr[64], outBufferStr[64]; 1976 dumpInOutBuffer(inBufferStr, sizeof(inBufferStr), true, mInBuffer.get()); 1977 dumpInOutBuffer(outBufferStr, sizeof(outBufferStr), false, mOutBuffer.get()); 1978 snprintf(buffer, SIZE, "\t%-*s%-*s Active tracks:\n", 1979 (int)strlen(inBufferStr), "In buffer ", 1980 (int)strlen(outBufferStr), "Out buffer "); 1981 result.append(buffer); 1982 snprintf(buffer, SIZE, "\t%s %s %d\n", inBufferStr, outBufferStr, mActiveTrackCnt); 1983 result.append(buffer); 1984 write(fd, result.string(), result.size()); 1985 1986 for (size_t i = 0; i < numEffects; ++i) { 1987 sp<EffectModule> effect = mEffects[i]; 1988 if (effect != 0) { 1989 effect->dump(fd, args); 1990 } 1991 } 1992 1993 if (locked) { 1994 mLock.unlock(); 1995 } 1996 } 1997 } 1998 1999 // must be called with ThreadBase::mLock held 2000 void AudioFlinger::EffectChain::setEffectSuspended_l( 2001 const effect_uuid_t *type, bool suspend) 2002 { 2003 sp<SuspendedEffectDesc> desc; 2004 // use effect type UUID timelow as key as there is no real risk of identical 2005 // timeLow fields among effect type UUIDs. 2006 ssize_t index = mSuspendedEffects.indexOfKey(type->timeLow); 2007 if (suspend) { 2008 if (index >= 0) { 2009 desc = mSuspendedEffects.valueAt(index); 2010 } else { 2011 desc = new SuspendedEffectDesc(); 2012 desc->mType = *type; 2013 mSuspendedEffects.add(type->timeLow, desc); 2014 ALOGV("setEffectSuspended_l() add entry for %08x", type->timeLow); 2015 } 2016 if (desc->mRefCount++ == 0) { 2017 sp<EffectModule> effect = getEffectIfEnabled(type); 2018 if (effect != 0) { 2019 desc->mEffect = effect; 2020 effect->setSuspended(true); 2021 effect->setEnabled(false); 2022 } 2023 } 2024 } else { 2025 if (index < 0) { 2026 return; 2027 } 2028 desc = mSuspendedEffects.valueAt(index); 2029 if (desc->mRefCount <= 0) { 2030 ALOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount); 2031 desc->mRefCount = 1; 2032 } 2033 if (--desc->mRefCount == 0) { 2034 ALOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index)); 2035 if (desc->mEffect != 0) { 2036 sp<EffectModule> effect = desc->mEffect.promote(); 2037 if (effect != 0) { 2038 effect->setSuspended(false); 2039 effect->lock(); 2040 EffectHandle *handle = effect->controlHandle_l(); 2041 if (handle != NULL && !handle->disconnected()) { 2042 effect->setEnabled_l(handle->enabled()); 2043 } 2044 effect->unlock(); 2045 } 2046 desc->mEffect.clear(); 2047 } 2048 mSuspendedEffects.removeItemsAt(index); 2049 } 2050 } 2051 } 2052 2053 // must be called with ThreadBase::mLock held 2054 void AudioFlinger::EffectChain::setEffectSuspendedAll_l(bool suspend) 2055 { 2056 sp<SuspendedEffectDesc> desc; 2057 2058 ssize_t index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll); 2059 if (suspend) { 2060 if (index >= 0) { 2061 desc = mSuspendedEffects.valueAt(index); 2062 } else { 2063 desc = new SuspendedEffectDesc(); 2064 mSuspendedEffects.add((int)kKeyForSuspendAll, desc); 2065 ALOGV("setEffectSuspendedAll_l() add entry for 0"); 2066 } 2067 if (desc->mRefCount++ == 0) { 2068 Vector< sp<EffectModule> > effects; 2069 getSuspendEligibleEffects(effects); 2070 for (size_t i = 0; i < effects.size(); i++) { 2071 setEffectSuspended_l(&effects[i]->desc().type, true); 2072 } 2073 } 2074 } else { 2075 if (index < 0) { 2076 return; 2077 } 2078 desc = mSuspendedEffects.valueAt(index); 2079 if (desc->mRefCount <= 0) { 2080 ALOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount); 2081 desc->mRefCount = 1; 2082 } 2083 if (--desc->mRefCount == 0) { 2084 Vector<const effect_uuid_t *> types; 2085 for (size_t i = 0; i < mSuspendedEffects.size(); i++) { 2086 if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) { 2087 continue; 2088 } 2089 types.add(&mSuspendedEffects.valueAt(i)->mType); 2090 } 2091 for (size_t i = 0; i < types.size(); i++) { 2092 setEffectSuspended_l(types[i], false); 2093 } 2094 ALOGV("setEffectSuspendedAll_l() remove entry for %08x", 2095 mSuspendedEffects.keyAt(index)); 2096 mSuspendedEffects.removeItem((int)kKeyForSuspendAll); 2097 } 2098 } 2099 } 2100 2101 2102 // The volume effect is used for automated tests only 2103 #ifndef OPENSL_ES_H_ 2104 static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6, 2105 { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } }; 2106 const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_; 2107 #endif //OPENSL_ES_H_ 2108 2109 bool AudioFlinger::EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc) 2110 { 2111 // auxiliary effects and visualizer are never suspended on output mix 2112 if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) && 2113 (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) || 2114 (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) || 2115 (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0))) { 2116 return false; 2117 } 2118 return true; 2119 } 2120 2121 void AudioFlinger::EffectChain::getSuspendEligibleEffects( 2122 Vector< sp<AudioFlinger::EffectModule> > &effects) 2123 { 2124 effects.clear(); 2125 for (size_t i = 0; i < mEffects.size(); i++) { 2126 if (isEffectEligibleForSuspend(mEffects[i]->desc())) { 2127 effects.add(mEffects[i]); 2128 } 2129 } 2130 } 2131 2132 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectIfEnabled( 2133 const effect_uuid_t *type) 2134 { 2135 sp<EffectModule> effect = getEffectFromType_l(type); 2136 return effect != 0 && effect->isEnabled() ? effect : 0; 2137 } 2138 2139 void AudioFlinger::EffectChain::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 2140 bool enabled) 2141 { 2142 ssize_t index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow); 2143 if (enabled) { 2144 if (index < 0) { 2145 // if the effect is not suspend check if all effects are suspended 2146 index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll); 2147 if (index < 0) { 2148 return; 2149 } 2150 if (!isEffectEligibleForSuspend(effect->desc())) { 2151 return; 2152 } 2153 setEffectSuspended_l(&effect->desc().type, enabled); 2154 index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow); 2155 if (index < 0) { 2156 ALOGW("checkSuspendOnEffectEnabled() Fx should be suspended here!"); 2157 return; 2158 } 2159 } 2160 ALOGV("checkSuspendOnEffectEnabled() enable suspending fx %08x", 2161 effect->desc().type.timeLow); 2162 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index); 2163 // if effect is requested to suspended but was not yet enabled, supend it now. 2164 if (desc->mEffect == 0) { 2165 desc->mEffect = effect; 2166 effect->setEnabled(false); 2167 effect->setSuspended(true); 2168 } 2169 } else { 2170 if (index < 0) { 2171 return; 2172 } 2173 ALOGV("checkSuspendOnEffectEnabled() disable restoring fx %08x", 2174 effect->desc().type.timeLow); 2175 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index); 2176 desc->mEffect.clear(); 2177 effect->setSuspended(false); 2178 } 2179 } 2180 2181 bool AudioFlinger::EffectChain::isNonOffloadableEnabled() 2182 { 2183 Mutex::Autolock _l(mLock); 2184 size_t size = mEffects.size(); 2185 for (size_t i = 0; i < size; i++) { 2186 if (mEffects[i]->isEnabled() && !mEffects[i]->isOffloadable()) { 2187 return true; 2188 } 2189 } 2190 return false; 2191 } 2192 2193 void AudioFlinger::EffectChain::setThread(const sp<ThreadBase>& thread) 2194 { 2195 Mutex::Autolock _l(mLock); 2196 mThread = thread; 2197 for (size_t i = 0; i < mEffects.size(); i++) { 2198 mEffects[i]->setThread(thread); 2199 } 2200 } 2201 2202 void AudioFlinger::EffectChain::checkOutputFlagCompatibility(audio_output_flags_t *flags) const 2203 { 2204 if ((*flags & AUDIO_OUTPUT_FLAG_RAW) != 0 && !isRawCompatible()) { 2205 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_RAW); 2206 } 2207 if ((*flags & AUDIO_OUTPUT_FLAG_FAST) != 0 && !isFastCompatible()) { 2208 *flags = (audio_output_flags_t)(*flags & ~AUDIO_OUTPUT_FLAG_FAST); 2209 } 2210 } 2211 2212 void AudioFlinger::EffectChain::checkInputFlagCompatibility(audio_input_flags_t *flags) const 2213 { 2214 if ((*flags & AUDIO_INPUT_FLAG_RAW) != 0 && !isRawCompatible()) { 2215 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_RAW); 2216 } 2217 if ((*flags & AUDIO_INPUT_FLAG_FAST) != 0 && !isFastCompatible()) { 2218 *flags = (audio_input_flags_t)(*flags & ~AUDIO_INPUT_FLAG_FAST); 2219 } 2220 } 2221 2222 bool AudioFlinger::EffectChain::isRawCompatible() const 2223 { 2224 Mutex::Autolock _l(mLock); 2225 for (const auto &effect : mEffects) { 2226 if (effect->isProcessImplemented()) { 2227 return false; 2228 } 2229 } 2230 // Allow effects without processing. 2231 return true; 2232 } 2233 2234 bool AudioFlinger::EffectChain::isFastCompatible() const 2235 { 2236 Mutex::Autolock _l(mLock); 2237 for (const auto &effect : mEffects) { 2238 if (effect->isProcessImplemented() 2239 && effect->isImplementationSoftware()) { 2240 return false; 2241 } 2242 } 2243 // Allow effects without processing or hw accelerated effects. 2244 return true; 2245 } 2246 2247 // isCompatibleWithThread_l() must be called with thread->mLock held 2248 bool AudioFlinger::EffectChain::isCompatibleWithThread_l(const sp<ThreadBase>& thread) const 2249 { 2250 Mutex::Autolock _l(mLock); 2251 for (size_t i = 0; i < mEffects.size(); i++) { 2252 if (thread->checkEffectCompatibility_l(&(mEffects[i]->desc()), mSessionId) != NO_ERROR) { 2253 return false; 2254 } 2255 } 2256 return true; 2257 } 2258 2259 } // namespace android 2260