AudioFlinger.h revision 1cda6afaf6207a41303e653a6ecd7909d73186eb 
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 "Configuration.h"
22#include <stdint.h>
23#include <sys/types.h>
24#include <limits.h>
25
26#include <common_time/cc_helper.h>
27
28#include <cutils/compiler.h>
29
30#include <media/IAudioFlinger.h>
31#include <media/IAudioFlingerClient.h>
32#include <media/IAudioTrack.h>
33#include <media/IAudioRecord.h>
34#include <media/AudioSystem.h>
35#include <media/AudioTrack.h>
36
37#include <utils/Atomic.h>
38#include <utils/Errors.h>
39#include <utils/threads.h>
40#include <utils/SortedVector.h>
41#include <utils/TypeHelpers.h>
42#include <utils/Vector.h>
43
44#include <binder/BinderService.h>
45#include <binder/MemoryDealer.h>
46
47#include <system/audio.h>
48#include <hardware/audio.h>
49#include <hardware/audio_policy.h>
50
51#include <media/AudioBufferProvider.h>
52#include <media/ExtendedAudioBufferProvider.h>
53#include "FastMixer.h"
54#include <media/nbaio/NBAIO.h>
55#include "AudioWatchdog.h"
56
57#include <powermanager/IPowerManager.h>
58
59#include <media/nbaio/NBLog.h>
60#include <private/media/AudioTrackShared.h>
61
62namespace android {
63
64struct audio_track_cblk_t;
65struct effect_param_cblk_t;
66class AudioMixer;
67class AudioBuffer;
68class AudioResampler;
69class FastMixer;
70class ServerProxy;
71
72// ----------------------------------------------------------------------------
73
74// AudioFlinger has a hard-coded upper limit of 2 channels for capture and playback.
75// There is support for > 2 channel tracks down-mixed to 2 channel output via a down-mix effect.
76// Adding full support for > 2 channel capture or playback would require more than simply changing
77// this #define.  There is an independent hard-coded upper limit in AudioMixer;
78// removing that AudioMixer limit would be necessary but insufficient to support > 2 channels.
79// The macro FCC_2 highlights some (but not all) places where there is are 2-channel assumptions.
80// Search also for "2", "left", "right", "[0]", "[1]", ">> 16", "<< 16", etc.
81#define FCC_2 2     // FCC_2 = Fixed Channel Count 2
82
83static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
84
85#define INCLUDING_FROM_AUDIOFLINGER_H
86
87class AudioFlinger :
88    public BinderService<AudioFlinger>,
89    public BnAudioFlinger
90{
91    friend class BinderService<AudioFlinger>;   // for AudioFlinger()
92public:
93    static const char* getServiceName() ANDROID_API { return "media.audio_flinger"; }
94
95    virtual     status_t    dump(int fd, const Vector<String16>& args);
96
97    // IAudioFlinger interface, in binder opcode order
98    virtual sp<IAudioTrack> createTrack(
99                                audio_stream_type_t streamType,
100                                uint32_t sampleRate,
101                                audio_format_t format,
102                                audio_channel_mask_t channelMask,
103                                size_t *pFrameCount,
104                                IAudioFlinger::track_flags_t *flags,
105                                const sp<IMemory>& sharedBuffer,
106                                audio_io_handle_t output,
107                                pid_t tid,
108                                int *sessionId,
109                                int clientUid,
110                                status_t *status /*non-NULL*/);
111
112    virtual sp<IAudioRecord> openRecord(
113                                audio_io_handle_t input,
114                                uint32_t sampleRate,
115                                audio_format_t format,
116                                audio_channel_mask_t channelMask,
117                                size_t *pFrameCount,
118                                IAudioFlinger::track_flags_t *flags,
119                                pid_t tid,
120                                int *sessionId,
121                                sp<IMemory>& cblk,
122                                sp<IMemory>& buffers,
123                                status_t *status /*non-NULL*/);
124
125    virtual     uint32_t    sampleRate(audio_io_handle_t output) const;
126    virtual     int         channelCount(audio_io_handle_t output) const;
127    virtual     audio_format_t format(audio_io_handle_t output) const;
128    virtual     size_t      frameCount(audio_io_handle_t output) const;
129    virtual     uint32_t    latency(audio_io_handle_t output) const;
130
131    virtual     status_t    setMasterVolume(float value);
132    virtual     status_t    setMasterMute(bool muted);
133
134    virtual     float       masterVolume() const;
135    virtual     bool        masterMute() const;
136
137    virtual     status_t    setStreamVolume(audio_stream_type_t stream, float value,
138                                            audio_io_handle_t output);
139    virtual     status_t    setStreamMute(audio_stream_type_t stream, bool muted);
140
141    virtual     float       streamVolume(audio_stream_type_t stream,
142                                         audio_io_handle_t output) const;
143    virtual     bool        streamMute(audio_stream_type_t stream) const;
144
145    virtual     status_t    setMode(audio_mode_t mode);
146
147    virtual     status_t    setMicMute(bool state);
148    virtual     bool        getMicMute() const;
149
150    virtual     status_t    setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
151    virtual     String8     getParameters(audio_io_handle_t ioHandle, const String8& keys) const;
152
153    virtual     void        registerClient(const sp<IAudioFlingerClient>& client);
154
155    virtual     size_t      getInputBufferSize(uint32_t sampleRate, audio_format_t format,
156                                               audio_channel_mask_t channelMask) const;
157
158    virtual audio_io_handle_t openOutput(audio_module_handle_t module,
159                                         audio_devices_t *pDevices,
160                                         uint32_t *pSamplingRate,
161                                         audio_format_t *pFormat,
162                                         audio_channel_mask_t *pChannelMask,
163                                         uint32_t *pLatencyMs,
164                                         audio_output_flags_t flags,
165                                         const audio_offload_info_t *offloadInfo);
166
167    virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1,
168                                                  audio_io_handle_t output2);
169
170    virtual status_t closeOutput(audio_io_handle_t output);
171
172    virtual status_t suspendOutput(audio_io_handle_t output);
173
174    virtual status_t restoreOutput(audio_io_handle_t output);
175
176    virtual audio_io_handle_t openInput(audio_module_handle_t module,
177                                        audio_devices_t *pDevices,
178                                        uint32_t *pSamplingRate,
179                                        audio_format_t *pFormat,
180                                        audio_channel_mask_t *pChannelMask);
181
182    virtual status_t closeInput(audio_io_handle_t input);
183
184    virtual status_t invalidateStream(audio_stream_type_t stream);
185
186    virtual status_t setVoiceVolume(float volume);
187
188    virtual status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
189                                       audio_io_handle_t output) const;
190
191    virtual uint32_t getInputFramesLost(audio_io_handle_t ioHandle) const;
192
193    virtual int newAudioSessionId();
194
195    virtual void acquireAudioSessionId(int audioSession, pid_t pid);
196
197    virtual void releaseAudioSessionId(int audioSession, pid_t pid);
198
199    virtual status_t queryNumberEffects(uint32_t *numEffects) const;
200
201    virtual status_t queryEffect(uint32_t index, effect_descriptor_t *descriptor) const;
202
203    virtual status_t getEffectDescriptor(const effect_uuid_t *pUuid,
204                                         effect_descriptor_t *descriptor) const;
205
206    virtual sp<IEffect> createEffect(
207                        effect_descriptor_t *pDesc,
208                        const sp<IEffectClient>& effectClient,
209                        int32_t priority,
210                        audio_io_handle_t io,
211                        int sessionId,
212                        status_t *status /*non-NULL*/,
213                        int *id,
214                        int *enabled);
215
216    virtual status_t moveEffects(int sessionId, audio_io_handle_t srcOutput,
217                        audio_io_handle_t dstOutput);
218
219    virtual audio_module_handle_t loadHwModule(const char *name);
220
221    virtual uint32_t getPrimaryOutputSamplingRate();
222    virtual size_t getPrimaryOutputFrameCount();
223
224    virtual status_t setLowRamDevice(bool isLowRamDevice);
225
226    /* List available audio ports and their attributes */
227    virtual status_t listAudioPorts(unsigned int *num_ports,
228                                    struct audio_port *ports)
229    {
230        return INVALID_OPERATION;
231    }
232
233    /* Get attributes for a given audio port */
234    virtual status_t getAudioPort(struct audio_port *port)
235    {
236        return INVALID_OPERATION;
237    }
238
239    /* Create an audio patch between several source and sink ports */
240    virtual status_t createAudioPatch(const struct audio_patch *patch,
241                                       audio_patch_handle_t *handle)
242    {
243        return INVALID_OPERATION;
244    }
245
246    /* Release an audio patch */
247    virtual status_t releaseAudioPatch(audio_patch_handle_t handle)
248    {
249        return INVALID_OPERATION;
250    }
251
252    /* List existing audio patches */
253    virtual status_t listAudioPatches(unsigned int *num_patches,
254                                      struct audio_patch *patches)
255    {
256        return INVALID_OPERATION;
257    }
258    /* Set audio port configuration */
259    virtual status_t setAudioPortConfig(const struct audio_port_config *config)
260    {
261        return INVALID_OPERATION;
262    }
263
264    virtual     status_t    onTransact(
265                                uint32_t code,
266                                const Parcel& data,
267                                Parcel* reply,
268                                uint32_t flags);
269
270    // end of IAudioFlinger interface
271
272    sp<NBLog::Writer>   newWriter_l(size_t size, const char *name);
273    void                unregisterWriter(const sp<NBLog::Writer>& writer);
274private:
275    static const size_t kLogMemorySize = 40 * 1024;
276    sp<MemoryDealer>    mLogMemoryDealer;   // == 0 when NBLog is disabled
277    // When a log writer is unregistered, it is done lazily so that media.log can continue to see it
278    // for as long as possible.  The memory is only freed when it is needed for another log writer.
279    Vector< sp<NBLog::Writer> > mUnregisteredWriters;
280    Mutex               mUnregisteredWritersLock;
281public:
282
283    class SyncEvent;
284
285    typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
286
287    class SyncEvent : public RefBase {
288    public:
289        SyncEvent(AudioSystem::sync_event_t type,
290                  int triggerSession,
291                  int listenerSession,
292                  sync_event_callback_t callBack,
293                  wp<RefBase> cookie)
294        : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
295          mCallback(callBack), mCookie(cookie)
296        {}
297
298        virtual ~SyncEvent() {}
299
300        void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
301        bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
302        void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
303        AudioSystem::sync_event_t type() const { return mType; }
304        int triggerSession() const { return mTriggerSession; }
305        int listenerSession() const { return mListenerSession; }
306        wp<RefBase> cookie() const { return mCookie; }
307
308    private:
309          const AudioSystem::sync_event_t mType;
310          const int mTriggerSession;
311          const int mListenerSession;
312          sync_event_callback_t mCallback;
313          const wp<RefBase> mCookie;
314          mutable Mutex mLock;
315    };
316
317    sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
318                                        int triggerSession,
319                                        int listenerSession,
320                                        sync_event_callback_t callBack,
321                                        wp<RefBase> cookie);
322
323private:
324    class AudioHwDevice;    // fwd declaration for findSuitableHwDev_l
325
326               audio_mode_t getMode() const { return mMode; }
327
328                bool        btNrecIsOff() const { return mBtNrecIsOff; }
329
330                            AudioFlinger() ANDROID_API;
331    virtual                 ~AudioFlinger();
332
333    // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
334    status_t                initCheck() const { return mPrimaryHardwareDev == NULL ?
335                                                        NO_INIT : NO_ERROR; }
336
337    // RefBase
338    virtual     void        onFirstRef();
339
340    AudioHwDevice*          findSuitableHwDev_l(audio_module_handle_t module,
341                                                audio_devices_t devices);
342    void                    purgeStaleEffects_l();
343
344    // standby delay for MIXER and DUPLICATING playback threads is read from property
345    // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
346    static nsecs_t          mStandbyTimeInNsecs;
347
348    // incremented by 2 when screen state changes, bit 0 == 1 means "off"
349    // AudioFlinger::setParameters() updates, other threads read w/o lock
350    static uint32_t         mScreenState;
351
352    // Internal dump utilities.
353    static const int kDumpLockRetries = 50;
354    static const int kDumpLockSleepUs = 20000;
355    static bool dumpTryLock(Mutex& mutex);
356    void dumpPermissionDenial(int fd, const Vector<String16>& args);
357    void dumpClients(int fd, const Vector<String16>& args);
358    void dumpInternals(int fd, const Vector<String16>& args);
359
360    // --- Client ---
361    class Client : public RefBase {
362    public:
363                            Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
364        virtual             ~Client();
365        sp<MemoryDealer>    heap() const;
366        pid_t               pid() const { return mPid; }
367        sp<AudioFlinger>    audioFlinger() const { return mAudioFlinger; }
368
369        bool reserveTimedTrack();
370        void releaseTimedTrack();
371
372    private:
373                            Client(const Client&);
374                            Client& operator = (const Client&);
375        const sp<AudioFlinger> mAudioFlinger;
376        const sp<MemoryDealer> mMemoryDealer;
377        const pid_t         mPid;
378
379        Mutex               mTimedTrackLock;
380        int                 mTimedTrackCount;
381    };
382
383    // --- Notification Client ---
384    class NotificationClient : public IBinder::DeathRecipient {
385    public:
386                            NotificationClient(const sp<AudioFlinger>& audioFlinger,
387                                                const sp<IAudioFlingerClient>& client,
388                                                pid_t pid);
389        virtual             ~NotificationClient();
390
391                sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
392
393                // IBinder::DeathRecipient
394                virtual     void        binderDied(const wp<IBinder>& who);
395
396    private:
397                            NotificationClient(const NotificationClient&);
398                            NotificationClient& operator = (const NotificationClient&);
399
400        const sp<AudioFlinger>  mAudioFlinger;
401        const pid_t             mPid;
402        const sp<IAudioFlingerClient> mAudioFlingerClient;
403    };
404
405    class TrackHandle;
406    class RecordHandle;
407    class RecordThread;
408    class PlaybackThread;
409    class MixerThread;
410    class DirectOutputThread;
411    class OffloadThread;
412    class DuplicatingThread;
413    class AsyncCallbackThread;
414    class Track;
415    class RecordTrack;
416    class EffectModule;
417    class EffectHandle;
418    class EffectChain;
419    struct AudioStreamOut;
420    struct AudioStreamIn;
421
422    struct  stream_type_t {
423        stream_type_t()
424            :   volume(1.0f),
425                mute(false)
426        {
427        }
428        float       volume;
429        bool        mute;
430    };
431
432    // --- PlaybackThread ---
433
434#include "Threads.h"
435
436#include "Effects.h"
437
438    // server side of the client's IAudioTrack
439    class TrackHandle : public android::BnAudioTrack {
440    public:
441                            TrackHandle(const sp<PlaybackThread::Track>& track);
442        virtual             ~TrackHandle();
443        virtual sp<IMemory> getCblk() const;
444        virtual status_t    start();
445        virtual void        stop();
446        virtual void        flush();
447        virtual void        pause();
448        virtual status_t    attachAuxEffect(int effectId);
449        virtual status_t    allocateTimedBuffer(size_t size,
450                                                sp<IMemory>* buffer);
451        virtual status_t    queueTimedBuffer(const sp<IMemory>& buffer,
452                                             int64_t pts);
453        virtual status_t    setMediaTimeTransform(const LinearTransform& xform,
454                                                  int target);
455        virtual status_t    setParameters(const String8& keyValuePairs);
456        virtual status_t    getTimestamp(AudioTimestamp& timestamp);
457        virtual void        signal(); // signal playback thread for a change in control block
458
459        virtual status_t onTransact(
460            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
461
462    private:
463        const sp<PlaybackThread::Track> mTrack;
464    };
465
466    // server side of the client's IAudioRecord
467    class RecordHandle : public android::BnAudioRecord {
468    public:
469        RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
470        virtual             ~RecordHandle();
471        virtual status_t    start(int /*AudioSystem::sync_event_t*/ event, int triggerSession);
472        virtual void        stop();
473        virtual status_t onTransact(
474            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
475    private:
476        const sp<RecordThread::RecordTrack> mRecordTrack;
477
478        // for use from destructor
479        void                stop_nonvirtual();
480    };
481
482
483              PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
484              MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
485              RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
486              // no range check, AudioFlinger::mLock held
487              bool streamMute_l(audio_stream_type_t stream) const
488                                { return mStreamTypes[stream].mute; }
489              // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held
490              float streamVolume_l(audio_stream_type_t stream) const
491                                { return mStreamTypes[stream].volume; }
492              void audioConfigChanged(int event, audio_io_handle_t ioHandle, const void *param2);
493
494              // Allocate an audio_io_handle_t, session ID, effect ID, or audio_module_handle_t.
495              // They all share the same ID space, but the namespaces are actually independent
496              // because there are separate KeyedVectors for each kind of ID.
497              // The return value is uint32_t, but is cast to signed for some IDs.
498              // FIXME This API does not handle rollover to zero (for unsigned IDs),
499              //       or from positive to negative (for signed IDs).
500              //       Thus it may fail by returning an ID of the wrong sign,
501              //       or by returning a non-unique ID.
502              uint32_t nextUniqueId();
503
504              status_t moveEffectChain_l(int sessionId,
505                                     PlaybackThread *srcThread,
506                                     PlaybackThread *dstThread,
507                                     bool reRegister);
508              // return thread associated with primary hardware device, or NULL
509              PlaybackThread *primaryPlaybackThread_l() const;
510              audio_devices_t primaryOutputDevice_l() const;
511
512              sp<PlaybackThread> getEffectThread_l(int sessionId, int EffectId);
513
514
515                void        removeClient_l(pid_t pid);
516                void        removeNotificationClient(pid_t pid);
517                bool isNonOffloadableGlobalEffectEnabled_l();
518                void onNonOffloadableGlobalEffectEnable();
519
520    class AudioHwDevice {
521    public:
522        enum Flags {
523            AHWD_CAN_SET_MASTER_VOLUME  = 0x1,
524            AHWD_CAN_SET_MASTER_MUTE    = 0x2,
525        };
526
527        AudioHwDevice(const char *moduleName,
528                      audio_hw_device_t *hwDevice,
529                      Flags flags)
530            : mModuleName(strdup(moduleName))
531            , mHwDevice(hwDevice)
532            , mFlags(flags) { }
533        /*virtual*/ ~AudioHwDevice() { free((void *)mModuleName); }
534
535        bool canSetMasterVolume() const {
536            return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
537        }
538
539        bool canSetMasterMute() const {
540            return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
541        }
542
543        const char *moduleName() const { return mModuleName; }
544        audio_hw_device_t *hwDevice() const { return mHwDevice; }
545    private:
546        const char * const mModuleName;
547        audio_hw_device_t * const mHwDevice;
548        const Flags mFlags;
549    };
550
551    // AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
552    // For emphasis, we could also make all pointers to them be "const *",
553    // but that would clutter the code unnecessarily.
554
555    struct AudioStreamOut {
556        AudioHwDevice* const audioHwDev;
557        audio_stream_out_t* const stream;
558        const audio_output_flags_t flags;
559
560        audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
561
562        AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out, audio_output_flags_t flags) :
563            audioHwDev(dev), stream(out), flags(flags) {}
564    };
565
566    struct AudioStreamIn {
567        AudioHwDevice* const audioHwDev;
568        audio_stream_in_t* const stream;
569
570        audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
571
572        AudioStreamIn(AudioHwDevice *dev, audio_stream_in_t *in) :
573            audioHwDev(dev), stream(in) {}
574    };
575
576    // for mAudioSessionRefs only
577    struct AudioSessionRef {
578        AudioSessionRef(int sessionid, pid_t pid) :
579            mSessionid(sessionid), mPid(pid), mCnt(1) {}
580        const int   mSessionid;
581        const pid_t mPid;
582        int         mCnt;
583    };
584
585    mutable     Mutex                               mLock;
586                // protects mClients and mNotificationClients.
587                // must be locked after mLock and ThreadBase::mLock if both must be locked
588                // avoids acquiring AudioFlinger::mLock from inside thread loop.
589    mutable     Mutex                               mClientLock;
590                // protected by mClientLock
591                DefaultKeyedVector< pid_t, wp<Client> >     mClients;   // see ~Client()
592
593                mutable     Mutex                   mHardwareLock;
594                // NOTE: If both mLock and mHardwareLock mutexes must be held,
595                // always take mLock before mHardwareLock
596
597                // These two fields are immutable after onFirstRef(), so no lock needed to access
598                AudioHwDevice*                      mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
599                DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>  mAudioHwDevs;
600
601    // for dump, indicates which hardware operation is currently in progress (but not stream ops)
602    enum hardware_call_state {
603        AUDIO_HW_IDLE = 0,              // no operation in progress
604        AUDIO_HW_INIT,                  // init_check
605        AUDIO_HW_OUTPUT_OPEN,           // open_output_stream
606        AUDIO_HW_OUTPUT_CLOSE,          // unused
607        AUDIO_HW_INPUT_OPEN,            // unused
608        AUDIO_HW_INPUT_CLOSE,           // unused
609        AUDIO_HW_STANDBY,               // unused
610        AUDIO_HW_SET_MASTER_VOLUME,     // set_master_volume
611        AUDIO_HW_GET_ROUTING,           // unused
612        AUDIO_HW_SET_ROUTING,           // unused
613        AUDIO_HW_GET_MODE,              // unused
614        AUDIO_HW_SET_MODE,              // set_mode
615        AUDIO_HW_GET_MIC_MUTE,          // get_mic_mute
616        AUDIO_HW_SET_MIC_MUTE,          // set_mic_mute
617        AUDIO_HW_SET_VOICE_VOLUME,      // set_voice_volume
618        AUDIO_HW_SET_PARAMETER,         // set_parameters
619        AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
620        AUDIO_HW_GET_MASTER_VOLUME,     // get_master_volume
621        AUDIO_HW_GET_PARAMETER,         // get_parameters
622        AUDIO_HW_SET_MASTER_MUTE,       // set_master_mute
623        AUDIO_HW_GET_MASTER_MUTE,       // get_master_mute
624    };
625
626    mutable     hardware_call_state                 mHardwareStatus;    // for dump only
627
628
629                DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> >  mPlaybackThreads;
630                stream_type_t                       mStreamTypes[AUDIO_STREAM_CNT];
631
632                // member variables below are protected by mLock
633                float                               mMasterVolume;
634                bool                                mMasterMute;
635                // end of variables protected by mLock
636
637                DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> >    mRecordThreads;
638
639                // protected by mClientLock
640                DefaultKeyedVector< pid_t, sp<NotificationClient> >    mNotificationClients;
641
642                volatile int32_t                    mNextUniqueId;  // updated by android_atomic_inc
643                // nextUniqueId() returns uint32_t, but this is declared int32_t
644                // because the atomic operations require an int32_t
645
646                audio_mode_t                        mMode;
647                bool                                mBtNrecIsOff;
648
649                // protected by mLock
650                Vector<AudioSessionRef*> mAudioSessionRefs;
651
652                float       masterVolume_l() const;
653                bool        masterMute_l() const;
654                audio_module_handle_t loadHwModule_l(const char *name);
655
656                Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
657                                                             // to be created
658
659private:
660    sp<Client>  registerPid(pid_t pid);    // always returns non-0
661
662    // for use from destructor
663    status_t    closeOutput_nonvirtual(audio_io_handle_t output);
664    status_t    closeInput_nonvirtual(audio_io_handle_t input);
665
666#ifdef TEE_SINK
667    // all record threads serially share a common tee sink, which is re-created on format change
668    sp<NBAIO_Sink>   mRecordTeeSink;
669    sp<NBAIO_Source> mRecordTeeSource;
670#endif
671
672public:
673
674#ifdef TEE_SINK
675    // tee sink, if enabled by property, allows dumpsys to write most recent audio to .wav file
676    static void dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id = 0);
677
678    // whether tee sink is enabled by property
679    static bool mTeeSinkInputEnabled;
680    static bool mTeeSinkOutputEnabled;
681    static bool mTeeSinkTrackEnabled;
682
683    // runtime configured size of each tee sink pipe, in frames
684    static size_t mTeeSinkInputFrames;
685    static size_t mTeeSinkOutputFrames;
686    static size_t mTeeSinkTrackFrames;
687
688    // compile-time default size of tee sink pipes, in frames
689    // 0x200000 stereo 16-bit PCM frames = 47.5 seconds at 44.1 kHz, 8 megabytes
690    static const size_t kTeeSinkInputFramesDefault = 0x200000;
691    static const size_t kTeeSinkOutputFramesDefault = 0x200000;
692    static const size_t kTeeSinkTrackFramesDefault = 0x200000;
693#endif
694
695    // This method reads from a variable without mLock, but the variable is updated under mLock.  So
696    // we might read a stale value, or a value that's inconsistent with respect to other variables.
697    // In this case, it's safe because the return value isn't used for making an important decision.
698    // The reason we don't want to take mLock is because it could block the caller for a long time.
699    bool    isLowRamDevice() const { return mIsLowRamDevice; }
700
701private:
702    bool    mIsLowRamDevice;
703    bool    mIsDeviceTypeKnown;
704    nsecs_t mGlobalEffectEnableTime;  // when a global effect was last enabled
705};
706
707#undef INCLUDING_FROM_AUDIOFLINGER_H
708
709const char *formatToString(audio_format_t format);
710
711// ----------------------------------------------------------------------------
712
713}; // namespace android
714
715#endif // ANDROID_AUDIO_FLINGER_H
716