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/IServiceManager.h> 28#include <utils/Log.h> 29#include <binder/Parcel.h> 30#include <binder/IPCThreadState.h> 31#include <utils/String16.h> 32#include <utils/threads.h> 33 34#include <cutils/properties.h> 35 36#include <media/AudioTrack.h> 37#include <media/AudioRecord.h> 38 39#include <private/media/AudioTrackShared.h> 40 41#include <hardware_legacy/AudioHardwareInterface.h> 42 43#include "AudioMixer.h" 44#include "AudioFlinger.h" 45 46#ifdef WITH_A2DP 47#include "A2dpAudioInterface.h" 48#endif 49 50// ---------------------------------------------------------------------------- 51// the sim build doesn't have gettid 52 53#ifndef HAVE_GETTID 54# define gettid getpid 55#endif 56 57// ---------------------------------------------------------------------------- 58 59namespace android { 60 61static const char* kDeadlockedString = "AudioFlinger may be deadlocked\n"; 62static const char* kHardwareLockedString = "Hardware lock is taken\n"; 63 64//static const nsecs_t kStandbyTimeInNsecs = seconds(3); 65static const float MAX_GAIN = 4096.0f; 66 67// retry counts for buffer fill timeout 68// 50 * ~20msecs = 1 second 69static const int8_t kMaxTrackRetries = 50; 70static const int8_t kMaxTrackStartupRetries = 50; 71 72static const int kDumpLockRetries = 50; 73static const int kDumpLockSleep = 20000; 74 75static const nsecs_t kWarningThrottle = seconds(5); 76 77 78#define AUDIOFLINGER_SECURITY_ENABLED 1 79 80// ---------------------------------------------------------------------------- 81 82static bool recordingAllowed() { 83#ifndef HAVE_ANDROID_OS 84 return true; 85#endif 86#if AUDIOFLINGER_SECURITY_ENABLED 87 if (getpid() == IPCThreadState::self()->getCallingPid()) return true; 88 bool ok = checkCallingPermission(String16("android.permission.RECORD_AUDIO")); 89 if (!ok) LOGE("Request requires android.permission.RECORD_AUDIO"); 90 return ok; 91#else 92 if (!checkCallingPermission(String16("android.permission.RECORD_AUDIO"))) 93 LOGW("WARNING: Need to add android.permission.RECORD_AUDIO to manifest"); 94 return true; 95#endif 96} 97 98static bool settingsAllowed() { 99#ifndef HAVE_ANDROID_OS 100 return true; 101#endif 102#if AUDIOFLINGER_SECURITY_ENABLED 103 if (getpid() == IPCThreadState::self()->getCallingPid()) return true; 104 bool ok = checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS")); 105 if (!ok) LOGE("Request requires android.permission.MODIFY_AUDIO_SETTINGS"); 106 return ok; 107#else 108 if (!checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS"))) 109 LOGW("WARNING: Need to add android.permission.MODIFY_AUDIO_SETTINGS to manifest"); 110 return true; 111#endif 112} 113 114// ---------------------------------------------------------------------------- 115 116AudioFlinger::AudioFlinger() 117 : BnAudioFlinger(), 118 mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextThreadId(0) 119{ 120 mHardwareStatus = AUDIO_HW_IDLE; 121 122 mAudioHardware = AudioHardwareInterface::create(); 123 124 mHardwareStatus = AUDIO_HW_INIT; 125 if (mAudioHardware->initCheck() == NO_ERROR) { 126 // open 16-bit output stream for s/w mixer 127 128 setMode(AudioSystem::MODE_NORMAL); 129 130 setMasterVolume(1.0f); 131 setMasterMute(false); 132 } else { 133 LOGE("Couldn't even initialize the stubbed audio hardware!"); 134 } 135} 136 137AudioFlinger::~AudioFlinger() 138{ 139 while (!mRecordThreads.isEmpty()) { 140 // closeInput() will remove first entry from mRecordThreads 141 closeInput(mRecordThreads.keyAt(0)); 142 } 143 while (!mPlaybackThreads.isEmpty()) { 144 // closeOutput() will remove first entry from mPlaybackThreads 145 closeOutput(mPlaybackThreads.keyAt(0)); 146 } 147 if (mAudioHardware) { 148 delete mAudioHardware; 149 } 150} 151 152 153 154status_t AudioFlinger::dumpClients(int fd, const Vector<String16>& args) 155{ 156 const size_t SIZE = 256; 157 char buffer[SIZE]; 158 String8 result; 159 160 result.append("Clients:\n"); 161 for (size_t i = 0; i < mClients.size(); ++i) { 162 wp<Client> wClient = mClients.valueAt(i); 163 if (wClient != 0) { 164 sp<Client> client = wClient.promote(); 165 if (client != 0) { 166 snprintf(buffer, SIZE, " pid: %d\n", client->pid()); 167 result.append(buffer); 168 } 169 } 170 } 171 write(fd, result.string(), result.size()); 172 return NO_ERROR; 173} 174 175 176status_t AudioFlinger::dumpInternals(int fd, const Vector<String16>& args) 177{ 178 const size_t SIZE = 256; 179 char buffer[SIZE]; 180 String8 result; 181 int hardwareStatus = mHardwareStatus; 182 183 snprintf(buffer, SIZE, "Hardware status: %d\n", hardwareStatus); 184 result.append(buffer); 185 write(fd, result.string(), result.size()); 186 return NO_ERROR; 187} 188 189status_t AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args) 190{ 191 const size_t SIZE = 256; 192 char buffer[SIZE]; 193 String8 result; 194 snprintf(buffer, SIZE, "Permission Denial: " 195 "can't dump AudioFlinger from pid=%d, uid=%d\n", 196 IPCThreadState::self()->getCallingPid(), 197 IPCThreadState::self()->getCallingUid()); 198 result.append(buffer); 199 write(fd, result.string(), result.size()); 200 return NO_ERROR; 201} 202 203static bool tryLock(Mutex& mutex) 204{ 205 bool locked = false; 206 for (int i = 0; i < kDumpLockRetries; ++i) { 207 if (mutex.tryLock() == NO_ERROR) { 208 locked = true; 209 break; 210 } 211 usleep(kDumpLockSleep); 212 } 213 return locked; 214} 215 216status_t AudioFlinger::dump(int fd, const Vector<String16>& args) 217{ 218 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 219 dumpPermissionDenial(fd, args); 220 } else { 221 // get state of hardware lock 222 bool hardwareLocked = tryLock(mHardwareLock); 223 if (!hardwareLocked) { 224 String8 result(kHardwareLockedString); 225 write(fd, result.string(), result.size()); 226 } else { 227 mHardwareLock.unlock(); 228 } 229 230 bool locked = tryLock(mLock); 231 232 // failed to lock - AudioFlinger is probably deadlocked 233 if (!locked) { 234 String8 result(kDeadlockedString); 235 write(fd, result.string(), result.size()); 236 } 237 238 dumpClients(fd, args); 239 dumpInternals(fd, args); 240 241 // dump playback threads 242 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 243 mPlaybackThreads.valueAt(i)->dump(fd, args); 244 } 245 246 // dump record threads 247 for (size_t i = 0; i < mRecordThreads.size(); i++) { 248 mRecordThreads.valueAt(i)->dump(fd, args); 249 } 250 251 if (mAudioHardware) { 252 mAudioHardware->dumpState(fd, args); 253 } 254 if (locked) mLock.unlock(); 255 } 256 return NO_ERROR; 257} 258 259 260// IAudioFlinger interface 261 262 263sp<IAudioTrack> AudioFlinger::createTrack( 264 pid_t pid, 265 int streamType, 266 uint32_t sampleRate, 267 int format, 268 int channelCount, 269 int frameCount, 270 uint32_t flags, 271 const sp<IMemory>& sharedBuffer, 272 int output, 273 status_t *status) 274{ 275 sp<PlaybackThread::Track> track; 276 sp<TrackHandle> trackHandle; 277 sp<Client> client; 278 wp<Client> wclient; 279 status_t lStatus; 280 281 if (streamType >= AudioSystem::NUM_STREAM_TYPES) { 282 LOGE("invalid stream type"); 283 lStatus = BAD_VALUE; 284 goto Exit; 285 } 286 287 { 288 Mutex::Autolock _l(mLock); 289 PlaybackThread *thread = checkPlaybackThread_l(output); 290 if (thread == NULL) { 291 LOGE("unknown output thread"); 292 lStatus = BAD_VALUE; 293 goto Exit; 294 } 295 296 wclient = mClients.valueFor(pid); 297 298 if (wclient != NULL) { 299 client = wclient.promote(); 300 } else { 301 client = new Client(this, pid); 302 mClients.add(pid, client); 303 } 304 track = thread->createTrack_l(client, streamType, sampleRate, format, 305 channelCount, frameCount, sharedBuffer, &lStatus); 306 } 307 if (lStatus == NO_ERROR) { 308 trackHandle = new TrackHandle(track); 309 } else { 310 // remove local strong reference to Client before deleting the Track so that the Client 311 // destructor is called by the TrackBase destructor with mLock held 312 client.clear(); 313 track.clear(); 314 } 315 316Exit: 317 if(status) { 318 *status = lStatus; 319 } 320 return trackHandle; 321} 322 323uint32_t AudioFlinger::sampleRate(int output) const 324{ 325 Mutex::Autolock _l(mLock); 326 PlaybackThread *thread = checkPlaybackThread_l(output); 327 if (thread == NULL) { 328 LOGW("sampleRate() unknown thread %d", output); 329 return 0; 330 } 331 return thread->sampleRate(); 332} 333 334int AudioFlinger::channelCount(int output) const 335{ 336 Mutex::Autolock _l(mLock); 337 PlaybackThread *thread = checkPlaybackThread_l(output); 338 if (thread == NULL) { 339 LOGW("channelCount() unknown thread %d", output); 340 return 0; 341 } 342 return thread->channelCount(); 343} 344 345int AudioFlinger::format(int output) const 346{ 347 Mutex::Autolock _l(mLock); 348 PlaybackThread *thread = checkPlaybackThread_l(output); 349 if (thread == NULL) { 350 LOGW("format() unknown thread %d", output); 351 return 0; 352 } 353 return thread->format(); 354} 355 356size_t AudioFlinger::frameCount(int output) const 357{ 358 Mutex::Autolock _l(mLock); 359 PlaybackThread *thread = checkPlaybackThread_l(output); 360 if (thread == NULL) { 361 LOGW("frameCount() unknown thread %d", output); 362 return 0; 363 } 364 return thread->frameCount(); 365} 366 367uint32_t AudioFlinger::latency(int output) const 368{ 369 Mutex::Autolock _l(mLock); 370 PlaybackThread *thread = checkPlaybackThread_l(output); 371 if (thread == NULL) { 372 LOGW("latency() unknown thread %d", output); 373 return 0; 374 } 375 return thread->latency(); 376} 377 378status_t AudioFlinger::setMasterVolume(float value) 379{ 380 // check calling permissions 381 if (!settingsAllowed()) { 382 return PERMISSION_DENIED; 383 } 384 385 // when hw supports master volume, don't scale in sw mixer 386 AutoMutex lock(mHardwareLock); 387 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 388 if (mAudioHardware->setMasterVolume(value) == NO_ERROR) { 389 value = 1.0f; 390 } 391 mHardwareStatus = AUDIO_HW_IDLE; 392 393 mMasterVolume = value; 394 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 395 mPlaybackThreads.valueAt(i)->setMasterVolume(value); 396 397 return NO_ERROR; 398} 399 400status_t AudioFlinger::setMode(int mode) 401{ 402 // check calling permissions 403 if (!settingsAllowed()) { 404 return PERMISSION_DENIED; 405 } 406 if ((mode < 0) || (mode >= AudioSystem::NUM_MODES)) { 407 LOGW("Illegal value: setMode(%d)", mode); 408 return BAD_VALUE; 409 } 410 411 AutoMutex lock(mHardwareLock); 412 mHardwareStatus = AUDIO_HW_SET_MODE; 413 status_t ret = mAudioHardware->setMode(mode); 414 mHardwareStatus = AUDIO_HW_IDLE; 415 return ret; 416} 417 418status_t AudioFlinger::setMicMute(bool state) 419{ 420 // check calling permissions 421 if (!settingsAllowed()) { 422 return PERMISSION_DENIED; 423 } 424 425 AutoMutex lock(mHardwareLock); 426 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE; 427 status_t ret = mAudioHardware->setMicMute(state); 428 mHardwareStatus = AUDIO_HW_IDLE; 429 return ret; 430} 431 432bool AudioFlinger::getMicMute() const 433{ 434 bool state = AudioSystem::MODE_INVALID; 435 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE; 436 mAudioHardware->getMicMute(&state); 437 mHardwareStatus = AUDIO_HW_IDLE; 438 return state; 439} 440 441status_t AudioFlinger::setMasterMute(bool muted) 442{ 443 // check calling permissions 444 if (!settingsAllowed()) { 445 return PERMISSION_DENIED; 446 } 447 448 mMasterMute = muted; 449 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 450 mPlaybackThreads.valueAt(i)->setMasterMute(muted); 451 452 return NO_ERROR; 453} 454 455float AudioFlinger::masterVolume() const 456{ 457 return mMasterVolume; 458} 459 460bool AudioFlinger::masterMute() const 461{ 462 return mMasterMute; 463} 464 465status_t AudioFlinger::setStreamVolume(int stream, float value, int output) 466{ 467 // check calling permissions 468 if (!settingsAllowed()) { 469 return PERMISSION_DENIED; 470 } 471 472 if (stream < 0 || uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) { 473 return BAD_VALUE; 474 } 475 476 AutoMutex lock(mLock); 477 PlaybackThread *thread = NULL; 478 if (output) { 479 thread = checkPlaybackThread_l(output); 480 if (thread == NULL) { 481 return BAD_VALUE; 482 } 483 } 484 485 mStreamTypes[stream].volume = value; 486 487 if (thread == NULL) { 488 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) { 489 mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value); 490 } 491 } else { 492 thread->setStreamVolume(stream, value); 493 } 494 495 return NO_ERROR; 496} 497 498status_t AudioFlinger::setStreamMute(int stream, bool muted) 499{ 500 // check calling permissions 501 if (!settingsAllowed()) { 502 return PERMISSION_DENIED; 503 } 504 505 if (stream < 0 || uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES || 506 uint32_t(stream) == AudioSystem::ENFORCED_AUDIBLE) { 507 return BAD_VALUE; 508 } 509 510 mStreamTypes[stream].mute = muted; 511 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 512 mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted); 513 514 return NO_ERROR; 515} 516 517float AudioFlinger::streamVolume(int stream, int output) const 518{ 519 if (stream < 0 || uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) { 520 return 0.0f; 521 } 522 523 AutoMutex lock(mLock); 524 float volume; 525 if (output) { 526 PlaybackThread *thread = checkPlaybackThread_l(output); 527 if (thread == NULL) { 528 return 0.0f; 529 } 530 volume = thread->streamVolume(stream); 531 } else { 532 volume = mStreamTypes[stream].volume; 533 } 534 535 return volume; 536} 537 538bool AudioFlinger::streamMute(int stream) const 539{ 540 if (stream < 0 || stream >= (int)AudioSystem::NUM_STREAM_TYPES) { 541 return true; 542 } 543 544 return mStreamTypes[stream].mute; 545} 546 547bool AudioFlinger::isMusicActive() const 548{ 549 Mutex::Autolock _l(mLock); 550 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) { 551 if (mPlaybackThreads.valueAt(i)->isMusicActive()) { 552 return true; 553 } 554 } 555 return false; 556} 557 558status_t AudioFlinger::setParameters(int ioHandle, const String8& keyValuePairs) 559{ 560 status_t result; 561 562 LOGV("setParameters(): io %d, keyvalue %s, tid %d, calling tid %d", 563 ioHandle, keyValuePairs.string(), gettid(), IPCThreadState::self()->getCallingPid()); 564 // check calling permissions 565 if (!settingsAllowed()) { 566 return PERMISSION_DENIED; 567 } 568 569 // ioHandle == 0 means the parameters are global to the audio hardware interface 570 if (ioHandle == 0) { 571 AutoMutex lock(mHardwareLock); 572 mHardwareStatus = AUDIO_SET_PARAMETER; 573 result = mAudioHardware->setParameters(keyValuePairs); 574 mHardwareStatus = AUDIO_HW_IDLE; 575 return result; 576 } 577 578 // hold a strong ref on thread in case closeOutput() or closeInput() is called 579 // and the thread is exited once the lock is released 580 sp<ThreadBase> thread; 581 { 582 Mutex::Autolock _l(mLock); 583 thread = checkPlaybackThread_l(ioHandle); 584 if (thread == NULL) { 585 thread = checkRecordThread_l(ioHandle); 586 } 587 } 588 if (thread != NULL) { 589 return thread->setParameters(keyValuePairs); 590 } 591 return BAD_VALUE; 592} 593 594String8 AudioFlinger::getParameters(int ioHandle, const String8& keys) 595{ 596// LOGV("getParameters() io %d, keys %s, tid %d, calling tid %d", 597// ioHandle, keys.string(), gettid(), IPCThreadState::self()->getCallingPid()); 598 599 if (ioHandle == 0) { 600 return mAudioHardware->getParameters(keys); 601 } 602 603 Mutex::Autolock _l(mLock); 604 605 PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle); 606 if (playbackThread != NULL) { 607 return playbackThread->getParameters(keys); 608 } 609 RecordThread *recordThread = checkRecordThread_l(ioHandle); 610 if (recordThread != NULL) { 611 return recordThread->getParameters(keys); 612 } 613 return String8(""); 614} 615 616size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) 617{ 618 return mAudioHardware->getInputBufferSize(sampleRate, format, channelCount); 619} 620 621status_t AudioFlinger::setVoiceVolume(float value) 622{ 623 // check calling permissions 624 if (!settingsAllowed()) { 625 return PERMISSION_DENIED; 626 } 627 628 AutoMutex lock(mHardwareLock); 629 mHardwareStatus = AUDIO_SET_VOICE_VOLUME; 630 status_t ret = mAudioHardware->setVoiceVolume(value); 631 mHardwareStatus = AUDIO_HW_IDLE; 632 633 return ret; 634} 635 636void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client) 637{ 638 639 LOGV("registerClient() %p, tid %d, calling tid %d", client.get(), gettid(), IPCThreadState::self()->getCallingPid()); 640 Mutex::Autolock _l(mLock); 641 642 sp<IBinder> binder = client->asBinder(); 643 if (mNotificationClients.indexOf(binder) < 0) { 644 LOGV("Adding notification client %p", binder.get()); 645 binder->linkToDeath(this); 646 mNotificationClients.add(binder); 647 } 648 649 // the config change is always sent from playback or record threads to avoid deadlock 650 // with AudioSystem::gLock 651 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 652 mPlaybackThreads.valueAt(i)->sendConfigEvent(AudioSystem::OUTPUT_OPENED); 653 } 654 655 for (size_t i = 0; i < mRecordThreads.size(); i++) { 656 mRecordThreads.valueAt(i)->sendConfigEvent(AudioSystem::INPUT_OPENED); 657 } 658} 659 660void AudioFlinger::binderDied(const wp<IBinder>& who) { 661 662 LOGV("binderDied() %p, tid %d, calling tid %d", who.unsafe_get(), gettid(), IPCThreadState::self()->getCallingPid()); 663 Mutex::Autolock _l(mLock); 664 665 IBinder *binder = who.unsafe_get(); 666 667 if (binder != NULL) { 668 int index = mNotificationClients.indexOf(binder); 669 if (index >= 0) { 670 LOGV("Removing notification client %p", binder); 671 mNotificationClients.removeAt(index); 672 } 673 } 674} 675 676// audioConfigChanged_l() must be called with AudioFlinger::mLock held 677void AudioFlinger::audioConfigChanged_l(int event, int ioHandle, void *param2) { 678 size_t size = mNotificationClients.size(); 679 for (size_t i = 0; i < size; i++) { 680 sp<IBinder> binder = mNotificationClients.itemAt(i); 681 LOGV("audioConfigChanged_l() Notifying change to client %p", binder.get()); 682 sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient> (binder); 683 client->ioConfigChanged(event, ioHandle, param2); 684 } 685} 686 687// removeClient_l() must be called with AudioFlinger::mLock held 688void AudioFlinger::removeClient_l(pid_t pid) 689{ 690 LOGV("removeClient_l() pid %d, tid %d, calling tid %d", pid, gettid(), IPCThreadState::self()->getCallingPid()); 691 mClients.removeItem(pid); 692} 693 694// ---------------------------------------------------------------------------- 695 696AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, int id) 697 : Thread(false), 698 mAudioFlinger(audioFlinger), mSampleRate(0), mFrameCount(0), mChannelCount(0), 699 mFormat(0), mFrameSize(1), mStandby(false), mId(id), mExiting(false) 700{ 701} 702 703AudioFlinger::ThreadBase::~ThreadBase() 704{ 705 mParamCond.broadcast(); 706 mNewParameters.clear(); 707} 708 709void AudioFlinger::ThreadBase::exit() 710{ 711 // keep a strong ref on ourself so that we wont get 712 // destroyed in the middle of requestExitAndWait() 713 sp <ThreadBase> strongMe = this; 714 715 LOGV("ThreadBase::exit"); 716 { 717 AutoMutex lock(&mLock); 718 mExiting = true; 719 requestExit(); 720 mWaitWorkCV.signal(); 721 } 722 requestExitAndWait(); 723} 724 725uint32_t AudioFlinger::ThreadBase::sampleRate() const 726{ 727 return mSampleRate; 728} 729 730int AudioFlinger::ThreadBase::channelCount() const 731{ 732 return mChannelCount; 733} 734 735int AudioFlinger::ThreadBase::format() const 736{ 737 return mFormat; 738} 739 740size_t AudioFlinger::ThreadBase::frameCount() const 741{ 742 return mFrameCount; 743} 744 745status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs) 746{ 747 status_t status; 748 749 LOGV("ThreadBase::setParameters() %s", keyValuePairs.string()); 750 Mutex::Autolock _l(mLock); 751 752 mNewParameters.add(keyValuePairs); 753 mWaitWorkCV.signal(); 754 // wait condition with timeout in case the thread loop has exited 755 // before the request could be processed 756 if (mParamCond.waitRelative(mLock, seconds(2)) == NO_ERROR) { 757 status = mParamStatus; 758 mWaitWorkCV.signal(); 759 } else { 760 status = TIMED_OUT; 761 } 762 return status; 763} 764 765void AudioFlinger::ThreadBase::sendConfigEvent(int event, int param) 766{ 767 Mutex::Autolock _l(mLock); 768 sendConfigEvent_l(event, param); 769} 770 771// sendConfigEvent_l() must be called with ThreadBase::mLock held 772void AudioFlinger::ThreadBase::sendConfigEvent_l(int event, int param) 773{ 774 ConfigEvent *configEvent = new ConfigEvent(); 775 configEvent->mEvent = event; 776 configEvent->mParam = param; 777 mConfigEvents.add(configEvent); 778 LOGV("sendConfigEvent() num events %d event %d, param %d", mConfigEvents.size(), event, param); 779 mWaitWorkCV.signal(); 780} 781 782void AudioFlinger::ThreadBase::processConfigEvents() 783{ 784 mLock.lock(); 785 while(!mConfigEvents.isEmpty()) { 786 LOGV("processConfigEvents() remaining events %d", mConfigEvents.size()); 787 ConfigEvent *configEvent = mConfigEvents[0]; 788 mConfigEvents.removeAt(0); 789 // release mLock because audioConfigChanged() will lock AudioFlinger mLock 790 // before calling Audioflinger::audioConfigChanged_l() thus creating 791 // potential cross deadlock between AudioFlinger::mLock and mLock 792 mLock.unlock(); 793 audioConfigChanged(configEvent->mEvent, configEvent->mParam); 794 delete configEvent; 795 mLock.lock(); 796 } 797 mLock.unlock(); 798} 799 800status_t AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args) 801{ 802 const size_t SIZE = 256; 803 char buffer[SIZE]; 804 String8 result; 805 806 bool locked = tryLock(mLock); 807 if (!locked) { 808 snprintf(buffer, SIZE, "thread %p maybe dead locked\n", this); 809 write(fd, buffer, strlen(buffer)); 810 } 811 812 snprintf(buffer, SIZE, "standby: %d\n", mStandby); 813 result.append(buffer); 814 snprintf(buffer, SIZE, "Sample rate: %d\n", mSampleRate); 815 result.append(buffer); 816 snprintf(buffer, SIZE, "Frame count: %d\n", mFrameCount); 817 result.append(buffer); 818 snprintf(buffer, SIZE, "Channel Count: %d\n", mChannelCount); 819 result.append(buffer); 820 snprintf(buffer, SIZE, "Format: %d\n", mFormat); 821 result.append(buffer); 822 snprintf(buffer, SIZE, "Frame size: %d\n", mFrameSize); 823 result.append(buffer); 824 825 snprintf(buffer, SIZE, "\nPending setParameters commands: \n"); 826 result.append(buffer); 827 result.append(" Index Command"); 828 for (size_t i = 0; i < mNewParameters.size(); ++i) { 829 snprintf(buffer, SIZE, "\n %02d ", i); 830 result.append(buffer); 831 result.append(mNewParameters[i]); 832 } 833 834 snprintf(buffer, SIZE, "\n\nPending config events: \n"); 835 result.append(buffer); 836 snprintf(buffer, SIZE, " Index event param\n"); 837 result.append(buffer); 838 for (size_t i = 0; i < mConfigEvents.size(); i++) { 839 snprintf(buffer, SIZE, " %02d %02d %d\n", i, mConfigEvents[i]->mEvent, mConfigEvents[i]->mParam); 840 result.append(buffer); 841 } 842 result.append("\n"); 843 844 write(fd, result.string(), result.size()); 845 846 if (locked) { 847 mLock.unlock(); 848 } 849 return NO_ERROR; 850} 851 852 853// ---------------------------------------------------------------------------- 854 855AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id) 856 : ThreadBase(audioFlinger, id), 857 mMixBuffer(0), mSuspended(0), mBytesWritten(0), mOutput(output), 858 mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false) 859{ 860 readOutputParameters(); 861 862 mMasterVolume = mAudioFlinger->masterVolume(); 863 mMasterMute = mAudioFlinger->masterMute(); 864 865 for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) { 866 mStreamTypes[stream].volume = mAudioFlinger->streamVolumeInternal(stream); 867 mStreamTypes[stream].mute = mAudioFlinger->streamMute(stream); 868 } 869 // notify client processes that a new input has been opened 870 sendConfigEvent(AudioSystem::OUTPUT_OPENED); 871} 872 873AudioFlinger::PlaybackThread::~PlaybackThread() 874{ 875 delete [] mMixBuffer; 876} 877 878status_t AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args) 879{ 880 dumpInternals(fd, args); 881 dumpTracks(fd, args); 882 return NO_ERROR; 883} 884 885status_t AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args) 886{ 887 const size_t SIZE = 256; 888 char buffer[SIZE]; 889 String8 result; 890 891 snprintf(buffer, SIZE, "Output thread %p tracks\n", this); 892 result.append(buffer); 893 result.append(" Name Clien Typ Fmt Chn Buf S M F SRate LeftV RighV Serv User\n"); 894 for (size_t i = 0; i < mTracks.size(); ++i) { 895 sp<Track> track = mTracks[i]; 896 if (track != 0) { 897 track->dump(buffer, SIZE); 898 result.append(buffer); 899 } 900 } 901 902 snprintf(buffer, SIZE, "Output thread %p active tracks\n", this); 903 result.append(buffer); 904 result.append(" Name Clien Typ Fmt Chn Buf S M F SRate LeftV RighV Serv User\n"); 905 for (size_t i = 0; i < mActiveTracks.size(); ++i) { 906 wp<Track> wTrack = mActiveTracks[i]; 907 if (wTrack != 0) { 908 sp<Track> track = wTrack.promote(); 909 if (track != 0) { 910 track->dump(buffer, SIZE); 911 result.append(buffer); 912 } 913 } 914 } 915 write(fd, result.string(), result.size()); 916 return NO_ERROR; 917} 918 919status_t AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args) 920{ 921 const size_t SIZE = 256; 922 char buffer[SIZE]; 923 String8 result; 924 925 snprintf(buffer, SIZE, "\nOutput thread %p internals\n", this); 926 result.append(buffer); 927 snprintf(buffer, SIZE, "last write occurred (msecs): %llu\n", ns2ms(systemTime() - mLastWriteTime)); 928 result.append(buffer); 929 snprintf(buffer, SIZE, "total writes: %d\n", mNumWrites); 930 result.append(buffer); 931 snprintf(buffer, SIZE, "delayed writes: %d\n", mNumDelayedWrites); 932 result.append(buffer); 933 snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite); 934 result.append(buffer); 935 snprintf(buffer, SIZE, "suspend count: %d\n", mSuspended); 936 result.append(buffer); 937 write(fd, result.string(), result.size()); 938 939 dumpBase(fd, args); 940 941 return NO_ERROR; 942} 943 944// Thread virtuals 945status_t AudioFlinger::PlaybackThread::readyToRun() 946{ 947 if (mSampleRate == 0) { 948 LOGE("No working audio driver found."); 949 return NO_INIT; 950 } 951 LOGI("AudioFlinger's thread %p ready to run", this); 952 return NO_ERROR; 953} 954 955void AudioFlinger::PlaybackThread::onFirstRef() 956{ 957 const size_t SIZE = 256; 958 char buffer[SIZE]; 959 960 snprintf(buffer, SIZE, "Playback Thread %p", this); 961 962 run(buffer, ANDROID_PRIORITY_URGENT_AUDIO); 963} 964 965// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held 966sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l( 967 const sp<AudioFlinger::Client>& client, 968 int streamType, 969 uint32_t sampleRate, 970 int format, 971 int channelCount, 972 int frameCount, 973 const sp<IMemory>& sharedBuffer, 974 status_t *status) 975{ 976 sp<Track> track; 977 status_t lStatus; 978 979 if (mType == DIRECT) { 980 if (sampleRate != mSampleRate || format != mFormat || channelCount != mChannelCount) { 981 LOGE("createTrack_l() Bad parameter: sampleRate %d format %d, channelCount %d for output %p", 982 sampleRate, format, channelCount, mOutput); 983 lStatus = BAD_VALUE; 984 goto Exit; 985 } 986 } else { 987 // Resampler implementation limits input sampling rate to 2 x output sampling rate. 988 if (sampleRate > mSampleRate*2) { 989 LOGE("Sample rate out of range: %d mSampleRate %d", sampleRate, mSampleRate); 990 lStatus = BAD_VALUE; 991 goto Exit; 992 } 993 } 994 995 if (mOutput == 0) { 996 LOGE("Audio driver not initialized."); 997 lStatus = NO_INIT; 998 goto Exit; 999 } 1000 1001 { // scope for mLock 1002 Mutex::Autolock _l(mLock); 1003 track = new Track(this, client, streamType, sampleRate, format, 1004 channelCount, frameCount, sharedBuffer); 1005 if (track->getCblk() == NULL || track->name() < 0) { 1006 lStatus = NO_MEMORY; 1007 goto Exit; 1008 } 1009 mTracks.add(track); 1010 } 1011 lStatus = NO_ERROR; 1012 1013Exit: 1014 if(status) { 1015 *status = lStatus; 1016 } 1017 return track; 1018} 1019 1020uint32_t AudioFlinger::PlaybackThread::latency() const 1021{ 1022 if (mOutput) { 1023 return mOutput->latency(); 1024 } 1025 else { 1026 return 0; 1027 } 1028} 1029 1030status_t AudioFlinger::PlaybackThread::setMasterVolume(float value) 1031{ 1032 mMasterVolume = value; 1033 return NO_ERROR; 1034} 1035 1036status_t AudioFlinger::PlaybackThread::setMasterMute(bool muted) 1037{ 1038 mMasterMute = muted; 1039 return NO_ERROR; 1040} 1041 1042float AudioFlinger::PlaybackThread::masterVolume() const 1043{ 1044 return mMasterVolume; 1045} 1046 1047bool AudioFlinger::PlaybackThread::masterMute() const 1048{ 1049 return mMasterMute; 1050} 1051 1052status_t AudioFlinger::PlaybackThread::setStreamVolume(int stream, float value) 1053{ 1054 mStreamTypes[stream].volume = value; 1055 return NO_ERROR; 1056} 1057 1058status_t AudioFlinger::PlaybackThread::setStreamMute(int stream, bool muted) 1059{ 1060 mStreamTypes[stream].mute = muted; 1061 return NO_ERROR; 1062} 1063 1064float AudioFlinger::PlaybackThread::streamVolume(int stream) const 1065{ 1066 return mStreamTypes[stream].volume; 1067} 1068 1069bool AudioFlinger::PlaybackThread::streamMute(int stream) const 1070{ 1071 return mStreamTypes[stream].mute; 1072} 1073 1074bool AudioFlinger::PlaybackThread::isMusicActive() const 1075{ 1076 Mutex::Autolock _l(mLock); 1077 size_t count = mActiveTracks.size(); 1078 for (size_t i = 0 ; i < count ; ++i) { 1079 sp<Track> t = mActiveTracks[i].promote(); 1080 if (t == 0) continue; 1081 Track* const track = t.get(); 1082 if (t->type() == AudioSystem::MUSIC) 1083 return true; 1084 } 1085 return false; 1086} 1087 1088// addTrack_l() must be called with ThreadBase::mLock held 1089status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track) 1090{ 1091 status_t status = ALREADY_EXISTS; 1092 1093 // set retry count for buffer fill 1094 track->mRetryCount = kMaxTrackStartupRetries; 1095 if (mActiveTracks.indexOf(track) < 0) { 1096 // the track is newly added, make sure it fills up all its 1097 // buffers before playing. This is to ensure the client will 1098 // effectively get the latency it requested. 1099 track->mFillingUpStatus = Track::FS_FILLING; 1100 track->mResetDone = false; 1101 mActiveTracks.add(track); 1102 status = NO_ERROR; 1103 } 1104 1105 LOGV("mWaitWorkCV.broadcast"); 1106 mWaitWorkCV.broadcast(); 1107 1108 return status; 1109} 1110 1111// destroyTrack_l() must be called with ThreadBase::mLock held 1112void AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track) 1113{ 1114 track->mState = TrackBase::TERMINATED; 1115 if (mActiveTracks.indexOf(track) < 0) { 1116 mTracks.remove(track); 1117 deleteTrackName_l(track->name()); 1118 } 1119} 1120 1121String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys) 1122{ 1123 return mOutput->getParameters(keys); 1124} 1125 1126void AudioFlinger::PlaybackThread::audioConfigChanged(int event, int param) { 1127 AudioSystem::OutputDescriptor desc; 1128 void *param2 = 0; 1129 1130 LOGV("PlaybackThread::audioConfigChanged, thread %p, event %d, param %d", this, event, param); 1131 1132 switch (event) { 1133 case AudioSystem::OUTPUT_OPENED: 1134 case AudioSystem::OUTPUT_CONFIG_CHANGED: 1135 desc.channels = mChannelCount; 1136 desc.samplingRate = mSampleRate; 1137 desc.format = mFormat; 1138 desc.frameCount = mFrameCount; 1139 desc.latency = latency(); 1140 param2 = &desc; 1141 break; 1142 1143 case AudioSystem::STREAM_CONFIG_CHANGED: 1144 param2 = ¶m; 1145 case AudioSystem::OUTPUT_CLOSED: 1146 default: 1147 break; 1148 } 1149 Mutex::Autolock _l(mAudioFlinger->mLock); 1150 mAudioFlinger->audioConfigChanged_l(event, mId, param2); 1151} 1152 1153void AudioFlinger::PlaybackThread::readOutputParameters() 1154{ 1155 mSampleRate = mOutput->sampleRate(); 1156 mChannelCount = AudioSystem::popCount(mOutput->channels()); 1157 1158 mFormat = mOutput->format(); 1159 mFrameSize = mOutput->frameSize(); 1160 mFrameCount = mOutput->bufferSize() / mFrameSize; 1161 1162 // FIXME - Current mixer implementation only supports stereo output: Always 1163 // Allocate a stereo buffer even if HW output is mono. 1164 if (mMixBuffer != NULL) delete mMixBuffer; 1165 mMixBuffer = new int16_t[mFrameCount * 2]; 1166 memset(mMixBuffer, 0, mFrameCount * 2 * sizeof(int16_t)); 1167} 1168 1169// ---------------------------------------------------------------------------- 1170 1171AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id) 1172 : PlaybackThread(audioFlinger, output, id), 1173 mAudioMixer(0) 1174{ 1175 mType = PlaybackThread::MIXER; 1176 mAudioMixer = new AudioMixer(mFrameCount, mSampleRate); 1177 1178 // FIXME - Current mixer implementation only supports stereo output 1179 if (mChannelCount == 1) { 1180 LOGE("Invalid audio hardware channel count"); 1181 } 1182} 1183 1184AudioFlinger::MixerThread::~MixerThread() 1185{ 1186 delete mAudioMixer; 1187} 1188 1189bool AudioFlinger::MixerThread::threadLoop() 1190{ 1191 int16_t* curBuf = mMixBuffer; 1192 Vector< sp<Track> > tracksToRemove; 1193 uint32_t mixerStatus = MIXER_IDLE; 1194 nsecs_t standbyTime = systemTime(); 1195 size_t mixBufferSize = mFrameCount * mFrameSize; 1196 // FIXME: Relaxed timing because of a certain device that can't meet latency 1197 // Should be reduced to 2x after the vendor fixes the driver issue 1198 nsecs_t maxPeriod = seconds(mFrameCount) / mSampleRate * 3; 1199 nsecs_t lastWarning = 0; 1200 bool longStandbyExit = false; 1201 uint32_t activeSleepTime = activeSleepTimeUs(); 1202 uint32_t idleSleepTime = idleSleepTimeUs(); 1203 uint32_t sleepTime = idleSleepTime; 1204 1205 while (!exitPending()) 1206 { 1207 processConfigEvents(); 1208 1209 mixerStatus = MIXER_IDLE; 1210 { // scope for mLock 1211 1212 Mutex::Autolock _l(mLock); 1213 1214 if (checkForNewParameters_l()) { 1215 mixBufferSize = mFrameCount * mFrameSize; 1216 // FIXME: Relaxed timing because of a certain device that can't meet latency 1217 // Should be reduced to 2x after the vendor fixes the driver issue 1218 maxPeriod = seconds(mFrameCount) / mSampleRate * 3; 1219 activeSleepTime = activeSleepTimeUs(); 1220 idleSleepTime = idleSleepTimeUs(); 1221 } 1222 1223 const SortedVector< wp<Track> >& activeTracks = mActiveTracks; 1224 1225 // put audio hardware into standby after short delay 1226 if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) || 1227 mSuspended) { 1228 if (!mStandby) { 1229 LOGV("Audio hardware entering standby, mixer %p, mSuspended %d\n", this, mSuspended); 1230 mOutput->standby(); 1231 mStandby = true; 1232 mBytesWritten = 0; 1233 } 1234 1235 if (!activeTracks.size() && mConfigEvents.isEmpty()) { 1236 // we're about to wait, flush the binder command buffer 1237 IPCThreadState::self()->flushCommands(); 1238 1239 if (exitPending()) break; 1240 1241 // wait until we have something to do... 1242 LOGV("MixerThread %p TID %d going to sleep\n", this, gettid()); 1243 mWaitWorkCV.wait(mLock); 1244 LOGV("MixerThread %p TID %d waking up\n", this, gettid()); 1245 1246 if (mMasterMute == false) { 1247 char value[PROPERTY_VALUE_MAX]; 1248 property_get("ro.audio.silent", value, "0"); 1249 if (atoi(value)) { 1250 LOGD("Silence is golden"); 1251 setMasterMute(true); 1252 } 1253 } 1254 1255 standbyTime = systemTime() + kStandbyTimeInNsecs; 1256 sleepTime = idleSleepTime; 1257 continue; 1258 } 1259 } 1260 1261 mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove); 1262 } 1263 1264 if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { 1265 // mix buffers... 1266 mAudioMixer->process(curBuf); 1267 sleepTime = 0; 1268 standbyTime = systemTime() + kStandbyTimeInNsecs; 1269 } else { 1270 // If no tracks are ready, sleep once for the duration of an output 1271 // buffer size, then write 0s to the output 1272 if (sleepTime == 0) { 1273 if (mixerStatus == MIXER_TRACKS_ENABLED) { 1274 sleepTime = activeSleepTime; 1275 } else { 1276 sleepTime = idleSleepTime; 1277 } 1278 } else if (mBytesWritten != 0 || 1279 (mixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)) { 1280 memset (curBuf, 0, mixBufferSize); 1281 sleepTime = 0; 1282 LOGV_IF((mBytesWritten == 0 && (mixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)), "anticipated start"); 1283 } 1284 } 1285 1286 if (mSuspended) { 1287 sleepTime = idleSleepTime; 1288 } 1289 // sleepTime == 0 means we must write to audio hardware 1290 if (sleepTime == 0) { 1291 mLastWriteTime = systemTime(); 1292 mInWrite = true; 1293 int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize); 1294 if (bytesWritten > 0) mBytesWritten += bytesWritten; 1295 mNumWrites++; 1296 mInWrite = false; 1297 nsecs_t now = systemTime(); 1298 nsecs_t delta = now - mLastWriteTime; 1299 if (delta > maxPeriod) { 1300 mNumDelayedWrites++; 1301 if ((now - lastWarning) > kWarningThrottle) { 1302 LOGW("write blocked for %llu msecs, %d delayed writes, thread %p", 1303 ns2ms(delta), mNumDelayedWrites, this); 1304 lastWarning = now; 1305 } 1306 if (mStandby) { 1307 longStandbyExit = true; 1308 } 1309 } 1310 mStandby = false; 1311 } else { 1312 usleep(sleepTime); 1313 } 1314 1315 // finally let go of all our tracks, without the lock held 1316 // since we can't guarantee the destructors won't acquire that 1317 // same lock. 1318 tracksToRemove.clear(); 1319 } 1320 1321 if (!mStandby) { 1322 mOutput->standby(); 1323 } 1324 1325 LOGV("MixerThread %p exiting", this); 1326 return false; 1327} 1328 1329// prepareTracks_l() must be called with ThreadBase::mLock held 1330uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp<Track> >& activeTracks, Vector< sp<Track> > *tracksToRemove) 1331{ 1332 1333 uint32_t mixerStatus = MIXER_IDLE; 1334 // find out which tracks need to be processed 1335 size_t count = activeTracks.size(); 1336 for (size_t i=0 ; i<count ; i++) { 1337 sp<Track> t = activeTracks[i].promote(); 1338 if (t == 0) continue; 1339 1340 Track* const track = t.get(); 1341 audio_track_cblk_t* cblk = track->cblk(); 1342 1343 // The first time a track is added we wait 1344 // for all its buffers to be filled before processing it 1345 mAudioMixer->setActiveTrack(track->name()); 1346 if (cblk->framesReady() && (track->isReady() || track->isStopped()) && 1347 !track->isPaused()) 1348 { 1349 //LOGV("track %d u=%08x, s=%08x [OK] on thread %p", track->name(), cblk->user, cblk->server, this); 1350 1351 // compute volume for this track 1352 int16_t left, right; 1353 if (track->isMuted() || mMasterMute || track->isPausing() || 1354 mStreamTypes[track->type()].mute) { 1355 left = right = 0; 1356 if (track->isPausing()) { 1357 track->setPaused(); 1358 } 1359 } else { 1360 float typeVolume = mStreamTypes[track->type()].volume; 1361 float v = mMasterVolume * typeVolume; 1362 float v_clamped = v * cblk->volume[0]; 1363 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN; 1364 left = int16_t(v_clamped); 1365 v_clamped = v * cblk->volume[1]; 1366 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN; 1367 right = int16_t(v_clamped); 1368 } 1369 1370 // XXX: these things DON'T need to be done each time 1371 mAudioMixer->setBufferProvider(track); 1372 mAudioMixer->enable(AudioMixer::MIXING); 1373 1374 int param = AudioMixer::VOLUME; 1375 if (track->mFillingUpStatus == Track::FS_FILLED) { 1376 // no ramp for the first volume setting 1377 track->mFillingUpStatus = Track::FS_ACTIVE; 1378 if (track->mState == TrackBase::RESUMING) { 1379 track->mState = TrackBase::ACTIVE; 1380 param = AudioMixer::RAMP_VOLUME; 1381 } 1382 } else if (cblk->server != 0) { 1383 // If the track is stopped before the first frame was mixed, 1384 // do not apply ramp 1385 param = AudioMixer::RAMP_VOLUME; 1386 } 1387 1388 mAudioMixer->setParameter(param, AudioMixer::VOLUME0, left); 1389 mAudioMixer->setParameter(param, AudioMixer::VOLUME1, right); 1390 mAudioMixer->setParameter( 1391 AudioMixer::TRACK, 1392 AudioMixer::FORMAT, track->format()); 1393 mAudioMixer->setParameter( 1394 AudioMixer::TRACK, 1395 AudioMixer::CHANNEL_COUNT, track->channelCount()); 1396 mAudioMixer->setParameter( 1397 AudioMixer::RESAMPLE, 1398 AudioMixer::SAMPLE_RATE, 1399 int(cblk->sampleRate)); 1400 1401 // reset retry count 1402 track->mRetryCount = kMaxTrackRetries; 1403 mixerStatus = MIXER_TRACKS_READY; 1404 } else { 1405 //LOGV("track %d u=%08x, s=%08x [NOT READY] on thread %p", track->name(), cblk->user, cblk->server, this); 1406 if (track->isStopped()) { 1407 track->reset(); 1408 } 1409 if (track->isTerminated() || track->isStopped() || track->isPaused()) { 1410 // We have consumed all the buffers of this track. 1411 // Remove it from the list of active tracks. 1412 tracksToRemove->add(track); 1413 mAudioMixer->disable(AudioMixer::MIXING); 1414 } else { 1415 // No buffers for this track. Give it a few chances to 1416 // fill a buffer, then remove it from active list. 1417 if (--(track->mRetryCount) <= 0) { 1418 LOGV("BUFFER TIMEOUT: remove(%d) from active list on thread %p", track->name(), this); 1419 tracksToRemove->add(track); 1420 } else if (mixerStatus != MIXER_TRACKS_READY) { 1421 mixerStatus = MIXER_TRACKS_ENABLED; 1422 } 1423 1424 mAudioMixer->disable(AudioMixer::MIXING); 1425 } 1426 } 1427 } 1428 1429 // remove all the tracks that need to be... 1430 count = tracksToRemove->size(); 1431 if (UNLIKELY(count)) { 1432 for (size_t i=0 ; i<count ; i++) { 1433 const sp<Track>& track = tracksToRemove->itemAt(i); 1434 mActiveTracks.remove(track); 1435 if (track->isTerminated()) { 1436 mTracks.remove(track); 1437 deleteTrackName_l(track->mName); 1438 } 1439 } 1440 } 1441 1442 return mixerStatus; 1443} 1444 1445void AudioFlinger::MixerThread::getTracks( 1446 SortedVector < sp<Track> >& tracks, 1447 SortedVector < wp<Track> >& activeTracks, 1448 int streamType) 1449{ 1450 LOGV ("MixerThread::getTracks() mixer %p, mTracks.size %d, mActiveTracks.size %d", this, mTracks.size(), mActiveTracks.size()); 1451 Mutex::Autolock _l(mLock); 1452 size_t size = mTracks.size(); 1453 for (size_t i = 0; i < size; i++) { 1454 sp<Track> t = mTracks[i]; 1455 if (t->type() == streamType) { 1456 tracks.add(t); 1457 int j = mActiveTracks.indexOf(t); 1458 if (j >= 0) { 1459 t = mActiveTracks[j].promote(); 1460 if (t != NULL) { 1461 activeTracks.add(t); 1462 } 1463 } 1464 } 1465 } 1466 1467 size = activeTracks.size(); 1468 for (size_t i = 0; i < size; i++) { 1469 mActiveTracks.remove(activeTracks[i]); 1470 } 1471 1472 size = tracks.size(); 1473 for (size_t i = 0; i < size; i++) { 1474 sp<Track> t = tracks[i]; 1475 mTracks.remove(t); 1476 deleteTrackName_l(t->name()); 1477 } 1478} 1479 1480void AudioFlinger::MixerThread::putTracks( 1481 SortedVector < sp<Track> >& tracks, 1482 SortedVector < wp<Track> >& activeTracks) 1483{ 1484 LOGV ("MixerThread::putTracks() mixer %p, tracks.size %d, activeTracks.size %d", this, tracks.size(), activeTracks.size()); 1485 Mutex::Autolock _l(mLock); 1486 size_t size = tracks.size(); 1487 for (size_t i = 0; i < size ; i++) { 1488 sp<Track> t = tracks[i]; 1489 int name = getTrackName_l(); 1490 1491 if (name < 0) return; 1492 1493 t->mName = name; 1494 t->mThread = this; 1495 mTracks.add(t); 1496 1497 int j = activeTracks.indexOf(t); 1498 if (j >= 0) { 1499 mActiveTracks.add(t); 1500 // force buffer refilling and no ramp volume when the track is mixed for the first time 1501 t->mFillingUpStatus = Track::FS_FILLING; 1502 } 1503 } 1504} 1505 1506// getTrackName_l() must be called with ThreadBase::mLock held 1507int AudioFlinger::MixerThread::getTrackName_l() 1508{ 1509 return mAudioMixer->getTrackName(); 1510} 1511 1512// deleteTrackName_l() must be called with ThreadBase::mLock held 1513void AudioFlinger::MixerThread::deleteTrackName_l(int name) 1514{ 1515 LOGV("remove track (%d) and delete from mixer", name); 1516 mAudioMixer->deleteTrackName(name); 1517} 1518 1519// checkForNewParameters_l() must be called with ThreadBase::mLock held 1520bool AudioFlinger::MixerThread::checkForNewParameters_l() 1521{ 1522 bool reconfig = false; 1523 1524 while (!mNewParameters.isEmpty()) { 1525 status_t status = NO_ERROR; 1526 String8 keyValuePair = mNewParameters[0]; 1527 AudioParameter param = AudioParameter(keyValuePair); 1528 int value; 1529 1530 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) { 1531 reconfig = true; 1532 } 1533 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) { 1534 if (value != AudioSystem::PCM_16_BIT) { 1535 status = BAD_VALUE; 1536 } else { 1537 reconfig = true; 1538 } 1539 } 1540 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) { 1541 if (value != AudioSystem::CHANNEL_OUT_STEREO) { 1542 status = BAD_VALUE; 1543 } else { 1544 reconfig = true; 1545 } 1546 } 1547 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { 1548 // do not accept frame count changes if tracks are open as the track buffer 1549 // size depends on frame count and correct behavior would not be garantied 1550 // if frame count is changed after track creation 1551 if (!mTracks.isEmpty()) { 1552 status = INVALID_OPERATION; 1553 } else { 1554 reconfig = true; 1555 } 1556 } 1557 if (status == NO_ERROR) { 1558 status = mOutput->setParameters(keyValuePair); 1559 if (!mStandby && status == INVALID_OPERATION) { 1560 mOutput->standby(); 1561 mStandby = true; 1562 mBytesWritten = 0; 1563 status = mOutput->setParameters(keyValuePair); 1564 } 1565 if (status == NO_ERROR && reconfig) { 1566 delete mAudioMixer; 1567 readOutputParameters(); 1568 mAudioMixer = new AudioMixer(mFrameCount, mSampleRate); 1569 for (size_t i = 0; i < mTracks.size() ; i++) { 1570 int name = getTrackName_l(); 1571 if (name < 0) break; 1572 mTracks[i]->mName = name; 1573 // limit track sample rate to 2 x new output sample rate 1574 if (mTracks[i]->mCblk->sampleRate > 2 * sampleRate()) { 1575 mTracks[i]->mCblk->sampleRate = 2 * sampleRate(); 1576 } 1577 } 1578 sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED); 1579 } 1580 } 1581 1582 mNewParameters.removeAt(0); 1583 1584 mParamStatus = status; 1585 mParamCond.signal(); 1586 mWaitWorkCV.wait(mLock); 1587 } 1588 return reconfig; 1589} 1590 1591status_t AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args) 1592{ 1593 const size_t SIZE = 256; 1594 char buffer[SIZE]; 1595 String8 result; 1596 1597 PlaybackThread::dumpInternals(fd, args); 1598 1599 snprintf(buffer, SIZE, "AudioMixer tracks: %08x\n", mAudioMixer->trackNames()); 1600 result.append(buffer); 1601 write(fd, result.string(), result.size()); 1602 return NO_ERROR; 1603} 1604 1605uint32_t AudioFlinger::MixerThread::activeSleepTimeUs() 1606{ 1607 return (uint32_t)(mOutput->latency() * 1000) / 2; 1608} 1609 1610uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() 1611{ 1612 return (uint32_t)((mFrameCount * 1000) / mSampleRate) * 1000; 1613} 1614 1615// ---------------------------------------------------------------------------- 1616AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id) 1617 : PlaybackThread(audioFlinger, output, id), 1618 mLeftVolume (1.0), mRightVolume(1.0) 1619{ 1620 mType = PlaybackThread::DIRECT; 1621} 1622 1623AudioFlinger::DirectOutputThread::~DirectOutputThread() 1624{ 1625} 1626 1627 1628bool AudioFlinger::DirectOutputThread::threadLoop() 1629{ 1630 uint32_t mixerStatus = MIXER_IDLE; 1631 sp<Track> trackToRemove; 1632 sp<Track> activeTrack; 1633 nsecs_t standbyTime = systemTime(); 1634 int8_t *curBuf; 1635 size_t mixBufferSize = mFrameCount*mFrameSize; 1636 uint32_t activeSleepTime = activeSleepTimeUs(); 1637 uint32_t idleSleepTime = idleSleepTimeUs(); 1638 uint32_t sleepTime = idleSleepTime; 1639 1640 1641 while (!exitPending()) 1642 { 1643 processConfigEvents(); 1644 1645 mixerStatus = MIXER_IDLE; 1646 1647 { // scope for the mLock 1648 1649 Mutex::Autolock _l(mLock); 1650 1651 if (checkForNewParameters_l()) { 1652 mixBufferSize = mFrameCount*mFrameSize; 1653 activeSleepTime = activeSleepTimeUs(); 1654 idleSleepTime = idleSleepTimeUs(); 1655 } 1656 1657 // put audio hardware into standby after short delay 1658 if UNLIKELY((!mActiveTracks.size() && systemTime() > standbyTime) || 1659 mSuspended) { 1660 // wait until we have something to do... 1661 if (!mStandby) { 1662 LOGV("Audio hardware entering standby, mixer %p\n", this); 1663 mOutput->standby(); 1664 mStandby = true; 1665 mBytesWritten = 0; 1666 } 1667 1668 if (!mActiveTracks.size() && mConfigEvents.isEmpty()) { 1669 // we're about to wait, flush the binder command buffer 1670 IPCThreadState::self()->flushCommands(); 1671 1672 if (exitPending()) break; 1673 1674 LOGV("DirectOutputThread %p TID %d going to sleep\n", this, gettid()); 1675 mWaitWorkCV.wait(mLock); 1676 LOGV("DirectOutputThread %p TID %d waking up in active mode\n", this, gettid()); 1677 1678 if (mMasterMute == false) { 1679 char value[PROPERTY_VALUE_MAX]; 1680 property_get("ro.audio.silent", value, "0"); 1681 if (atoi(value)) { 1682 LOGD("Silence is golden"); 1683 setMasterMute(true); 1684 } 1685 } 1686 1687 standbyTime = systemTime() + kStandbyTimeInNsecs; 1688 sleepTime = idleSleepTime; 1689 continue; 1690 } 1691 } 1692 1693 // find out which tracks need to be processed 1694 if (mActiveTracks.size() != 0) { 1695 sp<Track> t = mActiveTracks[0].promote(); 1696 if (t == 0) continue; 1697 1698 Track* const track = t.get(); 1699 audio_track_cblk_t* cblk = track->cblk(); 1700 1701 // The first time a track is added we wait 1702 // for all its buffers to be filled before processing it 1703 if (cblk->framesReady() && (track->isReady() || track->isStopped()) && 1704 !track->isPaused()) 1705 { 1706 //LOGV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server); 1707 1708 // compute volume for this track 1709 float left, right; 1710 if (track->isMuted() || mMasterMute || track->isPausing() || 1711 mStreamTypes[track->type()].mute) { 1712 left = right = 0; 1713 if (track->isPausing()) { 1714 track->setPaused(); 1715 } 1716 } else { 1717 float typeVolume = mStreamTypes[track->type()].volume; 1718 float v = mMasterVolume * typeVolume; 1719 float v_clamped = v * cblk->volume[0]; 1720 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN; 1721 left = v_clamped/MAX_GAIN; 1722 v_clamped = v * cblk->volume[1]; 1723 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN; 1724 right = v_clamped/MAX_GAIN; 1725 } 1726 1727 if (left != mLeftVolume || right != mRightVolume) { 1728 mOutput->setVolume(left, right); 1729 left = mLeftVolume; 1730 right = mRightVolume; 1731 } 1732 1733 if (track->mFillingUpStatus == Track::FS_FILLED) { 1734 track->mFillingUpStatus = Track::FS_ACTIVE; 1735 if (track->mState == TrackBase::RESUMING) { 1736 track->mState = TrackBase::ACTIVE; 1737 } 1738 } 1739 1740 // reset retry count 1741 track->mRetryCount = kMaxTrackRetries; 1742 activeTrack = t; 1743 mixerStatus = MIXER_TRACKS_READY; 1744 } else { 1745 //LOGV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server); 1746 if (track->isStopped()) { 1747 track->reset(); 1748 } 1749 if (track->isTerminated() || track->isStopped() || track->isPaused()) { 1750 // We have consumed all the buffers of this track. 1751 // Remove it from the list of active tracks. 1752 trackToRemove = track; 1753 } else { 1754 // No buffers for this track. Give it a few chances to 1755 // fill a buffer, then remove it from active list. 1756 if (--(track->mRetryCount) <= 0) { 1757 LOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name()); 1758 trackToRemove = track; 1759 } else { 1760 mixerStatus = MIXER_TRACKS_ENABLED; 1761 } 1762 } 1763 } 1764 } 1765 1766 // remove all the tracks that need to be... 1767 if (UNLIKELY(trackToRemove != 0)) { 1768 mActiveTracks.remove(trackToRemove); 1769 if (trackToRemove->isTerminated()) { 1770 mTracks.remove(trackToRemove); 1771 deleteTrackName_l(trackToRemove->mName); 1772 } 1773 } 1774 } 1775 1776 if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { 1777 AudioBufferProvider::Buffer buffer; 1778 size_t frameCount = mFrameCount; 1779 curBuf = (int8_t *)mMixBuffer; 1780 // output audio to hardware 1781 while(frameCount) { 1782 buffer.frameCount = frameCount; 1783 activeTrack->getNextBuffer(&buffer); 1784 if (UNLIKELY(buffer.raw == 0)) { 1785 memset(curBuf, 0, frameCount * mFrameSize); 1786 break; 1787 } 1788 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize); 1789 frameCount -= buffer.frameCount; 1790 curBuf += buffer.frameCount * mFrameSize; 1791 activeTrack->releaseBuffer(&buffer); 1792 } 1793 sleepTime = 0; 1794 standbyTime = systemTime() + kStandbyTimeInNsecs; 1795 } else { 1796 if (sleepTime == 0) { 1797 if (mixerStatus == MIXER_TRACKS_ENABLED) { 1798 sleepTime = activeSleepTime; 1799 } else { 1800 sleepTime = idleSleepTime; 1801 } 1802 } else if (mBytesWritten != 0 && AudioSystem::isLinearPCM(mFormat)) { 1803 memset (mMixBuffer, 0, mFrameCount * mFrameSize); 1804 sleepTime = 0; 1805 } 1806 } 1807 1808 if (mSuspended) { 1809 sleepTime = idleSleepTime; 1810 } 1811 // sleepTime == 0 means we must write to audio hardware 1812 if (sleepTime == 0) { 1813 mLastWriteTime = systemTime(); 1814 mInWrite = true; 1815 int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize); 1816 if (bytesWritten) mBytesWritten += bytesWritten; 1817 mNumWrites++; 1818 mInWrite = false; 1819 mStandby = false; 1820 } else { 1821 usleep(sleepTime); 1822 } 1823 1824 // finally let go of removed track, without the lock held 1825 // since we can't guarantee the destructors won't acquire that 1826 // same lock. 1827 trackToRemove.clear(); 1828 activeTrack.clear(); 1829 } 1830 1831 if (!mStandby) { 1832 mOutput->standby(); 1833 } 1834 1835 LOGV("DirectOutputThread %p exiting", this); 1836 return false; 1837} 1838 1839// getTrackName_l() must be called with ThreadBase::mLock held 1840int AudioFlinger::DirectOutputThread::getTrackName_l() 1841{ 1842 return 0; 1843} 1844 1845// deleteTrackName_l() must be called with ThreadBase::mLock held 1846void AudioFlinger::DirectOutputThread::deleteTrackName_l(int name) 1847{ 1848} 1849 1850// checkForNewParameters_l() must be called with ThreadBase::mLock held 1851bool AudioFlinger::DirectOutputThread::checkForNewParameters_l() 1852{ 1853 bool reconfig = false; 1854 1855 while (!mNewParameters.isEmpty()) { 1856 status_t status = NO_ERROR; 1857 String8 keyValuePair = mNewParameters[0]; 1858 AudioParameter param = AudioParameter(keyValuePair); 1859 int value; 1860 1861 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { 1862 // do not accept frame count changes if tracks are open as the track buffer 1863 // size depends on frame count and correct behavior would not be garantied 1864 // if frame count is changed after track creation 1865 if (!mTracks.isEmpty()) { 1866 status = INVALID_OPERATION; 1867 } else { 1868 reconfig = true; 1869 } 1870 } 1871 if (status == NO_ERROR) { 1872 status = mOutput->setParameters(keyValuePair); 1873 if (!mStandby && status == INVALID_OPERATION) { 1874 mOutput->standby(); 1875 mStandby = true; 1876 mBytesWritten = 0; 1877 status = mOutput->setParameters(keyValuePair); 1878 } 1879 if (status == NO_ERROR && reconfig) { 1880 readOutputParameters(); 1881 sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED); 1882 } 1883 } 1884 1885 mNewParameters.removeAt(0); 1886 1887 mParamStatus = status; 1888 mParamCond.signal(); 1889 mWaitWorkCV.wait(mLock); 1890 } 1891 return reconfig; 1892} 1893 1894uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() 1895{ 1896 uint32_t time; 1897 if (AudioSystem::isLinearPCM(mFormat)) { 1898 time = (uint32_t)(mOutput->latency() * 1000) / 2; 1899 } else { 1900 time = 10000; 1901 } 1902 return time; 1903} 1904 1905uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() 1906{ 1907 uint32_t time; 1908 if (AudioSystem::isLinearPCM(mFormat)) { 1909 time = (uint32_t)((mFrameCount * 1000) / mSampleRate) * 1000; 1910 } else { 1911 time = 10000; 1912 } 1913 return time; 1914} 1915 1916// ---------------------------------------------------------------------------- 1917 1918AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger, AudioFlinger::MixerThread* mainThread, int id) 1919 : MixerThread(audioFlinger, mainThread->getOutput(), id), mWaitTimeMs(UINT_MAX) 1920{ 1921 mType = PlaybackThread::DUPLICATING; 1922 addOutputTrack(mainThread); 1923} 1924 1925AudioFlinger::DuplicatingThread::~DuplicatingThread() 1926{ 1927 for (size_t i = 0; i < mOutputTracks.size(); i++) { 1928 mOutputTracks[i]->destroy(); 1929 } 1930 mOutputTracks.clear(); 1931} 1932 1933bool AudioFlinger::DuplicatingThread::threadLoop() 1934{ 1935 int16_t* curBuf = mMixBuffer; 1936 Vector< sp<Track> > tracksToRemove; 1937 uint32_t mixerStatus = MIXER_IDLE; 1938 nsecs_t standbyTime = systemTime(); 1939 size_t mixBufferSize = mFrameCount*mFrameSize; 1940 SortedVector< sp<OutputTrack> > outputTracks; 1941 uint32_t writeFrames = 0; 1942 uint32_t activeSleepTime = activeSleepTimeUs(); 1943 uint32_t idleSleepTime = idleSleepTimeUs(); 1944 uint32_t sleepTime = idleSleepTime; 1945 1946 while (!exitPending()) 1947 { 1948 processConfigEvents(); 1949 1950 mixerStatus = MIXER_IDLE; 1951 { // scope for the mLock 1952 1953 Mutex::Autolock _l(mLock); 1954 1955 if (checkForNewParameters_l()) { 1956 mixBufferSize = mFrameCount*mFrameSize; 1957 updateWaitTime(); 1958 activeSleepTime = activeSleepTimeUs(); 1959 idleSleepTime = idleSleepTimeUs(); 1960 } 1961 1962 const SortedVector< wp<Track> >& activeTracks = mActiveTracks; 1963 1964 for (size_t i = 0; i < mOutputTracks.size(); i++) { 1965 outputTracks.add(mOutputTracks[i]); 1966 } 1967 1968 // put audio hardware into standby after short delay 1969 if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) || 1970 mSuspended) { 1971 if (!mStandby) { 1972 for (size_t i = 0; i < outputTracks.size(); i++) { 1973 outputTracks[i]->stop(); 1974 } 1975 mStandby = true; 1976 mBytesWritten = 0; 1977 } 1978 1979 if (!activeTracks.size() && mConfigEvents.isEmpty()) { 1980 // we're about to wait, flush the binder command buffer 1981 IPCThreadState::self()->flushCommands(); 1982 outputTracks.clear(); 1983 1984 if (exitPending()) break; 1985 1986 LOGV("DuplicatingThread %p TID %d going to sleep\n", this, gettid()); 1987 mWaitWorkCV.wait(mLock); 1988 LOGV("DuplicatingThread %p TID %d waking up\n", this, gettid()); 1989 if (mMasterMute == false) { 1990 char value[PROPERTY_VALUE_MAX]; 1991 property_get("ro.audio.silent", value, "0"); 1992 if (atoi(value)) { 1993 LOGD("Silence is golden"); 1994 setMasterMute(true); 1995 } 1996 } 1997 1998 standbyTime = systemTime() + kStandbyTimeInNsecs; 1999 sleepTime = idleSleepTime; 2000 continue; 2001 } 2002 } 2003 2004 mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove); 2005 } 2006 2007 if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) { 2008 // mix buffers... 2009 if (outputsReady(outputTracks)) { 2010 mAudioMixer->process(curBuf); 2011 } else { 2012 memset(curBuf, 0, mixBufferSize); 2013 } 2014 sleepTime = 0; 2015 writeFrames = mFrameCount; 2016 } else { 2017 if (sleepTime == 0) { 2018 if (mixerStatus == MIXER_TRACKS_ENABLED) { 2019 sleepTime = activeSleepTime; 2020 } else { 2021 sleepTime = idleSleepTime; 2022 } 2023 } else if (mBytesWritten != 0) { 2024 // flush remaining overflow buffers in output tracks 2025 for (size_t i = 0; i < outputTracks.size(); i++) { 2026 if (outputTracks[i]->isActive()) { 2027 sleepTime = 0; 2028 writeFrames = 0; 2029 break; 2030 } 2031 } 2032 } 2033 } 2034 2035 if (mSuspended) { 2036 sleepTime = idleSleepTime; 2037 } 2038 // sleepTime == 0 means we must write to audio hardware 2039 if (sleepTime == 0) { 2040 standbyTime = systemTime() + kStandbyTimeInNsecs; 2041 for (size_t i = 0; i < outputTracks.size(); i++) { 2042 outputTracks[i]->write(curBuf, writeFrames); 2043 } 2044 mStandby = false; 2045 mBytesWritten += mixBufferSize; 2046 } else { 2047 usleep(sleepTime); 2048 } 2049 2050 // finally let go of all our tracks, without the lock held 2051 // since we can't guarantee the destructors won't acquire that 2052 // same lock. 2053 tracksToRemove.clear(); 2054 outputTracks.clear(); 2055 } 2056 2057 return false; 2058} 2059 2060void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread) 2061{ 2062 int frameCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate(); 2063 OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread, 2064 this, 2065 mSampleRate, 2066 mFormat, 2067 mChannelCount, 2068 frameCount); 2069 if (outputTrack->cblk() != NULL) { 2070 thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f); 2071 mOutputTracks.add(outputTrack); 2072 LOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread); 2073 updateWaitTime(); 2074 } 2075} 2076 2077void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread) 2078{ 2079 Mutex::Autolock _l(mLock); 2080 for (size_t i = 0; i < mOutputTracks.size(); i++) { 2081 if (mOutputTracks[i]->thread() == (ThreadBase *)thread) { 2082 mOutputTracks[i]->destroy(); 2083 mOutputTracks.removeAt(i); 2084 updateWaitTime(); 2085 return; 2086 } 2087 } 2088 LOGV("removeOutputTrack(): unkonwn thread: %p", thread); 2089} 2090 2091void AudioFlinger::DuplicatingThread::updateWaitTime() 2092{ 2093 mWaitTimeMs = UINT_MAX; 2094 for (size_t i = 0; i < mOutputTracks.size(); i++) { 2095 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote(); 2096 if (strong != NULL) { 2097 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate(); 2098 if (waitTimeMs < mWaitTimeMs) { 2099 mWaitTimeMs = waitTimeMs; 2100 } 2101 } 2102 } 2103} 2104 2105 2106bool AudioFlinger::DuplicatingThread::outputsReady(SortedVector< sp<OutputTrack> > &outputTracks) 2107{ 2108 for (size_t i = 0; i < outputTracks.size(); i++) { 2109 sp <ThreadBase> thread = outputTracks[i]->thread().promote(); 2110 if (thread == 0) { 2111 LOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p", outputTracks[i].get()); 2112 return false; 2113 } 2114 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 2115 if (playbackThread->standby() && !playbackThread->isSuspended()) { 2116 LOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(), thread.get()); 2117 return false; 2118 } 2119 } 2120 return true; 2121} 2122 2123uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() 2124{ 2125 return (mWaitTimeMs * 1000) / 2; 2126} 2127 2128// ---------------------------------------------------------------------------- 2129 2130// TrackBase constructor must be called with AudioFlinger::mLock held 2131AudioFlinger::ThreadBase::TrackBase::TrackBase( 2132 const wp<ThreadBase>& thread, 2133 const sp<Client>& client, 2134 uint32_t sampleRate, 2135 int format, 2136 int channelCount, 2137 int frameCount, 2138 uint32_t flags, 2139 const sp<IMemory>& sharedBuffer) 2140 : RefBase(), 2141 mThread(thread), 2142 mClient(client), 2143 mCblk(0), 2144 mFrameCount(0), 2145 mState(IDLE), 2146 mClientTid(-1), 2147 mFormat(format), 2148 mFlags(flags & ~SYSTEM_FLAGS_MASK) 2149{ 2150 LOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size()); 2151 2152 // LOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize); 2153 size_t size = sizeof(audio_track_cblk_t); 2154 size_t bufferSize = frameCount*channelCount*sizeof(int16_t); 2155 if (sharedBuffer == 0) { 2156 size += bufferSize; 2157 } 2158 2159 if (client != NULL) { 2160 mCblkMemory = client->heap()->allocate(size); 2161 if (mCblkMemory != 0) { 2162 mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer()); 2163 if (mCblk) { // construct the shared structure in-place. 2164 new(mCblk) audio_track_cblk_t(); 2165 // clear all buffers 2166 mCblk->frameCount = frameCount; 2167 mCblk->sampleRate = sampleRate; 2168 mCblk->channels = (uint8_t)channelCount; 2169 if (sharedBuffer == 0) { 2170 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 2171 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t)); 2172 // Force underrun condition to avoid false underrun callback until first data is 2173 // written to buffer 2174 mCblk->flowControlFlag = 1; 2175 } else { 2176 mBuffer = sharedBuffer->pointer(); 2177 } 2178 mBufferEnd = (uint8_t *)mBuffer + bufferSize; 2179 } 2180 } else { 2181 LOGE("not enough memory for AudioTrack size=%u", size); 2182 client->heap()->dump("AudioTrack"); 2183 return; 2184 } 2185 } else { 2186 mCblk = (audio_track_cblk_t *)(new uint8_t[size]); 2187 if (mCblk) { // construct the shared structure in-place. 2188 new(mCblk) audio_track_cblk_t(); 2189 // clear all buffers 2190 mCblk->frameCount = frameCount; 2191 mCblk->sampleRate = sampleRate; 2192 mCblk->channels = (uint8_t)channelCount; 2193 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t); 2194 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t)); 2195 // Force underrun condition to avoid false underrun callback until first data is 2196 // written to buffer 2197 mCblk->flowControlFlag = 1; 2198 mBufferEnd = (uint8_t *)mBuffer + bufferSize; 2199 } 2200 } 2201} 2202 2203AudioFlinger::ThreadBase::TrackBase::~TrackBase() 2204{ 2205 if (mCblk) { 2206 mCblk->~audio_track_cblk_t(); // destroy our shared-structure. 2207 if (mClient == NULL) { 2208 delete mCblk; 2209 } 2210 } 2211 mCblkMemory.clear(); // and free the shared memory 2212 if (mClient != NULL) { 2213 Mutex::Autolock _l(mClient->audioFlinger()->mLock); 2214 mClient.clear(); 2215 } 2216} 2217 2218void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer) 2219{ 2220 buffer->raw = 0; 2221 mFrameCount = buffer->frameCount; 2222 step(); 2223 buffer->frameCount = 0; 2224} 2225 2226bool AudioFlinger::ThreadBase::TrackBase::step() { 2227 bool result; 2228 audio_track_cblk_t* cblk = this->cblk(); 2229 2230 result = cblk->stepServer(mFrameCount); 2231 if (!result) { 2232 LOGV("stepServer failed acquiring cblk mutex"); 2233 mFlags |= STEPSERVER_FAILED; 2234 } 2235 return result; 2236} 2237 2238void AudioFlinger::ThreadBase::TrackBase::reset() { 2239 audio_track_cblk_t* cblk = this->cblk(); 2240 2241 cblk->user = 0; 2242 cblk->server = 0; 2243 cblk->userBase = 0; 2244 cblk->serverBase = 0; 2245 mFlags &= (uint32_t)(~SYSTEM_FLAGS_MASK); 2246 LOGV("TrackBase::reset"); 2247} 2248 2249sp<IMemory> AudioFlinger::ThreadBase::TrackBase::getCblk() const 2250{ 2251 return mCblkMemory; 2252} 2253 2254int AudioFlinger::ThreadBase::TrackBase::sampleRate() const { 2255 return (int)mCblk->sampleRate; 2256} 2257 2258int AudioFlinger::ThreadBase::TrackBase::channelCount() const { 2259 return (int)mCblk->channels; 2260} 2261 2262void* AudioFlinger::ThreadBase::TrackBase::getBuffer(uint32_t offset, uint32_t frames) const { 2263 audio_track_cblk_t* cblk = this->cblk(); 2264 int8_t *bufferStart = (int8_t *)mBuffer + (offset-cblk->serverBase)*cblk->frameSize; 2265 int8_t *bufferEnd = bufferStart + frames * cblk->frameSize; 2266 2267 // Check validity of returned pointer in case the track control block would have been corrupted. 2268 if (bufferStart < mBuffer || bufferStart > bufferEnd || bufferEnd > mBufferEnd || 2269 ((unsigned long)bufferStart & (unsigned long)(cblk->frameSize - 1))) { 2270 LOGE("TrackBase::getBuffer buffer out of range:\n start: %p, end %p , mBuffer %p mBufferEnd %p\n \ 2271 server %d, serverBase %d, user %d, userBase %d, channels %d", 2272 bufferStart, bufferEnd, mBuffer, mBufferEnd, 2273 cblk->server, cblk->serverBase, cblk->user, cblk->userBase, cblk->channels); 2274 return 0; 2275 } 2276 2277 return bufferStart; 2278} 2279 2280// ---------------------------------------------------------------------------- 2281 2282// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held 2283AudioFlinger::PlaybackThread::Track::Track( 2284 const wp<ThreadBase>& thread, 2285 const sp<Client>& client, 2286 int streamType, 2287 uint32_t sampleRate, 2288 int format, 2289 int channelCount, 2290 int frameCount, 2291 const sp<IMemory>& sharedBuffer) 2292 : TrackBase(thread, client, sampleRate, format, channelCount, frameCount, 0, sharedBuffer), 2293 mMute(false), mSharedBuffer(sharedBuffer), mName(-1) 2294{ 2295 if (mCblk != NULL) { 2296 sp<ThreadBase> baseThread = thread.promote(); 2297 if (baseThread != 0) { 2298 PlaybackThread *playbackThread = (PlaybackThread *)baseThread.get(); 2299 mName = playbackThread->getTrackName_l(); 2300 } 2301 LOGV("Track constructor name %d, calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 2302 if (mName < 0) { 2303 LOGE("no more track names available"); 2304 } 2305 mVolume[0] = 1.0f; 2306 mVolume[1] = 1.0f; 2307 mStreamType = streamType; 2308 // NOTE: audio_track_cblk_t::frameSize for 8 bit PCM data is based on a sample size of 2309 // 16 bit because data is converted to 16 bit before being stored in buffer by AudioTrack 2310 mCblk->frameSize = AudioSystem::isLinearPCM(format) ? channelCount * sizeof(int16_t) : sizeof(int8_t); 2311 } 2312} 2313 2314AudioFlinger::PlaybackThread::Track::~Track() 2315{ 2316 LOGV("PlaybackThread::Track destructor"); 2317 sp<ThreadBase> thread = mThread.promote(); 2318 if (thread != 0) { 2319 Mutex::Autolock _l(thread->mLock); 2320 mState = TERMINATED; 2321 } 2322} 2323 2324void AudioFlinger::PlaybackThread::Track::destroy() 2325{ 2326 // NOTE: destroyTrack_l() can remove a strong reference to this Track 2327 // by removing it from mTracks vector, so there is a risk that this Tracks's 2328 // desctructor is called. As the destructor needs to lock mLock, 2329 // we must acquire a strong reference on this Track before locking mLock 2330 // here so that the destructor is called only when exiting this function. 2331 // On the other hand, as long as Track::destroy() is only called by 2332 // TrackHandle destructor, the TrackHandle still holds a strong ref on 2333 // this Track with its member mTrack. 2334 sp<Track> keep(this); 2335 { // scope for mLock 2336 sp<ThreadBase> thread = mThread.promote(); 2337 if (thread != 0) { 2338 if (!isOutputTrack()) { 2339 if (mState == ACTIVE || mState == RESUMING) { 2340 AudioSystem::stopOutput(thread->id(), (AudioSystem::stream_type)mStreamType); 2341 } 2342 AudioSystem::releaseOutput(thread->id()); 2343 } 2344 Mutex::Autolock _l(thread->mLock); 2345 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 2346 playbackThread->destroyTrack_l(this); 2347 } 2348 } 2349} 2350 2351void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size) 2352{ 2353 snprintf(buffer, size, " %5d %5d %3u %3u %3u %04u %1d %1d %1d %5u %5u %5u %08x %08x\n", 2354 mName - AudioMixer::TRACK0, 2355 (mClient == NULL) ? getpid() : mClient->pid(), 2356 mStreamType, 2357 mFormat, 2358 mCblk->channels, 2359 mFrameCount, 2360 mState, 2361 mMute, 2362 mFillingUpStatus, 2363 mCblk->sampleRate, 2364 mCblk->volume[0], 2365 mCblk->volume[1], 2366 mCblk->server, 2367 mCblk->user); 2368} 2369 2370status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer) 2371{ 2372 audio_track_cblk_t* cblk = this->cblk(); 2373 uint32_t framesReady; 2374 uint32_t framesReq = buffer->frameCount; 2375 2376 // Check if last stepServer failed, try to step now 2377 if (mFlags & TrackBase::STEPSERVER_FAILED) { 2378 if (!step()) goto getNextBuffer_exit; 2379 LOGV("stepServer recovered"); 2380 mFlags &= ~TrackBase::STEPSERVER_FAILED; 2381 } 2382 2383 framesReady = cblk->framesReady(); 2384 2385 if (LIKELY(framesReady)) { 2386 uint32_t s = cblk->server; 2387 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount; 2388 2389 bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd : bufferEnd; 2390 if (framesReq > framesReady) { 2391 framesReq = framesReady; 2392 } 2393 if (s + framesReq > bufferEnd) { 2394 framesReq = bufferEnd - s; 2395 } 2396 2397 buffer->raw = getBuffer(s, framesReq); 2398 if (buffer->raw == 0) goto getNextBuffer_exit; 2399 2400 buffer->frameCount = framesReq; 2401 return NO_ERROR; 2402 } 2403 2404getNextBuffer_exit: 2405 buffer->raw = 0; 2406 buffer->frameCount = 0; 2407 LOGV("getNextBuffer() no more data for track %d on thread %p", mName, mThread.unsafe_get()); 2408 return NOT_ENOUGH_DATA; 2409} 2410 2411bool AudioFlinger::PlaybackThread::Track::isReady() const { 2412 if (mFillingUpStatus != FS_FILLING) return true; 2413 2414 if (mCblk->framesReady() >= mCblk->frameCount || 2415 mCblk->forceReady) { 2416 mFillingUpStatus = FS_FILLED; 2417 mCblk->forceReady = 0; 2418 return true; 2419 } 2420 return false; 2421} 2422 2423status_t AudioFlinger::PlaybackThread::Track::start() 2424{ 2425 status_t status = NO_ERROR; 2426 LOGV("start(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 2427 sp<ThreadBase> thread = mThread.promote(); 2428 if (thread != 0) { 2429 Mutex::Autolock _l(thread->mLock); 2430 int state = mState; 2431 // here the track could be either new, or restarted 2432 // in both cases "unstop" the track 2433 if (mState == PAUSED) { 2434 mState = TrackBase::RESUMING; 2435 LOGV("PAUSED => RESUMING (%d) on thread %p", mName, this); 2436 } else { 2437 mState = TrackBase::ACTIVE; 2438 LOGV("? => ACTIVE (%d) on thread %p", mName, this); 2439 } 2440 2441 if (!isOutputTrack() && state != ACTIVE && state != RESUMING) { 2442 thread->mLock.unlock(); 2443 status = AudioSystem::startOutput(thread->id(), (AudioSystem::stream_type)mStreamType); 2444 thread->mLock.lock(); 2445 } 2446 if (status == NO_ERROR) { 2447 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 2448 playbackThread->addTrack_l(this); 2449 } else { 2450 mState = state; 2451 } 2452 } else { 2453 status = BAD_VALUE; 2454 } 2455 return status; 2456} 2457 2458void AudioFlinger::PlaybackThread::Track::stop() 2459{ 2460 LOGV("stop(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 2461 sp<ThreadBase> thread = mThread.promote(); 2462 if (thread != 0) { 2463 Mutex::Autolock _l(thread->mLock); 2464 int state = mState; 2465 if (mState > STOPPED) { 2466 mState = STOPPED; 2467 // If the track is not active (PAUSED and buffers full), flush buffers 2468 PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); 2469 if (playbackThread->mActiveTracks.indexOf(this) < 0) { 2470 reset(); 2471 } 2472 LOGV("(> STOPPED) => STOPPED (%d) on thread %p", mName, playbackThread); 2473 } 2474 if (!isOutputTrack() && (state == ACTIVE || state == RESUMING)) { 2475 thread->mLock.unlock(); 2476 AudioSystem::stopOutput(thread->id(), (AudioSystem::stream_type)mStreamType); 2477 thread->mLock.lock(); 2478 } 2479 } 2480} 2481 2482void AudioFlinger::PlaybackThread::Track::pause() 2483{ 2484 LOGV("pause(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid()); 2485 sp<ThreadBase> thread = mThread.promote(); 2486 if (thread != 0) { 2487 Mutex::Autolock _l(thread->mLock); 2488 if (mState == ACTIVE || mState == RESUMING) { 2489 mState = PAUSING; 2490 LOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get()); 2491 if (!isOutputTrack()) { 2492 thread->mLock.unlock(); 2493 AudioSystem::stopOutput(thread->id(), (AudioSystem::stream_type)mStreamType); 2494 thread->mLock.lock(); 2495 } 2496 } 2497 } 2498} 2499 2500void AudioFlinger::PlaybackThread::Track::flush() 2501{ 2502 LOGV("flush(%d)", mName); 2503 sp<ThreadBase> thread = mThread.promote(); 2504 if (thread != 0) { 2505 Mutex::Autolock _l(thread->mLock); 2506 if (mState != STOPPED && mState != PAUSED && mState != PAUSING) { 2507 return; 2508 } 2509 // No point remaining in PAUSED state after a flush => go to 2510 // STOPPED state 2511 mState = STOPPED; 2512 2513 mCblk->lock.lock(); 2514 // NOTE: reset() will reset cblk->user and cblk->server with 2515 // the risk that at the same time, the AudioMixer is trying to read 2516 // data. In this case, getNextBuffer() would return a NULL pointer 2517 // as audio buffer => the AudioMixer code MUST always test that pointer 2518 // returned by getNextBuffer() is not NULL! 2519 reset(); 2520 mCblk->lock.unlock(); 2521 } 2522} 2523 2524void AudioFlinger::PlaybackThread::Track::reset() 2525{ 2526 // Do not reset twice to avoid discarding data written just after a flush and before 2527 // the audioflinger thread detects the track is stopped. 2528 if (!mResetDone) { 2529 TrackBase::reset(); 2530 // Force underrun condition to avoid false underrun callback until first data is 2531 // written to buffer 2532 mCblk->flowControlFlag = 1; 2533 mCblk->forceReady = 0; 2534 mFillingUpStatus = FS_FILLING; 2535 mResetDone = true; 2536 } 2537} 2538 2539void AudioFlinger::PlaybackThread::Track::mute(bool muted) 2540{ 2541 mMute = muted; 2542} 2543 2544void AudioFlinger::PlaybackThread::Track::setVolume(float left, float right) 2545{ 2546 mVolume[0] = left; 2547 mVolume[1] = right; 2548} 2549 2550// ---------------------------------------------------------------------------- 2551 2552// RecordTrack constructor must be called with AudioFlinger::mLock held 2553AudioFlinger::RecordThread::RecordTrack::RecordTrack( 2554 const wp<ThreadBase>& thread, 2555 const sp<Client>& client, 2556 uint32_t sampleRate, 2557 int format, 2558 int channelCount, 2559 int frameCount, 2560 uint32_t flags) 2561 : TrackBase(thread, client, sampleRate, format, 2562 channelCount, frameCount, flags, 0), 2563 mOverflow(false) 2564{ 2565 if (mCblk != NULL) { 2566 LOGV("RecordTrack constructor, size %d", (int)mBufferEnd - (int)mBuffer); 2567 if (format == AudioSystem::PCM_16_BIT) { 2568 mCblk->frameSize = channelCount * sizeof(int16_t); 2569 } else if (format == AudioSystem::PCM_8_BIT) { 2570 mCblk->frameSize = channelCount * sizeof(int8_t); 2571 } else { 2572 mCblk->frameSize = sizeof(int8_t); 2573 } 2574 } 2575} 2576 2577AudioFlinger::RecordThread::RecordTrack::~RecordTrack() 2578{ 2579 sp<ThreadBase> thread = mThread.promote(); 2580 if (thread != 0) { 2581 AudioSystem::releaseInput(thread->id()); 2582 } 2583} 2584 2585status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer) 2586{ 2587 audio_track_cblk_t* cblk = this->cblk(); 2588 uint32_t framesAvail; 2589 uint32_t framesReq = buffer->frameCount; 2590 2591 // Check if last stepServer failed, try to step now 2592 if (mFlags & TrackBase::STEPSERVER_FAILED) { 2593 if (!step()) goto getNextBuffer_exit; 2594 LOGV("stepServer recovered"); 2595 mFlags &= ~TrackBase::STEPSERVER_FAILED; 2596 } 2597 2598 framesAvail = cblk->framesAvailable_l(); 2599 2600 if (LIKELY(framesAvail)) { 2601 uint32_t s = cblk->server; 2602 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount; 2603 2604 if (framesReq > framesAvail) { 2605 framesReq = framesAvail; 2606 } 2607 if (s + framesReq > bufferEnd) { 2608 framesReq = bufferEnd - s; 2609 } 2610 2611 buffer->raw = getBuffer(s, framesReq); 2612 if (buffer->raw == 0) goto getNextBuffer_exit; 2613 2614 buffer->frameCount = framesReq; 2615 return NO_ERROR; 2616 } 2617 2618getNextBuffer_exit: 2619 buffer->raw = 0; 2620 buffer->frameCount = 0; 2621 return NOT_ENOUGH_DATA; 2622} 2623 2624status_t AudioFlinger::RecordThread::RecordTrack::start() 2625{ 2626 sp<ThreadBase> thread = mThread.promote(); 2627 if (thread != 0) { 2628 RecordThread *recordThread = (RecordThread *)thread.get(); 2629 return recordThread->start(this); 2630 } else { 2631 return BAD_VALUE; 2632 } 2633} 2634 2635void AudioFlinger::RecordThread::RecordTrack::stop() 2636{ 2637 sp<ThreadBase> thread = mThread.promote(); 2638 if (thread != 0) { 2639 RecordThread *recordThread = (RecordThread *)thread.get(); 2640 recordThread->stop(this); 2641 TrackBase::reset(); 2642 // Force overerrun condition to avoid false overrun callback until first data is 2643 // read from buffer 2644 mCblk->flowControlFlag = 1; 2645 } 2646} 2647 2648void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size) 2649{ 2650 snprintf(buffer, size, " %05d %03u %03u %04u %01d %05u %08x %08x\n", 2651 (mClient == NULL) ? getpid() : mClient->pid(), 2652 mFormat, 2653 mCblk->channels, 2654 mFrameCount, 2655 mState, 2656 mCblk->sampleRate, 2657 mCblk->server, 2658 mCblk->user); 2659} 2660 2661 2662// ---------------------------------------------------------------------------- 2663 2664AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( 2665 const wp<ThreadBase>& thread, 2666 DuplicatingThread *sourceThread, 2667 uint32_t sampleRate, 2668 int format, 2669 int channelCount, 2670 int frameCount) 2671 : Track(thread, NULL, AudioSystem::NUM_STREAM_TYPES, sampleRate, format, channelCount, frameCount, NULL), 2672 mActive(false), mSourceThread(sourceThread) 2673{ 2674 2675 PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get(); 2676 if (mCblk != NULL) { 2677 mCblk->out = 1; 2678 mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t); 2679 mCblk->volume[0] = mCblk->volume[1] = 0x1000; 2680 mOutBuffer.frameCount = 0; 2681 playbackThread->mTracks.add(this); 2682 LOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, mCblk->frameCount %d, mCblk->sampleRate %d, mCblk->channels %d mBufferEnd %p", 2683 mCblk, mBuffer, mCblk->buffers, mCblk->frameCount, mCblk->sampleRate, mCblk->channels, mBufferEnd); 2684 } else { 2685 LOGW("Error creating output track on thread %p", playbackThread); 2686 } 2687} 2688 2689AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack() 2690{ 2691 clearBufferQueue(); 2692} 2693 2694status_t AudioFlinger::PlaybackThread::OutputTrack::start() 2695{ 2696 status_t status = Track::start(); 2697 if (status != NO_ERROR) { 2698 return status; 2699 } 2700 2701 mActive = true; 2702 mRetryCount = 127; 2703 return status; 2704} 2705 2706void AudioFlinger::PlaybackThread::OutputTrack::stop() 2707{ 2708 Track::stop(); 2709 clearBufferQueue(); 2710 mOutBuffer.frameCount = 0; 2711 mActive = false; 2712} 2713 2714bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames) 2715{ 2716 Buffer *pInBuffer; 2717 Buffer inBuffer; 2718 uint32_t channels = mCblk->channels; 2719 bool outputBufferFull = false; 2720 inBuffer.frameCount = frames; 2721 inBuffer.i16 = data; 2722 2723 uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs(); 2724 2725 if (!mActive && frames != 0) { 2726 start(); 2727 sp<ThreadBase> thread = mThread.promote(); 2728 if (thread != 0) { 2729 MixerThread *mixerThread = (MixerThread *)thread.get(); 2730 if (mCblk->frameCount > frames){ 2731 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 2732 uint32_t startFrames = (mCblk->frameCount - frames); 2733 pInBuffer = new Buffer; 2734 pInBuffer->mBuffer = new int16_t[startFrames * channels]; 2735 pInBuffer->frameCount = startFrames; 2736 pInBuffer->i16 = pInBuffer->mBuffer; 2737 memset(pInBuffer->raw, 0, startFrames * channels * sizeof(int16_t)); 2738 mBufferQueue.add(pInBuffer); 2739 } else { 2740 LOGW ("OutputTrack::write() %p no more buffers in queue", this); 2741 } 2742 } 2743 } 2744 } 2745 2746 while (waitTimeLeftMs) { 2747 // First write pending buffers, then new data 2748 if (mBufferQueue.size()) { 2749 pInBuffer = mBufferQueue.itemAt(0); 2750 } else { 2751 pInBuffer = &inBuffer; 2752 } 2753 2754 if (pInBuffer->frameCount == 0) { 2755 break; 2756 } 2757 2758 if (mOutBuffer.frameCount == 0) { 2759 mOutBuffer.frameCount = pInBuffer->frameCount; 2760 nsecs_t startTime = systemTime(); 2761 if (obtainBuffer(&mOutBuffer, waitTimeLeftMs) == (status_t)AudioTrack::NO_MORE_BUFFERS) { 2762 LOGV ("OutputTrack::write() %p thread %p no more output buffers", this, mThread.unsafe_get()); 2763 outputBufferFull = true; 2764 break; 2765 } 2766 uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime); 2767 if (waitTimeLeftMs >= waitTimeMs) { 2768 waitTimeLeftMs -= waitTimeMs; 2769 } else { 2770 waitTimeLeftMs = 0; 2771 } 2772 } 2773 2774 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : pInBuffer->frameCount; 2775 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channels * sizeof(int16_t)); 2776 mCblk->stepUser(outFrames); 2777 pInBuffer->frameCount -= outFrames; 2778 pInBuffer->i16 += outFrames * channels; 2779 mOutBuffer.frameCount -= outFrames; 2780 mOutBuffer.i16 += outFrames * channels; 2781 2782 if (pInBuffer->frameCount == 0) { 2783 if (mBufferQueue.size()) { 2784 mBufferQueue.removeAt(0); 2785 delete [] pInBuffer->mBuffer; 2786 delete pInBuffer; 2787 LOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size()); 2788 } else { 2789 break; 2790 } 2791 } 2792 } 2793 2794 // If we could not write all frames, allocate a buffer and queue it for next time. 2795 if (inBuffer.frameCount) { 2796 sp<ThreadBase> thread = mThread.promote(); 2797 if (thread != 0 && !thread->standby()) { 2798 if (mBufferQueue.size() < kMaxOverFlowBuffers) { 2799 pInBuffer = new Buffer; 2800 pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels]; 2801 pInBuffer->frameCount = inBuffer.frameCount; 2802 pInBuffer->i16 = pInBuffer->mBuffer; 2803 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channels * sizeof(int16_t)); 2804 mBufferQueue.add(pInBuffer); 2805 LOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size()); 2806 } else { 2807 LOGW("OutputTrack::write() %p thread %p no more overflow buffers", mThread.unsafe_get(), this); 2808 } 2809 } 2810 } 2811 2812 // Calling write() with a 0 length buffer, means that no more data will be written: 2813 // If no more buffers are pending, fill output track buffer to make sure it is started 2814 // by output mixer. 2815 if (frames == 0 && mBufferQueue.size() == 0) { 2816 if (mCblk->user < mCblk->frameCount) { 2817 frames = mCblk->frameCount - mCblk->user; 2818 pInBuffer = new Buffer; 2819 pInBuffer->mBuffer = new int16_t[frames * channels]; 2820 pInBuffer->frameCount = frames; 2821 pInBuffer->i16 = pInBuffer->mBuffer; 2822 memset(pInBuffer->raw, 0, frames * channels * sizeof(int16_t)); 2823 mBufferQueue.add(pInBuffer); 2824 } else if (mActive) { 2825 stop(); 2826 } 2827 } 2828 2829 return outputBufferFull; 2830} 2831 2832status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs) 2833{ 2834 int active; 2835 status_t result; 2836 audio_track_cblk_t* cblk = mCblk; 2837 uint32_t framesReq = buffer->frameCount; 2838 2839// LOGV("OutputTrack::obtainBuffer user %d, server %d", cblk->user, cblk->server); 2840 buffer->frameCount = 0; 2841 2842 uint32_t framesAvail = cblk->framesAvailable(); 2843 2844 2845 if (framesAvail == 0) { 2846 Mutex::Autolock _l(cblk->lock); 2847 goto start_loop_here; 2848 while (framesAvail == 0) { 2849 active = mActive; 2850 if (UNLIKELY(!active)) { 2851 LOGV("Not active and NO_MORE_BUFFERS"); 2852 return AudioTrack::NO_MORE_BUFFERS; 2853 } 2854 result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs)); 2855 if (result != NO_ERROR) { 2856 return AudioTrack::NO_MORE_BUFFERS; 2857 } 2858 // read the server count again 2859 start_loop_here: 2860 framesAvail = cblk->framesAvailable_l(); 2861 } 2862 } 2863 2864// if (framesAvail < framesReq) { 2865// return AudioTrack::NO_MORE_BUFFERS; 2866// } 2867 2868 if (framesReq > framesAvail) { 2869 framesReq = framesAvail; 2870 } 2871 2872 uint32_t u = cblk->user; 2873 uint32_t bufferEnd = cblk->userBase + cblk->frameCount; 2874 2875 if (u + framesReq > bufferEnd) { 2876 framesReq = bufferEnd - u; 2877 } 2878 2879 buffer->frameCount = framesReq; 2880 buffer->raw = (void *)cblk->buffer(u); 2881 return NO_ERROR; 2882} 2883 2884 2885void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue() 2886{ 2887 size_t size = mBufferQueue.size(); 2888 Buffer *pBuffer; 2889 2890 for (size_t i = 0; i < size; i++) { 2891 pBuffer = mBufferQueue.itemAt(i); 2892 delete [] pBuffer->mBuffer; 2893 delete pBuffer; 2894 } 2895 mBufferQueue.clear(); 2896} 2897 2898// ---------------------------------------------------------------------------- 2899 2900AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid) 2901 : RefBase(), 2902 mAudioFlinger(audioFlinger), 2903 mMemoryDealer(new MemoryDealer(1024*1024)), 2904 mPid(pid) 2905{ 2906 // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer 2907} 2908 2909// Client destructor must be called with AudioFlinger::mLock held 2910AudioFlinger::Client::~Client() 2911{ 2912 mAudioFlinger->removeClient_l(mPid); 2913} 2914 2915const sp<MemoryDealer>& AudioFlinger::Client::heap() const 2916{ 2917 return mMemoryDealer; 2918} 2919 2920// ---------------------------------------------------------------------------- 2921 2922AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track) 2923 : BnAudioTrack(), 2924 mTrack(track) 2925{ 2926} 2927 2928AudioFlinger::TrackHandle::~TrackHandle() { 2929 // just stop the track on deletion, associated resources 2930 // will be freed from the main thread once all pending buffers have 2931 // been played. Unless it's not in the active track list, in which 2932 // case we free everything now... 2933 mTrack->destroy(); 2934} 2935 2936status_t AudioFlinger::TrackHandle::start() { 2937 return mTrack->start(); 2938} 2939 2940void AudioFlinger::TrackHandle::stop() { 2941 mTrack->stop(); 2942} 2943 2944void AudioFlinger::TrackHandle::flush() { 2945 mTrack->flush(); 2946} 2947 2948void AudioFlinger::TrackHandle::mute(bool e) { 2949 mTrack->mute(e); 2950} 2951 2952void AudioFlinger::TrackHandle::pause() { 2953 mTrack->pause(); 2954} 2955 2956void AudioFlinger::TrackHandle::setVolume(float left, float right) { 2957 mTrack->setVolume(left, right); 2958} 2959 2960sp<IMemory> AudioFlinger::TrackHandle::getCblk() const { 2961 return mTrack->getCblk(); 2962} 2963 2964status_t AudioFlinger::TrackHandle::onTransact( 2965 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 2966{ 2967 return BnAudioTrack::onTransact(code, data, reply, flags); 2968} 2969 2970// ---------------------------------------------------------------------------- 2971 2972sp<IAudioRecord> AudioFlinger::openRecord( 2973 pid_t pid, 2974 int input, 2975 uint32_t sampleRate, 2976 int format, 2977 int channelCount, 2978 int frameCount, 2979 uint32_t flags, 2980 status_t *status) 2981{ 2982 sp<RecordThread::RecordTrack> recordTrack; 2983 sp<RecordHandle> recordHandle; 2984 sp<Client> client; 2985 wp<Client> wclient; 2986 status_t lStatus; 2987 RecordThread *thread; 2988 size_t inFrameCount; 2989 2990 // check calling permissions 2991 if (!recordingAllowed()) { 2992 lStatus = PERMISSION_DENIED; 2993 goto Exit; 2994 } 2995 2996 // add client to list 2997 { // scope for mLock 2998 Mutex::Autolock _l(mLock); 2999 thread = checkRecordThread_l(input); 3000 if (thread == NULL) { 3001 lStatus = BAD_VALUE; 3002 goto Exit; 3003 } 3004 3005 wclient = mClients.valueFor(pid); 3006 if (wclient != NULL) { 3007 client = wclient.promote(); 3008 } else { 3009 client = new Client(this, pid); 3010 mClients.add(pid, client); 3011 } 3012 3013 // create new record track. The record track uses one track in mHardwareMixerThread by convention. 3014 recordTrack = new RecordThread::RecordTrack(thread, client, sampleRate, 3015 format, channelCount, frameCount, flags); 3016 } 3017 if (recordTrack->getCblk() == NULL) { 3018 // remove local strong reference to Client before deleting the RecordTrack so that the Client 3019 // destructor is called by the TrackBase destructor with mLock held 3020 client.clear(); 3021 recordTrack.clear(); 3022 lStatus = NO_MEMORY; 3023 goto Exit; 3024 } 3025 3026 // return to handle to client 3027 recordHandle = new RecordHandle(recordTrack); 3028 lStatus = NO_ERROR; 3029 3030Exit: 3031 if (status) { 3032 *status = lStatus; 3033 } 3034 return recordHandle; 3035} 3036 3037// ---------------------------------------------------------------------------- 3038 3039AudioFlinger::RecordHandle::RecordHandle(const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack) 3040 : BnAudioRecord(), 3041 mRecordTrack(recordTrack) 3042{ 3043} 3044 3045AudioFlinger::RecordHandle::~RecordHandle() { 3046 stop(); 3047} 3048 3049status_t AudioFlinger::RecordHandle::start() { 3050 LOGV("RecordHandle::start()"); 3051 return mRecordTrack->start(); 3052} 3053 3054void AudioFlinger::RecordHandle::stop() { 3055 LOGV("RecordHandle::stop()"); 3056 mRecordTrack->stop(); 3057} 3058 3059sp<IMemory> AudioFlinger::RecordHandle::getCblk() const { 3060 return mRecordTrack->getCblk(); 3061} 3062 3063status_t AudioFlinger::RecordHandle::onTransact( 3064 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 3065{ 3066 return BnAudioRecord::onTransact(code, data, reply, flags); 3067} 3068 3069// ---------------------------------------------------------------------------- 3070 3071AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger, AudioStreamIn *input, uint32_t sampleRate, uint32_t channels, int id) : 3072 ThreadBase(audioFlinger, id), 3073 mInput(input), mResampler(0), mRsmpOutBuffer(0), mRsmpInBuffer(0) 3074{ 3075 mReqChannelCount = AudioSystem::popCount(channels); 3076 mReqSampleRate = sampleRate; 3077 readInputParameters(); 3078 sendConfigEvent(AudioSystem::INPUT_OPENED); 3079} 3080 3081 3082AudioFlinger::RecordThread::~RecordThread() 3083{ 3084 delete[] mRsmpInBuffer; 3085 if (mResampler != 0) { 3086 delete mResampler; 3087 delete[] mRsmpOutBuffer; 3088 } 3089} 3090 3091void AudioFlinger::RecordThread::onFirstRef() 3092{ 3093 const size_t SIZE = 256; 3094 char buffer[SIZE]; 3095 3096 snprintf(buffer, SIZE, "Record Thread %p", this); 3097 3098 run(buffer, PRIORITY_URGENT_AUDIO); 3099} 3100 3101bool AudioFlinger::RecordThread::threadLoop() 3102{ 3103 AudioBufferProvider::Buffer buffer; 3104 sp<RecordTrack> activeTrack; 3105 3106 // start recording 3107 while (!exitPending()) { 3108 3109 processConfigEvents(); 3110 3111 { // scope for mLock 3112 Mutex::Autolock _l(mLock); 3113 checkForNewParameters_l(); 3114 if (mActiveTrack == 0 && mConfigEvents.isEmpty()) { 3115 if (!mStandby) { 3116 mInput->standby(); 3117 mStandby = true; 3118 } 3119 3120 if (exitPending()) break; 3121 3122 LOGV("RecordThread: loop stopping"); 3123 // go to sleep 3124 mWaitWorkCV.wait(mLock); 3125 LOGV("RecordThread: loop starting"); 3126 continue; 3127 } 3128 if (mActiveTrack != 0) { 3129 if (mActiveTrack->mState == TrackBase::PAUSING) { 3130 if (!mStandby) { 3131 mInput->standby(); 3132 mStandby = true; 3133 } 3134 mActiveTrack.clear(); 3135 mStartStopCond.broadcast(); 3136 } else if (mActiveTrack->mState == TrackBase::RESUMING) { 3137 if (mReqChannelCount != mActiveTrack->channelCount()) { 3138 mActiveTrack.clear(); 3139 mStartStopCond.broadcast(); 3140 } else if (mBytesRead != 0) { 3141 // record start succeeds only if first read from audio input 3142 // succeeds 3143 if (mBytesRead > 0) { 3144 mActiveTrack->mState = TrackBase::ACTIVE; 3145 } else { 3146 mActiveTrack.clear(); 3147 } 3148 mStartStopCond.broadcast(); 3149 } 3150 mStandby = false; 3151 } 3152 } 3153 } 3154 3155 if (mActiveTrack != 0) { 3156 if (mActiveTrack->mState != TrackBase::ACTIVE && 3157 mActiveTrack->mState != TrackBase::RESUMING) { 3158 usleep(5000); 3159 continue; 3160 } 3161 buffer.frameCount = mFrameCount; 3162 if (LIKELY(mActiveTrack->getNextBuffer(&buffer) == NO_ERROR)) { 3163 size_t framesOut = buffer.frameCount; 3164 if (mResampler == 0) { 3165 // no resampling 3166 while (framesOut) { 3167 size_t framesIn = mFrameCount - mRsmpInIndex; 3168 if (framesIn) { 3169 int8_t *src = (int8_t *)mRsmpInBuffer + mRsmpInIndex * mFrameSize; 3170 int8_t *dst = buffer.i8 + (buffer.frameCount - framesOut) * mActiveTrack->mCblk->frameSize; 3171 if (framesIn > framesOut) 3172 framesIn = framesOut; 3173 mRsmpInIndex += framesIn; 3174 framesOut -= framesIn; 3175 if (mChannelCount == mReqChannelCount || 3176 mFormat != AudioSystem::PCM_16_BIT) { 3177 memcpy(dst, src, framesIn * mFrameSize); 3178 } else { 3179 int16_t *src16 = (int16_t *)src; 3180 int16_t *dst16 = (int16_t *)dst; 3181 if (mChannelCount == 1) { 3182 while (framesIn--) { 3183 *dst16++ = *src16; 3184 *dst16++ = *src16++; 3185 } 3186 } else { 3187 while (framesIn--) { 3188 *dst16++ = (int16_t)(((int32_t)*src16 + (int32_t)*(src16 + 1)) >> 1); 3189 src16 += 2; 3190 } 3191 } 3192 } 3193 } 3194 if (framesOut && mFrameCount == mRsmpInIndex) { 3195 if (framesOut == mFrameCount && 3196 (mChannelCount == mReqChannelCount || mFormat != AudioSystem::PCM_16_BIT)) { 3197 mBytesRead = mInput->read(buffer.raw, mInputBytes); 3198 framesOut = 0; 3199 } else { 3200 mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes); 3201 mRsmpInIndex = 0; 3202 } 3203 if (mBytesRead < 0) { 3204 LOGE("Error reading audio input"); 3205 if (mActiveTrack->mState == TrackBase::ACTIVE) { 3206 sleep(1); 3207 } 3208 mRsmpInIndex = mFrameCount; 3209 framesOut = 0; 3210 buffer.frameCount = 0; 3211 } 3212 } 3213 } 3214 } else { 3215 // resampling 3216 3217 memset(mRsmpOutBuffer, 0, framesOut * 2 * sizeof(int32_t)); 3218 // alter output frame count as if we were expecting stereo samples 3219 if (mChannelCount == 1 && mReqChannelCount == 1) { 3220 framesOut >>= 1; 3221 } 3222 mResampler->resample(mRsmpOutBuffer, framesOut, this); 3223 // ditherAndClamp() works as long as all buffers returned by mActiveTrack->getNextBuffer() 3224 // are 32 bit aligned which should be always true. 3225 if (mChannelCount == 2 && mReqChannelCount == 1) { 3226 AudioMixer::ditherAndClamp(mRsmpOutBuffer, mRsmpOutBuffer, framesOut); 3227 // the resampler always outputs stereo samples: do post stereo to mono conversion 3228 int16_t *src = (int16_t *)mRsmpOutBuffer; 3229 int16_t *dst = buffer.i16; 3230 while (framesOut--) { 3231 *dst++ = (int16_t)(((int32_t)*src + (int32_t)*(src + 1)) >> 1); 3232 src += 2; 3233 } 3234 } else { 3235 AudioMixer::ditherAndClamp((int32_t *)buffer.raw, mRsmpOutBuffer, framesOut); 3236 } 3237 3238 } 3239 mActiveTrack->releaseBuffer(&buffer); 3240 mActiveTrack->overflow(); 3241 } 3242 // client isn't retrieving buffers fast enough 3243 else { 3244 if (!mActiveTrack->setOverflow()) 3245 LOGW("RecordThread: buffer overflow"); 3246 // Release the processor for a while before asking for a new buffer. 3247 // This will give the application more chance to read from the buffer and 3248 // clear the overflow. 3249 usleep(5000); 3250 } 3251 } 3252 } 3253 3254 if (!mStandby) { 3255 mInput->standby(); 3256 } 3257 mActiveTrack.clear(); 3258 3259 mStartStopCond.broadcast(); 3260 3261 LOGV("RecordThread %p exiting", this); 3262 return false; 3263} 3264 3265status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack) 3266{ 3267 LOGV("RecordThread::start"); 3268 sp <ThreadBase> strongMe = this; 3269 status_t status = NO_ERROR; 3270 { 3271 AutoMutex lock(&mLock); 3272 if (mActiveTrack != 0) { 3273 if (recordTrack != mActiveTrack.get()) { 3274 status = -EBUSY; 3275 } else if (mActiveTrack->mState == TrackBase::PAUSING) { 3276 mActiveTrack->mState = TrackBase::ACTIVE; 3277 } 3278 return status; 3279 } 3280 3281 recordTrack->mState = TrackBase::IDLE; 3282 mActiveTrack = recordTrack; 3283 mLock.unlock(); 3284 status_t status = AudioSystem::startInput(mId); 3285 mLock.lock(); 3286 if (status != NO_ERROR) { 3287 mActiveTrack.clear(); 3288 return status; 3289 } 3290 mActiveTrack->mState = TrackBase::RESUMING; 3291 mRsmpInIndex = mFrameCount; 3292 mBytesRead = 0; 3293 // signal thread to start 3294 LOGV("Signal record thread"); 3295 mWaitWorkCV.signal(); 3296 // do not wait for mStartStopCond if exiting 3297 if (mExiting) { 3298 mActiveTrack.clear(); 3299 status = INVALID_OPERATION; 3300 goto startError; 3301 } 3302 mStartStopCond.wait(mLock); 3303 if (mActiveTrack == 0) { 3304 LOGV("Record failed to start"); 3305 status = BAD_VALUE; 3306 goto startError; 3307 } 3308 LOGV("Record started OK"); 3309 return status; 3310 } 3311startError: 3312 AudioSystem::stopInput(mId); 3313 return status; 3314} 3315 3316void AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) { 3317 LOGV("RecordThread::stop"); 3318 sp <ThreadBase> strongMe = this; 3319 { 3320 AutoMutex lock(&mLock); 3321 if (mActiveTrack != 0 && recordTrack == mActiveTrack.get()) { 3322 mActiveTrack->mState = TrackBase::PAUSING; 3323 // do not wait for mStartStopCond if exiting 3324 if (mExiting) { 3325 return; 3326 } 3327 mStartStopCond.wait(mLock); 3328 // if we have been restarted, recordTrack == mActiveTrack.get() here 3329 if (mActiveTrack == 0 || recordTrack != mActiveTrack.get()) { 3330 mLock.unlock(); 3331 AudioSystem::stopInput(mId); 3332 mLock.lock(); 3333 LOGV("Record stopped OK"); 3334 } 3335 } 3336 } 3337} 3338 3339status_t AudioFlinger::RecordThread::dump(int fd, const Vector<String16>& args) 3340{ 3341 const size_t SIZE = 256; 3342 char buffer[SIZE]; 3343 String8 result; 3344 pid_t pid = 0; 3345 3346 snprintf(buffer, SIZE, "\nInput thread %p internals\n", this); 3347 result.append(buffer); 3348 3349 if (mActiveTrack != 0) { 3350 result.append("Active Track:\n"); 3351 result.append(" Clien Fmt Chn Buf S SRate Serv User\n"); 3352 mActiveTrack->dump(buffer, SIZE); 3353 result.append(buffer); 3354 3355 snprintf(buffer, SIZE, "In index: %d\n", mRsmpInIndex); 3356 result.append(buffer); 3357 snprintf(buffer, SIZE, "In size: %d\n", mInputBytes); 3358 result.append(buffer); 3359 snprintf(buffer, SIZE, "Resampling: %d\n", (mResampler != 0)); 3360 result.append(buffer); 3361 snprintf(buffer, SIZE, "Out channel count: %d\n", mReqChannelCount); 3362 result.append(buffer); 3363 snprintf(buffer, SIZE, "Out sample rate: %d\n", mReqSampleRate); 3364 result.append(buffer); 3365 3366 3367 } else { 3368 result.append("No record client\n"); 3369 } 3370 write(fd, result.string(), result.size()); 3371 3372 dumpBase(fd, args); 3373 3374 return NO_ERROR; 3375} 3376 3377status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer* buffer) 3378{ 3379 size_t framesReq = buffer->frameCount; 3380 size_t framesReady = mFrameCount - mRsmpInIndex; 3381 int channelCount; 3382 3383 if (framesReady == 0) { 3384 mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes); 3385 if (mBytesRead < 0) { 3386 LOGE("RecordThread::getNextBuffer() Error reading audio input"); 3387 if (mActiveTrack->mState == TrackBase::ACTIVE) { 3388 sleep(1); 3389 } 3390 buffer->raw = 0; 3391 buffer->frameCount = 0; 3392 return NOT_ENOUGH_DATA; 3393 } 3394 mRsmpInIndex = 0; 3395 framesReady = mFrameCount; 3396 } 3397 3398 if (framesReq > framesReady) { 3399 framesReq = framesReady; 3400 } 3401 3402 if (mChannelCount == 1 && mReqChannelCount == 2) { 3403 channelCount = 1; 3404 } else { 3405 channelCount = 2; 3406 } 3407 buffer->raw = mRsmpInBuffer + mRsmpInIndex * channelCount; 3408 buffer->frameCount = framesReq; 3409 return NO_ERROR; 3410} 3411 3412void AudioFlinger::RecordThread::releaseBuffer(AudioBufferProvider::Buffer* buffer) 3413{ 3414 mRsmpInIndex += buffer->frameCount; 3415 buffer->frameCount = 0; 3416} 3417 3418bool AudioFlinger::RecordThread::checkForNewParameters_l() 3419{ 3420 bool reconfig = false; 3421 3422 while (!mNewParameters.isEmpty()) { 3423 status_t status = NO_ERROR; 3424 String8 keyValuePair = mNewParameters[0]; 3425 AudioParameter param = AudioParameter(keyValuePair); 3426 int value; 3427 int reqFormat = mFormat; 3428 int reqSamplingRate = mReqSampleRate; 3429 int reqChannelCount = mReqChannelCount; 3430 3431 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) { 3432 reqSamplingRate = value; 3433 reconfig = true; 3434 } 3435 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) { 3436 reqFormat = value; 3437 reconfig = true; 3438 } 3439 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) { 3440 reqChannelCount = AudioSystem::popCount(value); 3441 reconfig = true; 3442 } 3443 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { 3444 // do not accept frame count changes if tracks are open as the track buffer 3445 // size depends on frame count and correct behavior would not be garantied 3446 // if frame count is changed after track creation 3447 if (mActiveTrack != 0) { 3448 status = INVALID_OPERATION; 3449 } else { 3450 reconfig = true; 3451 } 3452 } 3453 if (status == NO_ERROR) { 3454 status = mInput->setParameters(keyValuePair); 3455 if (status == INVALID_OPERATION) { 3456 mInput->standby(); 3457 status = mInput->setParameters(keyValuePair); 3458 } 3459 if (reconfig) { 3460 if (status == BAD_VALUE && 3461 reqFormat == mInput->format() && reqFormat == AudioSystem::PCM_16_BIT && 3462 ((int)mInput->sampleRate() <= 2 * reqSamplingRate) && 3463 (AudioSystem::popCount(mInput->channels()) < 3) && (reqChannelCount < 3)) { 3464 status = NO_ERROR; 3465 } 3466 if (status == NO_ERROR) { 3467 readInputParameters(); 3468 sendConfigEvent_l(AudioSystem::INPUT_CONFIG_CHANGED); 3469 } 3470 } 3471 } 3472 3473 mNewParameters.removeAt(0); 3474 3475 mParamStatus = status; 3476 mParamCond.signal(); 3477 mWaitWorkCV.wait(mLock); 3478 } 3479 return reconfig; 3480} 3481 3482String8 AudioFlinger::RecordThread::getParameters(const String8& keys) 3483{ 3484 return mInput->getParameters(keys); 3485} 3486 3487void AudioFlinger::RecordThread::audioConfigChanged(int event, int param) { 3488 AudioSystem::OutputDescriptor desc; 3489 void *param2 = 0; 3490 3491 switch (event) { 3492 case AudioSystem::INPUT_OPENED: 3493 case AudioSystem::INPUT_CONFIG_CHANGED: 3494 desc.channels = mChannelCount; 3495 desc.samplingRate = mSampleRate; 3496 desc.format = mFormat; 3497 desc.frameCount = mFrameCount; 3498 desc.latency = 0; 3499 param2 = &desc; 3500 break; 3501 3502 case AudioSystem::INPUT_CLOSED: 3503 default: 3504 break; 3505 } 3506 Mutex::Autolock _l(mAudioFlinger->mLock); 3507 mAudioFlinger->audioConfigChanged_l(event, mId, param2); 3508} 3509 3510void AudioFlinger::RecordThread::readInputParameters() 3511{ 3512 if (mRsmpInBuffer) delete mRsmpInBuffer; 3513 if (mRsmpOutBuffer) delete mRsmpOutBuffer; 3514 if (mResampler) delete mResampler; 3515 mResampler = 0; 3516 3517 mSampleRate = mInput->sampleRate(); 3518 mChannelCount = AudioSystem::popCount(mInput->channels()); 3519 mFormat = mInput->format(); 3520 mFrameSize = mInput->frameSize(); 3521 mInputBytes = mInput->bufferSize(); 3522 mFrameCount = mInputBytes / mFrameSize; 3523 mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount]; 3524 3525 if (mSampleRate != mReqSampleRate && mChannelCount < 3 && mReqChannelCount < 3) 3526 { 3527 int channelCount; 3528 // optmization: if mono to mono, use the resampler in stereo to stereo mode to avoid 3529 // stereo to mono post process as the resampler always outputs stereo. 3530 if (mChannelCount == 1 && mReqChannelCount == 2) { 3531 channelCount = 1; 3532 } else { 3533 channelCount = 2; 3534 } 3535 mResampler = AudioResampler::create(16, channelCount, mReqSampleRate); 3536 mResampler->setSampleRate(mSampleRate); 3537 mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN); 3538 mRsmpOutBuffer = new int32_t[mFrameCount * 2]; 3539 3540 // optmization: if mono to mono, alter input frame count as if we were inputing stereo samples 3541 if (mChannelCount == 1 && mReqChannelCount == 1) { 3542 mFrameCount >>= 1; 3543 } 3544 3545 } 3546 mRsmpInIndex = mFrameCount; 3547} 3548 3549// ---------------------------------------------------------------------------- 3550 3551int AudioFlinger::openOutput(uint32_t *pDevices, 3552 uint32_t *pSamplingRate, 3553 uint32_t *pFormat, 3554 uint32_t *pChannels, 3555 uint32_t *pLatencyMs, 3556 uint32_t flags) 3557{ 3558 status_t status; 3559 PlaybackThread *thread = NULL; 3560 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN; 3561 uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0; 3562 uint32_t format = pFormat ? *pFormat : 0; 3563 uint32_t channels = pChannels ? *pChannels : 0; 3564 uint32_t latency = pLatencyMs ? *pLatencyMs : 0; 3565 3566 LOGV("openOutput(), Device %x, SamplingRate %d, Format %d, Channels %x, flags %x", 3567 pDevices ? *pDevices : 0, 3568 samplingRate, 3569 format, 3570 channels, 3571 flags); 3572 3573 if (pDevices == NULL || *pDevices == 0) { 3574 return 0; 3575 } 3576 Mutex::Autolock _l(mLock); 3577 3578 AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices, 3579 (int *)&format, 3580 &channels, 3581 &samplingRate, 3582 &status); 3583 LOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %d, Channels %x, status %d", 3584 output, 3585 samplingRate, 3586 format, 3587 channels, 3588 status); 3589 3590 mHardwareStatus = AUDIO_HW_IDLE; 3591 if (output != 0) { 3592 if ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) || 3593 (format != AudioSystem::PCM_16_BIT) || 3594 (channels != AudioSystem::CHANNEL_OUT_STEREO)) { 3595 thread = new DirectOutputThread(this, output, ++mNextThreadId); 3596 LOGV("openOutput() created direct output: ID %d thread %p", mNextThreadId, thread); 3597 } else { 3598 thread = new MixerThread(this, output, ++mNextThreadId); 3599 LOGV("openOutput() created mixer output: ID %d thread %p", mNextThreadId, thread); 3600 } 3601 mPlaybackThreads.add(mNextThreadId, thread); 3602 3603 if (pSamplingRate) *pSamplingRate = samplingRate; 3604 if (pFormat) *pFormat = format; 3605 if (pChannels) *pChannels = channels; 3606 if (pLatencyMs) *pLatencyMs = thread->latency(); 3607 3608 return mNextThreadId; 3609 } 3610 3611 return 0; 3612} 3613 3614int AudioFlinger::openDuplicateOutput(int output1, int output2) 3615{ 3616 Mutex::Autolock _l(mLock); 3617 MixerThread *thread1 = checkMixerThread_l(output1); 3618 MixerThread *thread2 = checkMixerThread_l(output2); 3619 3620 if (thread1 == NULL || thread2 == NULL) { 3621 LOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, output2); 3622 return 0; 3623 } 3624 3625 3626 DuplicatingThread *thread = new DuplicatingThread(this, thread1, ++mNextThreadId); 3627 thread->addOutputTrack(thread2); 3628 mPlaybackThreads.add(mNextThreadId, thread); 3629 return mNextThreadId; 3630} 3631 3632status_t AudioFlinger::closeOutput(int output) 3633{ 3634 // keep strong reference on the playback thread so that 3635 // it is not destroyed while exit() is executed 3636 sp <PlaybackThread> thread; 3637 { 3638 Mutex::Autolock _l(mLock); 3639 thread = checkPlaybackThread_l(output); 3640 if (thread == NULL) { 3641 return BAD_VALUE; 3642 } 3643 3644 LOGV("closeOutput() %d", output); 3645 3646 if (thread->type() == PlaybackThread::MIXER) { 3647 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 3648 if (mPlaybackThreads.valueAt(i)->type() == PlaybackThread::DUPLICATING) { 3649 DuplicatingThread *dupThread = (DuplicatingThread *)mPlaybackThreads.valueAt(i).get(); 3650 dupThread->removeOutputTrack((MixerThread *)thread.get()); 3651 } 3652 } 3653 } 3654 void *param2 = 0; 3655 audioConfigChanged_l(AudioSystem::OUTPUT_CLOSED, output, param2); 3656 mPlaybackThreads.removeItem(output); 3657 } 3658 thread->exit(); 3659 3660 if (thread->type() != PlaybackThread::DUPLICATING) { 3661 mAudioHardware->closeOutputStream(thread->getOutput()); 3662 } 3663 return NO_ERROR; 3664} 3665 3666status_t AudioFlinger::suspendOutput(int output) 3667{ 3668 Mutex::Autolock _l(mLock); 3669 PlaybackThread *thread = checkPlaybackThread_l(output); 3670 3671 if (thread == NULL) { 3672 return BAD_VALUE; 3673 } 3674 3675 LOGV("suspendOutput() %d", output); 3676 thread->suspend(); 3677 3678 return NO_ERROR; 3679} 3680 3681status_t AudioFlinger::restoreOutput(int output) 3682{ 3683 Mutex::Autolock _l(mLock); 3684 PlaybackThread *thread = checkPlaybackThread_l(output); 3685 3686 if (thread == NULL) { 3687 return BAD_VALUE; 3688 } 3689 3690 LOGV("restoreOutput() %d", output); 3691 3692 thread->restore(); 3693 3694 return NO_ERROR; 3695} 3696 3697int AudioFlinger::openInput(uint32_t *pDevices, 3698 uint32_t *pSamplingRate, 3699 uint32_t *pFormat, 3700 uint32_t *pChannels, 3701 uint32_t acoustics) 3702{ 3703 status_t status; 3704 RecordThread *thread = NULL; 3705 uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0; 3706 uint32_t format = pFormat ? *pFormat : 0; 3707 uint32_t channels = pChannels ? *pChannels : 0; 3708 uint32_t reqSamplingRate = samplingRate; 3709 uint32_t reqFormat = format; 3710 uint32_t reqChannels = channels; 3711 3712 if (pDevices == NULL || *pDevices == 0) { 3713 return 0; 3714 } 3715 Mutex::Autolock _l(mLock); 3716 3717 AudioStreamIn *input = mAudioHardware->openInputStream(*pDevices, 3718 (int *)&format, 3719 &channels, 3720 &samplingRate, 3721 &status, 3722 (AudioSystem::audio_in_acoustics)acoustics); 3723 LOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %d, Channels %x, acoustics %x, status %d", 3724 input, 3725 samplingRate, 3726 format, 3727 channels, 3728 acoustics, 3729 status); 3730 3731 // If the input could not be opened with the requested parameters and we can handle the conversion internally, 3732 // try to open again with the proposed parameters. The AudioFlinger can resample the input and do mono to stereo 3733 // or stereo to mono conversions on 16 bit PCM inputs. 3734 if (input == 0 && status == BAD_VALUE && 3735 reqFormat == format && format == AudioSystem::PCM_16_BIT && 3736 (samplingRate <= 2 * reqSamplingRate) && 3737 (AudioSystem::popCount(channels) < 3) && (AudioSystem::popCount(reqChannels) < 3)) { 3738 LOGV("openInput() reopening with proposed sampling rate and channels"); 3739 input = mAudioHardware->openInputStream(*pDevices, 3740 (int *)&format, 3741 &channels, 3742 &samplingRate, 3743 &status, 3744 (AudioSystem::audio_in_acoustics)acoustics); 3745 } 3746 3747 if (input != 0) { 3748 // Start record thread 3749 thread = new RecordThread(this, input, reqSamplingRate, reqChannels, ++mNextThreadId); 3750 mRecordThreads.add(mNextThreadId, thread); 3751 LOGV("openInput() created record thread: ID %d thread %p", mNextThreadId, thread); 3752 if (pSamplingRate) *pSamplingRate = reqSamplingRate; 3753 if (pFormat) *pFormat = format; 3754 if (pChannels) *pChannels = reqChannels; 3755 3756 input->standby(); 3757 3758 return mNextThreadId; 3759 } 3760 3761 return 0; 3762} 3763 3764status_t AudioFlinger::closeInput(int input) 3765{ 3766 // keep strong reference on the record thread so that 3767 // it is not destroyed while exit() is executed 3768 sp <RecordThread> thread; 3769 { 3770 Mutex::Autolock _l(mLock); 3771 thread = checkRecordThread_l(input); 3772 if (thread == NULL) { 3773 return BAD_VALUE; 3774 } 3775 3776 LOGV("closeInput() %d", input); 3777 void *param2 = 0; 3778 audioConfigChanged_l(AudioSystem::INPUT_CLOSED, input, param2); 3779 mRecordThreads.removeItem(input); 3780 } 3781 thread->exit(); 3782 3783 mAudioHardware->closeInputStream(thread->getInput()); 3784 3785 return NO_ERROR; 3786} 3787 3788status_t AudioFlinger::setStreamOutput(uint32_t stream, int output) 3789{ 3790 Mutex::Autolock _l(mLock); 3791 MixerThread *dstThread = checkMixerThread_l(output); 3792 if (dstThread == NULL) { 3793 LOGW("setStreamOutput() bad output id %d", output); 3794 return BAD_VALUE; 3795 } 3796 3797 LOGV("setStreamOutput() stream %d to output %d", stream, output); 3798 3799 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 3800 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 3801 if (thread != dstThread && 3802 thread->type() != PlaybackThread::DIRECT) { 3803 MixerThread *srcThread = (MixerThread *)thread; 3804 SortedVector < sp<MixerThread::Track> > tracks; 3805 SortedVector < wp<MixerThread::Track> > activeTracks; 3806 srcThread->getTracks(tracks, activeTracks, stream); 3807 if (tracks.size()) { 3808 dstThread->putTracks(tracks, activeTracks); 3809 } 3810 } 3811 } 3812 3813 dstThread->sendConfigEvent(AudioSystem::STREAM_CONFIG_CHANGED, stream); 3814 3815 return NO_ERROR; 3816} 3817 3818// checkPlaybackThread_l() must be called with AudioFlinger::mLock held 3819AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(int output) const 3820{ 3821 PlaybackThread *thread = NULL; 3822 if (mPlaybackThreads.indexOfKey(output) >= 0) { 3823 thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get(); 3824 } 3825 return thread; 3826} 3827 3828// checkMixerThread_l() must be called with AudioFlinger::mLock held 3829AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(int output) const 3830{ 3831 PlaybackThread *thread = checkPlaybackThread_l(output); 3832 if (thread != NULL) { 3833 if (thread->type() == PlaybackThread::DIRECT) { 3834 thread = NULL; 3835 } 3836 } 3837 return (MixerThread *)thread; 3838} 3839 3840// checkRecordThread_l() must be called with AudioFlinger::mLock held 3841AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(int input) const 3842{ 3843 RecordThread *thread = NULL; 3844 if (mRecordThreads.indexOfKey(input) >= 0) { 3845 thread = (RecordThread *)mRecordThreads.valueFor(input).get(); 3846 } 3847 return thread; 3848} 3849 3850// ---------------------------------------------------------------------------- 3851 3852status_t AudioFlinger::onTransact( 3853 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 3854{ 3855 return BnAudioFlinger::onTransact(code, data, reply, flags); 3856} 3857 3858// ---------------------------------------------------------------------------- 3859 3860void AudioFlinger::instantiate() { 3861 defaultServiceManager()->addService( 3862 String16("media.audio_flinger"), new AudioFlinger()); 3863} 3864 3865}; // namespace android 3866