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