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 <memunreachable/memunreachable.h> 35 #include <utils/String16.h> 36 #include <utils/threads.h> 37 #include <utils/Atomic.h> 38 39 #include <cutils/bitops.h> 40 #include <cutils/properties.h> 41 42 #include <system/audio.h> 43 #include <hardware/audio.h> 44 45 #include "AudioMixer.h" 46 #include "AudioFlinger.h" 47 #include "ServiceUtilities.h" 48 49 #include <media/AudioResamplerPublic.h> 50 51 #include <media/EffectsFactoryApi.h> 52 #include <audio_effects/effect_visualizer.h> 53 #include <audio_effects/effect_ns.h> 54 #include <audio_effects/effect_aec.h> 55 56 #include <audio_utils/primitives.h> 57 58 #include <powermanager/PowerManager.h> 59 60 #include <media/IMediaLogService.h> 61 #include <media/MemoryLeakTrackUtil.h> 62 #include <media/nbaio/Pipe.h> 63 #include <media/nbaio/PipeReader.h> 64 #include <media/AudioParameter.h> 65 #include <mediautils/BatteryNotifier.h> 66 #include <private/android_filesystem_config.h> 67 68 // ---------------------------------------------------------------------------- 69 70 // Note: the following macro is used for extremely verbose logging message. In 71 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to 72 // 0; but one side effect of this is to turn all LOGV's as well. Some messages 73 // are so verbose that we want to suppress them even when we have ALOG_ASSERT 74 // turned on. Do not uncomment the #def below unless you really know what you 75 // are doing and want to see all of the extremely verbose messages. 76 //#define VERY_VERY_VERBOSE_LOGGING 77 #ifdef VERY_VERY_VERBOSE_LOGGING 78 #define ALOGVV ALOGV 79 #else 80 #define ALOGVV(a...) do { } while(0) 81 #endif 82 83 namespace android { 84 85 static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n"; 86 static const char kHardwareLockedString[] = "Hardware lock is taken\n"; 87 static const char kClientLockedString[] = "Client lock is taken\n"; 88 89 90 nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs; 91 92 uint32_t AudioFlinger::mScreenState; 93 94 #ifdef TEE_SINK 95 bool AudioFlinger::mTeeSinkInputEnabled = false; 96 bool AudioFlinger::mTeeSinkOutputEnabled = false; 97 bool AudioFlinger::mTeeSinkTrackEnabled = false; 98 99 size_t AudioFlinger::mTeeSinkInputFrames = kTeeSinkInputFramesDefault; 100 size_t AudioFlinger::mTeeSinkOutputFrames = kTeeSinkOutputFramesDefault; 101 size_t AudioFlinger::mTeeSinkTrackFrames = kTeeSinkTrackFramesDefault; 102 #endif 103 104 // In order to avoid invalidating offloaded tracks each time a Visualizer is turned on and off 105 // we define a minimum time during which a global effect is considered enabled. 106 static const nsecs_t kMinGlobalEffectEnabletimeNs = seconds(7200); 107 108 // ---------------------------------------------------------------------------- 109 110 const char *formatToString(audio_format_t format) { 111 switch (audio_get_main_format(format)) { 112 case AUDIO_FORMAT_PCM: 113 switch (format) { 114 case AUDIO_FORMAT_PCM_16_BIT: return "pcm16"; 115 case AUDIO_FORMAT_PCM_8_BIT: return "pcm8"; 116 case AUDIO_FORMAT_PCM_32_BIT: return "pcm32"; 117 case AUDIO_FORMAT_PCM_8_24_BIT: return "pcm8.24"; 118 case AUDIO_FORMAT_PCM_FLOAT: return "pcmfloat"; 119 case AUDIO_FORMAT_PCM_24_BIT_PACKED: return "pcm24"; 120 default: 121 break; 122 } 123 break; 124 case AUDIO_FORMAT_MP3: return "mp3"; 125 case AUDIO_FORMAT_AMR_NB: return "amr-nb"; 126 case AUDIO_FORMAT_AMR_WB: return "amr-wb"; 127 case AUDIO_FORMAT_AAC: return "aac"; 128 case AUDIO_FORMAT_HE_AAC_V1: return "he-aac-v1"; 129 case AUDIO_FORMAT_HE_AAC_V2: return "he-aac-v2"; 130 case AUDIO_FORMAT_VORBIS: return "vorbis"; 131 case AUDIO_FORMAT_OPUS: return "opus"; 132 case AUDIO_FORMAT_AC3: return "ac-3"; 133 case AUDIO_FORMAT_E_AC3: return "e-ac-3"; 134 case AUDIO_FORMAT_IEC61937: return "iec61937"; 135 case AUDIO_FORMAT_DTS: return "dts"; 136 case AUDIO_FORMAT_DTS_HD: return "dts-hd"; 137 case AUDIO_FORMAT_DOLBY_TRUEHD: return "dolby-truehd"; 138 default: 139 break; 140 } 141 return "unknown"; 142 } 143 144 static int load_audio_interface(const char *if_name, audio_hw_device_t **dev) 145 { 146 const hw_module_t *mod; 147 int rc; 148 149 rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod); 150 ALOGE_IF(rc, "%s couldn't load audio hw module %s.%s (%s)", __func__, 151 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc)); 152 if (rc) { 153 goto out; 154 } 155 rc = audio_hw_device_open(mod, dev); 156 ALOGE_IF(rc, "%s couldn't open audio hw device in %s.%s (%s)", __func__, 157 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc)); 158 if (rc) { 159 goto out; 160 } 161 if ((*dev)->common.version < AUDIO_DEVICE_API_VERSION_MIN) { 162 ALOGE("%s wrong audio hw device version %04x", __func__, (*dev)->common.version); 163 rc = BAD_VALUE; 164 goto out; 165 } 166 return 0; 167 168 out: 169 *dev = NULL; 170 return rc; 171 } 172 173 // ---------------------------------------------------------------------------- 174 175 AudioFlinger::AudioFlinger() 176 : BnAudioFlinger(), 177 mPrimaryHardwareDev(NULL), 178 mAudioHwDevs(NULL), 179 mHardwareStatus(AUDIO_HW_IDLE), 180 mMasterVolume(1.0f), 181 mMasterMute(false), 182 // mNextUniqueId(AUDIO_UNIQUE_ID_USE_MAX), 183 mMode(AUDIO_MODE_INVALID), 184 mBtNrecIsOff(false), 185 mIsLowRamDevice(true), 186 mIsDeviceTypeKnown(false), 187 mGlobalEffectEnableTime(0), 188 mSystemReady(false) 189 { 190 // unsigned instead of audio_unique_id_use_t, because ++ operator is unavailable for enum 191 for (unsigned use = AUDIO_UNIQUE_ID_USE_UNSPECIFIED; use < AUDIO_UNIQUE_ID_USE_MAX; use++) { 192 // zero ID has a special meaning, so unavailable 193 mNextUniqueIds[use] = AUDIO_UNIQUE_ID_USE_MAX; 194 } 195 196 getpid_cached = getpid(); 197 const bool doLog = property_get_bool("ro.test_harness", false); 198 if (doLog) { 199 mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters", 200 MemoryHeapBase::READ_ONLY); 201 } 202 203 // reset battery stats. 204 // if the audio service has crashed, battery stats could be left 205 // in bad state, reset the state upon service start. 206 BatteryNotifier::getInstance().noteResetAudio(); 207 208 #ifdef TEE_SINK 209 char value[PROPERTY_VALUE_MAX]; 210 (void) property_get("ro.debuggable", value, "0"); 211 int debuggable = atoi(value); 212 int teeEnabled = 0; 213 if (debuggable) { 214 (void) property_get("af.tee", value, "0"); 215 teeEnabled = atoi(value); 216 } 217 // FIXME symbolic constants here 218 if (teeEnabled & 1) { 219 mTeeSinkInputEnabled = true; 220 } 221 if (teeEnabled & 2) { 222 mTeeSinkOutputEnabled = true; 223 } 224 if (teeEnabled & 4) { 225 mTeeSinkTrackEnabled = true; 226 } 227 #endif 228 } 229 230 void AudioFlinger::onFirstRef() 231 { 232 Mutex::Autolock _l(mLock); 233 234 /* TODO: move all this work into an Init() function */ 235 char val_str[PROPERTY_VALUE_MAX] = { 0 }; 236 if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) { 237 uint32_t int_val; 238 if (1 == sscanf(val_str, "%u", &int_val)) { 239 mStandbyTimeInNsecs = milliseconds(int_val); 240 ALOGI("Using %u mSec as standby time.", int_val); 241 } else { 242 mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs; 243 ALOGI("Using default %u mSec as standby time.", 244 (uint32_t)(mStandbyTimeInNsecs / 1000000)); 245 } 246 } 247 248 mPatchPanel = new PatchPanel(this); 249 250 mMode = AUDIO_MODE_NORMAL; 251 } 252 253 AudioFlinger::~AudioFlinger() 254 { 255 while (!mRecordThreads.isEmpty()) { 256 // closeInput_nonvirtual() will remove specified entry from mRecordThreads 257 closeInput_nonvirtual(mRecordThreads.keyAt(0)); 258 } 259 while (!mPlaybackThreads.isEmpty()) { 260 // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads 261 closeOutput_nonvirtual(mPlaybackThreads.keyAt(0)); 262 } 263 264 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 265 // no mHardwareLock needed, as there are no other references to this 266 audio_hw_device_close(mAudioHwDevs.valueAt(i)->hwDevice()); 267 delete mAudioHwDevs.valueAt(i); 268 } 269 270 // Tell media.log service about any old writers that still need to be unregistered 271 if (mLogMemoryDealer != 0) { 272 sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log")); 273 if (binder != 0) { 274 sp<IMediaLogService> mediaLogService(interface_cast<IMediaLogService>(binder)); 275 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) { 276 sp<IMemory> iMemory(mUnregisteredWriters.top()->getIMemory()); 277 mUnregisteredWriters.pop(); 278 mediaLogService->unregisterWriter(iMemory); 279 } 280 } 281 } 282 } 283 284 static const char * const audio_interfaces[] = { 285 AUDIO_HARDWARE_MODULE_ID_PRIMARY, 286 AUDIO_HARDWARE_MODULE_ID_A2DP, 287 AUDIO_HARDWARE_MODULE_ID_USB, 288 }; 289 #define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0]))) 290 291 AudioHwDevice* AudioFlinger::findSuitableHwDev_l( 292 audio_module_handle_t module, 293 audio_devices_t devices) 294 { 295 // if module is 0, the request comes from an old policy manager and we should load 296 // well known modules 297 if (module == 0) { 298 ALOGW("findSuitableHwDev_l() loading well know audio hw modules"); 299 for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) { 300 loadHwModule_l(audio_interfaces[i]); 301 } 302 // then try to find a module supporting the requested device. 303 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 304 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i); 305 audio_hw_device_t *dev = audioHwDevice->hwDevice(); 306 if ((dev->get_supported_devices != NULL) && 307 (dev->get_supported_devices(dev) & devices) == devices) 308 return audioHwDevice; 309 } 310 } else { 311 // check a match for the requested module handle 312 AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module); 313 if (audioHwDevice != NULL) { 314 return audioHwDevice; 315 } 316 } 317 318 return NULL; 319 } 320 321 void AudioFlinger::dumpClients(int fd, const Vector<String16>& args __unused) 322 { 323 const size_t SIZE = 256; 324 char buffer[SIZE]; 325 String8 result; 326 327 result.append("Clients:\n"); 328 for (size_t i = 0; i < mClients.size(); ++i) { 329 sp<Client> client = mClients.valueAt(i).promote(); 330 if (client != 0) { 331 snprintf(buffer, SIZE, " pid: %d\n", client->pid()); 332 result.append(buffer); 333 } 334 } 335 336 result.append("Notification Clients:\n"); 337 for (size_t i = 0; i < mNotificationClients.size(); ++i) { 338 snprintf(buffer, SIZE, " pid: %d\n", mNotificationClients.keyAt(i)); 339 result.append(buffer); 340 } 341 342 result.append("Global session refs:\n"); 343 result.append(" session pid count\n"); 344 for (size_t i = 0; i < mAudioSessionRefs.size(); i++) { 345 AudioSessionRef *r = mAudioSessionRefs[i]; 346 snprintf(buffer, SIZE, " %7d %5d %5d\n", r->mSessionid, r->mPid, r->mCnt); 347 result.append(buffer); 348 } 349 write(fd, result.string(), result.size()); 350 } 351 352 353 void AudioFlinger::dumpInternals(int fd, const Vector<String16>& args __unused) 354 { 355 const size_t SIZE = 256; 356 char buffer[SIZE]; 357 String8 result; 358 hardware_call_state hardwareStatus = mHardwareStatus; 359 360 snprintf(buffer, SIZE, "Hardware status: %d\n" 361 "Standby Time mSec: %u\n", 362 hardwareStatus, 363 (uint32_t)(mStandbyTimeInNsecs / 1000000)); 364 result.append(buffer); 365 write(fd, result.string(), result.size()); 366 } 367 368 void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args __unused) 369 { 370 const size_t SIZE = 256; 371 char buffer[SIZE]; 372 String8 result; 373 snprintf(buffer, SIZE, "Permission Denial: " 374 "can't dump AudioFlinger from pid=%d, uid=%d\n", 375 IPCThreadState::self()->getCallingPid(), 376 IPCThreadState::self()->getCallingUid()); 377 result.append(buffer); 378 write(fd, result.string(), result.size()); 379 } 380 381 bool AudioFlinger::dumpTryLock(Mutex& mutex) 382 { 383 bool locked = false; 384 for (int i = 0; i < kDumpLockRetries; ++i) { 385 if (mutex.tryLock() == NO_ERROR) { 386 locked = true; 387 break; 388 } 389 usleep(kDumpLockSleepUs); 390 } 391 return locked; 392 } 393 394 status_t AudioFlinger::dump(int fd, const Vector<String16>& args) 395 { 396 if (!dumpAllowed()) { 397 dumpPermissionDenial(fd, args); 398 } else { 399 // get state of hardware lock 400 bool hardwareLocked = dumpTryLock(mHardwareLock); 401 if (!hardwareLocked) { 402 String8 result(kHardwareLockedString); 403 write(fd, result.string(), result.size()); 404 } else { 405 mHardwareLock.unlock(); 406 } 407 408 bool locked = dumpTryLock(mLock); 409 410 // failed to lock - AudioFlinger is probably deadlocked 411 if (!locked) { 412 String8 result(kDeadlockedString); 413 write(fd, result.string(), result.size()); 414 } 415 416 bool clientLocked = dumpTryLock(mClientLock); 417 if (!clientLocked) { 418 String8 result(kClientLockedString); 419 write(fd, result.string(), result.size()); 420 } 421 422 EffectDumpEffects(fd); 423 424 dumpClients(fd, args); 425 if (clientLocked) { 426 mClientLock.unlock(); 427 } 428 429 dumpInternals(fd, args); 430 431 // dump playback threads 432 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 433 mPlaybackThreads.valueAt(i)->dump(fd, args); 434 } 435 436 // dump record threads 437 for (size_t i = 0; i < mRecordThreads.size(); i++) { 438 mRecordThreads.valueAt(i)->dump(fd, args); 439 } 440 441 // dump orphan effect chains 442 if (mOrphanEffectChains.size() != 0) { 443 write(fd, " Orphan Effect Chains\n", strlen(" Orphan Effect Chains\n")); 444 for (size_t i = 0; i < mOrphanEffectChains.size(); i++) { 445 mOrphanEffectChains.valueAt(i)->dump(fd, args); 446 } 447 } 448 // dump all hardware devs 449 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 450 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 451 dev->dump(dev, fd); 452 } 453 454 #ifdef TEE_SINK 455 // dump the serially shared record tee sink 456 if (mRecordTeeSource != 0) { 457 dumpTee(fd, mRecordTeeSource); 458 } 459 #endif 460 461 if (locked) { 462 mLock.unlock(); 463 } 464 465 // append a copy of media.log here by forwarding fd to it, but don't attempt 466 // to lookup the service if it's not running, as it will block for a second 467 if (mLogMemoryDealer != 0) { 468 sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log")); 469 if (binder != 0) { 470 dprintf(fd, "\nmedia.log:\n"); 471 Vector<String16> args; 472 binder->dump(fd, args); 473 } 474 } 475 476 // check for optional arguments 477 bool dumpMem = false; 478 bool unreachableMemory = false; 479 for (const auto &arg : args) { 480 if (arg == String16("-m")) { 481 dumpMem = true; 482 } else if (arg == String16("--unreachable")) { 483 unreachableMemory = true; 484 } 485 } 486 487 if (dumpMem) { 488 dprintf(fd, "\nDumping memory:\n"); 489 std::string s = dumpMemoryAddresses(100 /* limit */); 490 write(fd, s.c_str(), s.size()); 491 } 492 if (unreachableMemory) { 493 dprintf(fd, "\nDumping unreachable memory:\n"); 494 // TODO - should limit be an argument parameter? 495 std::string s = GetUnreachableMemoryString(true /* contents */, 100 /* limit */); 496 write(fd, s.c_str(), s.size()); 497 } 498 } 499 return NO_ERROR; 500 } 501 502 sp<AudioFlinger::Client> AudioFlinger::registerPid(pid_t pid) 503 { 504 Mutex::Autolock _cl(mClientLock); 505 // If pid is already in the mClients wp<> map, then use that entry 506 // (for which promote() is always != 0), otherwise create a new entry and Client. 507 sp<Client> client = mClients.valueFor(pid).promote(); 508 if (client == 0) { 509 client = new Client(this, pid); 510 mClients.add(pid, client); 511 } 512 513 return client; 514 } 515 516 sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name) 517 { 518 // If there is no memory allocated for logs, return a dummy writer that does nothing 519 if (mLogMemoryDealer == 0) { 520 return new NBLog::Writer(); 521 } 522 sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log")); 523 // Similarly if we can't contact the media.log service, also return a dummy writer 524 if (binder == 0) { 525 return new NBLog::Writer(); 526 } 527 sp<IMediaLogService> mediaLogService(interface_cast<IMediaLogService>(binder)); 528 sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size)); 529 // If allocation fails, consult the vector of previously unregistered writers 530 // and garbage-collect one or more them until an allocation succeeds 531 if (shared == 0) { 532 Mutex::Autolock _l(mUnregisteredWritersLock); 533 for (size_t count = mUnregisteredWriters.size(); count > 0; count--) { 534 { 535 // Pick the oldest stale writer to garbage-collect 536 sp<IMemory> iMemory(mUnregisteredWriters[0]->getIMemory()); 537 mUnregisteredWriters.removeAt(0); 538 mediaLogService->unregisterWriter(iMemory); 539 // Now the media.log remote reference to IMemory is gone. When our last local 540 // reference to IMemory also drops to zero at end of this block, 541 // the IMemory destructor will deallocate the region from mLogMemoryDealer. 542 } 543 // Re-attempt the allocation 544 shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size)); 545 if (shared != 0) { 546 goto success; 547 } 548 } 549 // Even after garbage-collecting all old writers, there is still not enough memory, 550 // so return a dummy writer 551 return new NBLog::Writer(); 552 } 553 success: 554 mediaLogService->registerWriter(shared, size, name); 555 return new NBLog::Writer(size, shared); 556 } 557 558 void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer) 559 { 560 if (writer == 0) { 561 return; 562 } 563 sp<IMemory> iMemory(writer->getIMemory()); 564 if (iMemory == 0) { 565 return; 566 } 567 // Rather than removing the writer immediately, append it to a queue of old writers to 568 // be garbage-collected later. This allows us to continue to view old logs for a while. 569 Mutex::Autolock _l(mUnregisteredWritersLock); 570 mUnregisteredWriters.push(writer); 571 } 572 573 // IAudioFlinger interface 574 575 576 sp<IAudioTrack> AudioFlinger::createTrack( 577 audio_stream_type_t streamType, 578 uint32_t sampleRate, 579 audio_format_t format, 580 audio_channel_mask_t channelMask, 581 size_t *frameCount, 582 audio_output_flags_t *flags, 583 const sp<IMemory>& sharedBuffer, 584 audio_io_handle_t output, 585 pid_t pid, 586 pid_t tid, 587 audio_session_t *sessionId, 588 int clientUid, 589 status_t *status) 590 { 591 sp<PlaybackThread::Track> track; 592 sp<TrackHandle> trackHandle; 593 sp<Client> client; 594 status_t lStatus; 595 audio_session_t lSessionId; 596 597 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 598 if (pid == -1 || !isTrustedCallingUid(callingUid)) { 599 const pid_t callingPid = IPCThreadState::self()->getCallingPid(); 600 ALOGW_IF(pid != -1 && pid != callingPid, 601 "%s uid %d pid %d tried to pass itself off as pid %d", 602 __func__, callingUid, callingPid, pid); 603 pid = callingPid; 604 } 605 606 // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC, 607 // but if someone uses binder directly they could bypass that and cause us to crash 608 if (uint32_t(streamType) >= AUDIO_STREAM_CNT) { 609 ALOGE("createTrack() invalid stream type %d", streamType); 610 lStatus = BAD_VALUE; 611 goto Exit; 612 } 613 614 // further sample rate checks are performed by createTrack_l() depending on the thread type 615 if (sampleRate == 0) { 616 ALOGE("createTrack() invalid sample rate %u", sampleRate); 617 lStatus = BAD_VALUE; 618 goto Exit; 619 } 620 621 // further channel mask checks are performed by createTrack_l() depending on the thread type 622 if (!audio_is_output_channel(channelMask)) { 623 ALOGE("createTrack() invalid channel mask %#x", channelMask); 624 lStatus = BAD_VALUE; 625 goto Exit; 626 } 627 628 // further format checks are performed by createTrack_l() depending on the thread type 629 if (!audio_is_valid_format(format)) { 630 ALOGE("createTrack() invalid format %#x", format); 631 lStatus = BAD_VALUE; 632 goto Exit; 633 } 634 635 if (sharedBuffer != 0 && sharedBuffer->pointer() == NULL) { 636 ALOGE("createTrack() sharedBuffer is non-0 but has NULL pointer()"); 637 lStatus = BAD_VALUE; 638 goto Exit; 639 } 640 641 { 642 Mutex::Autolock _l(mLock); 643 PlaybackThread *thread = checkPlaybackThread_l(output); 644 if (thread == NULL) { 645 ALOGE("no playback thread found for output handle %d", output); 646 lStatus = BAD_VALUE; 647 goto Exit; 648 } 649 650 client = registerPid(pid); 651 652 PlaybackThread *effectThread = NULL; 653 if (sessionId != NULL && *sessionId != AUDIO_SESSION_ALLOCATE) { 654 if (audio_unique_id_get_use(*sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) { 655 ALOGE("createTrack() invalid session ID %d", *sessionId); 656 lStatus = BAD_VALUE; 657 goto Exit; 658 } 659 lSessionId = *sessionId; 660 // check if an effect chain with the same session ID is present on another 661 // output thread and move it here. 662 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 663 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 664 if (mPlaybackThreads.keyAt(i) != output) { 665 uint32_t sessions = t->hasAudioSession(lSessionId); 666 if (sessions & ThreadBase::EFFECT_SESSION) { 667 effectThread = t.get(); 668 break; 669 } 670 } 671 } 672 } else { 673 // if no audio session id is provided, create one here 674 lSessionId = (audio_session_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_SESSION); 675 if (sessionId != NULL) { 676 *sessionId = lSessionId; 677 } 678 } 679 ALOGV("createTrack() lSessionId: %d", lSessionId); 680 681 track = thread->createTrack_l(client, streamType, sampleRate, format, 682 channelMask, frameCount, sharedBuffer, lSessionId, flags, tid, clientUid, &lStatus); 683 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0)); 684 // we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless 685 686 // move effect chain to this output thread if an effect on same session was waiting 687 // for a track to be created 688 if (lStatus == NO_ERROR && effectThread != NULL) { 689 // no risk of deadlock because AudioFlinger::mLock is held 690 Mutex::Autolock _dl(thread->mLock); 691 Mutex::Autolock _sl(effectThread->mLock); 692 moveEffectChain_l(lSessionId, effectThread, thread, true); 693 } 694 695 // Look for sync events awaiting for a session to be used. 696 for (size_t i = 0; i < mPendingSyncEvents.size(); i++) { 697 if (mPendingSyncEvents[i]->triggerSession() == lSessionId) { 698 if (thread->isValidSyncEvent(mPendingSyncEvents[i])) { 699 if (lStatus == NO_ERROR) { 700 (void) track->setSyncEvent(mPendingSyncEvents[i]); 701 } else { 702 mPendingSyncEvents[i]->cancel(); 703 } 704 mPendingSyncEvents.removeAt(i); 705 i--; 706 } 707 } 708 } 709 710 setAudioHwSyncForSession_l(thread, lSessionId); 711 } 712 713 if (lStatus != NO_ERROR) { 714 // remove local strong reference to Client before deleting the Track so that the 715 // Client destructor is called by the TrackBase destructor with mClientLock held 716 // Don't hold mClientLock when releasing the reference on the track as the 717 // destructor will acquire it. 718 { 719 Mutex::Autolock _cl(mClientLock); 720 client.clear(); 721 } 722 track.clear(); 723 goto Exit; 724 } 725 726 // return handle to client 727 trackHandle = new TrackHandle(track); 728 729 Exit: 730 *status = lStatus; 731 return trackHandle; 732 } 733 734 uint32_t AudioFlinger::sampleRate(audio_io_handle_t ioHandle) const 735 { 736 Mutex::Autolock _l(mLock); 737 ThreadBase *thread = checkThread_l(ioHandle); 738 if (thread == NULL) { 739 ALOGW("sampleRate() unknown thread %d", ioHandle); 740 return 0; 741 } 742 return thread->sampleRate(); 743 } 744 745 audio_format_t AudioFlinger::format(audio_io_handle_t output) const 746 { 747 Mutex::Autolock _l(mLock); 748 PlaybackThread *thread = checkPlaybackThread_l(output); 749 if (thread == NULL) { 750 ALOGW("format() unknown thread %d", output); 751 return AUDIO_FORMAT_INVALID; 752 } 753 return thread->format(); 754 } 755 756 size_t AudioFlinger::frameCount(audio_io_handle_t ioHandle) const 757 { 758 Mutex::Autolock _l(mLock); 759 ThreadBase *thread = checkThread_l(ioHandle); 760 if (thread == NULL) { 761 ALOGW("frameCount() unknown thread %d", ioHandle); 762 return 0; 763 } 764 // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers; 765 // should examine all callers and fix them to handle smaller counts 766 return thread->frameCount(); 767 } 768 769 size_t AudioFlinger::frameCountHAL(audio_io_handle_t ioHandle) const 770 { 771 Mutex::Autolock _l(mLock); 772 ThreadBase *thread = checkThread_l(ioHandle); 773 if (thread == NULL) { 774 ALOGW("frameCountHAL() unknown thread %d", ioHandle); 775 return 0; 776 } 777 return thread->frameCountHAL(); 778 } 779 780 uint32_t AudioFlinger::latency(audio_io_handle_t output) const 781 { 782 Mutex::Autolock _l(mLock); 783 PlaybackThread *thread = checkPlaybackThread_l(output); 784 if (thread == NULL) { 785 ALOGW("latency(): no playback thread found for output handle %d", output); 786 return 0; 787 } 788 return thread->latency(); 789 } 790 791 status_t AudioFlinger::setMasterVolume(float value) 792 { 793 status_t ret = initCheck(); 794 if (ret != NO_ERROR) { 795 return ret; 796 } 797 798 // check calling permissions 799 if (!settingsAllowed()) { 800 return PERMISSION_DENIED; 801 } 802 803 Mutex::Autolock _l(mLock); 804 mMasterVolume = value; 805 806 // Set master volume in the HALs which support it. 807 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 808 AutoMutex lock(mHardwareLock); 809 AudioHwDevice *dev = mAudioHwDevs.valueAt(i); 810 811 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 812 if (dev->canSetMasterVolume()) { 813 dev->hwDevice()->set_master_volume(dev->hwDevice(), value); 814 } 815 mHardwareStatus = AUDIO_HW_IDLE; 816 } 817 818 // Now set the master volume in each playback thread. Playback threads 819 // assigned to HALs which do not have master volume support will apply 820 // master volume during the mix operation. Threads with HALs which do 821 // support master volume will simply ignore the setting. 822 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 823 if (mPlaybackThreads.valueAt(i)->isDuplicating()) { 824 continue; 825 } 826 mPlaybackThreads.valueAt(i)->setMasterVolume(value); 827 } 828 829 return NO_ERROR; 830 } 831 832 status_t AudioFlinger::setMode(audio_mode_t mode) 833 { 834 status_t ret = initCheck(); 835 if (ret != NO_ERROR) { 836 return ret; 837 } 838 839 // check calling permissions 840 if (!settingsAllowed()) { 841 return PERMISSION_DENIED; 842 } 843 if (uint32_t(mode) >= AUDIO_MODE_CNT) { 844 ALOGW("Illegal value: setMode(%d)", mode); 845 return BAD_VALUE; 846 } 847 848 { // scope for the lock 849 AutoMutex lock(mHardwareLock); 850 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 851 mHardwareStatus = AUDIO_HW_SET_MODE; 852 ret = dev->set_mode(dev, mode); 853 mHardwareStatus = AUDIO_HW_IDLE; 854 } 855 856 if (NO_ERROR == ret) { 857 Mutex::Autolock _l(mLock); 858 mMode = mode; 859 for (size_t i = 0; i < mPlaybackThreads.size(); i++) 860 mPlaybackThreads.valueAt(i)->setMode(mode); 861 } 862 863 return ret; 864 } 865 866 status_t AudioFlinger::setMicMute(bool state) 867 { 868 status_t ret = initCheck(); 869 if (ret != NO_ERROR) { 870 return ret; 871 } 872 873 // check calling permissions 874 if (!settingsAllowed()) { 875 return PERMISSION_DENIED; 876 } 877 878 AutoMutex lock(mHardwareLock); 879 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE; 880 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 881 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 882 status_t result = dev->set_mic_mute(dev, state); 883 if (result != NO_ERROR) { 884 ret = result; 885 } 886 } 887 mHardwareStatus = AUDIO_HW_IDLE; 888 return ret; 889 } 890 891 bool AudioFlinger::getMicMute() const 892 { 893 status_t ret = initCheck(); 894 if (ret != NO_ERROR) { 895 return false; 896 } 897 bool mute = true; 898 bool state = AUDIO_MODE_INVALID; 899 AutoMutex lock(mHardwareLock); 900 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE; 901 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 902 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 903 status_t result = dev->get_mic_mute(dev, &state); 904 if (result == NO_ERROR) { 905 mute = mute && state; 906 } 907 } 908 mHardwareStatus = AUDIO_HW_IDLE; 909 910 return mute; 911 } 912 913 status_t AudioFlinger::setMasterMute(bool muted) 914 { 915 status_t ret = initCheck(); 916 if (ret != NO_ERROR) { 917 return ret; 918 } 919 920 // check calling permissions 921 if (!settingsAllowed()) { 922 return PERMISSION_DENIED; 923 } 924 925 Mutex::Autolock _l(mLock); 926 mMasterMute = muted; 927 928 // Set master mute in the HALs which support it. 929 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 930 AutoMutex lock(mHardwareLock); 931 AudioHwDevice *dev = mAudioHwDevs.valueAt(i); 932 933 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE; 934 if (dev->canSetMasterMute()) { 935 dev->hwDevice()->set_master_mute(dev->hwDevice(), muted); 936 } 937 mHardwareStatus = AUDIO_HW_IDLE; 938 } 939 940 // Now set the master mute in each playback thread. Playback threads 941 // assigned to HALs which do not have master mute support will apply master 942 // mute during the mix operation. Threads with HALs which do support master 943 // mute will simply ignore the setting. 944 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 945 if (mPlaybackThreads.valueAt(i)->isDuplicating()) { 946 continue; 947 } 948 mPlaybackThreads.valueAt(i)->setMasterMute(muted); 949 } 950 951 return NO_ERROR; 952 } 953 954 float AudioFlinger::masterVolume() const 955 { 956 Mutex::Autolock _l(mLock); 957 return masterVolume_l(); 958 } 959 960 bool AudioFlinger::masterMute() const 961 { 962 Mutex::Autolock _l(mLock); 963 return masterMute_l(); 964 } 965 966 float AudioFlinger::masterVolume_l() const 967 { 968 return mMasterVolume; 969 } 970 971 bool AudioFlinger::masterMute_l() const 972 { 973 return mMasterMute; 974 } 975 976 status_t AudioFlinger::checkStreamType(audio_stream_type_t stream) const 977 { 978 if (uint32_t(stream) >= AUDIO_STREAM_CNT) { 979 ALOGW("setStreamVolume() invalid stream %d", stream); 980 return BAD_VALUE; 981 } 982 pid_t caller = IPCThreadState::self()->getCallingPid(); 983 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT && caller != getpid_cached) { 984 ALOGW("setStreamVolume() pid %d cannot use internal stream type %d", caller, stream); 985 return PERMISSION_DENIED; 986 } 987 988 return NO_ERROR; 989 } 990 991 status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value, 992 audio_io_handle_t output) 993 { 994 // check calling permissions 995 if (!settingsAllowed()) { 996 return PERMISSION_DENIED; 997 } 998 999 status_t status = checkStreamType(stream); 1000 if (status != NO_ERROR) { 1001 return status; 1002 } 1003 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to change AUDIO_STREAM_PATCH volume"); 1004 1005 AutoMutex lock(mLock); 1006 PlaybackThread *thread = NULL; 1007 if (output != AUDIO_IO_HANDLE_NONE) { 1008 thread = checkPlaybackThread_l(output); 1009 if (thread == NULL) { 1010 return BAD_VALUE; 1011 } 1012 } 1013 1014 mStreamTypes[stream].volume = value; 1015 1016 if (thread == NULL) { 1017 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1018 mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value); 1019 } 1020 } else { 1021 thread->setStreamVolume(stream, value); 1022 } 1023 1024 return NO_ERROR; 1025 } 1026 1027 status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted) 1028 { 1029 // check calling permissions 1030 if (!settingsAllowed()) { 1031 return PERMISSION_DENIED; 1032 } 1033 1034 status_t status = checkStreamType(stream); 1035 if (status != NO_ERROR) { 1036 return status; 1037 } 1038 ALOG_ASSERT(stream != AUDIO_STREAM_PATCH, "attempt to mute AUDIO_STREAM_PATCH"); 1039 1040 if (uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) { 1041 ALOGE("setStreamMute() invalid stream %d", stream); 1042 return BAD_VALUE; 1043 } 1044 1045 AutoMutex lock(mLock); 1046 mStreamTypes[stream].mute = muted; 1047 for (size_t i = 0; i < mPlaybackThreads.size(); i++) 1048 mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted); 1049 1050 return NO_ERROR; 1051 } 1052 1053 float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const 1054 { 1055 status_t status = checkStreamType(stream); 1056 if (status != NO_ERROR) { 1057 return 0.0f; 1058 } 1059 1060 AutoMutex lock(mLock); 1061 float volume; 1062 if (output != AUDIO_IO_HANDLE_NONE) { 1063 PlaybackThread *thread = checkPlaybackThread_l(output); 1064 if (thread == NULL) { 1065 return 0.0f; 1066 } 1067 volume = thread->streamVolume(stream); 1068 } else { 1069 volume = streamVolume_l(stream); 1070 } 1071 1072 return volume; 1073 } 1074 1075 bool AudioFlinger::streamMute(audio_stream_type_t stream) const 1076 { 1077 status_t status = checkStreamType(stream); 1078 if (status != NO_ERROR) { 1079 return true; 1080 } 1081 1082 AutoMutex lock(mLock); 1083 return streamMute_l(stream); 1084 } 1085 1086 1087 void AudioFlinger::broacastParametersToRecordThreads_l(const String8& keyValuePairs) 1088 { 1089 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1090 mRecordThreads.valueAt(i)->setParameters(keyValuePairs); 1091 } 1092 } 1093 1094 status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) 1095 { 1096 ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d", 1097 ioHandle, keyValuePairs.string(), IPCThreadState::self()->getCallingPid()); 1098 1099 // check calling permissions 1100 if (!settingsAllowed()) { 1101 return PERMISSION_DENIED; 1102 } 1103 1104 // AUDIO_IO_HANDLE_NONE means the parameters are global to the audio hardware interface 1105 if (ioHandle == AUDIO_IO_HANDLE_NONE) { 1106 Mutex::Autolock _l(mLock); 1107 status_t final_result = NO_ERROR; 1108 { 1109 AutoMutex lock(mHardwareLock); 1110 mHardwareStatus = AUDIO_HW_SET_PARAMETER; 1111 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 1112 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 1113 status_t result = dev->set_parameters(dev, keyValuePairs.string()); 1114 final_result = result ?: final_result; 1115 } 1116 mHardwareStatus = AUDIO_HW_IDLE; 1117 } 1118 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings 1119 AudioParameter param = AudioParameter(keyValuePairs); 1120 String8 value; 1121 if (param.get(String8(AUDIO_PARAMETER_KEY_BT_NREC), value) == NO_ERROR) { 1122 bool btNrecIsOff = (value == AUDIO_PARAMETER_VALUE_OFF); 1123 if (mBtNrecIsOff != btNrecIsOff) { 1124 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1125 sp<RecordThread> thread = mRecordThreads.valueAt(i); 1126 audio_devices_t device = thread->inDevice(); 1127 bool suspend = audio_is_bluetooth_sco_device(device) && btNrecIsOff; 1128 // collect all of the thread's session IDs 1129 KeyedVector<audio_session_t, bool> ids = thread->sessionIds(); 1130 // suspend effects associated with those session IDs 1131 for (size_t j = 0; j < ids.size(); ++j) { 1132 audio_session_t sessionId = ids.keyAt(j); 1133 thread->setEffectSuspended(FX_IID_AEC, 1134 suspend, 1135 sessionId); 1136 thread->setEffectSuspended(FX_IID_NS, 1137 suspend, 1138 sessionId); 1139 } 1140 } 1141 mBtNrecIsOff = btNrecIsOff; 1142 } 1143 } 1144 String8 screenState; 1145 if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) { 1146 bool isOff = screenState == "off"; 1147 if (isOff != (AudioFlinger::mScreenState & 1)) { 1148 AudioFlinger::mScreenState = ((AudioFlinger::mScreenState & ~1) + 2) | isOff; 1149 } 1150 } 1151 return final_result; 1152 } 1153 1154 // hold a strong ref on thread in case closeOutput() or closeInput() is called 1155 // and the thread is exited once the lock is released 1156 sp<ThreadBase> thread; 1157 { 1158 Mutex::Autolock _l(mLock); 1159 thread = checkPlaybackThread_l(ioHandle); 1160 if (thread == 0) { 1161 thread = checkRecordThread_l(ioHandle); 1162 } else if (thread == primaryPlaybackThread_l()) { 1163 // indicate output device change to all input threads for pre processing 1164 AudioParameter param = AudioParameter(keyValuePairs); 1165 int value; 1166 if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) && 1167 (value != 0)) { 1168 broacastParametersToRecordThreads_l(keyValuePairs); 1169 } 1170 } 1171 } 1172 if (thread != 0) { 1173 return thread->setParameters(keyValuePairs); 1174 } 1175 return BAD_VALUE; 1176 } 1177 1178 String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const 1179 { 1180 ALOGVV("getParameters() io %d, keys %s, calling pid %d", 1181 ioHandle, keys.string(), IPCThreadState::self()->getCallingPid()); 1182 1183 Mutex::Autolock _l(mLock); 1184 1185 if (ioHandle == AUDIO_IO_HANDLE_NONE) { 1186 String8 out_s8; 1187 1188 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 1189 char *s; 1190 { 1191 AutoMutex lock(mHardwareLock); 1192 mHardwareStatus = AUDIO_HW_GET_PARAMETER; 1193 audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice(); 1194 s = dev->get_parameters(dev, keys.string()); 1195 mHardwareStatus = AUDIO_HW_IDLE; 1196 } 1197 out_s8 += String8(s ? s : ""); 1198 free(s); 1199 } 1200 return out_s8; 1201 } 1202 1203 PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle); 1204 if (playbackThread != NULL) { 1205 return playbackThread->getParameters(keys); 1206 } 1207 RecordThread *recordThread = checkRecordThread_l(ioHandle); 1208 if (recordThread != NULL) { 1209 return recordThread->getParameters(keys); 1210 } 1211 return String8(""); 1212 } 1213 1214 size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format, 1215 audio_channel_mask_t channelMask) const 1216 { 1217 status_t ret = initCheck(); 1218 if (ret != NO_ERROR) { 1219 return 0; 1220 } 1221 if ((sampleRate == 0) || 1222 !audio_is_valid_format(format) || !audio_has_proportional_frames(format) || 1223 !audio_is_input_channel(channelMask)) { 1224 return 0; 1225 } 1226 1227 AutoMutex lock(mHardwareLock); 1228 mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE; 1229 audio_config_t config, proposed; 1230 memset(&proposed, 0, sizeof(proposed)); 1231 proposed.sample_rate = sampleRate; 1232 proposed.channel_mask = channelMask; 1233 proposed.format = format; 1234 1235 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 1236 size_t frames; 1237 for (;;) { 1238 // Note: config is currently a const parameter for get_input_buffer_size() 1239 // but we use a copy from proposed in case config changes from the call. 1240 config = proposed; 1241 frames = dev->get_input_buffer_size(dev, &config); 1242 if (frames != 0) { 1243 break; // hal success, config is the result 1244 } 1245 // change one parameter of the configuration each iteration to a more "common" value 1246 // to see if the device will support it. 1247 if (proposed.format != AUDIO_FORMAT_PCM_16_BIT) { 1248 proposed.format = AUDIO_FORMAT_PCM_16_BIT; 1249 } else if (proposed.sample_rate != 44100) { // 44.1 is claimed as must in CDD as well as 1250 proposed.sample_rate = 44100; // legacy AudioRecord.java. TODO: Query hw? 1251 } else { 1252 ALOGW("getInputBufferSize failed with minimum buffer size sampleRate %u, " 1253 "format %#x, channelMask 0x%X", 1254 sampleRate, format, channelMask); 1255 break; // retries failed, break out of loop with frames == 0. 1256 } 1257 } 1258 mHardwareStatus = AUDIO_HW_IDLE; 1259 if (frames > 0 && config.sample_rate != sampleRate) { 1260 frames = destinationFramesPossible(frames, sampleRate, config.sample_rate); 1261 } 1262 return frames; // may be converted to bytes at the Java level. 1263 } 1264 1265 uint32_t AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const 1266 { 1267 Mutex::Autolock _l(mLock); 1268 1269 RecordThread *recordThread = checkRecordThread_l(ioHandle); 1270 if (recordThread != NULL) { 1271 return recordThread->getInputFramesLost(); 1272 } 1273 return 0; 1274 } 1275 1276 status_t AudioFlinger::setVoiceVolume(float value) 1277 { 1278 status_t ret = initCheck(); 1279 if (ret != NO_ERROR) { 1280 return ret; 1281 } 1282 1283 // check calling permissions 1284 if (!settingsAllowed()) { 1285 return PERMISSION_DENIED; 1286 } 1287 1288 AutoMutex lock(mHardwareLock); 1289 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 1290 mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME; 1291 ret = dev->set_voice_volume(dev, value); 1292 mHardwareStatus = AUDIO_HW_IDLE; 1293 1294 return ret; 1295 } 1296 1297 status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, 1298 audio_io_handle_t output) const 1299 { 1300 Mutex::Autolock _l(mLock); 1301 1302 PlaybackThread *playbackThread = checkPlaybackThread_l(output); 1303 if (playbackThread != NULL) { 1304 return playbackThread->getRenderPosition(halFrames, dspFrames); 1305 } 1306 1307 return BAD_VALUE; 1308 } 1309 1310 void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client) 1311 { 1312 Mutex::Autolock _l(mLock); 1313 if (client == 0) { 1314 return; 1315 } 1316 pid_t pid = IPCThreadState::self()->getCallingPid(); 1317 { 1318 Mutex::Autolock _cl(mClientLock); 1319 if (mNotificationClients.indexOfKey(pid) < 0) { 1320 sp<NotificationClient> notificationClient = new NotificationClient(this, 1321 client, 1322 pid); 1323 ALOGV("registerClient() client %p, pid %d", notificationClient.get(), pid); 1324 1325 mNotificationClients.add(pid, notificationClient); 1326 1327 sp<IBinder> binder = IInterface::asBinder(client); 1328 binder->linkToDeath(notificationClient); 1329 } 1330 } 1331 1332 // mClientLock should not be held here because ThreadBase::sendIoConfigEvent() will lock the 1333 // ThreadBase mutex and the locking order is ThreadBase::mLock then AudioFlinger::mClientLock. 1334 // the config change is always sent from playback or record threads to avoid deadlock 1335 // with AudioSystem::gLock 1336 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1337 mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AUDIO_OUTPUT_OPENED, pid); 1338 } 1339 1340 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1341 mRecordThreads.valueAt(i)->sendIoConfigEvent(AUDIO_INPUT_OPENED, pid); 1342 } 1343 } 1344 1345 void AudioFlinger::removeNotificationClient(pid_t pid) 1346 { 1347 Mutex::Autolock _l(mLock); 1348 { 1349 Mutex::Autolock _cl(mClientLock); 1350 mNotificationClients.removeItem(pid); 1351 } 1352 1353 ALOGV("%d died, releasing its sessions", pid); 1354 size_t num = mAudioSessionRefs.size(); 1355 bool removed = false; 1356 for (size_t i = 0; i< num; ) { 1357 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i); 1358 ALOGV(" pid %d @ %zu", ref->mPid, i); 1359 if (ref->mPid == pid) { 1360 ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid); 1361 mAudioSessionRefs.removeAt(i); 1362 delete ref; 1363 removed = true; 1364 num--; 1365 } else { 1366 i++; 1367 } 1368 } 1369 if (removed) { 1370 purgeStaleEffects_l(); 1371 } 1372 } 1373 1374 void AudioFlinger::ioConfigChanged(audio_io_config_event event, 1375 const sp<AudioIoDescriptor>& ioDesc, 1376 pid_t pid) 1377 { 1378 Mutex::Autolock _l(mClientLock); 1379 size_t size = mNotificationClients.size(); 1380 for (size_t i = 0; i < size; i++) { 1381 if ((pid == 0) || (mNotificationClients.keyAt(i) == pid)) { 1382 mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(event, ioDesc); 1383 } 1384 } 1385 } 1386 1387 // removeClient_l() must be called with AudioFlinger::mClientLock held 1388 void AudioFlinger::removeClient_l(pid_t pid) 1389 { 1390 ALOGV("removeClient_l() pid %d, calling pid %d", pid, 1391 IPCThreadState::self()->getCallingPid()); 1392 mClients.removeItem(pid); 1393 } 1394 1395 // getEffectThread_l() must be called with AudioFlinger::mLock held 1396 sp<AudioFlinger::PlaybackThread> AudioFlinger::getEffectThread_l(audio_session_t sessionId, 1397 int EffectId) 1398 { 1399 sp<PlaybackThread> thread; 1400 1401 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1402 if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, EffectId) != 0) { 1403 ALOG_ASSERT(thread == 0); 1404 thread = mPlaybackThreads.valueAt(i); 1405 } 1406 } 1407 1408 return thread; 1409 } 1410 1411 1412 1413 // ---------------------------------------------------------------------------- 1414 1415 AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid) 1416 : RefBase(), 1417 mAudioFlinger(audioFlinger), 1418 mPid(pid) 1419 { 1420 size_t heapSize = kClientSharedHeapSizeBytes; 1421 // Increase heap size on non low ram devices to limit risk of reconnection failure for 1422 // invalidated tracks 1423 if (!audioFlinger->isLowRamDevice()) { 1424 heapSize *= kClientSharedHeapSizeMultiplier; 1425 } 1426 mMemoryDealer = new MemoryDealer(heapSize, "AudioFlinger::Client"); 1427 } 1428 1429 // Client destructor must be called with AudioFlinger::mClientLock held 1430 AudioFlinger::Client::~Client() 1431 { 1432 mAudioFlinger->removeClient_l(mPid); 1433 } 1434 1435 sp<MemoryDealer> AudioFlinger::Client::heap() const 1436 { 1437 return mMemoryDealer; 1438 } 1439 1440 // ---------------------------------------------------------------------------- 1441 1442 AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger, 1443 const sp<IAudioFlingerClient>& client, 1444 pid_t pid) 1445 : mAudioFlinger(audioFlinger), mPid(pid), mAudioFlingerClient(client) 1446 { 1447 } 1448 1449 AudioFlinger::NotificationClient::~NotificationClient() 1450 { 1451 } 1452 1453 void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who __unused) 1454 { 1455 sp<NotificationClient> keep(this); 1456 mAudioFlinger->removeNotificationClient(mPid); 1457 } 1458 1459 1460 // ---------------------------------------------------------------------------- 1461 1462 sp<IAudioRecord> AudioFlinger::openRecord( 1463 audio_io_handle_t input, 1464 uint32_t sampleRate, 1465 audio_format_t format, 1466 audio_channel_mask_t channelMask, 1467 const String16& opPackageName, 1468 size_t *frameCount, 1469 audio_input_flags_t *flags, 1470 pid_t pid, 1471 pid_t tid, 1472 int clientUid, 1473 audio_session_t *sessionId, 1474 size_t *notificationFrames, 1475 sp<IMemory>& cblk, 1476 sp<IMemory>& buffers, 1477 status_t *status) 1478 { 1479 sp<RecordThread::RecordTrack> recordTrack; 1480 sp<RecordHandle> recordHandle; 1481 sp<Client> client; 1482 status_t lStatus; 1483 audio_session_t lSessionId; 1484 1485 cblk.clear(); 1486 buffers.clear(); 1487 1488 bool updatePid = (pid == -1); 1489 const uid_t callingUid = IPCThreadState::self()->getCallingUid(); 1490 if (!isTrustedCallingUid(callingUid)) { 1491 ALOGW_IF((uid_t)clientUid != callingUid, 1492 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid, clientUid); 1493 clientUid = callingUid; 1494 updatePid = true; 1495 } 1496 1497 if (updatePid) { 1498 const pid_t callingPid = IPCThreadState::self()->getCallingPid(); 1499 ALOGW_IF(pid != -1 && pid != callingPid, 1500 "%s uid %d pid %d tried to pass itself off as pid %d", 1501 __func__, callingUid, callingPid, pid); 1502 pid = callingPid; 1503 } 1504 1505 // check calling permissions 1506 if (!recordingAllowed(opPackageName, tid, clientUid)) { 1507 ALOGE("openRecord() permission denied: recording not allowed"); 1508 lStatus = PERMISSION_DENIED; 1509 goto Exit; 1510 } 1511 1512 // further sample rate checks are performed by createRecordTrack_l() 1513 if (sampleRate == 0) { 1514 ALOGE("openRecord() invalid sample rate %u", sampleRate); 1515 lStatus = BAD_VALUE; 1516 goto Exit; 1517 } 1518 1519 // we don't yet support anything other than linear PCM 1520 if (!audio_is_valid_format(format) || !audio_is_linear_pcm(format)) { 1521 ALOGE("openRecord() invalid format %#x", format); 1522 lStatus = BAD_VALUE; 1523 goto Exit; 1524 } 1525 1526 // further channel mask checks are performed by createRecordTrack_l() 1527 if (!audio_is_input_channel(channelMask)) { 1528 ALOGE("openRecord() invalid channel mask %#x", channelMask); 1529 lStatus = BAD_VALUE; 1530 goto Exit; 1531 } 1532 1533 { 1534 Mutex::Autolock _l(mLock); 1535 RecordThread *thread = checkRecordThread_l(input); 1536 if (thread == NULL) { 1537 ALOGE("openRecord() checkRecordThread_l failed"); 1538 lStatus = BAD_VALUE; 1539 goto Exit; 1540 } 1541 1542 client = registerPid(pid); 1543 1544 if (sessionId != NULL && *sessionId != AUDIO_SESSION_ALLOCATE) { 1545 if (audio_unique_id_get_use(*sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) { 1546 lStatus = BAD_VALUE; 1547 goto Exit; 1548 } 1549 lSessionId = *sessionId; 1550 } else { 1551 // if no audio session id is provided, create one here 1552 lSessionId = (audio_session_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_SESSION); 1553 if (sessionId != NULL) { 1554 *sessionId = lSessionId; 1555 } 1556 } 1557 ALOGV("openRecord() lSessionId: %d input %d", lSessionId, input); 1558 1559 recordTrack = thread->createRecordTrack_l(client, sampleRate, format, channelMask, 1560 frameCount, lSessionId, notificationFrames, 1561 clientUid, flags, tid, &lStatus); 1562 LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0)); 1563 1564 if (lStatus == NO_ERROR) { 1565 // Check if one effect chain was awaiting for an AudioRecord to be created on this 1566 // session and move it to this thread. 1567 sp<EffectChain> chain = getOrphanEffectChain_l(lSessionId); 1568 if (chain != 0) { 1569 Mutex::Autolock _l(thread->mLock); 1570 thread->addEffectChain_l(chain); 1571 } 1572 } 1573 } 1574 1575 if (lStatus != NO_ERROR) { 1576 // remove local strong reference to Client before deleting the RecordTrack so that the 1577 // Client destructor is called by the TrackBase destructor with mClientLock held 1578 // Don't hold mClientLock when releasing the reference on the track as the 1579 // destructor will acquire it. 1580 { 1581 Mutex::Autolock _cl(mClientLock); 1582 client.clear(); 1583 } 1584 recordTrack.clear(); 1585 goto Exit; 1586 } 1587 1588 cblk = recordTrack->getCblk(); 1589 buffers = recordTrack->getBuffers(); 1590 1591 // return handle to client 1592 recordHandle = new RecordHandle(recordTrack); 1593 1594 Exit: 1595 *status = lStatus; 1596 return recordHandle; 1597 } 1598 1599 1600 1601 // ---------------------------------------------------------------------------- 1602 1603 audio_module_handle_t AudioFlinger::loadHwModule(const char *name) 1604 { 1605 if (name == NULL) { 1606 return AUDIO_MODULE_HANDLE_NONE; 1607 } 1608 if (!settingsAllowed()) { 1609 return AUDIO_MODULE_HANDLE_NONE; 1610 } 1611 Mutex::Autolock _l(mLock); 1612 return loadHwModule_l(name); 1613 } 1614 1615 // loadHwModule_l() must be called with AudioFlinger::mLock held 1616 audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name) 1617 { 1618 for (size_t i = 0; i < mAudioHwDevs.size(); i++) { 1619 if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) { 1620 ALOGW("loadHwModule() module %s already loaded", name); 1621 return mAudioHwDevs.keyAt(i); 1622 } 1623 } 1624 1625 audio_hw_device_t *dev; 1626 1627 int rc = load_audio_interface(name, &dev); 1628 if (rc) { 1629 ALOGE("loadHwModule() error %d loading module %s", rc, name); 1630 return AUDIO_MODULE_HANDLE_NONE; 1631 } 1632 1633 mHardwareStatus = AUDIO_HW_INIT; 1634 rc = dev->init_check(dev); 1635 mHardwareStatus = AUDIO_HW_IDLE; 1636 if (rc) { 1637 ALOGE("loadHwModule() init check error %d for module %s", rc, name); 1638 return AUDIO_MODULE_HANDLE_NONE; 1639 } 1640 1641 // Check and cache this HAL's level of support for master mute and master 1642 // volume. If this is the first HAL opened, and it supports the get 1643 // methods, use the initial values provided by the HAL as the current 1644 // master mute and volume settings. 1645 1646 AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0); 1647 { // scope for auto-lock pattern 1648 AutoMutex lock(mHardwareLock); 1649 1650 if (0 == mAudioHwDevs.size()) { 1651 mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME; 1652 if (NULL != dev->get_master_volume) { 1653 float mv; 1654 if (OK == dev->get_master_volume(dev, &mv)) { 1655 mMasterVolume = mv; 1656 } 1657 } 1658 1659 mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE; 1660 if (NULL != dev->get_master_mute) { 1661 bool mm; 1662 if (OK == dev->get_master_mute(dev, &mm)) { 1663 mMasterMute = mm; 1664 } 1665 } 1666 } 1667 1668 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; 1669 if ((NULL != dev->set_master_volume) && 1670 (OK == dev->set_master_volume(dev, mMasterVolume))) { 1671 flags = static_cast<AudioHwDevice::Flags>(flags | 1672 AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME); 1673 } 1674 1675 mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE; 1676 if ((NULL != dev->set_master_mute) && 1677 (OK == dev->set_master_mute(dev, mMasterMute))) { 1678 flags = static_cast<AudioHwDevice::Flags>(flags | 1679 AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE); 1680 } 1681 1682 mHardwareStatus = AUDIO_HW_IDLE; 1683 } 1684 1685 audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE); 1686 mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags)); 1687 1688 ALOGI("loadHwModule() Loaded %s audio interface from %s (%s) handle %d", 1689 name, dev->common.module->name, dev->common.module->id, handle); 1690 1691 return handle; 1692 1693 } 1694 1695 // ---------------------------------------------------------------------------- 1696 1697 uint32_t AudioFlinger::getPrimaryOutputSamplingRate() 1698 { 1699 Mutex::Autolock _l(mLock); 1700 PlaybackThread *thread = fastPlaybackThread_l(); 1701 return thread != NULL ? thread->sampleRate() : 0; 1702 } 1703 1704 size_t AudioFlinger::getPrimaryOutputFrameCount() 1705 { 1706 Mutex::Autolock _l(mLock); 1707 PlaybackThread *thread = fastPlaybackThread_l(); 1708 return thread != NULL ? thread->frameCountHAL() : 0; 1709 } 1710 1711 // ---------------------------------------------------------------------------- 1712 1713 status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice) 1714 { 1715 uid_t uid = IPCThreadState::self()->getCallingUid(); 1716 if (uid != AID_SYSTEM) { 1717 return PERMISSION_DENIED; 1718 } 1719 Mutex::Autolock _l(mLock); 1720 if (mIsDeviceTypeKnown) { 1721 return INVALID_OPERATION; 1722 } 1723 mIsLowRamDevice = isLowRamDevice; 1724 mIsDeviceTypeKnown = true; 1725 return NO_ERROR; 1726 } 1727 1728 audio_hw_sync_t AudioFlinger::getAudioHwSyncForSession(audio_session_t sessionId) 1729 { 1730 Mutex::Autolock _l(mLock); 1731 1732 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId); 1733 if (index >= 0) { 1734 ALOGV("getAudioHwSyncForSession found ID %d for session %d", 1735 mHwAvSyncIds.valueAt(index), sessionId); 1736 return mHwAvSyncIds.valueAt(index); 1737 } 1738 1739 audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice(); 1740 if (dev == NULL) { 1741 return AUDIO_HW_SYNC_INVALID; 1742 } 1743 char *reply = dev->get_parameters(dev, AUDIO_PARAMETER_HW_AV_SYNC); 1744 AudioParameter param = AudioParameter(String8(reply)); 1745 free(reply); 1746 1747 int value; 1748 if (param.getInt(String8(AUDIO_PARAMETER_HW_AV_SYNC), value) != NO_ERROR) { 1749 ALOGW("getAudioHwSyncForSession error getting sync for session %d", sessionId); 1750 return AUDIO_HW_SYNC_INVALID; 1751 } 1752 1753 // allow only one session for a given HW A/V sync ID. 1754 for (size_t i = 0; i < mHwAvSyncIds.size(); i++) { 1755 if (mHwAvSyncIds.valueAt(i) == (audio_hw_sync_t)value) { 1756 ALOGV("getAudioHwSyncForSession removing ID %d for session %d", 1757 value, mHwAvSyncIds.keyAt(i)); 1758 mHwAvSyncIds.removeItemsAt(i); 1759 break; 1760 } 1761 } 1762 1763 mHwAvSyncIds.add(sessionId, value); 1764 1765 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1766 sp<PlaybackThread> thread = mPlaybackThreads.valueAt(i); 1767 uint32_t sessions = thread->hasAudioSession(sessionId); 1768 if (sessions & ThreadBase::TRACK_SESSION) { 1769 AudioParameter param = AudioParameter(); 1770 param.addInt(String8(AUDIO_PARAMETER_STREAM_HW_AV_SYNC), value); 1771 thread->setParameters(param.toString()); 1772 break; 1773 } 1774 } 1775 1776 ALOGV("getAudioHwSyncForSession adding ID %d for session %d", value, sessionId); 1777 return (audio_hw_sync_t)value; 1778 } 1779 1780 status_t AudioFlinger::systemReady() 1781 { 1782 Mutex::Autolock _l(mLock); 1783 ALOGI("%s", __FUNCTION__); 1784 if (mSystemReady) { 1785 ALOGW("%s called twice", __FUNCTION__); 1786 return NO_ERROR; 1787 } 1788 mSystemReady = true; 1789 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1790 ThreadBase *thread = (ThreadBase *)mPlaybackThreads.valueAt(i).get(); 1791 thread->systemReady(); 1792 } 1793 for (size_t i = 0; i < mRecordThreads.size(); i++) { 1794 ThreadBase *thread = (ThreadBase *)mRecordThreads.valueAt(i).get(); 1795 thread->systemReady(); 1796 } 1797 return NO_ERROR; 1798 } 1799 1800 // setAudioHwSyncForSession_l() must be called with AudioFlinger::mLock held 1801 void AudioFlinger::setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId) 1802 { 1803 ssize_t index = mHwAvSyncIds.indexOfKey(sessionId); 1804 if (index >= 0) { 1805 audio_hw_sync_t syncId = mHwAvSyncIds.valueAt(index); 1806 ALOGV("setAudioHwSyncForSession_l found ID %d for session %d", syncId, sessionId); 1807 AudioParameter param = AudioParameter(); 1808 param.addInt(String8(AUDIO_PARAMETER_STREAM_HW_AV_SYNC), syncId); 1809 thread->setParameters(param.toString()); 1810 } 1811 } 1812 1813 1814 // ---------------------------------------------------------------------------- 1815 1816 1817 sp<AudioFlinger::PlaybackThread> AudioFlinger::openOutput_l(audio_module_handle_t module, 1818 audio_io_handle_t *output, 1819 audio_config_t *config, 1820 audio_devices_t devices, 1821 const String8& address, 1822 audio_output_flags_t flags) 1823 { 1824 AudioHwDevice *outHwDev = findSuitableHwDev_l(module, devices); 1825 if (outHwDev == NULL) { 1826 return 0; 1827 } 1828 1829 if (*output == AUDIO_IO_HANDLE_NONE) { 1830 *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT); 1831 } else { 1832 // Audio Policy does not currently request a specific output handle. 1833 // If this is ever needed, see openInput_l() for example code. 1834 ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output); 1835 return 0; 1836 } 1837 1838 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN; 1839 1840 // FOR TESTING ONLY: 1841 // This if statement allows overriding the audio policy settings 1842 // and forcing a specific format or channel mask to the HAL/Sink device for testing. 1843 if (!(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) { 1844 // Check only for Normal Mixing mode 1845 if (kEnableExtendedPrecision) { 1846 // Specify format (uncomment one below to choose) 1847 //config->format = AUDIO_FORMAT_PCM_FLOAT; 1848 //config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED; 1849 //config->format = AUDIO_FORMAT_PCM_32_BIT; 1850 //config->format = AUDIO_FORMAT_PCM_8_24_BIT; 1851 // ALOGV("openOutput_l() upgrading format to %#08x", config->format); 1852 } 1853 if (kEnableExtendedChannels) { 1854 // Specify channel mask (uncomment one below to choose) 1855 //config->channel_mask = audio_channel_out_mask_from_count(4); // for USB 4ch 1856 //config->channel_mask = audio_channel_mask_from_representation_and_bits( 1857 // AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1); // another 4ch example 1858 } 1859 } 1860 1861 AudioStreamOut *outputStream = NULL; 1862 status_t status = outHwDev->openOutputStream( 1863 &outputStream, 1864 *output, 1865 devices, 1866 flags, 1867 config, 1868 address.string()); 1869 1870 mHardwareStatus = AUDIO_HW_IDLE; 1871 1872 if (status == NO_ERROR) { 1873 1874 PlaybackThread *thread; 1875 if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) { 1876 thread = new OffloadThread(this, outputStream, *output, devices, mSystemReady); 1877 ALOGV("openOutput_l() created offload output: ID %d thread %p", *output, thread); 1878 } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT) 1879 || !isValidPcmSinkFormat(config->format) 1880 || !isValidPcmSinkChannelMask(config->channel_mask)) { 1881 thread = new DirectOutputThread(this, outputStream, *output, devices, mSystemReady); 1882 ALOGV("openOutput_l() created direct output: ID %d thread %p", *output, thread); 1883 } else { 1884 thread = new MixerThread(this, outputStream, *output, devices, mSystemReady); 1885 ALOGV("openOutput_l() created mixer output: ID %d thread %p", *output, thread); 1886 } 1887 mPlaybackThreads.add(*output, thread); 1888 return thread; 1889 } 1890 1891 return 0; 1892 } 1893 1894 status_t AudioFlinger::openOutput(audio_module_handle_t module, 1895 audio_io_handle_t *output, 1896 audio_config_t *config, 1897 audio_devices_t *devices, 1898 const String8& address, 1899 uint32_t *latencyMs, 1900 audio_output_flags_t flags) 1901 { 1902 ALOGI("openOutput(), module %d Device %x, SamplingRate %d, Format %#08x, Channels %x, flags %x", 1903 module, 1904 (devices != NULL) ? *devices : 0, 1905 config->sample_rate, 1906 config->format, 1907 config->channel_mask, 1908 flags); 1909 1910 if (*devices == AUDIO_DEVICE_NONE) { 1911 return BAD_VALUE; 1912 } 1913 1914 Mutex::Autolock _l(mLock); 1915 1916 sp<PlaybackThread> thread = openOutput_l(module, output, config, *devices, address, flags); 1917 if (thread != 0) { 1918 *latencyMs = thread->latency(); 1919 1920 // notify client processes of the new output creation 1921 thread->ioConfigChanged(AUDIO_OUTPUT_OPENED); 1922 1923 // the first primary output opened designates the primary hw device 1924 if ((mPrimaryHardwareDev == NULL) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) { 1925 ALOGI("Using module %d has the primary audio interface", module); 1926 mPrimaryHardwareDev = thread->getOutput()->audioHwDev; 1927 1928 AutoMutex lock(mHardwareLock); 1929 mHardwareStatus = AUDIO_HW_SET_MODE; 1930 mPrimaryHardwareDev->hwDevice()->set_mode(mPrimaryHardwareDev->hwDevice(), mMode); 1931 mHardwareStatus = AUDIO_HW_IDLE; 1932 } 1933 return NO_ERROR; 1934 } 1935 1936 return NO_INIT; 1937 } 1938 1939 audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1, 1940 audio_io_handle_t output2) 1941 { 1942 Mutex::Autolock _l(mLock); 1943 MixerThread *thread1 = checkMixerThread_l(output1); 1944 MixerThread *thread2 = checkMixerThread_l(output2); 1945 1946 if (thread1 == NULL || thread2 == NULL) { 1947 ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, 1948 output2); 1949 return AUDIO_IO_HANDLE_NONE; 1950 } 1951 1952 audio_io_handle_t id = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT); 1953 DuplicatingThread *thread = new DuplicatingThread(this, thread1, id, mSystemReady); 1954 thread->addOutputTrack(thread2); 1955 mPlaybackThreads.add(id, thread); 1956 // notify client processes of the new output creation 1957 thread->ioConfigChanged(AUDIO_OUTPUT_OPENED); 1958 return id; 1959 } 1960 1961 status_t AudioFlinger::closeOutput(audio_io_handle_t output) 1962 { 1963 return closeOutput_nonvirtual(output); 1964 } 1965 1966 status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output) 1967 { 1968 // keep strong reference on the playback thread so that 1969 // it is not destroyed while exit() is executed 1970 sp<PlaybackThread> thread; 1971 { 1972 Mutex::Autolock _l(mLock); 1973 thread = checkPlaybackThread_l(output); 1974 if (thread == NULL) { 1975 return BAD_VALUE; 1976 } 1977 1978 ALOGV("closeOutput() %d", output); 1979 1980 if (thread->type() == ThreadBase::MIXER) { 1981 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 1982 if (mPlaybackThreads.valueAt(i)->isDuplicating()) { 1983 DuplicatingThread *dupThread = 1984 (DuplicatingThread *)mPlaybackThreads.valueAt(i).get(); 1985 dupThread->removeOutputTrack((MixerThread *)thread.get()); 1986 } 1987 } 1988 } 1989 1990 1991 mPlaybackThreads.removeItem(output); 1992 // save all effects to the default thread 1993 if (mPlaybackThreads.size()) { 1994 PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0)); 1995 if (dstThread != NULL) { 1996 // audioflinger lock is held here so the acquisition order of thread locks does not 1997 // matter 1998 Mutex::Autolock _dl(dstThread->mLock); 1999 Mutex::Autolock _sl(thread->mLock); 2000 Vector< sp<EffectChain> > effectChains = thread->getEffectChains_l(); 2001 for (size_t i = 0; i < effectChains.size(); i ++) { 2002 moveEffectChain_l(effectChains[i]->sessionId(), thread.get(), dstThread, true); 2003 } 2004 } 2005 } 2006 const sp<AudioIoDescriptor> ioDesc = new AudioIoDescriptor(); 2007 ioDesc->mIoHandle = output; 2008 ioConfigChanged(AUDIO_OUTPUT_CLOSED, ioDesc); 2009 } 2010 thread->exit(); 2011 // The thread entity (active unit of execution) is no longer running here, 2012 // but the ThreadBase container still exists. 2013 2014 if (!thread->isDuplicating()) { 2015 closeOutputFinish(thread); 2016 } 2017 2018 return NO_ERROR; 2019 } 2020 2021 void AudioFlinger::closeOutputFinish(sp<PlaybackThread> thread) 2022 { 2023 AudioStreamOut *out = thread->clearOutput(); 2024 ALOG_ASSERT(out != NULL, "out shouldn't be NULL"); 2025 // from now on thread->mOutput is NULL 2026 out->hwDev()->close_output_stream(out->hwDev(), out->stream); 2027 delete out; 2028 } 2029 2030 void AudioFlinger::closeOutputInternal_l(sp<PlaybackThread> thread) 2031 { 2032 mPlaybackThreads.removeItem(thread->mId); 2033 thread->exit(); 2034 closeOutputFinish(thread); 2035 } 2036 2037 status_t AudioFlinger::suspendOutput(audio_io_handle_t output) 2038 { 2039 Mutex::Autolock _l(mLock); 2040 PlaybackThread *thread = checkPlaybackThread_l(output); 2041 2042 if (thread == NULL) { 2043 return BAD_VALUE; 2044 } 2045 2046 ALOGV("suspendOutput() %d", output); 2047 thread->suspend(); 2048 2049 return NO_ERROR; 2050 } 2051 2052 status_t AudioFlinger::restoreOutput(audio_io_handle_t output) 2053 { 2054 Mutex::Autolock _l(mLock); 2055 PlaybackThread *thread = checkPlaybackThread_l(output); 2056 2057 if (thread == NULL) { 2058 return BAD_VALUE; 2059 } 2060 2061 ALOGV("restoreOutput() %d", output); 2062 2063 thread->restore(); 2064 2065 return NO_ERROR; 2066 } 2067 2068 status_t AudioFlinger::openInput(audio_module_handle_t module, 2069 audio_io_handle_t *input, 2070 audio_config_t *config, 2071 audio_devices_t *devices, 2072 const String8& address, 2073 audio_source_t source, 2074 audio_input_flags_t flags) 2075 { 2076 Mutex::Autolock _l(mLock); 2077 2078 if (*devices == AUDIO_DEVICE_NONE) { 2079 return BAD_VALUE; 2080 } 2081 2082 sp<RecordThread> thread = openInput_l(module, input, config, *devices, address, source, flags); 2083 2084 if (thread != 0) { 2085 // notify client processes of the new input creation 2086 thread->ioConfigChanged(AUDIO_INPUT_OPENED); 2087 return NO_ERROR; 2088 } 2089 return NO_INIT; 2090 } 2091 2092 sp<AudioFlinger::RecordThread> AudioFlinger::openInput_l(audio_module_handle_t module, 2093 audio_io_handle_t *input, 2094 audio_config_t *config, 2095 audio_devices_t devices, 2096 const String8& address, 2097 audio_source_t source, 2098 audio_input_flags_t flags) 2099 { 2100 AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices); 2101 if (inHwDev == NULL) { 2102 *input = AUDIO_IO_HANDLE_NONE; 2103 return 0; 2104 } 2105 2106 // Audio Policy can request a specific handle for hardware hotword. 2107 // The goal here is not to re-open an already opened input. 2108 // It is to use a pre-assigned I/O handle. 2109 if (*input == AUDIO_IO_HANDLE_NONE) { 2110 *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT); 2111 } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) { 2112 ALOGE("openInput_l() requested input handle %d is invalid", *input); 2113 return 0; 2114 } else if (mRecordThreads.indexOfKey(*input) >= 0) { 2115 // This should not happen in a transient state with current design. 2116 ALOGE("openInput_l() requested input handle %d is already assigned", *input); 2117 return 0; 2118 } 2119 2120 audio_config_t halconfig = *config; 2121 audio_hw_device_t *inHwHal = inHwDev->hwDevice(); 2122 audio_stream_in_t *inStream = NULL; 2123 status_t status = inHwHal->open_input_stream(inHwHal, *input, devices, &halconfig, 2124 &inStream, flags, address.string(), source); 2125 ALOGV("openInput_l() openInputStream returned input %p, SamplingRate %d" 2126 ", Format %#x, Channels %x, flags %#x, status %d addr %s", 2127 inStream, 2128 halconfig.sample_rate, 2129 halconfig.format, 2130 halconfig.channel_mask, 2131 flags, 2132 status, address.string()); 2133 2134 // If the input could not be opened with the requested parameters and we can handle the 2135 // conversion internally, try to open again with the proposed parameters. 2136 if (status == BAD_VALUE && 2137 audio_is_linear_pcm(config->format) && 2138 audio_is_linear_pcm(halconfig.format) && 2139 (halconfig.sample_rate <= AUDIO_RESAMPLER_DOWN_RATIO_MAX * config->sample_rate) && 2140 (audio_channel_count_from_in_mask(halconfig.channel_mask) <= FCC_8) && 2141 (audio_channel_count_from_in_mask(config->channel_mask) <= FCC_8)) { 2142 // FIXME describe the change proposed by HAL (save old values so we can log them here) 2143 ALOGV("openInput_l() reopening with proposed sampling rate and channel mask"); 2144 inStream = NULL; 2145 status = inHwHal->open_input_stream(inHwHal, *input, devices, &halconfig, 2146 &inStream, flags, address.string(), source); 2147 // FIXME log this new status; HAL should not propose any further changes 2148 } 2149 2150 if (status == NO_ERROR && inStream != NULL) { 2151 2152 #ifdef TEE_SINK 2153 // Try to re-use most recently used Pipe to archive a copy of input for dumpsys, 2154 // or (re-)create if current Pipe is idle and does not match the new format 2155 sp<NBAIO_Sink> teeSink; 2156 enum { 2157 TEE_SINK_NO, // don't copy input 2158 TEE_SINK_NEW, // copy input using a new pipe 2159 TEE_SINK_OLD, // copy input using an existing pipe 2160 } kind; 2161 NBAIO_Format format = Format_from_SR_C(halconfig.sample_rate, 2162 audio_channel_count_from_in_mask(halconfig.channel_mask), halconfig.format); 2163 if (!mTeeSinkInputEnabled) { 2164 kind = TEE_SINK_NO; 2165 } else if (!Format_isValid(format)) { 2166 kind = TEE_SINK_NO; 2167 } else if (mRecordTeeSink == 0) { 2168 kind = TEE_SINK_NEW; 2169 } else if (mRecordTeeSink->getStrongCount() != 1) { 2170 kind = TEE_SINK_NO; 2171 } else if (Format_isEqual(format, mRecordTeeSink->format())) { 2172 kind = TEE_SINK_OLD; 2173 } else { 2174 kind = TEE_SINK_NEW; 2175 } 2176 switch (kind) { 2177 case TEE_SINK_NEW: { 2178 Pipe *pipe = new Pipe(mTeeSinkInputFrames, format); 2179 size_t numCounterOffers = 0; 2180 const NBAIO_Format offers[1] = {format}; 2181 ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers); 2182 ALOG_ASSERT(index == 0); 2183 PipeReader *pipeReader = new PipeReader(*pipe); 2184 numCounterOffers = 0; 2185 index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers); 2186 ALOG_ASSERT(index == 0); 2187 mRecordTeeSink = pipe; 2188 mRecordTeeSource = pipeReader; 2189 teeSink = pipe; 2190 } 2191 break; 2192 case TEE_SINK_OLD: 2193 teeSink = mRecordTeeSink; 2194 break; 2195 case TEE_SINK_NO: 2196 default: 2197 break; 2198 } 2199 #endif 2200 2201 AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags); 2202 2203 // Start record thread 2204 // RecordThread requires both input and output device indication to forward to audio 2205 // pre processing modules 2206 sp<RecordThread> thread = new RecordThread(this, 2207 inputStream, 2208 *input, 2209 primaryOutputDevice_l(), 2210 devices, 2211 mSystemReady 2212 #ifdef TEE_SINK 2213 , teeSink 2214 #endif 2215 ); 2216 mRecordThreads.add(*input, thread); 2217 ALOGV("openInput_l() created record thread: ID %d thread %p", *input, thread.get()); 2218 return thread; 2219 } 2220 2221 *input = AUDIO_IO_HANDLE_NONE; 2222 return 0; 2223 } 2224 2225 status_t AudioFlinger::closeInput(audio_io_handle_t input) 2226 { 2227 return closeInput_nonvirtual(input); 2228 } 2229 2230 status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input) 2231 { 2232 // keep strong reference on the record thread so that 2233 // it is not destroyed while exit() is executed 2234 sp<RecordThread> thread; 2235 { 2236 Mutex::Autolock _l(mLock); 2237 thread = checkRecordThread_l(input); 2238 if (thread == 0) { 2239 return BAD_VALUE; 2240 } 2241 2242 ALOGV("closeInput() %d", input); 2243 2244 // If we still have effect chains, it means that a client still holds a handle 2245 // on at least one effect. We must either move the chain to an existing thread with the 2246 // same session ID or put it aside in case a new record thread is opened for a 2247 // new capture on the same session 2248 sp<EffectChain> chain; 2249 { 2250 Mutex::Autolock _sl(thread->mLock); 2251 Vector< sp<EffectChain> > effectChains = thread->getEffectChains_l(); 2252 // Note: maximum one chain per record thread 2253 if (effectChains.size() != 0) { 2254 chain = effectChains[0]; 2255 } 2256 } 2257 if (chain != 0) { 2258 // first check if a record thread is already opened with a client on the same session. 2259 // This should only happen in case of overlap between one thread tear down and the 2260 // creation of its replacement 2261 size_t i; 2262 for (i = 0; i < mRecordThreads.size(); i++) { 2263 sp<RecordThread> t = mRecordThreads.valueAt(i); 2264 if (t == thread) { 2265 continue; 2266 } 2267 if (t->hasAudioSession(chain->sessionId()) != 0) { 2268 Mutex::Autolock _l(t->mLock); 2269 ALOGV("closeInput() found thread %d for effect session %d", 2270 t->id(), chain->sessionId()); 2271 t->addEffectChain_l(chain); 2272 break; 2273 } 2274 } 2275 // put the chain aside if we could not find a record thread with the same session id. 2276 if (i == mRecordThreads.size()) { 2277 putOrphanEffectChain_l(chain); 2278 } 2279 } 2280 const sp<AudioIoDescriptor> ioDesc = new AudioIoDescriptor(); 2281 ioDesc->mIoHandle = input; 2282 ioConfigChanged(AUDIO_INPUT_CLOSED, ioDesc); 2283 mRecordThreads.removeItem(input); 2284 } 2285 // FIXME: calling thread->exit() without mLock held should not be needed anymore now that 2286 // we have a different lock for notification client 2287 closeInputFinish(thread); 2288 return NO_ERROR; 2289 } 2290 2291 void AudioFlinger::closeInputFinish(sp<RecordThread> thread) 2292 { 2293 thread->exit(); 2294 AudioStreamIn *in = thread->clearInput(); 2295 ALOG_ASSERT(in != NULL, "in shouldn't be NULL"); 2296 // from now on thread->mInput is NULL 2297 in->hwDev()->close_input_stream(in->hwDev(), in->stream); 2298 delete in; 2299 } 2300 2301 void AudioFlinger::closeInputInternal_l(sp<RecordThread> thread) 2302 { 2303 mRecordThreads.removeItem(thread->mId); 2304 closeInputFinish(thread); 2305 } 2306 2307 status_t AudioFlinger::invalidateStream(audio_stream_type_t stream) 2308 { 2309 Mutex::Autolock _l(mLock); 2310 ALOGV("invalidateStream() stream %d", stream); 2311 2312 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2313 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 2314 thread->invalidateTracks(stream); 2315 } 2316 2317 return NO_ERROR; 2318 } 2319 2320 2321 audio_unique_id_t AudioFlinger::newAudioUniqueId(audio_unique_id_use_t use) 2322 { 2323 // This is a binder API, so a malicious client could pass in a bad parameter. 2324 // Check for that before calling the internal API nextUniqueId(). 2325 if ((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX) { 2326 ALOGE("newAudioUniqueId invalid use %d", use); 2327 return AUDIO_UNIQUE_ID_ALLOCATE; 2328 } 2329 return nextUniqueId(use); 2330 } 2331 2332 void AudioFlinger::acquireAudioSessionId(audio_session_t audioSession, pid_t pid) 2333 { 2334 Mutex::Autolock _l(mLock); 2335 pid_t caller = IPCThreadState::self()->getCallingPid(); 2336 ALOGV("acquiring %d from %d, for %d", audioSession, caller, pid); 2337 if (pid != -1 && (caller == getpid_cached)) { 2338 caller = pid; 2339 } 2340 2341 { 2342 Mutex::Autolock _cl(mClientLock); 2343 // Ignore requests received from processes not known as notification client. The request 2344 // is likely proxied by mediaserver (e.g CameraService) and releaseAudioSessionId() can be 2345 // called from a different pid leaving a stale session reference. Also we don't know how 2346 // to clear this reference if the client process dies. 2347 if (mNotificationClients.indexOfKey(caller) < 0) { 2348 ALOGW("acquireAudioSessionId() unknown client %d for session %d", caller, audioSession); 2349 return; 2350 } 2351 } 2352 2353 size_t num = mAudioSessionRefs.size(); 2354 for (size_t i = 0; i< num; i++) { 2355 AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i); 2356 if (ref->mSessionid == audioSession && ref->mPid == caller) { 2357 ref->mCnt++; 2358 ALOGV(" incremented refcount to %d", ref->mCnt); 2359 return; 2360 } 2361 } 2362 mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller)); 2363 ALOGV(" added new entry for %d", audioSession); 2364 } 2365 2366 void AudioFlinger::releaseAudioSessionId(audio_session_t audioSession, pid_t pid) 2367 { 2368 Mutex::Autolock _l(mLock); 2369 pid_t caller = IPCThreadState::self()->getCallingPid(); 2370 ALOGV("releasing %d from %d for %d", audioSession, caller, pid); 2371 if (pid != -1 && (caller == getpid_cached)) { 2372 caller = pid; 2373 } 2374 size_t num = mAudioSessionRefs.size(); 2375 for (size_t i = 0; i< num; i++) { 2376 AudioSessionRef *ref = mAudioSessionRefs.itemAt(i); 2377 if (ref->mSessionid == audioSession && ref->mPid == caller) { 2378 ref->mCnt--; 2379 ALOGV(" decremented refcount to %d", ref->mCnt); 2380 if (ref->mCnt == 0) { 2381 mAudioSessionRefs.removeAt(i); 2382 delete ref; 2383 purgeStaleEffects_l(); 2384 } 2385 return; 2386 } 2387 } 2388 // If the caller is mediaserver it is likely that the session being released was acquired 2389 // on behalf of a process not in notification clients and we ignore the warning. 2390 ALOGW_IF(caller != getpid_cached, "session id %d not found for pid %d", audioSession, caller); 2391 } 2392 2393 void AudioFlinger::purgeStaleEffects_l() { 2394 2395 ALOGV("purging stale effects"); 2396 2397 Vector< sp<EffectChain> > chains; 2398 2399 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2400 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 2401 for (size_t j = 0; j < t->mEffectChains.size(); j++) { 2402 sp<EffectChain> ec = t->mEffectChains[j]; 2403 if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) { 2404 chains.push(ec); 2405 } 2406 } 2407 } 2408 for (size_t i = 0; i < mRecordThreads.size(); i++) { 2409 sp<RecordThread> t = mRecordThreads.valueAt(i); 2410 for (size_t j = 0; j < t->mEffectChains.size(); j++) { 2411 sp<EffectChain> ec = t->mEffectChains[j]; 2412 chains.push(ec); 2413 } 2414 } 2415 2416 for (size_t i = 0; i < chains.size(); i++) { 2417 sp<EffectChain> ec = chains[i]; 2418 int sessionid = ec->sessionId(); 2419 sp<ThreadBase> t = ec->mThread.promote(); 2420 if (t == 0) { 2421 continue; 2422 } 2423 size_t numsessionrefs = mAudioSessionRefs.size(); 2424 bool found = false; 2425 for (size_t k = 0; k < numsessionrefs; k++) { 2426 AudioSessionRef *ref = mAudioSessionRefs.itemAt(k); 2427 if (ref->mSessionid == sessionid) { 2428 ALOGV(" session %d still exists for %d with %d refs", 2429 sessionid, ref->mPid, ref->mCnt); 2430 found = true; 2431 break; 2432 } 2433 } 2434 if (!found) { 2435 Mutex::Autolock _l(t->mLock); 2436 // remove all effects from the chain 2437 while (ec->mEffects.size()) { 2438 sp<EffectModule> effect = ec->mEffects[0]; 2439 effect->unPin(); 2440 t->removeEffect_l(effect); 2441 if (effect->purgeHandles()) { 2442 t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId()); 2443 } 2444 AudioSystem::unregisterEffect(effect->id()); 2445 } 2446 } 2447 } 2448 return; 2449 } 2450 2451 // checkThread_l() must be called with AudioFlinger::mLock held 2452 AudioFlinger::ThreadBase *AudioFlinger::checkThread_l(audio_io_handle_t ioHandle) const 2453 { 2454 ThreadBase *thread = NULL; 2455 switch (audio_unique_id_get_use(ioHandle)) { 2456 case AUDIO_UNIQUE_ID_USE_OUTPUT: 2457 thread = checkPlaybackThread_l(ioHandle); 2458 break; 2459 case AUDIO_UNIQUE_ID_USE_INPUT: 2460 thread = checkRecordThread_l(ioHandle); 2461 break; 2462 default: 2463 break; 2464 } 2465 return thread; 2466 } 2467 2468 // checkPlaybackThread_l() must be called with AudioFlinger::mLock held 2469 AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const 2470 { 2471 return mPlaybackThreads.valueFor(output).get(); 2472 } 2473 2474 // checkMixerThread_l() must be called with AudioFlinger::mLock held 2475 AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const 2476 { 2477 PlaybackThread *thread = checkPlaybackThread_l(output); 2478 return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL; 2479 } 2480 2481 // checkRecordThread_l() must be called with AudioFlinger::mLock held 2482 AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const 2483 { 2484 return mRecordThreads.valueFor(input).get(); 2485 } 2486 2487 audio_unique_id_t AudioFlinger::nextUniqueId(audio_unique_id_use_t use) 2488 { 2489 // This is the internal API, so it is OK to assert on bad parameter. 2490 LOG_ALWAYS_FATAL_IF((unsigned) use >= (unsigned) AUDIO_UNIQUE_ID_USE_MAX); 2491 const int maxRetries = use == AUDIO_UNIQUE_ID_USE_SESSION ? 3 : 1; 2492 for (int retry = 0; retry < maxRetries; retry++) { 2493 // The cast allows wraparound from max positive to min negative instead of abort 2494 uint32_t base = (uint32_t) atomic_fetch_add_explicit(&mNextUniqueIds[use], 2495 (uint_fast32_t) AUDIO_UNIQUE_ID_USE_MAX, memory_order_acq_rel); 2496 ALOG_ASSERT(audio_unique_id_get_use(base) == AUDIO_UNIQUE_ID_USE_UNSPECIFIED); 2497 // allow wrap by skipping 0 and -1 for session ids 2498 if (!(base == 0 || base == (~0u & ~AUDIO_UNIQUE_ID_USE_MASK))) { 2499 ALOGW_IF(retry != 0, "unique ID overflow for use %d", use); 2500 return (audio_unique_id_t) (base | use); 2501 } 2502 } 2503 // We have no way of recovering from wraparound 2504 LOG_ALWAYS_FATAL("unique ID overflow for use %d", use); 2505 // TODO Use a floor after wraparound. This may need a mutex. 2506 } 2507 2508 AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const 2509 { 2510 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2511 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 2512 if(thread->isDuplicating()) { 2513 continue; 2514 } 2515 AudioStreamOut *output = thread->getOutput(); 2516 if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) { 2517 return thread; 2518 } 2519 } 2520 return NULL; 2521 } 2522 2523 audio_devices_t AudioFlinger::primaryOutputDevice_l() const 2524 { 2525 PlaybackThread *thread = primaryPlaybackThread_l(); 2526 2527 if (thread == NULL) { 2528 return 0; 2529 } 2530 2531 return thread->outDevice(); 2532 } 2533 2534 AudioFlinger::PlaybackThread *AudioFlinger::fastPlaybackThread_l() const 2535 { 2536 size_t minFrameCount = 0; 2537 PlaybackThread *minThread = NULL; 2538 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2539 PlaybackThread *thread = mPlaybackThreads.valueAt(i).get(); 2540 if (!thread->isDuplicating()) { 2541 size_t frameCount = thread->frameCountHAL(); 2542 if (frameCount != 0 && (minFrameCount == 0 || frameCount < minFrameCount || 2543 (frameCount == minFrameCount && thread->hasFastMixer() && 2544 /*minThread != NULL &&*/ !minThread->hasFastMixer()))) { 2545 minFrameCount = frameCount; 2546 minThread = thread; 2547 } 2548 } 2549 } 2550 return minThread; 2551 } 2552 2553 sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type, 2554 audio_session_t triggerSession, 2555 audio_session_t listenerSession, 2556 sync_event_callback_t callBack, 2557 wp<RefBase> cookie) 2558 { 2559 Mutex::Autolock _l(mLock); 2560 2561 sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie); 2562 status_t playStatus = NAME_NOT_FOUND; 2563 status_t recStatus = NAME_NOT_FOUND; 2564 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2565 playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event); 2566 if (playStatus == NO_ERROR) { 2567 return event; 2568 } 2569 } 2570 for (size_t i = 0; i < mRecordThreads.size(); i++) { 2571 recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event); 2572 if (recStatus == NO_ERROR) { 2573 return event; 2574 } 2575 } 2576 if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) { 2577 mPendingSyncEvents.add(event); 2578 } else { 2579 ALOGV("createSyncEvent() invalid event %d", event->type()); 2580 event.clear(); 2581 } 2582 return event; 2583 } 2584 2585 // ---------------------------------------------------------------------------- 2586 // Effect management 2587 // ---------------------------------------------------------------------------- 2588 2589 2590 status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const 2591 { 2592 Mutex::Autolock _l(mLock); 2593 return EffectQueryNumberEffects(numEffects); 2594 } 2595 2596 status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const 2597 { 2598 Mutex::Autolock _l(mLock); 2599 return EffectQueryEffect(index, descriptor); 2600 } 2601 2602 status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid, 2603 effect_descriptor_t *descriptor) const 2604 { 2605 Mutex::Autolock _l(mLock); 2606 return EffectGetDescriptor(pUuid, descriptor); 2607 } 2608 2609 2610 sp<IEffect> AudioFlinger::createEffect( 2611 effect_descriptor_t *pDesc, 2612 const sp<IEffectClient>& effectClient, 2613 int32_t priority, 2614 audio_io_handle_t io, 2615 audio_session_t sessionId, 2616 const String16& opPackageName, 2617 status_t *status, 2618 int *id, 2619 int *enabled) 2620 { 2621 status_t lStatus = NO_ERROR; 2622 sp<EffectHandle> handle; 2623 effect_descriptor_t desc; 2624 2625 pid_t pid = IPCThreadState::self()->getCallingPid(); 2626 ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d", 2627 pid, effectClient.get(), priority, sessionId, io); 2628 2629 if (pDesc == NULL) { 2630 lStatus = BAD_VALUE; 2631 goto Exit; 2632 } 2633 2634 // check audio settings permission for global effects 2635 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) { 2636 lStatus = PERMISSION_DENIED; 2637 goto Exit; 2638 } 2639 2640 // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects 2641 // that can only be created by audio policy manager (running in same process) 2642 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid_cached != pid) { 2643 lStatus = PERMISSION_DENIED; 2644 goto Exit; 2645 } 2646 2647 { 2648 if (!EffectIsNullUuid(&pDesc->uuid)) { 2649 // if uuid is specified, request effect descriptor 2650 lStatus = EffectGetDescriptor(&pDesc->uuid, &desc); 2651 if (lStatus < 0) { 2652 ALOGW("createEffect() error %d from EffectGetDescriptor", lStatus); 2653 goto Exit; 2654 } 2655 } else { 2656 // if uuid is not specified, look for an available implementation 2657 // of the required type in effect factory 2658 if (EffectIsNullUuid(&pDesc->type)) { 2659 ALOGW("createEffect() no effect type"); 2660 lStatus = BAD_VALUE; 2661 goto Exit; 2662 } 2663 uint32_t numEffects = 0; 2664 effect_descriptor_t d; 2665 d.flags = 0; // prevent compiler warning 2666 bool found = false; 2667 2668 lStatus = EffectQueryNumberEffects(&numEffects); 2669 if (lStatus < 0) { 2670 ALOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus); 2671 goto Exit; 2672 } 2673 for (uint32_t i = 0; i < numEffects; i++) { 2674 lStatus = EffectQueryEffect(i, &desc); 2675 if (lStatus < 0) { 2676 ALOGW("createEffect() error %d from EffectQueryEffect", lStatus); 2677 continue; 2678 } 2679 if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) { 2680 // If matching type found save effect descriptor. If the session is 2681 // 0 and the effect is not auxiliary, continue enumeration in case 2682 // an auxiliary version of this effect type is available 2683 found = true; 2684 d = desc; 2685 if (sessionId != AUDIO_SESSION_OUTPUT_MIX || 2686 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 2687 break; 2688 } 2689 } 2690 } 2691 if (!found) { 2692 lStatus = BAD_VALUE; 2693 ALOGW("createEffect() effect not found"); 2694 goto Exit; 2695 } 2696 // For same effect type, chose auxiliary version over insert version if 2697 // connect to output mix (Compliance to OpenSL ES) 2698 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && 2699 (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) { 2700 desc = d; 2701 } 2702 } 2703 2704 // Do not allow auxiliary effects on a session different from 0 (output mix) 2705 if (sessionId != AUDIO_SESSION_OUTPUT_MIX && 2706 (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { 2707 lStatus = INVALID_OPERATION; 2708 goto Exit; 2709 } 2710 2711 // check recording permission for visualizer 2712 if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) && 2713 !recordingAllowed(opPackageName, pid, IPCThreadState::self()->getCallingUid())) { 2714 lStatus = PERMISSION_DENIED; 2715 goto Exit; 2716 } 2717 2718 // return effect descriptor 2719 *pDesc = desc; 2720 if (io == AUDIO_IO_HANDLE_NONE && sessionId == AUDIO_SESSION_OUTPUT_MIX) { 2721 // if the output returned by getOutputForEffect() is removed before we lock the 2722 // mutex below, the call to checkPlaybackThread_l(io) below will detect it 2723 // and we will exit safely 2724 io = AudioSystem::getOutputForEffect(&desc); 2725 ALOGV("createEffect got output %d", io); 2726 } 2727 2728 Mutex::Autolock _l(mLock); 2729 2730 // If output is not specified try to find a matching audio session ID in one of the 2731 // output threads. 2732 // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX 2733 // because of code checking output when entering the function. 2734 // Note: io is never 0 when creating an effect on an input 2735 if (io == AUDIO_IO_HANDLE_NONE) { 2736 if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) { 2737 // output must be specified by AudioPolicyManager when using session 2738 // AUDIO_SESSION_OUTPUT_STAGE 2739 lStatus = BAD_VALUE; 2740 goto Exit; 2741 } 2742 // look for the thread where the specified audio session is present 2743 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2744 if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) { 2745 io = mPlaybackThreads.keyAt(i); 2746 break; 2747 } 2748 } 2749 if (io == 0) { 2750 for (size_t i = 0; i < mRecordThreads.size(); i++) { 2751 if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) { 2752 io = mRecordThreads.keyAt(i); 2753 break; 2754 } 2755 } 2756 } 2757 // If no output thread contains the requested session ID, default to 2758 // first output. The effect chain will be moved to the correct output 2759 // thread when a track with the same session ID is created 2760 if (io == AUDIO_IO_HANDLE_NONE && mPlaybackThreads.size() > 0) { 2761 io = mPlaybackThreads.keyAt(0); 2762 } 2763 ALOGV("createEffect() got io %d for effect %s", io, desc.name); 2764 } 2765 ThreadBase *thread = checkRecordThread_l(io); 2766 if (thread == NULL) { 2767 thread = checkPlaybackThread_l(io); 2768 if (thread == NULL) { 2769 ALOGE("createEffect() unknown output thread"); 2770 lStatus = BAD_VALUE; 2771 goto Exit; 2772 } 2773 } else { 2774 // Check if one effect chain was awaiting for an effect to be created on this 2775 // session and used it instead of creating a new one. 2776 sp<EffectChain> chain = getOrphanEffectChain_l(sessionId); 2777 if (chain != 0) { 2778 Mutex::Autolock _l(thread->mLock); 2779 thread->addEffectChain_l(chain); 2780 } 2781 } 2782 2783 sp<Client> client = registerPid(pid); 2784 2785 // create effect on selected output thread 2786 handle = thread->createEffect_l(client, effectClient, priority, sessionId, 2787 &desc, enabled, &lStatus); 2788 if (handle != 0 && id != NULL) { 2789 *id = handle->id(); 2790 } 2791 if (handle == 0) { 2792 // remove local strong reference to Client with mClientLock held 2793 Mutex::Autolock _cl(mClientLock); 2794 client.clear(); 2795 } 2796 } 2797 2798 Exit: 2799 *status = lStatus; 2800 return handle; 2801 } 2802 2803 status_t AudioFlinger::moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput, 2804 audio_io_handle_t dstOutput) 2805 { 2806 ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d", 2807 sessionId, srcOutput, dstOutput); 2808 Mutex::Autolock _l(mLock); 2809 if (srcOutput == dstOutput) { 2810 ALOGW("moveEffects() same dst and src outputs %d", dstOutput); 2811 return NO_ERROR; 2812 } 2813 PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput); 2814 if (srcThread == NULL) { 2815 ALOGW("moveEffects() bad srcOutput %d", srcOutput); 2816 return BAD_VALUE; 2817 } 2818 PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput); 2819 if (dstThread == NULL) { 2820 ALOGW("moveEffects() bad dstOutput %d", dstOutput); 2821 return BAD_VALUE; 2822 } 2823 2824 Mutex::Autolock _dl(dstThread->mLock); 2825 Mutex::Autolock _sl(srcThread->mLock); 2826 return moveEffectChain_l(sessionId, srcThread, dstThread, false); 2827 } 2828 2829 // moveEffectChain_l must be called with both srcThread and dstThread mLocks held 2830 status_t AudioFlinger::moveEffectChain_l(audio_session_t sessionId, 2831 AudioFlinger::PlaybackThread *srcThread, 2832 AudioFlinger::PlaybackThread *dstThread, 2833 bool reRegister) 2834 { 2835 ALOGV("moveEffectChain_l() session %d from thread %p to thread %p", 2836 sessionId, srcThread, dstThread); 2837 2838 sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId); 2839 if (chain == 0) { 2840 ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p", 2841 sessionId, srcThread); 2842 return INVALID_OPERATION; 2843 } 2844 2845 // Check whether the destination thread and all effects in the chain are compatible 2846 if (!chain->isCompatibleWithThread_l(dstThread)) { 2847 ALOGW("moveEffectChain_l() effect chain failed because" 2848 " destination thread %p is not compatible with effects in the chain", 2849 dstThread); 2850 return INVALID_OPERATION; 2851 } 2852 2853 // remove chain first. This is useful only if reconfiguring effect chain on same output thread, 2854 // so that a new chain is created with correct parameters when first effect is added. This is 2855 // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is 2856 // removed. 2857 srcThread->removeEffectChain_l(chain); 2858 2859 // transfer all effects one by one so that new effect chain is created on new thread with 2860 // correct buffer sizes and audio parameters and effect engines reconfigured accordingly 2861 sp<EffectChain> dstChain; 2862 uint32_t strategy = 0; // prevent compiler warning 2863 sp<EffectModule> effect = chain->getEffectFromId_l(0); 2864 Vector< sp<EffectModule> > removed; 2865 status_t status = NO_ERROR; 2866 while (effect != 0) { 2867 srcThread->removeEffect_l(effect); 2868 removed.add(effect); 2869 status = dstThread->addEffect_l(effect); 2870 if (status != NO_ERROR) { 2871 break; 2872 } 2873 // removeEffect_l() has stopped the effect if it was active so it must be restarted 2874 if (effect->state() == EffectModule::ACTIVE || 2875 effect->state() == EffectModule::STOPPING) { 2876 effect->start(); 2877 } 2878 // if the move request is not received from audio policy manager, the effect must be 2879 // re-registered with the new strategy and output 2880 if (dstChain == 0) { 2881 dstChain = effect->chain().promote(); 2882 if (dstChain == 0) { 2883 ALOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get()); 2884 status = NO_INIT; 2885 break; 2886 } 2887 strategy = dstChain->strategy(); 2888 } 2889 if (reRegister) { 2890 AudioSystem::unregisterEffect(effect->id()); 2891 AudioSystem::registerEffect(&effect->desc(), 2892 dstThread->id(), 2893 strategy, 2894 sessionId, 2895 effect->id()); 2896 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled()); 2897 } 2898 effect = chain->getEffectFromId_l(0); 2899 } 2900 2901 if (status != NO_ERROR) { 2902 for (size_t i = 0; i < removed.size(); i++) { 2903 srcThread->addEffect_l(removed[i]); 2904 if (dstChain != 0 && reRegister) { 2905 AudioSystem::unregisterEffect(removed[i]->id()); 2906 AudioSystem::registerEffect(&removed[i]->desc(), 2907 srcThread->id(), 2908 strategy, 2909 sessionId, 2910 removed[i]->id()); 2911 AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled()); 2912 } 2913 } 2914 } 2915 2916 return status; 2917 } 2918 2919 bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l() 2920 { 2921 if (mGlobalEffectEnableTime != 0 && 2922 ((systemTime() - mGlobalEffectEnableTime) < kMinGlobalEffectEnabletimeNs)) { 2923 return true; 2924 } 2925 2926 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2927 sp<EffectChain> ec = 2928 mPlaybackThreads.valueAt(i)->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); 2929 if (ec != 0 && ec->isNonOffloadableEnabled()) { 2930 return true; 2931 } 2932 } 2933 return false; 2934 } 2935 2936 void AudioFlinger::onNonOffloadableGlobalEffectEnable() 2937 { 2938 Mutex::Autolock _l(mLock); 2939 2940 mGlobalEffectEnableTime = systemTime(); 2941 2942 for (size_t i = 0; i < mPlaybackThreads.size(); i++) { 2943 sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); 2944 if (t->mType == ThreadBase::OFFLOAD) { 2945 t->invalidateTracks(AUDIO_STREAM_MUSIC); 2946 } 2947 } 2948 2949 } 2950 2951 status_t AudioFlinger::putOrphanEffectChain_l(const sp<AudioFlinger::EffectChain>& chain) 2952 { 2953 audio_session_t session = chain->sessionId(); 2954 ssize_t index = mOrphanEffectChains.indexOfKey(session); 2955 ALOGV("putOrphanEffectChain_l session %d index %zd", session, index); 2956 if (index >= 0) { 2957 ALOGW("putOrphanEffectChain_l chain for session %d already present", session); 2958 return ALREADY_EXISTS; 2959 } 2960 mOrphanEffectChains.add(session, chain); 2961 return NO_ERROR; 2962 } 2963 2964 sp<AudioFlinger::EffectChain> AudioFlinger::getOrphanEffectChain_l(audio_session_t session) 2965 { 2966 sp<EffectChain> chain; 2967 ssize_t index = mOrphanEffectChains.indexOfKey(session); 2968 ALOGV("getOrphanEffectChain_l session %d index %zd", session, index); 2969 if (index >= 0) { 2970 chain = mOrphanEffectChains.valueAt(index); 2971 mOrphanEffectChains.removeItemsAt(index); 2972 } 2973 return chain; 2974 } 2975 2976 bool AudioFlinger::updateOrphanEffectChains(const sp<AudioFlinger::EffectModule>& effect) 2977 { 2978 Mutex::Autolock _l(mLock); 2979 audio_session_t session = effect->sessionId(); 2980 ssize_t index = mOrphanEffectChains.indexOfKey(session); 2981 ALOGV("updateOrphanEffectChains session %d index %zd", session, index); 2982 if (index >= 0) { 2983 sp<EffectChain> chain = mOrphanEffectChains.valueAt(index); 2984 if (chain->removeEffect_l(effect) == 0) { 2985 ALOGV("updateOrphanEffectChains removing effect chain at index %zd", index); 2986 mOrphanEffectChains.removeItemsAt(index); 2987 } 2988 return true; 2989 } 2990 return false; 2991 } 2992 2993 2994 struct Entry { 2995 #define TEE_MAX_FILENAME 32 // %Y%m%d%H%M%S_%d.wav = 4+2+2+2+2+2+1+1+4+1 = 21 2996 char mFileName[TEE_MAX_FILENAME]; 2997 }; 2998 2999 int comparEntry(const void *p1, const void *p2) 3000 { 3001 return strcmp(((const Entry *) p1)->mFileName, ((const Entry *) p2)->mFileName); 3002 } 3003 3004 #ifdef TEE_SINK 3005 void AudioFlinger::dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id) 3006 { 3007 NBAIO_Source *teeSource = source.get(); 3008 if (teeSource != NULL) { 3009 // .wav rotation 3010 // There is a benign race condition if 2 threads call this simultaneously. 3011 // They would both traverse the directory, but the result would simply be 3012 // failures at unlink() which are ignored. It's also unlikely since 3013 // normally dumpsys is only done by bugreport or from the command line. 3014 char teePath[32+256]; 3015 strcpy(teePath, "/data/misc/audioserver"); 3016 size_t teePathLen = strlen(teePath); 3017 DIR *dir = opendir(teePath); 3018 teePath[teePathLen++] = '/'; 3019 if (dir != NULL) { 3020 #define TEE_MAX_SORT 20 // number of entries to sort 3021 #define TEE_MAX_KEEP 10 // number of entries to keep 3022 struct Entry entries[TEE_MAX_SORT]; 3023 size_t entryCount = 0; 3024 while (entryCount < TEE_MAX_SORT) { 3025 struct dirent de; 3026 struct dirent *result = NULL; 3027 int rc = readdir_r(dir, &de, &result); 3028 if (rc != 0) { 3029 ALOGW("readdir_r failed %d", rc); 3030 break; 3031 } 3032 if (result == NULL) { 3033 break; 3034 } 3035 if (result != &de) { 3036 ALOGW("readdir_r returned unexpected result %p != %p", result, &de); 3037 break; 3038 } 3039 // ignore non .wav file entries 3040 size_t nameLen = strlen(de.d_name); 3041 if (nameLen <= 4 || nameLen >= TEE_MAX_FILENAME || 3042 strcmp(&de.d_name[nameLen - 4], ".wav")) { 3043 continue; 3044 } 3045 strcpy(entries[entryCount++].mFileName, de.d_name); 3046 } 3047 (void) closedir(dir); 3048 if (entryCount > TEE_MAX_KEEP) { 3049 qsort(entries, entryCount, sizeof(Entry), comparEntry); 3050 for (size_t i = 0; i < entryCount - TEE_MAX_KEEP; ++i) { 3051 strcpy(&teePath[teePathLen], entries[i].mFileName); 3052 (void) unlink(teePath); 3053 } 3054 } 3055 } else { 3056 if (fd >= 0) { 3057 dprintf(fd, "unable to rotate tees in %.*s: %s\n", (int) teePathLen, teePath, 3058 strerror(errno)); 3059 } 3060 } 3061 char teeTime[16]; 3062 struct timeval tv; 3063 gettimeofday(&tv, NULL); 3064 struct tm tm; 3065 localtime_r(&tv.tv_sec, &tm); 3066 strftime(teeTime, sizeof(teeTime), "%Y%m%d%H%M%S", &tm); 3067 snprintf(&teePath[teePathLen], sizeof(teePath) - teePathLen, "%s_%d.wav", teeTime, id); 3068 // if 2 dumpsys are done within 1 second, and rotation didn't work, then discard 2nd 3069 int teeFd = open(teePath, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, S_IRUSR | S_IWUSR); 3070 if (teeFd >= 0) { 3071 // FIXME use libsndfile 3072 char wavHeader[44]; 3073 memcpy(wavHeader, 3074 "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", 3075 sizeof(wavHeader)); 3076 NBAIO_Format format = teeSource->format(); 3077 unsigned channelCount = Format_channelCount(format); 3078 uint32_t sampleRate = Format_sampleRate(format); 3079 size_t frameSize = Format_frameSize(format); 3080 wavHeader[22] = channelCount; // number of channels 3081 wavHeader[24] = sampleRate; // sample rate 3082 wavHeader[25] = sampleRate >> 8; 3083 wavHeader[32] = frameSize; // block alignment 3084 wavHeader[33] = frameSize >> 8; 3085 write(teeFd, wavHeader, sizeof(wavHeader)); 3086 size_t total = 0; 3087 bool firstRead = true; 3088 #define TEE_SINK_READ 1024 // frames per I/O operation 3089 void *buffer = malloc(TEE_SINK_READ * frameSize); 3090 for (;;) { 3091 size_t count = TEE_SINK_READ; 3092 ssize_t actual = teeSource->read(buffer, count); 3093 bool wasFirstRead = firstRead; 3094 firstRead = false; 3095 if (actual <= 0) { 3096 if (actual == (ssize_t) OVERRUN && wasFirstRead) { 3097 continue; 3098 } 3099 break; 3100 } 3101 ALOG_ASSERT(actual <= (ssize_t)count); 3102 write(teeFd, buffer, actual * frameSize); 3103 total += actual; 3104 } 3105 free(buffer); 3106 lseek(teeFd, (off_t) 4, SEEK_SET); 3107 uint32_t temp = 44 + total * frameSize - 8; 3108 // FIXME not big-endian safe 3109 write(teeFd, &temp, sizeof(temp)); 3110 lseek(teeFd, (off_t) 40, SEEK_SET); 3111 temp = total * frameSize; 3112 // FIXME not big-endian safe 3113 write(teeFd, &temp, sizeof(temp)); 3114 close(teeFd); 3115 if (fd >= 0) { 3116 dprintf(fd, "tee copied to %s\n", teePath); 3117 } 3118 } else { 3119 if (fd >= 0) { 3120 dprintf(fd, "unable to create tee %s: %s\n", teePath, strerror(errno)); 3121 } 3122 } 3123 } 3124 } 3125 #endif 3126 3127 // ---------------------------------------------------------------------------- 3128 3129 status_t AudioFlinger::onTransact( 3130 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 3131 { 3132 return BnAudioFlinger::onTransact(code, data, reply, flags); 3133 } 3134 3135 } // namespace android 3136
