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