AudioFlinger.h revision 81784c37c61b09289654b979567a42bf73cd2b12 
1/*
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#ifndef ANDROID_AUDIO_FLINGER_H
19#define ANDROID_AUDIO_FLINGER_H
20
21#include <stdint.h>
22#include <sys/types.h>
23#include <limits.h>
24
25#include <common_time/cc_helper.h>
26
27#include <media/IAudioFlinger.h>
28#include <media/IAudioFlingerClient.h>
29#include <media/IAudioTrack.h>
30#include <media/IAudioRecord.h>
31#include <media/AudioSystem.h>
32#include <media/AudioTrack.h>
33
34#include <utils/Atomic.h>
35#include <utils/Errors.h>
36#include <utils/threads.h>
37#include <utils/SortedVector.h>
38#include <utils/TypeHelpers.h>
39#include <utils/Vector.h>
40
41#include <binder/BinderService.h>
42#include <binder/MemoryDealer.h>
43
44#include <system/audio.h>
45#include <hardware/audio.h>
46#include <hardware/audio_policy.h>
47
48#include <media/AudioBufferProvider.h>
49#include <media/ExtendedAudioBufferProvider.h>
50#include "FastMixer.h"
51#include <media/nbaio/NBAIO.h>
52#include "AudioWatchdog.h"
53
54#include <powermanager/IPowerManager.h>
55
56namespace android {
57
58class audio_track_cblk_t;
59class effect_param_cblk_t;
60class AudioMixer;
61class AudioBuffer;
62class AudioResampler;
63class FastMixer;
64
65// ----------------------------------------------------------------------------
66
67// AudioFlinger has a hard-coded upper limit of 2 channels for capture and playback.
68// There is support for > 2 channel tracks down-mixed to 2 channel output via a down-mix effect.
69// Adding full support for > 2 channel capture or playback would require more than simply changing
70// this #define.  There is an independent hard-coded upper limit in AudioMixer;
71// removing that AudioMixer limit would be necessary but insufficient to support > 2 channels.
72// The macro FCC_2 highlights some (but not all) places where there is are 2-channel assumptions.
73// Search also for "2", "left", "right", "[0]", "[1]", ">> 16", "<< 16", etc.
74#define FCC_2 2     // FCC_2 = Fixed Channel Count 2
75
76static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
77
78#define MAX_GAIN 4096.0f
79#define MAX_GAIN_INT 0x1000
80
81#define INCLUDING_FROM_AUDIOFLINGER_H
82
83class AudioFlinger :
84    public BinderService<AudioFlinger>,
85    public BnAudioFlinger
86{
87    friend class BinderService<AudioFlinger>;   // for AudioFlinger()
88public:
89    static const char* getServiceName() { return "media.audio_flinger"; }
90
91    virtual     status_t    dump(int fd, const Vector<String16>& args);
92
93    // IAudioFlinger interface, in binder opcode order
94    virtual sp<IAudioTrack> createTrack(
95                                pid_t pid,
96                                audio_stream_type_t streamType,
97                                uint32_t sampleRate,
98                                audio_format_t format,
99                                audio_channel_mask_t channelMask,
100                                size_t frameCount,
101                                IAudioFlinger::track_flags_t *flags,
102                                const sp<IMemory>& sharedBuffer,
103                                audio_io_handle_t output,
104                                pid_t tid,
105                                int *sessionId,
106                                status_t *status);
107
108    virtual sp<IAudioRecord> openRecord(
109                                pid_t pid,
110                                audio_io_handle_t input,
111                                uint32_t sampleRate,
112                                audio_format_t format,
113                                audio_channel_mask_t channelMask,
114                                size_t frameCount,
115                                IAudioFlinger::track_flags_t flags,
116                                pid_t tid,
117                                int *sessionId,
118                                status_t *status);
119
120    virtual     uint32_t    sampleRate(audio_io_handle_t output) const;
121    virtual     int         channelCount(audio_io_handle_t output) const;
122    virtual     audio_format_t format(audio_io_handle_t output) const;
123    virtual     size_t      frameCount(audio_io_handle_t output) const;
124    virtual     uint32_t    latency(audio_io_handle_t output) const;
125
126    virtual     status_t    setMasterVolume(float value);
127    virtual     status_t    setMasterMute(bool muted);
128
129    virtual     float       masterVolume() const;
130    virtual     bool        masterMute() const;
131
132    virtual     status_t    setStreamVolume(audio_stream_type_t stream, float value,
133                                            audio_io_handle_t output);
134    virtual     status_t    setStreamMute(audio_stream_type_t stream, bool muted);
135
136    virtual     float       streamVolume(audio_stream_type_t stream,
137                                         audio_io_handle_t output) const;
138    virtual     bool        streamMute(audio_stream_type_t stream) const;
139
140    virtual     status_t    setMode(audio_mode_t mode);
141
142    virtual     status_t    setMicMute(bool state);
143    virtual     bool        getMicMute() const;
144
145    virtual     status_t    setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
146    virtual     String8     getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
147
148    virtual     void        registerClient(const sp<IAudioFlingerClient>& client);
149
150    virtual     size_t      getInputBufferSize(uint32_t sampleRate, audio_format_t format,
151                                               audio_channel_mask_t channelMask) const;
152
153    virtual audio_io_handle_t openOutput(audio_module_handle_t module,
154                                         audio_devices_t *pDevices,
155                                         uint32_t *pSamplingRate,
156                                         audio_format_t *pFormat,
157                                         audio_channel_mask_t *pChannelMask,
158                                         uint32_t *pLatencyMs,
159                                         audio_output_flags_t flags);
160
161    virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
162                                                  audio_io_handle_t output2);
163
164    virtual status_t closeOutput(audio_io_handle_t output);
165
166    virtual status_t suspendOutput(audio_io_handle_t output);
167
168    virtual status_t restoreOutput(audio_io_handle_t output);
169
170    virtual audio_io_handle_t openInput(audio_module_handle_t module,
171                                        audio_devices_t *pDevices,
172                                        uint32_t *pSamplingRate,
173                                        audio_format_t *pFormat,
174                                        audio_channel_mask_t *pChannelMask);
175
176    virtual status_t closeInput(audio_io_handle_t input);
177
178    virtual status_t setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output);
179
180    virtual status_t setVoiceVolume(float volume);
181
182    virtual status_t getRenderPosition(size_t *halFrames, size_t *dspFrames,
183                                       audio_io_handle_t output) const;
184
185    virtual     unsigned int  getInputFramesLost(audio_io_handle_t ioHandle) const;
186
187    virtual int newAudioSessionId();
188
189    virtual void acquireAudioSessionId(int audioSession);
190
191    virtual void releaseAudioSessionId(int audioSession);
192
193    virtual status_t queryNumberEffects(uint32_t *numEffects) const;
194
195    virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
196
197    virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
198                                         effect_descriptor_t *descriptor) const;
199
200    virtual sp<IEffect> createEffect(pid_t pid,
201                        effect_descriptor_t *pDesc,
202                        const sp<IEffectClient>& effectClient,
203                        int32_t priority,
204                        audio_io_handle_t io,
205                        int sessionId,
206                        status_t *status,
207                        int *id,
208                        int *enabled);
209
210    virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,
211                        audio_io_handle_t dstOutput);
212
213    virtual audio_module_handle_t loadHwModule(const char *name);
214
215    virtual uint32_t getPrimaryOutputSamplingRate();
216    virtual size_t getPrimaryOutputFrameCount();
217
218    virtual     status_t    onTransact(
219                                uint32_t code,
220                                const Parcel& data,
221                                Parcel* reply,
222                                uint32_t flags);
223
224    // end of IAudioFlinger interface
225
226    class SyncEvent;
227
228    typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
229
230    class SyncEvent : public RefBase {
231    public:
232        SyncEvent(AudioSystem::sync_event_t type,
233                  int triggerSession,
234                  int listenerSession,
235                  sync_event_callback_t callBack,
236                  void *cookie)
237        : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
238          mCallback(callBack), mCookie(cookie)
239        {}
240
241        virtual ~SyncEvent() {}
242
243        void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
244        bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
245        void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
246        AudioSystem::sync_event_t type() const { return mType; }
247        int triggerSession() const { return mTriggerSession; }
248        int listenerSession() const { return mListenerSession; }
249        void *cookie() const { return mCookie; }
250
251    private:
252          const AudioSystem::sync_event_t mType;
253          const int mTriggerSession;
254          const int mListenerSession;
255          sync_event_callback_t mCallback;
256          void * const mCookie;
257          mutable Mutex mLock;
258    };
259
260    sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
261                                        int triggerSession,
262                                        int listenerSession,
263                                        sync_event_callback_t callBack,
264                                        void *cookie);
265
266private:
267    class AudioHwDevice;    // fwd declaration for findSuitableHwDev_l
268
269               audio_mode_t getMode() const { return mMode; }
270
271                bool        btNrecIsOff() const { return mBtNrecIsOff; }
272
273                            AudioFlinger();
274    virtual                 ~AudioFlinger();
275
276    // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
277    status_t                initCheck() const { return mPrimaryHardwareDev == NULL ?
278                                                        NO_INIT : NO_ERROR; }
279
280    // RefBase
281    virtual     void        onFirstRef();
282
283    AudioHwDevice*          findSuitableHwDev_l(audio_module_handle_t module,
284                                                audio_devices_t devices);
285    void                    purgeStaleEffects_l();
286
287    // standby delay for MIXER and DUPLICATING playback threads is read from property
288    // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
289    static nsecs_t          mStandbyTimeInNsecs;
290
291    // incremented by 2 when screen state changes, bit 0 == 1 means "off"
292    // AudioFlinger::setParameters() updates, other threads read w/o lock
293    static uint32_t         mScreenState;
294
295    // Internal dump utilities.
296    static const int kDumpLockRetries = 50;
297    static const int kDumpLockSleepUs = 20000;
298    static bool dumpTryLock(Mutex& mutex);
299    void dumpPermissionDenial(int fd, const Vector<String16>& args);
300    void dumpClients(int fd, const Vector<String16>& args);
301    void dumpInternals(int fd, const Vector<String16>& args);
302
303    // --- Client ---
304    class Client : public RefBase {
305    public:
306                            Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
307        virtual             ~Client();
308        sp<MemoryDealer>    heap() const;
309        pid_t               pid() const { return mPid; }
310        sp<AudioFlinger>    audioFlinger() const { return mAudioFlinger; }
311
312        bool reserveTimedTrack();
313        void releaseTimedTrack();
314
315    private:
316                            Client(const Client&);
317                            Client& operator = (const Client&);
318        const sp<AudioFlinger> mAudioFlinger;
319        const sp<MemoryDealer> mMemoryDealer;
320        const pid_t         mPid;
321
322        Mutex               mTimedTrackLock;
323        int                 mTimedTrackCount;
324    };
325
326    // --- Notification Client ---
327    class NotificationClient : public IBinder::DeathRecipient {
328    public:
329                            NotificationClient(const sp<AudioFlinger>& audioFlinger,
330                                                const sp<IAudioFlingerClient>& client,
331                                                pid_t pid);
332        virtual             ~NotificationClient();
333
334                sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
335
336                // IBinder::DeathRecipient
337                virtual     void        binderDied(const wp<IBinder>& who);
338
339    private:
340                            NotificationClient(const NotificationClient&);
341                            NotificationClient& operator = (const NotificationClient&);
342
343        const sp<AudioFlinger>  mAudioFlinger;
344        const pid_t             mPid;
345        const sp<IAudioFlingerClient> mAudioFlingerClient;
346    };
347
348    class TrackHandle;
349    class RecordHandle;
350    class RecordThread;
351    class PlaybackThread;
352    class MixerThread;
353    class DirectOutputThread;
354    class DuplicatingThread;
355    class Track;
356    class RecordTrack;
357    class EffectModule;
358    class EffectHandle;
359    class EffectChain;
360    struct AudioStreamOut;
361    struct AudioStreamIn;
362
363    struct  stream_type_t {
364        stream_type_t()
365            :   volume(1.0f),
366                mute(false)
367        {
368        }
369        float       volume;
370        bool        mute;
371    };
372
373    // --- PlaybackThread ---
374
375#include "Threads.h"
376
377#include "Effects.h"
378
379    // server side of the client's IAudioTrack
380    class TrackHandle : public android::BnAudioTrack {
381    public:
382                            TrackHandle(const sp<PlaybackThread::Track>& track);
383        virtual             ~TrackHandle();
384        virtual sp<IMemory> getCblk() const;
385        virtual status_t    start();
386        virtual void        stop();
387        virtual void        flush();
388        virtual void        mute(bool);
389        virtual void        pause();
390        virtual status_t    attachAuxEffect(int effectId);
391        virtual status_t    allocateTimedBuffer(size_t size,
392                                                sp<IMemory>* buffer);
393        virtual status_t    queueTimedBuffer(const sp<IMemory>& buffer,
394                                             int64_t pts);
395        virtual status_t    setMediaTimeTransform(const LinearTransform& xform,
396                                                  int target);
397        virtual status_t onTransact(
398            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
399    private:
400        const sp<PlaybackThread::Track> mTrack;
401    };
402
403    // server side of the client's IAudioRecord
404    class RecordHandle : public android::BnAudioRecord {
405    public:
406        RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
407        virtual             ~RecordHandle();
408        virtual sp<IMemory> getCblk() const;
409        virtual status_t    start(int /*AudioSystem::sync_event_t*/ event, int triggerSession);
410        virtual void        stop();
411        virtual status_t onTransact(
412            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
413    private:
414        const sp<RecordThread::RecordTrack> mRecordTrack;
415
416        // for use from destructor
417        void                stop_nonvirtual();
418    };
419
420              PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
421              MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
422              RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
423              // no range check, AudioFlinger::mLock held
424              bool streamMute_l(audio_stream_type_t stream) const
425                                { return mStreamTypes[stream].mute; }
426              // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held
427              float streamVolume_l(audio_stream_type_t stream) const
428                                { return mStreamTypes[stream].volume; }
429              void audioConfigChanged_l(int event, audio_io_handle_t ioHandle, const void *param2);
430
431              // allocate an audio_io_handle_t, session ID, or effect ID
432              uint32_t nextUniqueId();
433
434              status_t moveEffectChain_l(int sessionId,
435                                     PlaybackThread *srcThread,
436                                     PlaybackThread *dstThread,
437                                     bool reRegister);
438              // return thread associated with primary hardware device, or NULL
439              PlaybackThread *primaryPlaybackThread_l() const;
440              audio_devices_t primaryOutputDevice_l() const;
441
442              sp<PlaybackThread> getEffectThread_l(int sessionId, int EffectId);
443
444
445                void        removeClient_l(pid_t pid);
446                void        removeNotificationClient(pid_t pid);
447
448    class AudioHwDevice {
449    public:
450        enum Flags {
451            AHWD_CAN_SET_MASTER_VOLUME  = 0x1,
452            AHWD_CAN_SET_MASTER_MUTE    = 0x2,
453        };
454
455        AudioHwDevice(const char *moduleName,
456                      audio_hw_device_t *hwDevice,
457                      Flags flags)
458            : mModuleName(strdup(moduleName))
459            , mHwDevice(hwDevice)
460            , mFlags(flags) { }
461        /*virtual*/ ~AudioHwDevice() { free((void *)mModuleName); }
462
463        bool canSetMasterVolume() const {
464            return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
465        }
466
467        bool canSetMasterMute() const {
468            return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
469        }
470
471        const char *moduleName() const { return mModuleName; }
472        audio_hw_device_t *hwDevice() const { return mHwDevice; }
473    private:
474        const char * const mModuleName;
475        audio_hw_device_t * const mHwDevice;
476        Flags mFlags;
477    };
478
479    // AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
480    // For emphasis, we could also make all pointers to them be "const *",
481    // but that would clutter the code unnecessarily.
482
483    struct AudioStreamOut {
484        AudioHwDevice* const audioHwDev;
485        audio_stream_out_t* const stream;
486
487        audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
488
489        AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out) :
490            audioHwDev(dev), stream(out) {}
491    };
492
493    struct AudioStreamIn {
494        AudioHwDevice* const audioHwDev;
495        audio_stream_in_t* const stream;
496
497        audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
498
499        AudioStreamIn(AudioHwDevice *dev, audio_stream_in_t *in) :
500            audioHwDev(dev), stream(in) {}
501    };
502
503    // for mAudioSessionRefs only
504    struct AudioSessionRef {
505        AudioSessionRef(int sessionid, pid_t pid) :
506            mSessionid(sessionid), mPid(pid), mCnt(1) {}
507        const int   mSessionid;
508        const pid_t mPid;
509        int         mCnt;
510    };
511
512    mutable     Mutex                               mLock;
513
514                DefaultKeyedVector< pid_t, wp<Client> >     mClients;   // see ~Client()
515
516                mutable     Mutex                   mHardwareLock;
517                // NOTE: If both mLock and mHardwareLock mutexes must be held,
518                // always take mLock before mHardwareLock
519
520                // These two fields are immutable after onFirstRef(), so no lock needed to access
521                AudioHwDevice*                      mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
522                DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>  mAudioHwDevs;
523
524    // for dump, indicates which hardware operation is currently in progress (but not stream ops)
525    enum hardware_call_state {
526        AUDIO_HW_IDLE = 0,              // no operation in progress
527        AUDIO_HW_INIT,                  // init_check
528        AUDIO_HW_OUTPUT_OPEN,           // open_output_stream
529        AUDIO_HW_OUTPUT_CLOSE,          // unused
530        AUDIO_HW_INPUT_OPEN,            // unused
531        AUDIO_HW_INPUT_CLOSE,           // unused
532        AUDIO_HW_STANDBY,               // unused
533        AUDIO_HW_SET_MASTER_VOLUME,     // set_master_volume
534        AUDIO_HW_GET_ROUTING,           // unused
535        AUDIO_HW_SET_ROUTING,           // unused
536        AUDIO_HW_GET_MODE,              // unused
537        AUDIO_HW_SET_MODE,              // set_mode
538        AUDIO_HW_GET_MIC_MUTE,          // get_mic_mute
539        AUDIO_HW_SET_MIC_MUTE,          // set_mic_mute
540        AUDIO_HW_SET_VOICE_VOLUME,      // set_voice_volume
541        AUDIO_HW_SET_PARAMETER,         // set_parameters
542        AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
543        AUDIO_HW_GET_MASTER_VOLUME,     // get_master_volume
544        AUDIO_HW_GET_PARAMETER,         // get_parameters
545        AUDIO_HW_SET_MASTER_MUTE,       // set_master_mute
546        AUDIO_HW_GET_MASTER_MUTE,       // get_master_mute
547    };
548
549    mutable     hardware_call_state                 mHardwareStatus;    // for dump only
550
551
552                DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> >  mPlaybackThreads;
553                stream_type_t                       mStreamTypes[AUDIO_STREAM_CNT];
554
555                // member variables below are protected by mLock
556                float                               mMasterVolume;
557                bool                                mMasterMute;
558                // end of variables protected by mLock
559
560                DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> >    mRecordThreads;
561
562                DefaultKeyedVector< pid_t, sp<NotificationClient> >    mNotificationClients;
563                volatile int32_t                    mNextUniqueId;  // updated by android_atomic_inc
564                audio_mode_t                        mMode;
565                bool                                mBtNrecIsOff;
566
567                // protected by mLock
568                Vector<AudioSessionRef*> mAudioSessionRefs;
569
570                float       masterVolume_l() const;
571                bool        masterMute_l() const;
572                audio_module_handle_t loadHwModule_l(const char *name);
573
574                Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
575                                                             // to be created
576
577private:
578    sp<Client>  registerPid_l(pid_t pid);    // always returns non-0
579
580    // for use from destructor
581    status_t    closeOutput_nonvirtual(audio_io_handle_t output);
582    status_t    closeInput_nonvirtual(audio_io_handle_t input);
583
584    // all record threads serially share a common tee sink, which is re-created on format change
585    sp<NBAIO_Sink>   mRecordTeeSink;
586    sp<NBAIO_Source> mRecordTeeSource;
587
588public:
589    static void dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id = 0);
590};
591
592#undef INCLUDING_FROM_AUDIOFLINGER_H
593
594// ----------------------------------------------------------------------------
595
596}; // namespace android
597
598#endif // ANDROID_AUDIO_FLINGER_H
599