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