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