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