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