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