1 /* //device/include/server/AudioFlinger/AudioFlinger.cpp 2 ** 3 ** Copyright 2007, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 19 #define LOG_TAG "AudioFlinger" 20 //#define LOG_NDEBUG 0 21 22 #include <math.h> 23 #include <signal.h> 24 #include <sys/time.h> 25 #include <sys/resource.h> 26 27 #include <binder/IPCThreadState.h> 28 #include <binder/IServiceManager.h> 29 #include <utils/Log.h> 30 #include <binder/Parcel.h> 31 #include <binder/IPCThreadState.h> 32 #include <utils/String16.h> 33 #include <utils/threads.h> 34 #include <utils/Atomic.h> 35 36 #include <cutils/bitops.h> 37 #include <cutils/properties.h> 38 39 #include <media/AudioTrack.h> 40 #include <media/AudioRecord.h> 41 #include <media/IMediaPlayerService.h> 42 43 #include <private/media/AudioTrackShared.h> 44 #include <private/media/AudioEffectShared.h> 45 46 #include <system/audio.h> 47 #include <hardware/audio.h> 48 49 #include "AudioMixer.h" 50 #include "AudioFlinger.h" 51 52 #include <media/EffectsFactoryApi.h> 53 #include <audio_effects/effect_visualizer.h> 54 #include <audio_effects/effect_ns.h> 55 #include <audio_effects/effect_aec.h> 56 57 #include <cpustats/ThreadCpuUsage.h> 58 #include <powermanager/PowerManager.h> 59 // #define DEBUG_CPU_USAGE 10 // log statistics every n wall clock seconds 60 61 // ---------------------------------------------------------------------------- 62 63 64 namespace android { 65 66 static const char* kDeadlockedString = "AudioFlinger may be deadlocked\n"; 67 static const char* kHardwareLockedString = "Hardware lock is taken\n"; 68 69 //static const nsecs_t kStandbyTimeInNsecs = seconds(3); 70 static const float MAX_GAIN = 4096.0f; 71 static const float MAX_GAIN_INT = 0x1000; 72 73 // retry counts for buffer fill timeout 74 // 50 * ~20msecs = 1 second 75 static const int8_t kMaxTrackRetries = 50; 76 static const int8_t kMaxTrackStartupRetries = 50; 77 // allow less retry attempts on direct output thread. 78 // direct outputs can be a scarce resource in audio hardware and should 79 // be released as quickly as possible. 80 static const int8_t kMaxTrackRetriesDirect = 2; 81 82 static const int kDumpLockRetries = 50; 83 static const int kDumpLockSleep = 20000; 84 85 static const nsecs_t kWarningThrottle = seconds(5); 86 87 // RecordThread loop sleep time upon application overrun or audio HAL read error 88 static const int kRecordThreadSleepUs = 5000; 89 90 static const nsecs_t kSetParametersTimeout = seconds(2); 91 92 // minimum sleep time for the mixer thread loop when tracks are active but in underrun 93 static const uint32_t kMinThreadSleepTimeUs = 5000; 94 // maximum divider applied to the active sleep time in the mixer thread loop 95 static const uint32_t kMaxThreadSleepTimeShift = 2; 96 97 98 // ---------------------------------------------------------------------------- 99 100 static bool recordingAllowed() { 101 if (getpid() == IPCThreadState::self()->getCallingPid()) return true; 102 bool ok = checkCallingPermission(String16("android.permission.RECORD_AUDIO")); 103 if (!ok) LOGE("Request requires android.permission.RECORD_AUDIO"); 104 return ok; 105 } 106 107 static bool settingsAllowed() { 108 if (getpid() == IPCThreadState::self()->getCallingPid()) return true; 109 bool ok = checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS")); 110 if (!ok) LOGE("Request requires android.permission.MODIFY_AUDIO_SETTINGS"); 111 return ok; 112 } 113 114 // To collect the amplifier usage 115 static void addBatteryData(uint32_t params) { 116 sp<IBinder> binder = 117 defaultServiceManager()->getService(String16("media.player")); 118 sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder); 119 if (service.get() == NULL) { 120 LOGW("Cannot connect to the MediaPlayerService for battery tracking"); 121 return; 122 } 123 124 service->addBatteryData(params); 125 } 126 127 static int load_audio_interface(const char *if_name, const hw_module_t **mod, 128 audio_hw_device_t **dev) 129 { 130 int rc; 131 132 rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, mod); 133 if (rc) 134 goto out; 135 136 rc = audio_hw_device_open(*mod, dev); 137 LOGE_IF(rc, "couldn't open audio hw device in %s.%s (%s)", 138 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc)); 139 if (rc) 140 goto out; 141 142 return 0; 143 144 out: 145 *mod = NULL; 146 *dev = NULL; 147 return rc; 148 } 149 150 static const char *audio_interfaces[] = { 151 "primary", 152 "a2dp", 153 "usb", 154 }; 155 #define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0]))) 156 157 // ---------------------------------------------------------------------------- 158 159 AudioFlinger::AudioFlinger() 160 : BnAudioFlinger(), 161 mPrimaryHardwareDev(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1), 162 mBtNrecIsOff(false) 163 { 164 } 165 166 void AudioFlinger::onFirstRef() 167 { 168 int rc = 0; 169 170 Mutex::Autolock _l(mLock); 171 172 /* TODO: move all this work into an Init() function */ 173 mHardwareStatus = AUDIO_HW_IDLE; 174 175 for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) { 176 const hw_module_t *mod; 177 audio_hw_device_t *dev; 178 179 rc = load_audio_interface(audio_interfaces[i], &mod, &dev); 180 if (rc) 181 continue; 182 183 LOGI("Loaded %s audio interface from %s (%s)", audio_interfaces[i], 184 mod->name, mod->id); 185 mAudioHwDevs.push(dev); 186 187 if (!mPrimaryHardwareDev) { 188 mPrimaryHardwareDev = dev; 189 LOGI("Using '%s' (%s.%s) as the primary audio interface", 190 mod->name, mod->id, audio_interfaces[i]); 191 } 192 } 193 194 mHardwareStatus = AUDIO_HW_INIT; 195 196 if (!mPrimaryHardwareDev || mAudioHwDevs.size() == 0) { 197 LOGE("Primary audio interface not found"); 198 return; 199 } 200 201 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 202 audio_hw_device_t *dev = mAudioHwDevs[i]; 203 204 mHardwareStatus = AUDIO_HW_INIT; 205 rc = dev->init_check(dev); 206 if (rc == 0) { 207 AutoMutex lock(mHardwareLock); 208 209 mMode = AUDIO_MODE_NORMAL; 210 mHardwareStatus = AUDIO_HW_SET_MODE; 211 dev->set_mode(dev, mMode); 212 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 213 dev->set_master_volume(dev, 1.0f); 214 mHardwareStatus = AUDIO_HW_IDLE; 215 } 216 } 217 } 218 219 status_t AudioFlinger::initCheck() const 220 { 221 Mutex::Autolock _l(mLock); 222 if (mPrimaryHardwareDev == NULL || mAudioHwDevs.size() == 0) 223 return NO_INIT; 224 return NO_ERROR; 225 } 226 227 AudioFlinger::~AudioFlinger() 228 { 229 int num_devs = mAudioHwDevs.size(); 230 231 while (!mRecordThreads.isEmpty()) { 232 // closeInput() will remove first entry from mRecordThreads 233 closeInput(mRecordThreads.keyAt(0)); 234 } 235 while (!mPlaybackThreads.isEmpty()) { 236 // closeOutput() will remove first entry from mPlaybackThreads 237 closeOutput(mPlaybackThreads.keyAt(0)); 238 } 239 240 for (int i = 0; i < num_devs; i++) { 241 audio_hw_device_t *dev = mAudioHwDevs[i]; 242 audio_hw_device_close(dev); 243 } 244 mAudioHwDevs.clear(); 245 } 246 247 audio_hw_device_t* AudioFlinger::findSuitableHwDev_l(uint32_t devices) 248 { 249 /* first matching HW device is returned */ 250 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 251 audio_hw_device_t *dev = mAudioHwDevs[i]; 252 if ((dev->get_supported_devices(dev) & devices) == devices) 253 return dev; 254 } 255 return NULL; 256 } 257 258 status_t AudioFlinger::dumpClients(int fd, const Vector<String16>& args) 259 { 260 const size_t SIZE = 256; 261 char buffer[SIZE]; 262 String8 result; 263 264 result.append("Clients:\n"); 265 for (size_t i = 0; i < mClients.size(); ++i) { 266 wp<Client> wClient = mClients.valueAt(i); 267 if (wClient != 0) { 268 sp<Client> client = wClient.promote(); 269 if (client != 0) { 270 snprintf(buffer, SIZE, " pid: %d\n", client->pid()); 271 result.append(buffer); 272 } 273 } 274 } 275 276 result.append("Global session refs:\n"); 277 result.append(" session pid cnt\n"); 278 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) { 279 AudioSessionRef *r = mAudioSessionRefs[i]; 280 snprintf(buffer, SIZE, " %7d %3d %3d\n", r->sessionid, r->pid, r->cnt); 281 result.append(buffer); 282 } 283 write(fd, result.string(), result.size()); 284 return NO_ERROR; 285 } 286 287 288 status_t AudioFlinger::dumpInternals(int fd, const Vector<String16>& args) 289 { 290 const size_t SIZE = 256; 291 char buffer[SIZE]; 292 String8 result; 293 int hardwareStatus = mHardwareStatus; 294 295 snprintf(buffer, SIZE, "Hardware status: %d\n", hardwareStatus); 296 result.append(buffer); 297 write(fd, result.string(), result.size()); 298 return NO_ERROR; 299 } 300 301 status_t AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args) 302 { 303 const size_t SIZE = 256; 304 char buffer[SIZE]; 305 String8 result; 306 snprintf(buffer, SIZE, "Permission Denial: " 307 "can't dump AudioFlinger from pid=%d, uid=%d\n", 308 IPCThreadState::self()->getCallingPid(), 309 IPCThreadState::self()->getCallingUid()); 310 result.append(buffer); 311 write(fd, result.string(), result.size()); 312 return NO_ERROR; 313 } 314 315 static bool tryLock(Mutex& mutex) 316 { 317 bool locked = false; 318 for (int i = 0; i < kDumpLockRetries; ++i) { 319 if (mutex.tryLock() == NO_ERROR) { 320 locked = true; 321 break; 322 } 323 usleep(kDumpLockSleep); 324 } 325 return locked; 326 } 327 328 status_t AudioFlinger::dump(int fd, const Vector<String16>& args) 329 { 330 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 331 dumpPermissionDenial(fd, args); 332 } else { 333 // get state of hardware lock 334 bool hardwareLocked = tryLock(mHardwareLock); 335 if (!hardwareLocked) { 336 String8 result(kHardwareLockedString); 337 write(fd, result.string(), result.size()); 338 } else { 339 mHardwareLock.unlock(); 340 } 341 342 bool locked = tryLock(mLock); 343 344 // failed to lock - AudioFlinger is probably deadlocked 345 if (!locked) { 346 String8 result(kDeadlockedString); 347 write(fd, result.string(), result.size()); 348 } 349 350 dumpClients(fd, args); 351 dumpInternals(fd, args); 352 353 // dump playback threads 354 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 355 mPlaybackThreads.valueAt(i)->dump(fd, args); 356 } 357 358 // dump record threads 359 for (size_t i = 0; i < mRecordThreads.size(); i++) { 360 mRecordThreads.valueAt(i)->dump(fd, args); 361 } 362 363 // dump all hardware devs 364 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 365 audio_hw_device_t *dev = mAudioHwDevs[i]; 366 dev->dump(dev, fd); 367 } 368 if (locked) mLock.unlock(); 369 } 370 return NO_ERROR; 371 } 372 373 374 // IAudioFlinger interface 375 376 377 sp<IAudioTrack> AudioFlinger::createTrack( 378 pid_t pid, 379 int streamType, 380 uint32_t sampleRate, 381 uint32_t format, 382 uint32_t channelMask, 383 int frameCount, 384 uint32_t flags, 385 const sp<IMemory>& sharedBuffer, 386 int output, 387 int *sessionId, 388 status_t *status) 389 { 390 sp<PlaybackThread::Track> track; 391 sp<TrackHandle> trackHandle; 392 sp<Client> client; 393 wp<Client> wclient; 394 status_t lStatus; 395 int lSessionId; 396 397 if (streamType >= AUDIO_STREAM_CNT) { 398 LOGE("invalid stream type"); 399 lStatus = BAD_VALUE; 400 goto Exit; 401 } 402 403 { 404 Mutex::Autolock _l(mLock); 405 PlaybackThread *thread = checkPlaybackThread_l(output); 406 PlaybackThread *effectThread = NULL; 407 if (thread == NULL) { 408 LOGE("unknown output thread"); 409 lStatus = BAD_VALUE; 410 goto Exit; 411 } 412 413 wclient = mClients.valueFor(pid); 414 415 if (wclient != NULL) { 416 client = wclient.promote(); 417 } else { 418 client = new Client(this, pid); 419 mClients.add(pid, client); 420 } 421 422 LOGV("createTrack() sessionId: %d", (sessionId == NULL) ? -2 : *sessionId); 423 if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) { 424 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 425 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 426 if (mPlaybackThreads.keyAt(i) != output) { 427 // prevent same audio session on different output threads 428 uint32_t sessions = t->hasAudioSession(*sessionId); 429 if (sessions & PlaybackThread::TRACK_SESSION) { 430 lStatus = BAD_VALUE; 431 goto Exit; 432 } 433 // check if an effect with same session ID is waiting for a track to be created 434 if (sessions & PlaybackThread::EFFECT_SESSION) { 435 effectThread = t.get(); 436 } 437 } 438 } 439 lSessionId = *sessionId; 440 } else { 441 // if no audio session id is provided, create one here 442 lSessionId = nextUniqueId(); 443 if (sessionId != NULL) { 444 *sessionId = lSessionId; 445 } 446 } 447 LOGV("createTrack() lSessionId: %d", lSessionId); 448 449 track = thread->createTrack_l(client, streamType, sampleRate, format, 450 channelMask, frameCount, sharedBuffer, lSessionId, &lStatus); 451 452 // move effect chain to this output thread if an effect on same session was waiting 453 // for a track to be created 454 if (lStatus == NO_ERROR && effectThread != NULL) { 455 Mutex::Autolock _dl(thread->mLock); 456 Mutex::Autolock _sl(effectThread->mLock); 457 moveEffectChain_l(lSessionId, effectThread, thread, true); 458 } 459 } 460 if (lStatus == NO_ERROR) { 461 trackHandle = new TrackHandle(track); 462 } else { 463 // remove local strong reference to Client before deleting the Track so that the Client 464 // destructor is called by the TrackBase destructor with mLock held 465 client.clear(); 466 track.clear(); 467 } 468 469 Exit: 470 if(status) { 471 *status = lStatus; 472 } 473 return trackHandle; 474 } 475 476 uint32_t AudioFlinger::sampleRate(int output) const 477 { 478 Mutex::Autolock _l(mLock); 479 PlaybackThread *thread = checkPlaybackThread_l(output); 480 if (thread == NULL) { 481 LOGW("sampleRate() unknown thread %d", output); 482 return 0; 483 } 484 return thread->sampleRate(); 485 } 486 487 int AudioFlinger::channelCount(int output) const 488 { 489 Mutex::Autolock _l(mLock); 490 PlaybackThread *thread = checkPlaybackThread_l(output); 491 if (thread == NULL) { 492 LOGW("channelCount() unknown thread %d", output); 493 return 0; 494 } 495 return thread->channelCount(); 496 } 497 498 uint32_t AudioFlinger::format(int output) const 499 { 500 Mutex::Autolock _l(mLock); 501 PlaybackThread *thread = checkPlaybackThread_l(output); 502 if (thread == NULL) { 503 LOGW("format() unknown thread %d", output); 504 return 0; 505 } 506 return thread->format(); 507 } 508 509 size_t AudioFlinger::frameCount(int output) const 510 { 511 Mutex::Autolock _l(mLock); 512 PlaybackThread *thread = checkPlaybackThread_l(output); 513 if (thread == NULL) { 514 LOGW("frameCount() unknown thread %d", output); 515 return 0; 516 } 517 return thread->frameCount(); 518 } 519 520 uint32_t AudioFlinger::latency(int output) const 521 { 522 Mutex::Autolock _l(mLock); 523 PlaybackThread *thread = checkPlaybackThread_l(output); 524 if (thread == NULL) { 525 LOGW("latency() unknown thread %d", output); 526 return 0; 527 } 528 return thread->latency(); 529 } 530 531 status_t AudioFlinger::setMasterVolume(float value) 532 { 533 status_t ret = initCheck(); 534 if (ret != NO_ERROR) { 535 return ret; 536 } 537 538 // check calling permissions 539 if (!settingsAllowed()) { 540 return PERMISSION_DENIED; 541 } 542 543 // when hw supports master volume, don't scale in sw mixer 544 { // scope for the lock 545 AutoMutex lock(mHardwareLock); 546 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 547 if (mPrimaryHardwareDev->set_master_volume(mPrimaryHardwareDev, value) == NO_ERROR) { 548 value = 1.0f; 549 } 550 mHardwareStatus = AUDIO_HW_IDLE; 551 } 552 553 Mutex::Autolock _l(mLock); 554 mMasterVolume = value; 555 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 556 mPlaybackThreads.valueAt(i)->setMasterVolume(value); 557 558 return NO_ERROR; 559 } 560 561 status_t AudioFlinger::setMode(int mode) 562 { 563 status_t ret = initCheck(); 564 if (ret != NO_ERROR) { 565 return ret; 566 } 567 568 // check calling permissions 569 if (!settingsAllowed()) { 570 return PERMISSION_DENIED; 571 } 572 if ((mode < 0) || (mode >= AUDIO_MODE_CNT)) { 573 LOGW("Illegal value: setMode(%d)", mode); 574 return BAD_VALUE; 575 } 576 577 { // scope for the lock 578 AutoMutex lock(mHardwareLock); 579 mHardwareStatus = AUDIO_HW_SET_MODE; 580 ret = mPrimaryHardwareDev->set_mode(mPrimaryHardwareDev, mode); 581 mHardwareStatus = AUDIO_HW_IDLE; 582 } 583 584 if (NO_ERROR == ret) { 585 Mutex::Autolock _l(mLock); 586 mMode = mode; 587 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 588 mPlaybackThreads.valueAt(i)->setMode(mode); 589 } 590 591 return ret; 592 } 593 594 status_t AudioFlinger::setMicMute(bool state) 595 { 596 status_t ret = initCheck(); 597 if (ret != NO_ERROR) { 598 return ret; 599 } 600 601 // check calling permissions 602 if (!settingsAllowed()) { 603 return PERMISSION_DENIED; 604 } 605 606 AutoMutex lock(mHardwareLock); 607 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE; 608 ret = mPrimaryHardwareDev->set_mic_mute(mPrimaryHardwareDev, state); 609 mHardwareStatus = AUDIO_HW_IDLE; 610 return ret; 611 } 612 613 bool AudioFlinger::getMicMute() const 614 { 615 status_t ret = initCheck(); 616 if (ret != NO_ERROR) { 617 return false; 618 } 619 620 bool state = AUDIO_MODE_INVALID; 621 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE; 622 mPrimaryHardwareDev->get_mic_mute(mPrimaryHardwareDev, &state); 623 mHardwareStatus = AUDIO_HW_IDLE; 624 return state; 625 } 626 627 status_t AudioFlinger::setMasterMute(bool muted) 628 { 629 // check calling permissions 630 if (!settingsAllowed()) { 631 return PERMISSION_DENIED; 632 } 633 634 Mutex::Autolock _l(mLock); 635 mMasterMute = muted; 636 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 637 mPlaybackThreads.valueAt(i)->setMasterMute(muted); 638 639 return NO_ERROR; 640 } 641 642 float AudioFlinger::masterVolume() const 643 { 644 return mMasterVolume; 645 } 646 647 bool AudioFlinger::masterMute() const 648 { 649 return mMasterMute; 650 } 651 652 status_t AudioFlinger::setStreamVolume(int stream, float value, int output) 653 { 654 // check calling permissions 655 if (!settingsAllowed()) { 656 return PERMISSION_DENIED; 657 } 658 659 if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT) { 660 return BAD_VALUE; 661 } 662 663 AutoMutex lock(mLock); 664 PlaybackThread *thread = NULL; 665 if (output) { 666 thread = checkPlaybackThread_l(output); 667 if (thread == NULL) { 668 return BAD_VALUE; 669 } 670 } 671 672 mStreamTypes[stream].volume = value; 673 674 if (thread == NULL) { 675 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) { 676 mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value); 677 } 678 } else { 679 thread->setStreamVolume(stream, value); 680 } 681 682 return NO_ERROR; 683 } 684 685 status_t AudioFlinger::setStreamMute(int stream, bool muted) 686 { 687 // check calling permissions 688 if (!settingsAllowed()) { 689 return PERMISSION_DENIED; 690 } 691 692 if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT || 693 uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) { 694 return BAD_VALUE; 695 } 696 697 AutoMutex lock(mLock); 698 mStreamTypes[stream].mute = muted; 699 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 700 mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted); 701 702 return NO_ERROR; 703 } 704 705 float AudioFlinger::streamVolume(int stream, int output) const 706 { 707 if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT) { 708 return 0.0f; 709 } 710 711 AutoMutex lock(mLock); 712 float volume; 713 if (output) { 714 PlaybackThread *thread = checkPlaybackThread_l(output); 715 if (thread == NULL) { 716 return 0.0f; 717 } 718 volume = thread->streamVolume(stream); 719 } else { 720 volume = mStreamTypes[stream].volume; 721 } 722 723 return volume; 724 } 725 726 bool AudioFlinger::streamMute(int stream) const 727 { 728 if (stream < 0 || stream >= (int)AUDIO_STREAM_CNT) { 729 return true; 730 } 731 732 return mStreamTypes[stream].mute; 733 } 734 735 status_t AudioFlinger::setParameters(int ioHandle, const String8& keyValuePairs) 736 { 737 status_t result; 738 739 LOGV("setParameters(): io %d, keyvalue %s, tid %d, calling tid %d", 740 ioHandle, keyValuePairs.string(), gettid(), IPCThreadState::self()->getCallingPid()); 741 // check calling permissions 742 if (!settingsAllowed()) { 743 return PERMISSION_DENIED; 744 } 745 746 // ioHandle == 0 means the parameters are global to the audio hardware interface 747 if (ioHandle == 0) { 748 AutoMutex lock(mHardwareLock); 749 mHardwareStatus = AUDIO_SET_PARAMETER; 750 status_t final_result = NO_ERROR; 751 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 752 audio_hw_device_t *dev = mAudioHwDevs[i]; 753 result = dev->set_parameters(dev, keyValuePairs.string()); 754 final_result = result ?: final_result; 755 } 756 mHardwareStatus = AUDIO_HW_IDLE; 757 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings 758 AudioParameter param = AudioParameter(keyValuePairs); 759 String8 value; 760 if (param.get(String8(AUDIO_PARAMETER_KEY_BT_NREC), value) == NO_ERROR) { 761 Mutex::Autolock _l(mLock); 762 bool btNrecIsOff = (value == AUDIO_PARAMETER_VALUE_OFF); 763 if (mBtNrecIsOff != btNrecIsOff) { 764 for (size_t i = 0; i < mRecordThreads.size(); i++) { 765 sp<RecordThread> thread = mRecordThreads.valueAt(i); 766 RecordThread::RecordTrack *track = thread->track(); 767 if (track != NULL) { 768 audio_devices_t device = (audio_devices_t)( 769 thread->device() & AUDIO_DEVICE_IN_ALL); 770 bool suspend = audio_is_bluetooth_sco_device(device) && btNrecIsOff; 771 thread->setEffectSuspended(FX_IID_AEC, 772 suspend, 773 track->sessionId()); 774 thread->setEffectSuspended(FX_IID_NS, 775 suspend, 776 track->sessionId()); 777 } 778 } 779 mBtNrecIsOff = btNrecIsOff; 780 } 781 } 782 return final_result; 783 } 784 785 // hold a strong ref on thread in case closeOutput() or closeInput() is called 786 // and the thread is exited once the lock is released 787 sp<ThreadBase> thread; 788 { 789 Mutex::Autolock _l(mLock); 790 thread = checkPlaybackThread_l(ioHandle); 791 if (thread == NULL) { 792 thread = checkRecordThread_l(ioHandle); 793 } else if (thread.get() == primaryPlaybackThread_l()) { 794 // indicate output device change to all input threads for pre processing 795 AudioParameter param = AudioParameter(keyValuePairs); 796 int value; 797 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) { 798 for (size_t i = 0; i < mRecordThreads.size(); i++) { 799 mRecordThreads.valueAt(i)->setParameters(keyValuePairs); 800 } 801 } 802 } 803 } 804 if (thread != NULL) { 805 result = thread->setParameters(keyValuePairs); 806 return result; 807 } 808 return BAD_VALUE; 809 } 810 811 String8 AudioFlinger::getParameters(int ioHandle, const String8& keys) 812 { 813 // LOGV("getParameters() io %d, keys %s, tid %d, calling tid %d", 814 // ioHandle, keys.string(), gettid(), IPCThreadState::self()->getCallingPid()); 815 816 if (ioHandle == 0) { 817 String8 out_s8; 818 819 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 820 audio_hw_device_t *dev = mAudioHwDevs[i]; 821 char *s = dev->get_parameters(dev, keys.string()); 822 out_s8 += String8(s); 823 free(s); 824 } 825 return out_s8; 826 } 827 828 Mutex::Autolock _l(mLock); 829 830 PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle); 831 if (playbackThread != NULL) { 832 return playbackThread->getParameters(keys); 833 } 834 RecordThread *recordThread = checkRecordThread_l(ioHandle); 835 if (recordThread != NULL) { 836 return recordThread->getParameters(keys); 837 } 838 return String8(""); 839 } 840 841 size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) 842 { 843 status_t ret = initCheck(); 844 if (ret != NO_ERROR) { 845 return 0; 846 } 847 848 return mPrimaryHardwareDev->get_input_buffer_size(mPrimaryHardwareDev, sampleRate, format, channelCount); 849 } 850 851 unsigned int AudioFlinger::getInputFramesLost(int ioHandle) 852 { 853 if (ioHandle == 0) { 854 return 0; 855 } 856 857 Mutex::Autolock _l(mLock); 858 859 RecordThread *recordThread = checkRecordThread_l(ioHandle); 860 if (recordThread != NULL) { 861 return recordThread->getInputFramesLost(); 862 } 863 return 0; 864 } 865 866 status_t AudioFlinger::setVoiceVolume(float value) 867 { 868 status_t ret = initCheck(); 869 if (ret != NO_ERROR) { 870 return ret; 871 } 872 873 // check calling permissions 874 if (!settingsAllowed()) { 875 return PERMISSION_DENIED; 876 } 877 878 AutoMutex lock(mHardwareLock); 879 mHardwareStatus = AUDIO_SET_VOICE_VOLUME; 880 ret = mPrimaryHardwareDev->set_voice_volume(mPrimaryHardwareDev, value); 881 mHardwareStatus = AUDIO_HW_IDLE; 882 883 return ret; 884 } 885 886 status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int output) 887 { 888 status_t status; 889 890 Mutex::Autolock _l(mLock); 891 892 PlaybackThread *playbackThread = checkPlaybackThread_l(output); 893 if (playbackThread != NULL) { 894 return playbackThread->getRenderPosition(halFrames, dspFrames); 895 } 896 897 return BAD_VALUE; 898 } 899 900 void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client) 901 { 902 903 Mutex::Autolock _l(mLock); 904 905 int pid = IPCThreadState::self()->getCallingPid(); 906 if (mNotificationClients.indexOfKey(pid) < 0) { 907 sp<NotificationClient> notificationClient = new NotificationClient(this, 908 client, 909 pid); 910 LOGV("registerClient() client %p, pid %d", notificationClient.get(), pid); 911 912 mNotificationClients.add(pid, notificationClient); 913 914 sp<IBinder> binder = client->asBinder(); 915 binder->linkToDeath(notificationClient); 916 917 // the config change is always sent from playback or record threads to avoid deadlock 918 // with AudioSystem::gLock 919 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 920 mPlaybackThreads.valueAt(i)->sendConfigEvent(AudioSystem::OUTPUT_OPENED); 921 } 922 923 for (size_t i = 0; i < mRecordThreads.size(); i++) { 924 mRecordThreads.valueAt(i)->sendConfigEvent(AudioSystem::INPUT_OPENED); 925 } 926 } 927 } 928 929 void AudioFlinger::removeNotificationClient(pid_t pid) 930 { 931 Mutex::Autolock _l(mLock); 932 933 int index = mNotificationClients.indexOfKey(pid); 934 if (index >= 0) { 935 sp <NotificationClient> client = mNotificationClients.valueFor(pid); 936 LOGV("removeNotificationClient() %p, pid %d", client.get(), pid); 937 mNotificationClients.removeItem(pid); 938 } 939 940 LOGV("%d died, releasing its sessions", pid); 941 int num = mAudioSessionRefs.size(); 942 bool removed = false; 943 for (int i = 0; i< num; i++) { 944 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i); 945 LOGV(" pid %d @ %d", ref->pid, i); 946 if (ref->pid == pid) { 947 LOGV(" removing entry for pid %d session %d", pid, ref->sessionid); 948 mAudioSessionRefs.removeAt(i); 949 delete ref; 950 removed = true; 951 i--; 952 num--; 953 } 954 } 955 if (removed) { 956 purgeStaleEffects_l(); 957 } 958 } 959 960 // audioConfigChanged_l() must be called with AudioFlinger::mLock held 961 void AudioFlinger::audioConfigChanged_l(int event, int ioHandle, void *param2) 962 { 963 size_t size = mNotificationClients.size(); 964 for (size_t i = 0; i < size; i++) { 965 mNotificationClients.valueAt(i)->client()->ioConfigChanged(event, ioHandle, param2); 966 } 967 } 968 969 // removeClient_l() must be called with AudioFlinger::mLock held 970 void AudioFlinger::removeClient_l(pid_t pid) 971 { 972 LOGV("removeClient_l() pid %d, tid %d, calling tid %d", pid, gettid(), IPCThreadState::self()->getCallingPid()); 973 mClients.removeItem(pid); 974 } 975 976 977 // ---------------------------------------------------------------------------- 978 979 AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, int id, uint32_t device) 980 : Thread(false), 981 mAudioFlinger(audioFlinger), mSampleRate(0), mFrameCount(0), mChannelCount(0), 982 mFrameSize(1), mFormat(0), mStandby(false), mId(id), mExiting(false), 983 mDevice(device) 984 { 985 mDeathRecipient = new PMDeathRecipient(this); 986 } 987 988 AudioFlinger::ThreadBase::~ThreadBase() 989 { 990 mParamCond.broadcast(); 991 mNewParameters.clear(); 992 // do not lock the mutex in destructor 993 releaseWakeLock_l(); 994 if (mPowerManager != 0) { 995 sp<IBinder> binder = mPowerManager->asBinder(); 996 binder->unlinkToDeath(mDeathRecipient); 997 } 998 } 999 1000 void AudioFlinger::ThreadBase::exit() 1001 { 1002 // keep a strong ref on ourself so that we wont get 1003 // destroyed in the middle of requestExitAndWait() 1004 sp <ThreadBase> strongMe = this; 1005 1006 LOGV("ThreadBase::exit"); 1007 { 1008 AutoMutex lock(&mLock); 1009 mExiting = true; 1010 requestExit(); 1011 mWaitWorkCV.signal(); 1012 } 1013 requestExitAndWait(); 1014 } 1015 1016 uint32_t AudioFlinger::ThreadBase::sampleRate() const 1017 { 1018 return mSampleRate; 1019 } 1020 1021 int AudioFlinger::ThreadBase::channelCount() const 1022 { 1023 return (int)mChannelCount; 1024 } 1025 1026 uint32_t AudioFlinger::ThreadBase::format() const 1027 { 1028 return mFormat; 1029 } 1030 1031 size_t AudioFlinger::ThreadBase::frameCount() const 1032 { 1033 return mFrameCount; 1034 } 1035 1036 status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs) 1037 { 1038 status_t status; 1039 1040 LOGV("ThreadBase::setParameters() %s", keyValuePairs.string()); 1041 Mutex::Autolock _l(mLock); 1042 1043 mNewParameters.add(keyValuePairs); 1044 mWaitWorkCV.signal(); 1045 // wait condition with timeout in case the thread loop has exited 1046 // before the request could be processed 1047 if (mParamCond.waitRelative(mLock, kSetParametersTimeout) == NO_ERROR) { 1048 status = mParamStatus; 1049 mWaitWorkCV.signal(); 1050 } else { 1051 status = TIMED_OUT; 1052 } 1053 return status; 1054 } 1055 1056 void AudioFlinger::ThreadBase::sendConfigEvent(int event, int param) 1057 { 1058 Mutex::Autolock _l(mLock); 1059 sendConfigEvent_l(event, param); 1060 } 1061 1062 // sendConfigEvent_l() must be called with ThreadBase::mLock held 1063 void AudioFlinger::ThreadBase::sendConfigEvent_l(int event, int param) 1064 { 1065 ConfigEvent *configEvent = new ConfigEvent(); 1066 configEvent->mEvent = event; 1067 configEvent->mParam = param; 1068 mConfigEvents.add(configEvent); 1069 LOGV("sendConfigEvent() num events %d event %d, param %d", mConfigEvents.size(), event, param); 1070 mWaitWorkCV.signal(); 1071 } 1072 1073 void AudioFlinger::ThreadBase::processConfigEvents() 1074 { 1075 mLock.lock(); 1076 while(!mConfigEvents.isEmpty()) { 1077 LOGV("processConfigEvents() remaining events %d", mConfigEvents.size()); 1078 ConfigEvent *configEvent = mConfigEvents[0]; 1079 mConfigEvents.removeAt(0); 1080 // release mLock before locking AudioFlinger mLock: lock order is always 1081 // AudioFlinger then ThreadBase to avoid cross deadlock 1082 mLock.unlock(); 1083 mAudioFlinger->mLock.lock(); 1084 audioConfigChanged_l(configEvent->mEvent, configEvent->mParam); 1085 mAudioFlinger->mLock.unlock(); 1086 delete configEvent; 1087 mLock.lock(); 1088 } 1089 mLock.unlock(); 1090 } 1091 1092 status_t AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args) 1093 { 1094 const size_t SIZE = 256; 1095 char buffer[SIZE]; 1096 String8 result; 1097 1098 bool locked = tryLock(mLock); 1099 if (!locked) { 1100 snprintf(buffer, SIZE, "thread %p maybe dead locked\n", this); 1101 write(fd, buffer, strlen(buffer)); 1102 } 1103 1104 snprintf(buffer, SIZE, "standby: %d\n", mStandby); 1105 result.append(buffer); 1106 snprintf(buffer, SIZE, "Sample rate: %d\n", mSampleRate); 1107 result.append(buffer); 1108 snprintf(buffer, SIZE, "Frame count: %d\n", mFrameCount); 1109 result.append(buffer); 1110 snprintf(buffer, SIZE, "Channel Count: %d\n", mChannelCount); 1111 result.append(buffer); 1112 snprintf(buffer, SIZE, "Channel Mask: 0x%08x\n", mChannelMask); 1113 result.append(buffer); 1114 snprintf(buffer, SIZE, "Format: %d\n", mFormat); 1115 result.append(buffer); 1116 snprintf(buffer, SIZE, "Frame size: %d\n", mFrameSize); 1117 result.append(buffer); 1118 1119 snprintf(buffer, SIZE, "\nPending setParameters commands: \n"); 1120 result.append(buffer); 1121 result.append(" Index Command"); 1122 for (size_t i = 0; i < mNewParameters.size(); ++i) { 1123 snprintf(buffer, SIZE, "\n %02d ", i); 1124 result.append(buffer); 1125 result.append(mNewParameters[i]); 1126 } 1127 1128 snprintf(buffer, SIZE, "\n\nPending config events: \n"); 1129 result.append(buffer); 1130 snprintf(buffer, SIZE, " Index event param\n"); 1131 result.append(buffer); 1132 for (size_t i = 0; i < mConfigEvents.size(); i++) { 1133 snprintf(buffer, SIZE, " %02d %02d %d\n", i, mConfigEvents[i]->mEvent, mConfigEvents[i]->mParam); 1134 result.append(buffer); 1135 } 1136 result.append("\n"); 1137 1138 write(fd, result.string(), result.size()); 1139 1140 if (locked) { 1141 mLock.unlock(); 1142 } 1143 return NO_ERROR; 1144 } 1145 1146 status_t AudioFlinger::ThreadBase::dumpEffectChains(int fd, const Vector<String16>& args) 1147 { 1148 const size_t SIZE = 256; 1149 char buffer[SIZE]; 1150 String8 result; 1151 1152 snprintf(buffer, SIZE, "\n- %d Effect Chains:\n", mEffectChains.size()); 1153 write(fd, buffer, strlen(buffer)); 1154 1155 for (size_t i = 0; i < mEffectChains.size(); ++i) { 1156 sp<EffectChain> chain = mEffectChains[i]; 1157 if (chain != 0) { 1158 chain->dump(fd, args); 1159 } 1160 } 1161 return NO_ERROR; 1162 } 1163 1164 void AudioFlinger::ThreadBase::acquireWakeLock() 1165 { 1166 Mutex::Autolock _l(mLock); 1167 acquireWakeLock_l(); 1168 } 1169 1170 void AudioFlinger::ThreadBase::acquireWakeLock_l() 1171 { 1172 if (mPowerManager == 0) { 1173 // use checkService() to avoid blocking if power service is not up yet 1174 sp<IBinder> binder = 1175 defaultServiceManager()->checkService(String16("power")); 1176 if (binder == 0) { 1177 LOGW("Thread %s cannot connect to the power manager service", mName); 1178 } else { 1179 mPowerManager = interface_cast<IPowerManager>(binder); 1180 binder->linkToDeath(mDeathRecipient); 1181 } 1182 } 1183 if (mPowerManager != 0) { 1184 sp<IBinder> binder = new BBinder(); 1185 status_t status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK, 1186 binder, 1187 String16(mName)); 1188 if (status == NO_ERROR) { 1189 mWakeLockToken = binder; 1190 } 1191 LOGV("acquireWakeLock_l() %s status %d", mName, status); 1192 } 1193 } 1194 1195 void AudioFlinger::ThreadBase::releaseWakeLock() 1196 { 1197 Mutex::Autolock _l(mLock); 1198 releaseWakeLock_l(); 1199 } 1200 1201 void AudioFlinger::ThreadBase::releaseWakeLock_l() 1202 { 1203 if (mWakeLockToken != 0) { 1204 LOGV("releaseWakeLock_l() %s", mName); 1205 if (mPowerManager != 0) { 1206 mPowerManager->releaseWakeLock(mWakeLockToken, 0); 1207 } 1208 mWakeLockToken.clear(); 1209 } 1210 } 1211 1212 void AudioFlinger::ThreadBase::clearPowerManager() 1213 { 1214 Mutex::Autolock _l(mLock); 1215 releaseWakeLock_l(); 1216 mPowerManager.clear(); 1217 } 1218 1219 void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who) 1220 { 1221 sp<ThreadBase> thread = mThread.promote(); 1222 if (thread != 0) { 1223 thread->clearPowerManager(); 1224 } 1225 LOGW("power manager service died !!!"); 1226 } 1227 1228 void AudioFlinger::ThreadBase::setEffectSuspended( 1229 const effect_uuid_t *type, bool suspend, int sessionId) 1230 { 1231 Mutex::Autolock _l(mLock); 1232 setEffectSuspended_l(type, suspend, sessionId); 1233 } 1234 1235 void AudioFlinger::ThreadBase::setEffectSuspended_l( 1236 const effect_uuid_t *type, bool suspend, int sessionId) 1237 { 1238 sp<EffectChain> chain; 1239 chain = getEffectChain_l(sessionId); 1240 if (chain != 0) { 1241 if (type != NULL) { 1242 chain->setEffectSuspended_l(type, suspend); 1243 } else { 1244 chain->setEffectSuspendedAll_l(suspend); 1245 } 1246 } 1247 1248 updateSuspendedSessions_l(type, suspend, sessionId); 1249 } 1250 1251 void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain) 1252 { 1253 int index = mSuspendedSessions.indexOfKey(chain->sessionId()); 1254 if (index < 0) { 1255 return; 1256 } 1257 1258 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects = 1259 mSuspendedSessions.editValueAt(index); 1260 1261 for (size_t i = 0; i < sessionEffects.size(); i++) { 1262 sp <SuspendedSessionDesc> desc = sessionEffects.valueAt(i); 1263 for (int j = 0; j < desc->mRefCount; j++) { 1264 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) { 1265 chain->setEffectSuspendedAll_l(true); 1266 } else { 1267 LOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x", 1268 desc->mType.timeLow); 1269 chain->setEffectSuspended_l(&desc->mType, true); 1270 } 1271 } 1272 } 1273 } 1274 1275 void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type, 1276 bool suspend, 1277 int sessionId) 1278 { 1279 int index = mSuspendedSessions.indexOfKey(sessionId); 1280 1281 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects; 1282 1283 if (suspend) { 1284 if (index >= 0) { 1285 sessionEffects = mSuspendedSessions.editValueAt(index); 1286 } else { 1287 mSuspendedSessions.add(sessionId, sessionEffects); 1288 } 1289 } else { 1290 if (index < 0) { 1291 return; 1292 } 1293 sessionEffects = mSuspendedSessions.editValueAt(index); 1294 } 1295 1296 1297 int key = EffectChain::kKeyForSuspendAll; 1298 if (type != NULL) { 1299 key = type->timeLow; 1300 } 1301 index = sessionEffects.indexOfKey(key); 1302 1303 sp <SuspendedSessionDesc> desc; 1304 if (suspend) { 1305 if (index >= 0) { 1306 desc = sessionEffects.valueAt(index); 1307 } else { 1308 desc = new SuspendedSessionDesc(); 1309 if (type != NULL) { 1310 memcpy(&desc->mType, type, sizeof(effect_uuid_t)); 1311 } 1312 sessionEffects.add(key, desc); 1313 LOGV("updateSuspendedSessions_l() suspend adding effect %08x", key); 1314 } 1315 desc->mRefCount++; 1316 } else { 1317 if (index < 0) { 1318 return; 1319 } 1320 desc = sessionEffects.valueAt(index); 1321 if (--desc->mRefCount == 0) { 1322 LOGV("updateSuspendedSessions_l() restore removing effect %08x", key); 1323 sessionEffects.removeItemsAt(index); 1324 if (sessionEffects.isEmpty()) { 1325 LOGV("updateSuspendedSessions_l() restore removing session %d", 1326 sessionId); 1327 mSuspendedSessions.removeItem(sessionId); 1328 } 1329 } 1330 } 1331 if (!sessionEffects.isEmpty()) { 1332 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects); 1333 } 1334 } 1335 1336 void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 1337 bool enabled, 1338 int sessionId) 1339 { 1340 Mutex::Autolock _l(mLock); 1341 checkSuspendOnEffectEnabled_l(effect, enabled, sessionId); 1342 } 1343 1344 void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect, 1345 bool enabled, 1346 int sessionId) 1347 { 1348 if (mType != RECORD) { 1349 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on 1350 // another session. This gives the priority to well behaved effect control panels 1351 // and applications not using global effects. 1352 if (sessionId != AUDIO_SESSION_OUTPUT_MIX) { 1353 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX); 1354 } 1355 } 1356 1357 sp<EffectChain> chain = getEffectChain_l(sessionId); 1358 if (chain != 0) { 1359 chain->checkSuspendOnEffectEnabled(effect, enabled); 1360 } 1361 } 1362 1363 // ---------------------------------------------------------------------------- 1364 1365 AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, 1366 AudioStreamOut* output, 1367 int id, 1368 uint32_t device) 1369 : ThreadBase(audioFlinger, id, device), 1370 mMixBuffer(0), mSuspended(0), mBytesWritten(0), mOutput(output), 1371 mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false) 1372 { 1373 snprintf(mName, kNameLength, "AudioOut_%d", id); 1374 1375 readOutputParameters(); 1376 1377 mMasterVolume = mAudioFlinger->masterVolume(); 1378 mMasterMute = mAudioFlinger->masterMute(); 1379 1380 for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) { 1381 mStreamTypes[stream].volume = mAudioFlinger->streamVolumeInternal(stream); 1382 mStreamTypes[stream].mute = mAudioFlinger->streamMute(stream); 1383 mStreamTypes[stream].valid = true; 1384 } 1385 } 1386 1387 AudioFlinger::PlaybackThread::~PlaybackThread() 1388 { 1389 delete [] mMixBuffer; 1390 } 1391 1392 status_t AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args) 1393 { 1394 dumpInternals(fd, args); 1395 dumpTracks(fd, args); 1396 dumpEffectChains(fd, args); 1397 return NO_ERROR; 1398 } 1399 1400 status_t AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args) 1401 { 1402 const size_t SIZE = 256; 1403 char buffer[SIZE]; 1404 String8 result; 1405 1406 snprintf(buffer, SIZE, "Output thread %p tracks\n", this); 1407 result.append(buffer); 1408 result.append(" Name Clien Typ Fmt Chn mask Session Buf S M F SRate LeftV RighV Serv User Main buf Aux Buf\n"); 1409 for (size_t i = 0; i < mTracks.size(); ++i) { 1410 sp<Track> track = mTracks[i]; 1411 if (track != 0) { 1412 track->dump(buffer, SIZE); 1413 result.append(buffer); 1414 } 1415 } 1416 1417 snprintf(buffer, SIZE, "Output thread %p active tracks\n", this); 1418 result.append(buffer); 1419 result.append(" Name Clien Typ Fmt Chn mask Session Buf S M F SRate LeftV RighV Serv User Main buf Aux Buf\n"); 1420 for (size_t i = 0; i < mActiveTracks.size(); ++i) { 1421 wp<Track> wTrack = mActiveTracks[i]; 1422 if (wTrack != 0) { 1423 sp<Track> track = wTrack.promote(); 1424 if (track != 0) { 1425 track->dump(buffer, SIZE); 1426 result.append(buffer); 1427 } 1428 } 1429 } 1430 write(fd, result.string(), result.size()); 1431 return NO_ERROR; 1432 } 1433 1434 status_t AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args) 1435 { 1436 const size_t SIZE = 256; 1437 char buffer[SIZE]; 1438 String8 result; 1439 1440 snprintf(buffer, SIZE, "\nOutput thread %p internals\n", this); 1441 result.append(buffer); 1442 snprintf(buffer, SIZE, "last write occurred (msecs): %llu\n", ns2ms(systemTime() - mLastWriteTime)); 1443 result.append(buffer); 1444 snprintf(buffer, SIZE, "total writes: %d\n", mNumWrites); 1445 result.append(buffer); 1446 snprintf(buffer, SIZE, "delayed writes: %d\n", mNumDelayedWrites); 1447 result.append(buffer); 1448 snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite); 1449 result.append(buffer); 1450 snprintf(buffer, SIZE, "suspend count: %d\n", mSuspended); 1451 result.append(buffer); 1452 snprintf(buffer, SIZE, "mix buffer : %p\n", mMixBuffer); 1453 result.append(buffer); 1454 write(fd, result.string(), result.size()); 1455 1456 dumpBase(fd, args); 1457 1458 return NO_ERROR; 1459 } 1460 1461 // Thread virtuals 1462 status_t AudioFlinger::PlaybackThread::readyToRun() 1463 { 1464 status_t status = initCheck(); 1465 if (status == NO_ERROR) { 1466 LOGI("AudioFlinger's thread %p ready to run", this); 1467 } else { 1468 LOGE("No working audio driver found."); 1469 } 1470 return status; 1471 } 1472 1473 void AudioFlinger::PlaybackThread::onFirstRef() 1474 { 1475 run(mName, ANDROID_PRIORITY_URGENT_AUDIO); 1476 } 1477 1478 // PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held 1479 sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l( 1480 const sp<AudioFlinger::Client>& client, 1481 int streamType, 1482 uint32_t sampleRate, 1483 uint32_t format, 1484 uint32_t channelMask, 1485 int frameCount, 1486 const sp<IMemory>& sharedBuffer, 1487 int sessionId, 1488 status_t *status) 1489 { 1490 sp<Track> track; 1491 status_t lStatus; 1492 1493 if (mType == DIRECT) { 1494 if ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM) { 1495 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) { 1496 LOGE("createTrack_l() Bad parameter: sampleRate %d format %d, channelMask 0x%08x \"" 1497 "for output %p with format %d", 1498 sampleRate, format, channelMask, mOutput, mFormat); 1499 lStatus = BAD_VALUE; 1500 goto Exit; 1501 } 1502 } 1503 } else { 1504 // Resampler implementation limits input sampling rate to 2 x output sampling rate. 1505 if (sampleRate > mSampleRate*2) { 1506 LOGE("Sample rate out of range: %d mSampleRate %d", sampleRate, mSampleRate); 1507 lStatus = BAD_VALUE; 1508 goto Exit; 1509 } 1510 } 1511 1512 lStatus = initCheck(); 1513 if (lStatus != NO_ERROR) { 1514 LOGE("Audio driver not initialized."); 1515 goto Exit; 1516 } 1517 1518 { // scope for mLock 1519 Mutex::Autolock _l(mLock); 1520 1521 // all tracks in same audio session must share the same routing strategy otherwise 1522 // conflicts will happen when tracks are moved from one output to another by audio policy 1523 // manager 1524 uint32_t strategy = 1525 AudioSystem::getStrategyForStream((audio_stream_type_t)streamType); 1526 for (size_t i = 0; i < mTracks.size(); ++i) { 1527 sp<Track> t = mTracks[i]; 1528 if (t != 0) { 1529 if (sessionId == t->sessionId() && 1530 strategy != AudioSystem::getStrategyForStream((audio_stream_type_t)t->type())) { 1531 lStatus = BAD_VALUE; 1532 goto Exit; 1533 } 1534 } 1535 } 1536 1537 track = new Track(this, client, streamType, sampleRate, format, 1538 channelMask, frameCount, sharedBuffer, sessionId); 1539 if (track->getCblk() == NULL || track->name() < 0) { 1540 lStatus = NO_MEMORY; 1541 goto Exit; 1542 } 1543 mTracks.add(track); 1544 1545 sp<EffectChain> chain = getEffectChain_l(sessionId); 1546 if (chain != 0) { 1547 LOGV("createTrack_l() setting main buffer %p", chain->inBuffer()); 1548 track->setMainBuffer(chain->inBuffer()); 1549 chain->setStrategy(AudioSystem::getStrategyForStream((audio_stream_type_t)track->type())); 1550 chain->incTrackCnt(); 1551 } 1552 1553 // invalidate track immediately if the stream type was moved to another thread since 1554 // createTrack() was called by the client process. 1555 if (!mStreamTypes[streamType].valid) { 1556 LOGW("createTrack_l() on thread %p: invalidating track on stream %d", 1557 this, streamType); 1558 android_atomic_or(CBLK_INVALID_ON, &track->mCblk->flags); 1559 } 1560 } 1561 lStatus = NO_ERROR; 1562 1563 Exit: 1564 if(status) { 1565 *status = lStatus; 1566 } 1567 return track; 1568 } 1569 1570 uint32_t AudioFlinger::PlaybackThread::latency() const 1571 { 1572 Mutex::Autolock _l(mLock); 1573 if (initCheck() == NO_ERROR) { 1574 return mOutput->stream->get_latency(mOutput->stream); 1575 } else { 1576 return 0; 1577 } 1578 } 1579 1580 status_t AudioFlinger::PlaybackThread::setMasterVolume(float value) 1581 { 1582 mMasterVolume = value; 1583 return NO_ERROR; 1584 } 1585 1586 status_t AudioFlinger::PlaybackThread::setMasterMute(bool muted) 1587 { 1588 mMasterMute = muted; 1589 return NO_ERROR; 1590 } 1591 1592 float AudioFlinger::PlaybackThread::masterVolume() const 1593 { 1594 return mMasterVolume; 1595 } 1596 1597 bool AudioFlinger::PlaybackThread::masterMute() const 1598 { 1599 return mMasterMute; 1600 } 1601 1602 status_t AudioFlinger::PlaybackThread::setStreamVolume(int stream, float value) 1603 { 1604 mStreamTypes[stream].volume = value; 1605 return NO_ERROR; 1606 } 1607 1608 status_t AudioFlinger::PlaybackThread::setStreamMute(int stream, bool muted) 1609 { 1610 mStreamTypes[stream].mute = muted; 1611 return NO_ERROR; 1612 } 1613 1614 float AudioFlinger::PlaybackThread::streamVolume(int stream) const 1615 { 1616 return mStreamTypes[stream].volume; 1617 } 1618 1619 bool AudioFlinger::PlaybackThread::streamMute(int stream) const 1620 { 1621 return mStreamTypes[stream].mute; 1622 } 1623 1624 // addTrack_l() must be called with ThreadBase::mLock held 1625 status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track) 1626 { 1627 status_t status = ALREADY_EXISTS; 1628 1629 // set retry count for buffer fill 1630 track->mRetryCount = kMaxTrackStartupRetries; 1631 if (mActiveTracks.indexOf(track) < 0) { 1632 // the track is newly added, make sure it fills up all its 1633 // buffers before playing. This is to ensure the client will 1634 // effectively get the latency it requested. 1635 track->mFillingUpStatus = Track::FS_FILLING; 1636 track->mResetDone = false; 1637 mActiveTracks.add(track); 1638 if (track->mainBuffer() != mMixBuffer) { 1639 sp<EffectChain> chain = getEffectChain_l(track->sessionId()); 1640 if (chain != 0) { 1641 LOGV("addTrack_l() starting track on chain %p for session %d", chain.get(), track->sessionId()); 1642 chain->incActiveTrackCnt(); 1643 } 1644 } 1645 1646 status = NO_ERROR; 1647 } 1648 1649 LOGV("mWaitWorkCV.broadcast"); 1650 mWaitWorkCV.broadcast(); 1651 1652 return status; 1653 } 1654 1655 // destroyTrack_l() must be called with ThreadBase::mLock held 1656 void AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track) 1657 { 1658 track->mState = TrackBase::TERMINATED; 1659 if (mActiveTracks.indexOf(track) < 0) { 1660 removeTrack_l(track); 1661 } 1662 } 1663 1664 void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track) 1665 { 1666 mTracks.remove(track); 1667 deleteTrackName_l(track->name()); 1668 sp<EffectChain> chain = getEffectChain_l(track->sessionId()); 1669 if (chain != 0) { 1670 chain->decTrackCnt(); 1671 } 1672 } 1673 1674 String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys) 1675 { 1676 String8 out_s8 = String8(""); 1677 char *s; 1678 1679 Mutex::Autolock _l(mLock); 1680 if (initCheck() != NO_ERROR) { 1681 return out_s8; 1682 } 1683 1684 s = mOutput->stream->common.get_parameters(&mOutput->stream->common, keys.string()); 1685 out_s8 = String8(s); 1686 free(s); 1687 return out_s8; 1688 } 1689 1690 // audioConfigChanged_l() must be called with AudioFlinger::mLock held 1691 void AudioFlinger::PlaybackThread::audioConfigChanged_l(int event, int param) { 1692 AudioSystem::OutputDescriptor desc; 1693 void *param2 = 0; 1694 1695 LOGV("PlaybackThread::audioConfigChanged_l, thread %p, event %d, param %d", this, event, param); 1696 1697 switch (event) { 1698 case AudioSystem::OUTPUT_OPENED: 1699 case AudioSystem::OUTPUT_CONFIG_CHANGED: 1700 desc.channels = mChannelMask; 1701 desc.samplingRate = mSampleRate; 1702 desc.format = mFormat; 1703 desc.frameCount = mFrameCount; 1704 desc.latency = latency(); 1705 param2 = &desc; 1706 break; 1707 1708 case AudioSystem::STREAM_CONFIG_CHANGED: 1709 param2 = ¶m; 1710 case AudioSystem::OUTPUT_CLOSED: 1711 default: 1712 break; 1713 } 1714 mAudioFlinger->audioConfigChanged_l(event, mId, param2); 1715 } 1716 1717 void AudioFlinger::PlaybackThread::readOutputParameters() 1718 { 1719 mSampleRate = mOutput->stream->common.get_sample_rate(&mOutput->stream->common); 1720 mChannelMask = mOutput->stream->common.get_channels(&mOutput->stream->common); 1721 mChannelCount = (uint16_t)popcount(mChannelMask); 1722 mFormat = mOutput->stream->common.get_format(&mOutput->stream->common); 1723 mFrameSize = (uint16_t)audio_stream_frame_size(&mOutput->stream->common); 1724 mFrameCount = mOutput->stream->common.get_buffer_size(&mOutput->stream->common) / mFrameSize; 1725 1726 // FIXME - Current mixer implementation only supports stereo output: Always 1727 // Allocate a stereo buffer even if HW output is mono. 1728 if (mMixBuffer != NULL) delete[] mMixBuffer; 1729 mMixBuffer = new int16_t[mFrameCount * 2]; 1730 memset(mMixBuffer, 0, mFrameCount * 2 * sizeof(int16_t)); 1731 1732 // force reconfiguration of effect chains and engines to take new buffer size and audio 1733 // parameters into account 1734 // Note that mLock is not held when readOutputParameters() is called from the constructor 1735 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't 1736 // matter. 1737 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains 1738 Vector< sp<EffectChain> > effectChains = mEffectChains; 1739 for (size_t i = 0; i < effectChains.size(); i ++) { 1740 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(), this, this, false); 1741 } 1742 } 1743 1744 status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames) 1745 { 1746 if (halFrames == 0 || dspFrames == 0) { 1747 return BAD_VALUE; 1748 } 1749 Mutex::Autolock _l(mLock); 1750 if (initCheck() != NO_ERROR) { 1751 return INVALID_OPERATION; 1752 } 1753 *halFrames = mBytesWritten / audio_stream_frame_size(&mOutput->stream->common); 1754 1755 return mOutput->stream->get_render_position(mOutput->stream, dspFrames); 1756 } 1757 1758 uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId) 1759 { 1760 Mutex::Autolock _l(mLock); 1761 uint32_t result = 0; 1762 if (getEffectChain_l(sessionId) != 0) { 1763 result = EFFECT_SESSION; 1764 } 1765 1766 for (size_t i = 0; i < mTracks.size(); ++i) { 1767 sp<Track> track = mTracks[i]; 1768 if (sessionId == track->sessionId() && 1769 !(track->mCblk->flags & CBLK_INVALID_MSK)) { 1770 result |= TRACK_SESSION; 1771 break; 1772 } 1773 } 1774 1775 return result; 1776 } 1777 1778 uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(int sessionId) 1779 { 1780 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that 1781 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected 1782 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) { 1783 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); 1784 } 1785 for (size_t i = 0; i < mTracks.size(); i++) { 1786 sp<Track> track = mTracks[i]; 1787 if (sessionId == track->sessionId() && 1788 !(track->mCblk->flags & CBLK_INVALID_MSK)) { 1789 return AudioSystem::getStrategyForStream((audio_stream_type_t) track->type()); 1790 } 1791 } 1792 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); 1793 } 1794 1795 1796 AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() 1797 { 1798 Mutex::Autolock _l(mLock); 1799 return mOutput; 1800 } 1801 1802 AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput() 1803 { 1804 Mutex::Autolock _l(mLock); 1805 AudioStreamOut *output = mOutput; 1806 mOutput = NULL; 1807 return output; 1808 } 1809 1810 // this method must always be called either with ThreadBase mLock held or inside the thread loop 1811 audio_stream_t* AudioFlinger::PlaybackThread::stream() 1812 { 1813 if (mOutput == NULL) { 1814 return NULL; 1815 } 1816 return &mOutput->stream->common; 1817 } 1818 1819 uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() 1820 { 1821 // A2DP output latency is not due only to buffering capacity. It also reflects encoding, 1822 // decoding and transfer time. So sleeping for half of the latency would likely cause 1823 // underruns 1824 if (audio_is_a2dp_device((audio_devices_t)mDevice)) { 1825 return (uint32_t)((uint32_t)((mFrameCount * 1000) / mSampleRate) * 1000); 1826 } else { 1827 return (uint32_t)(mOutput->stream->get_latency(mOutput->stream) * 1000) / 2; 1828 } 1829 } 1830 1831 // ---------------------------------------------------------------------------- 1832 1833 AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device) 1834 : PlaybackThread(audioFlinger, output, id, device), 1835 mAudioMixer(0), mPrevMixerStatus(MIXER_IDLE) 1836 { 1837 mType = ThreadBase::MIXER; 1838 mAudioMixer = new AudioMixer(mFrameCount, mSampleRate); 1839 1840 // FIXME - Current mixer implementation only supports stereo output 1841 if (mChannelCount == 1) { 1842 LOGE("Invalid audio hardware channel count"); 1843 } 1844 } 1845 1846 AudioFlinger::MixerThread::~MixerThread() 1847 { 1848 delete mAudioMixer; 1849 } 1850 1851 bool AudioFlinger::MixerThread::threadLoop() 1852 { 1853 Vector< sp<Track> > tracksToRemove; 1854 uint32_t mixerStatus = MIXER_IDLE; 1855 nsecs_t standbyTime = systemTime(); 1856 size_t mixBufferSize = mFrameCount * mFrameSize; 1857 // FIXME: Relaxed timing because of a certain device that can't meet latency 1858 // Should be reduced to 2x after the vendor fixes the driver issue 1859 // increase threshold again due to low power audio mode. The way this warning threshold is 1860 // calculated and its usefulness should be reconsidered anyway. 1861 nsecs_t maxPeriod = seconds(mFrameCount) / mSampleRate * 15; 1862 nsecs_t lastWarning = 0; 1863 bool longStandbyExit = false; 1864 uint32_t activeSleepTime = activeSleepTimeUs(); 1865 uint32_t idleSleepTime = idleSleepTimeUs(); 1866 uint32_t sleepTime = idleSleepTime; 1867 uint32_t sleepTimeShift = 0; 1868 Vector< sp<EffectChain> > effectChains; 1869 #ifdef DEBUG_CPU_USAGE 1870 ThreadCpuUsage cpu; 1871 const CentralTendencyStatistics& stats = cpu.statistics(); 1872 #endif 1873 1874 acquireWakeLock(); 1875 1876 while (!exitPending()) 1877 { 1878 #ifdef DEBUG_CPU_USAGE 1879 cpu.sampleAndEnable(); 1880 unsigned n = stats.n(); 1881 // cpu.elapsed() is expensive, so don't call it every loop 1882 if ((n & 127) == 1) { 1883 long long elapsed = cpu.elapsed(); 1884 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) { 1885 double perLoop = elapsed / (double) n; 1886 double perLoop100 = perLoop * 0.01; 1887 double mean = stats.mean(); 1888 double stddev = stats.stddev(); 1889 double minimum = stats.minimum(); 1890 double maximum = stats.maximum(); 1891 cpu.resetStatistics(); 1892 LOGI("CPU usage over past %.1f secs (%u mixer loops at %.1f mean ms per loop):\n us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f", 1893 elapsed * .000000001, n, perLoop * .000001, 1894 mean * .001, 1895 stddev * .001, 1896 minimum * .001, 1897 maximum * .001, 1898 mean / perLoop100, 1899 stddev / perLoop100, 1900 minimum / perLoop100, 1901 maximum / perLoop100); 1902 } 1903 } 1904 #endif 1905 processConfigEvents(); 1906 1907 mixerStatus = MIXER_IDLE; 1908 { // scope for mLock 1909 1910 Mutex::Autolock _l(mLock); 1911 1912 if (checkForNewParameters_l()) { 1913 mixBufferSize = mFrameCount * mFrameSize; 1914 // FIXME: Relaxed timing because of a certain device that can't meet latency 1915 // Should be reduced to 2x after the vendor fixes the driver issue 1916 // increase threshold again due to low power audio mode. The way this warning 1917 // threshold is calculated and its usefulness should be reconsidered anyway. 1918 maxPeriod = seconds(mFrameCount) / mSampleRate * 15; 1919 activeSleepTime = activeSleepTimeUs(); 1920 idleSleepTime = idleSleepTimeUs(); 1921 } 1922 1923 const SortedVector< wp<Track> >& activeTracks = mActiveTracks; 1924 1925 // put audio hardware into standby after short delay 1926 if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) || 1927 mSuspended) { 1928 if (!mStandby) { 1929 LOGV("Audio hardware entering standby, mixer %p, mSuspended %d\n", this, mSuspended); 1930 mOutput->stream->common.standby(&mOutput->stream->common); 1931 mStandby = true; 1932 mBytesWritten = 0; 1933 } 1934 1935 if (!activeTracks.size() && mConfigEvents.isEmpty()) { 1936 // we're about to wait, flush the binder command buffer 1937 IPCThreadState::self()->flushCommands(); 1938 1939 if (exitPending()) break; 1940 1941 releaseWakeLock_l(); 1942 // wait until we have something to do... 1943 LOGV("MixerThread %p TID %d going to sleep\n", this, gettid()); 1944 mWaitWorkCV.wait(mLock); 1945 LOGV("MixerThread %p TID %d waking up\n", this, gettid()); 1946 acquireWakeLock_l(); 1947 1948 mPrevMixerStatus = MIXER_IDLE; 1949 if (mMasterMute == false) { 1950 char value[PROPERTY_VALUE_MAX]; 1951 property_get("ro.audio.silent", value, "0"); 1952 if (atoi(value)) { 1953 LOGD("Silence is golden"); 1954 setMasterMute(true); 1955 } 1956 } 1957 1958 standbyTime = systemTime() + kStandbyTimeInNsecs; 1959 sleepTime = idleSleepTime; 1960 sleepTimeShift = 0; 1961 continue; 1962 } 1963 } 1964 1965 mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove); 1966 1967 // prevent any changes in effect chain list and in each effect chain 1968 // during mixing and effect process as the audio buffers could be deleted 1969 // or modified if an effect is created or deleted 1970 lockEffectChains_l(effectChains); 1971 } 1972 1973 if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { 1974 // mix buffers... 1975 mAudioMixer->process(); 1976 // increase sleep time progressively when application underrun condition clears. 1977 // Only increase sleep time if the mixer is ready for two consecutive times to avoid 1978 // that a steady state of alternating ready/not ready conditions keeps the sleep time 1979 // such that we would underrun the audio HAL. 1980 if ((sleepTime == 0) && (sleepTimeShift > 0)) { 1981 sleepTimeShift--; 1982 } 1983 sleepTime = 0; 1984 standbyTime = systemTime() + kStandbyTimeInNsecs; 1985 //TODO: delay standby when effects have a tail 1986 } else { 1987 // If no tracks are ready, sleep once for the duration of an output 1988 // buffer size, then write 0s to the output 1989 if (sleepTime == 0) { 1990 if (mixerStatus == MIXER_TRACKS_ENABLED) { 1991 sleepTime = activeSleepTime >> sleepTimeShift; 1992 if (sleepTime < kMinThreadSleepTimeUs) { 1993 sleepTime = kMinThreadSleepTimeUs; 1994 } 1995 // reduce sleep time in case of consecutive application underruns to avoid 1996 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer 1997 // duration we would end up writing less data than needed by the audio HAL if 1998 // the condition persists. 1999 if (sleepTimeShift < kMaxThreadSleepTimeShift) { 2000 sleepTimeShift++; 2001 } 2002 } else { 2003 sleepTime = idleSleepTime; 2004 } 2005 } else if (mBytesWritten != 0 || 2006 (mixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)) { 2007 memset (mMixBuffer, 0, mixBufferSize); 2008 sleepTime = 0; 2009 LOGV_IF((mBytesWritten == 0 && (mixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)), "anticipated start"); 2010 } 2011 // TODO add standby time extension fct of effect tail 2012 } 2013 2014 if (mSuspended) { 2015 sleepTime = suspendSleepTimeUs(); 2016 } 2017 // sleepTime == 0 means we must write to audio hardware 2018 if (sleepTime == 0) { 2019 for (size_t i = 0; i < effectChains.size(); i ++) { 2020 effectChains[i]->process_l(); 2021 } 2022 // enable changes in effect chain 2023 unlockEffectChains(effectChains); 2024 mLastWriteTime = systemTime(); 2025 mInWrite = true; 2026 mBytesWritten += mixBufferSize; 2027 2028 int bytesWritten = (int)mOutput->stream->write(mOutput->stream, mMixBuffer, mixBufferSize); 2029 if (bytesWritten < 0) mBytesWritten -= mixBufferSize; 2030 mNumWrites++; 2031 mInWrite = false; 2032 nsecs_t now = systemTime(); 2033 nsecs_t delta = now - mLastWriteTime; 2034 if (!mStandby && delta > maxPeriod) { 2035 mNumDelayedWrites++; 2036 if ((now - lastWarning) > kWarningThrottle) { 2037 LOGW("write blocked for %llu msecs, %d delayed writes, thread %p", 2038 ns2ms(delta), mNumDelayedWrites, this); 2039 lastWarning = now; 2040 } 2041 if (mStandby) { 2042 longStandbyExit = true; 2043 } 2044 } 2045 mStandby = false; 2046 } else { 2047 // enable changes in effect chain 2048 unlockEffectChains(effectChains); 2049 usleep(sleepTime); 2050 } 2051 2052 // finally let go of all our tracks, without the lock held 2053 // since we can't guarantee the destructors won't acquire that 2054 // same lock. 2055 tracksToRemove.clear(); 2056 2057 // Effect chains will be actually deleted here if they were removed from 2058 // mEffectChains list during mixing or effects processing 2059 effectChains.clear(); 2060 } 2061 2062 if (!mStandby) { 2063 mOutput->stream->common.standby(&mOutput->stream->common); 2064 } 2065 2066 releaseWakeLock(); 2067 2068 LOGV("MixerThread %p exiting", this); 2069 return false; 2070 } 2071 2072 // prepareTracks_l() must be called with ThreadBase::mLock held 2073 uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp<Track> >& activeTracks, Vector< sp<Track> > *tracksToRemove) 2074 { 2075 2076 uint32_t mixerStatus = MIXER_IDLE; 2077 // find out which tracks need to be processed 2078 size_t count = activeTracks.size(); 2079 size_t mixedTracks = 0; 2080 size_t tracksWithEffect = 0; 2081 2082 float masterVolume = mMasterVolume; 2083 bool masterMute = mMasterMute; 2084 2085 if (masterMute) { 2086 masterVolume = 0; 2087 } 2088 // Delegate master volume control to effect in output mix effect chain if needed 2089 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); 2090 if (chain != 0) { 2091 uint32_t v = (uint32_t)(masterVolume * (1 << 24)); 2092 chain->setVolume_l(&v, &v); 2093 masterVolume = (float)((v + (1 << 23)) >> 24); 2094 chain.clear(); 2095 } 2096 2097 for (size_t i=0 ; i<count ; i++) { 2098 sp<Track> t = activeTracks[i].promote(); 2099 if (t == 0) continue; 2100 2101 Track* const track = t.get(); 2102 audio_track_cblk_t* cblk = track->cblk(); 2103 2104 // The first time a track is added we wait 2105 // for all its buffers to be filled before processing it 2106 mAudioMixer->setActiveTrack(track->name()); 2107 // make sure that we have enough frames to mix one full buffer. 2108 // enforce this condition only once to enable draining the buffer in case the client 2109 // app does not call stop() and relies on underrun to stop: 2110 // hence the test on (mPrevMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed 2111 // during last round 2112 uint32_t minFrames = 1; 2113 if (!track->isStopped() && !track->isPausing() && 2114 (mPrevMixerStatus == MIXER_TRACKS_READY)) { 2115 if (t->sampleRate() == (int)mSampleRate) { 2116 minFrames = mFrameCount; 2117 } else { 2118 // +1 for rounding and +1 for additional sample needed for interpolation 2119 minFrames = (mFrameCount * t->sampleRate()) / mSampleRate + 1 + 1; 2120 // add frames already consumed but not yet released by the resampler 2121 // because cblk->framesReady() will include these frames 2122 minFrames += mAudioMixer->getUnreleasedFrames(track->name()); 2123 // the minimum track buffer size is normally twice the number of frames necessary 2124 // to fill one buffer and the resampler should not leave more than one buffer worth 2125 // of unreleased frames after each pass, but just in case... 2126 LOG_ASSERT(minFrames <= cblk->frameCount); 2127 } 2128 } 2129 if ((cblk->framesReady() >= minFrames) && track->isReady() && 2130 !track->isPaused() && !track->isTerminated()) 2131 { 2132 //LOGV("track %d u=%08x, s=%08x [OK] on thread %p", track->name(), cblk->user, cblk->server, this); 2133 2134 mixedTracks++; 2135 2136 // track->mainBuffer() != mMixBuffer means there is an effect chain 2137 // connected to the track 2138 chain.clear(); 2139 if (track->mainBuffer() != mMixBuffer) { 2140 chain = getEffectChain_l(track->sessionId()); 2141 // Delegate volume control to effect in track effect chain if needed 2142 if (chain != 0) { 2143 tracksWithEffect++; 2144 } else { 2145 LOGW("prepareTracks_l(): track %08x attached to effect but no chain found on session %d", 2146 track->name(), track->sessionId()); 2147 } 2148 } 2149 2150 2151 int param = AudioMixer::VOLUME; 2152 if (track->mFillingUpStatus == Track::FS_FILLED) { 2153 // no ramp for the first volume setting 2154 track->mFillingUpStatus = Track::FS_ACTIVE; 2155 if (track->mState == TrackBase::RESUMING) { 2156 track->mState = TrackBase::ACTIVE; 2157 param = AudioMixer::RAMP_VOLUME; 2158 } 2159 mAudioMixer->setParameter(AudioMixer::RESAMPLE, AudioMixer::RESET, NULL); 2160 } else if (cblk->server != 0) { 2161 // If the track is stopped before the first frame was mixed, 2162 // do not apply ramp 2163 param = AudioMixer::RAMP_VOLUME; 2164 } 2165 2166 // compute volume for this track 2167 uint32_t vl, vr, va; 2168 if (track->isMuted() || track->isPausing() || 2169 mStreamTypes[track->type()].mute) { 2170 vl = vr = va = 0; 2171 if (track->isPausing()) { 2172 track->setPaused(); 2173 } 2174 } else { 2175 2176 // read original volumes with volume control 2177 float typeVolume = mStreamTypes[track->type()].volume; 2178 float v = masterVolume * typeVolume; 2179 vl = (uint32_t)(v * cblk->volume[0]) << 12; 2180 vr = (uint32_t)(v * cblk->volume[1]) << 12; 2181 2182 va = (uint32_t)(v * cblk->sendLevel); 2183 } 2184 // Delegate volume control to effect in track effect chain if needed 2185 if (chain != 0 && chain->setVolume_l(&vl, &vr)) { 2186 // Do not ramp volume if volume is controlled by effect 2187 param = AudioMixer::VOLUME; 2188 track->mHasVolumeController = true; 2189 } else { 2190 // force no volume ramp when volume controller was just disabled or removed 2191 // from effect chain to avoid volume spike 2192 if (track->mHasVolumeController) { 2193 param = AudioMixer::VOLUME; 2194 } 2195 track->mHasVolumeController = false; 2196 } 2197 2198 // Convert volumes from 8.24 to 4.12 format 2199 int16_t left, right, aux; 2200 uint32_t v_clamped = (vl + (1 << 11)) >> 12; 2201 if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT; 2202 left = int16_t(v_clamped); 2203 v_clamped = (vr + (1 << 11)) >> 12; 2204 if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT; 2205 right = int16_t(v_clamped); 2206 2207 if (va > MAX_GAIN_INT) va = MAX_GAIN_INT; 2208 aux = int16_t(va); 2209 2210 // XXX: these things DON'T need to be done each time 2211 mAudioMixer->setBufferProvider(track); 2212 mAudioMixer->enable(AudioMixer::MIXING); 2213 2214 mAudioMixer->setParameter(param, AudioMixer::VOLUME0, (void *)left); 2215 mAudioMixer->setParameter(param, AudioMixer::VOLUME1, (void *)right); 2216 mAudioMixer->setParameter(param, AudioMixer::AUXLEVEL, (void *)aux); 2217 mAudioMixer->setParameter( 2218 AudioMixer::TRACK, 2219 AudioMixer::FORMAT, (void *)track->format()); 2220 mAudioMixer->setParameter( 2221 AudioMixer::TRACK, 2222 AudioMixer::CHANNEL_MASK, (void *)track->channelMask()); 2223 mAudioMixer->setParameter( 2224 AudioMixer::RESAMPLE, 2225 AudioMixer::SAMPLE_RATE, 2226 (void *)(cblk->sampleRate)); 2227 mAudioMixer->setParameter( 2228 AudioMixer::TRACK, 2229 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer()); 2230 mAudioMixer->setParameter( 2231 AudioMixer::TRACK, 2232 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer()); 2233 2234 // reset retry count 2235 track->mRetryCount = kMaxTrackRetries; 2236 // If one track is ready, set the mixer ready if: 2237 // - the mixer was not ready during previous round OR 2238 // - no other track is not ready 2239 if (mPrevMixerStatus != MIXER_TRACKS_READY || 2240 mixerStatus != MIXER_TRACKS_ENABLED) { 2241 mixerStatus = MIXER_TRACKS_READY; 2242 } 2243 } else { 2244 //LOGV("track %d u=%08x, s=%08x [NOT READY] on thread %p", track->name(), cblk->user, cblk->server, this); 2245 if (track->isStopped()) { 2246 track->reset(); 2247 } 2248 if (track->isTerminated() || track->isStopped() || track->isPaused()) { 2249 // We have consumed all the buffers of this track. 2250 // Remove it from the list of active tracks. 2251 tracksToRemove->add(track); 2252 } else { 2253 // No buffers for this track. Give it a few chances to 2254 // fill a buffer, then remove it from active list. 2255 if (--(track->mRetryCount) <= 0) { 2256 LOGV("BUFFER TIMEOUT: remove(%d) from active list on thread %p", track->name(), this); 2257 tracksToRemove->add(track); 2258 // indicate to client process that the track was disabled because of underrun 2259 android_atomic_or(CBLK_DISABLED_ON, &cblk->flags); 2260 // If one track is not ready, mark the mixer also not ready if: 2261 // - the mixer was ready during previous round OR 2262 // - no other track is ready 2263 } else if (mPrevMixerStatus == MIXER_TRACKS_READY || 2264 mixerStatus != MIXER_TRACKS_READY) { 2265 mixerStatus = MIXER_TRACKS_ENABLED; 2266 } 2267 } 2268 mAudioMixer->disable(AudioMixer::MIXING); 2269 } 2270 } 2271 2272 // remove all the tracks that need to be... 2273 count = tracksToRemove->size(); 2274 if (UNLIKELY(count)) { 2275 for (size_t i=0 ; i<count ; i++) { 2276 const sp<Track>& track = tracksToRemove->itemAt(i); 2277 mActiveTracks.remove(track); 2278 if (track->mainBuffer() != mMixBuffer) { 2279 chain = getEffectChain_l(track->sessionId()); 2280 if (chain != 0) { 2281 LOGV("stopping track on chain %p for session Id: %d", chain.get(), track->sessionId()); 2282 chain->decActiveTrackCnt(); 2283 } 2284 } 2285 if (track->isTerminated()) { 2286 removeTrack_l(track); 2287 } 2288 } 2289 } 2290 2291 // mix buffer must be cleared if all tracks are connected to an 2292 // effect chain as in this case the mixer will not write to 2293 // mix buffer and track effects will accumulate into it 2294 if (mixedTracks != 0 && mixedTracks == tracksWithEffect) { 2295 memset(mMixBuffer, 0, mFrameCount * mChannelCount * sizeof(int16_t)); 2296 } 2297 2298 mPrevMixerStatus = mixerStatus; 2299 return mixerStatus; 2300 } 2301 2302 void AudioFlinger::MixerThread::invalidateTracks(int streamType) 2303 { 2304 LOGV ("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %d", 2305 this, streamType, mTracks.size()); 2306 Mutex::Autolock _l(mLock); 2307 2308 size_t size = mTracks.size(); 2309 for (size_t i = 0; i < size; i++) { 2310 sp<Track> t = mTracks[i]; 2311 if (t->type() == streamType) { 2312 android_atomic_or(CBLK_INVALID_ON, &t->mCblk->flags); 2313 t->mCblk->cv.signal(); 2314 } 2315 } 2316 } 2317 2318 void AudioFlinger::PlaybackThread::setStreamValid(int streamType, bool valid) 2319 { 2320 LOGV ("PlaybackThread::setStreamValid() thread %p, streamType %d, valid %d", 2321 this, streamType, valid); 2322 Mutex::Autolock _l(mLock); 2323 2324 mStreamTypes[streamType].valid = valid; 2325 } 2326 2327 // getTrackName_l() must be called with ThreadBase::mLock held 2328 int AudioFlinger::MixerThread::getTrackName_l() 2329 { 2330 return mAudioMixer->getTrackName(); 2331 } 2332 2333 // deleteTrackName_l() must be called with ThreadBase::mLock held 2334 void AudioFlinger::MixerThread::deleteTrackName_l(int name) 2335 { 2336 LOGV("remove track (%d) and delete from mixer", name); 2337 mAudioMixer->deleteTrackName(name); 2338 } 2339 2340 // checkForNewParameters_l() must be called with ThreadBase::mLock held 2341 bool AudioFlinger::MixerThread::checkForNewParameters_l() 2342 { 2343 bool reconfig = false; 2344 2345 while (!mNewParameters.isEmpty()) { 2346 status_t status = NO_ERROR; 2347 String8 keyValuePair = mNewParameters[0]; 2348 AudioParameter param = AudioParameter(keyValuePair); 2349 int value; 2350 2351 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) { 2352 reconfig = true; 2353 } 2354 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) { 2355 if (value != AUDIO_FORMAT_PCM_16_BIT) { 2356 status = BAD_VALUE; 2357 } else { 2358 reconfig = true; 2359 } 2360 } 2361 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) { 2362 if (value != AUDIO_CHANNEL_OUT_STEREO) { 2363 status = BAD_VALUE; 2364 } else { 2365 reconfig = true; 2366 } 2367 } 2368 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { 2369 // do not accept frame count changes if tracks are open as the track buffer 2370 // size depends on frame count and correct behavior would not be garantied 2371 // if frame count is changed after track creation 2372 if (!mTracks.isEmpty()) { 2373 status = INVALID_OPERATION; 2374 } else { 2375 reconfig = true; 2376 } 2377 } 2378 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) { 2379 // when changing the audio output device, call addBatteryData to notify 2380 // the change 2381 if ((int)mDevice != value) { 2382 uint32_t params = 0; 2383 // check whether speaker is on 2384 if (value & AUDIO_DEVICE_OUT_SPEAKER) { 2385 params |= IMediaPlayerService::kBatteryDataSpeakerOn; 2386 } 2387 2388 int deviceWithoutSpeaker 2389 = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER; 2390 // check if any other device (except speaker) is on 2391 if (value & deviceWithoutSpeaker ) { 2392 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn; 2393 } 2394 2395 if (params != 0) { 2396 addBatteryData(params); 2397 } 2398 } 2399 2400 // forward device change to effects that have requested to be 2401 // aware of attached audio device. 2402 mDevice = (uint32_t)value; 2403 for (size_t i = 0; i < mEffectChains.size(); i++) { 2404 mEffectChains[i]->setDevice_l(mDevice); 2405 } 2406 } 2407 2408 if (status == NO_ERROR) { 2409 status = mOutput->stream->common.set_parameters(&mOutput->stream->common, 2410 keyValuePair.string()); 2411 if (!mStandby && status == INVALID_OPERATION) { 2412 mOutput->stream->common.standby(&mOutput->stream->common); 2413 mStandby = true; 2414 mBytesWritten = 0; 2415 status = mOutput->stream->common.set_parameters(&mOutput->stream->common, 2416 keyValuePair.string()); 2417 } 2418 if (status == NO_ERROR && reconfig) { 2419 delete mAudioMixer; 2420 readOutputParameters(); 2421 mAudioMixer = new AudioMixer(mFrameCount, mSampleRate); 2422 for (size_t i = 0; i < mTracks.size() ; i++) { 2423 int name = getTrackName_l(); 2424 if (name < 0) break; 2425 mTracks[i]->mName = name; 2426 // limit track sample rate to 2 x new output sample rate 2427 if (mTracks[i]->mCblk->sampleRate > 2 * sampleRate()) { 2428 mTracks[i]->mCblk->sampleRate = 2 * sampleRate(); 2429 } 2430 } 2431 sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED); 2432 } 2433 } 2434 2435 mNewParameters.removeAt(0); 2436 2437 mParamStatus = status; 2438 mParamCond.signal(); 2439 // wait for condition with time out in case the thread calling ThreadBase::setParameters() 2440 // already timed out waiting for the status and will never signal the condition. 2441 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeout); 2442 } 2443 return reconfig; 2444 } 2445 2446 status_t AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args) 2447 { 2448 const size_t SIZE = 256; 2449 char buffer[SIZE]; 2450 String8 result; 2451 2452 PlaybackThread::dumpInternals(fd, args); 2453 2454 snprintf(buffer, SIZE, "AudioMixer tracks: %08x\n", mAudioMixer->trackNames()); 2455 result.append(buffer); 2456 write(fd, result.string(), result.size()); 2457 return NO_ERROR; 2458 } 2459 2460 uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() 2461 { 2462 return (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2; 2463 } 2464 2465 uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() 2466 { 2467 return (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000); 2468 } 2469 2470 // ---------------------------------------------------------------------------- 2471 AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device) 2472 : PlaybackThread(audioFlinger, output, id, device) 2473 { 2474 mType = ThreadBase::DIRECT; 2475 } 2476 2477 AudioFlinger::DirectOutputThread::~DirectOutputThread() 2478 { 2479 } 2480 2481 2482 static inline int16_t clamp16(int32_t sample) 2483 { 2484 if ((sample>>15) ^ (sample>>31)) 2485 sample = 0x7FFF ^ (sample>>31); 2486 return sample; 2487 } 2488 2489 static inline 2490 int32_t mul(int16_t in, int16_t v) 2491 { 2492 #if defined(__arm__) && !defined(__thumb__) 2493 int32_t out; 2494 asm( "smulbb %[out], %[in], %[v] \n" 2495 : [out]"=r"(out) 2496 : [in]"%r"(in), [v]"r"(v) 2497 : ); 2498 return out; 2499 #else 2500 return in * int32_t(v); 2501 #endif 2502 } 2503 2504 void AudioFlinger::DirectOutputThread::applyVolume(uint16_t leftVol, uint16_t rightVol, bool ramp) 2505 { 2506 // Do not apply volume on compressed audio 2507 if (!audio_is_linear_pcm(mFormat)) { 2508 return; 2509 } 2510 2511 // convert to signed 16 bit before volume calculation 2512 if (mFormat == AUDIO_FORMAT_PCM_8_BIT) { 2513 size_t count = mFrameCount * mChannelCount; 2514 uint8_t *src = (uint8_t *)mMixBuffer + count-1; 2515 int16_t *dst = mMixBuffer + count-1; 2516 while(count--) { 2517 *dst-- = (int16_t)(*src--^0x80) << 8; 2518 } 2519 } 2520 2521 size_t frameCount = mFrameCount; 2522 int16_t *out = mMixBuffer; 2523 if (ramp) { 2524 if (mChannelCount == 1) { 2525 int32_t d = ((int32_t)leftVol - (int32_t)mLeftVolShort) << 16; 2526 int32_t vlInc = d / (int32_t)frameCount; 2527 int32_t vl = ((int32_t)mLeftVolShort << 16); 2528 do { 2529 out[0] = clamp16(mul(out[0], vl >> 16) >> 12); 2530 out++; 2531 vl += vlInc; 2532 } while (--frameCount); 2533 2534 } else { 2535 int32_t d = ((int32_t)leftVol - (int32_t)mLeftVolShort) << 16; 2536 int32_t vlInc = d / (int32_t)frameCount; 2537 d = ((int32_t)rightVol - (int32_t)mRightVolShort) << 16; 2538 int32_t vrInc = d / (int32_t)frameCount; 2539 int32_t vl = ((int32_t)mLeftVolShort << 16); 2540 int32_t vr = ((int32_t)mRightVolShort << 16); 2541 do { 2542 out[0] = clamp16(mul(out[0], vl >> 16) >> 12); 2543 out[1] = clamp16(mul(out[1], vr >> 16) >> 12); 2544 out += 2; 2545 vl += vlInc; 2546 vr += vrInc; 2547 } while (--frameCount); 2548 } 2549 } else { 2550 if (mChannelCount == 1) { 2551 do { 2552 out[0] = clamp16(mul(out[0], leftVol) >> 12); 2553 out++; 2554 } while (--frameCount); 2555 } else { 2556 do { 2557 out[0] = clamp16(mul(out[0], leftVol) >> 12); 2558 out[1] = clamp16(mul(out[1], rightVol) >> 12); 2559 out += 2; 2560 } while (--frameCount); 2561 } 2562 } 2563 2564 // convert back to unsigned 8 bit after volume calculation 2565 if (mFormat == AUDIO_FORMAT_PCM_8_BIT) { 2566 size_t count = mFrameCount * mChannelCount; 2567 int16_t *src = mMixBuffer; 2568 uint8_t *dst = (uint8_t *)mMixBuffer; 2569 while(count--) { 2570 *dst++ = (uint8_t)(((int32_t)*src++ + (1<<7)) >> 8)^0x80; 2571 } 2572 } 2573 2574 mLeftVolShort = leftVol; 2575 mRightVolShort = rightVol; 2576 } 2577 2578 bool AudioFlinger::DirectOutputThread::threadLoop() 2579 { 2580 uint32_t mixerStatus = MIXER_IDLE; 2581 sp<Track> trackToRemove; 2582 sp<Track> activeTrack; 2583 nsecs_t standbyTime = systemTime(); 2584 int8_t *curBuf; 2585 size_t mixBufferSize = mFrameCount*mFrameSize; 2586 uint32_t activeSleepTime = activeSleepTimeUs(); 2587 uint32_t idleSleepTime = idleSleepTimeUs(); 2588 uint32_t sleepTime = idleSleepTime; 2589 // use shorter standby delay as on normal output to release 2590 // hardware resources as soon as possible 2591 nsecs_t standbyDelay = microseconds(activeSleepTime*2); 2592 2593 acquireWakeLock(); 2594 2595 while (!exitPending()) 2596 { 2597 bool rampVolume; 2598 uint16_t leftVol; 2599 uint16_t rightVol; 2600 Vector< sp<EffectChain> > effectChains; 2601 2602 processConfigEvents(); 2603 2604 mixerStatus = MIXER_IDLE; 2605 2606 { // scope for the mLock 2607 2608 Mutex::Autolock _l(mLock); 2609 2610 if (checkForNewParameters_l()) { 2611 mixBufferSize = mFrameCount*mFrameSize; 2612 activeSleepTime = activeSleepTimeUs(); 2613 idleSleepTime = idleSleepTimeUs(); 2614 standbyDelay = microseconds(activeSleepTime*2); 2615 } 2616 2617 // put audio hardware into standby after short delay 2618 if UNLIKELY((!mActiveTracks.size() && systemTime() > standbyTime) || 2619 mSuspended) { 2620 // wait until we have something to do... 2621 if (!mStandby) { 2622 LOGV("Audio hardware entering standby, mixer %p\n", this); 2623 mOutput->stream->common.standby(&mOutput->stream->common); 2624 mStandby = true; 2625 mBytesWritten = 0; 2626 } 2627 2628 if (!mActiveTracks.size() && mConfigEvents.isEmpty()) { 2629 // we're about to wait, flush the binder command buffer 2630 IPCThreadState::self()->flushCommands(); 2631 2632 if (exitPending()) break; 2633 2634 releaseWakeLock_l(); 2635 LOGV("DirectOutputThread %p TID %d going to sleep\n", this, gettid()); 2636 mWaitWorkCV.wait(mLock); 2637 LOGV("DirectOutputThread %p TID %d waking up in active mode\n", this, gettid()); 2638 acquireWakeLock_l(); 2639 2640 if (mMasterMute == false) { 2641 char value[PROPERTY_VALUE_MAX]; 2642 property_get("ro.audio.silent", value, "0"); 2643 if (atoi(value)) { 2644 LOGD("Silence is golden"); 2645 setMasterMute(true); 2646 } 2647 } 2648 2649 standbyTime = systemTime() + standbyDelay; 2650 sleepTime = idleSleepTime; 2651 continue; 2652 } 2653 } 2654 2655 effectChains = mEffectChains; 2656 2657 // find out which tracks need to be processed 2658 if (mActiveTracks.size() != 0) { 2659 sp<Track> t = mActiveTracks[0].promote(); 2660 if (t == 0) continue; 2661 2662 Track* const track = t.get(); 2663 audio_track_cblk_t* cblk = track->cblk(); 2664 2665 // The first time a track is added we wait 2666 // for all its buffers to be filled before processing it 2667 if (cblk->framesReady() && track->isReady() && 2668 !track->isPaused() && !track->isTerminated()) 2669 { 2670 //LOGV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server); 2671 2672 if (track->mFillingUpStatus == Track::FS_FILLED) { 2673 track->mFillingUpStatus = Track::FS_ACTIVE; 2674 mLeftVolFloat = mRightVolFloat = 0; 2675 mLeftVolShort = mRightVolShort = 0; 2676 if (track->mState == TrackBase::RESUMING) { 2677 track->mState = TrackBase::ACTIVE; 2678 rampVolume = true; 2679 } 2680 } else if (cblk->server != 0) { 2681 // If the track is stopped before the first frame was mixed, 2682 // do not apply ramp 2683 rampVolume = true; 2684 } 2685 // compute volume for this track 2686 float left, right; 2687 if (track->isMuted() || mMasterMute || track->isPausing() || 2688 mStreamTypes[track->type()].mute) { 2689 left = right = 0; 2690 if (track->isPausing()) { 2691 track->setPaused(); 2692 } 2693 } else { 2694 float typeVolume = mStreamTypes[track->type()].volume; 2695 float v = mMasterVolume * typeVolume; 2696 float v_clamped = v * cblk->volume[0]; 2697 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN; 2698 left = v_clamped/MAX_GAIN; 2699 v_clamped = v * cblk->volume[1]; 2700 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN; 2701 right = v_clamped/MAX_GAIN; 2702 } 2703 2704 if (left != mLeftVolFloat || right != mRightVolFloat) { 2705 mLeftVolFloat = left; 2706 mRightVolFloat = right; 2707 2708 // If audio HAL implements volume control, 2709 // force software volume to nominal value 2710 if (mOutput->stream->set_volume(mOutput->stream, left, right) == NO_ERROR) { 2711 left = 1.0f; 2712 right = 1.0f; 2713 } 2714 2715 // Convert volumes from float to 8.24 2716 uint32_t vl = (uint32_t)(left * (1 << 24)); 2717 uint32_t vr = (uint32_t)(right * (1 << 24)); 2718 2719 // Delegate volume control to effect in track effect chain if needed 2720 // only one effect chain can be present on DirectOutputThread, so if 2721 // there is one, the track is connected to it 2722 if (!effectChains.isEmpty()) { 2723 // Do not ramp volume if volume is controlled by effect 2724 if(effectChains[0]->setVolume_l(&vl, &vr)) { 2725 rampVolume = false; 2726 } 2727 } 2728 2729 // Convert volumes from 8.24 to 4.12 format 2730 uint32_t v_clamped = (vl + (1 << 11)) >> 12; 2731 if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT; 2732 leftVol = (uint16_t)v_clamped; 2733 v_clamped = (vr + (1 << 11)) >> 12; 2734 if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT; 2735 rightVol = (uint16_t)v_clamped; 2736 } else { 2737 leftVol = mLeftVolShort; 2738 rightVol = mRightVolShort; 2739 rampVolume = false; 2740 } 2741 2742 // reset retry count 2743 track->mRetryCount = kMaxTrackRetriesDirect; 2744 activeTrack = t; 2745 mixerStatus = MIXER_TRACKS_READY; 2746 } else { 2747 //LOGV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server); 2748 if (track->isStopped()) { 2749 track->reset(); 2750 } 2751 if (track->isTerminated() || track->isStopped() || track->isPaused()) { 2752 // We have consumed all the buffers of this track. 2753 // Remove it from the list of active tracks. 2754 trackToRemove = track; 2755 } else { 2756 // No buffers for this track. Give it a few chances to 2757 // fill a buffer, then remove it from active list. 2758 if (--(track->mRetryCount) <= 0) { 2759 LOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name()); 2760 trackToRemove = track; 2761 } else { 2762 mixerStatus = MIXER_TRACKS_ENABLED; 2763 } 2764 } 2765 } 2766 } 2767 2768 // remove all the tracks that need to be... 2769 if (UNLIKELY(trackToRemove != 0)) { 2770 mActiveTracks.remove(trackToRemove); 2771 if (!effectChains.isEmpty()) { 2772 LOGV("stopping track on chain %p for session Id: %d", effectChains[0].get(), 2773 trackToRemove->sessionId()); 2774 effectChains[0]->decActiveTrackCnt(); 2775 } 2776 if (trackToRemove->isTerminated()) { 2777 removeTrack_l(trackToRemove); 2778 } 2779 } 2780 2781 lockEffectChains_l(effectChains); 2782 } 2783 2784 if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { 2785 AudioBufferProvider::Buffer buffer; 2786 size_t frameCount = mFrameCount; 2787 curBuf = (int8_t *)mMixBuffer; 2788 // output audio to hardware 2789 while (frameCount) { 2790 buffer.frameCount = frameCount; 2791 activeTrack->getNextBuffer(&buffer); 2792 if (UNLIKELY(buffer.raw == 0)) { 2793 memset(curBuf, 0, frameCount * mFrameSize); 2794 break; 2795 } 2796 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize); 2797 frameCount -= buffer.frameCount; 2798 curBuf += buffer.frameCount * mFrameSize; 2799 activeTrack->releaseBuffer(&buffer); 2800 } 2801 sleepTime = 0; 2802 standbyTime = systemTime() + standbyDelay; 2803 } else { 2804 if (sleepTime == 0) { 2805 if (mixerStatus == MIXER_TRACKS_ENABLED) { 2806 sleepTime = activeSleepTime; 2807 } else { 2808 sleepTime = idleSleepTime; 2809 } 2810 } else if (mBytesWritten != 0 && audio_is_linear_pcm(mFormat)) { 2811 memset (mMixBuffer, 0, mFrameCount * mFrameSize); 2812 sleepTime = 0; 2813 } 2814 } 2815 2816 if (mSuspended) { 2817 sleepTime = suspendSleepTimeUs(); 2818 } 2819 // sleepTime == 0 means we must write to audio hardware 2820 if (sleepTime == 0) { 2821 if (mixerStatus == MIXER_TRACKS_READY) { 2822 applyVolume(leftVol, rightVol, rampVolume); 2823 } 2824 for (size_t i = 0; i < effectChains.size(); i ++) { 2825 effectChains[i]->process_l(); 2826 } 2827 unlockEffectChains(effectChains); 2828 2829 mLastWriteTime = systemTime(); 2830 mInWrite = true; 2831 mBytesWritten += mixBufferSize; 2832 int bytesWritten = (int)mOutput->stream->write(mOutput->stream, mMixBuffer, mixBufferSize); 2833 if (bytesWritten < 0) mBytesWritten -= mixBufferSize; 2834 mNumWrites++; 2835 mInWrite = false; 2836 mStandby = false; 2837 } else { 2838 unlockEffectChains(effectChains); 2839 usleep(sleepTime); 2840 } 2841 2842 // finally let go of removed track, without the lock held 2843 // since we can't guarantee the destructors won't acquire that 2844 // same lock. 2845 trackToRemove.clear(); 2846 activeTrack.clear(); 2847 2848 // Effect chains will be actually deleted here if they were removed from 2849 // mEffectChains list during mixing or effects processing 2850 effectChains.clear(); 2851 } 2852 2853 if (!mStandby) { 2854 mOutput->stream->common.standby(&mOutput->stream->common); 2855 } 2856 2857 releaseWakeLock(); 2858 2859 LOGV("DirectOutputThread %p exiting", this); 2860 return false; 2861 } 2862 2863 // getTrackName_l() must be called with ThreadBase::mLock held 2864 int AudioFlinger::DirectOutputThread::getTrackName_l() 2865 { 2866 return 0; 2867 } 2868 2869 // deleteTrackName_l() must be called with ThreadBase::mLock held 2870 void AudioFlinger::DirectOutputThread::deleteTrackName_l(int name) 2871 { 2872 } 2873 2874 // checkForNewParameters_l() must be called with ThreadBase::mLock held 2875 bool AudioFlinger::DirectOutputThread::checkForNewParameters_l() 2876 { 2877 bool reconfig = false; 2878 2879 while (!mNewParameters.isEmpty()) { 2880 status_t status = NO_ERROR; 2881 String8 keyValuePair = mNewParameters[0]; 2882 AudioParameter param = AudioParameter(keyValuePair); 2883 int value; 2884 2885 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { 2886 // do not accept frame count changes if tracks are open as the track buffer 2887 // size depends on frame count and correct behavior would not be garantied 2888 // if frame count is changed after track creation 2889 if (!mTracks.isEmpty()) { 2890 status = INVALID_OPERATION; 2891 } else { 2892 reconfig = true; 2893 } 2894 } 2895 if (status == NO_ERROR) { 2896 status = mOutput->stream->common.set_parameters(&mOutput->stream->common, 2897 keyValuePair.string()); 2898 if (!mStandby && status == INVALID_OPERATION) { 2899 mOutput->stream->common.standby(&mOutput->stream->common); 2900 mStandby = true; 2901 mBytesWritten = 0; 2902 status = mOutput->stream->common.set_parameters(&mOutput->stream->common, 2903 keyValuePair.string()); 2904 } 2905 if (status == NO_ERROR && reconfig) { 2906 readOutputParameters(); 2907 sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED); 2908 } 2909 } 2910 2911 mNewParameters.removeAt(0); 2912 2913 mParamStatus = status; 2914 mParamCond.signal(); 2915 // wait for condition with time out in case the thread calling ThreadBase::setParameters() 2916 // already timed out waiting for the status and will never signal the condition. 2917 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeout); 2918 } 2919 return reconfig; 2920 } 2921 2922 uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() 2923 { 2924 uint32_t time; 2925 if (audio_is_linear_pcm(mFormat)) { 2926 time = PlaybackThread::activeSleepTimeUs(); 2927 } else { 2928 time = 10000; 2929 } 2930 return time; 2931 } 2932 2933 uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() 2934 { 2935 uint32_t time; 2936 if (audio_is_linear_pcm(mFormat)) { 2937 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2; 2938 } else { 2939 time = 10000; 2940 } 2941 return time; 2942 } 2943 2944 uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() 2945 { 2946 uint32_t time; 2947 if (audio_is_linear_pcm(mFormat)) { 2948 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000); 2949 } else { 2950 time = 10000; 2951 } 2952 return time; 2953 } 2954 2955 2956 // ---------------------------------------------------------------------------- 2957 2958 AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger, AudioFlinger::MixerThread* mainThread, int id) 2959 : MixerThread(audioFlinger, mainThread->getOutput(), id, mainThread->device()), mWaitTimeMs(UINT_MAX) 2960 { 2961 mType = ThreadBase::DUPLICATING; 2962 addOutputTrack(mainThread); 2963 } 2964 2965 AudioFlinger::DuplicatingThread::~DuplicatingThread() 2966 { 2967 for (size_t i = 0; i < mOutputTracks.size(); i++) { 2968 mOutputTracks[i]->destroy(); 2969 } 2970 mOutputTracks.clear(); 2971 } 2972 2973 bool AudioFlinger::DuplicatingThread::threadLoop() 2974 { 2975 Vector< sp<Track> > tracksToRemove; 2976 uint32_t mixerStatus = MIXER_IDLE; 2977 nsecs_t standbyTime = systemTime(); 2978 size_t mixBufferSize = mFrameCount*mFrameSize; 2979 SortedVector< sp<OutputTrack> > outputTracks; 2980 uint32_t writeFrames = 0; 2981 uint32_t activeSleepTime = activeSleepTimeUs(); 2982 uint32_t idleSleepTime = idleSleepTimeUs(); 2983 uint32_t sleepTime = idleSleepTime; 2984 Vector< sp<EffectChain> > effectChains; 2985 2986 acquireWakeLock(); 2987 2988 while (!exitPending()) 2989 { 2990 processConfigEvents(); 2991 2992 mixerStatus = MIXER_IDLE; 2993 { // scope for the mLock 2994 2995 Mutex::Autolock _l(mLock); 2996 2997 if (checkForNewParameters_l()) { 2998 mixBufferSize = mFrameCount*mFrameSize; 2999 updateWaitTime(); 3000 activeSleepTime = activeSleepTimeUs(); 3001 idleSleepTime = idleSleepTimeUs(); 3002 } 3003 3004 const SortedVector< wp<Track> >& activeTracks = mActiveTracks; 3005 3006 for (size_t i = 0; i < mOutputTracks.size(); i++) { 3007 outputTracks.add(mOutputTracks[i]); 3008 } 3009 3010 // put audio hardware into standby after short delay 3011 if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) || 3012 mSuspended) { 3013 if (!mStandby) { 3014 for (size_t i = 0; i < outputTracks.size(); i++) { 3015 outputTracks[i]->stop(); 3016 } 3017 mStandby = true; 3018 mBytesWritten = 0; 3019 } 3020 3021 if (!activeTracks.size() && mConfigEvents.isEmpty()) { 3022 // we're about to wait, flush the binder command buffer 3023 IPCThreadState::self()->flushCommands(); 3024 outputTracks.clear(); 3025 3026 if (exitPending()) break; 3027 3028 releaseWakeLock_l(); 3029 LOGV("DuplicatingThread %p TID %d going to sleep\n", this, gettid()); 3030 mWaitWorkCV.wait(mLock); 3031 LOGV("DuplicatingThread %p TID %d waking up\n", this, gettid()); 3032 acquireWakeLock_l(); 3033 3034 mPrevMixerStatus = MIXER_IDLE; 3035 if (mMasterMute == false) { 3036 char value[PROPERTY_VALUE_MAX]; 3037 property_get("ro.audio.silent", value, "0"); 3038 if (atoi(value)) { 3039 LOGD("Silence is golden"); 3040 setMasterMute(true); 3041 } 3042 } 3043 3044 standbyTime = systemTime() + kStandbyTimeInNsecs; 3045 sleepTime = idleSleepTime; 3046 continue; 3047 } 3048 } 3049 3050 mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove); 3051 3052 // prevent any changes in effect chain list and in each effect chain 3053 // during mixing and effect process as the audio buffers could be deleted 3054 // or modified if an effect is created or deleted 3055 lockEffectChains_l(effectChains); 3056 } 3057 3058 if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { 3059 // mix buffers... 3060 if (outputsReady(outputTracks)) { 3061 mAudioMixer->process(); 3062 } else { 3063 memset(mMixBuffer, 0, mixBufferSize); 3064 } 3065 sleepTime = 0; 3066 writeFrames = mFrameCount; 3067 } else { 3068 if (sleepTime == 0) { 3069 if (mixerStatus == MIXER_TRACKS_ENABLED) { 3070 sleepTime = activeSleepTime; 3071 } else { 3072 sleepTime = idleSleepTime; 3073 } 3074 } else if (mBytesWritten != 0) { 3075 // flush remaining overflow buffers in output tracks 3076 for (size_t i = 0; i < outputTracks.size(); i++) { 3077 if (outputTracks[i]->isActive()) { 3078 sleepTime = 0; 3079 writeFrames = 0; 3080 memset(mMixBuffer, 0, mixBufferSize); 3081 break; 3082 } 3083 } 3084 } 3085 } 3086 3087 if (mSuspended) { 3088 sleepTime = suspendSleepTimeUs(); 3089 } 3090 // sleepTime == 0 means we must write to audio hardware 3091 if (sleepTime == 0) { 3092 for (size_t i = 0; i < effectChains.size(); i ++) { 3093 effectChains[i]->process_l(); 3094 } 3095 // enable changes in effect chain 3096 unlockEffectChains(effectChains); 3097 3098 standbyTime = systemTime() + kStandbyTimeInNsecs; 3099 for (size_t i = 0; i < outputTracks.size(); i++) { 3100 outputTracks[i]->write(mMixBuffer, writeFrames); 3101 } 3102 mStandby = false; 3103 mBytesWritten += mixBufferSize; 3104 } else { 3105 // enable changes in effect chain 3106 unlockEffectChains(effectChains); 3107 usleep(sleepTime); 3108 } 3109 3110 // finally let go of all our tracks, without the lock held 3111 // since we can't guarantee the destructors won't acquire that 3112 // same lock. 3113 tracksToRemove.clear(); 3114 outputTracks.clear(); 3115 3116 // Effect chains will be actually deleted here if they were removed from 3117 // mEffectChains list during mixing or effects processing 3118 effectChains.clear(); 3119 } 3120 3121 releaseWakeLock(); 3122 3123 return false; 3124 } 3125 3126 void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread) 3127 { 3128 int frameCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate(); 3129 OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread, 3130 this, 3131 mSampleRate, 3132 mFormat, 3133 mChannelMask, 3134 frameCount); 3135 if (outputTrack->cblk() != NULL) { 3136 thread->setStreamVolume(AUDIO_STREAM_CNT, 1.0f); 3137 mOutputTracks.add(outputTrack); 3138 LOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread); 3139 updateWaitTime(); 3140 } 3141 } 3142 3143 void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread) 3144 { 3145 Mutex::Autolock _l(mLock); 3146 for (size_t i = 0; i < mOutputTracks.size(); i++) { 3147 if (mOutputTracks[i]->thread() == (ThreadBase *)thread) { 3148 mOutputTracks[i]->destroy(); 3149 mOutputTracks.removeAt(i); 3150 updateWaitTime(); 3151 return; 3152 } 3153 } 3154 LOGV("removeOutputTrack(): unkonwn thread: %p", thread); 3155 } 3156 3157 void AudioFlinger::DuplicatingThread::updateWaitTime() 3158 { 3159 mWaitTimeMs = UINT_MAX; 3160 for (size_t i = 0; i < mOutputTracks.size(); i++) { 3161 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote(); 3162 if (strong != NULL) { 3163 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate(); 3164 if (waitTimeMs < mWaitTimeMs) { 3165 mWaitTimeMs = waitTimeMs; 3166 } 3167 } 3168 } 3169 } 3170 3171 3172 bool AudioFlinger::DuplicatingThread::outputsReady(SortedVector< sp<OutputTrack> > &outputTracks) 3173 { 3174 for (size_t i = 0; i < outputTracks.size(); i++) { 3175 sp <ThreadBase> thread = outputTracks[i]->thread().promote(); 3176 if (thread == 0) { 3177 LOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p", outputTracks[i].get()); 3178 return false; 3179 } 3180 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 3181 if (playbackThread->standby() && !playbackThread->isSuspended()) { 3182 LOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(), thread.get()); 3183 return false; 3184 } 3185 } 3186 return true; 3187 } 3188 3189 uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() 3190 { 3191 return (mWaitTimeMs * 1000) / 2; 3192 } 3193 3194 // ---------------------------------------------------------------------------- 3195 3196 // TrackBase constructor must be called with AudioFlinger::mLock held 3197 AudioFlinger::ThreadBase::TrackBase::TrackBase( 3198 const wp<ThreadBase>& thread, 3199 const sp<Client>& client, 3200 uint32_t sampleRate, 3201 uint32_t format, 3202 uint32_t channelMask, 3203 int frameCount, 3204 uint32_t flags, 3205 const sp<IMemory>& sharedBuffer, 3206 int sessionId) 3207 : RefBase(), 3208 mThread(thread), 3209 mClient(client), 3210 mCblk(0), 3211 mFrameCount(0), 3212 mState(IDLE), 3213 mClientTid(-1), 3214 mFormat(format), 3215 mFlags(flags & ~SYSTEM_FLAGS_MASK), 3216 mSessionId(sessionId) 3217 { 3218 LOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size()); 3219 3220 // LOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize); 3221 size_t size = sizeof(audio_track_cblk_t); 3222 uint8_t channelCount = popcount(channelMask); 3223 size_t bufferSize = frameCount*channelCount*sizeof(int16_t); 3224 if (sharedBuffer == 0) { 3225 size += bufferSize; 3226 } 3227 3228 if (client != NULL) { 3229 mCblkMemory = client->heap()->allocate(size); 3230 if (mCblkMemory != 0) { 3231 mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer()); 3232 if (mCblk) { // construct the shared structure in-place. 3233 new(mCblk) audio_track_cblk_t(); 3234 // clear all buffers 3235 mCblk->frameCount = frameCount; 3236 mCblk->sampleRate = sampleRate; 3237 mChannelCount = channelCount; 3238 mChannelMask = channelMask; 3239 if (sharedBuffer == 0) { 3240 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 3241 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t)); 3242 // Force underrun condition to avoid false underrun callback until first data is 3243 // written to buffer (other flags are cleared) 3244 mCblk->flags = CBLK_UNDERRUN_ON; 3245 } else { 3246 mBuffer = sharedBuffer->pointer(); 3247 } 3248 mBufferEnd = (uint8_t *)mBuffer + bufferSize; 3249 } 3250 } else { 3251 LOGE("not enough memory for AudioTrack size=%u", size); 3252 client->heap()->dump("AudioTrack"); 3253 return; 3254 } 3255 } else { 3256 mCblk = (audio_track_cblk_t *)(new uint8_t[size]); 3257 if (mCblk) { // construct the shared structure in-place. 3258 new(mCblk) audio_track_cblk_t(); 3259 // clear all buffers 3260 mCblk->frameCount = frameCount; 3261 mCblk->sampleRate = sampleRate; 3262 mChannelCount = channelCount; 3263 mChannelMask = channelMask; 3264 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 3265 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t)); 3266 // Force underrun condition to avoid false underrun callback until first data is 3267 // written to buffer (other flags are cleared) 3268 mCblk->flags = CBLK_UNDERRUN_ON; 3269 mBufferEnd = (uint8_t *)mBuffer + bufferSize; 3270 } 3271 } 3272 } 3273 3274 AudioFlinger::ThreadBase::TrackBase::~TrackBase() 3275 { 3276 if (mCblk) { 3277 mCblk->~audio_track_cblk_t(); // destroy our shared-structure. 3278 if (mClient == NULL) { 3279 delete mCblk; 3280 } 3281 } 3282 mCblkMemory.clear(); // and free the shared memory 3283 if (mClient != NULL) { 3284 Mutex::Autolock _l(mClient->audioFlinger()->mLock); 3285 mClient.clear(); 3286 } 3287 } 3288 3289 void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer) 3290 { 3291 buffer->raw = 0; 3292 mFrameCount = buffer->frameCount; 3293 step(); 3294 buffer->frameCount = 0; 3295 } 3296 3297 bool AudioFlinger::ThreadBase::TrackBase::step() { 3298 bool result; 3299 audio_track_cblk_t* cblk = this->cblk(); 3300 3301 result = cblk->stepServer(mFrameCount); 3302 if (!result) { 3303 LOGV("stepServer failed acquiring cblk mutex"); 3304 mFlags |= STEPSERVER_FAILED; 3305 } 3306 return result; 3307 } 3308 3309 void AudioFlinger::ThreadBase::TrackBase::reset() { 3310 audio_track_cblk_t* cblk = this->cblk(); 3311 3312 cblk->user = 0; 3313 cblk->server = 0; 3314 cblk->userBase = 0; 3315 cblk->serverBase = 0; 3316 mFlags &= (uint32_t)(~SYSTEM_FLAGS_MASK); 3317 LOGV("TrackBase::reset"); 3318 } 3319 3320 sp<IMemory> AudioFlinger::ThreadBase::TrackBase::getCblk() const 3321 { 3322 return mCblkMemory; 3323 } 3324 3325 int AudioFlinger::ThreadBase::TrackBase::sampleRate() const { 3326 return (int)mCblk->sampleRate; 3327 } 3328 3329 int AudioFlinger::ThreadBase::TrackBase::channelCount() const { 3330 return (const int)mChannelCount; 3331 } 3332 3333 uint32_t AudioFlinger::ThreadBase::TrackBase::channelMask() const { 3334 return mChannelMask; 3335 } 3336 3337 void* AudioFlinger::ThreadBase::TrackBase::getBuffer(uint32_t offset, uint32_t frames) const { 3338 audio_track_cblk_t* cblk = this->cblk(); 3339 int8_t *bufferStart = (int8_t *)mBuffer + (offset-cblk->serverBase)*cblk->frameSize; 3340 int8_t *bufferEnd = bufferStart + frames * cblk->frameSize; 3341 3342 // Check validity of returned pointer in case the track control block would have been corrupted. 3343 if (bufferStart < mBuffer || bufferStart > bufferEnd || bufferEnd > mBufferEnd || 3344 ((unsigned long)bufferStart & (unsigned long)(cblk->frameSize - 1))) { 3345 LOGE("TrackBase::getBuffer buffer out of range:\n start: %p, end %p , mBuffer %p mBufferEnd %p\n \ 3346 server %d, serverBase %d, user %d, userBase %d", 3347 bufferStart, bufferEnd, mBuffer, mBufferEnd, 3348 cblk->server, cblk->serverBase, cblk->user, cblk->userBase); 3349 return 0; 3350 } 3351 3352 return bufferStart; 3353 } 3354 3355 // ---------------------------------------------------------------------------- 3356 3357 // Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 3358 AudioFlinger::PlaybackThread::Track::Track( 3359 const wp<ThreadBase>& thread, 3360 const sp<Client>& client, 3361 int streamType, 3362 uint32_t sampleRate, 3363 uint32_t format, 3364 uint32_t channelMask, 3365 int frameCount, 3366 const sp<IMemory>& sharedBuffer, 3367 int sessionId) 3368 : TrackBase(thread, client, sampleRate, format, channelMask, frameCount, 0, sharedBuffer, sessionId), 3369 mMute(false), mSharedBuffer(sharedBuffer), mName(-1), mMainBuffer(NULL), mAuxBuffer(NULL), 3370 mAuxEffectId(0), mHasVolumeController(false) 3371 { 3372 if (mCblk != NULL) { 3373 sp<ThreadBase> baseThread = thread.promote(); 3374 if (baseThread != 0) { 3375 PlaybackThread *playbackThread = (PlaybackThread *)baseThread.get(); 3376 mName = playbackThread->getTrackName_l(); 3377 mMainBuffer = playbackThread->mixBuffer(); 3378 } 3379 LOGV("Track constructor name %d, calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 3380 if (mName < 0) { 3381 LOGE("no more track names available"); 3382 } 3383 mVolume[0] = 1.0f; 3384 mVolume[1] = 1.0f; 3385 mStreamType = streamType; 3386 // NOTE: audio_track_cblk_t::frameSize for 8 bit PCM data is based on a sample size of 3387 // 16 bit because data is converted to 16 bit before being stored in buffer by AudioTrack 3388 mCblk->frameSize = audio_is_linear_pcm(format) ? mChannelCount * sizeof(int16_t) : sizeof(uint8_t); 3389 } 3390 } 3391 3392 AudioFlinger::PlaybackThread::Track::~Track() 3393 { 3394 LOGV("PlaybackThread::Track destructor"); 3395 sp<ThreadBase> thread = mThread.promote(); 3396 if (thread != 0) { 3397 Mutex::Autolock _l(thread->mLock); 3398 mState = TERMINATED; 3399 } 3400 } 3401 3402 void AudioFlinger::PlaybackThread::Track::destroy() 3403 { 3404 // NOTE: destroyTrack_l() can remove a strong reference to this Track 3405 // by removing it from mTracks vector, so there is a risk that this Tracks's 3406 // desctructor is called. As the destructor needs to lock mLock, 3407 // we must acquire a strong reference on this Track before locking mLock 3408 // here so that the destructor is called only when exiting this function. 3409 // On the other hand, as long as Track::destroy() is only called by 3410 // TrackHandle destructor, the TrackHandle still holds a strong ref on 3411 // this Track with its member mTrack. 3412 sp<Track> keep(this); 3413 { // scope for mLock 3414 sp<ThreadBase> thread = mThread.promote(); 3415 if (thread != 0) { 3416 if (!isOutputTrack()) { 3417 if (mState == ACTIVE || mState == RESUMING) { 3418 AudioSystem::stopOutput(thread->id(), 3419 (audio_stream_type_t)mStreamType, 3420 mSessionId); 3421 3422 // to track the speaker usage 3423 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop); 3424 } 3425 AudioSystem::releaseOutput(thread->id()); 3426 } 3427 Mutex::Autolock _l(thread->mLock); 3428 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 3429 playbackThread->destroyTrack_l(this); 3430 } 3431 } 3432 } 3433 3434 void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size) 3435 { 3436 snprintf(buffer, size, " %05d %05d %03u %03u 0x%08x %05u %04u %1d %1d %1d %05u %05u %05u 0x%08x 0x%08x 0x%08x 0x%08x\n", 3437 mName - AudioMixer::TRACK0, 3438 (mClient == NULL) ? getpid() : mClient->pid(), 3439 mStreamType, 3440 mFormat, 3441 mChannelMask, 3442 mSessionId, 3443 mFrameCount, 3444 mState, 3445 mMute, 3446 mFillingUpStatus, 3447 mCblk->sampleRate, 3448 mCblk->volume[0], 3449 mCblk->volume[1], 3450 mCblk->server, 3451 mCblk->user, 3452 (int)mMainBuffer, 3453 (int)mAuxBuffer); 3454 } 3455 3456 status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer) 3457 { 3458 audio_track_cblk_t* cblk = this->cblk(); 3459 uint32_t framesReady; 3460 uint32_t framesReq = buffer->frameCount; 3461 3462 // Check if last stepServer failed, try to step now 3463 if (mFlags & TrackBase::STEPSERVER_FAILED) { 3464 if (!step()) goto getNextBuffer_exit; 3465 LOGV("stepServer recovered"); 3466 mFlags &= ~TrackBase::STEPSERVER_FAILED; 3467 } 3468 3469 framesReady = cblk->framesReady(); 3470 3471 if (LIKELY(framesReady)) { 3472 uint32_t s = cblk->server; 3473 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount; 3474 3475 bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd : bufferEnd; 3476 if (framesReq > framesReady) { 3477 framesReq = framesReady; 3478 } 3479 if (s + framesReq > bufferEnd) { 3480 framesReq = bufferEnd - s; 3481 } 3482 3483 buffer->raw = getBuffer(s, framesReq); 3484 if (buffer->raw == 0) goto getNextBuffer_exit; 3485 3486 buffer->frameCount = framesReq; 3487 return NO_ERROR; 3488 } 3489 3490 getNextBuffer_exit: 3491 buffer->raw = 0; 3492 buffer->frameCount = 0; 3493 LOGV("getNextBuffer() no more data for track %d on thread %p", mName, mThread.unsafe_get()); 3494 return NOT_ENOUGH_DATA; 3495 } 3496 3497 bool AudioFlinger::PlaybackThread::Track::isReady() const { 3498 if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) return true; 3499 3500 if (mCblk->framesReady() >= mCblk->frameCount || 3501 (mCblk->flags & CBLK_FORCEREADY_MSK)) { 3502 mFillingUpStatus = FS_FILLED; 3503 android_atomic_and(~CBLK_FORCEREADY_MSK, &mCblk->flags); 3504 return true; 3505 } 3506 return false; 3507 } 3508 3509 status_t AudioFlinger::PlaybackThread::Track::start() 3510 { 3511 status_t status = NO_ERROR; 3512 LOGV("start(%d), calling thread %d session %d", 3513 mName, IPCThreadState::self()->getCallingPid(), mSessionId); 3514 sp<ThreadBase> thread = mThread.promote(); 3515 if (thread != 0) { 3516 Mutex::Autolock _l(thread->mLock); 3517 int state = mState; 3518 // here the track could be either new, or restarted 3519 // in both cases "unstop" the track 3520 if (mState == PAUSED) { 3521 mState = TrackBase::RESUMING; 3522 LOGV("PAUSED => RESUMING (%d) on thread %p", mName, this); 3523 } else { 3524 mState = TrackBase::ACTIVE; 3525 LOGV("? => ACTIVE (%d) on thread %p", mName, this); 3526 } 3527 3528 if (!isOutputTrack() && state != ACTIVE && state != RESUMING) { 3529 thread->mLock.unlock(); 3530 status = AudioSystem::startOutput(thread->id(), 3531 (audio_stream_type_t)mStreamType, 3532 mSessionId); 3533 thread->mLock.lock(); 3534 3535 // to track the speaker usage 3536 if (status == NO_ERROR) { 3537 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart); 3538 } 3539 } 3540 if (status == NO_ERROR) { 3541 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 3542 playbackThread->addTrack_l(this); 3543 } else { 3544 mState = state; 3545 } 3546 } else { 3547 status = BAD_VALUE; 3548 } 3549 return status; 3550 } 3551 3552 void AudioFlinger::PlaybackThread::Track::stop() 3553 { 3554 LOGV("stop(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 3555 sp<ThreadBase> thread = mThread.promote(); 3556 if (thread != 0) { 3557 Mutex::Autolock _l(thread->mLock); 3558 int state = mState; 3559 if (mState > STOPPED) { 3560 mState = STOPPED; 3561 // If the track is not active (PAUSED and buffers full), flush buffers 3562 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 3563 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 3564 reset(); 3565 } 3566 LOGV("(> STOPPED) => STOPPED (%d) on thread %p", mName, playbackThread); 3567 } 3568 if (!isOutputTrack() && (state == ACTIVE || state == RESUMING)) { 3569 thread->mLock.unlock(); 3570 AudioSystem::stopOutput(thread->id(), 3571 (audio_stream_type_t)mStreamType, 3572 mSessionId); 3573 thread->mLock.lock(); 3574 3575 // to track the speaker usage 3576 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop); 3577 } 3578 } 3579 } 3580 3581 void AudioFlinger::PlaybackThread::Track::pause() 3582 { 3583 LOGV("pause(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 3584 sp<ThreadBase> thread = mThread.promote(); 3585 if (thread != 0) { 3586 Mutex::Autolock _l(thread->mLock); 3587 if (mState == ACTIVE || mState == RESUMING) { 3588 mState = PAUSING; 3589 LOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get()); 3590 if (!isOutputTrack()) { 3591 thread->mLock.unlock(); 3592 AudioSystem::stopOutput(thread->id(), 3593 (audio_stream_type_t)mStreamType, 3594 mSessionId); 3595 thread->mLock.lock(); 3596 3597 // to track the speaker usage 3598 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop); 3599 } 3600 } 3601 } 3602 } 3603 3604 void AudioFlinger::PlaybackThread::Track::flush() 3605 { 3606 LOGV("flush(%d)", mName); 3607 sp<ThreadBase> thread = mThread.promote(); 3608 if (thread != 0) { 3609 Mutex::Autolock _l(thread->mLock); 3610 if (mState != STOPPED && mState != PAUSED && mState != PAUSING) { 3611 return; 3612 } 3613 // No point remaining in PAUSED state after a flush => go to 3614 // STOPPED state 3615 mState = STOPPED; 3616 3617 // do not reset the track if it is still in the process of being stopped or paused. 3618 // this will be done by prepareTracks_l() when the track is stopped. 3619 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 3620 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 3621 reset(); 3622 } 3623 } 3624 } 3625 3626 void AudioFlinger::PlaybackThread::Track::reset() 3627 { 3628 // Do not reset twice to avoid discarding data written just after a flush and before 3629 // the audioflinger thread detects the track is stopped. 3630 if (!mResetDone) { 3631 TrackBase::reset(); 3632 // Force underrun condition to avoid false underrun callback until first data is 3633 // written to buffer 3634 android_atomic_and(~CBLK_FORCEREADY_MSK, &mCblk->flags); 3635 android_atomic_or(CBLK_UNDERRUN_ON, &mCblk->flags); 3636 mFillingUpStatus = FS_FILLING; 3637 mResetDone = true; 3638 } 3639 } 3640 3641 void AudioFlinger::PlaybackThread::Track::mute(bool muted) 3642 { 3643 mMute = muted; 3644 } 3645 3646 void AudioFlinger::PlaybackThread::Track::setVolume(float left, float right) 3647 { 3648 mVolume[0] = left; 3649 mVolume[1] = right; 3650 } 3651 3652 status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId) 3653 { 3654 status_t status = DEAD_OBJECT; 3655 sp<ThreadBase> thread = mThread.promote(); 3656 if (thread != 0) { 3657 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 3658 status = playbackThread->attachAuxEffect(this, EffectId); 3659 } 3660 return status; 3661 } 3662 3663 void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer) 3664 { 3665 mAuxEffectId = EffectId; 3666 mAuxBuffer = buffer; 3667 } 3668 3669 // ---------------------------------------------------------------------------- 3670 3671 // RecordTrack constructor must be called with AudioFlinger::mLock held 3672 AudioFlinger::RecordThread::RecordTrack::RecordTrack( 3673 const wp<ThreadBase>& thread, 3674 const sp<Client>& client, 3675 uint32_t sampleRate, 3676 uint32_t format, 3677 uint32_t channelMask, 3678 int frameCount, 3679 uint32_t flags, 3680 int sessionId) 3681 : TrackBase(thread, client, sampleRate, format, 3682 channelMask, frameCount, flags, 0, sessionId), 3683 mOverflow(false) 3684 { 3685 if (mCblk != NULL) { 3686 LOGV("RecordTrack constructor, size %d", (int)mBufferEnd - (int)mBuffer); 3687 if (format == AUDIO_FORMAT_PCM_16_BIT) { 3688 mCblk->frameSize = mChannelCount * sizeof(int16_t); 3689 } else if (format == AUDIO_FORMAT_PCM_8_BIT) { 3690 mCblk->frameSize = mChannelCount * sizeof(int8_t); 3691 } else { 3692 mCblk->frameSize = sizeof(int8_t); 3693 } 3694 } 3695 } 3696 3697 AudioFlinger::RecordThread::RecordTrack::~RecordTrack() 3698 { 3699 sp<ThreadBase> thread = mThread.promote(); 3700 if (thread != 0) { 3701 AudioSystem::releaseInput(thread->id()); 3702 } 3703 } 3704 3705 status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer) 3706 { 3707 audio_track_cblk_t* cblk = this->cblk(); 3708 uint32_t framesAvail; 3709 uint32_t framesReq = buffer->frameCount; 3710 3711 // Check if last stepServer failed, try to step now 3712 if (mFlags & TrackBase::STEPSERVER_FAILED) { 3713 if (!step()) goto getNextBuffer_exit; 3714 LOGV("stepServer recovered"); 3715 mFlags &= ~TrackBase::STEPSERVER_FAILED; 3716 } 3717 3718 framesAvail = cblk->framesAvailable_l(); 3719 3720 if (LIKELY(framesAvail)) { 3721 uint32_t s = cblk->server; 3722 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount; 3723 3724 if (framesReq > framesAvail) { 3725 framesReq = framesAvail; 3726 } 3727 if (s + framesReq > bufferEnd) { 3728 framesReq = bufferEnd - s; 3729 } 3730 3731 buffer->raw = getBuffer(s, framesReq); 3732 if (buffer->raw == 0) goto getNextBuffer_exit; 3733 3734 buffer->frameCount = framesReq; 3735 return NO_ERROR; 3736 } 3737 3738 getNextBuffer_exit: 3739 buffer->raw = 0; 3740 buffer->frameCount = 0; 3741 return NOT_ENOUGH_DATA; 3742 } 3743 3744 status_t AudioFlinger::RecordThread::RecordTrack::start() 3745 { 3746 sp<ThreadBase> thread = mThread.promote(); 3747 if (thread != 0) { 3748 RecordThread *recordThread = (RecordThread *)thread.get(); 3749 return recordThread->start(this); 3750 } else { 3751 return BAD_VALUE; 3752 } 3753 } 3754 3755 void AudioFlinger::RecordThread::RecordTrack::stop() 3756 { 3757 sp<ThreadBase> thread = mThread.promote(); 3758 if (thread != 0) { 3759 RecordThread *recordThread = (RecordThread *)thread.get(); 3760 recordThread->stop(this); 3761 TrackBase::reset(); 3762 // Force overerrun condition to avoid false overrun callback until first data is 3763 // read from buffer 3764 android_atomic_or(CBLK_UNDERRUN_ON, &mCblk->flags); 3765 } 3766 } 3767 3768 void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size) 3769 { 3770 snprintf(buffer, size, " %05d %03u 0x%08x %05d %04u %01d %05u %08x %08x\n", 3771 (mClient == NULL) ? getpid() : mClient->pid(), 3772 mFormat, 3773 mChannelMask, 3774 mSessionId, 3775 mFrameCount, 3776 mState, 3777 mCblk->sampleRate, 3778 mCblk->server, 3779 mCblk->user); 3780 } 3781 3782 3783 // ---------------------------------------------------------------------------- 3784 3785 AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( 3786 const wp<ThreadBase>& thread, 3787 DuplicatingThread *sourceThread, 3788 uint32_t sampleRate, 3789 uint32_t format, 3790 uint32_t channelMask, 3791 int frameCount) 3792 : Track(thread, NULL, AUDIO_STREAM_CNT, sampleRate, format, channelMask, frameCount, NULL, 0), 3793 mActive(false), mSourceThread(sourceThread) 3794 { 3795 3796 PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get(); 3797 if (mCblk != NULL) { 3798 mCblk->flags |= CBLK_DIRECTION_OUT; 3799 mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t); 3800 mCblk->volume[0] = mCblk->volume[1] = 0x1000; 3801 mOutBuffer.frameCount = 0; 3802 playbackThread->mTracks.add(this); 3803 LOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, " \ 3804 "mCblk->frameCount %d, mCblk->sampleRate %d, mChannelMask 0x%08x mBufferEnd %p", 3805 mCblk, mBuffer, mCblk->buffers, 3806 mCblk->frameCount, mCblk->sampleRate, mChannelMask, mBufferEnd); 3807 } else { 3808 LOGW("Error creating output track on thread %p", playbackThread); 3809 } 3810 } 3811 3812 AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack() 3813 { 3814 clearBufferQueue(); 3815 } 3816 3817 status_t AudioFlinger::PlaybackThread::OutputTrack::start() 3818 { 3819 status_t status = Track::start(); 3820 if (status != NO_ERROR) { 3821 return status; 3822 } 3823 3824 mActive = true; 3825 mRetryCount = 127; 3826 return status; 3827 } 3828 3829 void AudioFlinger::PlaybackThread::OutputTrack::stop() 3830 { 3831 Track::stop(); 3832 clearBufferQueue(); 3833 mOutBuffer.frameCount = 0; 3834 mActive = false; 3835 } 3836 3837 bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames) 3838 { 3839 Buffer *pInBuffer; 3840 Buffer inBuffer; 3841 uint32_t channelCount = mChannelCount; 3842 bool outputBufferFull = false; 3843 inBuffer.frameCount = frames; 3844 inBuffer.i16 = data; 3845 3846 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs(); 3847 3848 if (!mActive && frames != 0) { 3849 start(); 3850 sp<ThreadBase> thread = mThread.promote(); 3851 if (thread != 0) { 3852 MixerThread *mixerThread = (MixerThread *)thread.get(); 3853 if (mCblk->frameCount > frames){ 3854 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 3855 uint32_t startFrames = (mCblk->frameCount - frames); 3856 pInBuffer = new Buffer; 3857 pInBuffer->mBuffer = new int16_t[startFrames * channelCount]; 3858 pInBuffer->frameCount = startFrames; 3859 pInBuffer->i16 = pInBuffer->mBuffer; 3860 memset(pInBuffer->raw, 0, startFrames * channelCount * sizeof(int16_t)); 3861 mBufferQueue.add(pInBuffer); 3862 } else { 3863 LOGW ("OutputTrack::write() %p no more buffers in queue", this); 3864 } 3865 } 3866 } 3867 } 3868 3869 while (waitTimeLeftMs) { 3870 // First write pending buffers, then new data 3871 if (mBufferQueue.size()) { 3872 pInBuffer = mBufferQueue.itemAt(0); 3873 } else { 3874 pInBuffer = &inBuffer; 3875 } 3876 3877 if (pInBuffer->frameCount == 0) { 3878 break; 3879 } 3880 3881 if (mOutBuffer.frameCount == 0) { 3882 mOutBuffer.frameCount = pInBuffer->frameCount; 3883 nsecs_t startTime = systemTime(); 3884 if (obtainBuffer(&mOutBuffer, waitTimeLeftMs) == (status_t)AudioTrack::NO_MORE_BUFFERS) { 3885 LOGV ("OutputTrack::write() %p thread %p no more output buffers", this, mThread.unsafe_get()); 3886 outputBufferFull = true; 3887 break; 3888 } 3889 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime); 3890 if (waitTimeLeftMs >= waitTimeMs) { 3891 waitTimeLeftMs -= waitTimeMs; 3892 } else { 3893 waitTimeLeftMs = 0; 3894 } 3895 } 3896 3897 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : pInBuffer->frameCount; 3898 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channelCount * sizeof(int16_t)); 3899 mCblk->stepUser(outFrames); 3900 pInBuffer->frameCount -= outFrames; 3901 pInBuffer->i16 += outFrames * channelCount; 3902 mOutBuffer.frameCount -= outFrames; 3903 mOutBuffer.i16 += outFrames * channelCount; 3904 3905 if (pInBuffer->frameCount == 0) { 3906 if (mBufferQueue.size()) { 3907 mBufferQueue.removeAt(0); 3908 delete [] pInBuffer->mBuffer; 3909 delete pInBuffer; 3910 LOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size()); 3911 } else { 3912 break; 3913 } 3914 } 3915 } 3916 3917 // If we could not write all frames, allocate a buffer and queue it for next time. 3918 if (inBuffer.frameCount) { 3919 sp<ThreadBase> thread = mThread.promote(); 3920 if (thread != 0 && !thread->standby()) { 3921 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 3922 pInBuffer = new Buffer; 3923 pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channelCount]; 3924 pInBuffer->frameCount = inBuffer.frameCount; 3925 pInBuffer->i16 = pInBuffer->mBuffer; 3926 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channelCount * sizeof(int16_t)); 3927 mBufferQueue.add(pInBuffer); 3928 LOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size()); 3929 } else { 3930 LOGW("OutputTrack::write() %p thread %p no more overflow buffers", mThread.unsafe_get(), this); 3931 } 3932 } 3933 } 3934 3935 // Calling write() with a 0 length buffer, means that no more data will be written: 3936 // If no more buffers are pending, fill output track buffer to make sure it is started 3937 // by output mixer. 3938 if (frames == 0 && mBufferQueue.size() == 0) { 3939 if (mCblk->user < mCblk->frameCount) { 3940 frames = mCblk->frameCount - mCblk->user; 3941 pInBuffer = new Buffer; 3942 pInBuffer->mBuffer = new int16_t[frames * channelCount]; 3943 pInBuffer->frameCount = frames; 3944 pInBuffer->i16 = pInBuffer->mBuffer; 3945 memset(pInBuffer->raw, 0, frames * channelCount * sizeof(int16_t)); 3946 mBufferQueue.add(pInBuffer); 3947 } else if (mActive) { 3948 stop(); 3949 } 3950 } 3951 3952 return outputBufferFull; 3953 } 3954 3955 status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs) 3956 { 3957 int active; 3958 status_t result; 3959 audio_track_cblk_t* cblk = mCblk; 3960 uint32_t framesReq = buffer->frameCount; 3961 3962 // LOGV("OutputTrack::obtainBuffer user %d, server %d", cblk->user, cblk->server); 3963 buffer->frameCount = 0; 3964 3965 uint32_t framesAvail = cblk->framesAvailable(); 3966 3967 3968 if (framesAvail == 0) { 3969 Mutex::Autolock _l(cblk->lock); 3970 goto start_loop_here; 3971 while (framesAvail == 0) { 3972 active = mActive; 3973 if (UNLIKELY(!active)) { 3974 LOGV("Not active and NO_MORE_BUFFERS"); 3975 return AudioTrack::NO_MORE_BUFFERS; 3976 } 3977 result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs)); 3978 if (result != NO_ERROR) { 3979 return AudioTrack::NO_MORE_BUFFERS; 3980 } 3981 // read the server count again 3982 start_loop_here: 3983 framesAvail = cblk->framesAvailable_l(); 3984 } 3985 } 3986 3987 // if (framesAvail < framesReq) { 3988 // return AudioTrack::NO_MORE_BUFFERS; 3989 // } 3990 3991 if (framesReq > framesAvail) { 3992 framesReq = framesAvail; 3993 } 3994 3995 uint32_t u = cblk->user; 3996 uint32_t bufferEnd = cblk->userBase + cblk->frameCount; 3997 3998 if (u + framesReq > bufferEnd) { 3999 framesReq = bufferEnd - u; 4000 } 4001 4002 buffer->frameCount = framesReq; 4003 buffer->raw = (void *)cblk->buffer(u); 4004 return NO_ERROR; 4005 } 4006 4007 4008 void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue() 4009 { 4010 size_t size = mBufferQueue.size(); 4011 Buffer *pBuffer; 4012 4013 for (size_t i = 0; i < size; i++) { 4014 pBuffer = mBufferQueue.itemAt(i); 4015 delete [] pBuffer->mBuffer; 4016 delete pBuffer; 4017 } 4018 mBufferQueue.clear(); 4019 } 4020 4021 // ---------------------------------------------------------------------------- 4022 4023 AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid) 4024 : RefBase(), 4025 mAudioFlinger(audioFlinger), 4026 mMemoryDealer(new MemoryDealer(1024*1024, "AudioFlinger::Client")), 4027 mPid(pid) 4028 { 4029 // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer 4030 } 4031 4032 // Client destructor must be called with AudioFlinger::mLock held 4033 AudioFlinger::Client::~Client() 4034 { 4035 mAudioFlinger->removeClient_l(mPid); 4036 } 4037 4038 const sp<MemoryDealer>& AudioFlinger::Client::heap() const 4039 { 4040 return mMemoryDealer; 4041 } 4042 4043 // ---------------------------------------------------------------------------- 4044 4045 AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger, 4046 const sp<IAudioFlingerClient>& client, 4047 pid_t pid) 4048 : mAudioFlinger(audioFlinger), mPid(pid), mClient(client) 4049 { 4050 } 4051 4052 AudioFlinger::NotificationClient::~NotificationClient() 4053 { 4054 mClient.clear(); 4055 } 4056 4057 void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who) 4058 { 4059 sp<NotificationClient> keep(this); 4060 { 4061 mAudioFlinger->removeNotificationClient(mPid); 4062 } 4063 } 4064 4065 // ---------------------------------------------------------------------------- 4066 4067 AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track) 4068 : BnAudioTrack(), 4069 mTrack(track) 4070 { 4071 } 4072 4073 AudioFlinger::TrackHandle::~TrackHandle() { 4074 // just stop the track on deletion, associated resources 4075 // will be freed from the main thread once all pending buffers have 4076 // been played. Unless it's not in the active track list, in which 4077 // case we free everything now... 4078 mTrack->destroy(); 4079 } 4080 4081 status_t AudioFlinger::TrackHandle::start() { 4082 return mTrack->start(); 4083 } 4084 4085 void AudioFlinger::TrackHandle::stop() { 4086 mTrack->stop(); 4087 } 4088 4089 void AudioFlinger::TrackHandle::flush() { 4090 mTrack->flush(); 4091 } 4092 4093 void AudioFlinger::TrackHandle::mute(bool e) { 4094 mTrack->mute(e); 4095 } 4096 4097 void AudioFlinger::TrackHandle::pause() { 4098 mTrack->pause(); 4099 } 4100 4101 void AudioFlinger::TrackHandle::setVolume(float left, float right) { 4102 mTrack->setVolume(left, right); 4103 } 4104 4105 sp<IMemory> AudioFlinger::TrackHandle::getCblk() const { 4106 return mTrack->getCblk(); 4107 } 4108 4109 status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId) 4110 { 4111 return mTrack->attachAuxEffect(EffectId); 4112 } 4113 4114 status_t AudioFlinger::TrackHandle::onTransact( 4115 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 4116 { 4117 return BnAudioTrack::onTransact(code, data, reply, flags); 4118 } 4119 4120 // ---------------------------------------------------------------------------- 4121 4122 sp<IAudioRecord> AudioFlinger::openRecord( 4123 pid_t pid, 4124 int input, 4125 uint32_t sampleRate, 4126 uint32_t format, 4127 uint32_t channelMask, 4128 int frameCount, 4129 uint32_t flags, 4130 int *sessionId, 4131 status_t *status) 4132 { 4133 sp<RecordThread::RecordTrack> recordTrack; 4134 sp<RecordHandle> recordHandle; 4135 sp<Client> client; 4136 wp<Client> wclient; 4137 status_t lStatus; 4138 RecordThread *thread; 4139 size_t inFrameCount; 4140 int lSessionId; 4141 4142 // check calling permissions 4143 if (!recordingAllowed()) { 4144 lStatus = PERMISSION_DENIED; 4145 goto Exit; 4146 } 4147 4148 // add client to list 4149 { // scope for mLock 4150 Mutex::Autolock _l(mLock); 4151 thread = checkRecordThread_l(input); 4152 if (thread == NULL) { 4153 lStatus = BAD_VALUE; 4154 goto Exit; 4155 } 4156 4157 wclient = mClients.valueFor(pid); 4158 if (wclient != NULL) { 4159 client = wclient.promote(); 4160 } else { 4161 client = new Client(this, pid); 4162 mClients.add(pid, client); 4163 } 4164 4165 // If no audio session id is provided, create one here 4166 if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) { 4167 lSessionId = *sessionId; 4168 } else { 4169 lSessionId = nextUniqueId(); 4170 if (sessionId != NULL) { 4171 *sessionId = lSessionId; 4172 } 4173 } 4174 // create new record track. The record track uses one track in mHardwareMixerThread by convention. 4175 recordTrack = thread->createRecordTrack_l(client, 4176 sampleRate, 4177 format, 4178 channelMask, 4179 frameCount, 4180 flags, 4181 lSessionId, 4182 &lStatus); 4183 } 4184 if (lStatus != NO_ERROR) { 4185 // remove local strong reference to Client before deleting the RecordTrack so that the Client 4186 // destructor is called by the TrackBase destructor with mLock held 4187 client.clear(); 4188 recordTrack.clear(); 4189 goto Exit; 4190 } 4191 4192 // return to handle to client 4193 recordHandle = new RecordHandle(recordTrack); 4194 lStatus = NO_ERROR; 4195 4196 Exit: 4197 if (status) { 4198 *status = lStatus; 4199 } 4200 return recordHandle; 4201 } 4202 4203 // ---------------------------------------------------------------------------- 4204 4205 AudioFlinger::RecordHandle::RecordHandle(const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack) 4206 : BnAudioRecord(), 4207 mRecordTrack(recordTrack) 4208 { 4209 } 4210 4211 AudioFlinger::RecordHandle::~RecordHandle() { 4212 stop(); 4213 } 4214 4215 status_t AudioFlinger::RecordHandle::start() { 4216 LOGV("RecordHandle::start()"); 4217 return mRecordTrack->start(); 4218 } 4219 4220 void AudioFlinger::RecordHandle::stop() { 4221 LOGV("RecordHandle::stop()"); 4222 mRecordTrack->stop(); 4223 } 4224 4225 sp<IMemory> AudioFlinger::RecordHandle::getCblk() const { 4226 return mRecordTrack->getCblk(); 4227 } 4228 4229 status_t AudioFlinger::RecordHandle::onTransact( 4230 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 4231 { 4232 return BnAudioRecord::onTransact(code, data, reply, flags); 4233 } 4234 4235 // ---------------------------------------------------------------------------- 4236 4237 AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger, 4238 AudioStreamIn *input, 4239 uint32_t sampleRate, 4240 uint32_t channels, 4241 int id, 4242 uint32_t device) : 4243 ThreadBase(audioFlinger, id, device), 4244 mInput(input), mTrack(NULL), mResampler(0), mRsmpOutBuffer(0), mRsmpInBuffer(0) 4245 { 4246 mType = ThreadBase::RECORD; 4247 4248 snprintf(mName, kNameLength, "AudioIn_%d", id); 4249 4250 mReqChannelCount = popcount(channels); 4251 mReqSampleRate = sampleRate; 4252 readInputParameters(); 4253 } 4254 4255 4256 AudioFlinger::RecordThread::~RecordThread() 4257 { 4258 delete[] mRsmpInBuffer; 4259 if (mResampler != 0) { 4260 delete mResampler; 4261 delete[] mRsmpOutBuffer; 4262 } 4263 } 4264 4265 void AudioFlinger::RecordThread::onFirstRef() 4266 { 4267 run(mName, PRIORITY_URGENT_AUDIO); 4268 } 4269 4270 status_t AudioFlinger::RecordThread::readyToRun() 4271 { 4272 status_t status = initCheck(); 4273 LOGW_IF(status != NO_ERROR,"RecordThread %p could not initialize", this); 4274 return status; 4275 } 4276 4277 bool AudioFlinger::RecordThread::threadLoop() 4278 { 4279 AudioBufferProvider::Buffer buffer; 4280 sp<RecordTrack> activeTrack; 4281 Vector< sp<EffectChain> > effectChains; 4282 4283 nsecs_t lastWarning = 0; 4284 4285 acquireWakeLock(); 4286 4287 // start recording 4288 while (!exitPending()) { 4289 4290 processConfigEvents(); 4291 4292 { // scope for mLock 4293 Mutex::Autolock _l(mLock); 4294 checkForNewParameters_l(); 4295 if (mActiveTrack == 0 && mConfigEvents.isEmpty()) { 4296 if (!mStandby) { 4297 mInput->stream->common.standby(&mInput->stream->common); 4298 mStandby = true; 4299 } 4300 4301 if (exitPending()) break; 4302 4303 releaseWakeLock_l(); 4304 LOGV("RecordThread: loop stopping"); 4305 // go to sleep 4306 mWaitWorkCV.wait(mLock); 4307 LOGV("RecordThread: loop starting"); 4308 acquireWakeLock_l(); 4309 continue; 4310 } 4311 if (mActiveTrack != 0) { 4312 if (mActiveTrack->mState == TrackBase::PAUSING) { 4313 if (!mStandby) { 4314 mInput->stream->common.standby(&mInput->stream->common); 4315 mStandby = true; 4316 } 4317 mActiveTrack.clear(); 4318 mStartStopCond.broadcast(); 4319 } else if (mActiveTrack->mState == TrackBase::RESUMING) { 4320 if (mReqChannelCount != mActiveTrack->channelCount()) { 4321 mActiveTrack.clear(); 4322 mStartStopCond.broadcast(); 4323 } else if (mBytesRead != 0) { 4324 // record start succeeds only if first read from audio input 4325 // succeeds 4326 if (mBytesRead > 0) { 4327 mActiveTrack->mState = TrackBase::ACTIVE; 4328 } else { 4329 mActiveTrack.clear(); 4330 } 4331 mStartStopCond.broadcast(); 4332 } 4333 mStandby = false; 4334 } 4335 } 4336 lockEffectChains_l(effectChains); 4337 } 4338 4339 if (mActiveTrack != 0) { 4340 if (mActiveTrack->mState != TrackBase::ACTIVE && 4341 mActiveTrack->mState != TrackBase::RESUMING) { 4342 unlockEffectChains(effectChains); 4343 usleep(kRecordThreadSleepUs); 4344 continue; 4345 } 4346 for (size_t i = 0; i < effectChains.size(); i ++) { 4347 effectChains[i]->process_l(); 4348 } 4349 4350 buffer.frameCount = mFrameCount; 4351 if (LIKELY(mActiveTrack->getNextBuffer(&buffer) == NO_ERROR)) { 4352 size_t framesOut = buffer.frameCount; 4353 if (mResampler == 0) { 4354 // no resampling 4355 while (framesOut) { 4356 size_t framesIn = mFrameCount - mRsmpInIndex; 4357 if (framesIn) { 4358 int8_t *src = (int8_t *)mRsmpInBuffer + mRsmpInIndex * mFrameSize; 4359 int8_t *dst = buffer.i8 + (buffer.frameCount - framesOut) * mActiveTrack->mCblk->frameSize; 4360 if (framesIn > framesOut) 4361 framesIn = framesOut; 4362 mRsmpInIndex += framesIn; 4363 framesOut -= framesIn; 4364 if ((int)mChannelCount == mReqChannelCount || 4365 mFormat != AUDIO_FORMAT_PCM_16_BIT) { 4366 memcpy(dst, src, framesIn * mFrameSize); 4367 } else { 4368 int16_t *src16 = (int16_t *)src; 4369 int16_t *dst16 = (int16_t *)dst; 4370 if (mChannelCount == 1) { 4371 while (framesIn--) { 4372 *dst16++ = *src16; 4373 *dst16++ = *src16++; 4374 } 4375 } else { 4376 while (framesIn--) { 4377 *dst16++ = (int16_t)(((int32_t)*src16 + (int32_t)*(src16 + 1)) >> 1); 4378 src16 += 2; 4379 } 4380 } 4381 } 4382 } 4383 if (framesOut && mFrameCount == mRsmpInIndex) { 4384 if (framesOut == mFrameCount && 4385 ((int)mChannelCount == mReqChannelCount || mFormat != AUDIO_FORMAT_PCM_16_BIT)) { 4386 mBytesRead = mInput->stream->read(mInput->stream, buffer.raw, mInputBytes); 4387 framesOut = 0; 4388 } else { 4389 mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes); 4390 mRsmpInIndex = 0; 4391 } 4392 if (mBytesRead < 0) { 4393 LOGE("Error reading audio input"); 4394 if (mActiveTrack->mState == TrackBase::ACTIVE) { 4395 // Force input into standby so that it tries to 4396 // recover at next read attempt 4397 mInput->stream->common.standby(&mInput->stream->common); 4398 usleep(kRecordThreadSleepUs); 4399 } 4400 mRsmpInIndex = mFrameCount; 4401 framesOut = 0; 4402 buffer.frameCount = 0; 4403 } 4404 } 4405 } 4406 } else { 4407 // resampling 4408 4409 memset(mRsmpOutBuffer, 0, framesOut * 2 * sizeof(int32_t)); 4410 // alter output frame count as if we were expecting stereo samples 4411 if (mChannelCount == 1 && mReqChannelCount == 1) { 4412 framesOut >>= 1; 4413 } 4414 mResampler->resample(mRsmpOutBuffer, framesOut, this); 4415 // ditherAndClamp() works as long as all buffers returned by mActiveTrack->getNextBuffer() 4416 // are 32 bit aligned which should be always true. 4417 if (mChannelCount == 2 && mReqChannelCount == 1) { 4418 AudioMixer::ditherAndClamp(mRsmpOutBuffer, mRsmpOutBuffer, framesOut); 4419 // the resampler always outputs stereo samples: do post stereo to mono conversion 4420 int16_t *src = (int16_t *)mRsmpOutBuffer; 4421 int16_t *dst = buffer.i16; 4422 while (framesOut--) { 4423 *dst++ = (int16_t)(((int32_t)*src + (int32_t)*(src + 1)) >> 1); 4424 src += 2; 4425 } 4426 } else { 4427 AudioMixer::ditherAndClamp((int32_t *)buffer.raw, mRsmpOutBuffer, framesOut); 4428 } 4429 4430 } 4431 mActiveTrack->releaseBuffer(&buffer); 4432 mActiveTrack->overflow(); 4433 } 4434 // client isn't retrieving buffers fast enough 4435 else { 4436 if (!mActiveTrack->setOverflow()) { 4437 nsecs_t now = systemTime(); 4438 if ((now - lastWarning) > kWarningThrottle) { 4439 LOGW("RecordThread: buffer overflow"); 4440 lastWarning = now; 4441 } 4442 } 4443 // Release the processor for a while before asking for a new buffer. 4444 // This will give the application more chance to read from the buffer and 4445 // clear the overflow. 4446 usleep(kRecordThreadSleepUs); 4447 } 4448 } 4449 // enable changes in effect chain 4450 unlockEffectChains(effectChains); 4451 effectChains.clear(); 4452 } 4453 4454 if (!mStandby) { 4455 mInput->stream->common.standby(&mInput->stream->common); 4456 } 4457 mActiveTrack.clear(); 4458 4459 mStartStopCond.broadcast(); 4460 4461 releaseWakeLock(); 4462 4463 LOGV("RecordThread %p exiting", this); 4464 return false; 4465 } 4466 4467 4468 sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l( 4469 const sp<AudioFlinger::Client>& client, 4470 uint32_t sampleRate, 4471 int format, 4472 int channelMask, 4473 int frameCount, 4474 uint32_t flags, 4475 int sessionId, 4476 status_t *status) 4477 { 4478 sp<RecordTrack> track; 4479 status_t lStatus; 4480 4481 lStatus = initCheck(); 4482 if (lStatus != NO_ERROR) { 4483 LOGE("Audio driver not initialized."); 4484 goto Exit; 4485 } 4486 4487 { // scope for mLock 4488 Mutex::Autolock _l(mLock); 4489 4490 track = new RecordTrack(this, client, sampleRate, 4491 format, channelMask, frameCount, flags, sessionId); 4492 4493 if (track->getCblk() == NULL) { 4494 lStatus = NO_MEMORY; 4495 goto Exit; 4496 } 4497 4498 mTrack = track.get(); 4499 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings 4500 bool suspend = audio_is_bluetooth_sco_device( 4501 (audio_devices_t)(mDevice & AUDIO_DEVICE_IN_ALL)) && mAudioFlinger->btNrecIsOff(); 4502 setEffectSuspended_l(FX_IID_AEC, suspend, sessionId); 4503 setEffectSuspended_l(FX_IID_NS, suspend, sessionId); 4504 } 4505 lStatus = NO_ERROR; 4506 4507 Exit: 4508 if (status) { 4509 *status = lStatus; 4510 } 4511 return track; 4512 } 4513 4514 status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack) 4515 { 4516 LOGV("RecordThread::start"); 4517 sp <ThreadBase> strongMe = this; 4518 status_t status = NO_ERROR; 4519 { 4520 AutoMutex lock(&mLock); 4521 if (mActiveTrack != 0) { 4522 if (recordTrack != mActiveTrack.get()) { 4523 status = -EBUSY; 4524 } else if (mActiveTrack->mState == TrackBase::PAUSING) { 4525 mActiveTrack->mState = TrackBase::ACTIVE; 4526 } 4527 return status; 4528 } 4529 4530 recordTrack->mState = TrackBase::IDLE; 4531 mActiveTrack = recordTrack; 4532 mLock.unlock(); 4533 status_t status = AudioSystem::startInput(mId); 4534 mLock.lock(); 4535 if (status != NO_ERROR) { 4536 mActiveTrack.clear(); 4537 return status; 4538 } 4539 mRsmpInIndex = mFrameCount; 4540 mBytesRead = 0; 4541 if (mResampler != NULL) { 4542 mResampler->reset(); 4543 } 4544 mActiveTrack->mState = TrackBase::RESUMING; 4545 // signal thread to start 4546 LOGV("Signal record thread"); 4547 mWaitWorkCV.signal(); 4548 // do not wait for mStartStopCond if exiting 4549 if (mExiting) { 4550 mActiveTrack.clear(); 4551 status = INVALID_OPERATION; 4552 goto startError; 4553 } 4554 mStartStopCond.wait(mLock); 4555 if (mActiveTrack == 0) { 4556 LOGV("Record failed to start"); 4557 status = BAD_VALUE; 4558 goto startError; 4559 } 4560 LOGV("Record started OK"); 4561 return status; 4562 } 4563 startError: 4564 AudioSystem::stopInput(mId); 4565 return status; 4566 } 4567 4568 void AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) { 4569 LOGV("RecordThread::stop"); 4570 sp <ThreadBase> strongMe = this; 4571 { 4572 AutoMutex lock(&mLock); 4573 if (mActiveTrack != 0 && recordTrack == mActiveTrack.get()) { 4574 mActiveTrack->mState = TrackBase::PAUSING; 4575 // do not wait for mStartStopCond if exiting 4576 if (mExiting) { 4577 return; 4578 } 4579 mStartStopCond.wait(mLock); 4580 // if we have been restarted, recordTrack == mActiveTrack.get() here 4581 if (mActiveTrack == 0 || recordTrack != mActiveTrack.get()) { 4582 mLock.unlock(); 4583 AudioSystem::stopInput(mId); 4584 mLock.lock(); 4585 LOGV("Record stopped OK"); 4586 } 4587 } 4588 } 4589 } 4590 4591 status_t AudioFlinger::RecordThread::dump(int fd, const Vector<String16>& args) 4592 { 4593 const size_t SIZE = 256; 4594 char buffer[SIZE]; 4595 String8 result; 4596 pid_t pid = 0; 4597 4598 snprintf(buffer, SIZE, "\nInput thread %p internals\n", this); 4599 result.append(buffer); 4600 4601 if (mActiveTrack != 0) { 4602 result.append("Active Track:\n"); 4603 result.append(" Clien Fmt Chn mask Session Buf S SRate Serv User\n"); 4604 mActiveTrack->dump(buffer, SIZE); 4605 result.append(buffer); 4606 4607 snprintf(buffer, SIZE, "In index: %d\n", mRsmpInIndex); 4608 result.append(buffer); 4609 snprintf(buffer, SIZE, "In size: %d\n", mInputBytes); 4610 result.append(buffer); 4611 snprintf(buffer, SIZE, "Resampling: %d\n", (mResampler != 0)); 4612 result.append(buffer); 4613 snprintf(buffer, SIZE, "Out channel count: %d\n", mReqChannelCount); 4614 result.append(buffer); 4615 snprintf(buffer, SIZE, "Out sample rate: %d\n", mReqSampleRate); 4616 result.append(buffer); 4617 4618 4619 } else { 4620 result.append("No record client\n"); 4621 } 4622 write(fd, result.string(), result.size()); 4623 4624 dumpBase(fd, args); 4625 dumpEffectChains(fd, args); 4626 4627 return NO_ERROR; 4628 } 4629 4630 status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer* buffer) 4631 { 4632 size_t framesReq = buffer->frameCount; 4633 size_t framesReady = mFrameCount - mRsmpInIndex; 4634 int channelCount; 4635 4636 if (framesReady == 0) { 4637 mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes); 4638 if (mBytesRead < 0) { 4639 LOGE("RecordThread::getNextBuffer() Error reading audio input"); 4640 if (mActiveTrack->mState == TrackBase::ACTIVE) { 4641 // Force input into standby so that it tries to 4642 // recover at next read attempt 4643 mInput->stream->common.standby(&mInput->stream->common); 4644 usleep(kRecordThreadSleepUs); 4645 } 4646 buffer->raw = 0; 4647 buffer->frameCount = 0; 4648 return NOT_ENOUGH_DATA; 4649 } 4650 mRsmpInIndex = 0; 4651 framesReady = mFrameCount; 4652 } 4653 4654 if (framesReq > framesReady) { 4655 framesReq = framesReady; 4656 } 4657 4658 if (mChannelCount == 1 && mReqChannelCount == 2) { 4659 channelCount = 1; 4660 } else { 4661 channelCount = 2; 4662 } 4663 buffer->raw = mRsmpInBuffer + mRsmpInIndex * channelCount; 4664 buffer->frameCount = framesReq; 4665 return NO_ERROR; 4666 } 4667 4668 void AudioFlinger::RecordThread::releaseBuffer(AudioBufferProvider::Buffer* buffer) 4669 { 4670 mRsmpInIndex += buffer->frameCount; 4671 buffer->frameCount = 0; 4672 } 4673 4674 bool AudioFlinger::RecordThread::checkForNewParameters_l() 4675 { 4676 bool reconfig = false; 4677 4678 while (!mNewParameters.isEmpty()) { 4679 status_t status = NO_ERROR; 4680 String8 keyValuePair = mNewParameters[0]; 4681 AudioParameter param = AudioParameter(keyValuePair); 4682 int value; 4683 int reqFormat = mFormat; 4684 int reqSamplingRate = mReqSampleRate; 4685 int reqChannelCount = mReqChannelCount; 4686 4687 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) { 4688 reqSamplingRate = value; 4689 reconfig = true; 4690 } 4691 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) { 4692 reqFormat = value; 4693 reconfig = true; 4694 } 4695 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) { 4696 reqChannelCount = popcount(value); 4697 reconfig = true; 4698 } 4699 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { 4700 // do not accept frame count changes if tracks are open as the track buffer 4701 // size depends on frame count and correct behavior would not be garantied 4702 // if frame count is changed after track creation 4703 if (mActiveTrack != 0) { 4704 status = INVALID_OPERATION; 4705 } else { 4706 reconfig = true; 4707 } 4708 } 4709 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) { 4710 // forward device change to effects that have requested to be 4711 // aware of attached audio device. 4712 for (size_t i = 0; i < mEffectChains.size(); i++) { 4713 mEffectChains[i]->setDevice_l(value); 4714 } 4715 // store input device and output device but do not forward output device to audio HAL. 4716 // Note that status is ignored by the caller for output device 4717 // (see AudioFlinger::setParameters() 4718 if (value & AUDIO_DEVICE_OUT_ALL) { 4719 mDevice &= (uint32_t)~(value & AUDIO_DEVICE_OUT_ALL); 4720 status = BAD_VALUE; 4721 } else { 4722 mDevice &= (uint32_t)~(value & AUDIO_DEVICE_IN_ALL); 4723 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings 4724 if (mTrack != NULL) { 4725 bool suspend = audio_is_bluetooth_sco_device( 4726 (audio_devices_t)value) && mAudioFlinger->btNrecIsOff(); 4727 setEffectSuspended_l(FX_IID_AEC, suspend, mTrack->sessionId()); 4728 setEffectSuspended_l(FX_IID_NS, suspend, mTrack->sessionId()); 4729 } 4730 } 4731 mDevice |= (uint32_t)value; 4732 } 4733 if (status == NO_ERROR) { 4734 status = mInput->stream->common.set_parameters(&mInput->stream->common, keyValuePair.string()); 4735 if (status == INVALID_OPERATION) { 4736 mInput->stream->common.standby(&mInput->stream->common); 4737 status = mInput->stream->common.set_parameters(&mInput->stream->common, keyValuePair.string()); 4738 } 4739 if (reconfig) { 4740 if (status == BAD_VALUE && 4741 reqFormat == mInput->stream->common.get_format(&mInput->stream->common) && 4742 reqFormat == AUDIO_FORMAT_PCM_16_BIT && 4743 ((int)mInput->stream->common.get_sample_rate(&mInput->stream->common) <= (2 * reqSamplingRate)) && 4744 (popcount(mInput->stream->common.get_channels(&mInput->stream->common)) < 3) && 4745 (reqChannelCount < 3)) { 4746 status = NO_ERROR; 4747 } 4748 if (status == NO_ERROR) { 4749 readInputParameters(); 4750 sendConfigEvent_l(AudioSystem::INPUT_CONFIG_CHANGED); 4751 } 4752 } 4753 } 4754 4755 mNewParameters.removeAt(0); 4756 4757 mParamStatus = status; 4758 mParamCond.signal(); 4759 // wait for condition with time out in case the thread calling ThreadBase::setParameters() 4760 // already timed out waiting for the status and will never signal the condition. 4761 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeout); 4762 } 4763 return reconfig; 4764 } 4765 4766 String8 AudioFlinger::RecordThread::getParameters(const String8& keys) 4767 { 4768 char *s; 4769 String8 out_s8 = String8(); 4770 4771 Mutex::Autolock _l(mLock); 4772 if (initCheck() != NO_ERROR) { 4773 return out_s8; 4774 } 4775 4776 s = mInput->stream->common.get_parameters(&mInput->stream->common, keys.string()); 4777 out_s8 = String8(s); 4778 free(s); 4779 return out_s8; 4780 } 4781 4782 void AudioFlinger::RecordThread::audioConfigChanged_l(int event, int param) { 4783 AudioSystem::OutputDescriptor desc; 4784 void *param2 = 0; 4785 4786 switch (event) { 4787 case AudioSystem::INPUT_OPENED: 4788 case AudioSystem::INPUT_CONFIG_CHANGED: 4789 desc.channels = mChannelMask; 4790 desc.samplingRate = mSampleRate; 4791 desc.format = mFormat; 4792 desc.frameCount = mFrameCount; 4793 desc.latency = 0; 4794 param2 = &desc; 4795 break; 4796 4797 case AudioSystem::INPUT_CLOSED: 4798 default: 4799 break; 4800 } 4801 mAudioFlinger->audioConfigChanged_l(event, mId, param2); 4802 } 4803 4804 void AudioFlinger::RecordThread::readInputParameters() 4805 { 4806 if (mRsmpInBuffer) delete mRsmpInBuffer; 4807 if (mRsmpOutBuffer) delete mRsmpOutBuffer; 4808 if (mResampler) delete mResampler; 4809 mResampler = 0; 4810 4811 mSampleRate = mInput->stream->common.get_sample_rate(&mInput->stream->common); 4812 mChannelMask = mInput->stream->common.get_channels(&mInput->stream->common); 4813 mChannelCount = (uint16_t)popcount(mChannelMask); 4814 mFormat = mInput->stream->common.get_format(&mInput->stream->common); 4815 mFrameSize = (uint16_t)audio_stream_frame_size(&mInput->stream->common); 4816 mInputBytes = mInput->stream->common.get_buffer_size(&mInput->stream->common); 4817 mFrameCount = mInputBytes / mFrameSize; 4818 mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount]; 4819 4820 if (mSampleRate != mReqSampleRate && mChannelCount < 3 && mReqChannelCount < 3) 4821 { 4822 int channelCount; 4823 // optmization: if mono to mono, use the resampler in stereo to stereo mode to avoid 4824 // stereo to mono post process as the resampler always outputs stereo. 4825 if (mChannelCount == 1 && mReqChannelCount == 2) { 4826 channelCount = 1; 4827 } else { 4828 channelCount = 2; 4829 } 4830 mResampler = AudioResampler::create(16, channelCount, mReqSampleRate); 4831 mResampler->setSampleRate(mSampleRate); 4832 mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN); 4833 mRsmpOutBuffer = new int32_t[mFrameCount * 2]; 4834 4835 // optmization: if mono to mono, alter input frame count as if we were inputing stereo samples 4836 if (mChannelCount == 1 && mReqChannelCount == 1) { 4837 mFrameCount >>= 1; 4838 } 4839 4840 } 4841 mRsmpInIndex = mFrameCount; 4842 } 4843 4844 unsigned int AudioFlinger::RecordThread::getInputFramesLost() 4845 { 4846 Mutex::Autolock _l(mLock); 4847 if (initCheck() != NO_ERROR) { 4848 return 0; 4849 } 4850 4851 return mInput->stream->get_input_frames_lost(mInput->stream); 4852 } 4853 4854 uint32_t AudioFlinger::RecordThread::hasAudioSession(int sessionId) 4855 { 4856 Mutex::Autolock _l(mLock); 4857 uint32_t result = 0; 4858 if (getEffectChain_l(sessionId) != 0) { 4859 result = EFFECT_SESSION; 4860 } 4861 4862 if (mTrack != NULL && sessionId == mTrack->sessionId()) { 4863 result |= TRACK_SESSION; 4864 } 4865 4866 return result; 4867 } 4868 4869 AudioFlinger::RecordThread::RecordTrack* AudioFlinger::RecordThread::track() 4870 { 4871 Mutex::Autolock _l(mLock); 4872 return mTrack; 4873 } 4874 4875 AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::getInput() 4876 { 4877 Mutex::Autolock _l(mLock); 4878 return mInput; 4879 } 4880 4881 AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput() 4882 { 4883 Mutex::Autolock _l(mLock); 4884 AudioStreamIn *input = mInput; 4885 mInput = NULL; 4886 return input; 4887 } 4888 4889 // this method must always be called either with ThreadBase mLock held or inside the thread loop 4890 audio_stream_t* AudioFlinger::RecordThread::stream() 4891 { 4892 if (mInput == NULL) { 4893 return NULL; 4894 } 4895 return &mInput->stream->common; 4896 } 4897 4898 4899 // ---------------------------------------------------------------------------- 4900 4901 int AudioFlinger::openOutput(uint32_t *pDevices, 4902 uint32_t *pSamplingRate, 4903 uint32_t *pFormat, 4904 uint32_t *pChannels, 4905 uint32_t *pLatencyMs, 4906 uint32_t flags) 4907 { 4908 status_t status; 4909 PlaybackThread *thread = NULL; 4910 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN; 4911 uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0; 4912 uint32_t format = pFormat ? *pFormat : 0; 4913 uint32_t channels = pChannels ? *pChannels : 0; 4914 uint32_t latency = pLatencyMs ? *pLatencyMs : 0; 4915 audio_stream_out_t *outStream; 4916 audio_hw_device_t *outHwDev; 4917 4918 LOGV("openOutput(), Device %x, SamplingRate %d, Format %d, Channels %x, flags %x", 4919 pDevices ? *pDevices : 0, 4920 samplingRate, 4921 format, 4922 channels, 4923 flags); 4924 4925 if (pDevices == NULL || *pDevices == 0) { 4926 return 0; 4927 } 4928 4929 Mutex::Autolock _l(mLock); 4930 4931 outHwDev = findSuitableHwDev_l(*pDevices); 4932 if (outHwDev == NULL) 4933 return 0; 4934 4935 status = outHwDev->open_output_stream(outHwDev, *pDevices, (int *)&format, 4936 &channels, &samplingRate, &outStream); 4937 LOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %d, Channels %x, status %d", 4938 outStream, 4939 samplingRate, 4940 format, 4941 channels, 4942 status); 4943 4944 mHardwareStatus = AUDIO_HW_IDLE; 4945 if (outStream != NULL) { 4946 AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream); 4947 int id = nextUniqueId(); 4948 4949 if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) || 4950 (format != AUDIO_FORMAT_PCM_16_BIT) || 4951 (channels != AUDIO_CHANNEL_OUT_STEREO)) { 4952 thread = new DirectOutputThread(this, output, id, *pDevices); 4953 LOGV("openOutput() created direct output: ID %d thread %p", id, thread); 4954 } else { 4955 thread = new MixerThread(this, output, id, *pDevices); 4956 LOGV("openOutput() created mixer output: ID %d thread %p", id, thread); 4957 } 4958 mPlaybackThreads.add(id, thread); 4959 4960 if (pSamplingRate) *pSamplingRate = samplingRate; 4961 if (pFormat) *pFormat = format; 4962 if (pChannels) *pChannels = channels; 4963 if (pLatencyMs) *pLatencyMs = thread->latency(); 4964 4965 // notify client processes of the new output creation 4966 thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED); 4967 return id; 4968 } 4969 4970 return 0; 4971 } 4972 4973 int AudioFlinger::openDuplicateOutput(int output1, int output2) 4974 { 4975 Mutex::Autolock _l(mLock); 4976 MixerThread *thread1 = checkMixerThread_l(output1); 4977 MixerThread *thread2 = checkMixerThread_l(output2); 4978 4979 if (thread1 == NULL || thread2 == NULL) { 4980 LOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, output2); 4981 return 0; 4982 } 4983 4984 int id = nextUniqueId(); 4985 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id); 4986 thread->addOutputTrack(thread2); 4987 mPlaybackThreads.add(id, thread); 4988 // notify client processes of the new output creation 4989 thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED); 4990 return id; 4991 } 4992 4993 status_t AudioFlinger::closeOutput(int output) 4994 { 4995 // keep strong reference on the playback thread so that 4996 // it is not destroyed while exit() is executed 4997 sp <PlaybackThread> thread; 4998 { 4999 Mutex::Autolock _l(mLock); 5000 thread = checkPlaybackThread_l(output); 5001 if (thread == NULL) { 5002 return BAD_VALUE; 5003 } 5004 5005 LOGV("closeOutput() %d", output); 5006 5007 if (thread->type() == ThreadBase::MIXER) { 5008 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 5009 if (mPlaybackThreads.valueAt(i)->type() == ThreadBase::DUPLICATING) { 5010 DuplicatingThread *dupThread = (DuplicatingThread *)mPlaybackThreads.valueAt(i).get(); 5011 dupThread->removeOutputTrack((MixerThread *)thread.get()); 5012 } 5013 } 5014 } 5015 void *param2 = 0; 5016 audioConfigChanged_l(AudioSystem::OUTPUT_CLOSED, output, param2); 5017 mPlaybackThreads.removeItem(output); 5018 } 5019 thread->exit(); 5020 5021 if (thread->type() != ThreadBase::DUPLICATING) { 5022 AudioStreamOut *out = thread->clearOutput(); 5023 // from now on thread->mOutput is NULL 5024 out->hwDev->close_output_stream(out->hwDev, out->stream); 5025 delete out; 5026 } 5027 return NO_ERROR; 5028 } 5029 5030 status_t AudioFlinger::suspendOutput(int output) 5031 { 5032 Mutex::Autolock _l(mLock); 5033 PlaybackThread *thread = checkPlaybackThread_l(output); 5034 5035 if (thread == NULL) { 5036 return BAD_VALUE; 5037 } 5038 5039 LOGV("suspendOutput() %d", output); 5040 thread->suspend(); 5041 5042 return NO_ERROR; 5043 } 5044 5045 status_t AudioFlinger::restoreOutput(int output) 5046 { 5047 Mutex::Autolock _l(mLock); 5048 PlaybackThread *thread = checkPlaybackThread_l(output); 5049 5050 if (thread == NULL) { 5051 return BAD_VALUE; 5052 } 5053 5054 LOGV("restoreOutput() %d", output); 5055 5056 thread->restore(); 5057 5058 return NO_ERROR; 5059 } 5060 5061 int AudioFlinger::openInput(uint32_t *pDevices, 5062 uint32_t *pSamplingRate, 5063 uint32_t *pFormat, 5064 uint32_t *pChannels, 5065 uint32_t acoustics) 5066 { 5067 status_t status; 5068 RecordThread *thread = NULL; 5069 uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0; 5070 uint32_t format = pFormat ? *pFormat : 0; 5071 uint32_t channels = pChannels ? *pChannels : 0; 5072 uint32_t reqSamplingRate = samplingRate; 5073 uint32_t reqFormat = format; 5074 uint32_t reqChannels = channels; 5075 audio_stream_in_t *inStream; 5076 audio_hw_device_t *inHwDev; 5077 5078 if (pDevices == NULL || *pDevices == 0) { 5079 return 0; 5080 } 5081 5082 Mutex::Autolock _l(mLock); 5083 5084 inHwDev = findSuitableHwDev_l(*pDevices); 5085 if (inHwDev == NULL) 5086 return 0; 5087 5088 status = inHwDev->open_input_stream(inHwDev, *pDevices, (int *)&format, 5089 &channels, &samplingRate, 5090 (audio_in_acoustics_t)acoustics, 5091 &inStream); 5092 LOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %d, Channels %x, acoustics %x, status %d", 5093 inStream, 5094 samplingRate, 5095 format, 5096 channels, 5097 acoustics, 5098 status); 5099 5100 // If the input could not be opened with the requested parameters and we can handle the conversion internally, 5101 // try to open again with the proposed parameters. The AudioFlinger can resample the input and do mono to stereo 5102 // or stereo to mono conversions on 16 bit PCM inputs. 5103 if (inStream == NULL && status == BAD_VALUE && 5104 reqFormat == format && format == AUDIO_FORMAT_PCM_16_BIT && 5105 (samplingRate <= 2 * reqSamplingRate) && 5106 (popcount(channels) < 3) && (popcount(reqChannels) < 3)) { 5107 LOGV("openInput() reopening with proposed sampling rate and channels"); 5108 status = inHwDev->open_input_stream(inHwDev, *pDevices, (int *)&format, 5109 &channels, &samplingRate, 5110 (audio_in_acoustics_t)acoustics, 5111 &inStream); 5112 } 5113 5114 if (inStream != NULL) { 5115 AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream); 5116 5117 int id = nextUniqueId(); 5118 // Start record thread 5119 // RecorThread require both input and output device indication to forward to audio 5120 // pre processing modules 5121 uint32_t device = (*pDevices) | primaryOutputDevice_l(); 5122 thread = new RecordThread(this, 5123 input, 5124 reqSamplingRate, 5125 reqChannels, 5126 id, 5127 device); 5128 mRecordThreads.add(id, thread); 5129 LOGV("openInput() created record thread: ID %d thread %p", id, thread); 5130 if (pSamplingRate) *pSamplingRate = reqSamplingRate; 5131 if (pFormat) *pFormat = format; 5132 if (pChannels) *pChannels = reqChannels; 5133 5134 input->stream->common.standby(&input->stream->common); 5135 5136 // notify client processes of the new input creation 5137 thread->audioConfigChanged_l(AudioSystem::INPUT_OPENED); 5138 return id; 5139 } 5140 5141 return 0; 5142 } 5143 5144 status_t AudioFlinger::closeInput(int input) 5145 { 5146 // keep strong reference on the record thread so that 5147 // it is not destroyed while exit() is executed 5148 sp <RecordThread> thread; 5149 { 5150 Mutex::Autolock _l(mLock); 5151 thread = checkRecordThread_l(input); 5152 if (thread == NULL) { 5153 return BAD_VALUE; 5154 } 5155 5156 LOGV("closeInput() %d", input); 5157 void *param2 = 0; 5158 audioConfigChanged_l(AudioSystem::INPUT_CLOSED, input, param2); 5159 mRecordThreads.removeItem(input); 5160 } 5161 thread->exit(); 5162 5163 AudioStreamIn *in = thread->clearInput(); 5164 // from now on thread->mInput is NULL 5165 in->hwDev->close_input_stream(in->hwDev, in->stream); 5166 delete in; 5167 5168 return NO_ERROR; 5169 } 5170 5171 status_t AudioFlinger::setStreamOutput(uint32_t stream, int output) 5172 { 5173 Mutex::Autolock _l(mLock); 5174 MixerThread *dstThread = checkMixerThread_l(output); 5175 if (dstThread == NULL) { 5176 LOGW("setStreamOutput() bad output id %d", output); 5177 return BAD_VALUE; 5178 } 5179 5180 LOGV("setStreamOutput() stream %d to output %d", stream, output); 5181 audioConfigChanged_l(AudioSystem::STREAM_CONFIG_CHANGED, output, &stream); 5182 5183 dstThread->setStreamValid(stream, true); 5184 5185 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 5186 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 5187 if (thread != dstThread && 5188 thread->type() != ThreadBase::DIRECT) { 5189 MixerThread *srcThread = (MixerThread *)thread; 5190 srcThread->setStreamValid(stream, false); 5191 srcThread->invalidateTracks(stream); 5192 } 5193 } 5194 5195 return NO_ERROR; 5196 } 5197 5198 5199 int AudioFlinger::newAudioSessionId() 5200 { 5201 return nextUniqueId(); 5202 } 5203 5204 void AudioFlinger::acquireAudioSessionId(int audioSession) 5205 { 5206 Mutex::Autolock _l(mLock); 5207 int caller = IPCThreadState::self()->getCallingPid(); 5208 LOGV("acquiring %d from %d", audioSession, caller); 5209 int num = mAudioSessionRefs.size(); 5210 for (int i = 0; i< num; i++) { 5211 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i); 5212 if (ref->sessionid == audioSession && ref->pid == caller) { 5213 ref->cnt++; 5214 LOGV(" incremented refcount to %d", ref->cnt); 5215 return; 5216 } 5217 } 5218 AudioSessionRef *ref = new AudioSessionRef(); 5219 ref->sessionid = audioSession; 5220 ref->pid = caller; 5221 ref->cnt = 1; 5222 mAudioSessionRefs.push(ref); 5223 LOGV(" added new entry for %d", ref->sessionid); 5224 } 5225 5226 void AudioFlinger::releaseAudioSessionId(int audioSession) 5227 { 5228 Mutex::Autolock _l(mLock); 5229 int caller = IPCThreadState::self()->getCallingPid(); 5230 LOGV("releasing %d from %d", audioSession, caller); 5231 int num = mAudioSessionRefs.size(); 5232 for (int i = 0; i< num; i++) { 5233 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i); 5234 if (ref->sessionid == audioSession && ref->pid == caller) { 5235 ref->cnt--; 5236 LOGV(" decremented refcount to %d", ref->cnt); 5237 if (ref->cnt == 0) { 5238 mAudioSessionRefs.removeAt(i); 5239 delete ref; 5240 purgeStaleEffects_l(); 5241 } 5242 return; 5243 } 5244 } 5245 LOGW("session id %d not found for pid %d", audioSession, caller); 5246 } 5247 5248 void AudioFlinger::purgeStaleEffects_l() { 5249 5250 LOGV("purging stale effects"); 5251 5252 Vector< sp<EffectChain> > chains; 5253 5254 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 5255 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 5256 for (size_t j = 0; j < t->mEffectChains.size(); j++) { 5257 sp<EffectChain> ec = t->mEffectChains[j]; 5258 if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) { 5259 chains.push(ec); 5260 } 5261 } 5262 } 5263 for (size_t i = 0; i < mRecordThreads.size(); i++) { 5264 sp<RecordThread> t = mRecordThreads.valueAt(i); 5265 for (size_t j = 0; j < t->mEffectChains.size(); j++) { 5266 sp<EffectChain> ec = t->mEffectChains[j]; 5267 chains.push(ec); 5268 } 5269 } 5270 5271 for (size_t i = 0; i < chains.size(); i++) { 5272 sp<EffectChain> ec = chains[i]; 5273 int sessionid = ec->sessionId(); 5274 sp<ThreadBase> t = ec->mThread.promote(); 5275 if (t == 0) { 5276 continue; 5277 } 5278 size_t numsessionrefs = mAudioSessionRefs.size(); 5279 bool found = false; 5280 for (size_t k = 0; k < numsessionrefs; k++) { 5281 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k); 5282 if (ref->sessionid == sessionid) { 5283 LOGV(" session %d still exists for %d with %d refs", 5284 sessionid, ref->pid, ref->cnt); 5285 found = true; 5286 break; 5287 } 5288 } 5289 if (!found) { 5290 // remove all effects from the chain 5291 while (ec->mEffects.size()) { 5292 sp<EffectModule> effect = ec->mEffects[0]; 5293 effect->unPin(); 5294 Mutex::Autolock _l (t->mLock); 5295 t->removeEffect_l(effect); 5296 for (size_t j = 0; j < effect->mHandles.size(); j++) { 5297 sp<EffectHandle> handle = effect->mHandles[j].promote(); 5298 if (handle != 0) { 5299 handle->mEffect.clear(); 5300 if (handle->mHasControl && handle->mEnabled) { 5301 t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId()); 5302 } 5303 } 5304 } 5305 AudioSystem::unregisterEffect(effect->id()); 5306 } 5307 } 5308 } 5309 return; 5310 } 5311 5312 // checkPlaybackThread_l() must be called with AudioFlinger::mLock held 5313 AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(int output) const 5314 { 5315 PlaybackThread *thread = NULL; 5316 if (mPlaybackThreads.indexOfKey(output) >= 0) { 5317 thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get(); 5318 } 5319 return thread; 5320 } 5321 5322 // checkMixerThread_l() must be called with AudioFlinger::mLock held 5323 AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(int output) const 5324 { 5325 PlaybackThread *thread = checkPlaybackThread_l(output); 5326 if (thread != NULL) { 5327 if (thread->type() == ThreadBase::DIRECT) { 5328 thread = NULL; 5329 } 5330 } 5331 return (MixerThread *)thread; 5332 } 5333 5334 // checkRecordThread_l() must be called with AudioFlinger::mLock held 5335 AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(int input) const 5336 { 5337 RecordThread *thread = NULL; 5338 if (mRecordThreads.indexOfKey(input) >= 0) { 5339 thread = (RecordThread *)mRecordThreads.valueFor(input).get(); 5340 } 5341 return thread; 5342 } 5343 5344 uint32_t AudioFlinger::nextUniqueId() 5345 { 5346 return android_atomic_inc(&mNextUniqueId); 5347 } 5348 5349 AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() 5350 { 5351 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 5352 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 5353 AudioStreamOut *output = thread->getOutput(); 5354 if (output != NULL && output->hwDev == mPrimaryHardwareDev) { 5355 return thread; 5356 } 5357 } 5358 return NULL; 5359 } 5360 5361 uint32_t AudioFlinger::primaryOutputDevice_l() 5362 { 5363 PlaybackThread *thread = primaryPlaybackThread_l(); 5364 5365 if (thread == NULL) { 5366 return 0; 5367 } 5368 5369 return thread->device(); 5370 } 5371 5372 5373 // ---------------------------------------------------------------------------- 5374 // Effect management 5375 // ---------------------------------------------------------------------------- 5376 5377 5378 status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) 5379 { 5380 Mutex::Autolock _l(mLock); 5381 return EffectQueryNumberEffects(numEffects); 5382 } 5383 5384 status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) 5385 { 5386 Mutex::Autolock _l(mLock); 5387 return EffectQueryEffect(index, descriptor); 5388 } 5389 5390 status_t AudioFlinger::getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor) 5391 { 5392 Mutex::Autolock _l(mLock); 5393 return EffectGetDescriptor(pUuid, descriptor); 5394 } 5395 5396 5397 sp<IEffect> AudioFlinger::createEffect(pid_t pid, 5398 effect_descriptor_t *pDesc, 5399 const sp<IEffectClient>& effectClient, 5400 int32_t priority, 5401 int io, 5402 int sessionId, 5403 status_t *status, 5404 int *id, 5405 int *enabled) 5406 { 5407 status_t lStatus = NO_ERROR; 5408 sp<EffectHandle> handle; 5409 effect_descriptor_t desc; 5410 sp<Client> client; 5411 wp<Client> wclient; 5412 5413 LOGV("createEffect pid %d, client %p, priority %d, sessionId %d, io %d", 5414 pid, effectClient.get(), priority, sessionId, io); 5415 5416 if (pDesc == NULL) { 5417 lStatus = BAD_VALUE; 5418 goto Exit; 5419 } 5420 5421 // check audio settings permission for global effects 5422 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) { 5423 lStatus = PERMISSION_DENIED; 5424 goto Exit; 5425 } 5426 5427 // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects 5428 // that can only be created by audio policy manager (running in same process) 5429 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid() != pid) { 5430 lStatus = PERMISSION_DENIED; 5431 goto Exit; 5432 } 5433 5434 if (io == 0) { 5435 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) { 5436 // output must be specified by AudioPolicyManager when using session 5437 // AUDIO_SESSION_OUTPUT_STAGE 5438 lStatus = BAD_VALUE; 5439 goto Exit; 5440 } else if (sessionId == AUDIO_SESSION_OUTPUT_MIX) { 5441 // if the output returned by getOutputForEffect() is removed before we lock the 5442 // mutex below, the call to checkPlaybackThread_l(io) below will detect it 5443 // and we will exit safely 5444 io = AudioSystem::getOutputForEffect(&desc); 5445 } 5446 } 5447 5448 { 5449 Mutex::Autolock _l(mLock); 5450 5451 5452 if (!EffectIsNullUuid(&pDesc->uuid)) { 5453 // if uuid is specified, request effect descriptor 5454 lStatus = EffectGetDescriptor(&pDesc->uuid, &desc); 5455 if (lStatus < 0) { 5456 LOGW("createEffect() error %d from EffectGetDescriptor", lStatus); 5457 goto Exit; 5458 } 5459 } else { 5460 // if uuid is not specified, look for an available implementation 5461 // of the required type in effect factory 5462 if (EffectIsNullUuid(&pDesc->type)) { 5463 LOGW("createEffect() no effect type"); 5464 lStatus = BAD_VALUE; 5465 goto Exit; 5466 } 5467 uint32_t numEffects = 0; 5468 effect_descriptor_t d; 5469 d.flags = 0; // prevent compiler warning 5470 bool found = false; 5471 5472 lStatus = EffectQueryNumberEffects(&numEffects); 5473 if (lStatus < 0) { 5474 LOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus); 5475 goto Exit; 5476 } 5477 for (uint32_t i = 0; i < numEffects; i++) { 5478 lStatus = EffectQueryEffect(i, &desc); 5479 if (lStatus < 0) { 5480 LOGW("createEffect() error %d from EffectQueryEffect", lStatus); 5481 continue; 5482 } 5483 if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) { 5484 // If matching type found save effect descriptor. If the session is 5485 // 0 and the effect is not auxiliary, continue enumeration in case 5486 // an auxiliary version of this effect type is available 5487 found = true; 5488 memcpy(&d, &desc, sizeof(effect_descriptor_t)); 5489 if (sessionId != AUDIO_SESSION_OUTPUT_MIX || 5490 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 5491 break; 5492 } 5493 } 5494 } 5495 if (!found) { 5496 lStatus = BAD_VALUE; 5497 LOGW("createEffect() effect not found"); 5498 goto Exit; 5499 } 5500 // For same effect type, chose auxiliary version over insert version if 5501 // connect to output mix (Compliance to OpenSL ES) 5502 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && 5503 (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) { 5504 memcpy(&desc, &d, sizeof(effect_descriptor_t)); 5505 } 5506 } 5507 5508 // Do not allow auxiliary effects on a session different from 0 (output mix) 5509 if (sessionId != AUDIO_SESSION_OUTPUT_MIX && 5510 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 5511 lStatus = INVALID_OPERATION; 5512 goto Exit; 5513 } 5514 5515 // check recording permission for visualizer 5516 if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) && 5517 !recordingAllowed()) { 5518 lStatus = PERMISSION_DENIED; 5519 goto Exit; 5520 } 5521 5522 // return effect descriptor 5523 memcpy(pDesc, &desc, sizeof(effect_descriptor_t)); 5524 5525 // If output is not specified try to find a matching audio session ID in one of the 5526 // output threads. 5527 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX 5528 // because of code checking output when entering the function. 5529 // Note: io is never 0 when creating an effect on an input 5530 if (io == 0) { 5531 // look for the thread where the specified audio session is present 5532 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 5533 if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) { 5534 io = mPlaybackThreads.keyAt(i); 5535 break; 5536 } 5537 } 5538 if (io == 0) { 5539 for (size_t i = 0; i < mRecordThreads.size(); i++) { 5540 if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) { 5541 io = mRecordThreads.keyAt(i); 5542 break; 5543 } 5544 } 5545 } 5546 // If no output thread contains the requested session ID, default to 5547 // first output. The effect chain will be moved to the correct output 5548 // thread when a track with the same session ID is created 5549 if (io == 0 && mPlaybackThreads.size()) { 5550 io = mPlaybackThreads.keyAt(0); 5551 } 5552 LOGV("createEffect() got io %d for effect %s", io, desc.name); 5553 } 5554 ThreadBase *thread = checkRecordThread_l(io); 5555 if (thread == NULL) { 5556 thread = checkPlaybackThread_l(io); 5557 if (thread == NULL) { 5558 LOGE("createEffect() unknown output thread"); 5559 lStatus = BAD_VALUE; 5560 goto Exit; 5561 } 5562 } 5563 5564 wclient = mClients.valueFor(pid); 5565 5566 if (wclient != NULL) { 5567 client = wclient.promote(); 5568 } else { 5569 client = new Client(this, pid); 5570 mClients.add(pid, client); 5571 } 5572 5573 // create effect on selected output thread 5574 handle = thread->createEffect_l(client, effectClient, priority, sessionId, 5575 &desc, enabled, &lStatus); 5576 if (handle != 0 && id != NULL) { 5577 *id = handle->id(); 5578 } 5579 } 5580 5581 Exit: 5582 if(status) { 5583 *status = lStatus; 5584 } 5585 return handle; 5586 } 5587 5588 status_t AudioFlinger::moveEffects(int sessionId, int srcOutput, int dstOutput) 5589 { 5590 LOGV("moveEffects() session %d, srcOutput %d, dstOutput %d", 5591 sessionId, srcOutput, dstOutput); 5592 Mutex::Autolock _l(mLock); 5593 if (srcOutput == dstOutput) { 5594 LOGW("moveEffects() same dst and src outputs %d", dstOutput); 5595 return NO_ERROR; 5596 } 5597 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput); 5598 if (srcThread == NULL) { 5599 LOGW("moveEffects() bad srcOutput %d", srcOutput); 5600 return BAD_VALUE; 5601 } 5602 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput); 5603 if (dstThread == NULL) { 5604 LOGW("moveEffects() bad dstOutput %d", dstOutput); 5605 return BAD_VALUE; 5606 } 5607 5608 Mutex::Autolock _dl(dstThread->mLock); 5609 Mutex::Autolock _sl(srcThread->mLock); 5610 moveEffectChain_l(sessionId, srcThread, dstThread, false); 5611 5612 return NO_ERROR; 5613 } 5614 5615 // moveEffectChain_l must be called with both srcThread and dstThread mLocks held 5616 status_t AudioFlinger::moveEffectChain_l(int sessionId, 5617 AudioFlinger::PlaybackThread *srcThread, 5618 AudioFlinger::PlaybackThread *dstThread, 5619 bool reRegister) 5620 { 5621 LOGV("moveEffectChain_l() session %d from thread %p to thread %p", 5622 sessionId, srcThread, dstThread); 5623 5624 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId); 5625 if (chain == 0) { 5626 LOGW("moveEffectChain_l() effect chain for session %d not on source thread %p", 5627 sessionId, srcThread); 5628 return INVALID_OPERATION; 5629 } 5630 5631 // remove chain first. This is useful only if reconfiguring effect chain on same output thread, 5632 // so that a new chain is created with correct parameters when first effect is added. This is 5633 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is 5634 // removed. 5635 srcThread->removeEffectChain_l(chain); 5636 5637 // transfer all effects one by one so that new effect chain is created on new thread with 5638 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly 5639 int dstOutput = dstThread->id(); 5640 sp<EffectChain> dstChain; 5641 uint32_t strategy = 0; // prevent compiler warning 5642 sp<EffectModule> effect = chain->getEffectFromId_l(0); 5643 while (effect != 0) { 5644 srcThread->removeEffect_l(effect); 5645 dstThread->addEffect_l(effect); 5646 // removeEffect_l() has stopped the effect if it was active so it must be restarted 5647 if (effect->state() == EffectModule::ACTIVE || 5648 effect->state() == EffectModule::STOPPING) { 5649 effect->start(); 5650 } 5651 // if the move request is not received from audio policy manager, the effect must be 5652 // re-registered with the new strategy and output 5653 if (dstChain == 0) { 5654 dstChain = effect->chain().promote(); 5655 if (dstChain == 0) { 5656 LOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get()); 5657 srcThread->addEffect_l(effect); 5658 return NO_INIT; 5659 } 5660 strategy = dstChain->strategy(); 5661 } 5662 if (reRegister) { 5663 AudioSystem::unregisterEffect(effect->id()); 5664 AudioSystem::registerEffect(&effect->desc(), 5665 dstOutput, 5666 strategy, 5667 sessionId, 5668 effect->id()); 5669 } 5670 effect = chain->getEffectFromId_l(0); 5671 } 5672 5673 return NO_ERROR; 5674 } 5675 5676 5677 // PlaybackThread::createEffect_l() must be called with AudioFlinger::mLock held 5678 sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l( 5679 const sp<AudioFlinger::Client>& client, 5680 const sp<IEffectClient>& effectClient, 5681 int32_t priority, 5682 int sessionId, 5683 effect_descriptor_t *desc, 5684 int *enabled, 5685 status_t *status 5686 ) 5687 { 5688 sp<EffectModule> effect; 5689 sp<EffectHandle> handle; 5690 status_t lStatus; 5691 sp<EffectChain> chain; 5692 bool chainCreated = false; 5693 bool effectCreated = false; 5694 bool effectRegistered = false; 5695 5696 lStatus = initCheck(); 5697 if (lStatus != NO_ERROR) { 5698 LOGW("createEffect_l() Audio driver not initialized."); 5699 goto Exit; 5700 } 5701 5702 // Do not allow effects with session ID 0 on direct output or duplicating threads 5703 // TODO: add rule for hw accelerated effects on direct outputs with non PCM format 5704 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && mType != MIXER) { 5705 LOGW("createEffect_l() Cannot add auxiliary effect %s to session %d", 5706 desc->name, sessionId); 5707 lStatus = BAD_VALUE; 5708 goto Exit; 5709 } 5710 // Only Pre processor effects are allowed on input threads and only on input threads 5711 if ((mType == RECORD && 5712 (desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC) || 5713 (mType != RECORD && 5714 (desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) { 5715 LOGW("createEffect_l() effect %s (flags %08x) created on wrong thread type %d", 5716 desc->name, desc->flags, mType); 5717 lStatus = BAD_VALUE; 5718 goto Exit; 5719 } 5720 5721 LOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId); 5722 5723 { // scope for mLock 5724 Mutex::Autolock _l(mLock); 5725 5726 // check for existing effect chain with the requested audio session 5727 chain = getEffectChain_l(sessionId); 5728 if (chain == 0) { 5729 // create a new chain for this session 5730 LOGV("createEffect_l() new effect chain for session %d", sessionId); 5731 chain = new EffectChain(this, sessionId); 5732 addEffectChain_l(chain); 5733 chain->setStrategy(getStrategyForSession_l(sessionId)); 5734 chainCreated = true; 5735 } else { 5736 effect = chain->getEffectFromDesc_l(desc); 5737 } 5738 5739 LOGV("createEffect_l() got effect %p on chain %p", effect == 0 ? 0 : effect.get(), chain.get()); 5740 5741 if (effect == 0) { 5742 int id = mAudioFlinger->nextUniqueId(); 5743 // Check CPU and memory usage 5744 lStatus = AudioSystem::registerEffect(desc, mId, chain->strategy(), sessionId, id); 5745 if (lStatus != NO_ERROR) { 5746 goto Exit; 5747 } 5748 effectRegistered = true; 5749 // create a new effect module if none present in the chain 5750 effect = new EffectModule(this, chain, desc, id, sessionId); 5751 lStatus = effect->status(); 5752 if (lStatus != NO_ERROR) { 5753 goto Exit; 5754 } 5755 lStatus = chain->addEffect_l(effect); 5756 if (lStatus != NO_ERROR) { 5757 goto Exit; 5758 } 5759 effectCreated = true; 5760 5761 effect->setDevice(mDevice); 5762 effect->setMode(mAudioFlinger->getMode()); 5763 } 5764 // create effect handle and connect it to effect module 5765 handle = new EffectHandle(effect, client, effectClient, priority); 5766 lStatus = effect->addHandle(handle); 5767 if (enabled) { 5768 *enabled = (int)effect->isEnabled(); 5769 } 5770 } 5771 5772 Exit: 5773 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) { 5774 Mutex::Autolock _l(mLock); 5775 if (effectCreated) { 5776 chain->removeEffect_l(effect); 5777 } 5778 if (effectRegistered) { 5779 AudioSystem::unregisterEffect(effect->id()); 5780 } 5781 if (chainCreated) { 5782 removeEffectChain_l(chain); 5783 } 5784 handle.clear(); 5785 } 5786 5787 if(status) { 5788 *status = lStatus; 5789 } 5790 return handle; 5791 } 5792 5793 sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(int sessionId, int effectId) 5794 { 5795 sp<EffectModule> effect; 5796 5797 sp<EffectChain> chain = getEffectChain_l(sessionId); 5798 if (chain != 0) { 5799 effect = chain->getEffectFromId_l(effectId); 5800 } 5801 return effect; 5802 } 5803 5804 // PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and 5805 // PlaybackThread::mLock held 5806 status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect) 5807 { 5808 // check for existing effect chain with the requested audio session 5809 int sessionId = effect->sessionId(); 5810 sp<EffectChain> chain = getEffectChain_l(sessionId); 5811 bool chainCreated = false; 5812 5813 if (chain == 0) { 5814 // create a new chain for this session 5815 LOGV("addEffect_l() new effect chain for session %d", sessionId); 5816 chain = new EffectChain(this, sessionId); 5817 addEffectChain_l(chain); 5818 chain->setStrategy(getStrategyForSession_l(sessionId)); 5819 chainCreated = true; 5820 } 5821 LOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get()); 5822 5823 if (chain->getEffectFromId_l(effect->id()) != 0) { 5824 LOGW("addEffect_l() %p effect %s already present in chain %p", 5825 this, effect->desc().name, chain.get()); 5826 return BAD_VALUE; 5827 } 5828 5829 status_t status = chain->addEffect_l(effect); 5830 if (status != NO_ERROR) { 5831 if (chainCreated) { 5832 removeEffectChain_l(chain); 5833 } 5834 return status; 5835 } 5836 5837 effect->setDevice(mDevice); 5838 effect->setMode(mAudioFlinger->getMode()); 5839 return NO_ERROR; 5840 } 5841 5842 void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect) { 5843 5844 LOGV("removeEffect_l() %p effect %p", this, effect.get()); 5845 effect_descriptor_t desc = effect->desc(); 5846 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 5847 detachAuxEffect_l(effect->id()); 5848 } 5849 5850 sp<EffectChain> chain = effect->chain().promote(); 5851 if (chain != 0) { 5852 // remove effect chain if removing last effect 5853 if (chain->removeEffect_l(effect) == 0) { 5854 removeEffectChain_l(chain); 5855 } 5856 } else { 5857 LOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get()); 5858 } 5859 } 5860 5861 void AudioFlinger::ThreadBase::lockEffectChains_l( 5862 Vector<sp <AudioFlinger::EffectChain> >& effectChains) 5863 { 5864 effectChains = mEffectChains; 5865 for (size_t i = 0; i < mEffectChains.size(); i++) { 5866 mEffectChains[i]->lock(); 5867 } 5868 } 5869 5870 void AudioFlinger::ThreadBase::unlockEffectChains( 5871 Vector<sp <AudioFlinger::EffectChain> >& effectChains) 5872 { 5873 for (size_t i = 0; i < effectChains.size(); i++) { 5874 effectChains[i]->unlock(); 5875 } 5876 } 5877 5878 sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(int sessionId) 5879 { 5880 Mutex::Autolock _l(mLock); 5881 return getEffectChain_l(sessionId); 5882 } 5883 5884 sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(int sessionId) 5885 { 5886 sp<EffectChain> chain; 5887 5888 size_t size = mEffectChains.size(); 5889 for (size_t i = 0; i < size; i++) { 5890 if (mEffectChains[i]->sessionId() == sessionId) { 5891 chain = mEffectChains[i]; 5892 break; 5893 } 5894 } 5895 return chain; 5896 } 5897 5898 void AudioFlinger::ThreadBase::setMode(uint32_t mode) 5899 { 5900 Mutex::Autolock _l(mLock); 5901 size_t size = mEffectChains.size(); 5902 for (size_t i = 0; i < size; i++) { 5903 mEffectChains[i]->setMode_l(mode); 5904 } 5905 } 5906 5907 void AudioFlinger::ThreadBase::disconnectEffect(const sp<EffectModule>& effect, 5908 const wp<EffectHandle>& handle, 5909 bool unpiniflast) { 5910 5911 Mutex::Autolock _l(mLock); 5912 LOGV("disconnectEffect() %p effect %p", this, effect.get()); 5913 // delete the effect module if removing last handle on it 5914 if (effect->removeHandle(handle) == 0) { 5915 if (!effect->isPinned() || unpiniflast) { 5916 removeEffect_l(effect); 5917 AudioSystem::unregisterEffect(effect->id()); 5918 } 5919 } 5920 } 5921 5922 status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain) 5923 { 5924 int session = chain->sessionId(); 5925 int16_t *buffer = mMixBuffer; 5926 bool ownsBuffer = false; 5927 5928 LOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session); 5929 if (session > 0) { 5930 // Only one effect chain can be present in direct output thread and it uses 5931 // the mix buffer as input 5932 if (mType != DIRECT) { 5933 size_t numSamples = mFrameCount * mChannelCount; 5934 buffer = new int16_t[numSamples]; 5935 memset(buffer, 0, numSamples * sizeof(int16_t)); 5936 LOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session); 5937 ownsBuffer = true; 5938 } 5939 5940 // Attach all tracks with same session ID to this chain. 5941 for (size_t i = 0; i < mTracks.size(); ++i) { 5942 sp<Track> track = mTracks[i]; 5943 if (session == track->sessionId()) { 5944 LOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(), buffer); 5945 track->setMainBuffer(buffer); 5946 chain->incTrackCnt(); 5947 } 5948 } 5949 5950 // indicate all active tracks in the chain 5951 for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) { 5952 sp<Track> track = mActiveTracks[i].promote(); 5953 if (track == 0) continue; 5954 if (session == track->sessionId()) { 5955 LOGV("addEffectChain_l() activating track %p on session %d", track.get(), session); 5956 chain->incActiveTrackCnt(); 5957 } 5958 } 5959 } 5960 5961 chain->setInBuffer(buffer, ownsBuffer); 5962 chain->setOutBuffer(mMixBuffer); 5963 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect 5964 // chains list in order to be processed last as it contains output stage effects 5965 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before 5966 // session AUDIO_SESSION_OUTPUT_STAGE to be processed 5967 // after track specific effects and before output stage 5968 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and 5969 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX 5970 // Effect chain for other sessions are inserted at beginning of effect 5971 // chains list to be processed before output mix effects. Relative order between other 5972 // sessions is not important 5973 size_t size = mEffectChains.size(); 5974 size_t i = 0; 5975 for (i = 0; i < size; i++) { 5976 if (mEffectChains[i]->sessionId() < session) break; 5977 } 5978 mEffectChains.insertAt(chain, i); 5979 checkSuspendOnAddEffectChain_l(chain); 5980 5981 return NO_ERROR; 5982 } 5983 5984 size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain) 5985 { 5986 int session = chain->sessionId(); 5987 5988 LOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session); 5989 5990 for (size_t i = 0; i < mEffectChains.size(); i++) { 5991 if (chain == mEffectChains[i]) { 5992 mEffectChains.removeAt(i); 5993 // detach all active tracks from the chain 5994 for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) { 5995 sp<Track> track = mActiveTracks[i].promote(); 5996 if (track == 0) continue; 5997 if (session == track->sessionId()) { 5998 LOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d", 5999 chain.get(), session); 6000 chain->decActiveTrackCnt(); 6001 } 6002 } 6003 6004 // detach all tracks with same session ID from this chain 6005 for (size_t i = 0; i < mTracks.size(); ++i) { 6006 sp<Track> track = mTracks[i]; 6007 if (session == track->sessionId()) { 6008 track->setMainBuffer(mMixBuffer); 6009 chain->decTrackCnt(); 6010 } 6011 } 6012 break; 6013 } 6014 } 6015 return mEffectChains.size(); 6016 } 6017 6018 status_t AudioFlinger::PlaybackThread::attachAuxEffect( 6019 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId) 6020 { 6021 Mutex::Autolock _l(mLock); 6022 return attachAuxEffect_l(track, EffectId); 6023 } 6024 6025 status_t AudioFlinger::PlaybackThread::attachAuxEffect_l( 6026 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId) 6027 { 6028 status_t status = NO_ERROR; 6029 6030 if (EffectId == 0) { 6031 track->setAuxBuffer(0, NULL); 6032 } else { 6033 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX 6034 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId); 6035 if (effect != 0) { 6036 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 6037 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer()); 6038 } else { 6039 status = INVALID_OPERATION; 6040 } 6041 } else { 6042 status = BAD_VALUE; 6043 } 6044 } 6045 return status; 6046 } 6047 6048 void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId) 6049 { 6050 for (size_t i = 0; i < mTracks.size(); ++i) { 6051 sp<Track> track = mTracks[i]; 6052 if (track->auxEffectId() == effectId) { 6053 attachAuxEffect_l(track, 0); 6054 } 6055 } 6056 } 6057 6058 status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain) 6059 { 6060 // only one chain per input thread 6061 if (mEffectChains.size() != 0) { 6062 return INVALID_OPERATION; 6063 } 6064 LOGV("addEffectChain_l() %p on thread %p", chain.get(), this); 6065 6066 chain->setInBuffer(NULL); 6067 chain->setOutBuffer(NULL); 6068 6069 checkSuspendOnAddEffectChain_l(chain); 6070 6071 mEffectChains.add(chain); 6072 6073 return NO_ERROR; 6074 } 6075 6076 size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain) 6077 { 6078 LOGV("removeEffectChain_l() %p from thread %p", chain.get(), this); 6079 LOGW_IF(mEffectChains.size() != 1, 6080 "removeEffectChain_l() %p invalid chain size %d on thread %p", 6081 chain.get(), mEffectChains.size(), this); 6082 if (mEffectChains.size() == 1) { 6083 mEffectChains.removeAt(0); 6084 } 6085 return 0; 6086 } 6087 6088 // ---------------------------------------------------------------------------- 6089 // EffectModule implementation 6090 // ---------------------------------------------------------------------------- 6091 6092 #undef LOG_TAG 6093 #define LOG_TAG "AudioFlinger::EffectModule" 6094 6095 AudioFlinger::EffectModule::EffectModule(const wp<ThreadBase>& wThread, 6096 const wp<AudioFlinger::EffectChain>& chain, 6097 effect_descriptor_t *desc, 6098 int id, 6099 int sessionId) 6100 : mThread(wThread), mChain(chain), mId(id), mSessionId(sessionId), mEffectInterface(NULL), 6101 mStatus(NO_INIT), mState(IDLE), mSuspended(false) 6102 { 6103 LOGV("Constructor %p", this); 6104 int lStatus; 6105 sp<ThreadBase> thread = mThread.promote(); 6106 if (thread == 0) { 6107 return; 6108 } 6109 6110 memcpy(&mDescriptor, desc, sizeof(effect_descriptor_t)); 6111 6112 // create effect engine from effect factory 6113 mStatus = EffectCreate(&desc->uuid, sessionId, thread->id(), &mEffectInterface); 6114 6115 if (mStatus != NO_ERROR) { 6116 return; 6117 } 6118 lStatus = init(); 6119 if (lStatus < 0) { 6120 mStatus = lStatus; 6121 goto Error; 6122 } 6123 6124 if (mSessionId > AUDIO_SESSION_OUTPUT_MIX) { 6125 mPinned = true; 6126 } 6127 LOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface); 6128 return; 6129 Error: 6130 EffectRelease(mEffectInterface); 6131 mEffectInterface = NULL; 6132 LOGV("Constructor Error %d", mStatus); 6133 } 6134 6135 AudioFlinger::EffectModule::~EffectModule() 6136 { 6137 LOGV("Destructor %p", this); 6138 if (mEffectInterface != NULL) { 6139 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC || 6140 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) { 6141 sp<ThreadBase> thread = mThread.promote(); 6142 if (thread != 0) { 6143 audio_stream_t *stream = thread->stream(); 6144 if (stream != NULL) { 6145 stream->remove_audio_effect(stream, mEffectInterface); 6146 } 6147 } 6148 } 6149 // release effect engine 6150 EffectRelease(mEffectInterface); 6151 } 6152 } 6153 6154 status_t AudioFlinger::EffectModule::addHandle(sp<EffectHandle>& handle) 6155 { 6156 status_t status; 6157 6158 Mutex::Autolock _l(mLock); 6159 // First handle in mHandles has highest priority and controls the effect module 6160 int priority = handle->priority(); 6161 size_t size = mHandles.size(); 6162 sp<EffectHandle> h; 6163 size_t i; 6164 for (i = 0; i < size; i++) { 6165 h = mHandles[i].promote(); 6166 if (h == 0) continue; 6167 if (h->priority() <= priority) break; 6168 } 6169 // if inserted in first place, move effect control from previous owner to this handle 6170 if (i == 0) { 6171 bool enabled = false; 6172 if (h != 0) { 6173 enabled = h->enabled(); 6174 h->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/); 6175 } 6176 handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/); 6177 status = NO_ERROR; 6178 } else { 6179 status = ALREADY_EXISTS; 6180 } 6181 LOGV("addHandle() %p added handle %p in position %d", this, handle.get(), i); 6182 mHandles.insertAt(handle, i); 6183 return status; 6184 } 6185 6186 size_t AudioFlinger::EffectModule::removeHandle(const wp<EffectHandle>& handle) 6187 { 6188 Mutex::Autolock _l(mLock); 6189 size_t size = mHandles.size(); 6190 size_t i; 6191 for (i = 0; i < size; i++) { 6192 if (mHandles[i] == handle) break; 6193 } 6194 if (i == size) { 6195 return size; 6196 } 6197 LOGV("removeHandle() %p removed handle %p in position %d", this, handle.unsafe_get(), i); 6198 6199 bool enabled = false; 6200 EffectHandle *hdl = handle.unsafe_get(); 6201 if (hdl) { 6202 LOGV("removeHandle() unsafe_get OK"); 6203 enabled = hdl->enabled(); 6204 } 6205 mHandles.removeAt(i); 6206 size = mHandles.size(); 6207 // if removed from first place, move effect control from this handle to next in line 6208 if (i == 0 && size != 0) { 6209 sp<EffectHandle> h = mHandles[0].promote(); 6210 if (h != 0) { 6211 h->setControl(true /*hasControl*/, true /*signal*/ , enabled /*enabled*/); 6212 } 6213 } 6214 6215 // Prevent calls to process() and other functions on effect interface from now on. 6216 // The effect engine will be released by the destructor when the last strong reference on 6217 // this object is released which can happen after next process is called. 6218 if (size == 0 && !mPinned) { 6219 mState = DESTROYED; 6220 } 6221 6222 return size; 6223 } 6224 6225 sp<AudioFlinger::EffectHandle> AudioFlinger::EffectModule::controlHandle() 6226 { 6227 Mutex::Autolock _l(mLock); 6228 sp<EffectHandle> handle; 6229 if (mHandles.size() != 0) { 6230 handle = mHandles[0].promote(); 6231 } 6232 return handle; 6233 } 6234 6235 void AudioFlinger::EffectModule::disconnect(const wp<EffectHandle>& handle, bool unpiniflast) 6236 { 6237 LOGV("disconnect() %p handle %p ", this, handle.unsafe_get()); 6238 // keep a strong reference on this EffectModule to avoid calling the 6239 // destructor before we exit 6240 sp<EffectModule> keep(this); 6241 { 6242 sp<ThreadBase> thread = mThread.promote(); 6243 if (thread != 0) { 6244 thread->disconnectEffect(keep, handle, unpiniflast); 6245 } 6246 } 6247 } 6248 6249 void AudioFlinger::EffectModule::updateState() { 6250 Mutex::Autolock _l(mLock); 6251 6252 switch (mState) { 6253 case RESTART: 6254 reset_l(); 6255 // FALL THROUGH 6256 6257 case STARTING: 6258 // clear auxiliary effect input buffer for next accumulation 6259 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 6260 memset(mConfig.inputCfg.buffer.raw, 6261 0, 6262 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t)); 6263 } 6264 start_l(); 6265 mState = ACTIVE; 6266 break; 6267 case STOPPING: 6268 stop_l(); 6269 mDisableWaitCnt = mMaxDisableWaitCnt; 6270 mState = STOPPED; 6271 break; 6272 case STOPPED: 6273 // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the 6274 // turn off sequence. 6275 if (--mDisableWaitCnt == 0) { 6276 reset_l(); 6277 mState = IDLE; 6278 } 6279 break; 6280 default: //IDLE , ACTIVE, DESTROYED 6281 break; 6282 } 6283 } 6284 6285 void AudioFlinger::EffectModule::process() 6286 { 6287 Mutex::Autolock _l(mLock); 6288 6289 if (mState == DESTROYED || mEffectInterface == NULL || 6290 mConfig.inputCfg.buffer.raw == NULL || 6291 mConfig.outputCfg.buffer.raw == NULL) { 6292 return; 6293 } 6294 6295 if (isProcessEnabled()) { 6296 // do 32 bit to 16 bit conversion for auxiliary effect input buffer 6297 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 6298 AudioMixer::ditherAndClamp(mConfig.inputCfg.buffer.s32, 6299 mConfig.inputCfg.buffer.s32, 6300 mConfig.inputCfg.buffer.frameCount/2); 6301 } 6302 6303 // do the actual processing in the effect engine 6304 int ret = (*mEffectInterface)->process(mEffectInterface, 6305 &mConfig.inputCfg.buffer, 6306 &mConfig.outputCfg.buffer); 6307 6308 // force transition to IDLE state when engine is ready 6309 if (mState == STOPPED && ret == -ENODATA) { 6310 mDisableWaitCnt = 1; 6311 } 6312 6313 // clear auxiliary effect input buffer for next accumulation 6314 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 6315 memset(mConfig.inputCfg.buffer.raw, 0, 6316 mConfig.inputCfg.buffer.frameCount*sizeof(int32_t)); 6317 } 6318 } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT && 6319 mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) { 6320 // If an insert effect is idle and input buffer is different from output buffer, 6321 // accumulate input onto output 6322 sp<EffectChain> chain = mChain.promote(); 6323 if (chain != 0 && chain->activeTrackCnt() != 0) { 6324 size_t frameCnt = mConfig.inputCfg.buffer.frameCount * 2; //always stereo here 6325 int16_t *in = mConfig.inputCfg.buffer.s16; 6326 int16_t *out = mConfig.outputCfg.buffer.s16; 6327 for (size_t i = 0; i < frameCnt; i++) { 6328 out[i] = clamp16((int32_t)out[i] + (int32_t)in[i]); 6329 } 6330 } 6331 } 6332 } 6333 6334 void AudioFlinger::EffectModule::reset_l() 6335 { 6336 if (mEffectInterface == NULL) { 6337 return; 6338 } 6339 (*mEffectInterface)->command(mEffectInterface, EFFECT_CMD_RESET, 0, NULL, 0, NULL); 6340 } 6341 6342 status_t AudioFlinger::EffectModule::configure() 6343 { 6344 uint32_t channels; 6345 if (mEffectInterface == NULL) { 6346 return NO_INIT; 6347 } 6348 6349 sp<ThreadBase> thread = mThread.promote(); 6350 if (thread == 0) { 6351 return DEAD_OBJECT; 6352 } 6353 6354 // TODO: handle configuration of effects replacing track process 6355 if (thread->channelCount() == 1) { 6356 channels = AUDIO_CHANNEL_OUT_MONO; 6357 } else { 6358 channels = AUDIO_CHANNEL_OUT_STEREO; 6359 } 6360 6361 if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 6362 mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO; 6363 } else { 6364 mConfig.inputCfg.channels = channels; 6365 } 6366 mConfig.outputCfg.channels = channels; 6367 mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 6368 mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT; 6369 mConfig.inputCfg.samplingRate = thread->sampleRate(); 6370 mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate; 6371 mConfig.inputCfg.bufferProvider.cookie = NULL; 6372 mConfig.inputCfg.bufferProvider.getBuffer = NULL; 6373 mConfig.inputCfg.bufferProvider.releaseBuffer = NULL; 6374 mConfig.outputCfg.bufferProvider.cookie = NULL; 6375 mConfig.outputCfg.bufferProvider.getBuffer = NULL; 6376 mConfig.outputCfg.bufferProvider.releaseBuffer = NULL; 6377 mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; 6378 // Insert effect: 6379 // - in session AUDIO_SESSION_OUTPUT_MIX or AUDIO_SESSION_OUTPUT_STAGE, 6380 // always overwrites output buffer: input buffer == output buffer 6381 // - in other sessions: 6382 // last effect in the chain accumulates in output buffer: input buffer != output buffer 6383 // other effect: overwrites output buffer: input buffer == output buffer 6384 // Auxiliary effect: 6385 // accumulates in output buffer: input buffer != output buffer 6386 // Therefore: accumulate <=> input buffer != output buffer 6387 if (mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) { 6388 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE; 6389 } else { 6390 mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE; 6391 } 6392 mConfig.inputCfg.mask = EFFECT_CONFIG_ALL; 6393 mConfig.outputCfg.mask = EFFECT_CONFIG_ALL; 6394 mConfig.inputCfg.buffer.frameCount = thread->frameCount(); 6395 mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount; 6396 6397 LOGV("configure() %p thread %p buffer %p framecount %d", 6398 this, thread.get(), mConfig.inputCfg.buffer.raw, mConfig.inputCfg.buffer.frameCount); 6399 6400 status_t cmdStatus; 6401 uint32_t size = sizeof(int); 6402 status_t status = (*mEffectInterface)->command(mEffectInterface, 6403 EFFECT_CMD_CONFIGURE, 6404 sizeof(effect_config_t), 6405 &mConfig, 6406 &size, 6407 &cmdStatus); 6408 if (status == 0) { 6409 status = cmdStatus; 6410 } 6411 6412 mMaxDisableWaitCnt = (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate) / 6413 (1000 * mConfig.outputCfg.buffer.frameCount); 6414 6415 return status; 6416 } 6417 6418 status_t AudioFlinger::EffectModule::init() 6419 { 6420 Mutex::Autolock _l(mLock); 6421 if (mEffectInterface == NULL) { 6422 return NO_INIT; 6423 } 6424 status_t cmdStatus; 6425 uint32_t size = sizeof(status_t); 6426 status_t status = (*mEffectInterface)->command(mEffectInterface, 6427 EFFECT_CMD_INIT, 6428 0, 6429 NULL, 6430 &size, 6431 &cmdStatus); 6432 if (status == 0) { 6433 status = cmdStatus; 6434 } 6435 return status; 6436 } 6437 6438 status_t AudioFlinger::EffectModule::start() 6439 { 6440 Mutex::Autolock _l(mLock); 6441 return start_l(); 6442 } 6443 6444 status_t AudioFlinger::EffectModule::start_l() 6445 { 6446 if (mEffectInterface == NULL) { 6447 return NO_INIT; 6448 } 6449 status_t cmdStatus; 6450 uint32_t size = sizeof(status_t); 6451 status_t status = (*mEffectInterface)->command(mEffectInterface, 6452 EFFECT_CMD_ENABLE, 6453 0, 6454 NULL, 6455 &size, 6456 &cmdStatus); 6457 if (status == 0) { 6458 status = cmdStatus; 6459 } 6460 if (status == 0 && 6461 ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC || 6462 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC)) { 6463 sp<ThreadBase> thread = mThread.promote(); 6464 if (thread != 0) { 6465 audio_stream_t *stream = thread->stream(); 6466 if (stream != NULL) { 6467 stream->add_audio_effect(stream, mEffectInterface); 6468 } 6469 } 6470 } 6471 return status; 6472 } 6473 6474 status_t AudioFlinger::EffectModule::stop() 6475 { 6476 Mutex::Autolock _l(mLock); 6477 return stop_l(); 6478 } 6479 6480 status_t AudioFlinger::EffectModule::stop_l() 6481 { 6482 if (mEffectInterface == NULL) { 6483 return NO_INIT; 6484 } 6485 status_t cmdStatus; 6486 uint32_t size = sizeof(status_t); 6487 status_t status = (*mEffectInterface)->command(mEffectInterface, 6488 EFFECT_CMD_DISABLE, 6489 0, 6490 NULL, 6491 &size, 6492 &cmdStatus); 6493 if (status == 0) { 6494 status = cmdStatus; 6495 } 6496 if (status == 0 && 6497 ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC || 6498 (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC)) { 6499 sp<ThreadBase> thread = mThread.promote(); 6500 if (thread != 0) { 6501 audio_stream_t *stream = thread->stream(); 6502 if (stream != NULL) { 6503 stream->remove_audio_effect(stream, mEffectInterface); 6504 } 6505 } 6506 } 6507 return status; 6508 } 6509 6510 status_t AudioFlinger::EffectModule::command(uint32_t cmdCode, 6511 uint32_t cmdSize, 6512 void *pCmdData, 6513 uint32_t *replySize, 6514 void *pReplyData) 6515 { 6516 Mutex::Autolock _l(mLock); 6517 // LOGV("command(), cmdCode: %d, mEffectInterface: %p", cmdCode, mEffectInterface); 6518 6519 if (mState == DESTROYED || mEffectInterface == NULL) { 6520 return NO_INIT; 6521 } 6522 status_t status = (*mEffectInterface)->command(mEffectInterface, 6523 cmdCode, 6524 cmdSize, 6525 pCmdData, 6526 replySize, 6527 pReplyData); 6528 if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) { 6529 uint32_t size = (replySize == NULL) ? 0 : *replySize; 6530 for (size_t i = 1; i < mHandles.size(); i++) { 6531 sp<EffectHandle> h = mHandles[i].promote(); 6532 if (h != 0) { 6533 h->commandExecuted(cmdCode, cmdSize, pCmdData, size, pReplyData); 6534 } 6535 } 6536 } 6537 return status; 6538 } 6539 6540 status_t AudioFlinger::EffectModule::setEnabled(bool enabled) 6541 { 6542 6543 Mutex::Autolock _l(mLock); 6544 LOGV("setEnabled %p enabled %d", this, enabled); 6545 6546 if (enabled != isEnabled()) { 6547 status_t status = AudioSystem::setEffectEnabled(mId, enabled); 6548 if (enabled && status != NO_ERROR) { 6549 return status; 6550 } 6551 6552 switch (mState) { 6553 // going from disabled to enabled 6554 case IDLE: 6555 mState = STARTING; 6556 break; 6557 case STOPPED: 6558 mState = RESTART; 6559 break; 6560 case STOPPING: 6561 mState = ACTIVE; 6562 break; 6563 6564 // going from enabled to disabled 6565 case RESTART: 6566 mState = STOPPED; 6567 break; 6568 case STARTING: 6569 mState = IDLE; 6570 break; 6571 case ACTIVE: 6572 mState = STOPPING; 6573 break; 6574 case DESTROYED: 6575 return NO_ERROR; // simply ignore as we are being destroyed 6576 } 6577 for (size_t i = 1; i < mHandles.size(); i++) { 6578 sp<EffectHandle> h = mHandles[i].promote(); 6579 if (h != 0) { 6580 h->setEnabled(enabled); 6581 } 6582 } 6583 } 6584 return NO_ERROR; 6585 } 6586 6587 bool AudioFlinger::EffectModule::isEnabled() 6588 { 6589 switch (mState) { 6590 case RESTART: 6591 case STARTING: 6592 case ACTIVE: 6593 return true; 6594 case IDLE: 6595 case STOPPING: 6596 case STOPPED: 6597 case DESTROYED: 6598 default: 6599 return false; 6600 } 6601 } 6602 6603 bool AudioFlinger::EffectModule::isProcessEnabled() 6604 { 6605 switch (mState) { 6606 case RESTART: 6607 case ACTIVE: 6608 case STOPPING: 6609 case STOPPED: 6610 return true; 6611 case IDLE: 6612 case STARTING: 6613 case DESTROYED: 6614 default: 6615 return false; 6616 } 6617 } 6618 6619 status_t AudioFlinger::EffectModule::setVolume(uint32_t *left, uint32_t *right, bool controller) 6620 { 6621 Mutex::Autolock _l(mLock); 6622 status_t status = NO_ERROR; 6623 6624 // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume 6625 // if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set) 6626 if (isProcessEnabled() && 6627 ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL || 6628 (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND)) { 6629 status_t cmdStatus; 6630 uint32_t volume[2]; 6631 uint32_t *pVolume = NULL; 6632 uint32_t size = sizeof(volume); 6633 volume[0] = *left; 6634 volume[1] = *right; 6635 if (controller) { 6636 pVolume = volume; 6637 } 6638 status = (*mEffectInterface)->command(mEffectInterface, 6639 EFFECT_CMD_SET_VOLUME, 6640 size, 6641 volume, 6642 &size, 6643 pVolume); 6644 if (controller && status == NO_ERROR && size == sizeof(volume)) { 6645 *left = volume[0]; 6646 *right = volume[1]; 6647 } 6648 } 6649 return status; 6650 } 6651 6652 status_t AudioFlinger::EffectModule::setDevice(uint32_t device) 6653 { 6654 Mutex::Autolock _l(mLock); 6655 status_t status = NO_ERROR; 6656 if (device && (mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) { 6657 // audio pre processing modules on RecordThread can receive both output and 6658 // input device indication in the same call 6659 uint32_t dev = device & AUDIO_DEVICE_OUT_ALL; 6660 if (dev) { 6661 status_t cmdStatus; 6662 uint32_t size = sizeof(status_t); 6663 6664 status = (*mEffectInterface)->command(mEffectInterface, 6665 EFFECT_CMD_SET_DEVICE, 6666 sizeof(uint32_t), 6667 &dev, 6668 &size, 6669 &cmdStatus); 6670 if (status == NO_ERROR) { 6671 status = cmdStatus; 6672 } 6673 } 6674 dev = device & AUDIO_DEVICE_IN_ALL; 6675 if (dev) { 6676 status_t cmdStatus; 6677 uint32_t size = sizeof(status_t); 6678 6679 status_t status2 = (*mEffectInterface)->command(mEffectInterface, 6680 EFFECT_CMD_SET_INPUT_DEVICE, 6681 sizeof(uint32_t), 6682 &dev, 6683 &size, 6684 &cmdStatus); 6685 if (status2 == NO_ERROR) { 6686 status2 = cmdStatus; 6687 } 6688 if (status == NO_ERROR) { 6689 status = status2; 6690 } 6691 } 6692 } 6693 return status; 6694 } 6695 6696 status_t AudioFlinger::EffectModule::setMode(uint32_t mode) 6697 { 6698 Mutex::Autolock _l(mLock); 6699 status_t status = NO_ERROR; 6700 if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) { 6701 status_t cmdStatus; 6702 uint32_t size = sizeof(status_t); 6703 status = (*mEffectInterface)->command(mEffectInterface, 6704 EFFECT_CMD_SET_AUDIO_MODE, 6705 sizeof(int), 6706 &mode, 6707 &size, 6708 &cmdStatus); 6709 if (status == NO_ERROR) { 6710 status = cmdStatus; 6711 } 6712 } 6713 return status; 6714 } 6715 6716 void AudioFlinger::EffectModule::setSuspended(bool suspended) 6717 { 6718 Mutex::Autolock _l(mLock); 6719 mSuspended = suspended; 6720 } 6721 bool AudioFlinger::EffectModule::suspended() 6722 { 6723 Mutex::Autolock _l(mLock); 6724 return mSuspended; 6725 } 6726 6727 status_t AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args) 6728 { 6729 const size_t SIZE = 256; 6730 char buffer[SIZE]; 6731 String8 result; 6732 6733 snprintf(buffer, SIZE, "\tEffect ID %d:\n", mId); 6734 result.append(buffer); 6735 6736 bool locked = tryLock(mLock); 6737 // failed to lock - AudioFlinger is probably deadlocked 6738 if (!locked) { 6739 result.append("\t\tCould not lock Fx mutex:\n"); 6740 } 6741 6742 result.append("\t\tSession Status State Engine:\n"); 6743 snprintf(buffer, SIZE, "\t\t%05d %03d %03d 0x%08x\n", 6744 mSessionId, mStatus, mState, (uint32_t)mEffectInterface); 6745 result.append(buffer); 6746 6747 result.append("\t\tDescriptor:\n"); 6748 snprintf(buffer, SIZE, "\t\t- UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n", 6749 mDescriptor.uuid.timeLow, mDescriptor.uuid.timeMid, mDescriptor.uuid.timeHiAndVersion, 6750 mDescriptor.uuid.clockSeq, mDescriptor.uuid.node[0], mDescriptor.uuid.node[1],mDescriptor.uuid.node[2], 6751 mDescriptor.uuid.node[3],mDescriptor.uuid.node[4],mDescriptor.uuid.node[5]); 6752 result.append(buffer); 6753 snprintf(buffer, SIZE, "\t\t- TYPE: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n", 6754 mDescriptor.type.timeLow, mDescriptor.type.timeMid, mDescriptor.type.timeHiAndVersion, 6755 mDescriptor.type.clockSeq, mDescriptor.type.node[0], mDescriptor.type.node[1],mDescriptor.type.node[2], 6756 mDescriptor.type.node[3],mDescriptor.type.node[4],mDescriptor.type.node[5]); 6757 result.append(buffer); 6758 snprintf(buffer, SIZE, "\t\t- apiVersion: %08X\n\t\t- flags: %08X\n", 6759 mDescriptor.apiVersion, 6760 mDescriptor.flags); 6761 result.append(buffer); 6762 snprintf(buffer, SIZE, "\t\t- name: %s\n", 6763 mDescriptor.name); 6764 result.append(buffer); 6765 snprintf(buffer, SIZE, "\t\t- implementor: %s\n", 6766 mDescriptor.implementor); 6767 result.append(buffer); 6768 6769 result.append("\t\t- Input configuration:\n"); 6770 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n"); 6771 snprintf(buffer, SIZE, "\t\t\t0x%08x %05d %05d %08x %d\n", 6772 (uint32_t)mConfig.inputCfg.buffer.raw, 6773 mConfig.inputCfg.buffer.frameCount, 6774 mConfig.inputCfg.samplingRate, 6775 mConfig.inputCfg.channels, 6776 mConfig.inputCfg.format); 6777 result.append(buffer); 6778 6779 result.append("\t\t- Output configuration:\n"); 6780 result.append("\t\t\tBuffer Frames Smp rate Channels Format\n"); 6781 snprintf(buffer, SIZE, "\t\t\t0x%08x %05d %05d %08x %d\n", 6782 (uint32_t)mConfig.outputCfg.buffer.raw, 6783 mConfig.outputCfg.buffer.frameCount, 6784 mConfig.outputCfg.samplingRate, 6785 mConfig.outputCfg.channels, 6786 mConfig.outputCfg.format); 6787 result.append(buffer); 6788 6789 snprintf(buffer, SIZE, "\t\t%d Clients:\n", mHandles.size()); 6790 result.append(buffer); 6791 result.append("\t\t\tPid Priority Ctrl Locked client server\n"); 6792 for (size_t i = 0; i < mHandles.size(); ++i) { 6793 sp<EffectHandle> handle = mHandles[i].promote(); 6794 if (handle != 0) { 6795 handle->dump(buffer, SIZE); 6796 result.append(buffer); 6797 } 6798 } 6799 6800 result.append("\n"); 6801 6802 write(fd, result.string(), result.length()); 6803 6804 if (locked) { 6805 mLock.unlock(); 6806 } 6807 6808 return NO_ERROR; 6809 } 6810 6811 // ---------------------------------------------------------------------------- 6812 // EffectHandle implementation 6813 // ---------------------------------------------------------------------------- 6814 6815 #undef LOG_TAG 6816 #define LOG_TAG "AudioFlinger::EffectHandle" 6817 6818 AudioFlinger::EffectHandle::EffectHandle(const sp<EffectModule>& effect, 6819 const sp<AudioFlinger::Client>& client, 6820 const sp<IEffectClient>& effectClient, 6821 int32_t priority) 6822 : BnEffect(), 6823 mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL), 6824 mPriority(priority), mHasControl(false), mEnabled(false) 6825 { 6826 LOGV("constructor %p", this); 6827 6828 if (client == 0) { 6829 return; 6830 } 6831 int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int); 6832 mCblkMemory = client->heap()->allocate(EFFECT_PARAM_BUFFER_SIZE + bufOffset); 6833 if (mCblkMemory != 0) { 6834 mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->pointer()); 6835 6836 if (mCblk) { 6837 new(mCblk) effect_param_cblk_t(); 6838 mBuffer = (uint8_t *)mCblk + bufOffset; 6839 } 6840 } else { 6841 LOGE("not enough memory for Effect size=%u", EFFECT_PARAM_BUFFER_SIZE + sizeof(effect_param_cblk_t)); 6842 return; 6843 } 6844 } 6845 6846 AudioFlinger::EffectHandle::~EffectHandle() 6847 { 6848 LOGV("Destructor %p", this); 6849 disconnect(false); 6850 LOGV("Destructor DONE %p", this); 6851 } 6852 6853 status_t AudioFlinger::EffectHandle::enable() 6854 { 6855 LOGV("enable %p", this); 6856 if (!mHasControl) return INVALID_OPERATION; 6857 if (mEffect == 0) return DEAD_OBJECT; 6858 6859 if (mEnabled) { 6860 return NO_ERROR; 6861 } 6862 6863 mEnabled = true; 6864 6865 sp<ThreadBase> thread = mEffect->thread().promote(); 6866 if (thread != 0) { 6867 thread->checkSuspendOnEffectEnabled(mEffect, true, mEffect->sessionId()); 6868 } 6869 6870 // checkSuspendOnEffectEnabled() can suspend this same effect when enabled 6871 if (mEffect->suspended()) { 6872 return NO_ERROR; 6873 } 6874 6875 status_t status = mEffect->setEnabled(true); 6876 if (status != NO_ERROR) { 6877 if (thread != 0) { 6878 thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId()); 6879 } 6880 mEnabled = false; 6881 } 6882 return status; 6883 } 6884 6885 status_t AudioFlinger::EffectHandle::disable() 6886 { 6887 LOGV("disable %p", this); 6888 if (!mHasControl) return INVALID_OPERATION; 6889 if (mEffect == 0) return DEAD_OBJECT; 6890 6891 if (!mEnabled) { 6892 return NO_ERROR; 6893 } 6894 mEnabled = false; 6895 6896 if (mEffect->suspended()) { 6897 return NO_ERROR; 6898 } 6899 6900 status_t status = mEffect->setEnabled(false); 6901 6902 sp<ThreadBase> thread = mEffect->thread().promote(); 6903 if (thread != 0) { 6904 thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId()); 6905 } 6906 6907 return status; 6908 } 6909 6910 void AudioFlinger::EffectHandle::disconnect() 6911 { 6912 disconnect(true); 6913 } 6914 6915 void AudioFlinger::EffectHandle::disconnect(bool unpiniflast) 6916 { 6917 LOGV("disconnect(%s)", unpiniflast ? "true" : "false"); 6918 if (mEffect == 0) { 6919 return; 6920 } 6921 mEffect->disconnect(this, unpiniflast); 6922 6923 if (mHasControl && mEnabled) { 6924 sp<ThreadBase> thread = mEffect->thread().promote(); 6925 if (thread != 0) { 6926 thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId()); 6927 } 6928 } 6929 6930 // release sp on module => module destructor can be called now 6931 mEffect.clear(); 6932 if (mClient != 0) { 6933 if (mCblk) { 6934 mCblk->~effect_param_cblk_t(); // destroy our shared-structure. 6935 } 6936 mCblkMemory.clear(); // and free the shared memory 6937 Mutex::Autolock _l(mClient->audioFlinger()->mLock); 6938 mClient.clear(); 6939 } 6940 } 6941 6942 status_t AudioFlinger::EffectHandle::command(uint32_t cmdCode, 6943 uint32_t cmdSize, 6944 void *pCmdData, 6945 uint32_t *replySize, 6946 void *pReplyData) 6947 { 6948 // LOGV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p", 6949 // cmdCode, mHasControl, (mEffect == 0) ? 0 : mEffect.get()); 6950 6951 // only get parameter command is permitted for applications not controlling the effect 6952 if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) { 6953 return INVALID_OPERATION; 6954 } 6955 if (mEffect == 0) return DEAD_OBJECT; 6956 if (mClient == 0) return INVALID_OPERATION; 6957 6958 // handle commands that are not forwarded transparently to effect engine 6959 if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) { 6960 // No need to trylock() here as this function is executed in the binder thread serving a particular client process: 6961 // no risk to block the whole media server process or mixer threads is we are stuck here 6962 Mutex::Autolock _l(mCblk->lock); 6963 if (mCblk->clientIndex > EFFECT_PARAM_BUFFER_SIZE || 6964 mCblk->serverIndex > EFFECT_PARAM_BUFFER_SIZE) { 6965 mCblk->serverIndex = 0; 6966 mCblk->clientIndex = 0; 6967 return BAD_VALUE; 6968 } 6969 status_t status = NO_ERROR; 6970 while (mCblk->serverIndex < mCblk->clientIndex) { 6971 int reply; 6972 uint32_t rsize = sizeof(int); 6973 int *p = (int *)(mBuffer + mCblk->serverIndex); 6974 int size = *p++; 6975 if (((uint8_t *)p + size) > mBuffer + mCblk->clientIndex) { 6976 LOGW("command(): invalid parameter block size"); 6977 break; 6978 } 6979 effect_param_t *param = (effect_param_t *)p; 6980 if (param->psize == 0 || param->vsize == 0) { 6981 LOGW("command(): null parameter or value size"); 6982 mCblk->serverIndex += size; 6983 continue; 6984 } 6985 uint32_t psize = sizeof(effect_param_t) + 6986 ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + 6987 param->vsize; 6988 status_t ret = mEffect->command(EFFECT_CMD_SET_PARAM, 6989 psize, 6990 p, 6991 &rsize, 6992 &reply); 6993 // stop at first error encountered 6994 if (ret != NO_ERROR) { 6995 status = ret; 6996 *(int *)pReplyData = reply; 6997 break; 6998 } else if (reply != NO_ERROR) { 6999 *(int *)pReplyData = reply; 7000 break; 7001 } 7002 mCblk->serverIndex += size; 7003 } 7004 mCblk->serverIndex = 0; 7005 mCblk->clientIndex = 0; 7006 return status; 7007 } else if (cmdCode == EFFECT_CMD_ENABLE) { 7008 *(int *)pReplyData = NO_ERROR; 7009 return enable(); 7010 } else if (cmdCode == EFFECT_CMD_DISABLE) { 7011 *(int *)pReplyData = NO_ERROR; 7012 return disable(); 7013 } 7014 7015 return mEffect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData); 7016 } 7017 7018 sp<IMemory> AudioFlinger::EffectHandle::getCblk() const { 7019 return mCblkMemory; 7020 } 7021 7022 void AudioFlinger::EffectHandle::setControl(bool hasControl, bool signal, bool enabled) 7023 { 7024 LOGV("setControl %p control %d", this, hasControl); 7025 7026 mHasControl = hasControl; 7027 mEnabled = enabled; 7028 7029 if (signal && mEffectClient != 0) { 7030 mEffectClient->controlStatusChanged(hasControl); 7031 } 7032 } 7033 7034 void AudioFlinger::EffectHandle::commandExecuted(uint32_t cmdCode, 7035 uint32_t cmdSize, 7036 void *pCmdData, 7037 uint32_t replySize, 7038 void *pReplyData) 7039 { 7040 if (mEffectClient != 0) { 7041 mEffectClient->commandExecuted(cmdCode, cmdSize, pCmdData, replySize, pReplyData); 7042 } 7043 } 7044 7045 7046 7047 void AudioFlinger::EffectHandle::setEnabled(bool enabled) 7048 { 7049 if (mEffectClient != 0) { 7050 mEffectClient->enableStatusChanged(enabled); 7051 } 7052 } 7053 7054 status_t AudioFlinger::EffectHandle::onTransact( 7055 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 7056 { 7057 return BnEffect::onTransact(code, data, reply, flags); 7058 } 7059 7060 7061 void AudioFlinger::EffectHandle::dump(char* buffer, size_t size) 7062 { 7063 bool locked = mCblk ? tryLock(mCblk->lock) : false; 7064 7065 snprintf(buffer, size, "\t\t\t%05d %05d %01u %01u %05u %05u\n", 7066 (mClient == NULL) ? getpid() : mClient->pid(), 7067 mPriority, 7068 mHasControl, 7069 !locked, 7070 mCblk ? mCblk->clientIndex : 0, 7071 mCblk ? mCblk->serverIndex : 0 7072 ); 7073 7074 if (locked) { 7075 mCblk->lock.unlock(); 7076 } 7077 } 7078 7079 #undef LOG_TAG 7080 #define LOG_TAG "AudioFlinger::EffectChain" 7081 7082 AudioFlinger::EffectChain::EffectChain(const wp<ThreadBase>& wThread, 7083 int sessionId) 7084 : mThread(wThread), mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0), 7085 mOwnInBuffer(false), mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX), 7086 mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX) 7087 { 7088 mStrategy = AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); 7089 sp<ThreadBase> thread = mThread.promote(); 7090 if (thread == 0) { 7091 return; 7092 } 7093 mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) / 7094 thread->frameCount(); 7095 } 7096 7097 AudioFlinger::EffectChain::~EffectChain() 7098 { 7099 if (mOwnInBuffer) { 7100 delete mInBuffer; 7101 } 7102 7103 } 7104 7105 // getEffectFromDesc_l() must be called with ThreadBase::mLock held 7106 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromDesc_l(effect_descriptor_t *descriptor) 7107 { 7108 sp<EffectModule> effect; 7109 size_t size = mEffects.size(); 7110 7111 for (size_t i = 0; i < size; i++) { 7112 if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) { 7113 effect = mEffects[i]; 7114 break; 7115 } 7116 } 7117 return effect; 7118 } 7119 7120 // getEffectFromId_l() must be called with ThreadBase::mLock held 7121 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromId_l(int id) 7122 { 7123 sp<EffectModule> effect; 7124 size_t size = mEffects.size(); 7125 7126 for (size_t i = 0; i < size; i++) { 7127 // by convention, return first effect if id provided is 0 (0 is never a valid id) 7128 if (id == 0 || mEffects[i]->id() == id) { 7129 effect = mEffects[i]; 7130 break; 7131 } 7132 } 7133 return effect; 7134 } 7135 7136 // getEffectFromType_l() must be called with ThreadBase::mLock held 7137 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromType_l( 7138 const effect_uuid_t *type) 7139 { 7140 sp<EffectModule> effect; 7141 size_t size = mEffects.size(); 7142 7143 for (size_t i = 0; i < size; i++) { 7144 if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) { 7145 effect = mEffects[i]; 7146 break; 7147 } 7148 } 7149 return effect; 7150 } 7151 7152 // Must be called with EffectChain::mLock locked 7153 void AudioFlinger::EffectChain::process_l() 7154 { 7155 sp<ThreadBase> thread = mThread.promote(); 7156 if (thread == 0) { 7157 LOGW("process_l(): cannot promote mixer thread"); 7158 return; 7159 } 7160 bool isGlobalSession = (mSessionId == AUDIO_SESSION_OUTPUT_MIX) || 7161 (mSessionId == AUDIO_SESSION_OUTPUT_STAGE); 7162 // always process effects unless no more tracks are on the session and the effect tail 7163 // has been rendered 7164 bool doProcess = true; 7165 if (!isGlobalSession) { 7166 bool tracksOnSession = (trackCnt() != 0); 7167 7168 if (!tracksOnSession && mTailBufferCount == 0) { 7169 doProcess = false; 7170 } 7171 7172 if (activeTrackCnt() == 0) { 7173 // if no track is active and the effect tail has not been rendered, 7174 // the input buffer must be cleared here as the mixer process will not do it 7175 if (tracksOnSession || mTailBufferCount > 0) { 7176 size_t numSamples = thread->frameCount() * thread->channelCount(); 7177 memset(mInBuffer, 0, numSamples * sizeof(int16_t)); 7178 if (mTailBufferCount > 0) { 7179 mTailBufferCount--; 7180 } 7181 } 7182 } 7183 } 7184 7185 size_t size = mEffects.size(); 7186 if (doProcess) { 7187 for (size_t i = 0; i < size; i++) { 7188 mEffects[i]->process(); 7189 } 7190 } 7191 for (size_t i = 0; i < size; i++) { 7192 mEffects[i]->updateState(); 7193 } 7194 } 7195 7196 // addEffect_l() must be called with PlaybackThread::mLock held 7197 status_t AudioFlinger::EffectChain::addEffect_l(const sp<EffectModule>& effect) 7198 { 7199 effect_descriptor_t desc = effect->desc(); 7200 uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK; 7201 7202 Mutex::Autolock _l(mLock); 7203 effect->setChain(this); 7204 sp<ThreadBase> thread = mThread.promote(); 7205 if (thread == 0) { 7206 return NO_INIT; 7207 } 7208 effect->setThread(thread); 7209 7210 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 7211 // Auxiliary effects are inserted at the beginning of mEffects vector as 7212 // they are processed first and accumulated in chain input buffer 7213 mEffects.insertAt(effect, 0); 7214 7215 // the input buffer for auxiliary effect contains mono samples in 7216 // 32 bit format. This is to avoid saturation in AudoMixer 7217 // accumulation stage. Saturation is done in EffectModule::process() before 7218 // calling the process in effect engine 7219 size_t numSamples = thread->frameCount(); 7220 int32_t *buffer = new int32_t[numSamples]; 7221 memset(buffer, 0, numSamples * sizeof(int32_t)); 7222 effect->setInBuffer((int16_t *)buffer); 7223 // auxiliary effects output samples to chain input buffer for further processing 7224 // by insert effects 7225 effect->setOutBuffer(mInBuffer); 7226 } else { 7227 // Insert effects are inserted at the end of mEffects vector as they are processed 7228 // after track and auxiliary effects. 7229 // Insert effect order as a function of indicated preference: 7230 // if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if 7231 // another effect is present 7232 // else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the 7233 // last effect claiming first position 7234 // else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the 7235 // first effect claiming last position 7236 // else if EFFECT_FLAG_INSERT_ANY insert after first or before last 7237 // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is 7238 // already present 7239 7240 int size = (int)mEffects.size(); 7241 int idx_insert = size; 7242 int idx_insert_first = -1; 7243 int idx_insert_last = -1; 7244 7245 for (int i = 0; i < size; i++) { 7246 effect_descriptor_t d = mEffects[i]->desc(); 7247 uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK; 7248 uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK; 7249 if (iMode == EFFECT_FLAG_TYPE_INSERT) { 7250 // check invalid effect chaining combinations 7251 if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE || 7252 iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) { 7253 LOGW("addEffect_l() could not insert effect %s: exclusive conflict with %s", desc.name, d.name); 7254 return INVALID_OPERATION; 7255 } 7256 // remember position of first insert effect and by default 7257 // select this as insert position for new effect 7258 if (idx_insert == size) { 7259 idx_insert = i; 7260 } 7261 // remember position of last insert effect claiming 7262 // first position 7263 if (iPref == EFFECT_FLAG_INSERT_FIRST) { 7264 idx_insert_first = i; 7265 } 7266 // remember position of first insert effect claiming 7267 // last position 7268 if (iPref == EFFECT_FLAG_INSERT_LAST && 7269 idx_insert_last == -1) { 7270 idx_insert_last = i; 7271 } 7272 } 7273 } 7274 7275 // modify idx_insert from first position if needed 7276 if (insertPref == EFFECT_FLAG_INSERT_LAST) { 7277 if (idx_insert_last != -1) { 7278 idx_insert = idx_insert_last; 7279 } else { 7280 idx_insert = size; 7281 } 7282 } else { 7283 if (idx_insert_first != -1) { 7284 idx_insert = idx_insert_first + 1; 7285 } 7286 } 7287 7288 // always read samples from chain input buffer 7289 effect->setInBuffer(mInBuffer); 7290 7291 // if last effect in the chain, output samples to chain 7292 // output buffer, otherwise to chain input buffer 7293 if (idx_insert == size) { 7294 if (idx_insert != 0) { 7295 mEffects[idx_insert-1]->setOutBuffer(mInBuffer); 7296 mEffects[idx_insert-1]->configure(); 7297 } 7298 effect->setOutBuffer(mOutBuffer); 7299 } else { 7300 effect->setOutBuffer(mInBuffer); 7301 } 7302 mEffects.insertAt(effect, idx_insert); 7303 7304 LOGV("addEffect_l() effect %p, added in chain %p at rank %d", effect.get(), this, idx_insert); 7305 } 7306 effect->configure(); 7307 return NO_ERROR; 7308 } 7309 7310 // removeEffect_l() must be called with PlaybackThread::mLock held 7311 size_t AudioFlinger::EffectChain::removeEffect_l(const sp<EffectModule>& effect) 7312 { 7313 Mutex::Autolock _l(mLock); 7314 int size = (int)mEffects.size(); 7315 int i; 7316 uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK; 7317 7318 for (i = 0; i < size; i++) { 7319 if (effect == mEffects[i]) { 7320 // calling stop here will remove pre-processing effect from the audio HAL. 7321 // This is safe as we hold the EffectChain mutex which guarantees that we are not in 7322 // the middle of a read from audio HAL 7323 if (mEffects[i]->state() == EffectModule::ACTIVE || 7324 mEffects[i]->state() == EffectModule::STOPPING) { 7325 mEffects[i]->stop(); 7326 } 7327 if (type == EFFECT_FLAG_TYPE_AUXILIARY) { 7328 delete[] effect->inBuffer(); 7329 } else { 7330 if (i == size - 1 && i != 0) { 7331 mEffects[i - 1]->setOutBuffer(mOutBuffer); 7332 mEffects[i - 1]->configure(); 7333 } 7334 } 7335 mEffects.removeAt(i); 7336 LOGV("removeEffect_l() effect %p, removed from chain %p at rank %d", effect.get(), this, i); 7337 break; 7338 } 7339 } 7340 7341 return mEffects.size(); 7342 } 7343 7344 // setDevice_l() must be called with PlaybackThread::mLock held 7345 void AudioFlinger::EffectChain::setDevice_l(uint32_t device) 7346 { 7347 size_t size = mEffects.size(); 7348 for (size_t i = 0; i < size; i++) { 7349 mEffects[i]->setDevice(device); 7350 } 7351 } 7352 7353 // setMode_l() must be called with PlaybackThread::mLock held 7354 void AudioFlinger::EffectChain::setMode_l(uint32_t mode) 7355 { 7356 size_t size = mEffects.size(); 7357 for (size_t i = 0; i < size; i++) { 7358 mEffects[i]->setMode(mode); 7359 } 7360 } 7361 7362 // setVolume_l() must be called with PlaybackThread::mLock held 7363 bool AudioFlinger::EffectChain::setVolume_l(uint32_t *left, uint32_t *right) 7364 { 7365 uint32_t newLeft = *left; 7366 uint32_t newRight = *right; 7367 bool hasControl = false; 7368 int ctrlIdx = -1; 7369 size_t size = mEffects.size(); 7370 7371 // first update volume controller 7372 for (size_t i = size; i > 0; i--) { 7373 if (mEffects[i - 1]->isProcessEnabled() && 7374 (mEffects[i - 1]->desc().flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL) { 7375 ctrlIdx = i - 1; 7376 hasControl = true; 7377 break; 7378 } 7379 } 7380 7381 if (ctrlIdx == mVolumeCtrlIdx && *left == mLeftVolume && *right == mRightVolume) { 7382 if (hasControl) { 7383 *left = mNewLeftVolume; 7384 *right = mNewRightVolume; 7385 } 7386 return hasControl; 7387 } 7388 7389 mVolumeCtrlIdx = ctrlIdx; 7390 mLeftVolume = newLeft; 7391 mRightVolume = newRight; 7392 7393 // second get volume update from volume controller 7394 if (ctrlIdx >= 0) { 7395 mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true); 7396 mNewLeftVolume = newLeft; 7397 mNewRightVolume = newRight; 7398 } 7399 // then indicate volume to all other effects in chain. 7400 // Pass altered volume to effects before volume controller 7401 // and requested volume to effects after controller 7402 uint32_t lVol = newLeft; 7403 uint32_t rVol = newRight; 7404 7405 for (size_t i = 0; i < size; i++) { 7406 if ((int)i == ctrlIdx) continue; 7407 // this also works for ctrlIdx == -1 when there is no volume controller 7408 if ((int)i > ctrlIdx) { 7409 lVol = *left; 7410 rVol = *right; 7411 } 7412 mEffects[i]->setVolume(&lVol, &rVol, false); 7413 } 7414 *left = newLeft; 7415 *right = newRight; 7416 7417 return hasControl; 7418 } 7419 7420 status_t AudioFlinger::EffectChain::dump(int fd, const Vector<String16>& args) 7421 { 7422 const size_t SIZE = 256; 7423 char buffer[SIZE]; 7424 String8 result; 7425 7426 snprintf(buffer, SIZE, "Effects for session %d:\n", mSessionId); 7427 result.append(buffer); 7428 7429 bool locked = tryLock(mLock); 7430 // failed to lock - AudioFlinger is probably deadlocked 7431 if (!locked) { 7432 result.append("\tCould not lock mutex:\n"); 7433 } 7434 7435 result.append("\tNum fx In buffer Out buffer Active tracks:\n"); 7436 snprintf(buffer, SIZE, "\t%02d 0x%08x 0x%08x %d\n", 7437 mEffects.size(), 7438 (uint32_t)mInBuffer, 7439 (uint32_t)mOutBuffer, 7440 mActiveTrackCnt); 7441 result.append(buffer); 7442 write(fd, result.string(), result.size()); 7443 7444 for (size_t i = 0; i < mEffects.size(); ++i) { 7445 sp<EffectModule> effect = mEffects[i]; 7446 if (effect != 0) { 7447 effect->dump(fd, args); 7448 } 7449 } 7450 7451 if (locked) { 7452 mLock.unlock(); 7453 } 7454 7455 return NO_ERROR; 7456 } 7457 7458 // must be called with ThreadBase::mLock held 7459 void AudioFlinger::EffectChain::setEffectSuspended_l( 7460 const effect_uuid_t *type, bool suspend) 7461 { 7462 sp<SuspendedEffectDesc> desc; 7463 // use effect type UUID timelow as key as there is no real risk of identical 7464 // timeLow fields among effect type UUIDs. 7465 int index = mSuspendedEffects.indexOfKey(type->timeLow); 7466 if (suspend) { 7467 if (index >= 0) { 7468 desc = mSuspendedEffects.valueAt(index); 7469 } else { 7470 desc = new SuspendedEffectDesc(); 7471 memcpy(&desc->mType, type, sizeof(effect_uuid_t)); 7472 mSuspendedEffects.add(type->timeLow, desc); 7473 LOGV("setEffectSuspended_l() add entry for %08x", type->timeLow); 7474 } 7475 if (desc->mRefCount++ == 0) { 7476 sp<EffectModule> effect = getEffectIfEnabled(type); 7477 if (effect != 0) { 7478 desc->mEffect = effect; 7479 effect->setSuspended(true); 7480 effect->setEnabled(false); 7481 } 7482 } 7483 } else { 7484 if (index < 0) { 7485 return; 7486 } 7487 desc = mSuspendedEffects.valueAt(index); 7488 if (desc->mRefCount <= 0) { 7489 LOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount); 7490 desc->mRefCount = 1; 7491 } 7492 if (--desc->mRefCount == 0) { 7493 LOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index)); 7494 if (desc->mEffect != 0) { 7495 sp<EffectModule> effect = desc->mEffect.promote(); 7496 if (effect != 0) { 7497 effect->setSuspended(false); 7498 sp<EffectHandle> handle = effect->controlHandle(); 7499 if (handle != 0) { 7500 effect->setEnabled(handle->enabled()); 7501 } 7502 } 7503 desc->mEffect.clear(); 7504 } 7505 mSuspendedEffects.removeItemsAt(index); 7506 } 7507 } 7508 } 7509 7510 // must be called with ThreadBase::mLock held 7511 void AudioFlinger::EffectChain::setEffectSuspendedAll_l(bool suspend) 7512 { 7513 sp<SuspendedEffectDesc> desc; 7514 7515 int index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll); 7516 if (suspend) { 7517 if (index >= 0) { 7518 desc = mSuspendedEffects.valueAt(index); 7519 } else { 7520 desc = new SuspendedEffectDesc(); 7521 mSuspendedEffects.add((int)kKeyForSuspendAll, desc); 7522 LOGV("setEffectSuspendedAll_l() add entry for 0"); 7523 } 7524 if (desc->mRefCount++ == 0) { 7525 Vector< sp<EffectModule> > effects = getSuspendEligibleEffects(); 7526 for (size_t i = 0; i < effects.size(); i++) { 7527 setEffectSuspended_l(&effects[i]->desc().type, true); 7528 } 7529 } 7530 } else { 7531 if (index < 0) { 7532 return; 7533 } 7534 desc = mSuspendedEffects.valueAt(index); 7535 if (desc->mRefCount <= 0) { 7536 LOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount); 7537 desc->mRefCount = 1; 7538 } 7539 if (--desc->mRefCount == 0) { 7540 Vector<const effect_uuid_t *> types; 7541 for (size_t i = 0; i < mSuspendedEffects.size(); i++) { 7542 if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) { 7543 continue; 7544 } 7545 types.add(&mSuspendedEffects.valueAt(i)->mType); 7546 } 7547 for (size_t i = 0; i < types.size(); i++) { 7548 setEffectSuspended_l(types[i], false); 7549 } 7550 LOGV("setEffectSuspendedAll_l() remove entry for %08x", mSuspendedEffects.keyAt(index)); 7551 mSuspendedEffects.removeItem((int)kKeyForSuspendAll); 7552 } 7553 } 7554 } 7555 7556 7557 // The volume effect is used for automated tests only 7558 #ifndef OPENSL_ES_H_ 7559 static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6, 7560 { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } }; 7561 const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_; 7562 #endif //OPENSL_ES_H_ 7563 7564 bool AudioFlinger::EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc) 7565 { 7566 // auxiliary effects and visualizer are never suspended on output mix 7567 if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) && 7568 (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) || 7569 (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) || 7570 (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0))) { 7571 return false; 7572 } 7573 return true; 7574 } 7575 7576 Vector< sp<AudioFlinger::EffectModule> > AudioFlinger::EffectChain::getSuspendEligibleEffects() 7577 { 7578 Vector< sp<EffectModule> > effects; 7579 for (size_t i = 0; i < mEffects.size(); i++) { 7580 if (!isEffectEligibleForSuspend(mEffects[i]->desc())) { 7581 continue; 7582 } 7583 effects.add(mEffects[i]); 7584 } 7585 return effects; 7586 } 7587 7588 sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectIfEnabled( 7589 const effect_uuid_t *type) 7590 { 7591 sp<EffectModule> effect; 7592 effect = getEffectFromType_l(type); 7593 if (effect != 0 && !effect->isEnabled()) { 7594 effect.clear(); 7595 } 7596 return effect; 7597 } 7598 7599 void AudioFlinger::EffectChain::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 7600 bool enabled) 7601 { 7602 int index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow); 7603 if (enabled) { 7604 if (index < 0) { 7605 // if the effect is not suspend check if all effects are suspended 7606 index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll); 7607 if (index < 0) { 7608 return; 7609 } 7610 if (!isEffectEligibleForSuspend(effect->desc())) { 7611 return; 7612 } 7613 setEffectSuspended_l(&effect->desc().type, enabled); 7614 index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow); 7615 if (index < 0) { 7616 LOGW("checkSuspendOnEffectEnabled() Fx should be suspended here!"); 7617 return; 7618 } 7619 } 7620 LOGV("checkSuspendOnEffectEnabled() enable suspending fx %08x", 7621 effect->desc().type.timeLow); 7622 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index); 7623 // if effect is requested to suspended but was not yet enabled, supend it now. 7624 if (desc->mEffect == 0) { 7625 desc->mEffect = effect; 7626 effect->setEnabled(false); 7627 effect->setSuspended(true); 7628 } 7629 } else { 7630 if (index < 0) { 7631 return; 7632 } 7633 LOGV("checkSuspendOnEffectEnabled() disable restoring fx %08x", 7634 effect->desc().type.timeLow); 7635 sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index); 7636 desc->mEffect.clear(); 7637 effect->setSuspended(false); 7638 } 7639 } 7640 7641 #undef LOG_TAG 7642 #define LOG_TAG "AudioFlinger" 7643 7644 // ---------------------------------------------------------------------------- 7645 7646 status_t AudioFlinger::onTransact( 7647 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 7648 { 7649 return BnAudioFlinger::onTransact(code, data, reply, flags); 7650 } 7651 7652 }; // namespace android 7653