blob: 6a15f6ec90a6279067ef9f305995a6406d7a9a8f [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/*
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
Dima Zavin34bb4192011-05-11 14:15:23 -070024#include <system/audio.h>
Dima Zavin290029d2011-06-13 18:16:26 -070025#include <system/audio_policy.h>
Dima Zavin24fc2fb2011-04-19 22:30:36 -070026
Dima Zavin4dc22e72011-04-19 22:20:55 -070027/* XXX: Should be include by all the users instead */
28#include <media/AudioParameter.h>
29
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080030namespace android {
31
32typedef void (*audio_error_callback)(status_t err);
Eric Laurenta553c252009-07-17 12:17:14 -070033
34class IAudioPolicyService;
35class String8;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080036
37class AudioSystem
38{
39public:
40
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080041 /* These are static methods to control the system-wide AudioFlinger
42 * only privileged processes can have access to them
43 */
44
Eric Laurenta553c252009-07-17 12:17:14 -070045 // mute/unmute microphone
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080046 static status_t muteMicrophone(bool state);
47 static status_t isMicrophoneMuted(bool *state);
48
Eric Laurenta553c252009-07-17 12:17:14 -070049 // set/get master volume
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080050 static status_t setMasterVolume(float value);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080051 static status_t getMasterVolume(float* volume);
Glenn Kastened0079d2011-04-04 10:50:50 -070052
Eric Laurenta553c252009-07-17 12:17:14 -070053 // mute/unmute audio outputs
54 static status_t setMasterMute(bool mute);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080055 static status_t getMasterMute(bool* mute);
56
Eric Laurenta553c252009-07-17 12:17:14 -070057 // set/get stream volume on specified output
Eric Laurentddb78e72009-07-28 08:44:33 -070058 static status_t setStreamVolume(int stream, float value, int output);
59 static status_t getStreamVolume(int stream, float* volume, int output);
Eric Laurenta553c252009-07-17 12:17:14 -070060
61 // mute/unmute stream
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080062 static status_t setStreamMute(int stream, bool mute);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080063 static status_t getStreamMute(int stream, bool* mute);
64
Dima Zavin24fc2fb2011-04-19 22:30:36 -070065 // set audio mode in audio hardware (see audio_mode_t)
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080066 static status_t setMode(int mode);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080067
Eric Laurent25101b02011-02-02 09:33:30 -080068 // 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);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080071
Eric Laurenta553c252009-07-17 12:17:14 -070072 // 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
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080078 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
Dima Zavin24fc2fb2011-04-19 22:30:36 -070086 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);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080089
90 static bool routedToA2dpOutput(int streamType);
Eric Laurenta553c252009-07-17 12:17:14 -070091
92 static status_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount,
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080093 size_t* buffSize);
94
Eric Laurent415f3e22009-10-21 08:14:22 -070095 static status_t setVoiceVolume(float volume);
Eric Laurenta553c252009-07-17 12:17:14 -070096
Eric Laurent0986e792010-01-19 17:37:09 -080097 // return the number of audio frames written by AudioFlinger to audio HAL and
Glenn Kastened0079d2011-04-04 10:50:50 -070098 // audio dsp to DAC since the output on which the specified stream is playing
Eric Laurent0986e792010-01-19 17:37:09 -080099 // 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.
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700106 static status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int stream = AUDIO_STREAM_DEFAULT);
Eric Laurent0986e792010-01-19 17:37:09 -0800107
Eric Laurent47d0a922010-02-26 02:47:27 -0800108 static unsigned int getInputFramesLost(audio_io_handle_t ioHandle);
Eric Laurent65b65452010-06-01 23:49:17 -0700109
110 static int newAudioSessionId();
Marco Nelissenc74b93f2011-08-02 13:33:41 -0700111 static void acquireAudioSessionId(int audioSession);
112 static void releaseAudioSessionId(int audioSession);
Eric Laurenta553c252009-07-17 12:17:14 -0700113
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 //
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700143 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);
Eric Laurenta553c252009-07-17 12:17:14 -0700145 static status_t setPhoneState(int state);
146 static status_t setRingerMode(uint32_t mode, uint32_t mask);
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700147 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,
Eric Laurenta553c252009-07-17 12:17:14 -0700150 uint32_t samplingRate = 0,
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700151 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);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700154 static status_t startOutput(audio_io_handle_t output,
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700155 audio_stream_type_t stream,
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700156 int session = 0);
157 static status_t stopOutput(audio_io_handle_t output,
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700158 audio_stream_type_t stream,
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700159 int session = 0);
Eric Laurenta553c252009-07-17 12:17:14 -0700160 static void releaseOutput(audio_io_handle_t output);
161 static audio_io_handle_t getInput(int inputSource,
162 uint32_t samplingRate = 0,
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700163 uint32_t format = AUDIO_FORMAT_DEFAULT,
164 uint32_t channels = AUDIO_CHANNEL_IN_MONO,
Eric Laurent464d5b32011-06-17 21:29:58 -0700165 audio_in_acoustics_t acoustics = (audio_in_acoustics_t)0,
166 int sessionId = 0);
Eric Laurenta553c252009-07-17 12:17:14 -0700167 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);
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700170 static status_t initStreamVolume(audio_stream_type_t stream,
Eric Laurenta553c252009-07-17 12:17:14 -0700171 int indexMin,
172 int indexMax);
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700173 static status_t setStreamVolumeIndex(audio_stream_type_t stream, int index);
174 static status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index);
Eric Laurenta553c252009-07-17 12:17:14 -0700175
Dima Zavin24fc2fb2011-04-19 22:30:36 -0700176 static uint32_t getStrategyForStream(audio_stream_type_t stream);
177 static uint32_t getDevicesForStream(audio_stream_type_t stream);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700178
179 static audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc);
180 static status_t registerEffect(effect_descriptor_t *desc,
Eric Laurent464d5b32011-06-17 21:29:58 -0700181 audio_io_handle_t io,
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700182 uint32_t strategy,
183 int session,
184 int id);
185 static status_t unregisterEffect(int id);
Eric Laurent6752ec82011-08-10 10:37:50 -0700186 static status_t setEffectEnabled(int id, bool enabled);
Eric Laurent8ed6ed02010-07-13 04:45:46 -0700187
Eric Laurent05ce0942011-08-30 10:18:54 -0700188 // clear stream to output mapping cache (gStreamOutputMap)
189 // and output configuration cache (gOutputs)
190 static void clearAudioConfigCache();
191
Eric Laurenta553c252009-07-17 12:17:14 -0700192 static const sp<IAudioPolicyService>& get_audio_policy_service();
193
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800194 // ----------------------------------------------------------------------------
195
196private:
197
198 class AudioFlingerClient: public IBinder::DeathRecipient, public BnAudioFlingerClient
199 {
200 public:
Eric Laurenta553c252009-07-17 12:17:14 -0700201 AudioFlingerClient() {
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800202 }
Eric Laurenta553c252009-07-17 12:17:14 -0700203
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800204 // DeathRecipient
205 virtual void binderDied(const wp<IBinder>& who);
Eric Laurenta553c252009-07-17 12:17:14 -0700206
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800207 // IAudioFlingerClient
Eric Laurenta553c252009-07-17 12:17:14 -0700208
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
Eric Laurentddb78e72009-07-28 08:44:33 -0700211 virtual void ioConfigChanged(int event, int ioHandle, void *param2);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800212 };
Eric Laurenta553c252009-07-17 12:17:14 -0700213
214 class AudioPolicyServiceClient: public IBinder::DeathRecipient
215 {
216 public:
217 AudioPolicyServiceClient() {
218 }
219
220 // DeathRecipient
221 virtual void binderDied(const wp<IBinder>& who);
222 };
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800223
224 static sp<AudioFlingerClient> gAudioFlingerClient;
Eric Laurenta553c252009-07-17 12:17:14 -0700225 static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800226 friend class AudioFlingerClient;
Eric Laurenta553c252009-07-17 12:17:14 -0700227 friend class AudioPolicyServiceClient;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800228
229 static Mutex gLock;
230 static sp<IAudioFlinger> gAudioFlinger;
231 static audio_error_callback gAudioErrorCallback;
Eric Laurenta553c252009-07-17 12:17:14 -0700232
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800233 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
Eric Laurenta553c252009-07-17 12:17:14 -0700239 static sp<IAudioPolicyService> gAudioPolicyService;
240
241 // mapping between stream types and outputs
242 static DefaultKeyedVector<int, audio_io_handle_t> gStreamOutputMap;
Eric Laurent05ce0942011-08-30 10:18:54 -0700243 // list of output descriptors containing cached parameters
244 // (sampling rate, framecount, channel count...)
Eric Laurenta553c252009-07-17 12:17:14 -0700245 static DefaultKeyedVector<audio_io_handle_t, OutputDescriptor *> gOutputs;
246};
247
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800248}; // namespace android
249
250#endif /*ANDROID_AUDIOSYSTEM_H_*/