1 /* //device/include/server/AudioFlinger/AudioFlinger.h 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 <media/IAudioFlinger.h> 26 #include <media/IAudioFlingerClient.h> 27 #include <media/IAudioTrack.h> 28 #include <media/IAudioRecord.h> 29 #include <media/AudioTrack.h> 30 31 #include <utils/Atomic.h> 32 #include <utils/Errors.h> 33 #include <utils/threads.h> 34 #include <binder/MemoryDealer.h> 35 #include <utils/SortedVector.h> 36 #include <utils/Vector.h> 37 38 #include <hardware_legacy/AudioHardwareInterface.h> 39 40 #include "AudioBufferProvider.h" 41 42 namespace android { 43 44 class audio_track_cblk_t; 45 class AudioMixer; 46 class AudioBuffer; 47 class AudioResampler; 48 49 50 // ---------------------------------------------------------------------------- 51 52 #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) 53 #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) 54 55 56 // ---------------------------------------------------------------------------- 57 58 static const nsecs_t kStandbyTimeInNsecs = seconds(3); 59 60 class AudioFlinger : public BnAudioFlinger, public IBinder::DeathRecipient 61 { 62 public: 63 static void instantiate(); 64 65 virtual status_t dump(int fd, const Vector<String16>& args); 66 67 // IAudioFlinger interface 68 virtual sp<IAudioTrack> createTrack( 69 pid_t pid, 70 int streamType, 71 uint32_t sampleRate, 72 int format, 73 int channelCount, 74 int frameCount, 75 uint32_t flags, 76 const sp<IMemory>& sharedBuffer, 77 int output, 78 status_t *status); 79 80 virtual uint32_t sampleRate(int output) const; 81 virtual int channelCount(int output) const; 82 virtual int format(int output) const; 83 virtual size_t frameCount(int output) const; 84 virtual uint32_t latency(int output) const; 85 86 virtual status_t setMasterVolume(float value); 87 virtual status_t setMasterMute(bool muted); 88 89 virtual float masterVolume() const; 90 virtual bool masterMute() const; 91 92 virtual status_t setStreamVolume(int stream, float value, int output); 93 virtual status_t setStreamMute(int stream, bool muted); 94 95 virtual float streamVolume(int stream, int output) const; 96 virtual bool streamMute(int stream) const; 97 98 virtual status_t setMode(int mode); 99 100 virtual status_t setMicMute(bool state); 101 virtual bool getMicMute() const; 102 103 virtual bool isStreamActive(int stream) const; 104 105 virtual status_t setParameters(int ioHandle, const String8& keyValuePairs); 106 virtual String8 getParameters(int ioHandle, const String8& keys); 107 108 virtual void registerClient(const sp<IAudioFlingerClient>& client); 109 110 virtual size_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount); 111 virtual unsigned int getInputFramesLost(int ioHandle); 112 113 virtual int openOutput(uint32_t *pDevices, 114 uint32_t *pSamplingRate, 115 uint32_t *pFormat, 116 uint32_t *pChannels, 117 uint32_t *pLatencyMs, 118 uint32_t flags); 119 120 virtual int openDuplicateOutput(int output1, int output2); 121 122 virtual status_t closeOutput(int output); 123 124 virtual status_t suspendOutput(int output); 125 126 virtual status_t restoreOutput(int output); 127 128 virtual int openInput(uint32_t *pDevices, 129 uint32_t *pSamplingRate, 130 uint32_t *pFormat, 131 uint32_t *pChannels, 132 uint32_t acoustics); 133 134 virtual status_t closeInput(int input); 135 136 virtual status_t setStreamOutput(uint32_t stream, int output); 137 138 virtual status_t setVoiceVolume(float volume); 139 140 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int output); 141 142 // IBinder::DeathRecipient 143 virtual void binderDied(const wp<IBinder>& who); 144 145 enum hardware_call_state { 146 AUDIO_HW_IDLE = 0, 147 AUDIO_HW_INIT, 148 AUDIO_HW_OUTPUT_OPEN, 149 AUDIO_HW_OUTPUT_CLOSE, 150 AUDIO_HW_INPUT_OPEN, 151 AUDIO_HW_INPUT_CLOSE, 152 AUDIO_HW_STANDBY, 153 AUDIO_HW_SET_MASTER_VOLUME, 154 AUDIO_HW_GET_ROUTING, 155 AUDIO_HW_SET_ROUTING, 156 AUDIO_HW_GET_MODE, 157 AUDIO_HW_SET_MODE, 158 AUDIO_HW_GET_MIC_MUTE, 159 AUDIO_HW_SET_MIC_MUTE, 160 AUDIO_SET_VOICE_VOLUME, 161 AUDIO_SET_PARAMETER, 162 }; 163 164 // record interface 165 virtual sp<IAudioRecord> openRecord( 166 pid_t pid, 167 int input, 168 uint32_t sampleRate, 169 int format, 170 int channelCount, 171 int frameCount, 172 uint32_t flags, 173 status_t *status); 174 175 virtual status_t onTransact( 176 uint32_t code, 177 const Parcel& data, 178 Parcel* reply, 179 uint32_t flags); 180 181 private: 182 AudioFlinger(); 183 virtual ~AudioFlinger(); 184 185 186 // Internal dump utilites. 187 status_t dumpPermissionDenial(int fd, const Vector<String16>& args); 188 status_t dumpClients(int fd, const Vector<String16>& args); 189 status_t dumpInternals(int fd, const Vector<String16>& args); 190 191 // --- Client --- 192 class Client : public RefBase { 193 public: 194 Client(const sp<AudioFlinger>& audioFlinger, pid_t pid); 195 virtual ~Client(); 196 const sp<MemoryDealer>& heap() const; 197 pid_t pid() const { return mPid; } 198 sp<AudioFlinger> audioFlinger() { return mAudioFlinger; } 199 200 private: 201 Client(const Client&); 202 Client& operator = (const Client&); 203 sp<AudioFlinger> mAudioFlinger; 204 sp<MemoryDealer> mMemoryDealer; 205 pid_t mPid; 206 }; 207 208 209 class TrackHandle; 210 class RecordHandle; 211 class RecordThread; 212 class PlaybackThread; 213 class MixerThread; 214 class DirectOutputThread; 215 class DuplicatingThread; 216 class Track; 217 class RecordTrack; 218 219 class ThreadBase : public Thread { 220 public: 221 ThreadBase (const sp<AudioFlinger>& audioFlinger, int id); 222 virtual ~ThreadBase(); 223 224 status_t dumpBase(int fd, const Vector<String16>& args); 225 226 // base for record and playback 227 class TrackBase : public AudioBufferProvider, public RefBase { 228 229 public: 230 enum track_state { 231 IDLE, 232 TERMINATED, 233 STOPPED, 234 RESUMING, 235 ACTIVE, 236 PAUSING, 237 PAUSED 238 }; 239 240 enum track_flags { 241 STEPSERVER_FAILED = 0x01, // StepServer could not acquire cblk->lock mutex 242 SYSTEM_FLAGS_MASK = 0x0000ffffUL, 243 // The upper 16 bits are used for track-specific flags. 244 }; 245 246 TrackBase(const wp<ThreadBase>& thread, 247 const sp<Client>& client, 248 uint32_t sampleRate, 249 int format, 250 int channelCount, 251 int frameCount, 252 uint32_t flags, 253 const sp<IMemory>& sharedBuffer); 254 ~TrackBase(); 255 256 virtual status_t start() = 0; 257 virtual void stop() = 0; 258 sp<IMemory> getCblk() const; 259 audio_track_cblk_t* cblk() const { return mCblk; } 260 261 protected: 262 friend class ThreadBase; 263 friend class RecordHandle; 264 friend class PlaybackThread; 265 friend class RecordThread; 266 friend class MixerThread; 267 friend class DirectOutputThread; 268 269 TrackBase(const TrackBase&); 270 TrackBase& operator = (const TrackBase&); 271 272 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0; 273 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 274 275 int format() const { 276 return mFormat; 277 } 278 279 int channelCount() const ; 280 281 int sampleRate() const; 282 283 void* getBuffer(uint32_t offset, uint32_t frames) const; 284 285 bool isStopped() const { 286 return mState == STOPPED; 287 } 288 289 bool isTerminated() const { 290 return mState == TERMINATED; 291 } 292 293 bool step(); 294 void reset(); 295 296 wp<ThreadBase> mThread; 297 sp<Client> mClient; 298 sp<IMemory> mCblkMemory; 299 audio_track_cblk_t* mCblk; 300 void* mBuffer; 301 void* mBufferEnd; 302 uint32_t mFrameCount; 303 // we don't really need a lock for these 304 int mState; 305 int mClientTid; 306 uint8_t mFormat; 307 uint32_t mFlags; 308 }; 309 310 class ConfigEvent { 311 public: 312 ConfigEvent() : mEvent(0), mParam(0) {} 313 314 int mEvent; 315 int mParam; 316 }; 317 318 uint32_t sampleRate() const; 319 int channelCount() const; 320 int format() const; 321 size_t frameCount() const; 322 void wakeUp() { mWaitWorkCV.broadcast(); } 323 void exit(); 324 virtual bool checkForNewParameters_l() = 0; 325 virtual status_t setParameters(const String8& keyValuePairs); 326 virtual String8 getParameters(const String8& keys) = 0; 327 virtual void audioConfigChanged(int event, int param = 0) = 0; 328 void sendConfigEvent(int event, int param = 0); 329 void sendConfigEvent_l(int event, int param = 0); 330 void processConfigEvents(); 331 int id() const { return mId;} 332 bool standby() { return mStandby; } 333 334 mutable Mutex mLock; 335 336 protected: 337 338 friend class Track; 339 friend class TrackBase; 340 friend class PlaybackThread; 341 friend class MixerThread; 342 friend class DirectOutputThread; 343 friend class DuplicatingThread; 344 friend class RecordThread; 345 friend class RecordTrack; 346 347 Condition mWaitWorkCV; 348 sp<AudioFlinger> mAudioFlinger; 349 uint32_t mSampleRate; 350 size_t mFrameCount; 351 int mChannelCount; 352 int mFormat; 353 uint32_t mFrameSize; 354 Condition mParamCond; 355 Vector<String8> mNewParameters; 356 status_t mParamStatus; 357 Vector<ConfigEvent *> mConfigEvents; 358 bool mStandby; 359 int mId; 360 bool mExiting; 361 }; 362 363 // --- PlaybackThread --- 364 class PlaybackThread : public ThreadBase { 365 public: 366 367 enum type { 368 MIXER, 369 DIRECT, 370 DUPLICATING 371 }; 372 373 enum mixer_state { 374 MIXER_IDLE, 375 MIXER_TRACKS_ENABLED, 376 MIXER_TRACKS_READY 377 }; 378 379 // playback track 380 class Track : public TrackBase { 381 public: 382 Track( const wp<ThreadBase>& thread, 383 const sp<Client>& client, 384 int streamType, 385 uint32_t sampleRate, 386 int format, 387 int channelCount, 388 int frameCount, 389 const sp<IMemory>& sharedBuffer); 390 ~Track(); 391 392 void dump(char* buffer, size_t size); 393 virtual status_t start(); 394 virtual void stop(); 395 void pause(); 396 397 void flush(); 398 void destroy(); 399 void mute(bool); 400 void setVolume(float left, float right); 401 int name() const { 402 return mName; 403 } 404 405 int type() const { 406 return mStreamType; 407 } 408 409 410 protected: 411 friend class ThreadBase; 412 friend class AudioFlinger; 413 friend class TrackHandle; 414 friend class PlaybackThread; 415 friend class MixerThread; 416 friend class DirectOutputThread; 417 418 Track(const Track&); 419 Track& operator = (const Track&); 420 421 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 422 bool isMuted() { return mMute; } 423 bool isPausing() const { 424 return mState == PAUSING; 425 } 426 bool isPaused() const { 427 return mState == PAUSED; 428 } 429 bool isReady() const; 430 void setPaused() { mState = PAUSED; } 431 void reset(); 432 433 bool isOutputTrack() const { 434 return (mStreamType == AudioSystem::NUM_STREAM_TYPES); 435 } 436 437 // we don't really need a lock for these 438 float mVolume[2]; 439 volatile bool mMute; 440 // FILLED state is used for suppressing volume ramp at begin of playing 441 enum {FS_FILLING, FS_FILLED, FS_ACTIVE}; 442 mutable uint8_t mFillingUpStatus; 443 int8_t mRetryCount; 444 sp<IMemory> mSharedBuffer; 445 bool mResetDone; 446 int mStreamType; 447 int mName; 448 }; // end of Track 449 450 451 // playback track 452 class OutputTrack : public Track { 453 public: 454 455 class Buffer: public AudioBufferProvider::Buffer { 456 public: 457 int16_t *mBuffer; 458 }; 459 460 OutputTrack( const wp<ThreadBase>& thread, 461 DuplicatingThread *sourceThread, 462 uint32_t sampleRate, 463 int format, 464 int channelCount, 465 int frameCount); 466 ~OutputTrack(); 467 468 virtual status_t start(); 469 virtual void stop(); 470 bool write(int16_t* data, uint32_t frames); 471 bool bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; } 472 bool isActive() { return mActive; } 473 wp<ThreadBase>& thread() { return mThread; } 474 475 private: 476 477 status_t obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs); 478 void clearBufferQueue(); 479 480 // Maximum number of pending buffers allocated by OutputTrack::write() 481 static const uint8_t kMaxOverFlowBuffers = 10; 482 483 Vector < Buffer* > mBufferQueue; 484 AudioBufferProvider::Buffer mOutBuffer; 485 bool mActive; 486 DuplicatingThread* mSourceThread; 487 }; // end of OutputTrack 488 489 PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id); 490 virtual ~PlaybackThread(); 491 492 virtual status_t dump(int fd, const Vector<String16>& args); 493 494 // Thread virtuals 495 virtual status_t readyToRun(); 496 virtual void onFirstRef(); 497 498 virtual uint32_t latency() const; 499 500 virtual status_t setMasterVolume(float value); 501 virtual status_t setMasterMute(bool muted); 502 503 virtual float masterVolume() const; 504 virtual bool masterMute() const; 505 506 virtual status_t setStreamVolume(int stream, float value); 507 virtual status_t setStreamMute(int stream, bool muted); 508 509 virtual float streamVolume(int stream) const; 510 virtual bool streamMute(int stream) const; 511 512 bool isStreamActive(int stream) const; 513 514 sp<Track> createTrack_l( 515 const sp<AudioFlinger::Client>& client, 516 int streamType, 517 uint32_t sampleRate, 518 int format, 519 int channelCount, 520 int frameCount, 521 const sp<IMemory>& sharedBuffer, 522 status_t *status); 523 524 AudioStreamOut* getOutput() { return mOutput; } 525 526 virtual int type() const { return mType; } 527 void suspend() { mSuspended++; } 528 void restore() { if (mSuspended) mSuspended--; } 529 bool isSuspended() { return (mSuspended != 0); } 530 virtual String8 getParameters(const String8& keys); 531 virtual void audioConfigChanged(int event, int param = 0); 532 virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames); 533 534 struct stream_type_t { 535 stream_type_t() 536 : volume(1.0f), 537 mute(false) 538 { 539 } 540 float volume; 541 bool mute; 542 }; 543 544 protected: 545 int mType; 546 int16_t* mMixBuffer; 547 int mSuspended; 548 int mBytesWritten; 549 bool mMasterMute; 550 SortedVector< wp<Track> > mActiveTracks; 551 552 virtual int getTrackName_l() = 0; 553 virtual void deleteTrackName_l(int name) = 0; 554 virtual uint32_t activeSleepTimeUs() = 0; 555 virtual uint32_t idleSleepTimeUs() = 0; 556 557 private: 558 559 friend class AudioFlinger; 560 friend class OutputTrack; 561 friend class Track; 562 friend class TrackBase; 563 friend class MixerThread; 564 friend class DirectOutputThread; 565 friend class DuplicatingThread; 566 567 PlaybackThread(const Client&); 568 PlaybackThread& operator = (const PlaybackThread&); 569 570 status_t addTrack_l(const sp<Track>& track); 571 void destroyTrack_l(const sp<Track>& track); 572 573 void readOutputParameters(); 574 575 virtual status_t dumpInternals(int fd, const Vector<String16>& args); 576 status_t dumpTracks(int fd, const Vector<String16>& args); 577 578 SortedVector< sp<Track> > mTracks; 579 // mStreamTypes[] uses 1 additionnal stream type internally for the OutputTrack used by DuplicatingThread 580 stream_type_t mStreamTypes[AudioSystem::NUM_STREAM_TYPES + 1]; 581 AudioStreamOut* mOutput; 582 float mMasterVolume; 583 nsecs_t mLastWriteTime; 584 int mNumWrites; 585 int mNumDelayedWrites; 586 bool mInWrite; 587 }; 588 589 class MixerThread : public PlaybackThread { 590 public: 591 MixerThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id); 592 virtual ~MixerThread(); 593 594 // Thread virtuals 595 virtual bool threadLoop(); 596 597 void getTracks(SortedVector < sp<Track> >& tracks, 598 SortedVector < wp<Track> >& activeTracks, 599 int streamType); 600 void putTracks(SortedVector < sp<Track> >& tracks, 601 SortedVector < wp<Track> >& activeTracks); 602 virtual bool checkForNewParameters_l(); 603 virtual status_t dumpInternals(int fd, const Vector<String16>& args); 604 605 protected: 606 uint32_t prepareTracks_l(const SortedVector< wp<Track> >& activeTracks, Vector< sp<Track> > *tracksToRemove); 607 virtual int getTrackName_l(); 608 virtual void deleteTrackName_l(int name); 609 virtual uint32_t activeSleepTimeUs(); 610 virtual uint32_t idleSleepTimeUs(); 611 612 AudioMixer* mAudioMixer; 613 }; 614 615 class DirectOutputThread : public PlaybackThread { 616 public: 617 618 DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id); 619 ~DirectOutputThread(); 620 621 // Thread virtuals 622 virtual bool threadLoop(); 623 624 virtual bool checkForNewParameters_l(); 625 626 protected: 627 virtual int getTrackName_l(); 628 virtual void deleteTrackName_l(int name); 629 virtual uint32_t activeSleepTimeUs(); 630 virtual uint32_t idleSleepTimeUs(); 631 632 private: 633 float mLeftVolume; 634 float mRightVolume; 635 }; 636 637 class DuplicatingThread : public MixerThread { 638 public: 639 DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, int id); 640 ~DuplicatingThread(); 641 642 // Thread virtuals 643 virtual bool threadLoop(); 644 void addOutputTrack(MixerThread* thread); 645 void removeOutputTrack(MixerThread* thread); 646 uint32_t waitTimeMs() { return mWaitTimeMs; } 647 protected: 648 virtual uint32_t activeSleepTimeUs(); 649 650 private: 651 bool outputsReady(SortedVector< sp<OutputTrack> > &outputTracks); 652 void updateWaitTime(); 653 654 SortedVector < sp<OutputTrack> > mOutputTracks; 655 uint32_t mWaitTimeMs; 656 }; 657 658 PlaybackThread *checkPlaybackThread_l(int output) const; 659 MixerThread *checkMixerThread_l(int output) const; 660 RecordThread *checkRecordThread_l(int input) const; 661 float streamVolumeInternal(int stream) const { return mStreamTypes[stream].volume; } 662 void audioConfigChanged_l(int event, int ioHandle, void *param2); 663 664 friend class AudioBuffer; 665 666 class TrackHandle : public android::BnAudioTrack { 667 public: 668 TrackHandle(const sp<PlaybackThread::Track>& track); 669 virtual ~TrackHandle(); 670 virtual status_t start(); 671 virtual void stop(); 672 virtual void flush(); 673 virtual void mute(bool); 674 virtual void pause(); 675 virtual void setVolume(float left, float right); 676 virtual sp<IMemory> getCblk() const; 677 virtual status_t onTransact( 678 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 679 private: 680 sp<PlaybackThread::Track> mTrack; 681 }; 682 683 friend class Client; 684 friend class PlaybackThread::Track; 685 686 687 void removeClient_l(pid_t pid); 688 689 690 // record thread 691 class RecordThread : public ThreadBase, public AudioBufferProvider 692 { 693 public: 694 695 // record track 696 class RecordTrack : public TrackBase { 697 public: 698 RecordTrack(const wp<ThreadBase>& thread, 699 const sp<Client>& client, 700 uint32_t sampleRate, 701 int format, 702 int channelCount, 703 int frameCount, 704 uint32_t flags); 705 ~RecordTrack(); 706 707 virtual status_t start(); 708 virtual void stop(); 709 710 bool overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; } 711 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; } 712 713 void dump(char* buffer, size_t size); 714 private: 715 friend class AudioFlinger; 716 friend class RecordThread; 717 718 RecordTrack(const RecordTrack&); 719 RecordTrack& operator = (const RecordTrack&); 720 721 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 722 723 bool mOverflow; 724 }; 725 726 727 RecordThread(const sp<AudioFlinger>& audioFlinger, 728 AudioStreamIn *input, 729 uint32_t sampleRate, 730 uint32_t channels, 731 int id); 732 ~RecordThread(); 733 734 virtual bool threadLoop(); 735 virtual status_t readyToRun() { return NO_ERROR; } 736 virtual void onFirstRef(); 737 738 status_t start(RecordTrack* recordTrack); 739 void stop(RecordTrack* recordTrack); 740 status_t dump(int fd, const Vector<String16>& args); 741 AudioStreamIn* getInput() { return mInput; } 742 743 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 744 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 745 virtual bool checkForNewParameters_l(); 746 virtual String8 getParameters(const String8& keys); 747 virtual void audioConfigChanged(int event, int param = 0); 748 void readInputParameters(); 749 virtual unsigned int getInputFramesLost(); 750 751 private: 752 RecordThread(); 753 AudioStreamIn *mInput; 754 sp<RecordTrack> mActiveTrack; 755 Condition mStartStopCond; 756 AudioResampler *mResampler; 757 int32_t *mRsmpOutBuffer; 758 int16_t *mRsmpInBuffer; 759 size_t mRsmpInIndex; 760 size_t mInputBytes; 761 int mReqChannelCount; 762 uint32_t mReqSampleRate; 763 ssize_t mBytesRead; 764 }; 765 766 class RecordHandle : public android::BnAudioRecord { 767 public: 768 RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack); 769 virtual ~RecordHandle(); 770 virtual status_t start(); 771 virtual void stop(); 772 virtual sp<IMemory> getCblk() const; 773 virtual status_t onTransact( 774 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); 775 private: 776 sp<RecordThread::RecordTrack> mRecordTrack; 777 }; 778 779 friend class RecordThread; 780 friend class PlaybackThread; 781 782 783 mutable Mutex mLock; 784 785 DefaultKeyedVector< pid_t, wp<Client> > mClients; 786 787 mutable Mutex mHardwareLock; 788 AudioHardwareInterface* mAudioHardware; 789 mutable int mHardwareStatus; 790 791 792 DefaultKeyedVector< int, sp<PlaybackThread> > mPlaybackThreads; 793 PlaybackThread::stream_type_t mStreamTypes[AudioSystem::NUM_STREAM_TYPES]; 794 float mMasterVolume; 795 bool mMasterMute; 796 797 DefaultKeyedVector< int, sp<RecordThread> > mRecordThreads; 798 799 SortedVector< sp<IBinder> > mNotificationClients; 800 int mNextThreadId; 801 }; 802 803 // ---------------------------------------------------------------------------- 804 805 }; // namespace android 806 807 #endif // ANDROID_AUDIO_FLINGER_H 808
