AudioFlinger.h revision 117cd9286424888c1c5bf202ebf1e08ae1e6affe 
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 <utils/SortedVector.h>
35#include <utils/Vector.h>
36
37#include <binder/BinderService.h>
38#include <binder/MemoryDealer.h>
39
40#include <hardware_legacy/AudioHardwareInterface.h>
41
42#include "AudioBufferProvider.h"
43
44namespace android {
45
46class audio_track_cblk_t;
47class effect_param_cblk_t;
48class AudioMixer;
49class AudioBuffer;
50class AudioResampler;
51
52
53// ----------------------------------------------------------------------------
54
55#define LIKELY( exp )       (__builtin_expect( (exp) != 0, true  ))
56#define UNLIKELY( exp )     (__builtin_expect( (exp) != 0, false ))
57
58
59// ----------------------------------------------------------------------------
60
61static const nsecs_t kStandbyTimeInNsecs = seconds(3);
62
63class AudioFlinger :
64    public BinderService<AudioFlinger>,
65    public BnAudioFlinger
66{
67    friend class BinderService<AudioFlinger>;
68public:
69    static char const* getServiceName() { return "media.audio_flinger"; }
70
71    virtual     status_t    dump(int fd, const Vector<String16>& args);
72
73    // IAudioFlinger interface
74    virtual sp<IAudioTrack> createTrack(
75                                pid_t pid,
76                                int streamType,
77                                uint32_t sampleRate,
78                                int format,
79                                int channelCount,
80                                int frameCount,
81                                uint32_t flags,
82                                const sp<IMemory>& sharedBuffer,
83                                int output,
84                                int *sessionId,
85                                status_t *status);
86
87    virtual     uint32_t    sampleRate(int output) const;
88    virtual     int         channelCount(int output) const;
89    virtual     int         format(int output) const;
90    virtual     size_t      frameCount(int output) const;
91    virtual     uint32_t    latency(int output) const;
92
93    virtual     status_t    setMasterVolume(float value);
94    virtual     status_t    setMasterMute(bool muted);
95
96    virtual     float       masterVolume() const;
97    virtual     bool        masterMute() const;
98
99    virtual     status_t    setStreamVolume(int stream, float value, int output);
100    virtual     status_t    setStreamMute(int stream, bool muted);
101
102    virtual     float       streamVolume(int stream, int output) const;
103    virtual     bool        streamMute(int stream) const;
104
105    virtual     status_t    setMode(int mode);
106
107    virtual     status_t    setMicMute(bool state);
108    virtual     bool        getMicMute() const;
109
110    virtual     status_t    setParameters(int ioHandle, const String8& keyValuePairs);
111    virtual     String8     getParameters(int ioHandle, const String8& keys);
112
113    virtual     void        registerClient(const sp<IAudioFlingerClient>& client);
114
115    virtual     size_t      getInputBufferSize(uint32_t sampleRate, int format, int channelCount);
116    virtual     unsigned int  getInputFramesLost(int ioHandle);
117
118    virtual int openOutput(uint32_t *pDevices,
119                                    uint32_t *pSamplingRate,
120                                    uint32_t *pFormat,
121                                    uint32_t *pChannels,
122                                    uint32_t *pLatencyMs,
123                                    uint32_t flags);
124
125    virtual int openDuplicateOutput(int output1, int output2);
126
127    virtual status_t closeOutput(int output);
128
129    virtual status_t suspendOutput(int output);
130
131    virtual status_t restoreOutput(int output);
132
133    virtual int openInput(uint32_t *pDevices,
134                            uint32_t *pSamplingRate,
135                            uint32_t *pFormat,
136                            uint32_t *pChannels,
137                            uint32_t acoustics);
138
139    virtual status_t closeInput(int input);
140
141    virtual status_t setStreamOutput(uint32_t stream, int output);
142
143    virtual status_t setVoiceVolume(float volume);
144
145    virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int output);
146
147    virtual int newAudioSessionId();
148
149    virtual status_t loadEffectLibrary(const char *libPath, int *handle);
150
151    virtual status_t unloadEffectLibrary(int handle);
152
153    virtual status_t queryNumberEffects(uint32_t *numEffects);
154
155    virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor);
156
157    virtual status_t getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor);
158
159    virtual sp<IEffect> createEffect(pid_t pid,
160                        effect_descriptor_t *pDesc,
161                        const sp<IEffectClient>& effectClient,
162                        int32_t priority,
163                        int output,
164                        int sessionId,
165                        status_t *status,
166                        int *id,
167                        int *enabled);
168
169    virtual status_t moveEffects(int session, int srcOutput, int dstOutput);
170
171    enum hardware_call_state {
172        AUDIO_HW_IDLE = 0,
173        AUDIO_HW_INIT,
174        AUDIO_HW_OUTPUT_OPEN,
175        AUDIO_HW_OUTPUT_CLOSE,
176        AUDIO_HW_INPUT_OPEN,
177        AUDIO_HW_INPUT_CLOSE,
178        AUDIO_HW_STANDBY,
179        AUDIO_HW_SET_MASTER_VOLUME,
180        AUDIO_HW_GET_ROUTING,
181        AUDIO_HW_SET_ROUTING,
182        AUDIO_HW_GET_MODE,
183        AUDIO_HW_SET_MODE,
184        AUDIO_HW_GET_MIC_MUTE,
185        AUDIO_HW_SET_MIC_MUTE,
186        AUDIO_SET_VOICE_VOLUME,
187        AUDIO_SET_PARAMETER,
188    };
189
190    // record interface
191    virtual sp<IAudioRecord> openRecord(
192                                pid_t pid,
193                                int input,
194                                uint32_t sampleRate,
195                                int format,
196                                int channelCount,
197                                int frameCount,
198                                uint32_t flags,
199                                int *sessionId,
200                                status_t *status);
201
202    virtual     status_t    onTransact(
203                                uint32_t code,
204                                const Parcel& data,
205                                Parcel* reply,
206                                uint32_t flags);
207
208                uint32_t    getMode() { return mMode; }
209
210private:
211                            AudioFlinger();
212    virtual                 ~AudioFlinger();
213
214
215    // Internal dump utilites.
216    status_t dumpPermissionDenial(int fd, const Vector<String16>& args);
217    status_t dumpClients(int fd, const Vector<String16>& args);
218    status_t dumpInternals(int fd, const Vector<String16>& args);
219
220    // --- Client ---
221    class Client : public RefBase {
222    public:
223                            Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
224        virtual             ~Client();
225        const sp<MemoryDealer>&     heap() const;
226        pid_t               pid() const { return mPid; }
227        sp<AudioFlinger>    audioFlinger() { return mAudioFlinger; }
228
229    private:
230                            Client(const Client&);
231                            Client& operator = (const Client&);
232        sp<AudioFlinger>    mAudioFlinger;
233        sp<MemoryDealer>    mMemoryDealer;
234        pid_t               mPid;
235    };
236
237    // --- Notification Client ---
238    class NotificationClient : public IBinder::DeathRecipient {
239    public:
240                            NotificationClient(const sp<AudioFlinger>& audioFlinger,
241                                                const sp<IAudioFlingerClient>& client,
242                                                pid_t pid);
243        virtual             ~NotificationClient();
244
245                sp<IAudioFlingerClient>    client() { return mClient; }
246
247                // IBinder::DeathRecipient
248                virtual     void        binderDied(const wp<IBinder>& who);
249
250    private:
251                            NotificationClient(const NotificationClient&);
252                            NotificationClient& operator = (const NotificationClient&);
253
254        sp<AudioFlinger>        mAudioFlinger;
255        pid_t                   mPid;
256        sp<IAudioFlingerClient> mClient;
257    };
258
259    class TrackHandle;
260    class RecordHandle;
261    class RecordThread;
262    class PlaybackThread;
263    class MixerThread;
264    class DirectOutputThread;
265    class DuplicatingThread;
266    class Track;
267    class RecordTrack;
268    class EffectModule;
269    class EffectHandle;
270    class EffectChain;
271
272    class ThreadBase : public Thread {
273    public:
274        ThreadBase (const sp<AudioFlinger>& audioFlinger, int id);
275        virtual             ~ThreadBase();
276
277        status_t dumpBase(int fd, const Vector<String16>& args);
278
279        // base for record and playback
280        class TrackBase : public AudioBufferProvider, public RefBase {
281
282        public:
283            enum track_state {
284                IDLE,
285                TERMINATED,
286                STOPPED,
287                RESUMING,
288                ACTIVE,
289                PAUSING,
290                PAUSED
291            };
292
293            enum track_flags {
294                STEPSERVER_FAILED = 0x01, //  StepServer could not acquire cblk->lock mutex
295                SYSTEM_FLAGS_MASK = 0x0000ffffUL,
296                // The upper 16 bits are used for track-specific flags.
297            };
298
299                                TrackBase(const wp<ThreadBase>& thread,
300                                        const sp<Client>& client,
301                                        uint32_t sampleRate,
302                                        int format,
303                                        int channelCount,
304                                        int frameCount,
305                                        uint32_t flags,
306                                        const sp<IMemory>& sharedBuffer,
307                                        int sessionId);
308                                ~TrackBase();
309
310            virtual status_t    start() = 0;
311            virtual void        stop() = 0;
312                    sp<IMemory> getCblk() const;
313                    audio_track_cblk_t* cblk() const { return mCblk; }
314                    int         sessionId() { return mSessionId; }
315
316        protected:
317            friend class ThreadBase;
318            friend class RecordHandle;
319            friend class PlaybackThread;
320            friend class RecordThread;
321            friend class MixerThread;
322            friend class DirectOutputThread;
323
324                                TrackBase(const TrackBase&);
325                                TrackBase& operator = (const TrackBase&);
326
327            virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
328            virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
329
330            int format() const {
331                return mFormat;
332            }
333
334            int channelCount() const ;
335
336            int sampleRate() const;
337
338            void* getBuffer(uint32_t offset, uint32_t frames) const;
339
340            bool isStopped() const {
341                return mState == STOPPED;
342            }
343
344            bool isTerminated() const {
345                return mState == TERMINATED;
346            }
347
348            bool step();
349            void reset();
350
351            wp<ThreadBase>      mThread;
352            sp<Client>          mClient;
353            sp<IMemory>         mCblkMemory;
354            audio_track_cblk_t* mCblk;
355            void*               mBuffer;
356            void*               mBufferEnd;
357            uint32_t            mFrameCount;
358            // we don't really need a lock for these
359            int                 mState;
360            int                 mClientTid;
361            uint8_t             mFormat;
362            uint32_t            mFlags;
363            int                 mSessionId;
364        };
365
366        class ConfigEvent {
367        public:
368            ConfigEvent() : mEvent(0), mParam(0) {}
369
370            int mEvent;
371            int mParam;
372        };
373
374                    uint32_t    sampleRate() const;
375                    int         channelCount() const;
376                    int         format() const;
377                    size_t      frameCount() const;
378                    void        wakeUp()    { mWaitWorkCV.broadcast(); }
379                    void        exit();
380        virtual     bool        checkForNewParameters_l() = 0;
381        virtual     status_t    setParameters(const String8& keyValuePairs);
382        virtual     String8     getParameters(const String8& keys) = 0;
383        virtual     void        audioConfigChanged_l(int event, int param = 0) = 0;
384                    void        sendConfigEvent(int event, int param = 0);
385                    void        sendConfigEvent_l(int event, int param = 0);
386                    void        processConfigEvents();
387                    int         id() const { return mId;}
388                    bool        standby() { return mStandby; }
389
390        mutable     Mutex                   mLock;
391
392    protected:
393
394        friend class Track;
395        friend class TrackBase;
396        friend class PlaybackThread;
397        friend class MixerThread;
398        friend class DirectOutputThread;
399        friend class DuplicatingThread;
400        friend class RecordThread;
401        friend class RecordTrack;
402
403                    Condition               mWaitWorkCV;
404                    sp<AudioFlinger>        mAudioFlinger;
405                    uint32_t                mSampleRate;
406                    size_t                  mFrameCount;
407                    uint32_t                mChannels;
408                    uint16_t                mChannelCount;
409                    uint16_t                mFrameSize;
410                    int                     mFormat;
411                    Condition               mParamCond;
412                    Vector<String8>         mNewParameters;
413                    status_t                mParamStatus;
414                    Vector<ConfigEvent *>   mConfigEvents;
415                    bool                    mStandby;
416                    int                     mId;
417                    bool                    mExiting;
418    };
419
420    // --- PlaybackThread ---
421    class PlaybackThread : public ThreadBase {
422    public:
423
424        enum type {
425            MIXER,
426            DIRECT,
427            DUPLICATING
428        };
429
430        enum mixer_state {
431            MIXER_IDLE,
432            MIXER_TRACKS_ENABLED,
433            MIXER_TRACKS_READY
434        };
435
436        // playback track
437        class Track : public TrackBase {
438        public:
439                                Track(  const wp<ThreadBase>& thread,
440                                        const sp<Client>& client,
441                                        int streamType,
442                                        uint32_t sampleRate,
443                                        int format,
444                                        int channelCount,
445                                        int frameCount,
446                                        const sp<IMemory>& sharedBuffer,
447                                        int sessionId);
448                                ~Track();
449
450                    void        dump(char* buffer, size_t size);
451            virtual status_t    start();
452            virtual void        stop();
453                    void        pause();
454
455                    void        flush();
456                    void        destroy();
457                    void        mute(bool);
458                    void        setVolume(float left, float right);
459                    int name() const {
460                        return mName;
461                    }
462
463                    int type() const {
464                        return mStreamType;
465                    }
466                    status_t    attachAuxEffect(int EffectId);
467                    void        setAuxBuffer(int EffectId, int32_t *buffer);
468                    int32_t     *auxBuffer() { return mAuxBuffer; }
469                    void        setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }
470                    int16_t     *mainBuffer() { return mMainBuffer; }
471                    int         auxEffectId() { return mAuxEffectId; }
472
473
474        protected:
475            friend class ThreadBase;
476            friend class AudioFlinger;
477            friend class TrackHandle;
478            friend class PlaybackThread;
479            friend class MixerThread;
480            friend class DirectOutputThread;
481
482                                Track(const Track&);
483                                Track& operator = (const Track&);
484
485            virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
486            bool isMuted() { return mMute; }
487            bool isPausing() const {
488                return mState == PAUSING;
489            }
490            bool isPaused() const {
491                return mState == PAUSED;
492            }
493            bool isReady() const;
494            void setPaused() { mState = PAUSED; }
495            void reset();
496
497            bool isOutputTrack() const {
498                return (mStreamType == AudioSystem::NUM_STREAM_TYPES);
499            }
500
501            // we don't really need a lock for these
502            float               mVolume[2];
503            volatile bool       mMute;
504            // FILLED state is used for suppressing volume ramp at begin of playing
505            enum {FS_FILLING, FS_FILLED, FS_ACTIVE};
506            mutable uint8_t     mFillingUpStatus;
507            int8_t              mRetryCount;
508            sp<IMemory>         mSharedBuffer;
509            bool                mResetDone;
510            int                 mStreamType;
511            int                 mName;
512            int16_t             *mMainBuffer;
513            int32_t             *mAuxBuffer;
514            int                 mAuxEffectId;
515            bool                mHasVolumeController;
516        };  // end of Track
517
518
519        // playback track
520        class OutputTrack : public Track {
521        public:
522
523            class Buffer: public AudioBufferProvider::Buffer {
524            public:
525                int16_t *mBuffer;
526            };
527
528                                OutputTrack(  const wp<ThreadBase>& thread,
529                                        DuplicatingThread *sourceThread,
530                                        uint32_t sampleRate,
531                                        int format,
532                                        int channelCount,
533                                        int frameCount);
534                                ~OutputTrack();
535
536            virtual status_t    start();
537            virtual void        stop();
538                    bool        write(int16_t* data, uint32_t frames);
539                    bool        bufferQueueEmpty() { return (mBufferQueue.size() == 0) ? true : false; }
540                    bool        isActive() { return mActive; }
541            wp<ThreadBase>&     thread()  { return mThread; }
542
543        private:
544
545            status_t            obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs);
546            void                clearBufferQueue();
547
548            // Maximum number of pending buffers allocated by OutputTrack::write()
549            static const uint8_t kMaxOverFlowBuffers = 10;
550
551            Vector < Buffer* >          mBufferQueue;
552            AudioBufferProvider::Buffer mOutBuffer;
553            bool                        mActive;
554            DuplicatingThread*          mSourceThread;
555        };  // end of OutputTrack
556
557        PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device);
558        virtual             ~PlaybackThread();
559
560        virtual     status_t    dump(int fd, const Vector<String16>& args);
561
562        // Thread virtuals
563        virtual     status_t    readyToRun();
564        virtual     void        onFirstRef();
565
566        virtual     uint32_t    latency() const;
567
568        virtual     status_t    setMasterVolume(float value);
569        virtual     status_t    setMasterMute(bool muted);
570
571        virtual     float       masterVolume() const;
572        virtual     bool        masterMute() const;
573
574        virtual     status_t    setStreamVolume(int stream, float value);
575        virtual     status_t    setStreamMute(int stream, bool muted);
576
577        virtual     float       streamVolume(int stream) const;
578        virtual     bool        streamMute(int stream) const;
579
580                    sp<Track>   createTrack_l(
581                                    const sp<AudioFlinger::Client>& client,
582                                    int streamType,
583                                    uint32_t sampleRate,
584                                    int format,
585                                    int channelCount,
586                                    int frameCount,
587                                    const sp<IMemory>& sharedBuffer,
588                                    int sessionId,
589                                    status_t *status);
590
591                    AudioStreamOut* getOutput() { return mOutput; }
592
593        virtual     int         type() const { return mType; }
594                    void        suspend() { mSuspended++; }
595                    void        restore() { if (mSuspended) mSuspended--; }
596                    bool        isSuspended() { return (mSuspended != 0); }
597        virtual     String8     getParameters(const String8& keys);
598        virtual     void        audioConfigChanged_l(int event, int param = 0);
599        virtual     status_t    getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
600                    int16_t     *mixBuffer() { return mMixBuffer; };
601
602                    sp<EffectHandle> createEffect_l(
603                                        const sp<AudioFlinger::Client>& client,
604                                        const sp<IEffectClient>& effectClient,
605                                        int32_t priority,
606                                        int sessionId,
607                                        effect_descriptor_t *desc,
608                                        int *enabled,
609                                        status_t *status);
610                    void disconnectEffect(const sp< EffectModule>& effect,
611                                          const wp<EffectHandle>& handle);
612
613                    // return values for hasAudioSession (bit field)
614                    enum effect_state {
615                        EFFECT_SESSION = 0x1,   // the audio session corresponds to at least one
616                                                // effect
617                        TRACK_SESSION = 0x2     // the audio session corresponds to at least one
618                                                // track
619                    };
620
621                    uint32_t hasAudioSession(int sessionId);
622                    sp<EffectChain> getEffectChain(int sessionId);
623                    sp<EffectChain> getEffectChain_l(int sessionId);
624                    status_t addEffectChain_l(const sp<EffectChain>& chain);
625                    size_t removeEffectChain_l(const sp<EffectChain>& chain);
626                    void lockEffectChains_l(Vector<sp <EffectChain> >& effectChains);
627                    void unlockEffectChains(Vector<sp <EffectChain> >& effectChains);
628
629                    sp<AudioFlinger::EffectModule> getEffect_l(int sessionId, int effectId);
630                    void detachAuxEffect_l(int effectId);
631                    status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track,
632                            int EffectId);
633                    status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track,
634                            int EffectId);
635                    void setMode(uint32_t mode);
636
637                    status_t addEffect_l(const sp< EffectModule>& effect);
638                    void removeEffect_l(const sp< EffectModule>& effect);
639
640                    uint32_t getStrategyForSession_l(int sessionId);
641
642        struct  stream_type_t {
643            stream_type_t()
644                :   volume(1.0f),
645                    mute(false)
646            {
647            }
648            float       volume;
649            bool        mute;
650        };
651
652    protected:
653        int                             mType;
654        int16_t*                        mMixBuffer;
655        int                             mSuspended;
656        int                             mBytesWritten;
657        bool                            mMasterMute;
658        SortedVector< wp<Track> >       mActiveTracks;
659
660        virtual int             getTrackName_l() = 0;
661        virtual void            deleteTrackName_l(int name) = 0;
662        virtual uint32_t        activeSleepTimeUs() = 0;
663        virtual uint32_t        idleSleepTimeUs() = 0;
664        virtual uint32_t        suspendSleepTimeUs() = 0;
665
666    private:
667
668        friend class AudioFlinger;
669        friend class OutputTrack;
670        friend class Track;
671        friend class TrackBase;
672        friend class MixerThread;
673        friend class DirectOutputThread;
674        friend class DuplicatingThread;
675
676        PlaybackThread(const Client&);
677        PlaybackThread& operator = (const PlaybackThread&);
678
679        status_t    addTrack_l(const sp<Track>& track);
680        void        destroyTrack_l(const sp<Track>& track);
681
682        void        readOutputParameters();
683
684        uint32_t    device() { return mDevice; }
685
686        virtual status_t    dumpInternals(int fd, const Vector<String16>& args);
687        status_t    dumpTracks(int fd, const Vector<String16>& args);
688        status_t    dumpEffectChains(int fd, const Vector<String16>& args);
689
690        SortedVector< sp<Track> >       mTracks;
691        // mStreamTypes[] uses 1 additionnal stream type internally for the OutputTrack used by DuplicatingThread
692        stream_type_t                   mStreamTypes[AudioSystem::NUM_STREAM_TYPES + 1];
693        AudioStreamOut*                 mOutput;
694        float                           mMasterVolume;
695        nsecs_t                         mLastWriteTime;
696        int                             mNumWrites;
697        int                             mNumDelayedWrites;
698        bool                            mInWrite;
699        Vector< sp<EffectChain> >       mEffectChains;
700        uint32_t                        mDevice;
701    };
702
703    class MixerThread : public PlaybackThread {
704    public:
705        MixerThread (const sp<AudioFlinger>& audioFlinger,
706                     AudioStreamOut* output,
707                     int id,
708                     uint32_t device);
709        virtual             ~MixerThread();
710
711        // Thread virtuals
712        virtual     bool        threadLoop();
713
714                    void        invalidateTracks(int streamType);
715        virtual     bool        checkForNewParameters_l();
716        virtual     status_t    dumpInternals(int fd, const Vector<String16>& args);
717
718    protected:
719                    uint32_t    prepareTracks_l(const SortedVector< wp<Track> >& activeTracks,
720                                                Vector< sp<Track> > *tracksToRemove);
721        virtual     int         getTrackName_l();
722        virtual     void        deleteTrackName_l(int name);
723        virtual     uint32_t    activeSleepTimeUs();
724        virtual     uint32_t    idleSleepTimeUs();
725        virtual     uint32_t    suspendSleepTimeUs();
726
727        AudioMixer*                     mAudioMixer;
728    };
729
730    class DirectOutputThread : public PlaybackThread {
731    public:
732
733        DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device);
734        ~DirectOutputThread();
735
736        // Thread virtuals
737        virtual     bool        threadLoop();
738
739        virtual     bool        checkForNewParameters_l();
740
741    protected:
742        virtual     int         getTrackName_l();
743        virtual     void        deleteTrackName_l(int name);
744        virtual     uint32_t    activeSleepTimeUs();
745        virtual     uint32_t    idleSleepTimeUs();
746        virtual     uint32_t    suspendSleepTimeUs();
747
748    private:
749        void applyVolume(uint16_t leftVol, uint16_t rightVol, bool ramp);
750
751        float mLeftVolFloat;
752        float mRightVolFloat;
753        uint16_t mLeftVolShort;
754        uint16_t mRightVolShort;
755    };
756
757    class DuplicatingThread : public MixerThread {
758    public:
759        DuplicatingThread (const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread, int id);
760        ~DuplicatingThread();
761
762        // Thread virtuals
763        virtual     bool        threadLoop();
764                    void        addOutputTrack(MixerThread* thread);
765                    void        removeOutputTrack(MixerThread* thread);
766                    uint32_t    waitTimeMs() { return mWaitTimeMs; }
767    protected:
768        virtual     uint32_t    activeSleepTimeUs();
769
770    private:
771                    bool        outputsReady(SortedVector< sp<OutputTrack> > &outputTracks);
772                    void        updateWaitTime();
773
774        SortedVector < sp<OutputTrack> >  mOutputTracks;
775                    uint32_t    mWaitTimeMs;
776    };
777
778              PlaybackThread *checkPlaybackThread_l(int output) const;
779              MixerThread *checkMixerThread_l(int output) const;
780              RecordThread *checkRecordThread_l(int input) const;
781              float streamVolumeInternal(int stream) const { return mStreamTypes[stream].volume; }
782              void audioConfigChanged_l(int event, int ioHandle, void *param2);
783
784              int  nextUniqueId_l();
785              status_t moveEffectChain_l(int session,
786                                     AudioFlinger::PlaybackThread *srcThread,
787                                     AudioFlinger::PlaybackThread *dstThread,
788                                     bool reRegister);
789
790    friend class AudioBuffer;
791
792    class TrackHandle : public android::BnAudioTrack {
793    public:
794                            TrackHandle(const sp<PlaybackThread::Track>& track);
795        virtual             ~TrackHandle();
796        virtual status_t    start();
797        virtual void        stop();
798        virtual void        flush();
799        virtual void        mute(bool);
800        virtual void        pause();
801        virtual void        setVolume(float left, float right);
802        virtual sp<IMemory> getCblk() const;
803        virtual status_t    attachAuxEffect(int effectId);
804        virtual status_t onTransact(
805            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
806    private:
807        sp<PlaybackThread::Track> mTrack;
808    };
809
810    friend class Client;
811    friend class PlaybackThread::Track;
812
813
814                void        removeClient_l(pid_t pid);
815                void        removeNotificationClient(pid_t pid);
816
817
818    // record thread
819    class RecordThread : public ThreadBase, public AudioBufferProvider
820    {
821    public:
822
823        // record track
824        class RecordTrack : public TrackBase {
825        public:
826                                RecordTrack(const wp<ThreadBase>& thread,
827                                        const sp<Client>& client,
828                                        uint32_t sampleRate,
829                                        int format,
830                                        int channelCount,
831                                        int frameCount,
832                                        uint32_t flags,
833                                        int sessionId);
834                                ~RecordTrack();
835
836            virtual status_t    start();
837            virtual void        stop();
838
839                    bool        overflow() { bool tmp = mOverflow; mOverflow = false; return tmp; }
840                    bool        setOverflow() { bool tmp = mOverflow; mOverflow = true; return tmp; }
841
842                    void        dump(char* buffer, size_t size);
843        private:
844            friend class AudioFlinger;
845            friend class RecordThread;
846
847                                RecordTrack(const RecordTrack&);
848                                RecordTrack& operator = (const RecordTrack&);
849
850            virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
851
852            bool                mOverflow;
853        };
854
855
856                RecordThread(const sp<AudioFlinger>& audioFlinger,
857                        AudioStreamIn *input,
858                        uint32_t sampleRate,
859                        uint32_t channels,
860                        int id);
861                ~RecordThread();
862
863        virtual bool        threadLoop();
864        virtual status_t    readyToRun() { return NO_ERROR; }
865        virtual void        onFirstRef();
866
867                status_t    start(RecordTrack* recordTrack);
868                void        stop(RecordTrack* recordTrack);
869                status_t    dump(int fd, const Vector<String16>& args);
870                AudioStreamIn* getInput() { return mInput; }
871
872        virtual status_t    getNextBuffer(AudioBufferProvider::Buffer* buffer);
873        virtual void        releaseBuffer(AudioBufferProvider::Buffer* buffer);
874        virtual bool        checkForNewParameters_l();
875        virtual String8     getParameters(const String8& keys);
876        virtual void        audioConfigChanged_l(int event, int param = 0);
877                void        readInputParameters();
878        virtual unsigned int  getInputFramesLost();
879
880    private:
881                RecordThread();
882                AudioStreamIn                       *mInput;
883                sp<RecordTrack>                     mActiveTrack;
884                Condition                           mStartStopCond;
885                AudioResampler                      *mResampler;
886                int32_t                             *mRsmpOutBuffer;
887                int16_t                             *mRsmpInBuffer;
888                size_t                              mRsmpInIndex;
889                size_t                              mInputBytes;
890                int                                 mReqChannelCount;
891                uint32_t                            mReqSampleRate;
892                ssize_t                             mBytesRead;
893    };
894
895    class RecordHandle : public android::BnAudioRecord {
896    public:
897        RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
898        virtual             ~RecordHandle();
899        virtual status_t    start();
900        virtual void        stop();
901        virtual sp<IMemory> getCblk() const;
902        virtual status_t onTransact(
903            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
904    private:
905        sp<RecordThread::RecordTrack> mRecordTrack;
906    };
907
908    //--- Audio Effect Management
909
910    // EffectModule and EffectChain classes both have their own mutex to protect
911    // state changes or resource modifications. Always respect the following order
912    // if multiple mutexes must be acquired to avoid cross deadlock:
913    // AudioFlinger -> ThreadBase -> EffectChain -> EffectModule
914
915    // The EffectModule class is a wrapper object controlling the effect engine implementation
916    // in the effect library. It prevents concurrent calls to process() and command() functions
917    // from different client threads. It keeps a list of EffectHandle objects corresponding
918    // to all client applications using this effect and notifies applications of effect state,
919    // control or parameter changes. It manages the activation state machine to send appropriate
920    // reset, enable, disable commands to effect engine and provide volume
921    // ramping when effects are activated/deactivated.
922    // When controlling an auxiliary effect, the EffectModule also provides an input buffer used by
923    // the attached track(s) to accumulate their auxiliary channel.
924    class EffectModule: public RefBase {
925    public:
926        EffectModule(const wp<ThreadBase>& wThread,
927                        const wp<AudioFlinger::EffectChain>& chain,
928                        effect_descriptor_t *desc,
929                        int id,
930                        int sessionId);
931        ~EffectModule();
932
933        enum effect_state {
934            IDLE,
935            RESTART,
936            STARTING,
937            ACTIVE,
938            STOPPING,
939            STOPPED
940        };
941
942        int         id() { return mId; }
943        void process();
944        void updateState();
945        status_t command(uint32_t cmdCode,
946                         uint32_t cmdSize,
947                         void *pCmdData,
948                         uint32_t *replySize,
949                         void *pReplyData);
950
951        void reset_l();
952        status_t configure();
953        status_t init();
954        uint32_t state() {
955            return mState;
956        }
957        uint32_t status() {
958            return mStatus;
959        }
960        int sessionId() {
961            return mSessionId;
962        }
963        status_t    setEnabled(bool enabled);
964        bool isEnabled();
965        bool isProcessEnabled();
966
967        void        setInBuffer(int16_t *buffer) { mConfig.inputCfg.buffer.s16 = buffer; }
968        int16_t     *inBuffer() { return mConfig.inputCfg.buffer.s16; }
969        void        setOutBuffer(int16_t *buffer) { mConfig.outputCfg.buffer.s16 = buffer; }
970        int16_t     *outBuffer() { return mConfig.outputCfg.buffer.s16; }
971        void        setChain(const wp<EffectChain>& chain) { mChain = chain; }
972        void        setThread(const wp<ThreadBase>& thread) { mThread = thread; }
973
974        status_t addHandle(sp<EffectHandle>& handle);
975        void disconnect(const wp<EffectHandle>& handle);
976        size_t removeHandle (const wp<EffectHandle>& handle);
977
978        effect_descriptor_t& desc() { return mDescriptor; }
979        wp<EffectChain>&     chain() { return mChain; }
980
981        status_t         setDevice(uint32_t device);
982        status_t         setVolume(uint32_t *left, uint32_t *right, bool controller);
983        status_t         setMode(uint32_t mode);
984
985        status_t         dump(int fd, const Vector<String16>& args);
986
987    protected:
988
989        // Maximum time allocated to effect engines to complete the turn off sequence
990        static const uint32_t MAX_DISABLE_TIME_MS = 10000;
991
992        EffectModule(const EffectModule&);
993        EffectModule& operator = (const EffectModule&);
994
995        status_t start_l();
996        status_t stop_l();
997
998        // update this table when AudioSystem::audio_devices or audio_device_e (in EffectApi.h) are modified
999        static const uint32_t sDeviceConvTable[];
1000        static uint32_t deviceAudioSystemToEffectApi(uint32_t device);
1001
1002        // update this table when AudioSystem::audio_mode or audio_mode_e (in EffectApi.h) are modified
1003        static const uint32_t sModeConvTable[];
1004        static int modeAudioSystemToEffectApi(uint32_t mode);
1005
1006        Mutex               mLock;      // mutex for process, commands and handles list protection
1007        wp<ThreadBase>      mThread;    // parent thread
1008        wp<EffectChain>     mChain;     // parent effect chain
1009        int                 mId;        // this instance unique ID
1010        int                 mSessionId; // audio session ID
1011        effect_descriptor_t mDescriptor;// effect descriptor received from effect engine
1012        effect_config_t     mConfig;    // input and output audio configuration
1013        effect_interface_t  mEffectInterface; // Effect module C API
1014        status_t mStatus;               // initialization status
1015        uint32_t mState;                // current activation state (effect_state)
1016        Vector< wp<EffectHandle> > mHandles;    // list of client handles
1017        uint32_t mMaxDisableWaitCnt;    // maximum grace period before forcing an effect off after
1018                                        // sending disable command.
1019        uint32_t mDisableWaitCnt;       // current process() calls count during disable period.
1020    };
1021
1022    // The EffectHandle class implements the IEffect interface. It provides resources
1023    // to receive parameter updates, keeps track of effect control
1024    // ownership and state and has a pointer to the EffectModule object it is controlling.
1025    // There is one EffectHandle object for each application controlling (or using)
1026    // an effect module.
1027    // The EffectHandle is obtained by calling AudioFlinger::createEffect().
1028    class EffectHandle: public android::BnEffect {
1029    public:
1030
1031        EffectHandle(const sp<EffectModule>& effect,
1032                const sp<AudioFlinger::Client>& client,
1033                const sp<IEffectClient>& effectClient,
1034                int32_t priority);
1035        virtual ~EffectHandle();
1036
1037        // IEffect
1038        virtual status_t enable();
1039        virtual status_t disable();
1040        virtual status_t command(uint32_t cmdCode,
1041                                 uint32_t cmdSize,
1042                                 void *pCmdData,
1043                                 uint32_t *replySize,
1044                                 void *pReplyData);
1045        virtual void disconnect();
1046        virtual sp<IMemory> getCblk() const;
1047        virtual status_t onTransact(uint32_t code, const Parcel& data,
1048                Parcel* reply, uint32_t flags);
1049
1050
1051        // Give or take control of effect module
1052        void setControl(bool hasControl, bool signal);
1053        void commandExecuted(uint32_t cmdCode,
1054                             uint32_t cmdSize,
1055                             void *pCmdData,
1056                             uint32_t replySize,
1057                             void *pReplyData);
1058        void setEnabled(bool enabled);
1059
1060        // Getters
1061        int id() { return mEffect->id(); }
1062        int priority() { return mPriority; }
1063        bool hasControl() { return mHasControl; }
1064        sp<EffectModule> effect() { return mEffect; }
1065
1066        void dump(char* buffer, size_t size);
1067
1068    protected:
1069
1070        EffectHandle(const EffectHandle&);
1071        EffectHandle& operator =(const EffectHandle&);
1072
1073        sp<EffectModule> mEffect;           // pointer to controlled EffectModule
1074        sp<IEffectClient> mEffectClient;    // callback interface for client notifications
1075        sp<Client>          mClient;        // client for shared memory allocation
1076        sp<IMemory>         mCblkMemory;    // shared memory for control block
1077        effect_param_cblk_t* mCblk;         // control block for deferred parameter setting via shared memory
1078        uint8_t*            mBuffer;        // pointer to parameter area in shared memory
1079        int mPriority;                      // client application priority to control the effect
1080        bool mHasControl;                   // true if this handle is controlling the effect
1081    };
1082
1083    // the EffectChain class represents a group of effects associated to one audio session.
1084    // There can be any number of EffectChain objects per output mixer thread (PlaybackThread).
1085    // The EffecChain with session ID 0 contains global effects applied to the output mix.
1086    // Effects in this chain can be insert or auxiliary. Effects in other chains (attached to tracks)
1087    // are insert only. The EffectChain maintains an ordered list of effect module, the order corresponding
1088    // in the effect process order. When attached to a track (session ID != 0), it also provide it's own
1089    // input buffer used by the track as accumulation buffer.
1090    class EffectChain: public RefBase {
1091    public:
1092        EffectChain(const wp<ThreadBase>& wThread, int sessionId);
1093        ~EffectChain();
1094
1095        void process_l();
1096
1097        void lock() {
1098            mLock.lock();
1099        }
1100        void unlock() {
1101            mLock.unlock();
1102        }
1103
1104        status_t addEffect_l(const sp<EffectModule>& handle);
1105        size_t removeEffect_l(const sp<EffectModule>& handle);
1106
1107        int sessionId() {
1108            return mSessionId;
1109        }
1110
1111        sp<EffectModule> getEffectFromDesc_l(effect_descriptor_t *descriptor);
1112        sp<EffectModule> getEffectFromId_l(int id);
1113        bool setVolume_l(uint32_t *left, uint32_t *right);
1114        void setDevice_l(uint32_t device);
1115        void setMode_l(uint32_t mode);
1116
1117        void setInBuffer(int16_t *buffer, bool ownsBuffer = false) {
1118            mInBuffer = buffer;
1119            mOwnInBuffer = ownsBuffer;
1120        }
1121        int16_t *inBuffer() {
1122            return mInBuffer;
1123        }
1124        void setOutBuffer(int16_t *buffer) {
1125            mOutBuffer = buffer;
1126        }
1127        int16_t *outBuffer() {
1128            return mOutBuffer;
1129        }
1130
1131        void startTrack() {mActiveTrackCnt++;}
1132        void stopTrack() {mActiveTrackCnt--;}
1133        int activeTracks() { return mActiveTrackCnt;}
1134
1135        uint32_t strategy() { return mStrategy; }
1136        void setStrategy(uint32_t strategy)
1137                 { mStrategy = strategy; }
1138
1139        status_t dump(int fd, const Vector<String16>& args);
1140
1141    protected:
1142
1143        EffectChain(const EffectChain&);
1144        EffectChain& operator =(const EffectChain&);
1145
1146        wp<ThreadBase> mThread;     // parent mixer thread
1147        Mutex mLock;                // mutex protecting effect list
1148        Vector<sp<EffectModule> > mEffects; // list of effect modules
1149        int mSessionId;             // audio session ID
1150        int16_t *mInBuffer;         // chain input buffer
1151        int16_t *mOutBuffer;        // chain output buffer
1152        int mActiveTrackCnt;        // number of active tracks connected
1153        bool mOwnInBuffer;          // true if the chain owns its input buffer
1154        int mVolumeCtrlIdx;         // index of insert effect having control over volume
1155        uint32_t mLeftVolume;       // previous volume on left channel
1156        uint32_t mRightVolume;      // previous volume on right channel
1157        uint32_t mNewLeftVolume;       // new volume on left channel
1158        uint32_t mNewRightVolume;      // new volume on right channel
1159        uint32_t mStrategy; // strategy for this effect chain
1160    };
1161
1162    friend class RecordThread;
1163    friend class PlaybackThread;
1164
1165
1166    mutable     Mutex                               mLock;
1167
1168                DefaultKeyedVector< pid_t, wp<Client> >     mClients;
1169
1170                mutable     Mutex                   mHardwareLock;
1171                AudioHardwareInterface*             mAudioHardware;
1172    mutable     int                                 mHardwareStatus;
1173
1174
1175                DefaultKeyedVector< int, sp<PlaybackThread> >  mPlaybackThreads;
1176                PlaybackThread::stream_type_t       mStreamTypes[AudioSystem::NUM_STREAM_TYPES];
1177                float                               mMasterVolume;
1178                bool                                mMasterMute;
1179
1180                DefaultKeyedVector< int, sp<RecordThread> >    mRecordThreads;
1181
1182                DefaultKeyedVector< pid_t, sp<NotificationClient> >    mNotificationClients;
1183                volatile int32_t                    mNextUniqueId;
1184                uint32_t mMode;
1185
1186};
1187
1188// ----------------------------------------------------------------------------
1189
1190}; // namespace android
1191
1192#endif // ANDROID_AUDIO_FLINGER_H
1193