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