Home | History | Annotate | Download | only in audioflinger
      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 
     65 namespace android {
     66 
     67 struct audio_track_cblk_t;
     68 struct effect_param_cblk_t;
     69 class AudioMixer;
     70 class AudioBuffer;
     71 class AudioResampler;
     72 class FastMixer;
     73 class 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 
     86 static const nsecs_t kDefaultStandbyTimeInNsecs = seconds(3);
     87 
     88 #define INCLUDING_FROM_AUDIOFLINGER_H
     89 
     90 class AudioFlinger :
     91     public BinderService<AudioFlinger>,
     92     public BnAudioFlinger
     93 {
     94     friend class BinderService<AudioFlinger>;   // for AudioFlinger()
     95 public:
     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     /* Get the HW synchronization source used for an audio session */
    252     virtual audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId);
    253 
    254     virtual     status_t    onTransact(
    255                                 uint32_t code,
    256                                 const Parcel& data,
    257                                 Parcel* reply,
    258                                 uint32_t flags);
    259 
    260     // end of IAudioFlinger interface
    261 
    262     sp<NBLog::Writer>   newWriter_l(size_t size, const char *name);
    263     void                unregisterWriter(const sp<NBLog::Writer>& writer);
    264 private:
    265     static const size_t kLogMemorySize = 40 * 1024;
    266     sp<MemoryDealer>    mLogMemoryDealer;   // == 0 when NBLog is disabled
    267     // When a log writer is unregistered, it is done lazily so that media.log can continue to see it
    268     // for as long as possible.  The memory is only freed when it is needed for another log writer.
    269     Vector< sp<NBLog::Writer> > mUnregisteredWriters;
    270     Mutex               mUnregisteredWritersLock;
    271 public:
    272 
    273     class SyncEvent;
    274 
    275     typedef void (*sync_event_callback_t)(const wp<SyncEvent>& event) ;
    276 
    277     class SyncEvent : public RefBase {
    278     public:
    279         SyncEvent(AudioSystem::sync_event_t type,
    280                   int triggerSession,
    281                   int listenerSession,
    282                   sync_event_callback_t callBack,
    283                   wp<RefBase> cookie)
    284         : mType(type), mTriggerSession(triggerSession), mListenerSession(listenerSession),
    285           mCallback(callBack), mCookie(cookie)
    286         {}
    287 
    288         virtual ~SyncEvent() {}
    289 
    290         void trigger() { Mutex::Autolock _l(mLock); if (mCallback) mCallback(this); }
    291         bool isCancelled() const { Mutex::Autolock _l(mLock); return (mCallback == NULL); }
    292         void cancel() { Mutex::Autolock _l(mLock); mCallback = NULL; }
    293         AudioSystem::sync_event_t type() const { return mType; }
    294         int triggerSession() const { return mTriggerSession; }
    295         int listenerSession() const { return mListenerSession; }
    296         wp<RefBase> cookie() const { return mCookie; }
    297 
    298     private:
    299           const AudioSystem::sync_event_t mType;
    300           const int mTriggerSession;
    301           const int mListenerSession;
    302           sync_event_callback_t mCallback;
    303           const wp<RefBase> mCookie;
    304           mutable Mutex mLock;
    305     };
    306 
    307     sp<SyncEvent> createSyncEvent(AudioSystem::sync_event_t type,
    308                                         int triggerSession,
    309                                         int listenerSession,
    310                                         sync_event_callback_t callBack,
    311                                         wp<RefBase> cookie);
    312 
    313 private:
    314     class AudioHwDevice;    // fwd declaration for findSuitableHwDev_l
    315 
    316                audio_mode_t getMode() const { return mMode; }
    317 
    318                 bool        btNrecIsOff() const { return mBtNrecIsOff; }
    319 
    320                             AudioFlinger() ANDROID_API;
    321     virtual                 ~AudioFlinger();
    322 
    323     // call in any IAudioFlinger method that accesses mPrimaryHardwareDev
    324     status_t                initCheck() const { return mPrimaryHardwareDev == NULL ?
    325                                                         NO_INIT : NO_ERROR; }
    326 
    327     // RefBase
    328     virtual     void        onFirstRef();
    329 
    330     AudioHwDevice*          findSuitableHwDev_l(audio_module_handle_t module,
    331                                                 audio_devices_t devices);
    332     void                    purgeStaleEffects_l();
    333 
    334     // Set kEnableExtendedChannels to true to enable greater than stereo output
    335     // for the MixerThread and device sink.  Number of channels allowed is
    336     // FCC_2 <= channels <= AudioMixer::MAX_NUM_CHANNELS.
    337     static const bool kEnableExtendedChannels = true;
    338 
    339     // Returns true if channel mask is permitted for the PCM sink in the MixerThread
    340     static inline bool isValidPcmSinkChannelMask(audio_channel_mask_t channelMask) {
    341         switch (audio_channel_mask_get_representation(channelMask)) {
    342         case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
    343             uint32_t channelCount = FCC_2; // stereo is default
    344             if (kEnableExtendedChannels) {
    345                 channelCount = audio_channel_count_from_out_mask(channelMask);
    346                 if (channelCount < FCC_2 // mono is not supported at this time
    347                         || channelCount > AudioMixer::MAX_NUM_CHANNELS) {
    348                     return false;
    349                 }
    350             }
    351             // check that channelMask is the "canonical" one we expect for the channelCount.
    352             return channelMask == audio_channel_out_mask_from_count(channelCount);
    353             }
    354         default:
    355             return false;
    356         }
    357     }
    358 
    359     // Set kEnableExtendedPrecision to true to use extended precision in MixerThread
    360     static const bool kEnableExtendedPrecision = true;
    361 
    362     // Returns true if format is permitted for the PCM sink in the MixerThread
    363     static inline bool isValidPcmSinkFormat(audio_format_t format) {
    364         switch (format) {
    365         case AUDIO_FORMAT_PCM_16_BIT:
    366             return true;
    367         case AUDIO_FORMAT_PCM_FLOAT:
    368         case AUDIO_FORMAT_PCM_24_BIT_PACKED:
    369         case AUDIO_FORMAT_PCM_32_BIT:
    370         case AUDIO_FORMAT_PCM_8_24_BIT:
    371             return kEnableExtendedPrecision;
    372         default:
    373             return false;
    374         }
    375     }
    376 
    377     // standby delay for MIXER and DUPLICATING playback threads is read from property
    378     // ro.audio.flinger_standbytime_ms or defaults to kDefaultStandbyTimeInNsecs
    379     static nsecs_t          mStandbyTimeInNsecs;
    380 
    381     // incremented by 2 when screen state changes, bit 0 == 1 means "off"
    382     // AudioFlinger::setParameters() updates, other threads read w/o lock
    383     static uint32_t         mScreenState;
    384 
    385     // Internal dump utilities.
    386     static const int kDumpLockRetries = 50;
    387     static const int kDumpLockSleepUs = 20000;
    388     static bool dumpTryLock(Mutex& mutex);
    389     void dumpPermissionDenial(int fd, const Vector<String16>& args);
    390     void dumpClients(int fd, const Vector<String16>& args);
    391     void dumpInternals(int fd, const Vector<String16>& args);
    392 
    393     // --- Client ---
    394     class Client : public RefBase {
    395     public:
    396                             Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);
    397         virtual             ~Client();
    398         sp<MemoryDealer>    heap() const;
    399         pid_t               pid() const { return mPid; }
    400         sp<AudioFlinger>    audioFlinger() const { return mAudioFlinger; }
    401 
    402         bool reserveTimedTrack();
    403         void releaseTimedTrack();
    404 
    405     private:
    406                             Client(const Client&);
    407                             Client& operator = (const Client&);
    408         const sp<AudioFlinger> mAudioFlinger;
    409         const sp<MemoryDealer> mMemoryDealer;
    410         const pid_t         mPid;
    411 
    412         Mutex               mTimedTrackLock;
    413         int                 mTimedTrackCount;
    414     };
    415 
    416     // --- Notification Client ---
    417     class NotificationClient : public IBinder::DeathRecipient {
    418     public:
    419                             NotificationClient(const sp<AudioFlinger>& audioFlinger,
    420                                                 const sp<IAudioFlingerClient>& client,
    421                                                 pid_t pid);
    422         virtual             ~NotificationClient();
    423 
    424                 sp<IAudioFlingerClient> audioFlingerClient() const { return mAudioFlingerClient; }
    425 
    426                 // IBinder::DeathRecipient
    427                 virtual     void        binderDied(const wp<IBinder>& who);
    428 
    429     private:
    430                             NotificationClient(const NotificationClient&);
    431                             NotificationClient& operator = (const NotificationClient&);
    432 
    433         const sp<AudioFlinger>  mAudioFlinger;
    434         const pid_t             mPid;
    435         const sp<IAudioFlingerClient> mAudioFlingerClient;
    436     };
    437 
    438     class TrackHandle;
    439     class RecordHandle;
    440     class RecordThread;
    441     class PlaybackThread;
    442     class MixerThread;
    443     class DirectOutputThread;
    444     class OffloadThread;
    445     class DuplicatingThread;
    446     class AsyncCallbackThread;
    447     class Track;
    448     class RecordTrack;
    449     class EffectModule;
    450     class EffectHandle;
    451     class EffectChain;
    452     struct AudioStreamOut;
    453     struct AudioStreamIn;
    454 
    455     struct  stream_type_t {
    456         stream_type_t()
    457             :   volume(1.0f),
    458                 mute(false)
    459         {
    460         }
    461         float       volume;
    462         bool        mute;
    463     };
    464 
    465     // --- PlaybackThread ---
    466 
    467 #include "Threads.h"
    468 
    469 #include "Effects.h"
    470 
    471 #include "PatchPanel.h"
    472 
    473     // server side of the client's IAudioTrack
    474     class TrackHandle : public android::BnAudioTrack {
    475     public:
    476                             TrackHandle(const sp<PlaybackThread::Track>& track);
    477         virtual             ~TrackHandle();
    478         virtual sp<IMemory> getCblk() const;
    479         virtual status_t    start();
    480         virtual void        stop();
    481         virtual void        flush();
    482         virtual void        pause();
    483         virtual status_t    attachAuxEffect(int effectId);
    484         virtual status_t    allocateTimedBuffer(size_t size,
    485                                                 sp<IMemory>* buffer);
    486         virtual status_t    queueTimedBuffer(const sp<IMemory>& buffer,
    487                                              int64_t pts);
    488         virtual status_t    setMediaTimeTransform(const LinearTransform& xform,
    489                                                   int target);
    490         virtual status_t    setParameters(const String8& keyValuePairs);
    491         virtual status_t    getTimestamp(AudioTimestamp& timestamp);
    492         virtual void        signal(); // signal playback thread for a change in control block
    493 
    494         virtual status_t onTransact(
    495             uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
    496 
    497     private:
    498         const sp<PlaybackThread::Track> mTrack;
    499     };
    500 
    501     // server side of the client's IAudioRecord
    502     class RecordHandle : public android::BnAudioRecord {
    503     public:
    504         RecordHandle(const sp<RecordThread::RecordTrack>& recordTrack);
    505         virtual             ~RecordHandle();
    506         virtual status_t    start(int /*AudioSystem::sync_event_t*/ event, int triggerSession);
    507         virtual void        stop();
    508         virtual status_t onTransact(
    509             uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
    510     private:
    511         const sp<RecordThread::RecordTrack> mRecordTrack;
    512 
    513         // for use from destructor
    514         void                stop_nonvirtual();
    515     };
    516 
    517 
    518               PlaybackThread *checkPlaybackThread_l(audio_io_handle_t output) const;
    519               MixerThread *checkMixerThread_l(audio_io_handle_t output) const;
    520               RecordThread *checkRecordThread_l(audio_io_handle_t input) const;
    521               sp<RecordThread> openInput_l(audio_module_handle_t module,
    522                                            audio_io_handle_t *input,
    523                                            audio_config_t *config,
    524                                            audio_devices_t device,
    525                                            const String8& address,
    526                                            audio_source_t source,
    527                                            audio_input_flags_t flags);
    528               sp<PlaybackThread> openOutput_l(audio_module_handle_t module,
    529                                               audio_io_handle_t *output,
    530                                               audio_config_t *config,
    531                                               audio_devices_t devices,
    532                                               const String8& address,
    533                                               audio_output_flags_t flags);
    534 
    535               void closeOutputFinish(sp<PlaybackThread> thread);
    536               void closeInputFinish(sp<RecordThread> thread);
    537 
    538               // no range check, AudioFlinger::mLock held
    539               bool streamMute_l(audio_stream_type_t stream) const
    540                                 { return mStreamTypes[stream].mute; }
    541               // no range check, doesn't check per-thread stream volume, AudioFlinger::mLock held
    542               float streamVolume_l(audio_stream_type_t stream) const
    543                                 { return mStreamTypes[stream].volume; }
    544               void audioConfigChanged(int event, audio_io_handle_t ioHandle, const void *param2);
    545 
    546               // Allocate an audio_io_handle_t, session ID, effect ID, or audio_module_handle_t.
    547               // They all share the same ID space, but the namespaces are actually independent
    548               // because there are separate KeyedVectors for each kind of ID.
    549               // The return value is uint32_t, but is cast to signed for some IDs.
    550               // FIXME This API does not handle rollover to zero (for unsigned IDs),
    551               //       or from positive to negative (for signed IDs).
    552               //       Thus it may fail by returning an ID of the wrong sign,
    553               //       or by returning a non-unique ID.
    554               uint32_t nextUniqueId();
    555 
    556               status_t moveEffectChain_l(int sessionId,
    557                                      PlaybackThread *srcThread,
    558                                      PlaybackThread *dstThread,
    559                                      bool reRegister);
    560               // return thread associated with primary hardware device, or NULL
    561               PlaybackThread *primaryPlaybackThread_l() const;
    562               audio_devices_t primaryOutputDevice_l() const;
    563 
    564               sp<PlaybackThread> getEffectThread_l(int sessionId, int EffectId);
    565 
    566 
    567                 void        removeClient_l(pid_t pid);
    568                 void        removeNotificationClient(pid_t pid);
    569                 bool isNonOffloadableGlobalEffectEnabled_l();
    570                 void onNonOffloadableGlobalEffectEnable();
    571 
    572                 // Store an effect chain to mOrphanEffectChains keyed vector.
    573                 // Called when a thread exits and effects are still attached to it.
    574                 // If effects are later created on the same session, they will reuse the same
    575                 // effect chain and same instances in the effect library.
    576                 // return ALREADY_EXISTS if a chain with the same session already exists in
    577                 // mOrphanEffectChains. Note that this should never happen as there is only one
    578                 // chain for a given session and it is attached to only one thread at a time.
    579                 status_t        putOrphanEffectChain_l(const sp<EffectChain>& chain);
    580                 // Get an effect chain for the specified session in mOrphanEffectChains and remove
    581                 // it if found. Returns 0 if not found (this is the most common case).
    582                 sp<EffectChain> getOrphanEffectChain_l(audio_session_t session);
    583                 // Called when the last effect handle on an effect instance is removed. If this
    584                 // effect belongs to an effect chain in mOrphanEffectChains, the chain is updated
    585                 // and removed from mOrphanEffectChains if it does not contain any effect.
    586                 // Return true if the effect was found in mOrphanEffectChains, false otherwise.
    587                 bool            updateOrphanEffectChains(const sp<EffectModule>& effect);
    588 
    589     class AudioHwDevice {
    590     public:
    591         enum Flags {
    592             AHWD_CAN_SET_MASTER_VOLUME  = 0x1,
    593             AHWD_CAN_SET_MASTER_MUTE    = 0x2,
    594         };
    595 
    596         AudioHwDevice(audio_module_handle_t handle,
    597                       const char *moduleName,
    598                       audio_hw_device_t *hwDevice,
    599                       Flags flags)
    600             : mHandle(handle), mModuleName(strdup(moduleName))
    601             , mHwDevice(hwDevice)
    602             , mFlags(flags) { }
    603         /*virtual*/ ~AudioHwDevice() { free((void *)mModuleName); }
    604 
    605         bool canSetMasterVolume() const {
    606             return (0 != (mFlags & AHWD_CAN_SET_MASTER_VOLUME));
    607         }
    608 
    609         bool canSetMasterMute() const {
    610             return (0 != (mFlags & AHWD_CAN_SET_MASTER_MUTE));
    611         }
    612 
    613         audio_module_handle_t handle() const { return mHandle; }
    614         const char *moduleName() const { return mModuleName; }
    615         audio_hw_device_t *hwDevice() const { return mHwDevice; }
    616         uint32_t version() const { return mHwDevice->common.version; }
    617 
    618     private:
    619         const audio_module_handle_t mHandle;
    620         const char * const mModuleName;
    621         audio_hw_device_t * const mHwDevice;
    622         const Flags mFlags;
    623     };
    624 
    625     // AudioStreamOut and AudioStreamIn are immutable, so their fields are const.
    626     // For emphasis, we could also make all pointers to them be "const *",
    627     // but that would clutter the code unnecessarily.
    628 
    629     struct AudioStreamOut {
    630         AudioHwDevice* const audioHwDev;
    631         audio_stream_out_t* const stream;
    632         const audio_output_flags_t flags;
    633 
    634         audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
    635 
    636         AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out, audio_output_flags_t flags) :
    637             audioHwDev(dev), stream(out), flags(flags) {}
    638     };
    639 
    640     struct AudioStreamIn {
    641         AudioHwDevice* const audioHwDev;
    642         audio_stream_in_t* const stream;
    643 
    644         audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }
    645 
    646         AudioStreamIn(AudioHwDevice *dev, audio_stream_in_t *in) :
    647             audioHwDev(dev), stream(in) {}
    648     };
    649 
    650     // for mAudioSessionRefs only
    651     struct AudioSessionRef {
    652         AudioSessionRef(int sessionid, pid_t pid) :
    653             mSessionid(sessionid), mPid(pid), mCnt(1) {}
    654         const int   mSessionid;
    655         const pid_t mPid;
    656         int         mCnt;
    657     };
    658 
    659     mutable     Mutex                               mLock;
    660                 // protects mClients and mNotificationClients.
    661                 // must be locked after mLock and ThreadBase::mLock if both must be locked
    662                 // avoids acquiring AudioFlinger::mLock from inside thread loop.
    663     mutable     Mutex                               mClientLock;
    664                 // protected by mClientLock
    665                 DefaultKeyedVector< pid_t, wp<Client> >     mClients;   // see ~Client()
    666 
    667                 mutable     Mutex                   mHardwareLock;
    668                 // NOTE: If both mLock and mHardwareLock mutexes must be held,
    669                 // always take mLock before mHardwareLock
    670 
    671                 // These two fields are immutable after onFirstRef(), so no lock needed to access
    672                 AudioHwDevice*                      mPrimaryHardwareDev; // mAudioHwDevs[0] or NULL
    673                 DefaultKeyedVector<audio_module_handle_t, AudioHwDevice*>  mAudioHwDevs;
    674 
    675     // for dump, indicates which hardware operation is currently in progress (but not stream ops)
    676     enum hardware_call_state {
    677         AUDIO_HW_IDLE = 0,              // no operation in progress
    678         AUDIO_HW_INIT,                  // init_check
    679         AUDIO_HW_OUTPUT_OPEN,           // open_output_stream
    680         AUDIO_HW_OUTPUT_CLOSE,          // unused
    681         AUDIO_HW_INPUT_OPEN,            // unused
    682         AUDIO_HW_INPUT_CLOSE,           // unused
    683         AUDIO_HW_STANDBY,               // unused
    684         AUDIO_HW_SET_MASTER_VOLUME,     // set_master_volume
    685         AUDIO_HW_GET_ROUTING,           // unused
    686         AUDIO_HW_SET_ROUTING,           // unused
    687         AUDIO_HW_GET_MODE,              // unused
    688         AUDIO_HW_SET_MODE,              // set_mode
    689         AUDIO_HW_GET_MIC_MUTE,          // get_mic_mute
    690         AUDIO_HW_SET_MIC_MUTE,          // set_mic_mute
    691         AUDIO_HW_SET_VOICE_VOLUME,      // set_voice_volume
    692         AUDIO_HW_SET_PARAMETER,         // set_parameters
    693         AUDIO_HW_GET_INPUT_BUFFER_SIZE, // get_input_buffer_size
    694         AUDIO_HW_GET_MASTER_VOLUME,     // get_master_volume
    695         AUDIO_HW_GET_PARAMETER,         // get_parameters
    696         AUDIO_HW_SET_MASTER_MUTE,       // set_master_mute
    697         AUDIO_HW_GET_MASTER_MUTE,       // get_master_mute
    698     };
    699 
    700     mutable     hardware_call_state                 mHardwareStatus;    // for dump only
    701 
    702 
    703                 DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> >  mPlaybackThreads;
    704                 stream_type_t                       mStreamTypes[AUDIO_STREAM_CNT];
    705 
    706                 // member variables below are protected by mLock
    707                 float                               mMasterVolume;
    708                 bool                                mMasterMute;
    709                 // end of variables protected by mLock
    710 
    711                 DefaultKeyedVector< audio_io_handle_t, sp<RecordThread> >    mRecordThreads;
    712 
    713                 // protected by mClientLock
    714                 DefaultKeyedVector< pid_t, sp<NotificationClient> >    mNotificationClients;
    715 
    716                 volatile int32_t                    mNextUniqueId;  // updated by android_atomic_inc
    717                 // nextUniqueId() returns uint32_t, but this is declared int32_t
    718                 // because the atomic operations require an int32_t
    719 
    720                 audio_mode_t                        mMode;
    721                 bool                                mBtNrecIsOff;
    722 
    723                 // protected by mLock
    724                 Vector<AudioSessionRef*> mAudioSessionRefs;
    725 
    726                 float       masterVolume_l() const;
    727                 bool        masterMute_l() const;
    728                 audio_module_handle_t loadHwModule_l(const char *name);
    729 
    730                 Vector < sp<SyncEvent> > mPendingSyncEvents; // sync events awaiting for a session
    731                                                              // to be created
    732 
    733                 // Effect chains without a valid thread
    734                 DefaultKeyedVector< audio_session_t , sp<EffectChain> > mOrphanEffectChains;
    735 
    736                 // list of sessions for which a valid HW A/V sync ID was retrieved from the HAL
    737                 DefaultKeyedVector< audio_session_t , audio_hw_sync_t >mHwAvSyncIds;
    738 private:
    739     sp<Client>  registerPid(pid_t pid);    // always returns non-0
    740 
    741     // for use from destructor
    742     status_t    closeOutput_nonvirtual(audio_io_handle_t output);
    743     void        closeOutputInternal_l(sp<PlaybackThread> thread);
    744     status_t    closeInput_nonvirtual(audio_io_handle_t input);
    745     void        closeInputInternal_l(sp<RecordThread> thread);
    746     void        setAudioHwSyncForSession_l(PlaybackThread *thread, audio_session_t sessionId);
    747 
    748     status_t    checkStreamType(audio_stream_type_t stream) const;
    749 
    750 #ifdef TEE_SINK
    751     // all record threads serially share a common tee sink, which is re-created on format change
    752     sp<NBAIO_Sink>   mRecordTeeSink;
    753     sp<NBAIO_Source> mRecordTeeSource;
    754 #endif
    755 
    756 public:
    757 
    758 #ifdef TEE_SINK
    759     // tee sink, if enabled by property, allows dumpsys to write most recent audio to .wav file
    760     static void dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id = 0);
    761 
    762     // whether tee sink is enabled by property
    763     static bool mTeeSinkInputEnabled;
    764     static bool mTeeSinkOutputEnabled;
    765     static bool mTeeSinkTrackEnabled;
    766 
    767     // runtime configured size of each tee sink pipe, in frames
    768     static size_t mTeeSinkInputFrames;
    769     static size_t mTeeSinkOutputFrames;
    770     static size_t mTeeSinkTrackFrames;
    771 
    772     // compile-time default size of tee sink pipes, in frames
    773     // 0x200000 stereo 16-bit PCM frames = 47.5 seconds at 44.1 kHz, 8 megabytes
    774     static const size_t kTeeSinkInputFramesDefault = 0x200000;
    775     static const size_t kTeeSinkOutputFramesDefault = 0x200000;
    776     static const size_t kTeeSinkTrackFramesDefault = 0x200000;
    777 #endif
    778 
    779     // This method reads from a variable without mLock, but the variable is updated under mLock.  So
    780     // we might read a stale value, or a value that's inconsistent with respect to other variables.
    781     // In this case, it's safe because the return value isn't used for making an important decision.
    782     // The reason we don't want to take mLock is because it could block the caller for a long time.
    783     bool    isLowRamDevice() const { return mIsLowRamDevice; }
    784 
    785 private:
    786     bool    mIsLowRamDevice;
    787     bool    mIsDeviceTypeKnown;
    788     nsecs_t mGlobalEffectEnableTime;  // when a global effect was last enabled
    789 
    790     sp<PatchPanel> mPatchPanel;
    791 
    792     uint32_t    mPrimaryOutputSampleRate;   // sample rate of the primary output, or zero if none
    793                                             // protected by mHardwareLock
    794 };
    795 
    796 #undef INCLUDING_FROM_AUDIOFLINGER_H
    797 
    798 const char *formatToString(audio_format_t format);
    799 
    800 // ----------------------------------------------------------------------------
    801 
    802 }; // namespace android
    803 
    804 #endif // ANDROID_AUDIO_FLINGER_H
    805