Home | History | Annotate | Download | only in media 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ANDROID_AUDIOSYSTEM_H_
     18 #define ANDROID_AUDIOSYSTEM_H_
     19 
     20 #include <utils/RefBase.h>
     21 #include <utils/threads.h>
     22 #include <media/IAudioFlinger.h>
     23 
     24 #include <system/audio.h>
     25 #include <system/audio_policy.h>
     26 
     27 /* XXX: Should be include by all the users instead */
     28 #include <media/AudioParameter.h>
     29 
     30 namespace android {
     31 
     32 typedef void (*audio_error_callback)(status_t err);
     33 
     34 class IAudioPolicyService;
     35 class String8;
     36 
     37 class AudioSystem
     38 {
     39 public:
     40 
     41     /* These are static methods to control the system-wide AudioFlinger
     42      * only privileged processes can have access to them
     43      */
     44 
     45     // mute/unmute microphone
     46     static status_t muteMicrophone(bool state);
     47     static status_t isMicrophoneMuted(bool *state);
     48 
     49     // set/get master volume
     50     static status_t setMasterVolume(float value);
     51     static status_t getMasterVolume(float* volume);
     52 
     53     // mute/unmute audio outputs
     54     static status_t setMasterMute(bool mute);
     55     static status_t getMasterMute(bool* mute);
     56 
     57     // set/get stream volume on specified output
     58     static status_t setStreamVolume(int stream, float value, int output);
     59     static status_t getStreamVolume(int stream, float* volume, int output);
     60 
     61     // mute/unmute stream
     62     static status_t setStreamMute(int stream, bool mute);
     63     static status_t getStreamMute(int stream, bool* mute);
     64 
     65     // set audio mode in audio hardware (see audio_mode_t)
     66     static status_t setMode(int mode);
     67 
     68     // returns true in *state if tracks are active on the specified stream or has been active
     69     // in the past inPastMs milliseconds
     70     static status_t isStreamActive(int stream, bool *state, uint32_t inPastMs = 0);
     71 
     72     // set/get audio hardware parameters. The function accepts a list of parameters
     73     // key value pairs in the form: key1=value1;key2=value2;...
     74     // Some keys are reserved for standard parameters (See AudioParameter class).
     75     static status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
     76     static String8  getParameters(audio_io_handle_t ioHandle, const String8& keys);
     77 
     78     static void setErrorCallback(audio_error_callback cb);
     79 
     80     // helper function to obtain AudioFlinger service handle
     81     static const sp<IAudioFlinger>& get_audio_flinger();
     82 
     83     static float linearToLog(int volume);
     84     static int logToLinear(float volume);
     85 
     86     static status_t getOutputSamplingRate(int* samplingRate, int stream = AUDIO_STREAM_DEFAULT);
     87     static status_t getOutputFrameCount(int* frameCount, int stream = AUDIO_STREAM_DEFAULT);
     88     static status_t getOutputLatency(uint32_t* latency, int stream = AUDIO_STREAM_DEFAULT);
     89 
     90     static bool routedToA2dpOutput(int streamType);
     91 
     92     static status_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount,
     93         size_t* buffSize);
     94 
     95     static status_t setVoiceVolume(float volume);
     96 
     97     // return the number of audio frames written by AudioFlinger to audio HAL and
     98     // audio dsp to DAC since the output on which the specified stream is playing
     99     // has exited standby.
    100     // returned status (from utils/Errors.h) can be:
    101     // - NO_ERROR: successful operation, halFrames and dspFrames point to valid data
    102     // - INVALID_OPERATION: Not supported on current hardware platform
    103     // - BAD_VALUE: invalid parameter
    104     // NOTE: this feature is not supported on all hardware platforms and it is
    105     // necessary to check returned status before using the returned values.
    106     static status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int stream = AUDIO_STREAM_DEFAULT);
    107 
    108     static unsigned int  getInputFramesLost(audio_io_handle_t ioHandle);
    109 
    110     static int newAudioSessionId();
    111     static void acquireAudioSessionId(int audioSession);
    112     static void releaseAudioSessionId(int audioSession);
    113 
    114     // types of io configuration change events received with ioConfigChanged()
    115     enum io_config_event {
    116         OUTPUT_OPENED,
    117         OUTPUT_CLOSED,
    118         OUTPUT_CONFIG_CHANGED,
    119         INPUT_OPENED,
    120         INPUT_CLOSED,
    121         INPUT_CONFIG_CHANGED,
    122         STREAM_CONFIG_CHANGED,
    123         NUM_CONFIG_EVENTS
    124     };
    125 
    126     // audio output descritor used to cache output configurations in client process to avoid frequent calls
    127     // through IAudioFlinger
    128     class OutputDescriptor {
    129     public:
    130         OutputDescriptor()
    131         : samplingRate(0), format(0), channels(0), frameCount(0), latency(0)  {}
    132 
    133         uint32_t samplingRate;
    134         int32_t format;
    135         int32_t channels;
    136         size_t frameCount;
    137         uint32_t latency;
    138     };
    139 
    140     //
    141     // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)
    142     //
    143     static status_t setDeviceConnectionState(audio_devices_t device, audio_policy_dev_state_t state, const char *device_address);
    144     static audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, const char *device_address);
    145     static status_t setPhoneState(int state);
    146     static status_t setRingerMode(uint32_t mode, uint32_t mask);
    147     static status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
    148     static audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
    149     static audio_io_handle_t getOutput(audio_stream_type_t stream,
    150                                         uint32_t samplingRate = 0,
    151                                         uint32_t format = AUDIO_FORMAT_DEFAULT,
    152                                         uint32_t channels = AUDIO_CHANNEL_OUT_STEREO,
    153                                         audio_policy_output_flags_t flags = AUDIO_POLICY_OUTPUT_FLAG_INDIRECT);
    154     static status_t startOutput(audio_io_handle_t output,
    155                                 audio_stream_type_t stream,
    156                                 int session = 0);
    157     static status_t stopOutput(audio_io_handle_t output,
    158                                audio_stream_type_t stream,
    159                                int session = 0);
    160     static void releaseOutput(audio_io_handle_t output);
    161     static audio_io_handle_t getInput(int inputSource,
    162                                     uint32_t samplingRate = 0,
    163                                     uint32_t format = AUDIO_FORMAT_DEFAULT,
    164                                     uint32_t channels = AUDIO_CHANNEL_IN_MONO,
    165                                     audio_in_acoustics_t acoustics = (audio_in_acoustics_t)0,
    166                                     int sessionId = 0);
    167     static status_t startInput(audio_io_handle_t input);
    168     static status_t stopInput(audio_io_handle_t input);
    169     static void releaseInput(audio_io_handle_t input);
    170     static status_t initStreamVolume(audio_stream_type_t stream,
    171                                       int indexMin,
    172                                       int indexMax);
    173     static status_t setStreamVolumeIndex(audio_stream_type_t stream, int index);
    174     static status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index);
    175 
    176     static uint32_t getStrategyForStream(audio_stream_type_t stream);
    177     static uint32_t getDevicesForStream(audio_stream_type_t stream);
    178 
    179     static audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc);
    180     static status_t registerEffect(effect_descriptor_t *desc,
    181                                     audio_io_handle_t io,
    182                                     uint32_t strategy,
    183                                     int session,
    184                                     int id);
    185     static status_t unregisterEffect(int id);
    186     static status_t setEffectEnabled(int id, bool enabled);
    187 
    188     // clear stream to output mapping cache (gStreamOutputMap)
    189     // and output configuration cache (gOutputs)
    190     static void clearAudioConfigCache();
    191 
    192     static const sp<IAudioPolicyService>& get_audio_policy_service();
    193 
    194     // ----------------------------------------------------------------------------
    195 
    196 private:
    197 
    198     class AudioFlingerClient: public IBinder::DeathRecipient, public BnAudioFlingerClient
    199     {
    200     public:
    201         AudioFlingerClient() {
    202         }
    203 
    204         // DeathRecipient
    205         virtual void binderDied(const wp<IBinder>& who);
    206 
    207         // IAudioFlingerClient
    208 
    209         // indicate a change in the configuration of an output or input: keeps the cached
    210         // values for output/input parameters upto date in client process
    211         virtual void ioConfigChanged(int event, int ioHandle, void *param2);
    212     };
    213 
    214     class AudioPolicyServiceClient: public IBinder::DeathRecipient
    215     {
    216     public:
    217         AudioPolicyServiceClient() {
    218         }
    219 
    220         // DeathRecipient
    221         virtual void binderDied(const wp<IBinder>& who);
    222     };
    223 
    224     static sp<AudioFlingerClient> gAudioFlingerClient;
    225     static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient;
    226     friend class AudioFlingerClient;
    227     friend class AudioPolicyServiceClient;
    228 
    229     static Mutex gLock;
    230     static sp<IAudioFlinger> gAudioFlinger;
    231     static audio_error_callback gAudioErrorCallback;
    232 
    233     static size_t gInBuffSize;
    234     // previous parameters for recording buffer size queries
    235     static uint32_t gPrevInSamplingRate;
    236     static int gPrevInFormat;
    237     static int gPrevInChannelCount;
    238 
    239     static sp<IAudioPolicyService> gAudioPolicyService;
    240 
    241     // mapping between stream types and outputs
    242     static DefaultKeyedVector<int, audio_io_handle_t> gStreamOutputMap;
    243     // list of output descriptors containing cached parameters
    244     // (sampling rate, framecount, channel count...)
    245     static DefaultKeyedVector<audio_io_handle_t, OutputDescriptor *> gOutputs;
    246 };
    247 
    248 };  // namespace android
    249 
    250 #endif  /*ANDROID_AUDIOSYSTEM_H_*/
    251