AudioFlinger.h revision e3aa659e9cee7df5c12a80d285cc29ab3b2cbb39
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 <stdint.h> 22#include <sys/types.h> 23#include <limits.h> 24 25#include <common_time/cc_helper.h> 26 27#include <media/IAudioFlinger.h> 28#include <media/IAudioFlingerClient.h> 29#include <media/IAudioTrack.h> 30#include <media/IAudioRecord.h> 31#include <media/AudioSystem.h> 32#include <media/AudioTrack.h> 33 34#include <utils/Atomic.h> 35#include <utils/Errors.h> 36#include <utils/threads.h> 37#include <utils/SortedVector.h> 38#include <utils/TypeHelpers.h> 39#include <utils/Vector.h> 40 41#include <binder/BinderService.h> 42#include <binder/MemoryDealer.h> 43 44#include <system/audio.h> 45#include <hardware/audio.h> 46#include <hardware/audio_policy.h> 47 48#include <media/AudioBufferProvider.h> 49#include <media/ExtendedAudioBufferProvider.h> 50#include "FastMixer.h" 51#include <media/nbaio/NBAIO.h> 52#include "AudioWatchdog.h" 53 54#include <powermanager/IPowerManager.h> 55 56namespace android { 57 58class audio_track_cblk_t; 59class effect_param_cblk_t; 60class AudioMixer; 61class AudioBuffer; 62class AudioResampler; 63class FastMixer; 64class ServerProxy; 65 66// ---------------------------------------------------------------------------- 67 68// AudioFlinger has a hard-coded upper limit of 2 channels for capture and playback. 69// There is support for > 2 channel tracks down-mixed to 2 channel output via a down-mix effect. 70// Adding full support for > 2 channel capture or playback would require more than simply changing 71// this #define. There is an independent hard-coded upper limit in AudioMixer; 72// removing that AudioMixer limit would be necessary but insufficient to support > 2 channels. 73// The macro FCC_2 highlights some (but not all) places where there is are 2-channel assumptions. 74// Search also for "2", "left", "right", "[0]", "[1]", ">> 16", "<< 16", etc. 75#define FCC_2 2 // FCC_2 = Fixed Channel Count 2 76 77static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3); 78 79#define MAX_GAIN 4096.0f 80#define MAX_GAIN_INT 0x1000 81 82#define INCLUDING_FROM_AUDIOFLINGER_H 83 84class AudioFlinger : 85 public BinderService<AudioFlinger>, 86 public BnAudioFlinger 87{ 88 friend class BinderService<AudioFlinger>; // for AudioFlinger() 89public: 90 static const char* getServiceName() { return "media.audio_flinger"; } 91 92 virtual status_t dump(int fd, const Vector<String16>& args); 93 94 // IAudioFlinger interface, in binder opcode order 95 virtual sp<IAudioTrack> createTrack( 96 pid_t pid, 97 audio_stream_type_t streamType, 98 uint32_t sampleRate, 99 audio_format_t format, 100 audio_channel_mask_t channelMask, 101 size_t frameCount, 102 IAudioFlinger::track_flags_t *flags, 103 const sp<IMemory>& sharedBuffer, 104 audio_io_handle_t output, 105 pid_t tid, 106 int *sessionId, 107 status_t *status); 108 109 virtual sp<IAudioRecord> openRecord( 110 pid_t pid, 111 audio_io_handle_t input, 112 uint32_t sampleRate, 113 audio_format_t format, 114 audio_channel_mask_t channelMask, 115 size_t frameCount, 116 IAudioFlinger::track_flags_t flags, 117 pid_t tid, 118 int *sessionId, 119 status_t *status); 120 121 virtual uint32_t sampleRate(audio_io_handle_t output) const; 122 virtual int channelCount(audio_io_handle_t output) const; 123 virtual audio_format_t format(audio_io_handle_t output) const; 124 virtual size_t frameCount(audio_io_handle_t output) const; 125 virtual uint32_t latency(audio_io_handle_t output) const; 126 127 virtual status_t setMasterVolume(float value); 128 virtual status_t setMasterMute(bool muted); 129 130 virtual float masterVolume() const; 131 virtual bool masterMute() const; 132 133 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 134 audio_io_handle_t output); 135 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted); 136 137 virtual float streamVolume(audio_stream_type_t stream, 138 audio_io_handle_t output) const; 139 virtual bool streamMute(audio_stream_type_t stream) const; 140 141 virtual status_t setMode(audio_mode_t mode); 142 143 virtual status_t setMicMute(bool state); 144 virtual bool getMicMute() const; 145 146 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs); 147 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const; 148 149 virtual void registerClient(const sp<IAudioFlingerClient>& client); 150 151 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 152 audio_channel_mask_t channelMask) const; 153 154 virtual audio_io_handle_t openOutput(audio_module_handle_t module, 155 audio_devices_t *pDevices, 156 uint32_t *pSamplingRate, 157 audio_format_t *pFormat, 158 audio_channel_mask_t *pChannelMask, 159 uint32_t *pLatencyMs, 160 audio_output_flags_t flags); 161 162 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 163 audio_io_handle_t output2); 164 165 virtual status_t closeOutput(audio_io_handle_t output); 166 167 virtual status_t suspendOutput(audio_io_handle_t output); 168 169 virtual status_t restoreOutput(audio_io_handle_t output); 170 171 virtual audio_io_handle_t openInput(audio_module_handle_t module, 172 audio_devices_t *pDevices, 173 uint32_t *pSamplingRate, 174 audio_format_t *pFormat, 175 audio_channel_mask_t *pChannelMask); 176 177 virtual status_t closeInput(audio_io_handle_t input); 178 179 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output); 180 181 virtual status_t setVoiceVolume(float volume); 182 183 virtual status_t getRenderPosition(size_t *halFrames, size_t *dspFrames, 184 audio_io_handle_t output) const; 185 186 virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const; 187 188 virtual int newAudioSessionId(); 189 190 virtual void acquireAudioSessionId(int audioSession); 191 192 virtual void releaseAudioSessionId(int audioSession); 193 194 virtual status_t queryNumberEffects(uint32_t *numEffects) const; 195 196 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const; 197 198 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid, 199 effect_descriptor_t *descriptor) const; 200 201 virtual sp<IEffect> createEffect(pid_t pid, 202 effect_descriptor_t *pDesc, 203 const sp<IEffectClient>& effectClient, 204 int32_t priority, 205 audio_io_handle_t io, 206 int sessionId, 207 status_t *status, 208 int *id, 209 int *enabled); 210 211 virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput, 212 audio_io_handle_t dstOutput); 213 214 virtual audio_module_handle_t loadHwModule(const char *name); 215 216 virtual uint32_t getPrimaryOutputSamplingRate(); 217 virtual size_t getPrimaryOutputFrameCount(); 218 219 virtual status_t onTransact( 220 uint32_t code, 221 const Parcel& data, 222 Parcel* reply, 223 uint32_t flags); 224 225 // end of IAudioFlinger interface 226 227 class SyncEvent; 228 229 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ; 230 231 class SyncEvent : public RefBase { 232 public: 233 SyncEvent(AudioSystem::sync_event_t type, 234 int triggerSession, 235 int listenerSession, 236 sync_event_callback_t callBack, 237 void *cookie) 238 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession), 239 mCallback(callBack), mCookie(cookie) 240 {} 241 242 virtual ~SyncEvent() {} 243 244 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); } 245 bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); } 246 void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; } 247 AudioSystem::sync_event_t type() const { return mType; } 248 int triggerSession() const { return mTriggerSession; } 249 int listenerSession() const { return mListenerSession; } 250 void *cookie() const { return mCookie; } 251 252 private: 253 const AudioSystem::sync_event_t mType; 254 const int mTriggerSession; 255 const int mListenerSession; 256 sync_event_callback_t mCallback; 257 void * const mCookie; 258 mutable Mutex mLock; 259 }; 260 261 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type, 262 int triggerSession, 263 int listenerSession, 264 sync_event_callback_t callBack, 265 void *cookie); 266 267private: 268 class AudioHwDevice; // fwd declaration for findSuitableHwDev_l 269 270 audio_mode_t getMode() const { return mMode; } 271 272 bool btNrecIsOff() const { return mBtNrecIsOff; } 273 274 AudioFlinger(); 275 virtual ~AudioFlinger(); 276 277 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev 278 status_t initCheck() const { return mPrimaryHardwareDev == NULL ? 279 NO_INIT : NO_ERROR; } 280 281 // RefBase 282 virtual void onFirstRef(); 283 284 AudioHwDevice* findSuitableHwDev_l(audio_module_handle_t module, 285 audio_devices_t devices); 286 void purgeStaleEffects_l(); 287 288 // standby delay for MIXER and DUPLICATING playback threads is read from property 289 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs 290 static nsecs_t mStandbyTimeInNsecs; 291 292 // incremented by 2 when screen state changes, bit 0 == 1 means "off" 293 // AudioFlinger::setParameters() updates, other threads read w/o lock 294 static uint32_t mScreenState; 295 296 // Internal dump utilities. 297 static const int kDumpLockRetries = 50; 298 static const int kDumpLockSleepUs = 20000; 299 static bool dumpTryLock(Mutex& mutex); 300 void dumpPermissionDenial(int fd, const Vector<String16>& args); 301 void dumpClients(int fd, const Vector<String16>& args); 302 void dumpInternals(int fd, const Vector<String16>& args); 303 304 // --- Client --- 305 class Client : public RefBase { 306 public: 307 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid); 308 virtual ~Client(); 309 sp<MemoryDealer> heap() const; 310 pid_t pid() const { return mPid; } 311 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; } 312 313 bool reserveTimedTrack(); 314 void releaseTimedTrack(); 315 316 private: 317 Client(const Client&); 318 Client& operator = (const Client&); 319 const sp<AudioFlinger> mAudioFlinger; 320 const sp<MemoryDealer> mMemoryDealer; 321 const pid_t mPid; 322 323 Mutex mTimedTrackLock; 324 int mTimedTrackCount; 325 }; 326 327 // --- Notification Client --- 328 class NotificationClient : public IBinder::DeathRecipient { 329 public: 330 NotificationClient(const sp<AudioFlinger>& audioFlinger, 331 const sp<IAudioFlingerClient>& client, 332 pid_t pid); 333 virtual ~NotificationClient(); 334 335 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; } 336 337 // IBinder::DeathRecipient 338 virtual void binderDied(const wp<IBinder>& who); 339 340 private: 341 NotificationClient(const NotificationClient&); 342 NotificationClient& operator = (const NotificationClient&); 343 344 const sp<AudioFlinger> mAudioFlinger; 345 const pid_t mPid; 346 const sp<IAudioFlingerClient> mAudioFlingerClient; 347 }; 348 349 class TrackHandle; 350 class RecordHandle; 351 class RecordThread; 352 class PlaybackThread; 353 class MixerThread; 354 class DirectOutputThread; 355 class DuplicatingThread; 356 class Track; 357 class RecordTrack; 358 class EffectModule; 359 class EffectHandle; 360 class EffectChain; 361 struct AudioStreamOut; 362 struct AudioStreamIn; 363 364 struct stream_type_t { 365 stream_type_t() 366 : volume(1.0f), 367 mute(false) 368 { 369 } 370 float volume; 371 bool mute; 372 }; 373 374 // --- PlaybackThread --- 375 376#include "Threads.h" 377 378#include "Effects.h" 379 380 // server side of the client's IAudioTrack 381 class TrackHandle : public android::BnAudioTrack { 382 public: 383 TrackHandle(const sp<PlaybackThread::Track>& track); 384 virtual ~TrackHandle(); 385 virtual sp<IMemory> getCblk() const; 386 virtual status_t start(); 387 virtual void stop(); 388 virtual void flush(); 389 virtual void pause(); 390 virtual status_t attachAuxEffect(int effectId); 391 virtual status_t allocateTimedBuffer(size_t size, 392 sp<IMemory>* buffer); 393 virtual status_t queueTimedBuffer(const sp<IMemory>& buffer, 394 int64_t pts); 395 virtual status_t setMediaTimeTransform(const LinearTransform& xform, 396 int target); 397 virtual status_t onTransact( 398 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 399 private: 400 const sp<PlaybackThread::Track> mTrack; 401 }; 402 403 // server side of the client's IAudioRecord 404 class RecordHandle : public android::BnAudioRecord { 405 public: 406 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack); 407 virtual ~RecordHandle(); 408 virtual sp<IMemory> getCblk() const; 409 virtual status_t start(int /*AudioSystem::sync_event_t*/ event, int triggerSession); 410 virtual void stop(); 411 virtual status_t onTransact( 412 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 413 private: 414 const sp<RecordThread::RecordTrack> mRecordTrack; 415 416 // for use from destructor 417 void stop_nonvirtual(); 418 }; 419 420 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const; 421 MixerThread *checkMixerThread_l(audio_io_handle_t output) const; 422 RecordThread *checkRecordThread_l(audio_io_handle_t input) const; 423 // no range check, AudioFlinger::mLock held 424 bool streamMute_l(audio_stream_type_t stream) const 425 { return mStreamTypes[stream].mute; } 426 // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held 427 float streamVolume_l(audio_stream_type_t stream) const 428 { return mStreamTypes[stream].volume; } 429 void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2); 430 431 // allocate an audio_io_handle_t, session ID, or effect ID 432 uint32_t nextUniqueId(); 433 434 status_t moveEffectChain_l(int sessionId, 435 PlaybackThread *srcThread, 436 PlaybackThread *dstThread, 437 bool reRegister); 438 // return thread associated with primary hardware device, or NULL 439 PlaybackThread *primaryPlaybackThread_l() const; 440 audio_devices_t primaryOutputDevice_l() const; 441 442 sp<PlaybackThread> getEffectThread_l(int sessionId, int EffectId); 443 444 445 void removeClient_l(pid_t pid); 446 void removeNotificationClient(pid_t pid); 447 448 class AudioHwDevice { 449 public: 450 enum Flags { 451 AHWD_CAN_SET_MASTER_VOLUME = 0x1, 452 AHWD_CAN_SET_MASTER_MUTE = 0x2, 453 }; 454 455 AudioHwDevice(const char *moduleName, 456 audio_hw_device_t *hwDevice, 457 Flags flags) 458 : mModuleName(strdup(moduleName)) 459 , mHwDevice(hwDevice) 460 , mFlags(flags) { } 461 /*virtual*/ ~AudioHwDevice() { free((void *)mModuleName); } 462 463 bool canSetMasterVolume() const { 464 return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME)); 465 } 466 467 bool canSetMasterMute() const { 468 return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE)); 469 } 470 471 const char *moduleName() const { return mModuleName; } 472 audio_hw_device_t *hwDevice() const { return mHwDevice; } 473 private: 474 const char * const mModuleName; 475 audio_hw_device_t * const mHwDevice; 476 Flags mFlags; 477 }; 478 479 // AudioStreamOut and AudioStreamIn are immutable, so their fields are const. 480 // For emphasis, we could also make all pointers to them be "const *", 481 // but that would clutter the code unnecessarily. 482 483 struct AudioStreamOut { 484 AudioHwDevice* const audioHwDev; 485 audio_stream_out_t* const stream; 486 487 audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); } 488 489 AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out) : 490 audioHwDev(dev), stream(out) {} 491 }; 492 493 struct AudioStreamIn { 494 AudioHwDevice* const audioHwDev; 495 audio_stream_in_t* const stream; 496 497 audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); } 498 499 AudioStreamIn(AudioHwDevice *dev, audio_stream_in_t *in) : 500 audioHwDev(dev), stream(in) {} 501 }; 502 503 // for mAudioSessionRefs only 504 struct AudioSessionRef { 505 AudioSessionRef(int sessionid, pid_t pid) : 506 mSessionid(sessionid), mPid(pid), mCnt(1) {} 507 const int mSessionid; 508 const pid_t mPid; 509 int mCnt; 510 }; 511 512 mutable Mutex mLock; 513 514 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client() 515 516 mutable Mutex mHardwareLock; 517 // NOTE: If both mLock and mHardwareLock mutexes must be held, 518 // always take mLock before mHardwareLock 519 520 // These two fields are immutable after onFirstRef(), so no lock needed to access 521 AudioHwDevice* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL 522 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*> mAudioHwDevs; 523 524 // for dump, indicates which hardware operation is currently in progress (but not stream ops) 525 enum hardware_call_state { 526 AUDIO_HW_IDLE = 0, // no operation in progress 527 AUDIO_HW_INIT, // init_check 528 AUDIO_HW_OUTPUT_OPEN, // open_output_stream 529 AUDIO_HW_OUTPUT_CLOSE, // unused 530 AUDIO_HW_INPUT_OPEN, // unused 531 AUDIO_HW_INPUT_CLOSE, // unused 532 AUDIO_HW_STANDBY, // unused 533 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume 534 AUDIO_HW_GET_ROUTING, // unused 535 AUDIO_HW_SET_ROUTING, // unused 536 AUDIO_HW_GET_MODE, // unused 537 AUDIO_HW_SET_MODE, // set_mode 538 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute 539 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute 540 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume 541 AUDIO_HW_SET_PARAMETER, // set_parameters 542 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size 543 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume 544 AUDIO_HW_GET_PARAMETER, // get_parameters 545 AUDIO_HW_SET_MASTER_MUTE, // set_master_mute 546 AUDIO_HW_GET_MASTER_MUTE, // get_master_mute 547 }; 548 549 mutable hardware_call_state mHardwareStatus; // for dump only 550 551 552 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads; 553 stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; 554 555 // member variables below are protected by mLock 556 float mMasterVolume; 557 bool mMasterMute; 558 // end of variables protected by mLock 559 560 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads; 561 562 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients; 563 volatile int32_t mNextUniqueId; // updated by android_atomic_inc 564 audio_mode_t mMode; 565 bool mBtNrecIsOff; 566 567 // protected by mLock 568 Vector<AudioSessionRef*> mAudioSessionRefs; 569 570 float masterVolume_l() const; 571 bool masterMute_l() const; 572 audio_module_handle_t loadHwModule_l(const char *name); 573 574 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session 575 // to be created 576 577private: 578 sp<Client> registerPid_l(pid_t pid); // always returns non-0 579 580 // for use from destructor 581 status_t closeOutput_nonvirtual(audio_io_handle_t output); 582 status_t closeInput_nonvirtual(audio_io_handle_t input); 583 584 // all record threads serially share a common tee sink, which is re-created on format change 585 sp<NBAIO_Sink> mRecordTeeSink; 586 sp<NBAIO_Source> mRecordTeeSource; 587 588public: 589 static void dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id = 0); 590}; 591 592#undef INCLUDING_FROM_AUDIOFLINGER_H 593 594// ---------------------------------------------------------------------------- 595 596}; // namespace android 597 598#endif // ANDROID_AUDIO_FLINGER_H 599