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