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 #ifndef ANDROID_AUDIO_FLINGER_H 19 #define ANDROID_AUDIO_FLINGER_H 20 21 #include "Configuration.h" 22 #include <atomic> 23 #include <mutex> 24 #include <chrono> 25 #include <deque> 26 #include <map> 27 #include <numeric> 28 #include <optional> 29 #include <set> 30 #include <string> 31 #include <vector> 32 #include <stdint.h> 33 #include <sys/types.h> 34 #include <limits.h> 35 36 #include <android/os/BnExternalVibrationController.h> 37 #include <android-base/macros.h> 38 39 #include <cutils/atomic.h> 40 #include <cutils/compiler.h> 41 #include <cutils/properties.h> 42 43 #include <media/IAudioFlinger.h> 44 #include <media/IAudioFlingerClient.h> 45 #include <media/IAudioTrack.h> 46 #include <media/AudioSystem.h> 47 #include <media/AudioTrack.h> 48 #include <media/MmapStreamInterface.h> 49 #include <media/MmapStreamCallback.h> 50 51 #include <utils/Errors.h> 52 #include <utils/threads.h> 53 #include <utils/SortedVector.h> 54 #include <utils/TypeHelpers.h> 55 #include <utils/Vector.h> 56 57 #include <binder/AppOpsManager.h> 58 #include <binder/BinderService.h> 59 #include <binder/IAppOpsCallback.h> 60 #include <binder/MemoryDealer.h> 61 62 #include <system/audio.h> 63 #include <system/audio_policy.h> 64 65 #include <media/audiohal/EffectBufferHalInterface.h> 66 #include <media/audiohal/StreamHalInterface.h> 67 #include <media/AudioBufferProvider.h> 68 #include <media/AudioContainers.h> 69 #include <media/AudioDeviceTypeAddr.h> 70 #include <media/AudioMixer.h> 71 #include <media/DeviceDescriptorBase.h> 72 #include <media/ExtendedAudioBufferProvider.h> 73 #include <media/LinearMap.h> 74 #include <media/VolumeShaper.h> 75 76 #include <audio_utils/clock.h> 77 #include <audio_utils/FdToString.h> 78 #include <audio_utils/SimpleLog.h> 79 #include <audio_utils/TimestampVerifier.h> 80 81 #include "FastCapture.h" 82 #include "FastMixer.h" 83 #include <media/nbaio/NBAIO.h> 84 #include "AudioWatchdog.h" 85 #include "AudioStreamOut.h" 86 #include "SpdifStreamOut.h" 87 #include "AudioHwDevice.h" 88 #include "NBAIO_Tee.h" 89 90 #include <powermanager/IPowerManager.h> 91 92 #include <media/nblog/NBLog.h> 93 #include <private/media/AudioEffectShared.h> 94 #include <private/media/AudioTrackShared.h> 95 96 #include <vibrator/ExternalVibration.h> 97 98 #include "android/media/BnAudioRecord.h" 99 100 namespace android { 101 102 class AudioMixer; 103 class AudioBuffer; 104 class AudioResampler; 105 class DeviceHalInterface; 106 class DevicesFactoryHalCallback; 107 class DevicesFactoryHalInterface; 108 class EffectsFactoryHalInterface; 109 class FastMixer; 110 class PassthruBufferProvider; 111 class RecordBufferConverter; 112 class ServerProxy; 113 114 // ---------------------------------------------------------------------------- 115 116 static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3); 117 118 #define INCLUDING_FROM_AUDIOFLINGER_H 119 120 class AudioFlinger : 121 public BinderService<AudioFlinger>, 122 public BnAudioFlinger 123 { 124 friend class BinderService<AudioFlinger>; // for AudioFlinger() 125 126 public: getServiceName()127 static const char* getServiceName() ANDROID_API { return "media.audio_flinger"; } 128 129 virtual status_t dump(int fd, const Vector<String16>& args); 130 131 // IAudioFlinger interface, in binder opcode order 132 virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input, 133 CreateTrackOutput& output, 134 status_t *status); 135 136 virtual sp<media::IAudioRecord> createRecord(const CreateRecordInput& input, 137 CreateRecordOutput& output, 138 status_t *status); 139 140 virtual uint32_t sampleRate(audio_io_handle_t ioHandle) const; 141 virtual audio_format_t format(audio_io_handle_t output) const; 142 virtual size_t frameCount(audio_io_handle_t ioHandle) const; 143 virtual size_t frameCountHAL(audio_io_handle_t ioHandle) const; 144 virtual uint32_t latency(audio_io_handle_t output) const; 145 146 virtual status_t setMasterVolume(float value); 147 virtual status_t setMasterMute(bool muted); 148 149 virtual float masterVolume() const; 150 virtual bool masterMute() const; 151 152 // Balance value must be within -1.f (left only) to 1.f (right only) inclusive. 153 status_t setMasterBalance(float balance) override; 154 status_t getMasterBalance(float *balance) const override; 155 156 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 157 audio_io_handle_t output); 158 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted); 159 160 virtual float streamVolume(audio_stream_type_t stream, 161 audio_io_handle_t output) const; 162 virtual bool streamMute(audio_stream_type_t stream) const; 163 164 virtual status_t setMode(audio_mode_t mode); 165 166 virtual status_t setMicMute(bool state); 167 virtual bool getMicMute() const; 168 169 virtual void setRecordSilenced(uid_t uid, bool silenced); 170 171 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs); 172 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const; 173 174 virtual void registerClient(const sp<IAudioFlingerClient>& client); 175 176 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 177 audio_channel_mask_t channelMask) const; 178 179 virtual status_t openOutput(audio_module_handle_t module, 180 audio_io_handle_t *output, 181 audio_config_t *config, 182 const sp<DeviceDescriptorBase>& device, 183 uint32_t *latencyMs, 184 audio_output_flags_t flags); 185 186 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 187 audio_io_handle_t output2); 188 189 virtual status_t closeOutput(audio_io_handle_t output); 190 191 virtual status_t suspendOutput(audio_io_handle_t output); 192 193 virtual status_t restoreOutput(audio_io_handle_t output); 194 195 virtual status_t openInput(audio_module_handle_t module, 196 audio_io_handle_t *input, 197 audio_config_t *config, 198 audio_devices_t *device, 199 const String8& address, 200 audio_source_t source, 201 audio_input_flags_t flags); 202 203 virtual status_t closeInput(audio_io_handle_t input); 204 205 virtual status_t invalidateStream(audio_stream_type_t stream); 206 207 virtual status_t setVoiceVolume(float volume); 208 209 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, 210 audio_io_handle_t output) const; 211 212 virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const; 213 214 // This is the binder API. For the internal API see nextUniqueId(). 215 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 216 217 virtual void acquireAudioSessionId(audio_session_t audioSession, pid_t pid); 218 219 virtual void releaseAudioSessionId(audio_session_t audioSession, pid_t pid); 220 221 virtual status_t queryNumberEffects(uint32_t *numEffects) const; 222 223 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const; 224 225 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid, 226 const effect_uuid_t *pTypeUuid, 227 uint32_t preferredTypeFlag, 228 effect_descriptor_t *descriptor) const; 229 230 virtual sp<IEffect> createEffect( 231 effect_descriptor_t *pDesc, 232 const sp<IEffectClient>& effectClient, 233 int32_t priority, 234 audio_io_handle_t io, 235 audio_session_t sessionId, 236 const AudioDeviceTypeAddr& device, 237 const String16& opPackageName, 238 pid_t pid, 239 status_t *status /*non-NULL*/, 240 int *id, 241 int *enabled); 242 243 virtual status_t moveEffects(audio_session_t sessionId, audio_io_handle_t srcOutput, 244 audio_io_handle_t dstOutput); 245 246 void setEffectSuspended(int effectId, 247 audio_session_t sessionId, 248 bool suspended) override; 249 250 virtual audio_module_handle_t loadHwModule(const char *name); 251 252 virtual uint32_t getPrimaryOutputSamplingRate(); 253 virtual size_t getPrimaryOutputFrameCount(); 254 255 virtual status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) override; 256 257 /* List available audio ports and their attributes */ 258 virtual status_t listAudioPorts(unsigned int *num_ports, 259 struct audio_port *ports); 260 261 /* Get attributes for a given audio port */ 262 virtual status_t getAudioPort(struct audio_port *port); 263 264 /* Create an audio patch between several source and sink ports */ 265 virtual status_t createAudioPatch(const struct audio_patch *patch, 266 audio_patch_handle_t *handle); 267 268 /* Release an audio patch */ 269 virtual status_t releaseAudioPatch(audio_patch_handle_t handle); 270 271 /* List existing audio patches */ 272 virtual status_t listAudioPatches(unsigned int *num_patches, 273 struct audio_patch *patches); 274 275 /* Set audio port configuration */ 276 virtual status_t setAudioPortConfig(const struct audio_port_config *config); 277 278 /* Get the HW synchronization source used for an audio session */ 279 virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId); 280 281 /* Indicate JAVA services are ready (scheduling, power management ...) */ 282 virtual status_t systemReady(); 283 284 virtual status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones); 285 286 virtual status_t setAudioHalPids(const std::vector<pid_t>& pids); 287 288 virtual status_t onTransact( 289 uint32_t code, 290 const Parcel& data, 291 Parcel* reply, 292 uint32_t flags); 293 294 // end of IAudioFlinger interface 295 296 sp<NBLog::Writer> newWriter_l(size_t size, const char *name); 297 void unregisterWriter(const sp<NBLog::Writer>& writer); 298 sp<EffectsFactoryHalInterface> getEffectsFactory(); 299 300 status_t openMmapStream(MmapStreamInterface::stream_direction_t direction, 301 const audio_attributes_t *attr, 302 audio_config_base_t *config, 303 const AudioClient& client, 304 audio_port_handle_t *deviceId, 305 audio_session_t *sessionId, 306 const sp<MmapStreamCallback>& callback, 307 sp<MmapStreamInterface>& interface, 308 audio_port_handle_t *handle); 309 310 static int onExternalVibrationStart(const sp<os::ExternalVibration>& externalVibration); 311 static void onExternalVibrationStop(const sp<os::ExternalVibration>& externalVibration); 312 313 status_t addEffectToHal(audio_port_handle_t deviceId, 314 audio_module_handle_t hwModuleId, sp<EffectHalInterface> effect); 315 status_t removeEffectFromHal(audio_port_handle_t deviceId, 316 audio_module_handle_t hwModuleId, sp<EffectHalInterface> effect); 317 318 private: 319 // FIXME The 400 is temporarily too high until a leak of writers in media.log is fixed. 320 static const size_t kLogMemorySize = 400 * 1024; 321 sp<MemoryDealer> mLogMemoryDealer; // == 0 when NBLog is disabled 322 // When a log writer is unregistered, it is done lazily so that media.log can continue to see it 323 // for as long as possible. The memory is only freed when it is needed for another log writer. 324 Vector< sp<NBLog::Writer> > mUnregisteredWriters; 325 Mutex mUnregisteredWritersLock; 326 327 public: 328 329 class SyncEvent; 330 331 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ; 332 333 class SyncEvent : public RefBase { 334 public: SyncEvent(AudioSystem::sync_event_t type,audio_session_t triggerSession,audio_session_t listenerSession,sync_event_callback_t callBack,wp<RefBase> cookie)335 SyncEvent(AudioSystem::sync_event_t type, 336 audio_session_t triggerSession, 337 audio_session_t listenerSession, 338 sync_event_callback_t callBack, 339 wp<RefBase> cookie) 340 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession), 341 mCallback(callBack), mCookie(cookie) 342 {} 343 ~SyncEvent()344 virtual ~SyncEvent() {} 345 trigger()346 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); } isCancelled()347 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); } cancel()348 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; } type()349 AudioSystem::sync_event_t type() const { return mType; } triggerSession()350 audio_session_t triggerSession() const { return mTriggerSession; } listenerSession()351 audio_session_t listenerSession() const { return mListenerSession; } cookie()352 wp<RefBase> cookie() const { return mCookie; } 353 354 private: 355 const AudioSystem::sync_event_t mType; 356 const audio_session_t mTriggerSession; 357 const audio_session_t mListenerSession; 358 sync_event_callback_t mCallback; 359 const wp<RefBase> mCookie; 360 mutable Mutex mLock; 361 }; 362 363 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type, 364 audio_session_t triggerSession, 365 audio_session_t listenerSession, 366 sync_event_callback_t callBack, 367 const wp<RefBase>& cookie); 368 btNrecIsOff()369 bool btNrecIsOff() const { return mBtNrecIsOff.load(); } 370 371 372 private: 373 getMode()374 audio_mode_t getMode() const { return mMode; } 375 376 AudioFlinger() ANDROID_API; 377 virtual ~AudioFlinger(); 378 379 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev initCheck()380 status_t initCheck() const { return mPrimaryHardwareDev == NULL ? 381 NO_INIT : NO_ERROR; } 382 383 // RefBase 384 virtual void onFirstRef(); 385 386 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module, 387 audio_devices_t deviceType); 388 389 // Set kEnableExtendedChannels to true to enable greater than stereo output 390 // for the MixerThread and device sink. Number of channels allowed is 391 // FCC_2 <= channels <= AudioMixer::MAX_NUM_CHANNELS. 392 static const bool kEnableExtendedChannels = true; 393 394 // Returns true if channel mask is permitted for the PCM sink in the MixerThread isValidPcmSinkChannelMask(audio_channel_mask_t channelMask)395 static inline bool isValidPcmSinkChannelMask(audio_channel_mask_t channelMask) { 396 switch (audio_channel_mask_get_representation(channelMask)) { 397 case AUDIO_CHANNEL_REPRESENTATION_POSITION: { 398 // Haptic channel mask is only applicable for channel position mask. 399 const uint32_t channelCount = audio_channel_count_from_out_mask( 400 channelMask & ~AUDIO_CHANNEL_HAPTIC_ALL); 401 const uint32_t maxChannelCount = kEnableExtendedChannels 402 ? AudioMixer::MAX_NUM_CHANNELS : FCC_2; 403 if (channelCount < FCC_2 // mono is not supported at this time 404 || channelCount > maxChannelCount) { 405 return false; 406 } 407 // check that channelMask is the "canonical" one we expect for the channelCount. 408 return audio_channel_position_mask_is_out_canonical(channelMask); 409 } 410 case AUDIO_CHANNEL_REPRESENTATION_INDEX: 411 if (kEnableExtendedChannels) { 412 const uint32_t channelCount = audio_channel_count_from_out_mask(channelMask); 413 if (channelCount >= FCC_2 // mono is not supported at this time 414 && channelCount <= AudioMixer::MAX_NUM_CHANNELS) { 415 return true; 416 } 417 } 418 return false; 419 default: 420 return false; 421 } 422 } 423 424 // Set kEnableExtendedPrecision to true to use extended precision in MixerThread 425 static const bool kEnableExtendedPrecision = true; 426 427 // Returns true if format is permitted for the PCM sink in the MixerThread isValidPcmSinkFormat(audio_format_t format)428 static inline bool isValidPcmSinkFormat(audio_format_t format) { 429 switch (format) { 430 case AUDIO_FORMAT_PCM_16_BIT: 431 return true; 432 case AUDIO_FORMAT_PCM_FLOAT: 433 case AUDIO_FORMAT_PCM_24_BIT_PACKED: 434 case AUDIO_FORMAT_PCM_32_BIT: 435 case AUDIO_FORMAT_PCM_8_24_BIT: 436 return kEnableExtendedPrecision; 437 default: 438 return false; 439 } 440 } 441 442 // standby delay for MIXER and DUPLICATING playback threads is read from property 443 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs 444 static nsecs_t mStandbyTimeInNsecs; 445 446 // incremented by 2 when screen state changes, bit 0 == 1 means "off" 447 // AudioFlinger::setParameters() updates, other threads read w/o lock 448 static uint32_t mScreenState; 449 450 // Internal dump utilities. 451 static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND; 452 static bool dumpTryLock(Mutex& mutex); 453 void dumpPermissionDenial(int fd, const Vector<String16>& args); 454 void dumpClients(int fd, const Vector<String16>& args); 455 void dumpInternals(int fd, const Vector<String16>& args); 456 457 SimpleLog mThreadLog{16}; // 16 Thread history limit 458 459 class ThreadBase; 460 void dumpToThreadLog_l(const sp<ThreadBase> &thread); 461 462 // --- Client --- 463 class Client : public RefBase { 464 public: 465 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid); 466 virtual ~Client(); 467 sp<MemoryDealer> heap() const; pid()468 pid_t pid() const { return mPid; } audioFlinger()469 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; } 470 471 private: 472 DISALLOW_COPY_AND_ASSIGN(Client); 473 474 const sp<AudioFlinger> mAudioFlinger; 475 sp<MemoryDealer> mMemoryDealer; 476 const pid_t mPid; 477 }; 478 479 // --- Notification Client --- 480 class NotificationClient : public IBinder::DeathRecipient { 481 public: 482 NotificationClient(const sp<AudioFlinger>& audioFlinger, 483 const sp<IAudioFlingerClient>& client, 484 pid_t pid); 485 virtual ~NotificationClient(); 486 audioFlingerClient()487 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; } 488 489 // IBinder::DeathRecipient 490 virtual void binderDied(const wp<IBinder>& who); 491 492 private: 493 DISALLOW_COPY_AND_ASSIGN(NotificationClient); 494 495 const sp<AudioFlinger> mAudioFlinger; 496 const pid_t mPid; 497 const sp<IAudioFlingerClient> mAudioFlingerClient; 498 }; 499 500 // --- MediaLogNotifier --- 501 // Thread in charge of notifying MediaLogService to start merging. 502 // Receives requests from AudioFlinger's binder activity. It is used to reduce the amount of 503 // binder calls to MediaLogService in case of bursts of AudioFlinger binder calls. 504 class MediaLogNotifier : public Thread { 505 public: 506 MediaLogNotifier(); 507 508 // Requests a MediaLogService notification. It's ignored if there has recently been another 509 void requestMerge(); 510 private: 511 // Every iteration blocks waiting for a request, then interacts with MediaLogService to 512 // start merging. 513 // As every MediaLogService binder call is expensive, once it gets a request it ignores the 514 // following ones for a period of time. 515 virtual bool threadLoop() override; 516 517 bool mPendingRequests; 518 519 // Mutex and condition variable around mPendingRequests' value 520 Mutex mMutex; 521 Condition mCond; 522 523 // Duration of the sleep period after a processed request 524 static const int kPostTriggerSleepPeriod = 1000000; 525 }; 526 527 const sp<MediaLogNotifier> mMediaLogNotifier; 528 529 // This is a helper that is called during incoming binder calls. 530 void requestLogMerge(); 531 532 class TrackHandle; 533 class RecordHandle; 534 class RecordThread; 535 class PlaybackThread; 536 class MixerThread; 537 class DirectOutputThread; 538 class OffloadThread; 539 class DuplicatingThread; 540 class AsyncCallbackThread; 541 class Track; 542 class RecordTrack; 543 class EffectBase; 544 class EffectModule; 545 class EffectHandle; 546 class EffectChain; 547 class DeviceEffectProxy; 548 class DeviceEffectManager; 549 class PatchPanel; 550 class DeviceEffectManagerCallback; 551 552 struct AudioStreamIn; 553 struct TeePatch; 554 using TeePatches = std::vector<TeePatch>; 555 556 557 struct stream_type_t { stream_type_tstream_type_t558 stream_type_t() 559 : volume(1.0f), 560 mute(false) 561 { 562 } 563 float volume; 564 bool mute; 565 }; 566 567 // Abstraction for the Audio Source for the RecordThread (HAL or PassthruPatchRecord). 568 struct Source 569 { 570 virtual ~Source() = default; 571 // The following methods have the same signatures as in StreamHalInterface. 572 virtual status_t read(void *buffer, size_t bytes, size_t *read) = 0; 573 virtual status_t getCapturePosition(int64_t *frames, int64_t *time) = 0; 574 virtual status_t standby() = 0; 575 }; 576 577 // --- PlaybackThread --- 578 #ifdef FLOAT_EFFECT_CHAIN 579 #define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_FLOAT 580 using effect_buffer_t = float; 581 #else 582 #define EFFECT_BUFFER_FORMAT AUDIO_FORMAT_PCM_16_BIT 583 using effect_buffer_t = int16_t; 584 #endif 585 586 #include "Threads.h" 587 588 #include "PatchPanel.h" 589 590 #include "Effects.h" 591 592 #include "DeviceEffectManager.h" 593 594 // Find io handle by session id. 595 // Preference is given to an io handle with a matching effect chain to session id. 596 // If none found, AUDIO_IO_HANDLE_NONE is returned. 597 template <typename T> findIoHandleBySessionId_l(audio_session_t sessionId,const T & threads)598 static audio_io_handle_t findIoHandleBySessionId_l( 599 audio_session_t sessionId, const T& threads) { 600 audio_io_handle_t io = AUDIO_IO_HANDLE_NONE; 601 602 for (size_t i = 0; i < threads.size(); i++) { 603 const uint32_t sessionType = threads.valueAt(i)->hasAudioSession(sessionId); 604 if (sessionType != 0) { 605 io = threads.keyAt(i); 606 if ((sessionType & AudioFlinger::ThreadBase::EFFECT_SESSION) != 0) { 607 break; // effect chain here. 608 } 609 } 610 } 611 return io; 612 } 613 614 // server side of the client's IAudioTrack 615 class TrackHandle : public android::BnAudioTrack { 616 public: 617 explicit TrackHandle(const sp<PlaybackThread::Track>& track); 618 virtual ~TrackHandle(); 619 virtual sp<IMemory> getCblk() const; 620 virtual status_t start(); 621 virtual void stop(); 622 virtual void flush(); 623 virtual void pause(); 624 virtual status_t attachAuxEffect(int effectId); 625 virtual status_t setParameters(const String8& keyValuePairs); 626 virtual status_t selectPresentation(int presentationId, int programId); 627 virtual media::VolumeShaper::Status applyVolumeShaper( 628 const sp<media::VolumeShaper::Configuration>& configuration, 629 const sp<media::VolumeShaper::Operation>& operation) override; 630 virtual sp<media::VolumeShaper::State> getVolumeShaperState(int id) override; 631 virtual status_t getTimestamp(AudioTimestamp& timestamp); 632 virtual void signal(); // signal playback thread for a change in control block 633 634 virtual status_t onTransact( 635 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 636 637 private: 638 const sp<PlaybackThread::Track> mTrack; 639 }; 640 641 // server side of the client's IAudioRecord 642 class RecordHandle : public android::media::BnAudioRecord { 643 public: 644 explicit RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack); 645 virtual ~RecordHandle(); 646 virtual binder::Status start(int /*AudioSystem::sync_event_t*/ event, 647 int /*audio_session_t*/ triggerSession); 648 virtual binder::Status stop(); 649 virtual binder::Status getActiveMicrophones( 650 std::vector<media::MicrophoneInfo>* activeMicrophones); 651 virtual binder::Status setPreferredMicrophoneDirection( 652 int /*audio_microphone_direction_t*/ direction); 653 virtual binder::Status setPreferredMicrophoneFieldDimension(float zoom); 654 655 private: 656 const sp<RecordThread::RecordTrack> mRecordTrack; 657 658 // for use from destructor 659 void stop_nonvirtual(); 660 }; 661 662 // Mmap stream control interface implementation. Each MmapThreadHandle controls one 663 // MmapPlaybackThread or MmapCaptureThread instance. 664 class MmapThreadHandle : public MmapStreamInterface { 665 public: 666 explicit MmapThreadHandle(const sp<MmapThread>& thread); 667 virtual ~MmapThreadHandle(); 668 669 // MmapStreamInterface virtuals 670 virtual status_t createMmapBuffer(int32_t minSizeFrames, 671 struct audio_mmap_buffer_info *info); 672 virtual status_t getMmapPosition(struct audio_mmap_position *position); 673 virtual status_t start(const AudioClient& client, 674 audio_port_handle_t *handle); 675 virtual status_t stop(audio_port_handle_t handle); 676 virtual status_t standby(); 677 678 private: 679 const sp<MmapThread> mThread; 680 }; 681 682 ThreadBase *checkThread_l(audio_io_handle_t ioHandle) const; 683 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const; 684 MixerThread *checkMixerThread_l(audio_io_handle_t output) const; 685 RecordThread *checkRecordThread_l(audio_io_handle_t input) const; 686 MmapThread *checkMmapThread_l(audio_io_handle_t io) const; 687 VolumeInterface *getVolumeInterface_l(audio_io_handle_t output) const; 688 Vector <VolumeInterface *> getAllVolumeInterfaces_l() const; 689 690 sp<ThreadBase> openInput_l(audio_module_handle_t module, 691 audio_io_handle_t *input, 692 audio_config_t *config, 693 audio_devices_t device, 694 const String8& address, 695 audio_source_t source, 696 audio_input_flags_t flags, 697 audio_devices_t outputDevice, 698 const String8& outputDeviceAddress); 699 sp<ThreadBase> openOutput_l(audio_module_handle_t module, 700 audio_io_handle_t *output, 701 audio_config_t *config, 702 audio_devices_t deviceType, 703 const String8& address, 704 audio_output_flags_t flags); 705 706 void closeOutputFinish(const sp<PlaybackThread>& thread); 707 void closeInputFinish(const sp<RecordThread>& thread); 708 709 // no range check, AudioFlinger::mLock held streamMute_l(audio_stream_type_t stream)710 bool streamMute_l(audio_stream_type_t stream) const 711 { return mStreamTypes[stream].mute; } 712 void ioConfigChanged(audio_io_config_event event, 713 const sp<AudioIoDescriptor>& ioDesc, 714 pid_t pid = 0); 715 716 // Allocate an audio_unique_id_t. 717 // Specific types are audio_io_handle_t, audio_session_t, effect ID (int), 718 // audio_module_handle_t, and audio_patch_handle_t. 719 // They all share the same ID space, but the namespaces are actually independent 720 // because there are separate KeyedVectors for each kind of ID. 721 // The return value is cast to the specific type depending on how the ID will be used. 722 // FIXME This API does not handle rollover to zero (for unsigned IDs), 723 // or from positive to negative (for signed IDs). 724 // Thus it may fail by returning an ID of the wrong sign, 725 // or by returning a non-unique ID. 726 // This is the internal API. For the binder API see newAudioUniqueId(). 727 audio_unique_id_t nextUniqueId(audio_unique_id_use_t use); 728 729 status_t moveEffectChain_l(audio_session_t sessionId, 730 PlaybackThread *srcThread, 731 PlaybackThread *dstThread); 732 733 status_t moveAuxEffectToIo(int EffectId, 734 const sp<PlaybackThread>& dstThread, 735 sp<PlaybackThread> *srcThread); 736 737 // return thread associated with primary hardware device, or NULL 738 PlaybackThread *primaryPlaybackThread_l() const; 739 DeviceTypeSet primaryOutputDevice_l() const; 740 741 // return the playback thread with smallest HAL buffer size, and prefer fast 742 PlaybackThread *fastPlaybackThread_l() const; 743 744 sp<ThreadBase> getEffectThread_l(audio_session_t sessionId, int effectId); 745 746 747 void removeClient_l(pid_t pid); 748 void removeNotificationClient(pid_t pid); 749 bool isNonOffloadableGlobalEffectEnabled_l(); 750 void onNonOffloadableGlobalEffectEnable(); 751 bool isSessionAcquired_l(audio_session_t audioSession); 752 753 // Store an effect chain to mOrphanEffectChains keyed vector. 754 // Called when a thread exits and effects are still attached to it. 755 // If effects are later created on the same session, they will reuse the same 756 // effect chain and same instances in the effect library. 757 // return ALREADY_EXISTS if a chain with the same session already exists in 758 // mOrphanEffectChains. Note that this should never happen as there is only one 759 // chain for a given session and it is attached to only one thread at a time. 760 status_t putOrphanEffectChain_l(const sp<EffectChain>& chain); 761 // Get an effect chain for the specified session in mOrphanEffectChains and remove 762 // it if found. Returns 0 if not found (this is the most common case). 763 sp<EffectChain> getOrphanEffectChain_l(audio_session_t session); 764 // Called when the last effect handle on an effect instance is removed. If this 765 // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated 766 // and removed from mOrphanEffectChains if it does not contain any effect. 767 // Return true if the effect was found in mOrphanEffectChains, false otherwise. 768 bool updateOrphanEffectChains(const sp<EffectModule>& effect); 769 770 std::vector< sp<EffectModule> > purgeStaleEffects_l(); 771 772 void broacastParametersToRecordThreads_l(const String8& keyValuePairs); 773 void updateOutDevicesForRecordThreads_l(const DeviceDescriptorBaseVector& devices); 774 void forwardParametersToDownstreamPatches_l( 775 audio_io_handle_t upStream, const String8& keyValuePairs, 776 std::function<bool(const sp<PlaybackThread>&)> useThread = nullptr); 777 778 // AudioStreamIn is immutable, so their fields are const. 779 // For emphasis, we could also make all pointers to them be "const *", 780 // but that would clutter the code unnecessarily. 781 782 struct AudioStreamIn : public Source { 783 AudioHwDevice* const audioHwDev; 784 sp<StreamInHalInterface> stream; 785 audio_input_flags_t flags; 786 hwDevAudioStreamIn787 sp<DeviceHalInterface> hwDev() const { return audioHwDev->hwDevice(); } 788 AudioStreamInAudioStreamIn789 AudioStreamIn(AudioHwDevice *dev, sp<StreamInHalInterface> in, audio_input_flags_t flags) : 790 audioHwDev(dev), stream(in), flags(flags) {} readAudioStreamIn791 status_t read(void *buffer, size_t bytes, size_t *read) override { 792 return stream->read(buffer, bytes, read); 793 } getCapturePositionAudioStreamIn794 status_t getCapturePosition(int64_t *frames, int64_t *time) override { 795 return stream->getCapturePosition(frames, time); 796 } standbyAudioStreamIn797 status_t standby() override { return stream->standby(); } 798 }; 799 800 struct TeePatch { 801 sp<RecordThread::PatchRecord> patchRecord; 802 sp<PlaybackThread::PatchTrack> patchTrack; 803 }; 804 805 // for mAudioSessionRefs only 806 struct AudioSessionRef { AudioSessionRefAudioSessionRef807 AudioSessionRef(audio_session_t sessionid, pid_t pid) : 808 mSessionid(sessionid), mPid(pid), mCnt(1) {} 809 const audio_session_t mSessionid; 810 const pid_t mPid; 811 int mCnt; 812 }; 813 814 mutable Mutex mLock; 815 // protects mClients and mNotificationClients. 816 // must be locked after mLock and ThreadBase::mLock if both must be locked 817 // avoids acquiring AudioFlinger::mLock from inside thread loop. 818 mutable Mutex mClientLock; 819 // protected by mClientLock 820 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client() 821 822 mutable Mutex mHardwareLock; 823 // NOTE: If both mLock and mHardwareLock mutexes must be held, 824 // always take mLock before mHardwareLock 825 826 // guarded by mHardwareLock 827 AudioHwDevice* mPrimaryHardwareDev; 828 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs; 829 830 // These two fields are immutable after onFirstRef(), so no lock needed to access 831 sp<DevicesFactoryHalInterface> mDevicesFactoryHal; 832 sp<DevicesFactoryHalCallback> mDevicesFactoryHalCallback; 833 834 // for dump, indicates which hardware operation is currently in progress (but not stream ops) 835 enum hardware_call_state { 836 AUDIO_HW_IDLE = 0, // no operation in progress 837 AUDIO_HW_INIT, // init_check 838 AUDIO_HW_OUTPUT_OPEN, // open_output_stream 839 AUDIO_HW_OUTPUT_CLOSE, // unused 840 AUDIO_HW_INPUT_OPEN, // unused 841 AUDIO_HW_INPUT_CLOSE, // unused 842 AUDIO_HW_STANDBY, // unused 843 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume 844 AUDIO_HW_GET_ROUTING, // unused 845 AUDIO_HW_SET_ROUTING, // unused 846 AUDIO_HW_GET_MODE, // unused 847 AUDIO_HW_SET_MODE, // set_mode 848 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute 849 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute 850 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume 851 AUDIO_HW_SET_PARAMETER, // set_parameters 852 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size 853 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume 854 AUDIO_HW_GET_PARAMETER, // get_parameters 855 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute 856 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute 857 AUDIO_HW_GET_MICROPHONES, // getMicrophones 858 }; 859 860 mutable hardware_call_state mHardwareStatus; // for dump only 861 862 863 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads; 864 stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; 865 866 // member variables below are protected by mLock 867 float mMasterVolume; 868 bool mMasterMute; 869 float mMasterBalance = 0.f; 870 // end of variables protected by mLock 871 872 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads; 873 874 // protected by mClientLock 875 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients; 876 877 // updated by atomic_fetch_add_explicit 878 volatile atomic_uint_fast32_t mNextUniqueIds[AUDIO_UNIQUE_ID_USE_MAX]; 879 880 audio_mode_t mMode; 881 std::atomic_bool mBtNrecIsOff; 882 883 // protected by mLock 884 Vector<AudioSessionRef*> mAudioSessionRefs; 885 886 float masterVolume_l() const; 887 float getMasterBalance_l() const; 888 bool masterMute_l() const; 889 audio_module_handle_t loadHwModule_l(const char *name); 890 891 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session 892 // to be created 893 894 // Effect chains without a valid thread 895 DefaultKeyedVector< audio_session_t , sp<EffectChain> > mOrphanEffectChains; 896 897 // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL 898 DefaultKeyedVector< audio_session_t , audio_hw_sync_t >mHwAvSyncIds; 899 900 // list of MMAP stream control threads. Those threads allow for wake lock, routing 901 // and volume control for activity on the associated MMAP stream at the HAL. 902 // Audio data transfer is directly handled by the client creating the MMAP stream 903 DefaultKeyedVector< audio_io_handle_t, sp<MmapThread> > mMmapThreads; 904 905 private: 906 sp<Client> registerPid(pid_t pid); // always returns non-0 907 908 // for use from destructor 909 status_t closeOutput_nonvirtual(audio_io_handle_t output); 910 void closeThreadInternal_l(const sp<PlaybackThread>& thread); 911 status_t closeInput_nonvirtual(audio_io_handle_t input); 912 void closeThreadInternal_l(const sp<RecordThread>& thread); 913 void setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId); 914 915 status_t checkStreamType(audio_stream_type_t stream) const; 916 917 void filterReservedParameters(String8& keyValuePairs, uid_t callingUid); 918 void logFilteredParameters(size_t originalKVPSize, const String8& originalKVPs, 919 size_t rejectedKVPSize, const String8& rejectedKVPs, 920 uid_t callingUid); 921 922 public: 923 // These methods read variables atomically without mLock, 924 // though the variables are updated with mLock. isLowRamDevice()925 bool isLowRamDevice() const { return mIsLowRamDevice; } 926 size_t getClientSharedHeapSize() const; 927 928 private: 929 std::atomic<bool> mIsLowRamDevice; 930 bool mIsDeviceTypeKnown; 931 int64_t mTotalMemory; 932 std::atomic<size_t> mClientSharedHeapSize; 933 static constexpr size_t kMinimumClientSharedHeapSizeBytes = 1024 * 1024; // 1MB 934 935 nsecs_t mGlobalEffectEnableTime; // when a global effect was last enabled 936 937 // protected by mLock 938 PatchPanel mPatchPanel; 939 sp<EffectsFactoryHalInterface> mEffectsFactoryHal; 940 941 DeviceEffectManager mDeviceEffectManager; 942 943 bool mSystemReady; 944 945 SimpleLog mRejectedSetParameterLog; 946 SimpleLog mAppSetParameterLog; 947 SimpleLog mSystemSetParameterLog; 948 }; 949 950 #undef INCLUDING_FROM_AUDIOFLINGER_H 951 952 std::string formatToString(audio_format_t format); 953 std::string inputFlagsToString(audio_input_flags_t flags); 954 std::string outputFlagsToString(audio_output_flags_t flags); 955 std::string devicesToString(audio_devices_t devices); 956 const char *sourceToString(audio_source_t source); 957 958 // ---------------------------------------------------------------------------- 959 960 } // namespace android 961 962 #endif // ANDROID_AUDIO_FLINGER_H 963