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