AudioFlinger.h revision 1a9ed11a472493cac7f6dfcbfac2064526a493ed
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 47#include "AudioBufferProvider.h" 48 49#include <powermanager/IPowerManager.h> 50 51namespace android { 52 53class audio_track_cblk_t; 54class effect_param_cblk_t; 55class AudioMixer; 56class AudioBuffer; 57class AudioResampler; 58 59// ---------------------------------------------------------------------------- 60 61// AudioFlinger has a hard-coded upper limit of 2 channels for capture and playback. 62// There is support for > 2 channel tracks down-mixed to 2 channel output via a down-mix effect. 63// Adding full support for > 2 channel capture or playback would require more than simply changing 64// this #define. There is an independent hard-coded upper limit in AudioMixer; 65// removing that AudioMixer limit would be necessary but insufficient to support > 2 channels. 66// The macro FCC_2 highlights some (but not all) places where there is are 2-channel assumptions. 67// Search also for "2", "left", "right", "[0]", "[1]", ">> 16", "<< 16", etc. 68#define FCC_2 2 // FCC_2 = Fixed Channel Count 2 69 70static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3); 71 72class AudioFlinger : 73 public BinderService<AudioFlinger>, 74 public BnAudioFlinger 75{ 76 friend class BinderService<AudioFlinger>; // for AudioFlinger() 77public: 78 static const char* getServiceName() { return "media.audio_flinger"; } 79 80 virtual status_t dump(int fd, const Vector<String16>& args); 81 82 // IAudioFlinger interface, in binder opcode order 83 virtual sp<IAudioTrack> createTrack( 84 pid_t pid, 85 audio_stream_type_t streamType, 86 uint32_t sampleRate, 87 audio_format_t format, 88 uint32_t channelMask, 89 int frameCount, 90 IAudioFlinger::track_flags_t flags, 91 const sp<IMemory>& sharedBuffer, 92 audio_io_handle_t output, 93 int *sessionId, 94 status_t *status); 95 96 virtual sp<IAudioRecord> openRecord( 97 pid_t pid, 98 audio_io_handle_t input, 99 uint32_t sampleRate, 100 audio_format_t format, 101 uint32_t channelMask, 102 int frameCount, 103 IAudioFlinger::track_flags_t flags, 104 int *sessionId, 105 status_t *status); 106 107 virtual uint32_t sampleRate(audio_io_handle_t output) const; 108 virtual int channelCount(audio_io_handle_t output) const; 109 virtual audio_format_t format(audio_io_handle_t output) const; 110 virtual size_t frameCount(audio_io_handle_t output) const; 111 virtual uint32_t latency(audio_io_handle_t output) const; 112 113 virtual status_t setMasterVolume(float value); 114 virtual status_t setMasterMute(bool muted); 115 116 virtual float masterVolume() const; 117 virtual float masterVolumeSW() const; 118 virtual bool masterMute() const; 119 120 virtual status_t setStreamVolume(audio_stream_type_t stream, float value, 121 audio_io_handle_t output); 122 virtual status_t setStreamMute(audio_stream_type_t stream, bool muted); 123 124 virtual float streamVolume(audio_stream_type_t stream, 125 audio_io_handle_t output) const; 126 virtual bool streamMute(audio_stream_type_t stream) const; 127 128 virtual status_t setMode(audio_mode_t mode); 129 130 virtual status_t setMicMute(bool state); 131 virtual bool getMicMute() const; 132 133 virtual status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs); 134 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) const; 135 136 virtual void registerClient(const sp<IAudioFlingerClient>& client); 137 138 virtual size_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount) const; 139 140 virtual audio_io_handle_t openOutput(uint32_t *pDevices, 141 uint32_t *pSamplingRate, 142 audio_format_t *pFormat, 143 uint32_t *pChannels, 144 uint32_t *pLatencyMs, 145 audio_policy_output_flags_t flags); 146 147 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 148 audio_io_handle_t output2); 149 150 virtual status_t closeOutput(audio_io_handle_t output); 151 152 virtual status_t suspendOutput(audio_io_handle_t output); 153 154 virtual status_t restoreOutput(audio_io_handle_t output); 155 156 virtual audio_io_handle_t openInput(uint32_t *pDevices, 157 uint32_t *pSamplingRate, 158 audio_format_t *pFormat, 159 uint32_t *pChannels, 160 audio_in_acoustics_t acoustics); 161 162 virtual status_t closeInput(audio_io_handle_t input); 163 164 virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output); 165 166 virtual status_t setVoiceVolume(float volume); 167 168 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, 169 audio_io_handle_t output) const; 170 171 virtual unsigned int getInputFramesLost(audio_io_handle_t ioHandle) const; 172 173 virtual int newAudioSessionId(); 174 175 virtual void acquireAudioSessionId(int audioSession); 176 177 virtual void releaseAudioSessionId(int audioSession); 178 179 virtual status_t queryNumberEffects(uint32_t *numEffects) const; 180 181 virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const; 182 183 virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid, 184 effect_descriptor_t *descriptor) const; 185 186 virtual sp<IEffect> createEffect(pid_t pid, 187 effect_descriptor_t *pDesc, 188 const sp<IEffectClient>& effectClient, 189 int32_t priority, 190 audio_io_handle_t io, 191 int sessionId, 192 status_t *status, 193 int *id, 194 int *enabled); 195 196 virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput, 197 audio_io_handle_t dstOutput); 198 199 virtual status_t onTransact( 200 uint32_t code, 201 const Parcel& data, 202 Parcel* reply, 203 uint32_t flags); 204 205 // end of IAudioFlinger interface 206 207 class SyncEvent; 208 209 typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ; 210 211 class SyncEvent : public RefBase { 212 public: 213 SyncEvent(AudioSystem::sync_event_t type, 214 int triggerSession, 215 int listenerSession, 216 sync_event_callback_t callBack, 217 void *cookie) 218 : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession), 219 mCallback(callBack), mCookie(cookie) 220 {} 221 222 virtual ~SyncEvent() {} 223 224 void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); } 225 void cancel() {Mutex::Autolock _l(mLock); mCallback = NULL; } 226 AudioSystem::sync_event_t type() const { return mType; } 227 int triggerSession() const { return mTriggerSession; } 228 int listenerSession() const { return mListenerSession; } 229 void *cookie() const { return mCookie; } 230 231 private: 232 const AudioSystem::sync_event_t mType; 233 const int mTriggerSession; 234 const int mListenerSession; 235 sync_event_callback_t mCallback; 236 void * const mCookie; 237 Mutex mLock; 238 }; 239 240 sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type, 241 int triggerSession, 242 int listenerSession, 243 sync_event_callback_t callBack, 244 void *cookie); 245private: 246 audio_mode_t getMode() const { return mMode; } 247 248 bool btNrecIsOff() const { return mBtNrecIsOff; } 249 250 AudioFlinger(); 251 virtual ~AudioFlinger(); 252 253 // call in any IAudioFlinger method that accesses mPrimaryHardwareDev 254 status_t initCheck() const { return mPrimaryHardwareDev == NULL ? NO_INIT : NO_ERROR; } 255 256 // RefBase 257 virtual void onFirstRef(); 258 259 audio_hw_device_t* findSuitableHwDev_l(uint32_t devices); 260 void purgeStaleEffects_l(); 261 262 // standby delay for MIXER and DUPLICATING playback threads is read from property 263 // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs 264 static nsecs_t mStandbyTimeInNsecs; 265 266 // Internal dump utilites. 267 status_t dumpPermissionDenial(int fd, const Vector<String16>& args); 268 status_t dumpClients(int fd, const Vector<String16>& args); 269 status_t dumpInternals(int fd, const Vector<String16>& args); 270 271 // --- Client --- 272 class Client : public RefBase { 273 public: 274 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid); 275 virtual ~Client(); 276 sp<MemoryDealer> heap() const; 277 pid_t pid() const { return mPid; } 278 sp<AudioFlinger> audioFlinger() const { return mAudioFlinger; } 279 280 bool reserveTimedTrack(); 281 void releaseTimedTrack(); 282 283 private: 284 Client(const Client&); 285 Client& operator = (const Client&); 286 const sp<AudioFlinger> mAudioFlinger; 287 const sp<MemoryDealer> mMemoryDealer; 288 const pid_t mPid; 289 290 Mutex mTimedTrackLock; 291 int mTimedTrackCount; 292 }; 293 294 // --- Notification Client --- 295 class NotificationClient : public IBinder::DeathRecipient { 296 public: 297 NotificationClient(const sp<AudioFlinger>& audioFlinger, 298 const sp<IAudioFlingerClient>& client, 299 pid_t pid); 300 virtual ~NotificationClient(); 301 302 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; } 303 304 // IBinder::DeathRecipient 305 virtual void binderDied(const wp<IBinder>& who); 306 307 private: 308 NotificationClient(const NotificationClient&); 309 NotificationClient& operator = (const NotificationClient&); 310 311 const sp<AudioFlinger> mAudioFlinger; 312 const pid_t mPid; 313 const sp<IAudioFlingerClient> mAudioFlingerClient; 314 }; 315 316 class TrackHandle; 317 class RecordHandle; 318 class RecordThread; 319 class PlaybackThread; 320 class MixerThread; 321 class DirectOutputThread; 322 class DuplicatingThread; 323 class Track; 324 class RecordTrack; 325 class EffectModule; 326 class EffectHandle; 327 class EffectChain; 328 struct AudioStreamOut; 329 struct AudioStreamIn; 330 331 class ThreadBase : public Thread { 332 public: 333 334 enum type_t { 335 MIXER, // Thread class is MixerThread 336 DIRECT, // Thread class is DirectOutputThread 337 DUPLICATING, // Thread class is DuplicatingThread 338 RECORD // Thread class is RecordThread 339 }; 340 341 ThreadBase (const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id, uint32_t device, type_t type); 342 virtual ~ThreadBase(); 343 344 status_t dumpBase(int fd, const Vector<String16>& args); 345 status_t dumpEffectChains(int fd, const Vector<String16>& args); 346 347 void clearPowerManager(); 348 349 // base for record and playback 350 class TrackBase : public AudioBufferProvider, public RefBase { 351 352 public: 353 enum track_state { 354 IDLE, 355 TERMINATED, 356 // These are order-sensitive; do not change order without reviewing the impact. 357 // In particular there are assumptions about > STOPPED. 358 STOPPED, 359 RESUMING, 360 ACTIVE, 361 PAUSING, 362 PAUSED 363 }; 364 365 TrackBase(ThreadBase *thread, 366 const sp<Client>& client, 367 uint32_t sampleRate, 368 audio_format_t format, 369 uint32_t channelMask, 370 int frameCount, 371 const sp<IMemory>& sharedBuffer, 372 int sessionId); 373 virtual ~TrackBase(); 374 375 virtual status_t start(pid_t tid, 376 AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE, 377 int triggerSession = 0) = 0; 378 virtual void stop() = 0; 379 sp<IMemory> getCblk() const { return mCblkMemory; } 380 audio_track_cblk_t* cblk() const { return mCblk; } 381 int sessionId() const { return mSessionId; } 382 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 383 384 protected: 385 TrackBase(const TrackBase&); 386 TrackBase& operator = (const TrackBase&); 387 388 // AudioBufferProvider interface 389 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0; 390 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 391 392 audio_format_t format() const { 393 return mFormat; 394 } 395 396 int channelCount() const { return mChannelCount; } 397 398 uint32_t channelMask() const { return mChannelMask; } 399 400 int sampleRate() const; // FIXME inline after cblk sr moved 401 402 void* getBuffer(uint32_t offset, uint32_t frames) const; 403 404 bool isStopped() const { 405 return mState == STOPPED; 406 } 407 408 bool isTerminated() const { 409 return mState == TERMINATED; 410 } 411 412 bool step(); 413 void reset(); 414 415 const wp<ThreadBase> mThread; 416 /*const*/ sp<Client> mClient; // see explanation at ~TrackBase() why not const 417 sp<IMemory> mCblkMemory; 418 audio_track_cblk_t* mCblk; 419 void* mBuffer; 420 void* mBufferEnd; 421 uint32_t mFrameCount; 422 // we don't really need a lock for these 423 track_state mState; 424 const audio_format_t mFormat; 425 bool mStepServerFailed; 426 const int mSessionId; 427 uint8_t mChannelCount; 428 uint32_t mChannelMask; 429 Vector < sp<SyncEvent> >mSyncEvents; 430 }; 431 432 class ConfigEvent { 433 public: 434 ConfigEvent() : mEvent(0), mParam(0) {} 435 436 int mEvent; 437 int mParam; 438 }; 439 440 class PMDeathRecipient : public IBinder::DeathRecipient { 441 public: 442 PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {} 443 virtual ~PMDeathRecipient() {} 444 445 // IBinder::DeathRecipient 446 virtual void binderDied(const wp<IBinder>& who); 447 448 private: 449 PMDeathRecipient(const PMDeathRecipient&); 450 PMDeathRecipient& operator = (const PMDeathRecipient&); 451 452 wp<ThreadBase> mThread; 453 }; 454 455 virtual status_t initCheck() const = 0; 456 type_t type() const { return mType; } 457 uint32_t sampleRate() const { return mSampleRate; } 458 int channelCount() const { return mChannelCount; } 459 audio_format_t format() const { return mFormat; } 460 size_t frameCount() const { return mFrameCount; } 461 void wakeUp() { mWaitWorkCV.broadcast(); } 462 // Should be "virtual status_t requestExitAndWait()" and override same 463 // method in Thread, but Thread::requestExitAndWait() is not yet virtual. 464 void exit(); 465 virtual bool checkForNewParameters_l() = 0; 466 virtual status_t setParameters(const String8& keyValuePairs); 467 virtual String8 getParameters(const String8& keys) = 0; 468 virtual void audioConfigChanged_l(int event, int param = 0) = 0; 469 void sendConfigEvent(int event, int param = 0); 470 void sendConfigEvent_l(int event, int param = 0); 471 void processConfigEvents(); 472 audio_io_handle_t id() const { return mId;} 473 bool standby() const { return mStandby; } 474 uint32_t device() const { return mDevice; } 475 virtual audio_stream_t* stream() const = 0; 476 477 sp<EffectHandle> createEffect_l( 478 const sp<AudioFlinger::Client>& client, 479 const sp<IEffectClient>& effectClient, 480 int32_t priority, 481 int sessionId, 482 effect_descriptor_t *desc, 483 int *enabled, 484 status_t *status); 485 void disconnectEffect(const sp< EffectModule>& effect, 486 const wp<EffectHandle>& handle, 487 bool unpinIfLast); 488 489 // return values for hasAudioSession (bit field) 490 enum effect_state { 491 EFFECT_SESSION = 0x1, // the audio session corresponds to at least one 492 // effect 493 TRACK_SESSION = 0x2 // the audio session corresponds to at least one 494 // track 495 }; 496 497 // get effect chain corresponding to session Id. 498 sp<EffectChain> getEffectChain(int sessionId); 499 // same as getEffectChain() but must be called with ThreadBase mutex locked 500 sp<EffectChain> getEffectChain_l(int sessionId); 501 // add an effect chain to the chain list (mEffectChains) 502 virtual status_t addEffectChain_l(const sp<EffectChain>& chain) = 0; 503 // remove an effect chain from the chain list (mEffectChains) 504 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0; 505 // lock all effect chains Mutexes. Must be called before releasing the 506 // ThreadBase mutex before processing the mixer and effects. This guarantees the 507 // integrity of the chains during the process. 508 // Also sets the parameter 'effectChains' to current value of mEffectChains. 509 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains); 510 // unlock effect chains after process 511 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains); 512 // set audio mode to all effect chains 513 void setMode(audio_mode_t mode); 514 // get effect module with corresponding ID on specified audio session 515 sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId); 516 // add and effect module. Also creates the effect chain is none exists for 517 // the effects audio session 518 status_t addEffect_l(const sp< EffectModule>& effect); 519 // remove and effect module. Also removes the effect chain is this was the last 520 // effect 521 void removeEffect_l(const sp< EffectModule>& effect); 522 // detach all tracks connected to an auxiliary effect 523 virtual void detachAuxEffect_l(int effectId) {} 524 // returns either EFFECT_SESSION if effects on this audio session exist in one 525 // chain, or TRACK_SESSION if tracks on this audio session exist, or both 526 virtual uint32_t hasAudioSession(int sessionId) = 0; 527 // the value returned by default implementation is not important as the 528 // strategy is only meaningful for PlaybackThread which implements this method 529 virtual uint32_t getStrategyForSession_l(int sessionId) { return 0; } 530 531 // suspend or restore effect according to the type of effect passed. a NULL 532 // type pointer means suspend all effects in the session 533 void setEffectSuspended(const effect_uuid_t *type, 534 bool suspend, 535 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 536 // check if some effects must be suspended/restored when an effect is enabled 537 // or disabled 538 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 539 bool enabled, 540 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 541 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect, 542 bool enabled, 543 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 544 545 virtual status_t setSyncEvent(const sp<SyncEvent>& event) = 0; 546 virtual bool isValidSyncEvent(const sp<SyncEvent>& event) = 0; 547 548 549 mutable Mutex mLock; 550 551 protected: 552 553 // entry describing an effect being suspended in mSuspendedSessions keyed vector 554 class SuspendedSessionDesc : public RefBase { 555 public: 556 SuspendedSessionDesc() : mRefCount(0) {} 557 558 int mRefCount; // number of active suspend requests 559 effect_uuid_t mType; // effect type UUID 560 }; 561 562 void acquireWakeLock(); 563 void acquireWakeLock_l(); 564 void releaseWakeLock(); 565 void releaseWakeLock_l(); 566 void setEffectSuspended_l(const effect_uuid_t *type, 567 bool suspend, 568 int sessionId = AUDIO_SESSION_OUTPUT_MIX); 569 // updated mSuspendedSessions when an effect suspended or restored 570 void updateSuspendedSessions_l(const effect_uuid_t *type, 571 bool suspend, 572 int sessionId); 573 // check if some effects must be suspended when an effect chain is added 574 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain); 575 576 friend class AudioFlinger; // for mEffectChains 577 578 const type_t mType; 579 580 // Used by parameters, config events, addTrack_l, exit 581 Condition mWaitWorkCV; 582 583 const sp<AudioFlinger> mAudioFlinger; 584 uint32_t mSampleRate; 585 size_t mFrameCount; 586 uint32_t mChannelMask; 587 uint16_t mChannelCount; 588 size_t mFrameSize; 589 audio_format_t mFormat; 590 591 // Parameter sequence by client: binder thread calling setParameters(): 592 // 1. Lock mLock 593 // 2. Append to mNewParameters 594 // 3. mWaitWorkCV.signal 595 // 4. mParamCond.waitRelative with timeout 596 // 5. read mParamStatus 597 // 6. mWaitWorkCV.signal 598 // 7. Unlock 599 // 600 // Parameter sequence by server: threadLoop calling checkForNewParameters_l(): 601 // 1. Lock mLock 602 // 2. If there is an entry in mNewParameters proceed ... 603 // 2. Read first entry in mNewParameters 604 // 3. Process 605 // 4. Remove first entry from mNewParameters 606 // 5. Set mParamStatus 607 // 6. mParamCond.signal 608 // 7. mWaitWorkCV.wait with timeout (this is to avoid overwriting mParamStatus) 609 // 8. Unlock 610 Condition mParamCond; 611 Vector<String8> mNewParameters; 612 status_t mParamStatus; 613 614 Vector<ConfigEvent> mConfigEvents; 615 bool mStandby; 616 const audio_io_handle_t mId; 617 Vector< sp<EffectChain> > mEffectChains; 618 uint32_t mDevice; // output device for PlaybackThread 619 // input + output devices for RecordThread 620 static const int kNameLength = 16; // prctl(PR_SET_NAME) limit 621 char mName[kNameLength]; 622 sp<IPowerManager> mPowerManager; 623 sp<IBinder> mWakeLockToken; 624 const sp<PMDeathRecipient> mDeathRecipient; 625 // list of suspended effects per session and per type. The first vector is 626 // keyed by session ID, the second by type UUID timeLow field 627 KeyedVector< int, KeyedVector< int, sp<SuspendedSessionDesc> > > mSuspendedSessions; 628 }; 629 630 struct stream_type_t { 631 stream_type_t() 632 : volume(1.0f), 633 mute(false) 634 { 635 } 636 float volume; 637 bool mute; 638 }; 639 640 // --- PlaybackThread --- 641 class PlaybackThread : public ThreadBase { 642 public: 643 644 enum mixer_state { 645 MIXER_IDLE, // no active tracks 646 MIXER_TRACKS_ENABLED, // at least one active track, but no track has any data ready 647 MIXER_TRACKS_READY // at least one active track, and at least one track has data 648 // standby mode does not have an enum value 649 // suspend by audio policy manager is orthogonal to mixer state 650 }; 651 652 // playback track 653 class Track : public TrackBase { 654 public: 655 Track( PlaybackThread *thread, 656 const sp<Client>& client, 657 audio_stream_type_t streamType, 658 uint32_t sampleRate, 659 audio_format_t format, 660 uint32_t channelMask, 661 int frameCount, 662 const sp<IMemory>& sharedBuffer, 663 int sessionId, 664 IAudioFlinger::track_flags_t flags); 665 virtual ~Track(); 666 667 void dump(char* buffer, size_t size); 668 virtual status_t start(pid_t tid, 669 AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE, 670 int triggerSession = 0); 671 virtual void stop(); 672 void pause(); 673 674 void flush(); 675 void destroy(); 676 void mute(bool); 677 int name() const { 678 return mName; 679 } 680 681 audio_stream_type_t streamType() const { 682 return mStreamType; 683 } 684 status_t attachAuxEffect(int EffectId); 685 void setAuxBuffer(int EffectId, int32_t *buffer); 686 int32_t *auxBuffer() const { return mAuxBuffer; } 687 void setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; } 688 int16_t *mainBuffer() const { return mMainBuffer; } 689 int auxEffectId() const { return mAuxEffectId; } 690 691 bool isFastTrack() const 692 { return (mFlags & IAudioFlinger::TRACK_FAST) != 0; } 693 694 protected: 695 // for numerous 696 friend class PlaybackThread; 697 friend class MixerThread; 698 friend class DirectOutputThread; 699 700 Track(const Track&); 701 Track& operator = (const Track&); 702 703 // AudioBufferProvider interface 704 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS); 705 // releaseBuffer() not overridden 706 707 virtual uint32_t framesReady() const; 708 709 bool isMuted() const { return mMute; } 710 bool isPausing() const { 711 return mState == PAUSING; 712 } 713 bool isPaused() const { 714 return mState == PAUSED; 715 } 716 bool isReady() const; 717 void setPaused() { mState = PAUSED; } 718 void reset(); 719 720 bool isOutputTrack() const { 721 return (mStreamType == AUDIO_STREAM_CNT); 722 } 723 724 bool presentationComplete(size_t framesWritten, size_t audioHalFrames); 725 void triggerEvents(AudioSystem::sync_event_t type); 726 727 public: 728 virtual bool isTimedTrack() const { return false; } 729 protected: 730 731 // we don't really need a lock for these 732 volatile bool mMute; 733 // FILLED state is used for suppressing volume ramp at begin of playing 734 enum {FS_FILLING, FS_FILLED, FS_ACTIVE}; 735 mutable uint8_t mFillingUpStatus; 736 int8_t mRetryCount; 737 const sp<IMemory> mSharedBuffer; 738 bool mResetDone; 739 const audio_stream_type_t mStreamType; 740 int mName; 741 int16_t *mMainBuffer; 742 int32_t *mAuxBuffer; 743 int mAuxEffectId; 744 bool mHasVolumeController; 745 size_t mPresentationCompleteFrames; // number of frames written to the audio HAL 746 // when this track will be fully rendered 747 private: 748 IAudioFlinger::track_flags_t mFlags; 749 }; // end of Track 750 751 class TimedTrack : public Track { 752 public: 753 static sp<TimedTrack> create(PlaybackThread *thread, 754 const sp<Client>& client, 755 audio_stream_type_t streamType, 756 uint32_t sampleRate, 757 audio_format_t format, 758 uint32_t channelMask, 759 int frameCount, 760 const sp<IMemory>& sharedBuffer, 761 int sessionId); 762 ~TimedTrack(); 763 764 class TimedBuffer { 765 public: 766 TimedBuffer(); 767 TimedBuffer(const sp<IMemory>& buffer, int64_t pts); 768 const sp<IMemory>& buffer() const { return mBuffer; } 769 int64_t pts() const { return mPTS; } 770 int position() const { return mPosition; } 771 void setPosition(int pos) { mPosition = pos; } 772 private: 773 sp<IMemory> mBuffer; 774 int64_t mPTS; 775 int mPosition; 776 }; 777 778 virtual bool isTimedTrack() const { return true; } 779 780 virtual uint32_t framesReady() const; 781 782 // AudioBufferProvider interface 783 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts); 784 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 785 786 void timedYieldSamples(AudioBufferProvider::Buffer* buffer); 787 void timedYieldSilence(uint32_t numFrames, 788 AudioBufferProvider::Buffer* buffer); 789 790 status_t allocateTimedBuffer(size_t size, 791 sp<IMemory>* buffer); 792 status_t queueTimedBuffer(const sp<IMemory>& buffer, 793 int64_t pts); 794 status_t setMediaTimeTransform(const LinearTransform& xform, 795 TimedAudioTrack::TargetTimeline target); 796 void trimTimedBufferQueue_l(); 797 798 private: 799 TimedTrack(PlaybackThread *thread, 800 const sp<Client>& client, 801 audio_stream_type_t streamType, 802 uint32_t sampleRate, 803 audio_format_t format, 804 uint32_t channelMask, 805 int frameCount, 806 const sp<IMemory>& sharedBuffer, 807 int sessionId); 808 809 uint64_t mLocalTimeFreq; 810 LinearTransform mLocalTimeToSampleTransform; 811 sp<MemoryDealer> mTimedMemoryDealer; 812 Vector<TimedBuffer> mTimedBufferQueue; 813 uint8_t* mTimedSilenceBuffer; 814 uint32_t mTimedSilenceBufferSize; 815 mutable Mutex mTimedBufferQueueLock; 816 bool mTimedAudioOutputOnTime; 817 CCHelper mCCHelper; 818 819 Mutex mMediaTimeTransformLock; 820 LinearTransform mMediaTimeTransform; 821 bool mMediaTimeTransformValid; 822 TimedAudioTrack::TargetTimeline mMediaTimeTransformTarget; 823 }; 824 825 826 // playback track 827 class OutputTrack : public Track { 828 public: 829 830 class Buffer: public AudioBufferProvider::Buffer { 831 public: 832 int16_t *mBuffer; 833 }; 834 835 OutputTrack(PlaybackThread *thread, 836 DuplicatingThread *sourceThread, 837 uint32_t sampleRate, 838 audio_format_t format, 839 uint32_t channelMask, 840 int frameCount); 841 virtual ~OutputTrack(); 842 843 virtual status_t start(pid_t tid, 844 AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE, 845 int triggerSession = 0); 846 virtual void stop(); 847 bool write(int16_t* data, uint32_t frames); 848 bool bufferQueueEmpty() const { return mBufferQueue.size() == 0; } 849 bool isActive() const { return mActive; } 850 const wp<ThreadBase>& thread() const { return mThread; } 851 852 private: 853 854 enum { 855 NO_MORE_BUFFERS = 0x80000001, // same in AudioTrack.h, ok to be different value 856 }; 857 858 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs); 859 void clearBufferQueue(); 860 861 // Maximum number of pending buffers allocated by OutputTrack::write() 862 static const uint8_t kMaxOverFlowBuffers = 10; 863 864 Vector < Buffer* > mBufferQueue; 865 AudioBufferProvider::Buffer mOutBuffer; 866 bool mActive; 867 DuplicatingThread* const mSourceThread; // for waitTimeMs() in write() 868 }; // end of OutputTrack 869 870 PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 871 audio_io_handle_t id, uint32_t device, type_t type); 872 virtual ~PlaybackThread(); 873 874 status_t dump(int fd, const Vector<String16>& args); 875 876 // Thread virtuals 877 virtual status_t readyToRun(); 878 virtual bool threadLoop(); 879 880 // RefBase 881 virtual void onFirstRef(); 882 883protected: 884 // Code snippets that were lifted up out of threadLoop() 885 virtual void threadLoop_mix() = 0; 886 virtual void threadLoop_sleepTime() = 0; 887 virtual void threadLoop_write(); 888 virtual void threadLoop_standby(); 889 890 // prepareTracks_l reads and writes mActiveTracks, and also returns the 891 // pending set of tracks to remove via Vector 'tracksToRemove'. The caller is 892 // responsible for clearing or destroying this Vector later on, when it 893 // is safe to do so. That will drop the final ref count and destroy the tracks. 894 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0; 895 896public: 897 898 virtual status_t initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; } 899 900 // return estimated latency in milliseconds, as reported by HAL 901 uint32_t latency() const; 902 903 void setMasterVolume(float value); 904 void setMasterMute(bool muted); 905 906 void setStreamVolume(audio_stream_type_t stream, float value); 907 void setStreamMute(audio_stream_type_t stream, bool muted); 908 909 float streamVolume(audio_stream_type_t stream) const; 910 911 sp<Track> createTrack_l( 912 const sp<AudioFlinger::Client>& client, 913 audio_stream_type_t streamType, 914 uint32_t sampleRate, 915 audio_format_t format, 916 uint32_t channelMask, 917 int frameCount, 918 const sp<IMemory>& sharedBuffer, 919 int sessionId, 920 IAudioFlinger::track_flags_t flags, 921 status_t *status); 922 923 AudioStreamOut* getOutput() const; 924 AudioStreamOut* clearOutput(); 925 virtual audio_stream_t* stream() const; 926 927 void suspend() { mSuspended++; } 928 void restore() { if (mSuspended > 0) mSuspended--; } 929 bool isSuspended() const { return (mSuspended > 0); } 930 virtual String8 getParameters(const String8& keys); 931 virtual void audioConfigChanged_l(int event, int param = 0); 932 status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames); 933 int16_t *mixBuffer() const { return mMixBuffer; }; 934 935 virtual void detachAuxEffect_l(int effectId); 936 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track, 937 int EffectId); 938 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track, 939 int EffectId); 940 941 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 942 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 943 virtual uint32_t hasAudioSession(int sessionId); 944 virtual uint32_t getStrategyForSession_l(int sessionId); 945 946 947 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 948 virtual bool isValidSyncEvent(const sp<SyncEvent>& event); 949 950 protected: 951 int16_t* mMixBuffer; 952 uint32_t mSuspended; // suspend count, > 0 means suspended 953 int mBytesWritten; 954 private: 955 // mMasterMute is in both PlaybackThread and in AudioFlinger. When a 956 // PlaybackThread needs to find out if master-muted, it checks it's local 957 // copy rather than the one in AudioFlinger. This optimization saves a lock. 958 bool mMasterMute; 959 void setMasterMute_l(bool muted) { mMasterMute = muted; } 960 protected: 961 SortedVector< wp<Track> > mActiveTracks; 962 963 // Allocate a track name. Returns name >= 0 if successful, -1 on failure. 964 virtual int getTrackName_l() = 0; 965 virtual void deleteTrackName_l(int name) = 0; 966 967 // Time to sleep between cycles when: 968 virtual uint32_t activeSleepTimeUs() const; // mixer state MIXER_TRACKS_ENABLED 969 virtual uint32_t idleSleepTimeUs() const = 0; // mixer state MIXER_IDLE 970 virtual uint32_t suspendSleepTimeUs() const = 0; // audio policy manager suspended us 971 // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write() 972 // No sleep in standby mode; waits on a condition 973 974 // Code snippets that are temporarily lifted up out of threadLoop() until the merge 975 void checkSilentMode_l(); 976 977 // Non-trivial for DUPLICATING only 978 virtual void saveOutputTracks() { } 979 virtual void clearOutputTracks() { } 980 981 // Cache various calculated values, at threadLoop() entry and after a parameter change 982 virtual void cacheParameters_l(); 983 984 private: 985 986 friend class AudioFlinger; // for numerous 987 988 PlaybackThread(const Client&); 989 PlaybackThread& operator = (const PlaybackThread&); 990 991 status_t addTrack_l(const sp<Track>& track); 992 void destroyTrack_l(const sp<Track>& track); 993 void removeTrack_l(const sp<Track>& track); 994 995 void readOutputParameters(); 996 997 virtual status_t dumpInternals(int fd, const Vector<String16>& args); 998 status_t dumpTracks(int fd, const Vector<String16>& args); 999 1000 SortedVector< sp<Track> > mTracks; 1001 // mStreamTypes[] uses 1 additional stream type internally for the OutputTrack used by DuplicatingThread 1002 stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1]; 1003 AudioStreamOut *mOutput; 1004 float mMasterVolume; 1005 nsecs_t mLastWriteTime; 1006 int mNumWrites; 1007 int mNumDelayedWrites; 1008 bool mInWrite; 1009 1010 // FIXME rename these former local variables of threadLoop to standard "m" names 1011 nsecs_t standbyTime; 1012 size_t mixBufferSize; 1013 1014 // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l() 1015 uint32_t activeSleepTime; 1016 uint32_t idleSleepTime; 1017 1018 uint32_t sleepTime; 1019 1020 // mixer status returned by prepareTracks_l() 1021 mixer_state mMixerStatus; // current cycle 1022 mixer_state mPrevMixerStatus; // previous cycle 1023 1024 // FIXME move these declarations into the specific sub-class that needs them 1025 // MIXER only 1026 bool longStandbyExit; 1027 uint32_t sleepTimeShift; 1028 1029 // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value 1030 nsecs_t standbyDelay; 1031 1032 // MIXER only 1033 nsecs_t maxPeriod; 1034 1035 // DUPLICATING only 1036 uint32_t writeFrames; 1037 }; 1038 1039 class MixerThread : public PlaybackThread { 1040 public: 1041 MixerThread (const sp<AudioFlinger>& audioFlinger, 1042 AudioStreamOut* output, 1043 audio_io_handle_t id, 1044 uint32_t device, 1045 type_t type = MIXER); 1046 virtual ~MixerThread(); 1047 1048 // Thread virtuals 1049 1050 void invalidateTracks(audio_stream_type_t streamType); 1051 virtual bool checkForNewParameters_l(); 1052 virtual status_t dumpInternals(int fd, const Vector<String16>& args); 1053 1054 protected: 1055 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1056 virtual int getTrackName_l(); 1057 virtual void deleteTrackName_l(int name); 1058 virtual uint32_t idleSleepTimeUs() const; 1059 virtual uint32_t suspendSleepTimeUs() const; 1060 virtual void cacheParameters_l(); 1061 1062 // threadLoop snippets 1063 virtual void threadLoop_mix(); 1064 virtual void threadLoop_sleepTime(); 1065 1066 AudioMixer* mAudioMixer; 1067 }; 1068 1069 class DirectOutputThread : public PlaybackThread { 1070 public: 1071 1072 DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, 1073 audio_io_handle_t id, uint32_t device); 1074 virtual ~DirectOutputThread(); 1075 1076 // Thread virtuals 1077 1078 virtual bool checkForNewParameters_l(); 1079 1080 protected: 1081 virtual int getTrackName_l(); 1082 virtual void deleteTrackName_l(int name); 1083 virtual uint32_t activeSleepTimeUs() const; 1084 virtual uint32_t idleSleepTimeUs() const; 1085 virtual uint32_t suspendSleepTimeUs() const; 1086 virtual void cacheParameters_l(); 1087 1088 // threadLoop snippets 1089 virtual mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove); 1090 virtual void threadLoop_mix(); 1091 virtual void threadLoop_sleepTime(); 1092 1093 // volumes last sent to audio HAL with stream->set_volume() 1094 // FIXME use standard representation and names 1095 float mLeftVolFloat; 1096 float mRightVolFloat; 1097 uint16_t mLeftVolShort; 1098 uint16_t mRightVolShort; 1099 1100 // FIXME rename these former local variables of threadLoop to standard names 1101 // next 3 were local to the while !exitingPending loop 1102 bool rampVolume; 1103 uint16_t leftVol; 1104 uint16_t rightVol; 1105 1106private: 1107 // prepareTracks_l() tells threadLoop_mix() the name of the single active track 1108 sp<Track> mActiveTrack; 1109 }; 1110 1111 class DuplicatingThread : public MixerThread { 1112 public: 1113 DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, 1114 audio_io_handle_t id); 1115 virtual ~DuplicatingThread(); 1116 1117 // Thread virtuals 1118 void addOutputTrack(MixerThread* thread); 1119 void removeOutputTrack(MixerThread* thread); 1120 uint32_t waitTimeMs() const { return mWaitTimeMs; } 1121 protected: 1122 virtual uint32_t activeSleepTimeUs() const; 1123 1124 private: 1125 bool outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks); 1126 protected: 1127 // threadLoop snippets 1128 virtual void threadLoop_mix(); 1129 virtual void threadLoop_sleepTime(); 1130 virtual void threadLoop_write(); 1131 virtual void threadLoop_standby(); 1132 virtual void cacheParameters_l(); 1133 1134 private: 1135 // called from threadLoop, addOutputTrack, removeOutputTrack 1136 virtual void updateWaitTime_l(); 1137 protected: 1138 virtual void saveOutputTracks(); 1139 virtual void clearOutputTracks(); 1140 private: 1141 1142 uint32_t mWaitTimeMs; 1143 SortedVector < sp<OutputTrack> > outputTracks; 1144 SortedVector < sp<OutputTrack> > mOutputTracks; 1145 }; 1146 1147 PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const; 1148 MixerThread *checkMixerThread_l(audio_io_handle_t output) const; 1149 RecordThread *checkRecordThread_l(audio_io_handle_t input) const; 1150 // no range check, AudioFlinger::mLock held 1151 bool streamMute_l(audio_stream_type_t stream) const 1152 { return mStreamTypes[stream].mute; } 1153 // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held 1154 float streamVolume_l(audio_stream_type_t stream) const 1155 { return mStreamTypes[stream].volume; } 1156 void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2); 1157 1158 // allocate an audio_io_handle_t, session ID, or effect ID 1159 uint32_t nextUniqueId(); 1160 1161 status_t moveEffectChain_l(int sessionId, 1162 PlaybackThread *srcThread, 1163 PlaybackThread *dstThread, 1164 bool reRegister); 1165 // return thread associated with primary hardware device, or NULL 1166 PlaybackThread *primaryPlaybackThread_l() const; 1167 uint32_t primaryOutputDevice_l() const; 1168 1169 // server side of the client's IAudioTrack 1170 class TrackHandle : public android::BnAudioTrack { 1171 public: 1172 TrackHandle(const sp<PlaybackThread::Track>& track); 1173 virtual ~TrackHandle(); 1174 virtual sp<IMemory> getCblk() const; 1175 virtual status_t start(pid_t tid); 1176 virtual void stop(); 1177 virtual void flush(); 1178 virtual void mute(bool); 1179 virtual void pause(); 1180 virtual status_t attachAuxEffect(int effectId); 1181 virtual status_t allocateTimedBuffer(size_t size, 1182 sp<IMemory>* buffer); 1183 virtual status_t queueTimedBuffer(const sp<IMemory>& buffer, 1184 int64_t pts); 1185 virtual status_t setMediaTimeTransform(const LinearTransform& xform, 1186 int target); 1187 virtual status_t onTransact( 1188 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 1189 private: 1190 const sp<PlaybackThread::Track> mTrack; 1191 }; 1192 1193 void removeClient_l(pid_t pid); 1194 void removeNotificationClient(pid_t pid); 1195 1196 1197 // record thread 1198 class RecordThread : public ThreadBase, public AudioBufferProvider 1199 { 1200 public: 1201 1202 // record track 1203 class RecordTrack : public TrackBase { 1204 public: 1205 RecordTrack(RecordThread *thread, 1206 const sp<Client>& client, 1207 uint32_t sampleRate, 1208 audio_format_t format, 1209 uint32_t channelMask, 1210 int frameCount, 1211 int sessionId); 1212 virtual ~RecordTrack(); 1213 1214 virtual status_t start(pid_t tid, 1215 AudioSystem::sync_event_t event = AudioSystem::SYNC_EVENT_NONE, 1216 int triggerSession = 0); 1217 virtual void stop(); 1218 1219 bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; } 1220 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; } 1221 1222 void dump(char* buffer, size_t size); 1223 1224 private: 1225 friend class AudioFlinger; // for mState 1226 1227 RecordTrack(const RecordTrack&); 1228 RecordTrack& operator = (const RecordTrack&); 1229 1230 // AudioBufferProvider interface 1231 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts = kInvalidPTS); 1232 // releaseBuffer() not overridden 1233 1234 bool mOverflow; 1235 }; 1236 1237 1238 RecordThread(const sp<AudioFlinger>& audioFlinger, 1239 AudioStreamIn *input, 1240 uint32_t sampleRate, 1241 uint32_t channels, 1242 audio_io_handle_t id, 1243 uint32_t device); 1244 virtual ~RecordThread(); 1245 1246 // Thread 1247 virtual bool threadLoop(); 1248 virtual status_t readyToRun(); 1249 1250 // RefBase 1251 virtual void onFirstRef(); 1252 1253 virtual status_t initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; } 1254 sp<AudioFlinger::RecordThread::RecordTrack> createRecordTrack_l( 1255 const sp<AudioFlinger::Client>& client, 1256 uint32_t sampleRate, 1257 audio_format_t format, 1258 int channelMask, 1259 int frameCount, 1260 int sessionId, 1261 status_t *status); 1262 1263 status_t start(RecordTrack* recordTrack, pid_t tid, 1264 AudioSystem::sync_event_t event, 1265 int triggerSession); 1266 void stop(RecordTrack* recordTrack); 1267 status_t dump(int fd, const Vector<String16>& args); 1268 AudioStreamIn* getInput() const; 1269 AudioStreamIn* clearInput(); 1270 virtual audio_stream_t* stream() const; 1271 1272 // AudioBufferProvider interface 1273 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts); 1274 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 1275 1276 virtual bool checkForNewParameters_l(); 1277 virtual String8 getParameters(const String8& keys); 1278 virtual void audioConfigChanged_l(int event, int param = 0); 1279 void readInputParameters(); 1280 virtual unsigned int getInputFramesLost(); 1281 1282 virtual status_t addEffectChain_l(const sp<EffectChain>& chain); 1283 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain); 1284 virtual uint32_t hasAudioSession(int sessionId); 1285 RecordTrack* track(); 1286 1287 virtual status_t setSyncEvent(const sp<SyncEvent>& event); 1288 virtual bool isValidSyncEvent(const sp<SyncEvent>& event); 1289 1290 static void syncStartEventCallback(const wp<SyncEvent>& event); 1291 void handleSyncStartEvent(const sp<SyncEvent>& event); 1292 1293 private: 1294 void clearSyncStartEvent(); 1295 1296 RecordThread(); 1297 AudioStreamIn *mInput; 1298 RecordTrack* mTrack; 1299 sp<RecordTrack> mActiveTrack; 1300 Condition mStartStopCond; 1301 AudioResampler *mResampler; 1302 int32_t *mRsmpOutBuffer; 1303 int16_t *mRsmpInBuffer; 1304 size_t mRsmpInIndex; 1305 size_t mInputBytes; 1306 const int mReqChannelCount; 1307 const uint32_t mReqSampleRate; 1308 ssize_t mBytesRead; 1309 // sync event triggering actual audio capture. Frames read before this event will 1310 // be dropped and therefore not read by the application. 1311 sp<SyncEvent> mSyncStartEvent; 1312 // number of captured frames to drop after the start sync event has been received. 1313 ssize_t mFramestoDrop; 1314 }; 1315 1316 // server side of the client's IAudioRecord 1317 class RecordHandle : public android::BnAudioRecord { 1318 public: 1319 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack); 1320 virtual ~RecordHandle(); 1321 virtual sp<IMemory> getCblk() const; 1322 virtual status_t start(pid_t tid, int event, int triggerSession); 1323 virtual void stop(); 1324 virtual status_t onTransact( 1325 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 1326 private: 1327 const sp<RecordThread::RecordTrack> mRecordTrack; 1328 }; 1329 1330 //--- Audio Effect Management 1331 1332 // EffectModule and EffectChain classes both have their own mutex to protect 1333 // state changes or resource modifications. Always respect the following order 1334 // if multiple mutexes must be acquired to avoid cross deadlock: 1335 // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule 1336 1337 // The EffectModule class is a wrapper object controlling the effect engine implementation 1338 // in the effect library. It prevents concurrent calls to process() and command() functions 1339 // from different client threads. It keeps a list of EffectHandle objects corresponding 1340 // to all client applications using this effect and notifies applications of effect state, 1341 // control or parameter changes. It manages the activation state machine to send appropriate 1342 // reset, enable, disable commands to effect engine and provide volume 1343 // ramping when effects are activated/deactivated. 1344 // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by 1345 // the attached track(s) to accumulate their auxiliary channel. 1346 class EffectModule: public RefBase { 1347 public: 1348 EffectModule(ThreadBase *thread, 1349 const wp<AudioFlinger::EffectChain>& chain, 1350 effect_descriptor_t *desc, 1351 int id, 1352 int sessionId); 1353 virtual ~EffectModule(); 1354 1355 enum effect_state { 1356 IDLE, 1357 RESTART, 1358 STARTING, 1359 ACTIVE, 1360 STOPPING, 1361 STOPPED, 1362 DESTROYED 1363 }; 1364 1365 int id() const { return mId; } 1366 void process(); 1367 void updateState(); 1368 status_t command(uint32_t cmdCode, 1369 uint32_t cmdSize, 1370 void *pCmdData, 1371 uint32_t *replySize, 1372 void *pReplyData); 1373 1374 void reset_l(); 1375 status_t configure(); 1376 status_t init(); 1377 effect_state state() const { 1378 return mState; 1379 } 1380 uint32_t status() { 1381 return mStatus; 1382 } 1383 int sessionId() const { 1384 return mSessionId; 1385 } 1386 status_t setEnabled(bool enabled); 1387 bool isEnabled() const; 1388 bool isProcessEnabled() const; 1389 1390 void setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; } 1391 int16_t *inBuffer() { return mConfig.inputCfg.buffer.s16; } 1392 void setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; } 1393 int16_t *outBuffer() { return mConfig.outputCfg.buffer.s16; } 1394 void setChain(const wp<EffectChain>& chain) { mChain = chain; } 1395 void setThread(const wp<ThreadBase>& thread) { mThread = thread; } 1396 const wp<ThreadBase>& thread() { return mThread; } 1397 1398 status_t addHandle(const sp<EffectHandle>& handle); 1399 void disconnect(const wp<EffectHandle>& handle, bool unpinIfLast); 1400 size_t removeHandle (const wp<EffectHandle>& handle); 1401 1402 effect_descriptor_t& desc() { return mDescriptor; } 1403 wp<EffectChain>& chain() { return mChain; } 1404 1405 status_t setDevice(uint32_t device); 1406 status_t setVolume(uint32_t *left, uint32_t *right, bool controller); 1407 status_t setMode(audio_mode_t mode); 1408 status_t start(); 1409 status_t stop(); 1410 void setSuspended(bool suspended); 1411 bool suspended() const; 1412 1413 sp<EffectHandle> controlHandle(); 1414 1415 bool isPinned() const { return mPinned; } 1416 void unPin() { mPinned = false; } 1417 1418 status_t dump(int fd, const Vector<String16>& args); 1419 1420 protected: 1421 friend class AudioFlinger; // for mHandles 1422 bool mPinned; 1423 1424 // Maximum time allocated to effect engines to complete the turn off sequence 1425 static const uint32_t MAX_DISABLE_TIME_MS = 10000; 1426 1427 EffectModule(const EffectModule&); 1428 EffectModule& operator = (const EffectModule&); 1429 1430 status_t start_l(); 1431 status_t stop_l(); 1432 1433mutable Mutex mLock; // mutex for process, commands and handles list protection 1434 wp<ThreadBase> mThread; // parent thread 1435 wp<EffectChain> mChain; // parent effect chain 1436 int mId; // this instance unique ID 1437 int mSessionId; // audio session ID 1438 effect_descriptor_t mDescriptor;// effect descriptor received from effect engine 1439 effect_config_t mConfig; // input and output audio configuration 1440 effect_handle_t mEffectInterface; // Effect module C API 1441 status_t mStatus; // initialization status 1442 effect_state mState; // current activation state 1443 Vector< wp<EffectHandle> > mHandles; // list of client handles 1444 // First handle in mHandles has highest priority and controls the effect module 1445 uint32_t mMaxDisableWaitCnt; // maximum grace period before forcing an effect off after 1446 // sending disable command. 1447 uint32_t mDisableWaitCnt; // current process() calls count during disable period. 1448 bool mSuspended; // effect is suspended: temporarily disabled by framework 1449 }; 1450 1451 // The EffectHandle class implements the IEffect interface. It provides resources 1452 // to receive parameter updates, keeps track of effect control 1453 // ownership and state and has a pointer to the EffectModule object it is controlling. 1454 // There is one EffectHandle object for each application controlling (or using) 1455 // an effect module. 1456 // The EffectHandle is obtained by calling AudioFlinger::createEffect(). 1457 class EffectHandle: public android::BnEffect { 1458 public: 1459 1460 EffectHandle(const sp<EffectModule>& effect, 1461 const sp<AudioFlinger::Client>& client, 1462 const sp<IEffectClient>& effectClient, 1463 int32_t priority); 1464 virtual ~EffectHandle(); 1465 1466 // IEffect 1467 virtual status_t enable(); 1468 virtual status_t disable(); 1469 virtual status_t command(uint32_t cmdCode, 1470 uint32_t cmdSize, 1471 void *pCmdData, 1472 uint32_t *replySize, 1473 void *pReplyData); 1474 virtual void disconnect(); 1475 private: 1476 void disconnect(bool unpinIfLast); 1477 public: 1478 virtual sp<IMemory> getCblk() const { return mCblkMemory; } 1479 virtual status_t onTransact(uint32_t code, const Parcel& data, 1480 Parcel* reply, uint32_t flags); 1481 1482 1483 // Give or take control of effect module 1484 // - hasControl: true if control is given, false if removed 1485 // - signal: true client app should be signaled of change, false otherwise 1486 // - enabled: state of the effect when control is passed 1487 void setControl(bool hasControl, bool signal, bool enabled); 1488 void commandExecuted(uint32_t cmdCode, 1489 uint32_t cmdSize, 1490 void *pCmdData, 1491 uint32_t replySize, 1492 void *pReplyData); 1493 void setEnabled(bool enabled); 1494 bool enabled() const { return mEnabled; } 1495 1496 // Getters 1497 int id() const { return mEffect->id(); } 1498 int priority() const { return mPriority; } 1499 bool hasControl() const { return mHasControl; } 1500 sp<EffectModule> effect() const { return mEffect; } 1501 1502 void dump(char* buffer, size_t size); 1503 1504 protected: 1505 friend class AudioFlinger; // for mEffect, mHasControl, mEnabled 1506 EffectHandle(const EffectHandle&); 1507 EffectHandle& operator =(const EffectHandle&); 1508 1509 sp<EffectModule> mEffect; // pointer to controlled EffectModule 1510 sp<IEffectClient> mEffectClient; // callback interface for client notifications 1511 /*const*/ sp<Client> mClient; // client for shared memory allocation, see disconnect() 1512 sp<IMemory> mCblkMemory; // shared memory for control block 1513 effect_param_cblk_t* mCblk; // control block for deferred parameter setting via shared memory 1514 uint8_t* mBuffer; // pointer to parameter area in shared memory 1515 int mPriority; // client application priority to control the effect 1516 bool mHasControl; // true if this handle is controlling the effect 1517 bool mEnabled; // cached enable state: needed when the effect is 1518 // restored after being suspended 1519 }; 1520 1521 // the EffectChain class represents a group of effects associated to one audio session. 1522 // There can be any number of EffectChain objects per output mixer thread (PlaybackThread). 1523 // The EffecChain with session ID 0 contains global effects applied to the output mix. 1524 // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks) 1525 // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding 1526 // in the effect process order. When attached to a track (session ID != 0), it also provide it's own 1527 // input buffer used by the track as accumulation buffer. 1528 class EffectChain: public RefBase { 1529 public: 1530 EffectChain(const wp<ThreadBase>& wThread, int sessionId); 1531 EffectChain(ThreadBase *thread, int sessionId); 1532 virtual ~EffectChain(); 1533 1534 // special key used for an entry in mSuspendedEffects keyed vector 1535 // corresponding to a suspend all request. 1536 static const int kKeyForSuspendAll = 0; 1537 1538 // minimum duration during which we force calling effect process when last track on 1539 // a session is stopped or removed to allow effect tail to be rendered 1540 static const int kProcessTailDurationMs = 1000; 1541 1542 void process_l(); 1543 1544 void lock() { 1545 mLock.lock(); 1546 } 1547 void unlock() { 1548 mLock.unlock(); 1549 } 1550 1551 status_t addEffect_l(const sp<EffectModule>& handle); 1552 size_t removeEffect_l(const sp<EffectModule>& handle); 1553 1554 int sessionId() const { return mSessionId; } 1555 void setSessionId(int sessionId) { mSessionId = sessionId; } 1556 1557 sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor); 1558 sp<EffectModule> getEffectFromId_l(int id); 1559 sp<EffectModule> getEffectFromType_l(const effect_uuid_t *type); 1560 bool setVolume_l(uint32_t *left, uint32_t *right); 1561 void setDevice_l(uint32_t device); 1562 void setMode_l(audio_mode_t mode); 1563 1564 void setInBuffer(int16_t *buffer, bool ownsBuffer = false) { 1565 mInBuffer = buffer; 1566 mOwnInBuffer = ownsBuffer; 1567 } 1568 int16_t *inBuffer() const { 1569 return mInBuffer; 1570 } 1571 void setOutBuffer(int16_t *buffer) { 1572 mOutBuffer = buffer; 1573 } 1574 int16_t *outBuffer() const { 1575 return mOutBuffer; 1576 } 1577 1578 void incTrackCnt() { android_atomic_inc(&mTrackCnt); } 1579 void decTrackCnt() { android_atomic_dec(&mTrackCnt); } 1580 int32_t trackCnt() const { return mTrackCnt;} 1581 1582 void incActiveTrackCnt() { android_atomic_inc(&mActiveTrackCnt); 1583 mTailBufferCount = mMaxTailBuffers; } 1584 void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); } 1585 int32_t activeTrackCnt() const { return mActiveTrackCnt;} 1586 1587 uint32_t strategy() const { return mStrategy; } 1588 void setStrategy(uint32_t strategy) 1589 { mStrategy = strategy; } 1590 1591 // suspend effect of the given type 1592 void setEffectSuspended_l(const effect_uuid_t *type, 1593 bool suspend); 1594 // suspend all eligible effects 1595 void setEffectSuspendedAll_l(bool suspend); 1596 // check if effects should be suspend or restored when a given effect is enable or disabled 1597 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect, 1598 bool enabled); 1599 1600 status_t dump(int fd, const Vector<String16>& args); 1601 1602 protected: 1603 friend class AudioFlinger; // for mThread, mEffects 1604 EffectChain(const EffectChain&); 1605 EffectChain& operator =(const EffectChain&); 1606 1607 class SuspendedEffectDesc : public RefBase { 1608 public: 1609 SuspendedEffectDesc() : mRefCount(0) {} 1610 1611 int mRefCount; 1612 effect_uuid_t mType; 1613 wp<EffectModule> mEffect; 1614 }; 1615 1616 // get a list of effect modules to suspend when an effect of the type 1617 // passed is enabled. 1618 void getSuspendEligibleEffects(Vector< sp<EffectModule> > &effects); 1619 1620 // get an effect module if it is currently enable 1621 sp<EffectModule> getEffectIfEnabled(const effect_uuid_t *type); 1622 // true if the effect whose descriptor is passed can be suspended 1623 // OEMs can modify the rules implemented in this method to exclude specific effect 1624 // types or implementations from the suspend/restore mechanism. 1625 bool isEffectEligibleForSuspend(const effect_descriptor_t& desc); 1626 1627 wp<ThreadBase> mThread; // parent mixer thread 1628 Mutex mLock; // mutex protecting effect list 1629 Vector< sp<EffectModule> > mEffects; // list of effect modules 1630 int mSessionId; // audio session ID 1631 int16_t *mInBuffer; // chain input buffer 1632 int16_t *mOutBuffer; // chain output buffer 1633 volatile int32_t mActiveTrackCnt; // number of active tracks connected 1634 volatile int32_t mTrackCnt; // number of tracks connected 1635 int32_t mTailBufferCount; // current effect tail buffer count 1636 int32_t mMaxTailBuffers; // maximum effect tail buffers 1637 bool mOwnInBuffer; // true if the chain owns its input buffer 1638 int mVolumeCtrlIdx; // index of insert effect having control over volume 1639 uint32_t mLeftVolume; // previous volume on left channel 1640 uint32_t mRightVolume; // previous volume on right channel 1641 uint32_t mNewLeftVolume; // new volume on left channel 1642 uint32_t mNewRightVolume; // new volume on right channel 1643 uint32_t mStrategy; // strategy for this effect chain 1644 // mSuspendedEffects lists all effects currently suspended in the chain. 1645 // Use effect type UUID timelow field as key. There is no real risk of identical 1646 // timeLow fields among effect type UUIDs. 1647 // Updated by updateSuspendedSessions_l() only. 1648 KeyedVector< int, sp<SuspendedEffectDesc> > mSuspendedEffects; 1649 }; 1650 1651 // AudioStreamOut and AudioStreamIn are immutable, so their fields are const. 1652 // For emphasis, we could also make all pointers to them be "const *", 1653 // but that would clutter the code unnecessarily. 1654 1655 struct AudioStreamOut { 1656 audio_hw_device_t* const hwDev; 1657 audio_stream_out_t* const stream; 1658 1659 AudioStreamOut(audio_hw_device_t *dev, audio_stream_out_t *out) : 1660 hwDev(dev), stream(out) {} 1661 }; 1662 1663 struct AudioStreamIn { 1664 audio_hw_device_t* const hwDev; 1665 audio_stream_in_t* const stream; 1666 1667 AudioStreamIn(audio_hw_device_t *dev, audio_stream_in_t *in) : 1668 hwDev(dev), stream(in) {} 1669 }; 1670 1671 // for mAudioSessionRefs only 1672 struct AudioSessionRef { 1673 AudioSessionRef(int sessionid, pid_t pid) : 1674 mSessionid(sessionid), mPid(pid), mCnt(1) {} 1675 const int mSessionid; 1676 const pid_t mPid; 1677 int mCnt; 1678 }; 1679 1680 enum master_volume_support { 1681 // MVS_NONE: 1682 // Audio HAL has no support for master volume, either setting or 1683 // getting. All master volume control must be implemented in SW by the 1684 // AudioFlinger mixing core. 1685 MVS_NONE, 1686 1687 // MVS_SETONLY: 1688 // Audio HAL has support for setting master volume, but not for getting 1689 // master volume (original HAL design did not include a getter). 1690 // AudioFlinger needs to keep track of the last set master volume in 1691 // addition to needing to set an initial, default, master volume at HAL 1692 // load time. 1693 MVS_SETONLY, 1694 1695 // MVS_FULL: 1696 // Audio HAL has support both for setting and getting master volume. 1697 // AudioFlinger should send all set and get master volume requests 1698 // directly to the HAL. 1699 MVS_FULL, 1700 }; 1701 1702 mutable Mutex mLock; 1703 1704 DefaultKeyedVector< pid_t, wp<Client> > mClients; // see ~Client() 1705 1706 mutable Mutex mHardwareLock; 1707 1708 // These two fields are immutable after onFirstRef(), so no lock needed to access 1709 audio_hw_device_t* mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL 1710 Vector<audio_hw_device_t*> mAudioHwDevs; 1711 1712 // for dump, indicates which hardware operation is currently in progress (but not stream ops) 1713 enum hardware_call_state { 1714 AUDIO_HW_IDLE = 0, // no operation in progress 1715 AUDIO_HW_INIT, // init_check 1716 AUDIO_HW_OUTPUT_OPEN, // open_output_stream 1717 AUDIO_HW_OUTPUT_CLOSE, // unused 1718 AUDIO_HW_INPUT_OPEN, // unused 1719 AUDIO_HW_INPUT_CLOSE, // unused 1720 AUDIO_HW_STANDBY, // unused 1721 AUDIO_HW_SET_MASTER_VOLUME, // set_master_volume 1722 AUDIO_HW_GET_ROUTING, // unused 1723 AUDIO_HW_SET_ROUTING, // unused 1724 AUDIO_HW_GET_MODE, // unused 1725 AUDIO_HW_SET_MODE, // set_mode 1726 AUDIO_HW_GET_MIC_MUTE, // get_mic_mute 1727 AUDIO_HW_SET_MIC_MUTE, // set_mic_mute 1728 AUDIO_HW_SET_VOICE_VOLUME, // set_voice_volume 1729 AUDIO_HW_SET_PARAMETER, // set_parameters 1730 AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size 1731 AUDIO_HW_GET_MASTER_VOLUME, // get_master_volume 1732 AUDIO_HW_GET_PARAMETER, // get_parameters 1733 }; 1734 1735 mutable hardware_call_state mHardwareStatus; // for dump only 1736 1737 1738 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> > mPlaybackThreads; 1739 stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; 1740 1741 // both are protected by mLock 1742 float mMasterVolume; 1743 float mMasterVolumeSW; 1744 master_volume_support mMasterVolumeSupportLvl; 1745 bool mMasterMute; 1746 1747 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> > mRecordThreads; 1748 1749 DefaultKeyedVector< pid_t, sp<NotificationClient> > mNotificationClients; 1750 volatile int32_t mNextUniqueId; // updated by android_atomic_inc 1751 audio_mode_t mMode; 1752 bool mBtNrecIsOff; 1753 1754 // protected by mLock 1755 Vector<AudioSessionRef*> mAudioSessionRefs; 1756 1757 float masterVolume_l() const; 1758 float masterVolumeSW_l() const { return mMasterVolumeSW; } 1759 bool masterMute_l() const { return mMasterMute; } 1760 1761 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session 1762 // to be created 1763 1764private: 1765 sp<Client> registerPid_l(pid_t pid); // always returns non-0 1766 1767}; 1768 1769 1770// ---------------------------------------------------------------------------- 1771 1772}; // namespace android 1773 1774#endif // ANDROID_AUDIO_FLINGER_H 1775