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