AudioFlinger.cpp revision fa319e6d918b84f93fb5457af5d1cca6421ac517
1/* 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 "Configuration.h" 23#include <dirent.h> 24#include <math.h> 25#include <signal.h> 26#include <sys/time.h> 27#include <sys/resource.h> 28 29#include <binder/IPCThreadState.h> 30#include <binder/IServiceManager.h> 31#include <utils/Log.h> 32#include <utils/Trace.h> 33#include <binder/Parcel.h> 34#include <utils/String16.h> 35#include <utils/threads.h> 36#include <utils/Atomic.h> 37 38#include <cutils/bitops.h> 39#include <cutils/properties.h> 40 41#include <system/audio.h> 42#include <hardware/audio.h> 43 44#include "AudioMixer.h" 45#include "AudioFlinger.h" 46#include "ServiceUtilities.h" 47 48#include <media/EffectsFactoryApi.h> 49#include <audio_effects/effect_visualizer.h> 50#include <audio_effects/effect_ns.h> 51#include <audio_effects/effect_aec.h> 52 53#include <audio_utils/primitives.h> 54 55#include <powermanager/PowerManager.h> 56 57#include <common_time/cc_helper.h> 58 59#include <media/IMediaLogService.h> 60 61#include <media/nbaio/Pipe.h> 62#include <media/nbaio/PipeReader.h> 63#include <media/AudioParameter.h> 64#include <private/android_filesystem_config.h> 65 66// ---------------------------------------------------------------------------- 67 68// Note: the following macro is used for extremely verbose logging message. In 69// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to 70// 0; but one side effect of this is to turn all LOGV's as well. Some messages 71// are so verbose that we want to suppress them even when we have ALOG_ASSERT 72// turned on. Do not uncomment the #def below unless you really know what you 73// are doing and want to see all of the extremely verbose messages. 74//#define VERY_VERY_VERBOSE_LOGGING 75#ifdef VERY_VERY_VERBOSE_LOGGING 76#define ALOGVV ALOGV 77#else 78#define ALOGVV(a...) do { } while(0) 79#endif 80 81namespace android { 82 83static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n"; 84static const char kHardwareLockedString[] = "Hardware lock is taken\n"; 85 86 87nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs; 88 89uint32_t AudioFlinger::mScreenState; 90 91#ifdef TEE_SINK 92bool AudioFlinger::mTeeSinkInputEnabled = false; 93bool AudioFlinger::mTeeSinkOutputEnabled = false; 94bool AudioFlinger::mTeeSinkTrackEnabled = false; 95 96size_t AudioFlinger::mTeeSinkInputFrames = kTeeSinkInputFramesDefault; 97size_t AudioFlinger::mTeeSinkOutputFrames = kTeeSinkOutputFramesDefault; 98size_t AudioFlinger::mTeeSinkTrackFrames = kTeeSinkTrackFramesDefault; 99#endif 100 101// ---------------------------------------------------------------------------- 102 103static int load_audio_interface(const char *if_name, audio_hw_device_t **dev) 104{ 105 const hw_module_t *mod; 106 int rc; 107 108 rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod); 109 ALOGE_IF(rc, "%s couldn't load audio hw module %s.%s (%s)", __func__, 110 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc)); 111 if (rc) { 112 goto out; 113 } 114 rc = audio_hw_device_open(mod, dev); 115 ALOGE_IF(rc, "%s couldn't open audio hw device in %s.%s (%s)", __func__, 116 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc)); 117 if (rc) { 118 goto out; 119 } 120 if ((*dev)->common.version != AUDIO_DEVICE_API_VERSION_CURRENT) { 121 ALOGE("%s wrong audio hw device version %04x", __func__, (*dev)->common.version); 122 rc = BAD_VALUE; 123 goto out; 124 } 125 return 0; 126 127out: 128 *dev = NULL; 129 return rc; 130} 131 132// ---------------------------------------------------------------------------- 133 134AudioFlinger::AudioFlinger() 135 : BnAudioFlinger(), 136 mPrimaryHardwareDev(NULL), 137 mHardwareStatus(AUDIO_HW_IDLE), 138 mMasterVolume(1.0f), 139 mMasterMute(false), 140 mNextUniqueId(1), 141 mMode(AUDIO_MODE_INVALID), 142 mBtNrecIsOff(false), 143 mIsLowRamDevice(true), 144 mIsDeviceTypeKnown(false) 145{ 146 getpid_cached = getpid(); 147 char value[PROPERTY_VALUE_MAX]; 148 bool doLog = (property_get("ro.test_harness", value, "0") > 0) && (atoi(value) == 1); 149 if (doLog) { 150 mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters"); 151 } 152#ifdef TEE_SINK 153 (void) property_get("ro.debuggable", value, "0"); 154 int debuggable = atoi(value); 155 int teeEnabled = 0; 156 if (debuggable) { 157 (void) property_get("af.tee", value, "0"); 158 teeEnabled = atoi(value); 159 } 160 if (teeEnabled & 1) 161 mTeeSinkInputEnabled = true; 162 if (teeEnabled & 2) 163 mTeeSinkOutputEnabled = true; 164 if (teeEnabled & 4) 165 mTeeSinkTrackEnabled = true; 166#endif 167} 168 169void AudioFlinger::onFirstRef() 170{ 171 int rc = 0; 172 173 Mutex::Autolock _l(mLock); 174 175 /* TODO: move all this work into an Init() function */ 176 char val_str[PROPERTY_VALUE_MAX] = { 0 }; 177 if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) { 178 uint32_t int_val; 179 if (1 == sscanf(val_str, "%u", &int_val)) { 180 mStandbyTimeInNsecs = milliseconds(int_val); 181 ALOGI("Using %u mSec as standby time.", int_val); 182 } else { 183 mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs; 184 ALOGI("Using default %u mSec as standby time.", 185 (uint32_t)(mStandbyTimeInNsecs / 1000000)); 186 } 187 } 188 189 mMode = AUDIO_MODE_NORMAL; 190} 191 192AudioFlinger::~AudioFlinger() 193{ 194 while (!mRecordThreads.isEmpty()) { 195 // closeInput_nonvirtual() will remove specified entry from mRecordThreads 196 closeInput_nonvirtual(mRecordThreads.keyAt(0)); 197 } 198 while (!mPlaybackThreads.isEmpty()) { 199 // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads 200 closeOutput_nonvirtual(mPlaybackThreads.keyAt(0)); 201 } 202 203 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 204 // no mHardwareLock needed, as there are no other references to this 205 audio_hw_device_close(mAudioHwDevs.valueAt(i)->hwDevice()); 206 delete mAudioHwDevs.valueAt(i); 207 } 208} 209 210static const char * const audio_interfaces[] = { 211 AUDIO_HARDWARE_MODULE_ID_PRIMARY, 212 AUDIO_HARDWARE_MODULE_ID_A2DP, 213 AUDIO_HARDWARE_MODULE_ID_USB, 214}; 215#define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0]))) 216 217AudioFlinger::AudioHwDevice* AudioFlinger::findSuitableHwDev_l( 218 audio_module_handle_t module, 219 audio_devices_t devices) 220{ 221 // if module is 0, the request comes from an old policy manager and we should load 222 // well known modules 223 if (module == 0) { 224 ALOGW("findSuitableHwDev_l() loading well know audio hw modules"); 225 for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) { 226 loadHwModule_l(audio_interfaces[i]); 227 } 228 // then try to find a module supporting the requested device. 229 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 230 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i); 231 audio_hw_device_t *dev = audioHwDevice->hwDevice(); 232 if ((dev->get_supported_devices != NULL) && 233 (dev->get_supported_devices(dev) & devices) == devices) 234 return audioHwDevice; 235 } 236 } else { 237 // check a match for the requested module handle 238 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module); 239 if (audioHwDevice != NULL) { 240 return audioHwDevice; 241 } 242 } 243 244 return NULL; 245} 246 247void AudioFlinger::dumpClients(int fd, const Vector<String16>& args) 248{ 249 const size_t SIZE = 256; 250 char buffer[SIZE]; 251 String8 result; 252 253 result.append("Clients:\n"); 254 for (size_t i = 0; i < mClients.size(); ++i) { 255 sp<Client> client = mClients.valueAt(i).promote(); 256 if (client != 0) { 257 snprintf(buffer, SIZE, " pid: %d\n", client->pid()); 258 result.append(buffer); 259 } 260 } 261 262 result.append("Global session refs:\n"); 263 result.append(" session pid count\n"); 264 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) { 265 AudioSessionRef *r = mAudioSessionRefs[i]; 266 snprintf(buffer, SIZE, " %7d %3d %3d\n", r->mSessionid, r->mPid, r->mCnt); 267 result.append(buffer); 268 } 269 write(fd, result.string(), result.size()); 270} 271 272 273void AudioFlinger::dumpInternals(int fd, const Vector<String16>& args) 274{ 275 const size_t SIZE = 256; 276 char buffer[SIZE]; 277 String8 result; 278 hardware_call_state hardwareStatus = mHardwareStatus; 279 280 snprintf(buffer, SIZE, "Hardware status: %d\n" 281 "Standby Time mSec: %u\n", 282 hardwareStatus, 283 (uint32_t)(mStandbyTimeInNsecs / 1000000)); 284 result.append(buffer); 285 write(fd, result.string(), result.size()); 286} 287 288void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args) 289{ 290 const size_t SIZE = 256; 291 char buffer[SIZE]; 292 String8 result; 293 snprintf(buffer, SIZE, "Permission Denial: " 294 "can't dump AudioFlinger from pid=%d, uid=%d\n", 295 IPCThreadState::self()->getCallingPid(), 296 IPCThreadState::self()->getCallingUid()); 297 result.append(buffer); 298 write(fd, result.string(), result.size()); 299} 300 301bool AudioFlinger::dumpTryLock(Mutex& mutex) 302{ 303 bool locked = false; 304 for (int i = 0; i < kDumpLockRetries; ++i) { 305 if (mutex.tryLock() == NO_ERROR) { 306 locked = true; 307 break; 308 } 309 usleep(kDumpLockSleepUs); 310 } 311 return locked; 312} 313 314status_t AudioFlinger::dump(int fd, const Vector<String16>& args) 315{ 316 if (!dumpAllowed()) { 317 dumpPermissionDenial(fd, args); 318 } else { 319 // get state of hardware lock 320 bool hardwareLocked = dumpTryLock(mHardwareLock); 321 if (!hardwareLocked) { 322 String8 result(kHardwareLockedString); 323 write(fd, result.string(), result.size()); 324 } else { 325 mHardwareLock.unlock(); 326 } 327 328 bool locked = dumpTryLock(mLock); 329 330 // failed to lock - AudioFlinger is probably deadlocked 331 if (!locked) { 332 String8 result(kDeadlockedString); 333 write(fd, result.string(), result.size()); 334 } 335 336 dumpClients(fd, args); 337 dumpInternals(fd, args); 338 339 // dump playback threads 340 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 341 mPlaybackThreads.valueAt(i)->dump(fd, args); 342 } 343 344 // dump record threads 345 for (size_t i = 0; i < mRecordThreads.size(); i++) { 346 mRecordThreads.valueAt(i)->dump(fd, args); 347 } 348 349 // dump all hardware devs 350 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 351 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 352 dev->dump(dev, fd); 353 } 354 355#ifdef TEE_SINK 356 // dump the serially shared record tee sink 357 if (mRecordTeeSource != 0) { 358 dumpTee(fd, mRecordTeeSource); 359 } 360#endif 361 362 if (locked) { 363 mLock.unlock(); 364 } 365 366 // append a copy of media.log here by forwarding fd to it, but don't attempt 367 // to lookup the service if it's not running, as it will block for a second 368 if (mLogMemoryDealer != 0) { 369 sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log")); 370 if (binder != 0) { 371 fdprintf(fd, "\nmedia.log:\n"); 372 Vector<String16> args; 373 binder->dump(fd, args); 374 } 375 } 376 } 377 return NO_ERROR; 378} 379 380sp<AudioFlinger::Client> AudioFlinger::registerPid_l(pid_t pid) 381{ 382 // If pid is already in the mClients wp<> map, then use that entry 383 // (for which promote() is always != 0), otherwise create a new entry and Client. 384 sp<Client> client = mClients.valueFor(pid).promote(); 385 if (client == 0) { 386 client = new Client(this, pid); 387 mClients.add(pid, client); 388 } 389 390 return client; 391} 392 393sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name) 394{ 395 if (mLogMemoryDealer == 0) { 396 return new NBLog::Writer(); 397 } 398 sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size)); 399 sp<NBLog::Writer> writer = new NBLog::Writer(size, shared); 400 sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log")); 401 if (binder != 0) { 402 interface_cast<IMediaLogService>(binder)->registerWriter(shared, size, name); 403 } 404 return writer; 405} 406 407void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer) 408{ 409 if (writer == 0) { 410 return; 411 } 412 sp<IMemory> iMemory(writer->getIMemory()); 413 if (iMemory == 0) { 414 return; 415 } 416 sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log")); 417 if (binder != 0) { 418 interface_cast<IMediaLogService>(binder)->unregisterWriter(iMemory); 419 // Now the media.log remote reference to IMemory is gone. 420 // When our last local reference to IMemory also drops to zero, 421 // the IMemory destructor will deallocate the region from mMemoryDealer. 422 } 423} 424 425// IAudioFlinger interface 426 427 428sp<IAudioTrack> AudioFlinger::createTrack( 429 audio_stream_type_t streamType, 430 uint32_t sampleRate, 431 audio_format_t format, 432 audio_channel_mask_t channelMask, 433 size_t frameCount, 434 IAudioFlinger::track_flags_t *flags, 435 const sp<IMemory>& sharedBuffer, 436 audio_io_handle_t output, 437 pid_t tid, 438 int *sessionId, 439 status_t *status) 440{ 441 sp<PlaybackThread::Track> track; 442 sp<TrackHandle> trackHandle; 443 sp<Client> client; 444 status_t lStatus; 445 int lSessionId; 446 447 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC, 448 // but if someone uses binder directly they could bypass that and cause us to crash 449 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) { 450 ALOGE("createTrack() invalid stream type %d", streamType); 451 lStatus = BAD_VALUE; 452 goto Exit; 453 } 454 455 // client is responsible for conversion of 8-bit PCM to 16-bit PCM, 456 // and we don't yet support 8.24 or 32-bit PCM 457 if (audio_is_linear_pcm(format) && format != AUDIO_FORMAT_PCM_16_BIT) { 458 ALOGE("createTrack() invalid format %d", format); 459 lStatus = BAD_VALUE; 460 goto Exit; 461 } 462 463 { 464 Mutex::Autolock _l(mLock); 465 PlaybackThread *thread = checkPlaybackThread_l(output); 466 PlaybackThread *effectThread = NULL; 467 if (thread == NULL) { 468 ALOGE("no playback thread found for output handle %d", output); 469 lStatus = BAD_VALUE; 470 goto Exit; 471 } 472 473 pid_t pid = IPCThreadState::self()->getCallingPid(); 474 client = registerPid_l(pid); 475 476 ALOGV("createTrack() sessionId: %d", (sessionId == NULL) ? -2 : *sessionId); 477 if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) { 478 // check if an effect chain with the same session ID is present on another 479 // output thread and move it here. 480 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 481 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 482 if (mPlaybackThreads.keyAt(i) != output) { 483 uint32_t sessions = t->hasAudioSession(*sessionId); 484 if (sessions & PlaybackThread::EFFECT_SESSION) { 485 effectThread = t.get(); 486 break; 487 } 488 } 489 } 490 lSessionId = *sessionId; 491 } else { 492 // if no audio session id is provided, create one here 493 lSessionId = nextUniqueId(); 494 if (sessionId != NULL) { 495 *sessionId = lSessionId; 496 } 497 } 498 ALOGV("createTrack() lSessionId: %d", lSessionId); 499 500 track = thread->createTrack_l(client, streamType, sampleRate, format, 501 channelMask, frameCount, sharedBuffer, lSessionId, flags, tid, &lStatus); 502 503 // move effect chain to this output thread if an effect on same session was waiting 504 // for a track to be created 505 if (lStatus == NO_ERROR && effectThread != NULL) { 506 Mutex::Autolock _dl(thread->mLock); 507 Mutex::Autolock _sl(effectThread->mLock); 508 moveEffectChain_l(lSessionId, effectThread, thread, true); 509 } 510 511 // Look for sync events awaiting for a session to be used. 512 for (int i = 0; i < (int)mPendingSyncEvents.size(); i++) { 513 if (mPendingSyncEvents[i]->triggerSession() == lSessionId) { 514 if (thread->isValidSyncEvent(mPendingSyncEvents[i])) { 515 if (lStatus == NO_ERROR) { 516 (void) track->setSyncEvent(mPendingSyncEvents[i]); 517 } else { 518 mPendingSyncEvents[i]->cancel(); 519 } 520 mPendingSyncEvents.removeAt(i); 521 i--; 522 } 523 } 524 } 525 } 526 if (lStatus == NO_ERROR) { 527 trackHandle = new TrackHandle(track); 528 } else { 529 // remove local strong reference to Client before deleting the Track so that the Client 530 // destructor is called by the TrackBase destructor with mLock held 531 client.clear(); 532 track.clear(); 533 } 534 535Exit: 536 if (status != NULL) { 537 *status = lStatus; 538 } 539 return trackHandle; 540} 541 542uint32_t AudioFlinger::sampleRate(audio_io_handle_t output) const 543{ 544 Mutex::Autolock _l(mLock); 545 PlaybackThread *thread = checkPlaybackThread_l(output); 546 if (thread == NULL) { 547 ALOGW("sampleRate() unknown thread %d", output); 548 return 0; 549 } 550 return thread->sampleRate(); 551} 552 553int AudioFlinger::channelCount(audio_io_handle_t output) const 554{ 555 Mutex::Autolock _l(mLock); 556 PlaybackThread *thread = checkPlaybackThread_l(output); 557 if (thread == NULL) { 558 ALOGW("channelCount() unknown thread %d", output); 559 return 0; 560 } 561 return thread->channelCount(); 562} 563 564audio_format_t AudioFlinger::format(audio_io_handle_t output) const 565{ 566 Mutex::Autolock _l(mLock); 567 PlaybackThread *thread = checkPlaybackThread_l(output); 568 if (thread == NULL) { 569 ALOGW("format() unknown thread %d", output); 570 return AUDIO_FORMAT_INVALID; 571 } 572 return thread->format(); 573} 574 575size_t AudioFlinger::frameCount(audio_io_handle_t output) const 576{ 577 Mutex::Autolock _l(mLock); 578 PlaybackThread *thread = checkPlaybackThread_l(output); 579 if (thread == NULL) { 580 ALOGW("frameCount() unknown thread %d", output); 581 return 0; 582 } 583 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers; 584 // should examine all callers and fix them to handle smaller counts 585 return thread->frameCount(); 586} 587 588uint32_t AudioFlinger::latency(audio_io_handle_t output) const 589{ 590 Mutex::Autolock _l(mLock); 591 PlaybackThread *thread = checkPlaybackThread_l(output); 592 if (thread == NULL) { 593 ALOGW("latency(): no playback thread found for output handle %d", output); 594 return 0; 595 } 596 return thread->latency(); 597} 598 599status_t AudioFlinger::setMasterVolume(float value) 600{ 601 status_t ret = initCheck(); 602 if (ret != NO_ERROR) { 603 return ret; 604 } 605 606 // check calling permissions 607 if (!settingsAllowed()) { 608 return PERMISSION_DENIED; 609 } 610 611 Mutex::Autolock _l(mLock); 612 mMasterVolume = value; 613 614 // Set master volume in the HALs which support it. 615 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 616 AutoMutex lock(mHardwareLock); 617 AudioHwDevice *dev = mAudioHwDevs.valueAt(i); 618 619 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 620 if (dev->canSetMasterVolume()) { 621 dev->hwDevice()->set_master_volume(dev->hwDevice(), value); 622 } 623 mHardwareStatus = AUDIO_HW_IDLE; 624 } 625 626 // Now set the master volume in each playback thread. Playback threads 627 // assigned to HALs which do not have master volume support will apply 628 // master volume during the mix operation. Threads with HALs which do 629 // support master volume will simply ignore the setting. 630 for (size_t i = 0; i < mPlaybackThreads.size(); i++) 631 mPlaybackThreads.valueAt(i)->setMasterVolume(value); 632 633 return NO_ERROR; 634} 635 636status_t AudioFlinger::setMode(audio_mode_t mode) 637{ 638 status_t ret = initCheck(); 639 if (ret != NO_ERROR) { 640 return ret; 641 } 642 643 // check calling permissions 644 if (!settingsAllowed()) { 645 return PERMISSION_DENIED; 646 } 647 if (uint32_t(mode) >= AUDIO_MODE_CNT) { 648 ALOGW("Illegal value: setMode(%d)", mode); 649 return BAD_VALUE; 650 } 651 652 { // scope for the lock 653 AutoMutex lock(mHardwareLock); 654 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 655 mHardwareStatus = AUDIO_HW_SET_MODE; 656 ret = dev->set_mode(dev, mode); 657 mHardwareStatus = AUDIO_HW_IDLE; 658 } 659 660 if (NO_ERROR == ret) { 661 Mutex::Autolock _l(mLock); 662 mMode = mode; 663 for (size_t i = 0; i < mPlaybackThreads.size(); i++) 664 mPlaybackThreads.valueAt(i)->setMode(mode); 665 } 666 667 return ret; 668} 669 670status_t AudioFlinger::setMicMute(bool state) 671{ 672 status_t ret = initCheck(); 673 if (ret != NO_ERROR) { 674 return ret; 675 } 676 677 // check calling permissions 678 if (!settingsAllowed()) { 679 return PERMISSION_DENIED; 680 } 681 682 AutoMutex lock(mHardwareLock); 683 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 684 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE; 685 ret = dev->set_mic_mute(dev, state); 686 mHardwareStatus = AUDIO_HW_IDLE; 687 return ret; 688} 689 690bool AudioFlinger::getMicMute() const 691{ 692 status_t ret = initCheck(); 693 if (ret != NO_ERROR) { 694 return false; 695 } 696 697 bool state = AUDIO_MODE_INVALID; 698 AutoMutex lock(mHardwareLock); 699 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 700 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE; 701 dev->get_mic_mute(dev, &state); 702 mHardwareStatus = AUDIO_HW_IDLE; 703 return state; 704} 705 706status_t AudioFlinger::setMasterMute(bool muted) 707{ 708 status_t ret = initCheck(); 709 if (ret != NO_ERROR) { 710 return ret; 711 } 712 713 // check calling permissions 714 if (!settingsAllowed()) { 715 return PERMISSION_DENIED; 716 } 717 718 Mutex::Autolock _l(mLock); 719 mMasterMute = muted; 720 721 // Set master mute in the HALs which support it. 722 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 723 AutoMutex lock(mHardwareLock); 724 AudioHwDevice *dev = mAudioHwDevs.valueAt(i); 725 726 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE; 727 if (dev->canSetMasterMute()) { 728 dev->hwDevice()->set_master_mute(dev->hwDevice(), muted); 729 } 730 mHardwareStatus = AUDIO_HW_IDLE; 731 } 732 733 // Now set the master mute in each playback thread. Playback threads 734 // assigned to HALs which do not have master mute support will apply master 735 // mute during the mix operation. Threads with HALs which do support master 736 // mute will simply ignore the setting. 737 for (size_t i = 0; i < mPlaybackThreads.size(); i++) 738 mPlaybackThreads.valueAt(i)->setMasterMute(muted); 739 740 return NO_ERROR; 741} 742 743float AudioFlinger::masterVolume() const 744{ 745 Mutex::Autolock _l(mLock); 746 return masterVolume_l(); 747} 748 749bool AudioFlinger::masterMute() const 750{ 751 Mutex::Autolock _l(mLock); 752 return masterMute_l(); 753} 754 755float AudioFlinger::masterVolume_l() const 756{ 757 return mMasterVolume; 758} 759 760bool AudioFlinger::masterMute_l() const 761{ 762 return mMasterMute; 763} 764 765status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value, 766 audio_io_handle_t output) 767{ 768 // check calling permissions 769 if (!settingsAllowed()) { 770 return PERMISSION_DENIED; 771 } 772 773 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 774 ALOGE("setStreamVolume() invalid stream %d", stream); 775 return BAD_VALUE; 776 } 777 778 AutoMutex lock(mLock); 779 PlaybackThread *thread = NULL; 780 if (output) { 781 thread = checkPlaybackThread_l(output); 782 if (thread == NULL) { 783 return BAD_VALUE; 784 } 785 } 786 787 mStreamTypes[stream].volume = value; 788 789 if (thread == NULL) { 790 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 791 mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value); 792 } 793 } else { 794 thread->setStreamVolume(stream, value); 795 } 796 797 return NO_ERROR; 798} 799 800status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted) 801{ 802 // check calling permissions 803 if (!settingsAllowed()) { 804 return PERMISSION_DENIED; 805 } 806 807 if (uint32_t(stream) >= AUDIO_STREAM_CNT || 808 uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) { 809 ALOGE("setStreamMute() invalid stream %d", stream); 810 return BAD_VALUE; 811 } 812 813 AutoMutex lock(mLock); 814 mStreamTypes[stream].mute = muted; 815 for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) 816 mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted); 817 818 return NO_ERROR; 819} 820 821float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const 822{ 823 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 824 return 0.0f; 825 } 826 827 AutoMutex lock(mLock); 828 float volume; 829 if (output) { 830 PlaybackThread *thread = checkPlaybackThread_l(output); 831 if (thread == NULL) { 832 return 0.0f; 833 } 834 volume = thread->streamVolume(stream); 835 } else { 836 volume = streamVolume_l(stream); 837 } 838 839 return volume; 840} 841 842bool AudioFlinger::streamMute(audio_stream_type_t stream) const 843{ 844 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 845 return true; 846 } 847 848 AutoMutex lock(mLock); 849 return streamMute_l(stream); 850} 851 852status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) 853{ 854 ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d", 855 ioHandle, keyValuePairs.string(), IPCThreadState::self()->getCallingPid()); 856 857 // check calling permissions 858 if (!settingsAllowed()) { 859 return PERMISSION_DENIED; 860 } 861 862 // ioHandle == 0 means the parameters are global to the audio hardware interface 863 if (ioHandle == 0) { 864 Mutex::Autolock _l(mLock); 865 status_t final_result = NO_ERROR; 866 { 867 AutoMutex lock(mHardwareLock); 868 mHardwareStatus = AUDIO_HW_SET_PARAMETER; 869 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 870 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 871 status_t result = dev->set_parameters(dev, keyValuePairs.string()); 872 final_result = result ?: final_result; 873 } 874 mHardwareStatus = AUDIO_HW_IDLE; 875 } 876 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings 877 AudioParameter param = AudioParameter(keyValuePairs); 878 String8 value; 879 if (param.get(String8(AUDIO_PARAMETER_KEY_BT_NREC), value) == NO_ERROR) { 880 bool btNrecIsOff = (value == AUDIO_PARAMETER_VALUE_OFF); 881 if (mBtNrecIsOff != btNrecIsOff) { 882 for (size_t i = 0; i < mRecordThreads.size(); i++) { 883 sp<RecordThread> thread = mRecordThreads.valueAt(i); 884 audio_devices_t device = thread->inDevice(); 885 bool suspend = audio_is_bluetooth_sco_device(device) && btNrecIsOff; 886 // collect all of the thread's session IDs 887 KeyedVector<int, bool> ids = thread->sessionIds(); 888 // suspend effects associated with those session IDs 889 for (size_t j = 0; j < ids.size(); ++j) { 890 int sessionId = ids.keyAt(j); 891 thread->setEffectSuspended(FX_IID_AEC, 892 suspend, 893 sessionId); 894 thread->setEffectSuspended(FX_IID_NS, 895 suspend, 896 sessionId); 897 } 898 } 899 mBtNrecIsOff = btNrecIsOff; 900 } 901 } 902 String8 screenState; 903 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) { 904 bool isOff = screenState == "off"; 905 if (isOff != (AudioFlinger::mScreenState & 1)) { 906 AudioFlinger::mScreenState = ((AudioFlinger::mScreenState & ~1) + 2) | isOff; 907 } 908 } 909 return final_result; 910 } 911 912 // hold a strong ref on thread in case closeOutput() or closeInput() is called 913 // and the thread is exited once the lock is released 914 sp<ThreadBase> thread; 915 { 916 Mutex::Autolock _l(mLock); 917 thread = checkPlaybackThread_l(ioHandle); 918 if (thread == 0) { 919 thread = checkRecordThread_l(ioHandle); 920 } else if (thread == primaryPlaybackThread_l()) { 921 // indicate output device change to all input threads for pre processing 922 AudioParameter param = AudioParameter(keyValuePairs); 923 int value; 924 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) && 925 (value != 0)) { 926 for (size_t i = 0; i < mRecordThreads.size(); i++) { 927 mRecordThreads.valueAt(i)->setParameters(keyValuePairs); 928 } 929 } 930 } 931 } 932 if (thread != 0) { 933 return thread->setParameters(keyValuePairs); 934 } 935 return BAD_VALUE; 936} 937 938String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const 939{ 940 ALOGVV("getParameters() io %d, keys %s, calling pid %d", 941 ioHandle, keys.string(), IPCThreadState::self()->getCallingPid()); 942 943 Mutex::Autolock _l(mLock); 944 945 if (ioHandle == 0) { 946 String8 out_s8; 947 948 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 949 char *s; 950 { 951 AutoMutex lock(mHardwareLock); 952 mHardwareStatus = AUDIO_HW_GET_PARAMETER; 953 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 954 s = dev->get_parameters(dev, keys.string()); 955 mHardwareStatus = AUDIO_HW_IDLE; 956 } 957 out_s8 += String8(s ? s : ""); 958 free(s); 959 } 960 return out_s8; 961 } 962 963 PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle); 964 if (playbackThread != NULL) { 965 return playbackThread->getParameters(keys); 966 } 967 RecordThread *recordThread = checkRecordThread_l(ioHandle); 968 if (recordThread != NULL) { 969 return recordThread->getParameters(keys); 970 } 971 return String8(""); 972} 973 974size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format, 975 audio_channel_mask_t channelMask) const 976{ 977 status_t ret = initCheck(); 978 if (ret != NO_ERROR) { 979 return 0; 980 } 981 982 AutoMutex lock(mHardwareLock); 983 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE; 984 struct audio_config config; 985 memset(&config, 0, sizeof(config)); 986 config.sample_rate = sampleRate; 987 config.channel_mask = channelMask; 988 config.format = format; 989 990 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 991 size_t size = dev->get_input_buffer_size(dev, &config); 992 mHardwareStatus = AUDIO_HW_IDLE; 993 return size; 994} 995 996unsigned int AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const 997{ 998 Mutex::Autolock _l(mLock); 999 1000 RecordThread *recordThread = checkRecordThread_l(ioHandle); 1001 if (recordThread != NULL) { 1002 return recordThread->getInputFramesLost(); 1003 } 1004 return 0; 1005} 1006 1007status_t AudioFlinger::setVoiceVolume(float value) 1008{ 1009 status_t ret = initCheck(); 1010 if (ret != NO_ERROR) { 1011 return ret; 1012 } 1013 1014 // check calling permissions 1015 if (!settingsAllowed()) { 1016 return PERMISSION_DENIED; 1017 } 1018 1019 AutoMutex lock(mHardwareLock); 1020 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 1021 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME; 1022 ret = dev->set_voice_volume(dev, value); 1023 mHardwareStatus = AUDIO_HW_IDLE; 1024 1025 return ret; 1026} 1027 1028status_t AudioFlinger::getRenderPosition(size_t *halFrames, size_t *dspFrames, 1029 audio_io_handle_t output) const 1030{ 1031 status_t status; 1032 1033 Mutex::Autolock _l(mLock); 1034 1035 PlaybackThread *playbackThread = checkPlaybackThread_l(output); 1036 if (playbackThread != NULL) { 1037 return playbackThread->getRenderPosition(halFrames, dspFrames); 1038 } 1039 1040 return BAD_VALUE; 1041} 1042 1043void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client) 1044{ 1045 1046 Mutex::Autolock _l(mLock); 1047 1048 pid_t pid = IPCThreadState::self()->getCallingPid(); 1049 if (mNotificationClients.indexOfKey(pid) < 0) { 1050 sp<NotificationClient> notificationClient = new NotificationClient(this, 1051 client, 1052 pid); 1053 ALOGV("registerClient() client %p, pid %d", notificationClient.get(), pid); 1054 1055 mNotificationClients.add(pid, notificationClient); 1056 1057 sp<IBinder> binder = client->asBinder(); 1058 binder->linkToDeath(notificationClient); 1059 1060 // the config change is always sent from playback or record threads to avoid deadlock 1061 // with AudioSystem::gLock 1062 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1063 mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AudioSystem::OUTPUT_OPENED); 1064 } 1065 1066 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1067 mRecordThreads.valueAt(i)->sendIoConfigEvent(AudioSystem::INPUT_OPENED); 1068 } 1069 } 1070} 1071 1072void AudioFlinger::removeNotificationClient(pid_t pid) 1073{ 1074 Mutex::Autolock _l(mLock); 1075 1076 mNotificationClients.removeItem(pid); 1077 1078 ALOGV("%d died, releasing its sessions", pid); 1079 size_t num = mAudioSessionRefs.size(); 1080 bool removed = false; 1081 for (size_t i = 0; i< num; ) { 1082 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i); 1083 ALOGV(" pid %d @ %d", ref->mPid, i); 1084 if (ref->mPid == pid) { 1085 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid); 1086 mAudioSessionRefs.removeAt(i); 1087 delete ref; 1088 removed = true; 1089 num--; 1090 } else { 1091 i++; 1092 } 1093 } 1094 if (removed) { 1095 purgeStaleEffects_l(); 1096 } 1097} 1098 1099// audioConfigChanged_l() must be called with AudioFlinger::mLock held 1100void AudioFlinger::audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2) 1101{ 1102 size_t size = mNotificationClients.size(); 1103 for (size_t i = 0; i < size; i++) { 1104 mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(event, ioHandle, 1105 param2); 1106 } 1107} 1108 1109// removeClient_l() must be called with AudioFlinger::mLock held 1110void AudioFlinger::removeClient_l(pid_t pid) 1111{ 1112 ALOGV("removeClient_l() pid %d, calling pid %d", pid, 1113 IPCThreadState::self()->getCallingPid()); 1114 mClients.removeItem(pid); 1115} 1116 1117// getEffectThread_l() must be called with AudioFlinger::mLock held 1118sp<AudioFlinger::PlaybackThread> AudioFlinger::getEffectThread_l(int sessionId, int EffectId) 1119{ 1120 sp<PlaybackThread> thread; 1121 1122 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1123 if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, EffectId) != 0) { 1124 ALOG_ASSERT(thread == 0); 1125 thread = mPlaybackThreads.valueAt(i); 1126 } 1127 } 1128 1129 return thread; 1130} 1131 1132 1133 1134// ---------------------------------------------------------------------------- 1135 1136AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid) 1137 : RefBase(), 1138 mAudioFlinger(audioFlinger), 1139 // FIXME should be a "k" constant not hard-coded, in .h or ro. property, see 4 lines below 1140 mMemoryDealer(new MemoryDealer(1024*1024, "AudioFlinger::Client")), 1141 mPid(pid), 1142 mTimedTrackCount(0) 1143{ 1144 // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer 1145} 1146 1147// Client destructor must be called with AudioFlinger::mLock held 1148AudioFlinger::Client::~Client() 1149{ 1150 mAudioFlinger->removeClient_l(mPid); 1151} 1152 1153sp<MemoryDealer> AudioFlinger::Client::heap() const 1154{ 1155 return mMemoryDealer; 1156} 1157 1158// Reserve one of the limited slots for a timed audio track associated 1159// with this client 1160bool AudioFlinger::Client::reserveTimedTrack() 1161{ 1162 const int kMaxTimedTracksPerClient = 4; 1163 1164 Mutex::Autolock _l(mTimedTrackLock); 1165 1166 if (mTimedTrackCount >= kMaxTimedTracksPerClient) { 1167 ALOGW("can not create timed track - pid %d has exceeded the limit", 1168 mPid); 1169 return false; 1170 } 1171 1172 mTimedTrackCount++; 1173 return true; 1174} 1175 1176// Release a slot for a timed audio track 1177void AudioFlinger::Client::releaseTimedTrack() 1178{ 1179 Mutex::Autolock _l(mTimedTrackLock); 1180 mTimedTrackCount--; 1181} 1182 1183// ---------------------------------------------------------------------------- 1184 1185AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger, 1186 const sp<IAudioFlingerClient>& client, 1187 pid_t pid) 1188 : mAudioFlinger(audioFlinger), mPid(pid), mAudioFlingerClient(client) 1189{ 1190} 1191 1192AudioFlinger::NotificationClient::~NotificationClient() 1193{ 1194} 1195 1196void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who) 1197{ 1198 sp<NotificationClient> keep(this); 1199 mAudioFlinger->removeNotificationClient(mPid); 1200} 1201 1202 1203// ---------------------------------------------------------------------------- 1204 1205sp<IAudioRecord> AudioFlinger::openRecord( 1206 audio_io_handle_t input, 1207 uint32_t sampleRate, 1208 audio_format_t format, 1209 audio_channel_mask_t channelMask, 1210 size_t frameCount, 1211 IAudioFlinger::track_flags_t flags, 1212 pid_t tid, 1213 int *sessionId, 1214 status_t *status) 1215{ 1216 sp<RecordThread::RecordTrack> recordTrack; 1217 sp<RecordHandle> recordHandle; 1218 sp<Client> client; 1219 status_t lStatus; 1220 RecordThread *thread; 1221 size_t inFrameCount; 1222 int lSessionId; 1223 1224 // check calling permissions 1225 if (!recordingAllowed()) { 1226 lStatus = PERMISSION_DENIED; 1227 goto Exit; 1228 } 1229 1230 // add client to list 1231 { // scope for mLock 1232 Mutex::Autolock _l(mLock); 1233 thread = checkRecordThread_l(input); 1234 if (thread == NULL) { 1235 lStatus = BAD_VALUE; 1236 goto Exit; 1237 } 1238 1239 pid_t pid = IPCThreadState::self()->getCallingPid(); 1240 client = registerPid_l(pid); 1241 1242 // If no audio session id is provided, create one here 1243 if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) { 1244 lSessionId = *sessionId; 1245 } else { 1246 lSessionId = nextUniqueId(); 1247 if (sessionId != NULL) { 1248 *sessionId = lSessionId; 1249 } 1250 } 1251 // create new record track. 1252 // The record track uses one track in mHardwareMixerThread by convention. 1253 recordTrack = thread->createRecordTrack_l(client, sampleRate, format, channelMask, 1254 frameCount, lSessionId, flags, tid, &lStatus); 1255 } 1256 if (lStatus != NO_ERROR) { 1257 // remove local strong reference to Client before deleting the RecordTrack so that the 1258 // Client destructor is called by the TrackBase destructor with mLock held 1259 client.clear(); 1260 recordTrack.clear(); 1261 goto Exit; 1262 } 1263 1264 // return to handle to client 1265 recordHandle = new RecordHandle(recordTrack); 1266 lStatus = NO_ERROR; 1267 1268Exit: 1269 if (status) { 1270 *status = lStatus; 1271 } 1272 return recordHandle; 1273} 1274 1275 1276 1277// ---------------------------------------------------------------------------- 1278 1279audio_module_handle_t AudioFlinger::loadHwModule(const char *name) 1280{ 1281 if (!settingsAllowed()) { 1282 return 0; 1283 } 1284 Mutex::Autolock _l(mLock); 1285 return loadHwModule_l(name); 1286} 1287 1288// loadHwModule_l() must be called with AudioFlinger::mLock held 1289audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name) 1290{ 1291 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 1292 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) { 1293 ALOGW("loadHwModule() module %s already loaded", name); 1294 return mAudioHwDevs.keyAt(i); 1295 } 1296 } 1297 1298 audio_hw_device_t *dev; 1299 1300 int rc = load_audio_interface(name, &dev); 1301 if (rc) { 1302 ALOGI("loadHwModule() error %d loading module %s ", rc, name); 1303 return 0; 1304 } 1305 1306 mHardwareStatus = AUDIO_HW_INIT; 1307 rc = dev->init_check(dev); 1308 mHardwareStatus = AUDIO_HW_IDLE; 1309 if (rc) { 1310 ALOGI("loadHwModule() init check error %d for module %s ", rc, name); 1311 return 0; 1312 } 1313 1314 // Check and cache this HAL's level of support for master mute and master 1315 // volume. If this is the first HAL opened, and it supports the get 1316 // methods, use the initial values provided by the HAL as the current 1317 // master mute and volume settings. 1318 1319 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0); 1320 { // scope for auto-lock pattern 1321 AutoMutex lock(mHardwareLock); 1322 1323 if (0 == mAudioHwDevs.size()) { 1324 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME; 1325 if (NULL != dev->get_master_volume) { 1326 float mv; 1327 if (OK == dev->get_master_volume(dev, &mv)) { 1328 mMasterVolume = mv; 1329 } 1330 } 1331 1332 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE; 1333 if (NULL != dev->get_master_mute) { 1334 bool mm; 1335 if (OK == dev->get_master_mute(dev, &mm)) { 1336 mMasterMute = mm; 1337 } 1338 } 1339 } 1340 1341 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 1342 if ((NULL != dev->set_master_volume) && 1343 (OK == dev->set_master_volume(dev, mMasterVolume))) { 1344 flags = static_cast<AudioHwDevice::Flags>(flags | 1345 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME); 1346 } 1347 1348 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE; 1349 if ((NULL != dev->set_master_mute) && 1350 (OK == dev->set_master_mute(dev, mMasterMute))) { 1351 flags = static_cast<AudioHwDevice::Flags>(flags | 1352 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE); 1353 } 1354 1355 mHardwareStatus = AUDIO_HW_IDLE; 1356 } 1357 1358 audio_module_handle_t handle = nextUniqueId(); 1359 mAudioHwDevs.add(handle, new AudioHwDevice(name, dev, flags)); 1360 1361 ALOGI("loadHwModule() Loaded %s audio interface from %s (%s) handle %d", 1362 name, dev->common.module->name, dev->common.module->id, handle); 1363 1364 return handle; 1365 1366} 1367 1368// ---------------------------------------------------------------------------- 1369 1370uint32_t AudioFlinger::getPrimaryOutputSamplingRate() 1371{ 1372 Mutex::Autolock _l(mLock); 1373 PlaybackThread *thread = primaryPlaybackThread_l(); 1374 return thread != NULL ? thread->sampleRate() : 0; 1375} 1376 1377size_t AudioFlinger::getPrimaryOutputFrameCount() 1378{ 1379 Mutex::Autolock _l(mLock); 1380 PlaybackThread *thread = primaryPlaybackThread_l(); 1381 return thread != NULL ? thread->frameCountHAL() : 0; 1382} 1383 1384// ---------------------------------------------------------------------------- 1385 1386status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice) 1387{ 1388 uid_t uid = IPCThreadState::self()->getCallingUid(); 1389 if (uid != AID_SYSTEM) { 1390 return PERMISSION_DENIED; 1391 } 1392 Mutex::Autolock _l(mLock); 1393 if (mIsDeviceTypeKnown) { 1394 return INVALID_OPERATION; 1395 } 1396 mIsLowRamDevice = isLowRamDevice; 1397 mIsDeviceTypeKnown = true; 1398 return NO_ERROR; 1399} 1400 1401// ---------------------------------------------------------------------------- 1402 1403audio_io_handle_t AudioFlinger::openOutput(audio_module_handle_t module, 1404 audio_devices_t *pDevices, 1405 uint32_t *pSamplingRate, 1406 audio_format_t *pFormat, 1407 audio_channel_mask_t *pChannelMask, 1408 uint32_t *pLatencyMs, 1409 audio_output_flags_t flags, 1410 const audio_offload_info_t *offloadInfo) 1411{ 1412 PlaybackThread *thread = NULL; 1413 struct audio_config config; 1414 config.sample_rate = (pSamplingRate != NULL) ? *pSamplingRate : 0; 1415 config.channel_mask = (pChannelMask != NULL) ? *pChannelMask : 0; 1416 config.format = (pFormat != NULL) ? *pFormat : AUDIO_FORMAT_DEFAULT; 1417 if (offloadInfo) { 1418 config.offload_info = *offloadInfo; 1419 } 1420 1421 audio_stream_out_t *outStream = NULL; 1422 AudioHwDevice *outHwDev; 1423 1424 ALOGV("openOutput(), module %d Device %x, SamplingRate %d, Format %#08x, Channels %x, flags %x", 1425 module, 1426 (pDevices != NULL) ? *pDevices : 0, 1427 config.sample_rate, 1428 config.format, 1429 config.channel_mask, 1430 flags); 1431 ALOGV("openOutput(), offloadInfo %p version 0x%04x", 1432 offloadInfo, offloadInfo == NULL ? -1 : offloadInfo->version ); 1433 1434 if (pDevices == NULL || *pDevices == 0) { 1435 return 0; 1436 } 1437 1438 Mutex::Autolock _l(mLock); 1439 1440 outHwDev = findSuitableHwDev_l(module, *pDevices); 1441 if (outHwDev == NULL) 1442 return 0; 1443 1444 audio_hw_device_t *hwDevHal = outHwDev->hwDevice(); 1445 audio_io_handle_t id = nextUniqueId(); 1446 1447 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN; 1448 1449 status_t status = hwDevHal->open_output_stream(hwDevHal, 1450 id, 1451 *pDevices, 1452 (audio_output_flags_t)flags, 1453 &config, 1454 &outStream); 1455 1456 mHardwareStatus = AUDIO_HW_IDLE; 1457 ALOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %#08x, " 1458 "Channels %x, status %d", 1459 outStream, 1460 config.sample_rate, 1461 config.format, 1462 config.channel_mask, 1463 status); 1464 1465 if (status == NO_ERROR && outStream != NULL) { 1466 AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream, flags); 1467 1468 if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) { 1469 thread = new OffloadThread(this, output, id, *pDevices); 1470 ALOGV("openOutput() created offload output: ID %d thread %p", id, thread); 1471 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT) || 1472 (config.format != AUDIO_FORMAT_PCM_16_BIT) || 1473 (config.channel_mask != AUDIO_CHANNEL_OUT_STEREO)) { 1474 thread = new DirectOutputThread(this, output, id, *pDevices); 1475 ALOGV("openOutput() created direct output: ID %d thread %p", id, thread); 1476 } else { 1477 thread = new MixerThread(this, output, id, *pDevices); 1478 ALOGV("openOutput() created mixer output: ID %d thread %p", id, thread); 1479 } 1480 mPlaybackThreads.add(id, thread); 1481 1482 if (pSamplingRate != NULL) { 1483 *pSamplingRate = config.sample_rate; 1484 } 1485 if (pFormat != NULL) { 1486 *pFormat = config.format; 1487 } 1488 if (pChannelMask != NULL) { 1489 *pChannelMask = config.channel_mask; 1490 } 1491 if (pLatencyMs != NULL) { 1492 *pLatencyMs = thread->latency(); 1493 } 1494 1495 // notify client processes of the new output creation 1496 thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED); 1497 1498 // the first primary output opened designates the primary hw device 1499 if ((mPrimaryHardwareDev == NULL) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) { 1500 ALOGI("Using module %d has the primary audio interface", module); 1501 mPrimaryHardwareDev = outHwDev; 1502 1503 AutoMutex lock(mHardwareLock); 1504 mHardwareStatus = AUDIO_HW_SET_MODE; 1505 hwDevHal->set_mode(hwDevHal, mMode); 1506 mHardwareStatus = AUDIO_HW_IDLE; 1507 } 1508 return id; 1509 } 1510 1511 return 0; 1512} 1513 1514audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1, 1515 audio_io_handle_t output2) 1516{ 1517 Mutex::Autolock _l(mLock); 1518 MixerThread *thread1 = checkMixerThread_l(output1); 1519 MixerThread *thread2 = checkMixerThread_l(output2); 1520 1521 if (thread1 == NULL || thread2 == NULL) { 1522 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, 1523 output2); 1524 return 0; 1525 } 1526 1527 audio_io_handle_t id = nextUniqueId(); 1528 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id); 1529 thread->addOutputTrack(thread2); 1530 mPlaybackThreads.add(id, thread); 1531 // notify client processes of the new output creation 1532 thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED); 1533 return id; 1534} 1535 1536status_t AudioFlinger::closeOutput(audio_io_handle_t output) 1537{ 1538 return closeOutput_nonvirtual(output); 1539} 1540 1541status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output) 1542{ 1543 // keep strong reference on the playback thread so that 1544 // it is not destroyed while exit() is executed 1545 sp<PlaybackThread> thread; 1546 { 1547 Mutex::Autolock _l(mLock); 1548 thread = checkPlaybackThread_l(output); 1549 if (thread == NULL) { 1550 return BAD_VALUE; 1551 } 1552 1553 ALOGV("closeOutput() %d", output); 1554 1555 if (thread->type() == ThreadBase::MIXER) { 1556 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1557 if (mPlaybackThreads.valueAt(i)->type() == ThreadBase::DUPLICATING) { 1558 DuplicatingThread *dupThread = 1559 (DuplicatingThread *)mPlaybackThreads.valueAt(i).get(); 1560 dupThread->removeOutputTrack((MixerThread *)thread.get()); 1561 1562 } 1563 } 1564 } 1565 1566 1567 mPlaybackThreads.removeItem(output); 1568 // save all effects to the default thread 1569 if (mPlaybackThreads.size()) { 1570 PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0)); 1571 if (dstThread != NULL) { 1572 // audioflinger lock is held here so the acquisition order of thread locks does not 1573 // matter 1574 Mutex::Autolock _dl(dstThread->mLock); 1575 Mutex::Autolock _sl(thread->mLock); 1576 Vector< sp<EffectChain> > effectChains = thread->getEffectChains_l(); 1577 for (size_t i = 0; i < effectChains.size(); i ++) { 1578 moveEffectChain_l(effectChains[i]->sessionId(), thread.get(), dstThread, true); 1579 } 1580 } 1581 } 1582 audioConfigChanged_l(AudioSystem::OUTPUT_CLOSED, output, NULL); 1583 } 1584 thread->exit(); 1585 // The thread entity (active unit of execution) is no longer running here, 1586 // but the ThreadBase container still exists. 1587 1588 if (thread->type() != ThreadBase::DUPLICATING) { 1589 AudioStreamOut *out = thread->clearOutput(); 1590 ALOG_ASSERT(out != NULL, "out shouldn't be NULL"); 1591 // from now on thread->mOutput is NULL 1592 out->hwDev()->close_output_stream(out->hwDev(), out->stream); 1593 delete out; 1594 } 1595 return NO_ERROR; 1596} 1597 1598status_t AudioFlinger::suspendOutput(audio_io_handle_t output) 1599{ 1600 Mutex::Autolock _l(mLock); 1601 PlaybackThread *thread = checkPlaybackThread_l(output); 1602 1603 if (thread == NULL) { 1604 return BAD_VALUE; 1605 } 1606 1607 ALOGV("suspendOutput() %d", output); 1608 thread->suspend(); 1609 1610 return NO_ERROR; 1611} 1612 1613status_t AudioFlinger::restoreOutput(audio_io_handle_t output) 1614{ 1615 Mutex::Autolock _l(mLock); 1616 PlaybackThread *thread = checkPlaybackThread_l(output); 1617 1618 if (thread == NULL) { 1619 return BAD_VALUE; 1620 } 1621 1622 ALOGV("restoreOutput() %d", output); 1623 1624 thread->restore(); 1625 1626 return NO_ERROR; 1627} 1628 1629audio_io_handle_t AudioFlinger::openInput(audio_module_handle_t module, 1630 audio_devices_t *pDevices, 1631 uint32_t *pSamplingRate, 1632 audio_format_t *pFormat, 1633 audio_channel_mask_t *pChannelMask) 1634{ 1635 status_t status; 1636 RecordThread *thread = NULL; 1637 struct audio_config config; 1638 config.sample_rate = (pSamplingRate != NULL) ? *pSamplingRate : 0; 1639 config.channel_mask = (pChannelMask != NULL) ? *pChannelMask : 0; 1640 config.format = (pFormat != NULL) ? *pFormat : AUDIO_FORMAT_DEFAULT; 1641 1642 uint32_t reqSamplingRate = config.sample_rate; 1643 audio_format_t reqFormat = config.format; 1644 audio_channel_mask_t reqChannels = config.channel_mask; 1645 audio_stream_in_t *inStream = NULL; 1646 AudioHwDevice *inHwDev; 1647 1648 if (pDevices == NULL || *pDevices == 0) { 1649 return 0; 1650 } 1651 1652 Mutex::Autolock _l(mLock); 1653 1654 inHwDev = findSuitableHwDev_l(module, *pDevices); 1655 if (inHwDev == NULL) 1656 return 0; 1657 1658 audio_hw_device_t *inHwHal = inHwDev->hwDevice(); 1659 audio_io_handle_t id = nextUniqueId(); 1660 1661 status = inHwHal->open_input_stream(inHwHal, id, *pDevices, &config, 1662 &inStream); 1663 ALOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %d, Channels %x, " 1664 "status %d", 1665 inStream, 1666 config.sample_rate, 1667 config.format, 1668 config.channel_mask, 1669 status); 1670 1671 // If the input could not be opened with the requested parameters and we can handle the 1672 // conversion internally, try to open again with the proposed parameters. The AudioFlinger can 1673 // resample the input and do mono to stereo or stereo to mono conversions on 16 bit PCM inputs. 1674 if (status == BAD_VALUE && 1675 reqFormat == config.format && config.format == AUDIO_FORMAT_PCM_16_BIT && 1676 (config.sample_rate <= 2 * reqSamplingRate) && 1677 (popcount(config.channel_mask) <= FCC_2) && (popcount(reqChannels) <= FCC_2)) { 1678 ALOGV("openInput() reopening with proposed sampling rate and channel mask"); 1679 inStream = NULL; 1680 status = inHwHal->open_input_stream(inHwHal, id, *pDevices, &config, &inStream); 1681 } 1682 1683 if (status == NO_ERROR && inStream != NULL) { 1684 1685#ifdef TEE_SINK 1686 // Try to re-use most recently used Pipe to archive a copy of input for dumpsys, 1687 // or (re-)create if current Pipe is idle and does not match the new format 1688 sp<NBAIO_Sink> teeSink; 1689 enum { 1690 TEE_SINK_NO, // don't copy input 1691 TEE_SINK_NEW, // copy input using a new pipe 1692 TEE_SINK_OLD, // copy input using an existing pipe 1693 } kind; 1694 NBAIO_Format format = Format_from_SR_C(inStream->common.get_sample_rate(&inStream->common), 1695 popcount(inStream->common.get_channels(&inStream->common))); 1696 if (!mTeeSinkInputEnabled) { 1697 kind = TEE_SINK_NO; 1698 } else if (format == Format_Invalid) { 1699 kind = TEE_SINK_NO; 1700 } else if (mRecordTeeSink == 0) { 1701 kind = TEE_SINK_NEW; 1702 } else if (mRecordTeeSink->getStrongCount() != 1) { 1703 kind = TEE_SINK_NO; 1704 } else if (format == mRecordTeeSink->format()) { 1705 kind = TEE_SINK_OLD; 1706 } else { 1707 kind = TEE_SINK_NEW; 1708 } 1709 switch (kind) { 1710 case TEE_SINK_NEW: { 1711 Pipe *pipe = new Pipe(mTeeSinkInputFrames, format); 1712 size_t numCounterOffers = 0; 1713 const NBAIO_Format offers[1] = {format}; 1714 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers); 1715 ALOG_ASSERT(index == 0); 1716 PipeReader *pipeReader = new PipeReader(*pipe); 1717 numCounterOffers = 0; 1718 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers); 1719 ALOG_ASSERT(index == 0); 1720 mRecordTeeSink = pipe; 1721 mRecordTeeSource = pipeReader; 1722 teeSink = pipe; 1723 } 1724 break; 1725 case TEE_SINK_OLD: 1726 teeSink = mRecordTeeSink; 1727 break; 1728 case TEE_SINK_NO: 1729 default: 1730 break; 1731 } 1732#endif 1733 1734 AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream); 1735 1736 // Start record thread 1737 // RecorThread require both input and output device indication to forward to audio 1738 // pre processing modules 1739 thread = new RecordThread(this, 1740 input, 1741 reqSamplingRate, 1742 reqChannels, 1743 id, 1744 primaryOutputDevice_l(), 1745 *pDevices 1746#ifdef TEE_SINK 1747 , teeSink 1748#endif 1749 ); 1750 mRecordThreads.add(id, thread); 1751 ALOGV("openInput() created record thread: ID %d thread %p", id, thread); 1752 if (pSamplingRate != NULL) { 1753 *pSamplingRate = reqSamplingRate; 1754 } 1755 if (pFormat != NULL) { 1756 *pFormat = config.format; 1757 } 1758 if (pChannelMask != NULL) { 1759 *pChannelMask = reqChannels; 1760 } 1761 1762 // notify client processes of the new input creation 1763 thread->audioConfigChanged_l(AudioSystem::INPUT_OPENED); 1764 return id; 1765 } 1766 1767 return 0; 1768} 1769 1770status_t AudioFlinger::closeInput(audio_io_handle_t input) 1771{ 1772 return closeInput_nonvirtual(input); 1773} 1774 1775status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input) 1776{ 1777 // keep strong reference on the record thread so that 1778 // it is not destroyed while exit() is executed 1779 sp<RecordThread> thread; 1780 { 1781 Mutex::Autolock _l(mLock); 1782 thread = checkRecordThread_l(input); 1783 if (thread == 0) { 1784 return BAD_VALUE; 1785 } 1786 1787 ALOGV("closeInput() %d", input); 1788 audioConfigChanged_l(AudioSystem::INPUT_CLOSED, input, NULL); 1789 mRecordThreads.removeItem(input); 1790 } 1791 thread->exit(); 1792 // The thread entity (active unit of execution) is no longer running here, 1793 // but the ThreadBase container still exists. 1794 1795 AudioStreamIn *in = thread->clearInput(); 1796 ALOG_ASSERT(in != NULL, "in shouldn't be NULL"); 1797 // from now on thread->mInput is NULL 1798 in->hwDev()->close_input_stream(in->hwDev(), in->stream); 1799 delete in; 1800 1801 return NO_ERROR; 1802} 1803 1804status_t AudioFlinger::setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output) 1805{ 1806 Mutex::Autolock _l(mLock); 1807 ALOGV("setStreamOutput() stream %d to output %d", stream, output); 1808 1809 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1810 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 1811 thread->invalidateTracks(stream); 1812 } 1813 1814 return NO_ERROR; 1815} 1816 1817 1818int AudioFlinger::newAudioSessionId() 1819{ 1820 return nextUniqueId(); 1821} 1822 1823void AudioFlinger::acquireAudioSessionId(int audioSession) 1824{ 1825 Mutex::Autolock _l(mLock); 1826 pid_t caller = IPCThreadState::self()->getCallingPid(); 1827 ALOGV("acquiring %d from %d", audioSession, caller); 1828 size_t num = mAudioSessionRefs.size(); 1829 for (size_t i = 0; i< num; i++) { 1830 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i); 1831 if (ref->mSessionid == audioSession && ref->mPid == caller) { 1832 ref->mCnt++; 1833 ALOGV(" incremented refcount to %d", ref->mCnt); 1834 return; 1835 } 1836 } 1837 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller)); 1838 ALOGV(" added new entry for %d", audioSession); 1839} 1840 1841void AudioFlinger::releaseAudioSessionId(int audioSession) 1842{ 1843 Mutex::Autolock _l(mLock); 1844 pid_t caller = IPCThreadState::self()->getCallingPid(); 1845 ALOGV("releasing %d from %d", audioSession, caller); 1846 size_t num = mAudioSessionRefs.size(); 1847 for (size_t i = 0; i< num; i++) { 1848 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i); 1849 if (ref->mSessionid == audioSession && ref->mPid == caller) { 1850 ref->mCnt--; 1851 ALOGV(" decremented refcount to %d", ref->mCnt); 1852 if (ref->mCnt == 0) { 1853 mAudioSessionRefs.removeAt(i); 1854 delete ref; 1855 purgeStaleEffects_l(); 1856 } 1857 return; 1858 } 1859 } 1860 ALOGW("session id %d not found for pid %d", audioSession, caller); 1861} 1862 1863void AudioFlinger::purgeStaleEffects_l() { 1864 1865 ALOGV("purging stale effects"); 1866 1867 Vector< sp<EffectChain> > chains; 1868 1869 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1870 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 1871 for (size_t j = 0; j < t->mEffectChains.size(); j++) { 1872 sp<EffectChain> ec = t->mEffectChains[j]; 1873 if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) { 1874 chains.push(ec); 1875 } 1876 } 1877 } 1878 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1879 sp<RecordThread> t = mRecordThreads.valueAt(i); 1880 for (size_t j = 0; j < t->mEffectChains.size(); j++) { 1881 sp<EffectChain> ec = t->mEffectChains[j]; 1882 chains.push(ec); 1883 } 1884 } 1885 1886 for (size_t i = 0; i < chains.size(); i++) { 1887 sp<EffectChain> ec = chains[i]; 1888 int sessionid = ec->sessionId(); 1889 sp<ThreadBase> t = ec->mThread.promote(); 1890 if (t == 0) { 1891 continue; 1892 } 1893 size_t numsessionrefs = mAudioSessionRefs.size(); 1894 bool found = false; 1895 for (size_t k = 0; k < numsessionrefs; k++) { 1896 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k); 1897 if (ref->mSessionid == sessionid) { 1898 ALOGV(" session %d still exists for %d with %d refs", 1899 sessionid, ref->mPid, ref->mCnt); 1900 found = true; 1901 break; 1902 } 1903 } 1904 if (!found) { 1905 Mutex::Autolock _l (t->mLock); 1906 // remove all effects from the chain 1907 while (ec->mEffects.size()) { 1908 sp<EffectModule> effect = ec->mEffects[0]; 1909 effect->unPin(); 1910 t->removeEffect_l(effect); 1911 if (effect->purgeHandles()) { 1912 t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId()); 1913 } 1914 AudioSystem::unregisterEffect(effect->id()); 1915 } 1916 } 1917 } 1918 return; 1919} 1920 1921// checkPlaybackThread_l() must be called with AudioFlinger::mLock held 1922AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const 1923{ 1924 return mPlaybackThreads.valueFor(output).get(); 1925} 1926 1927// checkMixerThread_l() must be called with AudioFlinger::mLock held 1928AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const 1929{ 1930 PlaybackThread *thread = checkPlaybackThread_l(output); 1931 return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL; 1932} 1933 1934// checkRecordThread_l() must be called with AudioFlinger::mLock held 1935AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const 1936{ 1937 return mRecordThreads.valueFor(input).get(); 1938} 1939 1940uint32_t AudioFlinger::nextUniqueId() 1941{ 1942 return android_atomic_inc(&mNextUniqueId); 1943} 1944 1945AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const 1946{ 1947 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1948 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 1949 AudioStreamOut *output = thread->getOutput(); 1950 if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) { 1951 return thread; 1952 } 1953 } 1954 return NULL; 1955} 1956 1957audio_devices_t AudioFlinger::primaryOutputDevice_l() const 1958{ 1959 PlaybackThread *thread = primaryPlaybackThread_l(); 1960 1961 if (thread == NULL) { 1962 return 0; 1963 } 1964 1965 return thread->outDevice(); 1966} 1967 1968sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type, 1969 int triggerSession, 1970 int listenerSession, 1971 sync_event_callback_t callBack, 1972 void *cookie) 1973{ 1974 Mutex::Autolock _l(mLock); 1975 1976 sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie); 1977 status_t playStatus = NAME_NOT_FOUND; 1978 status_t recStatus = NAME_NOT_FOUND; 1979 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1980 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event); 1981 if (playStatus == NO_ERROR) { 1982 return event; 1983 } 1984 } 1985 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1986 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event); 1987 if (recStatus == NO_ERROR) { 1988 return event; 1989 } 1990 } 1991 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) { 1992 mPendingSyncEvents.add(event); 1993 } else { 1994 ALOGV("createSyncEvent() invalid event %d", event->type()); 1995 event.clear(); 1996 } 1997 return event; 1998} 1999 2000// ---------------------------------------------------------------------------- 2001// Effect management 2002// ---------------------------------------------------------------------------- 2003 2004 2005status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const 2006{ 2007 Mutex::Autolock _l(mLock); 2008 return EffectQueryNumberEffects(numEffects); 2009} 2010 2011status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const 2012{ 2013 Mutex::Autolock _l(mLock); 2014 return EffectQueryEffect(index, descriptor); 2015} 2016 2017status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid, 2018 effect_descriptor_t *descriptor) const 2019{ 2020 Mutex::Autolock _l(mLock); 2021 return EffectGetDescriptor(pUuid, descriptor); 2022} 2023 2024 2025sp<IEffect> AudioFlinger::createEffect( 2026 effect_descriptor_t *pDesc, 2027 const sp<IEffectClient>& effectClient, 2028 int32_t priority, 2029 audio_io_handle_t io, 2030 int sessionId, 2031 status_t *status, 2032 int *id, 2033 int *enabled) 2034{ 2035 status_t lStatus = NO_ERROR; 2036 sp<EffectHandle> handle; 2037 effect_descriptor_t desc; 2038 2039 pid_t pid = IPCThreadState::self()->getCallingPid(); 2040 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d", 2041 pid, effectClient.get(), priority, sessionId, io); 2042 2043 if (pDesc == NULL) { 2044 lStatus = BAD_VALUE; 2045 goto Exit; 2046 } 2047 2048 // check audio settings permission for global effects 2049 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) { 2050 lStatus = PERMISSION_DENIED; 2051 goto Exit; 2052 } 2053 2054 // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects 2055 // that can only be created by audio policy manager (running in same process) 2056 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid_cached != pid) { 2057 lStatus = PERMISSION_DENIED; 2058 goto Exit; 2059 } 2060 2061 if (io == 0) { 2062 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) { 2063 // output must be specified by AudioPolicyManager when using session 2064 // AUDIO_SESSION_OUTPUT_STAGE 2065 lStatus = BAD_VALUE; 2066 goto Exit; 2067 } else if (sessionId == AUDIO_SESSION_OUTPUT_MIX) { 2068 // if the output returned by getOutputForEffect() is removed before we lock the 2069 // mutex below, the call to checkPlaybackThread_l(io) below will detect it 2070 // and we will exit safely 2071 io = AudioSystem::getOutputForEffect(&desc); 2072 } 2073 } 2074 2075 { 2076 Mutex::Autolock _l(mLock); 2077 2078 2079 if (!EffectIsNullUuid(&pDesc->uuid)) { 2080 // if uuid is specified, request effect descriptor 2081 lStatus = EffectGetDescriptor(&pDesc->uuid, &desc); 2082 if (lStatus < 0) { 2083 ALOGW("createEffect() error %d from EffectGetDescriptor", lStatus); 2084 goto Exit; 2085 } 2086 } else { 2087 // if uuid is not specified, look for an available implementation 2088 // of the required type in effect factory 2089 if (EffectIsNullUuid(&pDesc->type)) { 2090 ALOGW("createEffect() no effect type"); 2091 lStatus = BAD_VALUE; 2092 goto Exit; 2093 } 2094 uint32_t numEffects = 0; 2095 effect_descriptor_t d; 2096 d.flags = 0; // prevent compiler warning 2097 bool found = false; 2098 2099 lStatus = EffectQueryNumberEffects(&numEffects); 2100 if (lStatus < 0) { 2101 ALOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus); 2102 goto Exit; 2103 } 2104 for (uint32_t i = 0; i < numEffects; i++) { 2105 lStatus = EffectQueryEffect(i, &desc); 2106 if (lStatus < 0) { 2107 ALOGW("createEffect() error %d from EffectQueryEffect", lStatus); 2108 continue; 2109 } 2110 if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) { 2111 // If matching type found save effect descriptor. If the session is 2112 // 0 and the effect is not auxiliary, continue enumeration in case 2113 // an auxiliary version of this effect type is available 2114 found = true; 2115 d = desc; 2116 if (sessionId != AUDIO_SESSION_OUTPUT_MIX || 2117 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 2118 break; 2119 } 2120 } 2121 } 2122 if (!found) { 2123 lStatus = BAD_VALUE; 2124 ALOGW("createEffect() effect not found"); 2125 goto Exit; 2126 } 2127 // For same effect type, chose auxiliary version over insert version if 2128 // connect to output mix (Compliance to OpenSL ES) 2129 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && 2130 (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) { 2131 desc = d; 2132 } 2133 } 2134 2135 // Do not allow auxiliary effects on a session different from 0 (output mix) 2136 if (sessionId != AUDIO_SESSION_OUTPUT_MIX && 2137 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 2138 lStatus = INVALID_OPERATION; 2139 goto Exit; 2140 } 2141 2142 // check recording permission for visualizer 2143 if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) && 2144 !recordingAllowed()) { 2145 lStatus = PERMISSION_DENIED; 2146 goto Exit; 2147 } 2148 2149 // return effect descriptor 2150 *pDesc = desc; 2151 2152 // If output is not specified try to find a matching audio session ID in one of the 2153 // output threads. 2154 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX 2155 // because of code checking output when entering the function. 2156 // Note: io is never 0 when creating an effect on an input 2157 if (io == 0) { 2158 // look for the thread where the specified audio session is present 2159 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2160 if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) { 2161 io = mPlaybackThreads.keyAt(i); 2162 break; 2163 } 2164 } 2165 if (io == 0) { 2166 for (size_t i = 0; i < mRecordThreads.size(); i++) { 2167 if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) { 2168 io = mRecordThreads.keyAt(i); 2169 break; 2170 } 2171 } 2172 } 2173 // If no output thread contains the requested session ID, default to 2174 // first output. The effect chain will be moved to the correct output 2175 // thread when a track with the same session ID is created 2176 if (io == 0 && mPlaybackThreads.size()) { 2177 io = mPlaybackThreads.keyAt(0); 2178 } 2179 ALOGV("createEffect() got io %d for effect %s", io, desc.name); 2180 } 2181 ThreadBase *thread = checkRecordThread_l(io); 2182 if (thread == NULL) { 2183 thread = checkPlaybackThread_l(io); 2184 if (thread == NULL) { 2185 ALOGE("createEffect() unknown output thread"); 2186 lStatus = BAD_VALUE; 2187 goto Exit; 2188 } 2189 } 2190 2191 sp<Client> client = registerPid_l(pid); 2192 2193 // create effect on selected output thread 2194 handle = thread->createEffect_l(client, effectClient, priority, sessionId, 2195 &desc, enabled, &lStatus); 2196 if (handle != 0 && id != NULL) { 2197 *id = handle->id(); 2198 } 2199 } 2200 2201Exit: 2202 if (status != NULL) { 2203 *status = lStatus; 2204 } 2205 return handle; 2206} 2207 2208status_t AudioFlinger::moveEffects(int sessionId, audio_io_handle_t srcOutput, 2209 audio_io_handle_t dstOutput) 2210{ 2211 ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d", 2212 sessionId, srcOutput, dstOutput); 2213 Mutex::Autolock _l(mLock); 2214 if (srcOutput == dstOutput) { 2215 ALOGW("moveEffects() same dst and src outputs %d", dstOutput); 2216 return NO_ERROR; 2217 } 2218 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput); 2219 if (srcThread == NULL) { 2220 ALOGW("moveEffects() bad srcOutput %d", srcOutput); 2221 return BAD_VALUE; 2222 } 2223 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput); 2224 if (dstThread == NULL) { 2225 ALOGW("moveEffects() bad dstOutput %d", dstOutput); 2226 return BAD_VALUE; 2227 } 2228 2229 Mutex::Autolock _dl(dstThread->mLock); 2230 Mutex::Autolock _sl(srcThread->mLock); 2231 moveEffectChain_l(sessionId, srcThread, dstThread, false); 2232 2233 return NO_ERROR; 2234} 2235 2236// moveEffectChain_l must be called with both srcThread and dstThread mLocks held 2237status_t AudioFlinger::moveEffectChain_l(int sessionId, 2238 AudioFlinger::PlaybackThread *srcThread, 2239 AudioFlinger::PlaybackThread *dstThread, 2240 bool reRegister) 2241{ 2242 ALOGV("moveEffectChain_l() session %d from thread %p to thread %p", 2243 sessionId, srcThread, dstThread); 2244 2245 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId); 2246 if (chain == 0) { 2247 ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p", 2248 sessionId, srcThread); 2249 return INVALID_OPERATION; 2250 } 2251 2252 // remove chain first. This is useful only if reconfiguring effect chain on same output thread, 2253 // so that a new chain is created with correct parameters when first effect is added. This is 2254 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is 2255 // removed. 2256 srcThread->removeEffectChain_l(chain); 2257 2258 // transfer all effects one by one so that new effect chain is created on new thread with 2259 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly 2260 audio_io_handle_t dstOutput = dstThread->id(); 2261 sp<EffectChain> dstChain; 2262 uint32_t strategy = 0; // prevent compiler warning 2263 sp<EffectModule> effect = chain->getEffectFromId_l(0); 2264 while (effect != 0) { 2265 srcThread->removeEffect_l(effect); 2266 dstThread->addEffect_l(effect); 2267 // removeEffect_l() has stopped the effect if it was active so it must be restarted 2268 if (effect->state() == EffectModule::ACTIVE || 2269 effect->state() == EffectModule::STOPPING) { 2270 effect->start(); 2271 } 2272 // if the move request is not received from audio policy manager, the effect must be 2273 // re-registered with the new strategy and output 2274 if (dstChain == 0) { 2275 dstChain = effect->chain().promote(); 2276 if (dstChain == 0) { 2277 ALOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get()); 2278 srcThread->addEffect_l(effect); 2279 return NO_INIT; 2280 } 2281 strategy = dstChain->strategy(); 2282 } 2283 if (reRegister) { 2284 AudioSystem::unregisterEffect(effect->id()); 2285 AudioSystem::registerEffect(&effect->desc(), 2286 dstOutput, 2287 strategy, 2288 sessionId, 2289 effect->id()); 2290 } 2291 effect = chain->getEffectFromId_l(0); 2292 } 2293 2294 return NO_ERROR; 2295} 2296 2297struct Entry { 2298#define MAX_NAME 32 // %Y%m%d%H%M%S_%d.wav 2299 char mName[MAX_NAME]; 2300}; 2301 2302int comparEntry(const void *p1, const void *p2) 2303{ 2304 return strcmp(((const Entry *) p1)->mName, ((const Entry *) p2)->mName); 2305} 2306 2307#ifdef TEE_SINK 2308void AudioFlinger::dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id) 2309{ 2310 NBAIO_Source *teeSource = source.get(); 2311 if (teeSource != NULL) { 2312 // .wav rotation 2313 // There is a benign race condition if 2 threads call this simultaneously. 2314 // They would both traverse the directory, but the result would simply be 2315 // failures at unlink() which are ignored. It's also unlikely since 2316 // normally dumpsys is only done by bugreport or from the command line. 2317 char teePath[32+256]; 2318 strcpy(teePath, "/data/misc/media"); 2319 size_t teePathLen = strlen(teePath); 2320 DIR *dir = opendir(teePath); 2321 teePath[teePathLen++] = '/'; 2322 if (dir != NULL) { 2323#define MAX_SORT 20 // number of entries to sort 2324#define MAX_KEEP 10 // number of entries to keep 2325 struct Entry entries[MAX_SORT]; 2326 size_t entryCount = 0; 2327 while (entryCount < MAX_SORT) { 2328 struct dirent de; 2329 struct dirent *result = NULL; 2330 int rc = readdir_r(dir, &de, &result); 2331 if (rc != 0) { 2332 ALOGW("readdir_r failed %d", rc); 2333 break; 2334 } 2335 if (result == NULL) { 2336 break; 2337 } 2338 if (result != &de) { 2339 ALOGW("readdir_r returned unexpected result %p != %p", result, &de); 2340 break; 2341 } 2342 // ignore non .wav file entries 2343 size_t nameLen = strlen(de.d_name); 2344 if (nameLen <= 4 || nameLen >= MAX_NAME || 2345 strcmp(&de.d_name[nameLen - 4], ".wav")) { 2346 continue; 2347 } 2348 strcpy(entries[entryCount++].mName, de.d_name); 2349 } 2350 (void) closedir(dir); 2351 if (entryCount > MAX_KEEP) { 2352 qsort(entries, entryCount, sizeof(Entry), comparEntry); 2353 for (size_t i = 0; i < entryCount - MAX_KEEP; ++i) { 2354 strcpy(&teePath[teePathLen], entries[i].mName); 2355 (void) unlink(teePath); 2356 } 2357 } 2358 } else { 2359 if (fd >= 0) { 2360 fdprintf(fd, "unable to rotate tees in %s: %s\n", teePath, strerror(errno)); 2361 } 2362 } 2363 char teeTime[16]; 2364 struct timeval tv; 2365 gettimeofday(&tv, NULL); 2366 struct tm tm; 2367 localtime_r(&tv.tv_sec, &tm); 2368 strftime(teeTime, sizeof(teeTime), "%Y%m%d%H%M%S", &tm); 2369 snprintf(&teePath[teePathLen], sizeof(teePath) - teePathLen, "%s_%d.wav", teeTime, id); 2370 // if 2 dumpsys are done within 1 second, and rotation didn't work, then discard 2nd 2371 int teeFd = open(teePath, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, S_IRUSR | S_IWUSR); 2372 if (teeFd >= 0) { 2373 char wavHeader[44]; 2374 memcpy(wavHeader, 2375 "RIFF\0\0\0\0WAVEfmt \20\0\0\0\1\0\2\0\104\254\0\0\0\0\0\0\4\0\20\0data\0\0\0\0", 2376 sizeof(wavHeader)); 2377 NBAIO_Format format = teeSource->format(); 2378 unsigned channelCount = Format_channelCount(format); 2379 ALOG_ASSERT(channelCount <= FCC_2); 2380 uint32_t sampleRate = Format_sampleRate(format); 2381 wavHeader[22] = channelCount; // number of channels 2382 wavHeader[24] = sampleRate; // sample rate 2383 wavHeader[25] = sampleRate >> 8; 2384 wavHeader[32] = channelCount * 2; // block alignment 2385 write(teeFd, wavHeader, sizeof(wavHeader)); 2386 size_t total = 0; 2387 bool firstRead = true; 2388 for (;;) { 2389#define TEE_SINK_READ 1024 2390 short buffer[TEE_SINK_READ * FCC_2]; 2391 size_t count = TEE_SINK_READ; 2392 ssize_t actual = teeSource->read(buffer, count, 2393 AudioBufferProvider::kInvalidPTS); 2394 bool wasFirstRead = firstRead; 2395 firstRead = false; 2396 if (actual <= 0) { 2397 if (actual == (ssize_t) OVERRUN && wasFirstRead) { 2398 continue; 2399 } 2400 break; 2401 } 2402 ALOG_ASSERT(actual <= (ssize_t)count); 2403 write(teeFd, buffer, actual * channelCount * sizeof(short)); 2404 total += actual; 2405 } 2406 lseek(teeFd, (off_t) 4, SEEK_SET); 2407 uint32_t temp = 44 + total * channelCount * sizeof(short) - 8; 2408 write(teeFd, &temp, sizeof(temp)); 2409 lseek(teeFd, (off_t) 40, SEEK_SET); 2410 temp = total * channelCount * sizeof(short); 2411 write(teeFd, &temp, sizeof(temp)); 2412 close(teeFd); 2413 if (fd >= 0) { 2414 fdprintf(fd, "tee copied to %s\n", teePath); 2415 } 2416 } else { 2417 if (fd >= 0) { 2418 fdprintf(fd, "unable to create tee %s: %s\n", teePath, strerror(errno)); 2419 } 2420 } 2421 } 2422} 2423#endif 2424 2425// ---------------------------------------------------------------------------- 2426 2427status_t AudioFlinger::onTransact( 2428 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 2429{ 2430 return BnAudioFlinger::onTransact(code, data, reply, flags); 2431} 2432 2433}; // namespace android 2434