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 #pragma GCC visibility push(default)
21
22 #include <utils/RefBase.h>
23 #include <utils/threads.h>
24 #include "IAudioFlinger.h"
25
26 #ifndef VANILLA_ANDROID
27 /* request to open a direct output with get_output() (by opposition to
28 * sharing an output with other AudioTracks)
29 */
30 typedef enum {
31 AUDIO_POLICY_OUTPUT_FLAG_INDIRECT = 0x0,
32 AUDIO_POLICY_OUTPUT_FLAG_DIRECT = 0x1
33 } audio_policy_output_flags_t;
34
35 /* device categories used for audio_policy->set_force_use() */
36 typedef enum {
37 AUDIO_POLICY_FORCE_NONE,
38 AUDIO_POLICY_FORCE_SPEAKER,
39 AUDIO_POLICY_FORCE_HEADPHONES,
40 AUDIO_POLICY_FORCE_BT_SCO,
41 AUDIO_POLICY_FORCE_BT_A2DP,
42 AUDIO_POLICY_FORCE_WIRED_ACCESSORY,
43 AUDIO_POLICY_FORCE_BT_CAR_DOCK,
44 AUDIO_POLICY_FORCE_BT_DESK_DOCK,
45 AUDIO_POLICY_FORCE_ANALOG_DOCK,
46 AUDIO_POLICY_FORCE_DIGITAL_DOCK,
47 AUDIO_POLICY_FORCE_NO_BT_A2DP,
48 AUDIO_POLICY_FORCE_CFG_CNT,
49 AUDIO_POLICY_FORCE_CFG_MAX = AUDIO_POLICY_FORCE_CFG_CNT - 1,
50
51 AUDIO_POLICY_FORCE_DEFAULT = AUDIO_POLICY_FORCE_NONE,
52 } audio_policy_forced_cfg_t;
53
54 /* usages used for audio_policy->set_force_use() */
55 typedef enum {
56 AUDIO_POLICY_FORCE_FOR_COMMUNICATION,
57 AUDIO_POLICY_FORCE_FOR_MEDIA,
58 AUDIO_POLICY_FORCE_FOR_RECORD,
59 AUDIO_POLICY_FORCE_FOR_DOCK,
60
61 AUDIO_POLICY_FORCE_USE_CNT,
62 AUDIO_POLICY_FORCE_USE_MAX = AUDIO_POLICY_FORCE_USE_CNT - 1,
63 } audio_policy_force_use_t;
64
65 typedef enum {
66 AUDIO_STREAM_DEFAULT = -1,
67 AUDIO_STREAM_VOICE_CALL = 0,
68 AUDIO_STREAM_SYSTEM = 1,
69 AUDIO_STREAM_RING = 2,
70 AUDIO_STREAM_MUSIC = 3,
71 AUDIO_STREAM_ALARM = 4,
72 AUDIO_STREAM_NOTIFICATION = 5,
73 AUDIO_STREAM_BLUETOOTH_SCO = 6,
74 AUDIO_STREAM_ENFORCED_AUDIBLE = 7, /* Sounds that cannot be muted by user and must be routed to speaker */
75 AUDIO_STREAM_DTMF = 8,
76 AUDIO_STREAM_TTS = 9,
77 #if ANDROID_VERSION < 19
78 AUDIO_STREAM_FM = 10,
79 #endif
80
81 AUDIO_STREAM_CNT,
82 AUDIO_STREAM_MAX = AUDIO_STREAM_CNT - 1,
83 } audio_stream_type_t;
84
85 /* PCM sub formats */
86 typedef enum {
87 AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1, /* DO NOT CHANGE - PCM signed 16 bits */
88 AUDIO_FORMAT_PCM_SUB_8_BIT = 0x2, /* DO NOT CHANGE - PCM unsigned 8 bits */
89 AUDIO_FORMAT_PCM_SUB_32_BIT = 0x3, /* PCM signed .31 fixed point */
90 AUDIO_FORMAT_PCM_SUB_8_24_BIT = 0x4, /* PCM signed 7.24 fixed point */
91 } audio_format_pcm_sub_fmt_t;
92
93 /* Audio format consists in a main format field (upper 8 bits) and a sub format
94 * field (lower 24 bits).
95 *
96 * The main format indicates the main codec type. The sub format field
97 * indicates options and parameters for each format. The sub format is mainly
98 * used for record to indicate for instance the requested bitrate or profile.
99 * It can also be used for certain formats to give informations not present in
100 * the encoded audio stream (e.g. octet alignement for AMR).
101 */
102 typedef enum {
103 AUDIO_FORMAT_INVALID = 0xFFFFFFFFUL,
104 AUDIO_FORMAT_DEFAULT = 0,
105 AUDIO_FORMAT_PCM = 0x00000000UL, /* DO NOT CHANGE */
106 AUDIO_FORMAT_MP3 = 0x01000000UL,
107 AUDIO_FORMAT_AMR_NB = 0x02000000UL,
108 AUDIO_FORMAT_AMR_WB = 0x03000000UL,
109 AUDIO_FORMAT_AAC = 0x04000000UL,
110 AUDIO_FORMAT_HE_AAC_V1 = 0x05000000UL,
111 AUDIO_FORMAT_HE_AAC_V2 = 0x06000000UL,
112 AUDIO_FORMAT_VORBIS = 0x07000000UL,
113 AUDIO_FORMAT_MAIN_MASK = 0xFF000000UL,
114 AUDIO_FORMAT_SUB_MASK = 0x00FFFFFFUL,
115
116 /* Aliases */
117 AUDIO_FORMAT_PCM_16_BIT = (AUDIO_FORMAT_PCM |
118 AUDIO_FORMAT_PCM_SUB_16_BIT),
119 AUDIO_FORMAT_PCM_8_BIT = (AUDIO_FORMAT_PCM |
120 AUDIO_FORMAT_PCM_SUB_8_BIT),
121 AUDIO_FORMAT_PCM_32_BIT = (AUDIO_FORMAT_PCM |
122 AUDIO_FORMAT_PCM_SUB_32_BIT),
123 AUDIO_FORMAT_PCM_8_24_BIT = (AUDIO_FORMAT_PCM |
124 AUDIO_FORMAT_PCM_SUB_8_24_BIT),
125 } audio_format_t;
126
127 typedef enum {
128 /* output channels */
129 AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1,
130 AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2,
131 AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4,
132 AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8,
133 AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10,
134 AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20,
135 AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40,
136 AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80,
137 AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100,
138 AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200,
139 AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400,
140 AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800,
141 AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000,
142 AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000,
143 AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000,
144 AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000,
145 AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000,
146 AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000,
147
148 AUDIO_CHANNEL_OUT_MONO = AUDIO_CHANNEL_OUT_FRONT_LEFT,
149 AUDIO_CHANNEL_OUT_STEREO = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
150 AUDIO_CHANNEL_OUT_FRONT_RIGHT),
151 AUDIO_CHANNEL_OUT_QUAD = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
152 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
153 AUDIO_CHANNEL_OUT_BACK_LEFT |
154 AUDIO_CHANNEL_OUT_BACK_RIGHT),
155 AUDIO_CHANNEL_OUT_SURROUND = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
156 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
157 AUDIO_CHANNEL_OUT_FRONT_CENTER |
158 AUDIO_CHANNEL_OUT_BACK_CENTER),
159 AUDIO_CHANNEL_OUT_5POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
160 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
161 AUDIO_CHANNEL_OUT_FRONT_CENTER |
162 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
163 AUDIO_CHANNEL_OUT_BACK_LEFT |
164 AUDIO_CHANNEL_OUT_BACK_RIGHT),
165 // matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND definition for 7.1
166 AUDIO_CHANNEL_OUT_7POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
167 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
168 AUDIO_CHANNEL_OUT_FRONT_CENTER |
169 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
170 AUDIO_CHANNEL_OUT_BACK_LEFT |
171 AUDIO_CHANNEL_OUT_BACK_RIGHT |
172 AUDIO_CHANNEL_OUT_SIDE_LEFT |
173 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
174 AUDIO_CHANNEL_OUT_ALL = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
175 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
176 AUDIO_CHANNEL_OUT_FRONT_CENTER |
177 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
178 AUDIO_CHANNEL_OUT_BACK_LEFT |
179 AUDIO_CHANNEL_OUT_BACK_RIGHT |
180 AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER |
181 AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER |
182 AUDIO_CHANNEL_OUT_BACK_CENTER|
183 AUDIO_CHANNEL_OUT_SIDE_LEFT|
184 AUDIO_CHANNEL_OUT_SIDE_RIGHT|
185 AUDIO_CHANNEL_OUT_TOP_CENTER|
186 AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT|
187 AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER|
188 AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT|
189 AUDIO_CHANNEL_OUT_TOP_BACK_LEFT|
190 AUDIO_CHANNEL_OUT_TOP_BACK_CENTER|
191 AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT),
192
193 /* input channels */
194 AUDIO_CHANNEL_IN_LEFT = 0x4,
195 AUDIO_CHANNEL_IN_RIGHT = 0x8,
196 AUDIO_CHANNEL_IN_FRONT = 0x10,
197 AUDIO_CHANNEL_IN_BACK = 0x20,
198 AUDIO_CHANNEL_IN_LEFT_PROCESSED = 0x40,
199 AUDIO_CHANNEL_IN_RIGHT_PROCESSED = 0x80,
200 AUDIO_CHANNEL_IN_FRONT_PROCESSED = 0x100,
201 AUDIO_CHANNEL_IN_BACK_PROCESSED = 0x200,
202 AUDIO_CHANNEL_IN_PRESSURE = 0x400,
203 AUDIO_CHANNEL_IN_X_AXIS = 0x800,
204 AUDIO_CHANNEL_IN_Y_AXIS = 0x1000,
205 AUDIO_CHANNEL_IN_Z_AXIS = 0x2000,
206 AUDIO_CHANNEL_IN_VOICE_UPLINK = 0x4000,
207 AUDIO_CHANNEL_IN_VOICE_DNLINK = 0x8000,
208
209 AUDIO_CHANNEL_IN_MONO = AUDIO_CHANNEL_IN_FRONT,
210 AUDIO_CHANNEL_IN_STEREO = (AUDIO_CHANNEL_IN_LEFT | AUDIO_CHANNEL_IN_RIGHT),
211 AUDIO_CHANNEL_IN_ALL = (AUDIO_CHANNEL_IN_LEFT |
212 AUDIO_CHANNEL_IN_RIGHT |
213 AUDIO_CHANNEL_IN_FRONT |
214 AUDIO_CHANNEL_IN_BACK|
215 AUDIO_CHANNEL_IN_LEFT_PROCESSED |
216 AUDIO_CHANNEL_IN_RIGHT_PROCESSED |
217 AUDIO_CHANNEL_IN_FRONT_PROCESSED |
218 AUDIO_CHANNEL_IN_BACK_PROCESSED|
219 AUDIO_CHANNEL_IN_PRESSURE |
220 AUDIO_CHANNEL_IN_X_AXIS |
221 AUDIO_CHANNEL_IN_Y_AXIS |
222 AUDIO_CHANNEL_IN_Z_AXIS |
223 AUDIO_CHANNEL_IN_VOICE_UPLINK |
224 AUDIO_CHANNEL_IN_VOICE_DNLINK),
225 } audio_channels_t;
226
227 #if ANDROID_VERSION >= 17
228 typedef enum {
229 AUDIO_MODE_INVALID = -2,
230 AUDIO_MODE_CURRENT = -1,
231 AUDIO_MODE_NORMAL = 0,
232 AUDIO_MODE_RINGTONE = 1,
233 AUDIO_MODE_IN_CALL = 2,
234 AUDIO_MODE_IN_COMMUNICATION = 3,
235
236 AUDIO_MODE_CNT,
237 AUDIO_MODE_MAX = AUDIO_MODE_CNT - 1,
238 } audio_mode_t;
239 #endif
240 #endif
241
242 #if ANDROID_VERSION < 17
243 typedef enum {
244 AUDIO_DEVICE_NONE = 0x0,
245 /* output devices */
246 AUDIO_DEVICE_OUT_EARPIECE = 0x1,
247 AUDIO_DEVICE_OUT_SPEAKER = 0x2,
248 AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4,
249 AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8,
250 AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10,
251 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
252 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
253 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
254 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
255 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
256 AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400,
257 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800,
258 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000,
259 AUDIO_DEVICE_OUT_FM = 0x2000,
260 AUDIO_DEVICE_OUT_ANC_HEADSET = 0x4000,
261 AUDIO_DEVICE_OUT_ANC_HEADPHONE = 0x8000,
262 AUDIO_DEVICE_OUT_FM_TX = 0x10000,
263 AUDIO_DEVICE_OUT_DIRECTOUTPUT = 0x20000,
264 AUDIO_DEVICE_OUT_PROXY = 0x40000,
265 AUDIO_DEVICE_OUT_DEFAULT = 0x80000,
266 AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_EARPIECE |
267 AUDIO_DEVICE_OUT_SPEAKER |
268 AUDIO_DEVICE_OUT_WIRED_HEADSET |
269 AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
270 AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
271 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
272 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
273 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
274 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
275 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER |
276 AUDIO_DEVICE_OUT_AUX_DIGITAL |
277 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
278 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
279 AUDIO_DEVICE_OUT_FM |
280 AUDIO_DEVICE_OUT_ANC_HEADSET |
281 AUDIO_DEVICE_OUT_ANC_HEADPHONE |
282 AUDIO_DEVICE_OUT_FM_TX |
283 AUDIO_DEVICE_OUT_DIRECTOUTPUT |
284 AUDIO_DEVICE_OUT_PROXY |
285 AUDIO_DEVICE_OUT_DEFAULT),
286 AUDIO_DEVICE_OUT_ALL_A2DP = (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
287 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
288 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
289 AUDIO_DEVICE_OUT_ALL_SCO = (AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
290 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
291 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT),
292 /* input devices */
293 AUDIO_DEVICE_IN_COMMUNICATION = 0x100000,
294 AUDIO_DEVICE_IN_AMBIENT = 0x200000,
295 AUDIO_DEVICE_IN_BUILTIN_MIC = 0x400000,
296 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = 0x800000,
297 AUDIO_DEVICE_IN_WIRED_HEADSET = 0x1000000,
298 AUDIO_DEVICE_IN_AUX_DIGITAL = 0x2000000,
299 AUDIO_DEVICE_IN_VOICE_CALL = 0x4000000,
300 AUDIO_DEVICE_IN_BACK_MIC = 0x8000000,
301 AUDIO_DEVICE_IN_ANC_HEADSET = 0x10000000,
302 AUDIO_DEVICE_IN_FM_RX = 0x20000000,
303 AUDIO_DEVICE_IN_FM_RX_A2DP = 0x40000000,
304 AUDIO_DEVICE_IN_DEFAULT = 0x80000000,
305
306 AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_COMMUNICATION |
307 AUDIO_DEVICE_IN_AMBIENT |
308 AUDIO_DEVICE_IN_BUILTIN_MIC |
309 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET |
310 AUDIO_DEVICE_IN_WIRED_HEADSET |
311 AUDIO_DEVICE_IN_AUX_DIGITAL |
312 AUDIO_DEVICE_IN_VOICE_CALL |
313 AUDIO_DEVICE_IN_BACK_MIC |
314 AUDIO_DEVICE_IN_ANC_HEADSET |
315 AUDIO_DEVICE_IN_FM_RX |
316 AUDIO_DEVICE_IN_FM_RX_A2DP |
317 AUDIO_DEVICE_IN_DEFAULT),
318 AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
319 } audio_devices_t;
320 #elif ANDROID_VERSION < 21
321 enum {
322 AUDIO_DEVICE_NONE = 0x0,
323 /* reserved bits */
324 AUDIO_DEVICE_BIT_IN = 0x80000000,
325 AUDIO_DEVICE_BIT_DEFAULT = 0x40000000,
326 /* output devices */
327 AUDIO_DEVICE_OUT_EARPIECE = 0x1,
328 AUDIO_DEVICE_OUT_SPEAKER = 0x2,
329 AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4,
330 AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8,
331 AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10,
332 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
333 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
334 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
335 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
336 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
337 AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400,
338 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800,
339 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000,
340 AUDIO_DEVICE_OUT_USB_ACCESSORY = 0x2000,
341 AUDIO_DEVICE_OUT_USB_DEVICE = 0x4000,
342 AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 0x8000,
343 AUDIO_DEVICE_OUT_ANC_HEADSET = 0x10000,
344 AUDIO_DEVICE_OUT_ANC_HEADPHONE = 0x20000,
345 AUDIO_DEVICE_OUT_PROXY = 0x40000,
346 AUDIO_DEVICE_OUT_FM = 0x80000,
347 AUDIO_DEVICE_OUT_FM_TX = 0x100000,
348 AUDIO_DEVICE_OUT_DEFAULT = AUDIO_DEVICE_BIT_DEFAULT,
349 AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_EARPIECE |
350 AUDIO_DEVICE_OUT_SPEAKER |
351 AUDIO_DEVICE_OUT_WIRED_HEADSET |
352 AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
353 AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
354 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
355 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
356 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
357 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
358 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER |
359 AUDIO_DEVICE_OUT_AUX_DIGITAL |
360 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
361 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
362 AUDIO_DEVICE_OUT_USB_ACCESSORY |
363 AUDIO_DEVICE_OUT_USB_DEVICE |
364 AUDIO_DEVICE_OUT_REMOTE_SUBMIX |
365 AUDIO_DEVICE_OUT_ANC_HEADSET |
366 AUDIO_DEVICE_OUT_ANC_HEADPHONE |
367 AUDIO_DEVICE_OUT_PROXY |
368 AUDIO_DEVICE_OUT_FM |
369 AUDIO_DEVICE_OUT_FM_TX |
370 AUDIO_DEVICE_OUT_DEFAULT),
371 AUDIO_DEVICE_OUT_ALL_A2DP = (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
372 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
373 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
374 AUDIO_DEVICE_OUT_ALL_SCO = (AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
375 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
376 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT),
377 AUDIO_DEVICE_OUT_ALL_USB = (AUDIO_DEVICE_OUT_USB_ACCESSORY |
378 AUDIO_DEVICE_OUT_USB_DEVICE),
379
380 /* input devices */
381 AUDIO_DEVICE_IN_COMMUNICATION = AUDIO_DEVICE_BIT_IN | 0x1,
382 AUDIO_DEVICE_IN_AMBIENT = AUDIO_DEVICE_BIT_IN | 0x2,
383 AUDIO_DEVICE_IN_BUILTIN_MIC = AUDIO_DEVICE_BIT_IN | 0x4,
384 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = AUDIO_DEVICE_BIT_IN | 0x8,
385 AUDIO_DEVICE_IN_WIRED_HEADSET = AUDIO_DEVICE_BIT_IN | 0x10,
386 AUDIO_DEVICE_IN_AUX_DIGITAL = AUDIO_DEVICE_BIT_IN | 0x20,
387 AUDIO_DEVICE_IN_VOICE_CALL = AUDIO_DEVICE_BIT_IN | 0x40,
388 AUDIO_DEVICE_IN_BACK_MIC = AUDIO_DEVICE_BIT_IN | 0x80,
389 AUDIO_DEVICE_IN_REMOTE_SUBMIX = AUDIO_DEVICE_BIT_IN | 0x100,
390 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x200,
391 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x400,
392 AUDIO_DEVICE_IN_USB_ACCESSORY = AUDIO_DEVICE_BIT_IN | 0x800,
393 AUDIO_DEVICE_IN_USB_DEVICE = AUDIO_DEVICE_BIT_IN | 0x1000,
394 AUDIO_DEVICE_IN_ANC_HEADSET = AUDIO_DEVICE_BIT_IN | 0x2000,
395 AUDIO_DEVICE_IN_PROXY = AUDIO_DEVICE_BIT_IN | 0x4000,
396 AUDIO_DEVICE_IN_FM_RX = AUDIO_DEVICE_BIT_IN | 0x8000,
397 AUDIO_DEVICE_IN_FM_RX_A2DP = AUDIO_DEVICE_BIT_IN | 0x10000,
398 AUDIO_DEVICE_IN_DEFAULT = AUDIO_DEVICE_BIT_IN | AUDIO_DEVICE_BIT_DEFAULT,
399
400 AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_COMMUNICATION |
401 AUDIO_DEVICE_IN_AMBIENT |
402 AUDIO_DEVICE_IN_BUILTIN_MIC |
403 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET |
404 AUDIO_DEVICE_IN_WIRED_HEADSET |
405 AUDIO_DEVICE_IN_AUX_DIGITAL |
406 AUDIO_DEVICE_IN_VOICE_CALL |
407 AUDIO_DEVICE_IN_BACK_MIC |
408 AUDIO_DEVICE_IN_REMOTE_SUBMIX |
409 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET |
410 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET |
411 AUDIO_DEVICE_IN_USB_ACCESSORY |
412 AUDIO_DEVICE_IN_USB_DEVICE |
413 AUDIO_DEVICE_IN_ANC_HEADSET |
414 AUDIO_DEVICE_IN_FM_RX |
415 AUDIO_DEVICE_IN_FM_RX_A2DP |
416 AUDIO_DEVICE_IN_PROXY |
417 AUDIO_DEVICE_IN_DEFAULT),
418 AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
419 };
420
421 typedef uint32_t audio_devices_t;
422 #else
423 enum {
424 AUDIO_DEVICE_NONE = 0x0,
425 /* reserved bits */
426 AUDIO_DEVICE_BIT_IN = 0x80000000,
427 AUDIO_DEVICE_BIT_DEFAULT = 0x40000000,
428 /* output devices */
429 AUDIO_DEVICE_OUT_EARPIECE = 0x1,
430 AUDIO_DEVICE_OUT_SPEAKER = 0x2,
431 AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4,
432 AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8,
433 AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10,
434 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
435 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
436 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
437 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
438 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
439 AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400,
440 AUDIO_DEVICE_OUT_HDMI = AUDIO_DEVICE_OUT_AUX_DIGITAL,
441 /* uses an analog connection (multiplexed over the USB connector pins for instance) */
442 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800,
443 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000,
444 /* USB accessory mode: your Android device is a USB device and the dock is a USB host */
445 AUDIO_DEVICE_OUT_USB_ACCESSORY = 0x2000,
446 /* USB host mode: your Android device is a USB host and the dock is a USB device */
447 AUDIO_DEVICE_OUT_USB_DEVICE = 0x4000,
448 AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 0x8000,
449 /* Telephony voice TX path */
450 AUDIO_DEVICE_OUT_TELEPHONY_TX = 0x10000,
451 /* Analog jack with line impedance detected */
452 AUDIO_DEVICE_OUT_LINE = 0x20000,
453 /* HDMI Audio Return Channel */
454 AUDIO_DEVICE_OUT_HDMI_ARC = 0x40000,
455 /* S/PDIF out */
456 AUDIO_DEVICE_OUT_SPDIF = 0x80000,
457 /* FM transmitter out */
458 AUDIO_DEVICE_OUT_FM = 0x100000,
459 /* Line out for av devices */
460 AUDIO_DEVICE_OUT_AUX_LINE = 0x200000,
461 /* limited-output speaker device for acoustic safety */
462 AUDIO_DEVICE_OUT_SPEAKER_SAFE = 0x400000,
463 AUDIO_DEVICE_OUT_DEFAULT = AUDIO_DEVICE_BIT_DEFAULT,
464 AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_EARPIECE |
465 AUDIO_DEVICE_OUT_SPEAKER |
466 AUDIO_DEVICE_OUT_WIRED_HEADSET |
467 AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
468 AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
469 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
470 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
471 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
472 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
473 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER |
474 AUDIO_DEVICE_OUT_AUX_DIGITAL |
475 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
476 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
477 AUDIO_DEVICE_OUT_USB_ACCESSORY |
478 AUDIO_DEVICE_OUT_USB_DEVICE |
479 AUDIO_DEVICE_OUT_REMOTE_SUBMIX |
480 AUDIO_DEVICE_OUT_TELEPHONY_TX |
481 AUDIO_DEVICE_OUT_LINE |
482 AUDIO_DEVICE_OUT_HDMI_ARC |
483 AUDIO_DEVICE_OUT_SPDIF |
484 AUDIO_DEVICE_OUT_FM |
485 AUDIO_DEVICE_OUT_AUX_LINE |
486 AUDIO_DEVICE_OUT_SPEAKER_SAFE |
487 AUDIO_DEVICE_OUT_DEFAULT),
488 AUDIO_DEVICE_OUT_ALL_A2DP = (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
489 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
490 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
491 AUDIO_DEVICE_OUT_ALL_SCO = (AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
492 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
493 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT),
494 AUDIO_DEVICE_OUT_ALL_USB = (AUDIO_DEVICE_OUT_USB_ACCESSORY |
495 AUDIO_DEVICE_OUT_USB_DEVICE),
496 /* input devices */
497 AUDIO_DEVICE_IN_COMMUNICATION = AUDIO_DEVICE_BIT_IN | 0x1,
498 AUDIO_DEVICE_IN_AMBIENT = AUDIO_DEVICE_BIT_IN | 0x2,
499 AUDIO_DEVICE_IN_BUILTIN_MIC = AUDIO_DEVICE_BIT_IN | 0x4,
500 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = AUDIO_DEVICE_BIT_IN | 0x8,
501 AUDIO_DEVICE_IN_WIRED_HEADSET = AUDIO_DEVICE_BIT_IN | 0x10,
502 AUDIO_DEVICE_IN_AUX_DIGITAL = AUDIO_DEVICE_BIT_IN | 0x20,
503 AUDIO_DEVICE_IN_HDMI = AUDIO_DEVICE_IN_AUX_DIGITAL,
504 /* Telephony voice RX path */
505 AUDIO_DEVICE_IN_VOICE_CALL = AUDIO_DEVICE_BIT_IN | 0x40,
506 AUDIO_DEVICE_IN_BACK_MIC = AUDIO_DEVICE_BIT_IN | 0x80,
507 AUDIO_DEVICE_IN_REMOTE_SUBMIX = AUDIO_DEVICE_BIT_IN | 0x100,
508 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x200,
509 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x400,
510 AUDIO_DEVICE_IN_USB_ACCESSORY = AUDIO_DEVICE_BIT_IN | 0x800,
511 AUDIO_DEVICE_IN_USB_DEVICE = AUDIO_DEVICE_BIT_IN | 0x1000,
512 /* FM tuner input */
513 AUDIO_DEVICE_IN_FM_TUNER = AUDIO_DEVICE_BIT_IN | 0x2000,
514 /* TV tuner input */
515 AUDIO_DEVICE_IN_TV_TUNER = AUDIO_DEVICE_BIT_IN | 0x4000,
516 /* Analog jack with line impedance detected */
517 AUDIO_DEVICE_IN_LINE = AUDIO_DEVICE_BIT_IN | 0x8000,
518 /* S/PDIF in */
519 AUDIO_DEVICE_IN_SPDIF = AUDIO_DEVICE_BIT_IN | 0x10000,
520 AUDIO_DEVICE_IN_BLUETOOTH_A2DP = AUDIO_DEVICE_BIT_IN | 0x20000,
521 AUDIO_DEVICE_IN_LOOPBACK = AUDIO_DEVICE_BIT_IN | 0x40000,
522 AUDIO_DEVICE_IN_DEFAULT = AUDIO_DEVICE_BIT_IN | AUDIO_DEVICE_BIT_DEFAULT,
523 AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_COMMUNICATION |
524 AUDIO_DEVICE_IN_AMBIENT |
525 AUDIO_DEVICE_IN_BUILTIN_MIC |
526 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET |
527 AUDIO_DEVICE_IN_WIRED_HEADSET |
528 AUDIO_DEVICE_IN_AUX_DIGITAL |
529 AUDIO_DEVICE_IN_VOICE_CALL |
530 AUDIO_DEVICE_IN_BACK_MIC |
531 AUDIO_DEVICE_IN_REMOTE_SUBMIX |
532 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET |
533 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET |
534 AUDIO_DEVICE_IN_USB_ACCESSORY |
535 AUDIO_DEVICE_IN_USB_DEVICE |
536 AUDIO_DEVICE_IN_FM_TUNER |
537 AUDIO_DEVICE_IN_TV_TUNER |
538 AUDIO_DEVICE_IN_LINE |
539 AUDIO_DEVICE_IN_SPDIF |
540 AUDIO_DEVICE_IN_BLUETOOTH_A2DP |
541 AUDIO_DEVICE_IN_LOOPBACK |
542 AUDIO_DEVICE_IN_DEFAULT),
543 AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
544 AUDIO_DEVICE_IN_ALL_USB = (AUDIO_DEVICE_IN_USB_ACCESSORY |
545 AUDIO_DEVICE_IN_USB_DEVICE),
546 };
547
548 typedef uint32_t audio_devices_t;
549 #endif
550
audio_is_output_device(uint32_t device)551 static inline bool audio_is_output_device(uint32_t device)
552 {
553 #if ANDROID_VERSION < 17
554 if ((__builtin_popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL) == 0))
555 return true;
556 else
557 return false;
558 #else
559 if (((device & AUDIO_DEVICE_BIT_IN) == 0) &&
560 (__builtin_popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL) == 0))
561 return true;
562 else
563 return false;
564 #endif
565 }
566
567 /* device connection states used for audio_policy->set_device_connection_state()
568 * */
569 typedef enum {
570 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
571 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
572
573 AUDIO_POLICY_DEVICE_STATE_CNT,
574 AUDIO_POLICY_DEVICE_STATE_MAX = AUDIO_POLICY_DEVICE_STATE_CNT - 1,
575 } audio_policy_dev_state_t;
576
577 namespace android {
578
579 typedef void (*audio_error_callback)(status_t err);
580 typedef int audio_io_handle_t;
581
582 class IAudioPolicyService;
583 class String8;
584
585 class AudioSystem
586 {
587 public:
588
589 enum stream_type {
590 DEFAULT =-1,
591 VOICE_CALL = 0,
592 SYSTEM = 1,
593 RING = 2,
594 MUSIC = 3,
595 ALARM = 4,
596 NOTIFICATION = 5,
597 BLUETOOTH_SCO = 6,
598 ENFORCED_AUDIBLE = 7, // Sounds that cannot be muted by user and must be routed to speaker
599 DTMF = 8,
600 TTS = 9,
601 FM = 10,
602 NUM_STREAM_TYPES
603 };
604
605 // Audio sub formats (see AudioSystem::audio_format).
606 enum pcm_sub_format {
607 PCM_SUB_16_BIT = 0x1, // must be 1 for backward compatibility
608 PCM_SUB_8_BIT = 0x2, // must be 2 for backward compatibility
609 };
610
611 // MP3 sub format field definition : can use 11 LSBs in the same way as MP3 frame header to specify
612 // bit rate, stereo mode, version...
613 enum mp3_sub_format {
614 //TODO
615 };
616
617 // AMR NB/WB sub format field definition: specify frame block interleaving, bandwidth efficient or octet aligned,
618 // encoding mode for recording...
619 enum amr_sub_format {
620 //TODO
621 };
622
623 // AAC sub format field definition: specify profile or bitrate for recording...
624 enum aac_sub_format {
625 //TODO
626 };
627
628 // VORBIS sub format field definition: specify quality for recording...
629 enum vorbis_sub_format {
630 //TODO
631 };
632
633 // Audio format consists in a main format field (upper 8 bits) and a sub format field (lower 24 bits).
634 // The main format indicates the main codec type. The sub format field indicates options and parameters
635 // for each format. The sub format is mainly used for record to indicate for instance the requested bitrate
636 // or profile. It can also be used for certain formats to give informations not present in the encoded
637 // audio stream (e.g. octet alignement for AMR).
638 enum audio_format {
639 INVALID_FORMAT = -1,
640 FORMAT_DEFAULT = 0,
641 PCM = 0x00000000, // must be 0 for backward compatibility
642 MP3 = 0x01000000,
643 AMR_NB = 0x02000000,
644 AMR_WB = 0x03000000,
645 AAC = 0x04000000,
646 HE_AAC_V1 = 0x05000000,
647 HE_AAC_V2 = 0x06000000,
648 VORBIS = 0x07000000,
649 EVRC = 0x08000000,
650 QCELP = 0x09000000,
651 VOIP_PCM_INPUT = 0x0A000000,
652 MAIN_FORMAT_MASK = 0xFF000000,
653 SUB_FORMAT_MASK = 0x00FFFFFF,
654 // Aliases
655 PCM_16_BIT = (PCM|PCM_SUB_16_BIT),
656 PCM_8_BIT = (PCM|PCM_SUB_8_BIT)
657 };
658
659
660 // Channel mask definitions must be kept in sync with JAVA values in /media/java/android/media/AudioFormat.java
661 enum audio_channels {
662 // output channels
663 CHANNEL_OUT_FRONT_LEFT = 0x4,
664 CHANNEL_OUT_FRONT_RIGHT = 0x8,
665 CHANNEL_OUT_FRONT_CENTER = 0x10,
666 CHANNEL_OUT_LOW_FREQUENCY = 0x20,
667 CHANNEL_OUT_BACK_LEFT = 0x40,
668 CHANNEL_OUT_BACK_RIGHT = 0x80,
669 CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x100,
670 CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x200,
671 CHANNEL_OUT_BACK_CENTER = 0x400,
672 CHANNEL_OUT_MONO = CHANNEL_OUT_FRONT_LEFT,
673 CHANNEL_OUT_STEREO = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT),
674 CHANNEL_OUT_QUAD = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
675 CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
676 CHANNEL_OUT_SURROUND = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
677 CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_BACK_CENTER),
678 CHANNEL_OUT_5POINT1 = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
679 CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT),
680 CHANNEL_OUT_7POINT1 = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
681 CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT |
682 CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER),
683 CHANNEL_OUT_ALL = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT |
684 CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT |
685 CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER | CHANNEL_OUT_BACK_CENTER),
686
687 // input channels
688 CHANNEL_IN_LEFT = 0x4,
689 CHANNEL_IN_RIGHT = 0x8,
690 CHANNEL_IN_FRONT = 0x10,
691 CHANNEL_IN_BACK = 0x20,
692 CHANNEL_IN_LEFT_PROCESSED = 0x40,
693 CHANNEL_IN_RIGHT_PROCESSED = 0x80,
694 CHANNEL_IN_FRONT_PROCESSED = 0x100,
695 CHANNEL_IN_BACK_PROCESSED = 0x200,
696 CHANNEL_IN_PRESSURE = 0x400,
697 CHANNEL_IN_X_AXIS = 0x800,
698 CHANNEL_IN_Y_AXIS = 0x1000,
699 CHANNEL_IN_Z_AXIS = 0x2000,
700 CHANNEL_IN_VOICE_UPLINK = 0x4000,
701 CHANNEL_IN_VOICE_DNLINK = 0x8000,
702 CHANNEL_IN_MONO = CHANNEL_IN_FRONT,
703 CHANNEL_IN_STEREO = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT),
704 CHANNEL_IN_ALL = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT | CHANNEL_IN_FRONT | CHANNEL_IN_BACK|
705 CHANNEL_IN_LEFT_PROCESSED | CHANNEL_IN_RIGHT_PROCESSED | CHANNEL_IN_FRONT_PROCESSED | CHANNEL_IN_BACK_PROCESSED|
706 CHANNEL_IN_PRESSURE | CHANNEL_IN_X_AXIS | CHANNEL_IN_Y_AXIS | CHANNEL_IN_Z_AXIS |
707 CHANNEL_IN_VOICE_UPLINK | CHANNEL_IN_VOICE_DNLINK)
708 };
709
710 enum audio_mode {
711 MODE_INVALID = -2,
712 MODE_CURRENT = -1,
713 MODE_NORMAL = 0,
714 MODE_RINGTONE,
715 MODE_IN_CALL,
716 MODE_IN_COMMUNICATION,
717 NUM_MODES // not a valid entry, denotes end-of-list
718 };
719
720 enum audio_in_acoustics {
721 AGC_ENABLE = 0x0001,
722 AGC_DISABLE = 0,
723 NS_ENABLE = 0x0002,
724 NS_DISABLE = 0,
725 TX_IIR_ENABLE = 0x0004,
726 TX_DISABLE = 0
727 };
728
729 // special audio session values
730 enum audio_sessions {
731 SESSION_OUTPUT_STAGE = -1, // session for effects attached to a particular output stream
732 // (value must be less than 0)
733 SESSION_OUTPUT_MIX = 0, // session for effects applied to output mix. These effects can
734 // be moved by audio policy manager to another output stream
735 // (value must be 0)
736 };
737
738 /* These are static methods to control the system-wide AudioFlinger
739 * only privileged processes can have access to them
740 */
741
742 // mute/unmute microphone
743 static status_t muteMicrophone(bool state);
744 static status_t isMicrophoneMuted(bool *state);
745
746 // set/get master volume
747 static status_t setMasterVolume(float value);
748 static status_t getMasterVolume(float* volume);
749 // mute/unmute audio outputs
750 static status_t setMasterMute(bool mute);
751 static status_t getMasterMute(bool* mute);
752
753 // set/get stream volume on specified output
754 static status_t setStreamVolume(int stream, float value, int output);
755 static status_t getStreamVolume(int stream, float* volume, int output);
756
757 // mute/unmute stream
758 static status_t setStreamMute(int stream, bool mute);
759 static status_t getStreamMute(int stream, bool* mute);
760
761 // set audio mode in audio hardware (see AudioSystem::audio_mode)
762 static status_t setMode(int mode);
763
764 // returns true in *state if tracks are active on the specified stream
765 static status_t isStreamActive(int stream, bool *state);
766
767 // set/get audio hardware parameters. The function accepts a list of parameters
768 // key value pairs in the form: key1=value1;key2=value2;...
769 // Some keys are reserved for standard parameters (See AudioParameter class).
770 static status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
771 static String8 getParameters(audio_io_handle_t ioHandle, const String8& keys);
772
773 static void setErrorCallback(audio_error_callback cb);
774
775 // helper function to obtain AudioFlinger service handle
776 static const sp<IAudioFlinger>& get_audio_flinger();
777
778 static float linearToLog(int volume);
779 static int logToLinear(float volume);
780
781 static status_t getOutputSamplingRate(int* samplingRate, int stream = DEFAULT);
782 static status_t getOutputFrameCount(int* frameCount, int stream = DEFAULT);
783 static status_t getOutputLatency(uint32_t* latency, int stream = DEFAULT);
784
785 static bool routedToA2dpOutput(int streamType);
786
787 static status_t getInputBufferSize(uint32_t sampleRate, int format, int channelCount,
788 size_t* buffSize);
789
790 static status_t setVoiceVolume(float volume);
791
792 // return the number of audio frames written by AudioFlinger to audio HAL and
793 // audio dsp to DAC since the output on which the specificed stream is playing
794 // has exited standby.
795 // returned status (from utils/Errors.h) can be:
796 // - NO_ERROR: successful operation, halFrames and dspFrames point to valid data
797 // - INVALID_OPERATION: Not supported on current hardware platform
798 // - BAD_VALUE: invalid parameter
799 // NOTE: this feature is not supported on all hardware platforms and it is
800 // necessary to check returned status before using the returned values.
801 static status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int stream = DEFAULT);
802
803 static unsigned int getInputFramesLost(audio_io_handle_t ioHandle);
804
805 static int newAudioSessionId();
806 //
807 // AudioPolicyService interface
808 //
809
810 enum audio_devices {
811 // output devices
812 DEVICE_OUT_EARPIECE = 0x1,
813 DEVICE_OUT_SPEAKER = 0x2,
814 DEVICE_OUT_WIRED_HEADSET = 0x4,
815 DEVICE_OUT_WIRED_HEADPHONE = 0x8,
816 DEVICE_OUT_BLUETOOTH_SCO = 0x10,
817 DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
818 DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
819 DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
820 DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
821 DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
822 DEVICE_OUT_AUX_DIGITAL = 0x400,
823 DEVICE_OUT_DEFAULT = 0x8000,
824 DEVICE_OUT_ALL = (DEVICE_OUT_EARPIECE | DEVICE_OUT_SPEAKER | DEVICE_OUT_WIRED_HEADSET |
825 DEVICE_OUT_WIRED_HEADPHONE | DEVICE_OUT_BLUETOOTH_SCO | DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
826 DEVICE_OUT_BLUETOOTH_SCO_CARKIT | DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
827 DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER | DEVICE_OUT_AUX_DIGITAL | DEVICE_OUT_DEFAULT),
828 DEVICE_OUT_ALL_A2DP = (DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
829 DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
830
831 // input devices
832 DEVICE_IN_COMMUNICATION = 0x10000,
833 DEVICE_IN_AMBIENT = 0x20000,
834 DEVICE_IN_BUILTIN_MIC = 0x40000,
835 DEVICE_IN_BLUETOOTH_SCO_HEADSET = 0x80000,
836 DEVICE_IN_WIRED_HEADSET = 0x100000,
837 DEVICE_IN_AUX_DIGITAL = 0x200000,
838 DEVICE_IN_VOICE_CALL = 0x400000,
839 DEVICE_IN_BACK_MIC = 0x800000,
840 DEVICE_IN_DEFAULT = 0x80000000,
841
842 DEVICE_IN_ALL = (DEVICE_IN_COMMUNICATION | DEVICE_IN_AMBIENT | DEVICE_IN_BUILTIN_MIC |
843 DEVICE_IN_BLUETOOTH_SCO_HEADSET | DEVICE_IN_WIRED_HEADSET | DEVICE_IN_AUX_DIGITAL |
844 DEVICE_IN_VOICE_CALL | DEVICE_IN_BACK_MIC | DEVICE_IN_DEFAULT)
845 };
846
847 // device connection states used for setDeviceConnectionState()
848 enum device_connection_state {
849 DEVICE_STATE_UNAVAILABLE,
850 DEVICE_STATE_AVAILABLE,
851 NUM_DEVICE_STATES
852 };
853
854 // request to open a direct output with getOutput() (by opposition to sharing an output with other AudioTracks)
855 enum output_flags {
856 OUTPUT_FLAG_INDIRECT = 0x0,
857 OUTPUT_FLAG_DIRECT = 0x1
858 };
859
860 // device categories used for setForceUse()
861 enum forced_config {
862 FORCE_NONE,
863 FORCE_SPEAKER,
864 FORCE_HEADPHONES,
865 FORCE_BT_SCO,
866 FORCE_BT_A2DP,
867 FORCE_WIRED_ACCESSORY,
868 FORCE_BT_CAR_DOCK,
869 FORCE_BT_DESK_DOCK,
870 FORCE_ANALOG_DOCK,
871 FORCE_DIGITAL_DOCK,
872 FORCE_NO_BT_A2DP,
873 NUM_FORCE_CONFIG,
874 FORCE_DEFAULT = FORCE_NONE
875 };
876
877 // usages used for setForceUse()
878 enum force_use {
879 FOR_COMMUNICATION,
880 FOR_MEDIA,
881 FOR_RECORD,
882 FOR_DOCK,
883 NUM_FORCE_USE
884 };
885
886 // types of io configuration change events received with ioConfigChanged()
887 enum io_config_event {
888 OUTPUT_OPENED,
889 OUTPUT_CLOSED,
890 OUTPUT_CONFIG_CHANGED,
891 INPUT_OPENED,
892 INPUT_CLOSED,
893 INPUT_CONFIG_CHANGED,
894 STREAM_CONFIG_CHANGED,
895 NUM_CONFIG_EVENTS
896 };
897
898 // audio output descritor used to cache output configurations in client process to avoid frequent calls
899 // through IAudioFlinger
900 class OutputDescriptor {
901 public:
OutputDescriptor()902 OutputDescriptor()
903 : samplingRate(0), format(0), channels(0), frameCount(0), latency(0) {}
904
905 uint32_t samplingRate;
906 int32_t format;
907 int32_t channels;
908 size_t frameCount;
909 uint32_t latency;
910 };
911
912 //
913 // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)
914 //
915 static status_t setDeviceConnectionState(audio_devices device, device_connection_state state, const char *device_address);
916 static device_connection_state getDeviceConnectionState(audio_devices device, const char *device_address);
917 static status_t setPhoneState(int state);
918 #if ANDROID_VERSION >= 17
919 static status_t setPhoneState(audio_mode_t state);
920 #endif
921 static status_t setRingerMode(uint32_t mode, uint32_t mask);
922 #ifdef VANILLA_ANDROID
923 static status_t setForceUse(force_use usage, forced_config config);
924 static forced_config getForceUse(force_use usage);
925 static audio_io_handle_t getOutput(stream_type stream,
926 uint32_t samplingRate = 0,
927 uint32_t format = FORMAT_DEFAULT,
928 uint32_t channels = CHANNEL_OUT_STEREO,
929 output_flags flags = OUTPUT_FLAG_INDIRECT);
930 static status_t setDeviceConnectionState(audio_devices_t device, audio_policy_dev_state_t state, const char *device_address);
931 static status_t setFmVolume(float volume);
932 static audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, const char *device_address);
933 #else
934 static status_t setForceUse(force_use usage, forced_config config) __attribute__((weak));
935 static forced_config getForceUse(force_use usage) __attribute__((weak));
936 static audio_io_handle_t getOutput(stream_type stream,
937 uint32_t samplingRate = 0,
938 uint32_t format = FORMAT_DEFAULT,
939 uint32_t channels = CHANNEL_OUT_STEREO,
940 output_flags flags = OUTPUT_FLAG_INDIRECT) __attribute__((weak));
941
942 static status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) __attribute__((weak));
943 static audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) __attribute__((weak));
944 static audio_io_handle_t getOutput(audio_stream_type_t stream,
945 uint32_t samplingRate = 0,
946 uint32_t format = AUDIO_FORMAT_DEFAULT,
947 uint32_t channels = AUDIO_CHANNEL_OUT_STEREO,
948 audio_policy_output_flags_t flags = AUDIO_POLICY_OUTPUT_FLAG_INDIRECT) __attribute__((weak));
949 static status_t setDeviceConnectionState(audio_devices_t device, audio_policy_dev_state_t state, const char *device_address) __attribute__((weak));
950 static status_t setFmVolume(float volume) __attribute__((weak));
951 static audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, const char *device_address) __attribute__((weak));
952
953 #endif
954 static status_t startOutput(audio_io_handle_t output,
955 AudioSystem::stream_type stream,
956 int session = 0);
957 static status_t stopOutput(audio_io_handle_t output,
958 AudioSystem::stream_type stream,
959 int session = 0);
960 static void releaseOutput(audio_io_handle_t output);
961 static audio_io_handle_t getInput(int inputSource,
962 uint32_t samplingRate = 0,
963 uint32_t format = FORMAT_DEFAULT,
964 uint32_t channels = CHANNEL_IN_MONO,
965 audio_in_acoustics acoustics = (audio_in_acoustics)0);
966 static status_t startInput(audio_io_handle_t input);
967 static status_t stopInput(audio_io_handle_t input);
968 static void releaseInput(audio_io_handle_t input);
969 static status_t initStreamVolume(stream_type stream,
970 int indexMin,
971 int indexMax);
972 static status_t initStreamVolume(audio_stream_type_t stream,
973 int indexMin,
974 int indexMax);
975 static status_t setStreamVolumeIndex(stream_type stream, int index);
976 static status_t setStreamVolumeIndex(audio_stream_type_t stream, int index);
977 #if ANDROID_VERSION >= 17
978 static status_t setStreamVolumeIndex(audio_stream_type_t stream,
979 int index,
980 audio_devices_t device);
981 static status_t getStreamVolumeIndex(audio_stream_type_t stream,
982 int *index,
983 audio_devices_t device);
984 #endif
985 static status_t getStreamVolumeIndex(stream_type stream, int *index);
986 static status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index);
987
988 static uint32_t getStrategyForStream(stream_type stream);
989 #if ANDROID_VERSION >= 17
990 static audio_devices_t getDevicesForStream(audio_stream_type_t stream);
991 #endif
992
993 static audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc);
994 static status_t registerEffect(effect_descriptor_t *desc,
995 audio_io_handle_t output,
996 uint32_t strategy,
997 int session,
998 int id);
999 static status_t unregisterEffect(int id);
1000
1001 static const sp<IAudioPolicyService>& get_audio_policy_service();
1002
1003 // ----------------------------------------------------------------------------
1004
1005 static uint32_t popCount(uint32_t u);
1006 static bool isOutputDevice(audio_devices device);
1007 static bool isInputDevice(audio_devices device);
1008 static bool isA2dpDevice(audio_devices device);
1009 static bool isBluetoothScoDevice(audio_devices device);
1010 static bool isSeperatedStream(stream_type stream);
1011 static bool isLowVisibility(stream_type stream);
1012 static bool isOutputChannel(uint32_t channel);
1013 static bool isInputChannel(uint32_t channel);
1014 static bool isValidFormat(uint32_t format);
1015 static bool isLinearPCM(uint32_t format);
1016 static bool isModeInCall();
1017
1018 #if ANDROID_VERSION >= 21
1019 class AudioPortCallback : public RefBase
1020 {
1021 public:
1022
AudioPortCallback()1023 AudioPortCallback() {}
~AudioPortCallback()1024 virtual ~AudioPortCallback() {}
1025
1026 virtual void onAudioPortListUpdate() = 0;
1027 virtual void onAudioPatchListUpdate() = 0;
1028 virtual void onServiceDied() = 0;
1029
1030 };
1031
1032 static void setAudioPortCallback(sp<AudioPortCallback> callBack);
1033 #endif
1034
1035 private:
1036
1037 class AudioFlingerClient: public IBinder::DeathRecipient, public BnAudioFlingerClient
1038 {
1039 public:
AudioFlingerClient()1040 AudioFlingerClient() {
1041 }
1042
1043 // DeathRecipient
1044 virtual void binderDied(const wp<IBinder>& who);
1045
1046 // IAudioFlingerClient
1047
1048 // indicate a change in the configuration of an output or input: keeps the cached
1049 // values for output/input parameters upto date in client process
1050 virtual void ioConfigChanged(int event, int ioHandle, void *param2);
1051 };
1052
1053 class AudioPolicyServiceClient: public IBinder::DeathRecipient
1054 {
1055 public:
AudioPolicyServiceClient()1056 AudioPolicyServiceClient() {
1057 }
1058
1059 // DeathRecipient
1060 virtual void binderDied(const wp<IBinder>& who);
1061 };
1062
1063 static sp<AudioFlingerClient> gAudioFlingerClient;
1064 static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient;
1065 friend class AudioFlingerClient;
1066 friend class AudioPolicyServiceClient;
1067
1068 static Mutex gLock;
1069 static sp<IAudioFlinger> gAudioFlinger;
1070 static audio_error_callback gAudioErrorCallback;
1071
1072 static size_t gInBuffSize;
1073 // previous parameters for recording buffer size queries
1074 static uint32_t gPrevInSamplingRate;
1075 static int gPrevInFormat;
1076 static int gPrevInChannelCount;
1077
1078 static sp<IAudioPolicyService> gAudioPolicyService;
1079
1080 // mapping between stream types and outputs
1081 static DefaultKeyedVector<int, audio_io_handle_t> gStreamOutputMap;
1082 // list of output descritor containing cached parameters (sampling rate, framecount, channel count...)
1083 static DefaultKeyedVector<audio_io_handle_t, OutputDescriptor *> gOutputs;
1084 };
1085
1086 class AudioParameter {
1087
1088 public:
AudioParameter()1089 AudioParameter() {}
1090 AudioParameter(const String8& keyValuePairs);
1091 virtual ~AudioParameter();
1092
1093 // reserved parameter keys for changing standard parameters with setParameters() function.
1094 // Using these keys is mandatory for AudioFlinger to properly monitor audio output/input
1095 // configuration changes and act accordingly.
1096 // keyRouting: to change audio routing, value is an int in AudioSystem::audio_devices
1097 // keySamplingRate: to change sampling rate routing, value is an int
1098 // keyFormat: to change audio format, value is an int in AudioSystem::audio_format
1099 // keyChannels: to change audio channel configuration, value is an int in AudioSystem::audio_channels
1100 // keyFrameCount: to change audio output frame count, value is an int
1101 // keyInputSource: to change audio input source, value is an int in audio_source
1102 // (defined in media/mediarecorder.h)
1103 static const char *keyRouting;
1104 static const char *keySamplingRate;
1105 static const char *keyFormat;
1106 static const char *keyChannels;
1107 static const char *keyFrameCount;
1108 static const char *keyInputSource;
1109
1110 String8 toString();
1111
1112 status_t add(const String8& key, const String8& value);
1113 status_t addInt(const String8& key, const int value);
1114 status_t addFloat(const String8& key, const float value);
1115
1116 status_t remove(const String8& key);
1117
1118 status_t get(const String8& key, String8& value);
1119 status_t getInt(const String8& key, int& value);
1120 status_t getFloat(const String8& key, float& value);
1121 status_t getAt(size_t index, String8& key, String8& value);
1122
size()1123 size_t size() { return mParameters.size(); }
1124
1125 private:
1126 String8 mKeyValuePairs;
1127 KeyedVector <String8, String8> mParameters;
1128 };
1129
1130 }; // namespace android
1131
1132 #pragma GCC visibility pop
1133
1134 #endif /*ANDROID_AUDIOSYSTEM_H_*/
1135