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
24#include <media/IAudioFlinger.h>
25#include <media/IAudioFlingerClient.h>
26#include <media/IAudioTrack.h>
27#include <media/IAudioRecord.h>
28#include <media/AudioTrack.h>
29
30#include <utils/Atomic.h>
31#include <utils/Errors.h>
32#include <utils/threads.h>
33#include <utils/MemoryDealer.h>
34#include <utils/KeyedVector.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;
47
48
49// ----------------------------------------------------------------------------
50
51#define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
52#define UNLIKELY( exp )     (__builtin_expect( (exp) != 0, false ))
53
54
55// ----------------------------------------------------------------------------
56
57static const nsecs_t kStandbyTimeInNsecs = seconds(3);
58
59class AudioFlinger : public BnAudioFlinger, public IBinder::DeathRecipient
60{
61public:
62    static void instantiate();
63
64    virtual     status_t    dump(int fd, const Vector<String16>& args);
65
66    // IAudioFlinger interface
67    virtual sp<IAudioTrack> createTrack(
68                                pid_t pid,
69                                int streamType,
70                                uint32_t sampleRate,
71                                int format,
72                                int channelCount,
73                                int frameCount,
74                                uint32_t flags,
75                                const sp<IMemory>& sharedBuffer,
76                                status_t *status);
77
78    virtual     uint32_t    sampleRate(int output) const;
79    virtual     int         channelCount(int output) const;
80    virtual     int         format(int output) const;
81    virtual     size_t      frameCount(int output) const;
82    virtual     uint32_t    latency(int output) const;
83
84    virtual     status_t    setMasterVolume(float value);
85    virtual     status_t    setMasterMute(bool muted);
86
87    virtual     float       masterVolume() const;
88    virtual     bool        masterMute() const;
89
90    virtual     status_t    setStreamVolume(int stream, float value);
91    virtual     status_t    setStreamMute(int stream, bool muted);
92
93    virtual     float       streamVolume(int stream) const;
94    virtual     bool        streamMute(int stream) const;
95
96    virtual     status_t    setRouting(int mode, uint32_t routes, uint32_t mask);
97    virtual     uint32_t    getRouting(int mode) const;
98
99    virtual     status_t    setMode(int mode);
100    virtual     int         getMode() const;
101
102    virtual     status_t    setMicMute(bool state);
103    virtual     bool        getMicMute() const;
104
105    virtual     bool        isMusicActive() const;
106
107    virtual     bool        isA2dpEnabled() const;
108
109    virtual     status_t    setParameter(const char* key, const char* value);
110
111    virtual     void        registerClient(const sp<IAudioFlingerClient>& client);
112
113    virtual     size_t      getInputBufferSize(uint32_t sampleRate, int format, int channelCount);
114
115    virtual     void        wakeUp()    { mWaitWorkCV.broadcast(); }
116
117    // IBinder::DeathRecipient
118    virtual     void        binderDied(const wp<IBinder>& who);
119
120    enum hardware_call_state {
121        AUDIO_HW_IDLE = 0,
122        AUDIO_HW_INIT,
123        AUDIO_HW_OUTPUT_OPEN,
124        AUDIO_HW_OUTPUT_CLOSE,
125        AUDIO_HW_INPUT_OPEN,
126        AUDIO_HW_INPUT_CLOSE,
127        AUDIO_HW_STANDBY,
128        AUDIO_HW_SET_MASTER_VOLUME,
129        AUDIO_HW_GET_ROUTING,
130        AUDIO_HW_SET_ROUTING,
131        AUDIO_HW_GET_MODE,
132        AUDIO_HW_SET_MODE,
133        AUDIO_HW_GET_MIC_MUTE,
134        AUDIO_HW_SET_MIC_MUTE,
135        AUDIO_SET_VOICE_VOLUME,
136        AUDIO_SET_PARAMETER,
137    };
138
139    // record interface
140    virtual sp<IAudioRecord> openRecord(
141                                pid_t pid,
142                                int inputSource,
143                                uint32_t sampleRate,
144                                int format,
145                                int channelCount,
146                                int frameCount,
147                                uint32_t flags,
148                                status_t *status);
149
150    virtual     status_t    onTransact(
151                                uint32_t code,
152                                const Parcel& data,
153                                Parcel* reply,
154                                uint32_t flags);
155
156private:
157                            AudioFlinger();
158    virtual                 ~AudioFlinger();
159
160    void                    setOutput(int outputType);
161    void                    doSetOutput(int outputType);
162
163#ifdef WITH_A2DP
164    void                    setA2dpEnabled_l(bool enable);
165    void                    checkA2dpEnabledChange_l();
166#endif
167    static bool             streamForcedToSpeaker(int streamType);
168
169    // Management of forced route to speaker for certain track types.
170    enum force_speaker_command {
171        ACTIVE_TRACK_ADDED = 0,
172        ACTIVE_TRACK_REMOVED,
173        CHECK_ROUTE_RESTORE_TIME,
174        FORCE_ROUTE_RESTORE
175    };
176    void                    handleForcedSpeakerRoute(int command);
177#ifdef WITH_A2DP
178    void                    handleRouteDisablesA2dp_l(int routes);
179#endif
180
181    // Internal dump utilites.
182    status_t dumpPermissionDenial(int fd, const Vector<String16>& args);
183    status_t dumpClients(int fd, const Vector<String16>& args);
184    status_t dumpInternals(int fd, const Vector<String16>& args);
185
186    // --- Client ---
187    class Client : public RefBase {
188    public:
189                            Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
190        virtual             ~Client();
191        const sp<MemoryDealer>&     heap() const;
192        pid_t               pid() const { return mPid; }
193    private:
194                            Client(const Client&);
195                            Client& operator = (const Client&);
196        sp<AudioFlinger>    mAudioFlinger;
197        sp<MemoryDealer>    mMemoryDealer;
198        pid_t               mPid;
199    };
200
201
202    class TrackHandle;
203    class RecordHandle;
204    class AudioRecordThread;
205
206
207    // --- MixerThread ---
208    class MixerThread : public Thread {
209    public:
210
211        // --- Track ---
212
213        // base for record and playback
214        class TrackBase : public AudioBufferProvider, public RefBase {
215
216        public:
217            enum track_state {
218                IDLE,
219                TERMINATED,
220                STOPPED,
221                RESUMING,
222                ACTIVE,
223                PAUSING,
224                PAUSED
225            };
226
227            enum track_flags {
228                STEPSERVER_FAILED = 0x01, //  StepServer could not acquire cblk->lock mutex
229                SYSTEM_FLAGS_MASK = 0x0000ffffUL,
230                // The upper 16 bits are used for track-specific flags.
231            };
232
233                                TrackBase(const sp<MixerThread>& mixerThread,
234                                        const sp<Client>& client,
235                                        uint32_t sampleRate,
236                                        int format,
237                                        int channelCount,
238                                        int frameCount,
239                                        uint32_t flags,
240                                        const sp<IMemory>& sharedBuffer);
241                                ~TrackBase();
242
243            virtual status_t    start() = 0;
244            virtual void        stop() = 0;
245                    sp<IMemory> getCblk() const;
246
247        protected:
248            friend class MixerThread;
249            friend class RecordHandle;
250            friend class AudioRecordThread;
251
252                                TrackBase(const TrackBase&);
253                                TrackBase& operator = (const TrackBase&);
254
255            virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
256            virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
257
258            audio_track_cblk_t* cblk() const {
259                return mCblk;
260            }
261
262            int format() const {
263                return mFormat;
264            }
265
266            int channelCount() const ;
267
268            int sampleRate() const;
269
270            void* getBuffer(uint32_t offset, uint32_t frames) const;
271
272            int name() const {
273                return mName;
274            }
275
276            bool isStopped() const {
277                return mState == STOPPED;
278            }
279
280            bool isTerminated() const {
281                return mState == TERMINATED;
282            }
283
284            bool step();
285            void reset();
286
287            sp<MixerThread>     mMixerThread;
288            sp<Client>          mClient;
289            sp<IMemory>         mCblkMemory;
290            audio_track_cblk_t* mCblk;
291            void*               mBuffer;
292            void*               mBufferEnd;
293            uint32_t            mFrameCount;
294            int                 mName;
295            // we don't really need a lock for these
296            int                 mState;
297            int                 mClientTid;
298            uint8_t             mFormat;
299            uint32_t            mFlags;
300        };
301
302        // playback track
303        class Track : public TrackBase {
304        public:
305                                Track(  const sp<MixerThread>& mixerThread,
306                                        const sp<Client>& client,
307                                        int streamType,
308                                        uint32_t sampleRate,
309                                        int format,
310                                        int channelCount,
311                                        int frameCount,
312                                        const sp<IMemory>& sharedBuffer);
313                                ~Track();
314
315                    void        dump(char* buffer, size_t size);
316            virtual status_t    start();
317            virtual void        stop();
318                    void        pause();
319
320                    void        flush();
321                    void        destroy();
322                    void        mute(bool);
323                    void        setVolume(float left, float right);
324
325                    int type() const {
326                        return mStreamType;
327                    }
328
329
330        protected:
331            friend class MixerThread;
332            friend class AudioFlinger;
333            friend class AudioFlinger::TrackHandle;
334
335                                Track(const Track&);
336                                Track& operator = (const Track&);
337
338            virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
339
340            bool isMuted() const {
341                return (mMute || mMixerThread->mStreamTypes[mStreamType].mute);
342            }
343
344            bool isPausing() const {
345                return mState == PAUSING;
346            }
347
348            bool isPaused() const {
349                return mState == PAUSED;
350            }
351
352            bool isReady() const;
353
354            void setPaused() { mState = PAUSED; }
355            void reset();
356
357            // we don't really need a lock for these
358            float               mVolume[2];
359            volatile bool       mMute;
360            // FILLED state is used for suppressing volume ramp at begin of playing
361            enum {FS_FILLING, FS_FILLED, FS_ACTIVE};
362            mutable uint8_t     mFillingUpStatus;
363            int8_t              mRetryCount;
364            sp<IMemory>         mSharedBuffer;
365            bool                mResetDone;
366            int                 mStreamType;
367        };  // end of Track
368
369        // record track
370        class RecordTrack : public TrackBase {
371        public:
372                                RecordTrack(const sp<MixerThread>& mixerThread,
373                                        const sp<Client>& client,
374                                        int inputSource,
375                                        uint32_t sampleRate,
376                                        int format,
377                                        int channelCount,
378                                        int frameCount,
379                                        uint32_t flags);
380                                ~RecordTrack();
381
382            virtual status_t    start();
383            virtual void        stop();
384
385                    bool        overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; }
386                    bool        setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
387
388                    int         inputSource() const { return mInputSource; }
389
390        private:
391            friend class AudioFlinger;
392            friend class AudioFlinger::RecordHandle;
393            friend class AudioFlinger::AudioRecordThread;
394            friend class MixerThread;
395
396                                RecordTrack(const Track&);
397                                RecordTrack& operator = (const Track&);
398
399            virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
400
401            bool                mOverflow;
402            int                 mInputSource;
403        };
404
405        // playback track
406        class OutputTrack : public Track {
407        public:
408
409            class Buffer: public AudioBufferProvider::Buffer {
410            public:
411                int16_t *mBuffer;
412            };
413
414                                OutputTrack(  const sp<MixerThread>& mixerThread,
415                                        uint32_t sampleRate,
416                                        int format,
417                                        int channelCount,
418                                        int frameCount);
419                                ~OutputTrack();
420
421            virtual status_t    start();
422            virtual void        stop();
423                    void        write(int16_t* data, uint32_t frames);
424                    bool        bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; }
425
426        private:
427
428            status_t            obtainBuffer(AudioBufferProvider::Buffer* buffer);
429            void                clearBufferQueue();
430
431            sp<MixerThread>             mOutputMixerThread;
432            Vector < Buffer* >          mBufferQueue;
433            AudioBufferProvider::Buffer mOutBuffer;
434            uint32_t                    mFramesWritten;
435
436         };  // end of OutputTrack
437
438        MixerThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int outputType);
439        virtual             ~MixerThread();
440
441        virtual     status_t    dump(int fd, const Vector<String16>& args);
442
443        // Thread virtuals
444        virtual     bool        threadLoop();
445        virtual     status_t    readyToRun();
446        virtual     void        onFirstRef();
447
448        virtual     uint32_t    sampleRate() const;
449        virtual     int         channelCount() const;
450        virtual     int         format() const;
451        virtual     size_t      frameCount() const;
452        virtual     uint32_t    latency() const;
453
454        virtual     status_t    setMasterVolume(float value);
455        virtual     status_t    setMasterMute(bool muted);
456
457        virtual     float       masterVolume() const;
458        virtual     bool        masterMute() const;
459
460        virtual     status_t    setStreamVolume(int stream, float value);
461        virtual     status_t    setStreamMute(int stream, bool muted);
462
463        virtual     float       streamVolume(int stream) const;
464        virtual     bool        streamMute(int stream) const;
465
466                    bool        isMusicActive_l() const;
467
468
469                    sp<Track>   createTrack_l(
470                                    const sp<AudioFlinger::Client>& client,
471                                    int streamType,
472                                    uint32_t sampleRate,
473                                    int format,
474                                    int channelCount,
475                                    int frameCount,
476                                    const sp<IMemory>& sharedBuffer,
477                                    status_t *status);
478
479                    void        getTracks_l(SortedVector < sp<Track> >& tracks,
480                                          SortedVector < wp<Track> >& activeTracks);
481                    void        putTracks_l(SortedVector < sp<Track> >& tracks,
482                                          SortedVector < wp<Track> >& activeTracks);
483                    void        setOuputTrack(OutputTrack *track) { mOutputTrack = track; }
484
485        struct  stream_type_t {
486            stream_type_t()
487                :   volume(1.0f),
488                    mute(false)
489            {
490            }
491            float       volume;
492            bool        mute;
493        };
494
495    private:
496
497
498        friend class AudioFlinger;
499        friend class Track;
500        friend class TrackBase;
501        friend class RecordTrack;
502
503        MixerThread(const Client&);
504        MixerThread& operator = (const MixerThread&);
505
506        status_t    addTrack_l(const sp<Track>& track);
507        void        destroyTrack_l(const sp<Track>& track);
508        int         getTrackName_l();
509        void        deleteTrackName_l(int name);
510        void        addActiveTrack_l(const wp<Track>& t);
511        void        removeActiveTrack_l(const wp<Track>& t);
512        size_t      getOutputFrameCount();
513
514        status_t    dumpInternals(int fd, const Vector<String16>& args);
515        status_t    dumpTracks(int fd, const Vector<String16>& args);
516
517        sp<AudioFlinger>                mAudioFlinger;
518        SortedVector< wp<Track> >       mActiveTracks;
519        SortedVector< sp<Track> >       mTracks;
520        stream_type_t                   mStreamTypes[AudioSystem::NUM_STREAM_TYPES];
521        AudioMixer*                     mAudioMixer;
522        AudioStreamOut*                 mOutput;
523        int                             mOutputType;
524        uint32_t                        mSampleRate;
525        size_t                          mFrameCount;
526        int                             mChannelCount;
527        int                             mFormat;
528        int16_t*                        mMixBuffer;
529        float                           mMasterVolume;
530        bool                            mMasterMute;
531        nsecs_t                         mLastWriteTime;
532        int                             mNumWrites;
533        int                             mNumDelayedWrites;
534        bool                            mStandby;
535        bool                            mInWrite;
536        sp <OutputTrack>                mOutputTrack;
537    };
538
539
540    friend class AudioBuffer;
541
542    class TrackHandle : public android::BnAudioTrack {
543    public:
544                            TrackHandle(const sp<MixerThread::Track>& track);
545        virtual             ~TrackHandle();
546        virtual status_t    start();
547        virtual void        stop();
548        virtual void        flush();
549        virtual void        mute(bool);
550        virtual void        pause();
551        virtual void        setVolume(float left, float right);
552        virtual sp<IMemory> getCblk() const;
553        virtual status_t onTransact(
554            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
555    private:
556        sp<MixerThread::Track> mTrack;
557    };
558
559    friend class Client;
560    friend class MixerThread::Track;
561
562
563                void        removeClient(pid_t pid);
564
565
566
567    class RecordHandle : public android::BnAudioRecord {
568    public:
569        RecordHandle(const sp<MixerThread::RecordTrack>& recordTrack);
570        virtual             ~RecordHandle();
571        virtual status_t    start();
572        virtual void        stop();
573        virtual sp<IMemory> getCblk() const;
574        virtual status_t onTransact(
575            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
576    private:
577        sp<MixerThread::RecordTrack> mRecordTrack;
578    };
579
580    // record thread
581    class AudioRecordThread : public Thread
582    {
583    public:
584        AudioRecordThread(AudioHardwareInterface* audioHardware, const sp<AudioFlinger>& audioFlinger);
585        virtual             ~AudioRecordThread();
586        virtual bool        threadLoop();
587        virtual status_t    readyToRun() { return NO_ERROR; }
588        virtual void        onFirstRef() {}
589
590                status_t    start(MixerThread::RecordTrack* recordTrack);
591                void        stop(MixerThread::RecordTrack* recordTrack);
592                void        exit();
593                status_t    dump(int fd, const Vector<String16>& args);
594
595    private:
596                AudioRecordThread();
597                AudioHardwareInterface              *mAudioHardware;
598                sp<AudioFlinger>                    mAudioFlinger;
599                sp<MixerThread::RecordTrack>        mRecordTrack;
600                Mutex                               mLock;
601                Condition                           mWaitWorkCV;
602                Condition                           mStopped;
603                volatile bool                       mActive;
604                status_t                            mStartStatus;
605    };
606
607    friend class AudioRecordThread;
608    friend class MixerThread;
609
610                status_t    startRecord(MixerThread::RecordTrack* recordTrack);
611                void        stopRecord(MixerThread::RecordTrack* recordTrack);
612
613    mutable     Mutex                               mHardwareLock;
614    mutable     Mutex                               mLock;
615    mutable     Condition                           mWaitWorkCV;
616
617                DefaultKeyedVector< pid_t, wp<Client> >     mClients;
618
619                sp<MixerThread>                     mA2dpMixerThread;
620                sp<MixerThread>                     mHardwareMixerThread;
621                AudioHardwareInterface*             mAudioHardware;
622                AudioHardwareInterface*             mA2dpAudioInterface;
623                sp<AudioRecordThread>               mAudioRecordThread;
624                bool                                mA2dpEnabled;
625                bool                                mNotifyA2dpChange;
626    mutable     int                                 mHardwareStatus;
627                SortedVector< wp<IBinder> >         mNotificationClients;
628                int                                 mForcedSpeakerCount;
629                int                                 mA2dpDisableCount;
630
631                // true if A2DP should resume when mA2dpDisableCount returns to zero
632                bool                                mA2dpSuppressed;
633                uint32_t                            mSavedRoute;
634                uint32_t                            mForcedRoute;
635                nsecs_t                             mRouteRestoreTime;
636                bool                                mMusicMuteSaved;
637};
638
639// ----------------------------------------------------------------------------
640
641}; // namespace android
642
643#endif // ANDROID_AUDIO_FLINGER_H
644