1 /*
2 * Copyright (C) 2011 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
18 #ifndef ANDROID_AUDIO_CORE_H
19 #define ANDROID_AUDIO_CORE_H
20
21 #include <stdbool.h>
22 #include <stdint.h>
23 #include <stdio.h>
24 #include <sys/cdefs.h>
25 #include <sys/types.h>
26
27 #include <cutils/bitops.h>
28
29 __BEGIN_DECLS
30
31 /* The macro FCC_2 highlights places where there are 2-channel assumptions.
32 * This is typically due to legacy implementation of stereo input or output.
33 * Search also for "2", "left", "right", "[0]", "[1]", ">> 16", "<< 16", etc.
34 * Do not change this value.
35 */
36 #define FCC_2 2 // FCC_2 = Fixed Channel Count 2
37
38 /* The macro FCC_8 highlights places where there are 8-channel assumptions.
39 * This is typically due to audio mixer and resampler limitations.
40 * Do not change this value without verifying all locations that use it.
41 */
42 #define FCC_8 8 // FCC_8 = Fixed Channel Count 8
43
44 /* The enums were moved here mostly from
45 * frameworks/base/include/media/AudioSystem.h
46 */
47
48 /* device address used to refer to the standard remote submix */
49 #define AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS "0"
50
51 /* AudioFlinger and AudioPolicy services use I/O handles to identify audio sources and sinks */
52 typedef int audio_io_handle_t;
53 #define AUDIO_IO_HANDLE_NONE 0
54
55 /* Audio stream types */
56 typedef enum {
57 /* These values must kept in sync with
58 * frameworks/base/media/java/android/media/AudioSystem.java
59 */
60 AUDIO_STREAM_DEFAULT = -1,
61 AUDIO_STREAM_MIN = 0,
62 AUDIO_STREAM_VOICE_CALL = 0,
63 AUDIO_STREAM_SYSTEM = 1,
64 AUDIO_STREAM_RING = 2,
65 AUDIO_STREAM_MUSIC = 3,
66 AUDIO_STREAM_ALARM = 4,
67 AUDIO_STREAM_NOTIFICATION = 5,
68 AUDIO_STREAM_BLUETOOTH_SCO = 6,
69 AUDIO_STREAM_ENFORCED_AUDIBLE = 7, /* Sounds that cannot be muted by user
70 * and must be routed to speaker
71 */
72 AUDIO_STREAM_DTMF = 8,
73 AUDIO_STREAM_TTS = 9, /* Transmitted Through Speaker.
74 * Plays over speaker only, silent on other devices.
75 */
76 AUDIO_STREAM_ACCESSIBILITY = 10, /* For accessibility talk back prompts */
77 AUDIO_STREAM_REROUTING = 11, /* For dynamic policy output mixes */
78 AUDIO_STREAM_PATCH = 12, /* For internal audio flinger tracks. Fixed volume */
79 AUDIO_STREAM_PUBLIC_CNT = AUDIO_STREAM_TTS + 1,
80 AUDIO_STREAM_FOR_POLICY_CNT = AUDIO_STREAM_PATCH, /* number of streams considered by
81 audio policy for volume and routing */
82 AUDIO_STREAM_CNT = AUDIO_STREAM_PATCH + 1,
83 } audio_stream_type_t;
84
85 /* Do not change these values without updating their counterparts
86 * in frameworks/base/media/java/android/media/AudioAttributes.java
87 */
88 typedef enum {
89 AUDIO_CONTENT_TYPE_UNKNOWN = 0,
90 AUDIO_CONTENT_TYPE_SPEECH = 1,
91 AUDIO_CONTENT_TYPE_MUSIC = 2,
92 AUDIO_CONTENT_TYPE_MOVIE = 3,
93 AUDIO_CONTENT_TYPE_SONIFICATION = 4,
94
95 AUDIO_CONTENT_TYPE_CNT,
96 AUDIO_CONTENT_TYPE_MAX = AUDIO_CONTENT_TYPE_CNT - 1,
97 } audio_content_type_t;
98
99 /* Do not change these values without updating their counterparts
100 * in frameworks/base/media/java/android/media/AudioAttributes.java
101 */
102 typedef enum {
103 AUDIO_USAGE_UNKNOWN = 0,
104 AUDIO_USAGE_MEDIA = 1,
105 AUDIO_USAGE_VOICE_COMMUNICATION = 2,
106 AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING = 3,
107 AUDIO_USAGE_ALARM = 4,
108 AUDIO_USAGE_NOTIFICATION = 5,
109 AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE = 6,
110 AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7,
111 AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8,
112 AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9,
113 AUDIO_USAGE_NOTIFICATION_EVENT = 10,
114 AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY = 11,
115 AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12,
116 AUDIO_USAGE_ASSISTANCE_SONIFICATION = 13,
117 AUDIO_USAGE_GAME = 14,
118 AUDIO_USAGE_VIRTUAL_SOURCE = 15,
119
120 AUDIO_USAGE_CNT,
121 AUDIO_USAGE_MAX = AUDIO_USAGE_CNT - 1,
122 } audio_usage_t;
123
124 typedef uint32_t audio_flags_mask_t;
125
126 /* Do not change these values without updating their counterparts
127 * in frameworks/base/media/java/android/media/AudioAttributes.java
128 */
129 enum {
130 AUDIO_FLAG_AUDIBILITY_ENFORCED = 0x1,
131 AUDIO_FLAG_SECURE = 0x2,
132 AUDIO_FLAG_SCO = 0x4,
133 AUDIO_FLAG_BEACON = 0x8,
134 AUDIO_FLAG_HW_AV_SYNC = 0x10,
135 AUDIO_FLAG_HW_HOTWORD = 0x20,
136 AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY = 0x40,
137 AUDIO_FLAG_BYPASS_MUTE = 0x80,
138 AUDIO_FLAG_LOW_LATENCY = 0x100,
139 };
140
141 /* Do not change these values without updating their counterparts
142 * in frameworks/base/media/java/android/media/MediaRecorder.java,
143 * frameworks/av/services/audiopolicy/AudioPolicyService.cpp,
144 * and system/media/audio_effects/include/audio_effects/audio_effects_conf.h!
145 */
146 typedef enum {
147 AUDIO_SOURCE_DEFAULT = 0,
148 AUDIO_SOURCE_MIC = 1,
149 AUDIO_SOURCE_VOICE_UPLINK = 2,
150 AUDIO_SOURCE_VOICE_DOWNLINK = 3,
151 AUDIO_SOURCE_VOICE_CALL = 4,
152 AUDIO_SOURCE_CAMCORDER = 5,
153 AUDIO_SOURCE_VOICE_RECOGNITION = 6,
154 AUDIO_SOURCE_VOICE_COMMUNICATION = 7,
155 AUDIO_SOURCE_REMOTE_SUBMIX = 8, /* Source for the mix to be presented remotely. */
156 /* An example of remote presentation is Wifi Display */
157 /* where a dongle attached to a TV can be used to */
158 /* play the mix captured by this audio source. */
159 AUDIO_SOURCE_UNPROCESSED = 9, /* Source for unprocessed sound.
160 Usage examples include level measurement and raw
161 signal analysis. */
162 AUDIO_SOURCE_CNT,
163 AUDIO_SOURCE_MAX = AUDIO_SOURCE_CNT - 1,
164 AUDIO_SOURCE_FM_TUNER = 1998,
165 AUDIO_SOURCE_HOTWORD = 1999, /* A low-priority, preemptible audio source for
166 for background software hotword detection.
167 Same tuning as AUDIO_SOURCE_VOICE_RECOGNITION.
168 Used only internally to the framework. Not exposed
169 at the audio HAL. */
170 } audio_source_t;
171
172 /* Audio attributes */
173 #define AUDIO_ATTRIBUTES_TAGS_MAX_SIZE 256
174 typedef struct {
175 audio_content_type_t content_type;
176 audio_usage_t usage;
177 audio_source_t source;
178 audio_flags_mask_t flags;
179 char tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE]; /* UTF8 */
180 } audio_attributes_t;
181
182 /* special audio session values
183 * do not need to have audio_unique_id_get_use(session) == AUDIO_UNIQUE_ID_USE_SESSION
184 * (XXX: should this be living in the audio effects land?)
185 */
186 typedef enum {
187 /* session for effects attached to a particular output stream
188 * (value must be less than 0)
189 */
190 AUDIO_SESSION_OUTPUT_STAGE = -1,
191
192 /* session for effects applied to output mix. These effects can
193 * be moved by audio policy manager to another output stream
194 * (value must be 0)
195 */
196 AUDIO_SESSION_OUTPUT_MIX = 0,
197
198 /* application does not specify an explicit session ID to be used,
199 * and requests a new session ID to be allocated
200 * TODO use unique values for AUDIO_SESSION_OUTPUT_MIX and AUDIO_SESSION_ALLOCATE,
201 * after all uses have been updated from 0 to the appropriate symbol, and have been tested.
202 * Corresponds to AudioManager.AUDIO_SESSION_ID_GENERATE and AudioSystem.AUDIO_SESSION_ALLOCATE.
203 */
204 AUDIO_SESSION_ALLOCATE = 0,
205
206 /* For use with AudioRecord::start(), this indicates no trigger session.
207 * It is also used with output tracks and patch tracks, which never have a session.
208 */
209 AUDIO_SESSION_NONE = 0,
210 } audio_session_t;
211
212 /* a unique ID allocated by AudioFlinger for use as an audio_io_handle_t, audio_session_t,
213 * effect ID (int), audio_module_handle_t, and audio_patch_handle_t.
214 * Audio port IDs (audio_port_handle_t) are allocated by AudioPolicy
215 * in a different namespace than AudioFlinger unique IDs.
216 */
217 typedef int audio_unique_id_t;
218
219 /* Possible uses for an audio_unique_id_t */
220 typedef enum {
221 AUDIO_UNIQUE_ID_USE_UNSPECIFIED = 0,
222 AUDIO_UNIQUE_ID_USE_SESSION = 1, // for allocated sessions, not special AUDIO_SESSION_*
223 AUDIO_UNIQUE_ID_USE_MODULE = 2,
224 AUDIO_UNIQUE_ID_USE_EFFECT = 3,
225 AUDIO_UNIQUE_ID_USE_PATCH = 4,
226 AUDIO_UNIQUE_ID_USE_OUTPUT = 5,
227 AUDIO_UNIQUE_ID_USE_INPUT = 6,
228 // 7 is available
229 AUDIO_UNIQUE_ID_USE_MAX = 8, // must be a power-of-two
230 AUDIO_UNIQUE_ID_USE_MASK = AUDIO_UNIQUE_ID_USE_MAX - 1
231 } audio_unique_id_use_t;
232
233 /* Return the use of an audio_unique_id_t */
audio_unique_id_get_use(audio_unique_id_t id)234 static inline audio_unique_id_use_t audio_unique_id_get_use(audio_unique_id_t id)
235 {
236 return (audio_unique_id_use_t) (id & AUDIO_UNIQUE_ID_USE_MASK);
237 }
238
239 /* Reserved audio_unique_id_t values. FIXME: not a complete list. */
240 #define AUDIO_UNIQUE_ID_ALLOCATE AUDIO_SESSION_ALLOCATE
241
242 /* Audio sub formats (see enum audio_format). */
243
244 /* PCM sub formats */
245 typedef enum {
246 /* All of these are in native byte order */
247 AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1, /* DO NOT CHANGE - PCM signed 16 bits */
248 AUDIO_FORMAT_PCM_SUB_8_BIT = 0x2, /* DO NOT CHANGE - PCM unsigned 8 bits */
249 AUDIO_FORMAT_PCM_SUB_32_BIT = 0x3, /* PCM signed .31 fixed point */
250 AUDIO_FORMAT_PCM_SUB_8_24_BIT = 0x4, /* PCM signed 8.23 fixed point */
251 AUDIO_FORMAT_PCM_SUB_FLOAT = 0x5, /* PCM single-precision floating point */
252 AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED = 0x6, /* PCM signed .23 fixed point packed in 3 bytes */
253 } audio_format_pcm_sub_fmt_t;
254
255 /* The audio_format_*_sub_fmt_t declarations are not currently used */
256
257 /* MP3 sub format field definition : can use 11 LSBs in the same way as MP3
258 * frame header to specify bit rate, stereo mode, version...
259 */
260 typedef enum {
261 AUDIO_FORMAT_MP3_SUB_NONE = 0x0,
262 } audio_format_mp3_sub_fmt_t;
263
264 /* AMR NB/WB sub format field definition: specify frame block interleaving,
265 * bandwidth efficient or octet aligned, encoding mode for recording...
266 */
267 typedef enum {
268 AUDIO_FORMAT_AMR_SUB_NONE = 0x0,
269 } audio_format_amr_sub_fmt_t;
270
271 /* AAC sub format field definition: specify profile or bitrate for recording... */
272 typedef enum {
273 AUDIO_FORMAT_AAC_SUB_MAIN = 0x1,
274 AUDIO_FORMAT_AAC_SUB_LC = 0x2,
275 AUDIO_FORMAT_AAC_SUB_SSR = 0x4,
276 AUDIO_FORMAT_AAC_SUB_LTP = 0x8,
277 AUDIO_FORMAT_AAC_SUB_HE_V1 = 0x10,
278 AUDIO_FORMAT_AAC_SUB_SCALABLE = 0x20,
279 AUDIO_FORMAT_AAC_SUB_ERLC = 0x40,
280 AUDIO_FORMAT_AAC_SUB_LD = 0x80,
281 AUDIO_FORMAT_AAC_SUB_HE_V2 = 0x100,
282 AUDIO_FORMAT_AAC_SUB_ELD = 0x200,
283 } audio_format_aac_sub_fmt_t;
284
285 /* VORBIS sub format field definition: specify quality for recording... */
286 typedef enum {
287 AUDIO_FORMAT_VORBIS_SUB_NONE = 0x0,
288 } audio_format_vorbis_sub_fmt_t;
289
290
291 /* Audio format is a 32-bit word that consists of:
292 * main format field (upper 8 bits)
293 * sub format field (lower 24 bits).
294 *
295 * The main format indicates the main codec type. The sub format field
296 * indicates options and parameters for each format. The sub format is mainly
297 * used for record to indicate for instance the requested bitrate or profile.
298 * It can also be used for certain formats to give informations not present in
299 * the encoded audio stream (e.g. octet alignement for AMR).
300 */
301 typedef enum {
302 AUDIO_FORMAT_INVALID = 0xFFFFFFFFUL,
303 AUDIO_FORMAT_DEFAULT = 0,
304 AUDIO_FORMAT_PCM = 0x00000000UL, /* DO NOT CHANGE */
305 AUDIO_FORMAT_MP3 = 0x01000000UL,
306 AUDIO_FORMAT_AMR_NB = 0x02000000UL,
307 AUDIO_FORMAT_AMR_WB = 0x03000000UL,
308 AUDIO_FORMAT_AAC = 0x04000000UL,
309 AUDIO_FORMAT_HE_AAC_V1 = 0x05000000UL, /* Deprecated, Use AUDIO_FORMAT_AAC_HE_V1*/
310 AUDIO_FORMAT_HE_AAC_V2 = 0x06000000UL, /* Deprecated, Use AUDIO_FORMAT_AAC_HE_V2*/
311 AUDIO_FORMAT_VORBIS = 0x07000000UL,
312 AUDIO_FORMAT_OPUS = 0x08000000UL,
313 AUDIO_FORMAT_AC3 = 0x09000000UL,
314 AUDIO_FORMAT_E_AC3 = 0x0A000000UL,
315 AUDIO_FORMAT_DTS = 0x0B000000UL,
316 AUDIO_FORMAT_DTS_HD = 0x0C000000UL,
317 // IEC61937 is encoded audio wrapped in 16-bit PCM.
318 AUDIO_FORMAT_IEC61937 = 0x0D000000UL,
319 AUDIO_FORMAT_MAIN_MASK = 0xFF000000UL, /* Deprecated. Use audio_get_main_format() */
320 AUDIO_FORMAT_SUB_MASK = 0x00FFFFFFUL,
321
322 /* Aliases */
323 /* note != AudioFormat.ENCODING_PCM_16BIT */
324 AUDIO_FORMAT_PCM_16_BIT = (AUDIO_FORMAT_PCM |
325 AUDIO_FORMAT_PCM_SUB_16_BIT),
326 /* note != AudioFormat.ENCODING_PCM_8BIT */
327 AUDIO_FORMAT_PCM_8_BIT = (AUDIO_FORMAT_PCM |
328 AUDIO_FORMAT_PCM_SUB_8_BIT),
329 AUDIO_FORMAT_PCM_32_BIT = (AUDIO_FORMAT_PCM |
330 AUDIO_FORMAT_PCM_SUB_32_BIT),
331 AUDIO_FORMAT_PCM_8_24_BIT = (AUDIO_FORMAT_PCM |
332 AUDIO_FORMAT_PCM_SUB_8_24_BIT),
333 AUDIO_FORMAT_PCM_FLOAT = (AUDIO_FORMAT_PCM |
334 AUDIO_FORMAT_PCM_SUB_FLOAT),
335 AUDIO_FORMAT_PCM_24_BIT_PACKED = (AUDIO_FORMAT_PCM |
336 AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED),
337 AUDIO_FORMAT_AAC_MAIN = (AUDIO_FORMAT_AAC |
338 AUDIO_FORMAT_AAC_SUB_MAIN),
339 AUDIO_FORMAT_AAC_LC = (AUDIO_FORMAT_AAC |
340 AUDIO_FORMAT_AAC_SUB_LC),
341 AUDIO_FORMAT_AAC_SSR = (AUDIO_FORMAT_AAC |
342 AUDIO_FORMAT_AAC_SUB_SSR),
343 AUDIO_FORMAT_AAC_LTP = (AUDIO_FORMAT_AAC |
344 AUDIO_FORMAT_AAC_SUB_LTP),
345 AUDIO_FORMAT_AAC_HE_V1 = (AUDIO_FORMAT_AAC |
346 AUDIO_FORMAT_AAC_SUB_HE_V1),
347 AUDIO_FORMAT_AAC_SCALABLE = (AUDIO_FORMAT_AAC |
348 AUDIO_FORMAT_AAC_SUB_SCALABLE),
349 AUDIO_FORMAT_AAC_ERLC = (AUDIO_FORMAT_AAC |
350 AUDIO_FORMAT_AAC_SUB_ERLC),
351 AUDIO_FORMAT_AAC_LD = (AUDIO_FORMAT_AAC |
352 AUDIO_FORMAT_AAC_SUB_LD),
353 AUDIO_FORMAT_AAC_HE_V2 = (AUDIO_FORMAT_AAC |
354 AUDIO_FORMAT_AAC_SUB_HE_V2),
355 AUDIO_FORMAT_AAC_ELD = (AUDIO_FORMAT_AAC |
356 AUDIO_FORMAT_AAC_SUB_ELD),
357 } audio_format_t;
358
359 /* For the channel mask for position assignment representation */
360 enum {
361
362 /* These can be a complete audio_channel_mask_t. */
363
364 AUDIO_CHANNEL_NONE = 0x0,
365 AUDIO_CHANNEL_INVALID = 0xC0000000,
366
367 /* These can be the bits portion of an audio_channel_mask_t
368 * with representation AUDIO_CHANNEL_REPRESENTATION_POSITION.
369 * Using these bits as a complete audio_channel_mask_t is deprecated.
370 */
371
372 /* output channels */
373 AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1,
374 AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2,
375 AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4,
376 AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8,
377 AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10,
378 AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20,
379 AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40,
380 AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80,
381 AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100,
382 AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200,
383 AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400,
384 AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800,
385 AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000,
386 AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000,
387 AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000,
388 AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000,
389 AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000,
390 AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000,
391
392 /* TODO: should these be considered complete channel masks, or only bits? */
393
394 AUDIO_CHANNEL_OUT_MONO = AUDIO_CHANNEL_OUT_FRONT_LEFT,
395 AUDIO_CHANNEL_OUT_STEREO = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
396 AUDIO_CHANNEL_OUT_FRONT_RIGHT),
397 AUDIO_CHANNEL_OUT_QUAD = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
398 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
399 AUDIO_CHANNEL_OUT_BACK_LEFT |
400 AUDIO_CHANNEL_OUT_BACK_RIGHT),
401 AUDIO_CHANNEL_OUT_QUAD_BACK = AUDIO_CHANNEL_OUT_QUAD,
402 /* like AUDIO_CHANNEL_OUT_QUAD_BACK with *_SIDE_* instead of *_BACK_* */
403 AUDIO_CHANNEL_OUT_QUAD_SIDE = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
404 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
405 AUDIO_CHANNEL_OUT_SIDE_LEFT |
406 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
407 AUDIO_CHANNEL_OUT_5POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
408 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
409 AUDIO_CHANNEL_OUT_FRONT_CENTER |
410 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
411 AUDIO_CHANNEL_OUT_BACK_LEFT |
412 AUDIO_CHANNEL_OUT_BACK_RIGHT),
413 AUDIO_CHANNEL_OUT_5POINT1_BACK = AUDIO_CHANNEL_OUT_5POINT1,
414 /* like AUDIO_CHANNEL_OUT_5POINT1_BACK with *_SIDE_* instead of *_BACK_* */
415 AUDIO_CHANNEL_OUT_5POINT1_SIDE = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
416 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
417 AUDIO_CHANNEL_OUT_FRONT_CENTER |
418 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
419 AUDIO_CHANNEL_OUT_SIDE_LEFT |
420 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
421 // matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND definition for 7.1
422 AUDIO_CHANNEL_OUT_7POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
423 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
424 AUDIO_CHANNEL_OUT_FRONT_CENTER |
425 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
426 AUDIO_CHANNEL_OUT_BACK_LEFT |
427 AUDIO_CHANNEL_OUT_BACK_RIGHT |
428 AUDIO_CHANNEL_OUT_SIDE_LEFT |
429 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
430 AUDIO_CHANNEL_OUT_ALL = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
431 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
432 AUDIO_CHANNEL_OUT_FRONT_CENTER |
433 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
434 AUDIO_CHANNEL_OUT_BACK_LEFT |
435 AUDIO_CHANNEL_OUT_BACK_RIGHT |
436 AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER |
437 AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER |
438 AUDIO_CHANNEL_OUT_BACK_CENTER|
439 AUDIO_CHANNEL_OUT_SIDE_LEFT|
440 AUDIO_CHANNEL_OUT_SIDE_RIGHT|
441 AUDIO_CHANNEL_OUT_TOP_CENTER|
442 AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT|
443 AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER|
444 AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT|
445 AUDIO_CHANNEL_OUT_TOP_BACK_LEFT|
446 AUDIO_CHANNEL_OUT_TOP_BACK_CENTER|
447 AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT),
448
449 /* These are bits only, not complete values */
450
451 /* input channels */
452 AUDIO_CHANNEL_IN_LEFT = 0x4,
453 AUDIO_CHANNEL_IN_RIGHT = 0x8,
454 AUDIO_CHANNEL_IN_FRONT = 0x10,
455 AUDIO_CHANNEL_IN_BACK = 0x20,
456 AUDIO_CHANNEL_IN_LEFT_PROCESSED = 0x40,
457 AUDIO_CHANNEL_IN_RIGHT_PROCESSED = 0x80,
458 AUDIO_CHANNEL_IN_FRONT_PROCESSED = 0x100,
459 AUDIO_CHANNEL_IN_BACK_PROCESSED = 0x200,
460 AUDIO_CHANNEL_IN_PRESSURE = 0x400,
461 AUDIO_CHANNEL_IN_X_AXIS = 0x800,
462 AUDIO_CHANNEL_IN_Y_AXIS = 0x1000,
463 AUDIO_CHANNEL_IN_Z_AXIS = 0x2000,
464 AUDIO_CHANNEL_IN_VOICE_UPLINK = 0x4000,
465 AUDIO_CHANNEL_IN_VOICE_DNLINK = 0x8000,
466
467 /* TODO: should these be considered complete channel masks, or only bits, or deprecated? */
468
469 AUDIO_CHANNEL_IN_MONO = AUDIO_CHANNEL_IN_FRONT,
470 AUDIO_CHANNEL_IN_STEREO = (AUDIO_CHANNEL_IN_LEFT | AUDIO_CHANNEL_IN_RIGHT),
471 AUDIO_CHANNEL_IN_FRONT_BACK = (AUDIO_CHANNEL_IN_FRONT | AUDIO_CHANNEL_IN_BACK),
472 AUDIO_CHANNEL_IN_ALL = (AUDIO_CHANNEL_IN_LEFT |
473 AUDIO_CHANNEL_IN_RIGHT |
474 AUDIO_CHANNEL_IN_FRONT |
475 AUDIO_CHANNEL_IN_BACK|
476 AUDIO_CHANNEL_IN_LEFT_PROCESSED |
477 AUDIO_CHANNEL_IN_RIGHT_PROCESSED |
478 AUDIO_CHANNEL_IN_FRONT_PROCESSED |
479 AUDIO_CHANNEL_IN_BACK_PROCESSED|
480 AUDIO_CHANNEL_IN_PRESSURE |
481 AUDIO_CHANNEL_IN_X_AXIS |
482 AUDIO_CHANNEL_IN_Y_AXIS |
483 AUDIO_CHANNEL_IN_Z_AXIS |
484 AUDIO_CHANNEL_IN_VOICE_UPLINK |
485 AUDIO_CHANNEL_IN_VOICE_DNLINK),
486 };
487
488 /* A channel mask per se only defines the presence or absence of a channel, not the order.
489 * But see AUDIO_INTERLEAVE_* below for the platform convention of order.
490 *
491 * audio_channel_mask_t is an opaque type and its internal layout should not
492 * be assumed as it may change in the future.
493 * Instead, always use the functions declared in this header to examine.
494 *
495 * These are the current representations:
496 *
497 * AUDIO_CHANNEL_REPRESENTATION_POSITION
498 * is a channel mask representation for position assignment.
499 * Each low-order bit corresponds to the spatial position of a transducer (output),
500 * or interpretation of channel (input).
501 * The user of a channel mask needs to know the context of whether it is for output or input.
502 * The constants AUDIO_CHANNEL_OUT_* or AUDIO_CHANNEL_IN_* apply to the bits portion.
503 * It is not permitted for no bits to be set.
504 *
505 * AUDIO_CHANNEL_REPRESENTATION_INDEX
506 * is a channel mask representation for index assignment.
507 * Each low-order bit corresponds to a selected channel.
508 * There is no platform interpretation of the various bits.
509 * There is no concept of output or input.
510 * It is not permitted for no bits to be set.
511 *
512 * All other representations are reserved for future use.
513 *
514 * Warning: current representation distinguishes between input and output, but this will not the be
515 * case in future revisions of the platform. Wherever there is an ambiguity between input and output
516 * that is currently resolved by checking the channel mask, the implementer should look for ways to
517 * fix it with additional information outside of the mask.
518 */
519 typedef uint32_t audio_channel_mask_t;
520
521 /* Maximum number of channels for all representations */
522 #define AUDIO_CHANNEL_COUNT_MAX 30
523
524 /* log(2) of maximum number of representations, not part of public API */
525 #define AUDIO_CHANNEL_REPRESENTATION_LOG2 2
526
527 /* Representations */
528 typedef enum {
529 AUDIO_CHANNEL_REPRESENTATION_POSITION = 0, // must be zero for compatibility
530 // 1 is reserved for future use
531 AUDIO_CHANNEL_REPRESENTATION_INDEX = 2,
532 // 3 is reserved for future use
533 } audio_channel_representation_t;
534
535 /* The channel index masks defined here are the canonical masks for 1 to 8 channel
536 * endpoints and apply to both source and sink.
537 */
538 enum {
539 AUDIO_CHANNEL_INDEX_HDR = AUDIO_CHANNEL_REPRESENTATION_INDEX << AUDIO_CHANNEL_COUNT_MAX,
540 AUDIO_CHANNEL_INDEX_MASK_1 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 1) - 1),
541 AUDIO_CHANNEL_INDEX_MASK_2 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 2) - 1),
542 AUDIO_CHANNEL_INDEX_MASK_3 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 3) - 1),
543 AUDIO_CHANNEL_INDEX_MASK_4 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 4) - 1),
544 AUDIO_CHANNEL_INDEX_MASK_5 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 5) - 1),
545 AUDIO_CHANNEL_INDEX_MASK_6 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 6) - 1),
546 AUDIO_CHANNEL_INDEX_MASK_7 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 7) - 1),
547 AUDIO_CHANNEL_INDEX_MASK_8 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 8) - 1),
548 // FIXME FCC_8
549 };
550
551 /* The return value is undefined if the channel mask is invalid. */
audio_channel_mask_get_bits(audio_channel_mask_t channel)552 static inline uint32_t audio_channel_mask_get_bits(audio_channel_mask_t channel)
553 {
554 return channel & ((1 << AUDIO_CHANNEL_COUNT_MAX) - 1);
555 }
556
557 /* The return value is undefined if the channel mask is invalid. */
audio_channel_mask_get_representation(audio_channel_mask_t channel)558 static inline audio_channel_representation_t audio_channel_mask_get_representation(
559 audio_channel_mask_t channel)
560 {
561 // The right shift should be sufficient, but also "and" for safety in case mask is not 32 bits
562 return (audio_channel_representation_t)
563 ((channel >> AUDIO_CHANNEL_COUNT_MAX) & ((1 << AUDIO_CHANNEL_REPRESENTATION_LOG2) - 1));
564 }
565
566 /* Returns true if the channel mask is valid,
567 * or returns false for AUDIO_CHANNEL_NONE, AUDIO_CHANNEL_INVALID, and other invalid values.
568 * This function is unable to determine whether a channel mask for position assignment
569 * is invalid because an output mask has an invalid output bit set,
570 * or because an input mask has an invalid input bit set.
571 * All other APIs that take a channel mask assume that it is valid.
572 */
audio_channel_mask_is_valid(audio_channel_mask_t channel)573 static inline bool audio_channel_mask_is_valid(audio_channel_mask_t channel)
574 {
575 uint32_t bits = audio_channel_mask_get_bits(channel);
576 audio_channel_representation_t representation = audio_channel_mask_get_representation(channel);
577 switch (representation) {
578 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
579 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
580 break;
581 default:
582 bits = 0;
583 break;
584 }
585 return bits != 0;
586 }
587
588 /* Not part of public API */
audio_channel_mask_from_representation_and_bits(audio_channel_representation_t representation,uint32_t bits)589 static inline audio_channel_mask_t audio_channel_mask_from_representation_and_bits(
590 audio_channel_representation_t representation, uint32_t bits)
591 {
592 return (audio_channel_mask_t) ((representation << AUDIO_CHANNEL_COUNT_MAX) | bits);
593 }
594
595 /* Expresses the convention when stereo audio samples are stored interleaved
596 * in an array. This should improve readability by allowing code to use
597 * symbolic indices instead of hard-coded [0] and [1].
598 *
599 * For multi-channel beyond stereo, the platform convention is that channels
600 * are interleaved in order from least significant channel mask bit
601 * to most significant channel mask bit, with unused bits skipped.
602 * Any exceptions to this convention will be noted at the appropriate API.
603 */
604 enum {
605 AUDIO_INTERLEAVE_LEFT = 0,
606 AUDIO_INTERLEAVE_RIGHT = 1,
607 };
608
609 typedef enum {
610 AUDIO_MODE_INVALID = -2,
611 AUDIO_MODE_CURRENT = -1,
612 AUDIO_MODE_NORMAL = 0,
613 AUDIO_MODE_RINGTONE = 1,
614 AUDIO_MODE_IN_CALL = 2,
615 AUDIO_MODE_IN_COMMUNICATION = 3,
616
617 AUDIO_MODE_CNT,
618 AUDIO_MODE_MAX = AUDIO_MODE_CNT - 1,
619 } audio_mode_t;
620
621 /* This enum is deprecated */
622 typedef enum {
623 AUDIO_IN_ACOUSTICS_NONE = 0,
624 AUDIO_IN_ACOUSTICS_AGC_ENABLE = 0x0001,
625 AUDIO_IN_ACOUSTICS_AGC_DISABLE = 0,
626 AUDIO_IN_ACOUSTICS_NS_ENABLE = 0x0002,
627 AUDIO_IN_ACOUSTICS_NS_DISABLE = 0,
628 AUDIO_IN_ACOUSTICS_TX_IIR_ENABLE = 0x0004,
629 AUDIO_IN_ACOUSTICS_TX_DISABLE = 0,
630 } audio_in_acoustics_t;
631
632 enum {
633 AUDIO_DEVICE_NONE = 0x0,
634 /* reserved bits */
635 AUDIO_DEVICE_BIT_IN = 0x80000000,
636 AUDIO_DEVICE_BIT_DEFAULT = 0x40000000,
637 /* output devices */
638 AUDIO_DEVICE_OUT_EARPIECE = 0x1,
639 AUDIO_DEVICE_OUT_SPEAKER = 0x2,
640 AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4,
641 AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8,
642 AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10,
643 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
644 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
645 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
646 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
647 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
648 AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400,
649 AUDIO_DEVICE_OUT_HDMI = AUDIO_DEVICE_OUT_AUX_DIGITAL,
650 /* uses an analog connection (multiplexed over the USB connector pins for instance) */
651 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800,
652 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000,
653 /* USB accessory mode: your Android device is a USB device and the dock is a USB host */
654 AUDIO_DEVICE_OUT_USB_ACCESSORY = 0x2000,
655 /* USB host mode: your Android device is a USB host and the dock is a USB device */
656 AUDIO_DEVICE_OUT_USB_DEVICE = 0x4000,
657 AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 0x8000,
658 /* Telephony voice TX path */
659 AUDIO_DEVICE_OUT_TELEPHONY_TX = 0x10000,
660 /* Analog jack with line impedance detected */
661 AUDIO_DEVICE_OUT_LINE = 0x20000,
662 /* HDMI Audio Return Channel */
663 AUDIO_DEVICE_OUT_HDMI_ARC = 0x40000,
664 /* S/PDIF out */
665 AUDIO_DEVICE_OUT_SPDIF = 0x80000,
666 /* FM transmitter out */
667 AUDIO_DEVICE_OUT_FM = 0x100000,
668 /* Line out for av devices */
669 AUDIO_DEVICE_OUT_AUX_LINE = 0x200000,
670 /* limited-output speaker device for acoustic safety */
671 AUDIO_DEVICE_OUT_SPEAKER_SAFE = 0x400000,
672 AUDIO_DEVICE_OUT_IP = 0x800000,
673 /* audio bus implemented by the audio system (e.g an MOST stereo channel) */
674 AUDIO_DEVICE_OUT_BUS = 0x1000000,
675 AUDIO_DEVICE_OUT_DEFAULT = AUDIO_DEVICE_BIT_DEFAULT,
676 AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_EARPIECE |
677 AUDIO_DEVICE_OUT_SPEAKER |
678 AUDIO_DEVICE_OUT_WIRED_HEADSET |
679 AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
680 AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
681 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
682 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
683 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
684 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
685 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER |
686 AUDIO_DEVICE_OUT_HDMI |
687 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
688 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
689 AUDIO_DEVICE_OUT_USB_ACCESSORY |
690 AUDIO_DEVICE_OUT_USB_DEVICE |
691 AUDIO_DEVICE_OUT_REMOTE_SUBMIX |
692 AUDIO_DEVICE_OUT_TELEPHONY_TX |
693 AUDIO_DEVICE_OUT_LINE |
694 AUDIO_DEVICE_OUT_HDMI_ARC |
695 AUDIO_DEVICE_OUT_SPDIF |
696 AUDIO_DEVICE_OUT_FM |
697 AUDIO_DEVICE_OUT_AUX_LINE |
698 AUDIO_DEVICE_OUT_SPEAKER_SAFE |
699 AUDIO_DEVICE_OUT_IP |
700 AUDIO_DEVICE_OUT_BUS |
701 AUDIO_DEVICE_OUT_DEFAULT),
702 AUDIO_DEVICE_OUT_ALL_A2DP = (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
703 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
704 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
705 AUDIO_DEVICE_OUT_ALL_SCO = (AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
706 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
707 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT),
708 AUDIO_DEVICE_OUT_ALL_USB = (AUDIO_DEVICE_OUT_USB_ACCESSORY |
709 AUDIO_DEVICE_OUT_USB_DEVICE),
710 /* input devices */
711 AUDIO_DEVICE_IN_COMMUNICATION = AUDIO_DEVICE_BIT_IN | 0x1,
712 AUDIO_DEVICE_IN_AMBIENT = AUDIO_DEVICE_BIT_IN | 0x2,
713 AUDIO_DEVICE_IN_BUILTIN_MIC = AUDIO_DEVICE_BIT_IN | 0x4,
714 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = AUDIO_DEVICE_BIT_IN | 0x8,
715 AUDIO_DEVICE_IN_WIRED_HEADSET = AUDIO_DEVICE_BIT_IN | 0x10,
716 AUDIO_DEVICE_IN_AUX_DIGITAL = AUDIO_DEVICE_BIT_IN | 0x20,
717 AUDIO_DEVICE_IN_HDMI = AUDIO_DEVICE_IN_AUX_DIGITAL,
718 /* Telephony voice RX path */
719 AUDIO_DEVICE_IN_VOICE_CALL = AUDIO_DEVICE_BIT_IN | 0x40,
720 AUDIO_DEVICE_IN_TELEPHONY_RX = AUDIO_DEVICE_IN_VOICE_CALL,
721 AUDIO_DEVICE_IN_BACK_MIC = AUDIO_DEVICE_BIT_IN | 0x80,
722 AUDIO_DEVICE_IN_REMOTE_SUBMIX = AUDIO_DEVICE_BIT_IN | 0x100,
723 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x200,
724 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x400,
725 AUDIO_DEVICE_IN_USB_ACCESSORY = AUDIO_DEVICE_BIT_IN | 0x800,
726 AUDIO_DEVICE_IN_USB_DEVICE = AUDIO_DEVICE_BIT_IN | 0x1000,
727 /* FM tuner input */
728 AUDIO_DEVICE_IN_FM_TUNER = AUDIO_DEVICE_BIT_IN | 0x2000,
729 /* TV tuner input */
730 AUDIO_DEVICE_IN_TV_TUNER = AUDIO_DEVICE_BIT_IN | 0x4000,
731 /* Analog jack with line impedance detected */
732 AUDIO_DEVICE_IN_LINE = AUDIO_DEVICE_BIT_IN | 0x8000,
733 /* S/PDIF in */
734 AUDIO_DEVICE_IN_SPDIF = AUDIO_DEVICE_BIT_IN | 0x10000,
735 AUDIO_DEVICE_IN_BLUETOOTH_A2DP = AUDIO_DEVICE_BIT_IN | 0x20000,
736 AUDIO_DEVICE_IN_LOOPBACK = AUDIO_DEVICE_BIT_IN | 0x40000,
737 AUDIO_DEVICE_IN_IP = AUDIO_DEVICE_BIT_IN | 0x80000,
738 /* audio bus implemented by the audio system (e.g an MOST stereo channel) */
739 AUDIO_DEVICE_IN_BUS = AUDIO_DEVICE_BIT_IN | 0x100000,
740 AUDIO_DEVICE_IN_DEFAULT = AUDIO_DEVICE_BIT_IN | AUDIO_DEVICE_BIT_DEFAULT,
741
742 AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_COMMUNICATION |
743 AUDIO_DEVICE_IN_AMBIENT |
744 AUDIO_DEVICE_IN_BUILTIN_MIC |
745 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET |
746 AUDIO_DEVICE_IN_WIRED_HEADSET |
747 AUDIO_DEVICE_IN_HDMI |
748 AUDIO_DEVICE_IN_TELEPHONY_RX |
749 AUDIO_DEVICE_IN_BACK_MIC |
750 AUDIO_DEVICE_IN_REMOTE_SUBMIX |
751 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET |
752 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET |
753 AUDIO_DEVICE_IN_USB_ACCESSORY |
754 AUDIO_DEVICE_IN_USB_DEVICE |
755 AUDIO_DEVICE_IN_FM_TUNER |
756 AUDIO_DEVICE_IN_TV_TUNER |
757 AUDIO_DEVICE_IN_LINE |
758 AUDIO_DEVICE_IN_SPDIF |
759 AUDIO_DEVICE_IN_BLUETOOTH_A2DP |
760 AUDIO_DEVICE_IN_LOOPBACK |
761 AUDIO_DEVICE_IN_IP |
762 AUDIO_DEVICE_IN_BUS |
763 AUDIO_DEVICE_IN_DEFAULT),
764 AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
765 AUDIO_DEVICE_IN_ALL_USB = (AUDIO_DEVICE_IN_USB_ACCESSORY |
766 AUDIO_DEVICE_IN_USB_DEVICE),
767 };
768
769 typedef uint32_t audio_devices_t;
770
771 /* the audio output flags serve two purposes:
772 * - when an AudioTrack is created they indicate a "wish" to be connected to an
773 * output stream with attributes corresponding to the specified flags
774 * - when present in an output profile descriptor listed for a particular audio
775 * hardware module, they indicate that an output stream can be opened that
776 * supports the attributes indicated by the flags.
777 * the audio policy manager will try to match the flags in the request
778 * (when getOuput() is called) to an available output stream.
779 */
780 typedef enum {
781 AUDIO_OUTPUT_FLAG_NONE = 0x0, // no attributes
782 AUDIO_OUTPUT_FLAG_DIRECT = 0x1, // this output directly connects a track
783 // to one output stream: no software mixer
784 AUDIO_OUTPUT_FLAG_PRIMARY = 0x2, // this output is the primary output of
785 // the device. It is unique and must be
786 // present. It is opened by default and
787 // receives routing, audio mode and volume
788 // controls related to voice calls.
789 AUDIO_OUTPUT_FLAG_FAST = 0x4, // output supports "fast tracks",
790 // defined elsewhere
791 AUDIO_OUTPUT_FLAG_DEEP_BUFFER = 0x8, // use deep audio buffers
792 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD = 0x10, // offload playback of compressed
793 // streams to hardware codec
794 AUDIO_OUTPUT_FLAG_NON_BLOCKING = 0x20, // use non-blocking write
795 AUDIO_OUTPUT_FLAG_HW_AV_SYNC = 0x40, // output uses a hardware A/V synchronization source
796 AUDIO_OUTPUT_FLAG_TTS = 0x80, // output for streams transmitted through speaker
797 // at a sample rate high enough to accommodate
798 // lower-range ultrasonic playback
799 AUDIO_OUTPUT_FLAG_RAW = 0x100, // minimize signal processing
800 AUDIO_OUTPUT_FLAG_SYNC = 0x200, // synchronize I/O streams
801
802 AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO = 0x400, // Audio stream contains compressed audio in
803 // SPDIF data bursts, not PCM.
804 } audio_output_flags_t;
805
806 /* The audio input flags are analogous to audio output flags.
807 * Currently they are used only when an AudioRecord is created,
808 * to indicate a preference to be connected to an input stream with
809 * attributes corresponding to the specified flags.
810 */
811 typedef enum {
812 AUDIO_INPUT_FLAG_NONE = 0x0, // no attributes
813 AUDIO_INPUT_FLAG_FAST = 0x1, // prefer an input that supports "fast tracks"
814 AUDIO_INPUT_FLAG_HW_HOTWORD = 0x2, // prefer an input that captures from hw hotword source
815 AUDIO_INPUT_FLAG_RAW = 0x4, // minimize signal processing
816 AUDIO_INPUT_FLAG_SYNC = 0x8, // synchronize I/O streams
817
818 } audio_input_flags_t;
819
820 /* Additional information about compressed streams offloaded to
821 * hardware playback
822 * The version and size fields must be initialized by the caller by using
823 * one of the constants defined here.
824 */
825 typedef struct {
826 uint16_t version; // version of the info structure
827 uint16_t size; // total size of the structure including version and size
828 uint32_t sample_rate; // sample rate in Hz
829 audio_channel_mask_t channel_mask; // channel mask
830 audio_format_t format; // audio format
831 audio_stream_type_t stream_type; // stream type
832 uint32_t bit_rate; // bit rate in bits per second
833 int64_t duration_us; // duration in microseconds, -1 if unknown
834 bool has_video; // true if stream is tied to a video stream
835 bool is_streaming; // true if streaming, false if local playback
836 } audio_offload_info_t;
837
838 #define AUDIO_MAKE_OFFLOAD_INFO_VERSION(maj,min) \
839 ((((maj) & 0xff) << 8) | ((min) & 0xff))
840
841 #define AUDIO_OFFLOAD_INFO_VERSION_0_1 AUDIO_MAKE_OFFLOAD_INFO_VERSION(0, 1)
842 #define AUDIO_OFFLOAD_INFO_VERSION_CURRENT AUDIO_OFFLOAD_INFO_VERSION_0_1
843
844 static const audio_offload_info_t AUDIO_INFO_INITIALIZER = {
845 version: AUDIO_OFFLOAD_INFO_VERSION_CURRENT,
846 size: sizeof(audio_offload_info_t),
847 sample_rate: 0,
848 channel_mask: 0,
849 format: AUDIO_FORMAT_DEFAULT,
850 stream_type: AUDIO_STREAM_VOICE_CALL,
851 bit_rate: 0,
852 duration_us: 0,
853 has_video: false,
854 is_streaming: false
855 };
856
857 /* common audio stream configuration parameters
858 * You should memset() the entire structure to zero before use to
859 * ensure forward compatibility
860 */
861 struct audio_config {
862 uint32_t sample_rate;
863 audio_channel_mask_t channel_mask;
864 audio_format_t format;
865 audio_offload_info_t offload_info;
866 size_t frame_count;
867 };
868 typedef struct audio_config audio_config_t;
869
870 static const audio_config_t AUDIO_CONFIG_INITIALIZER = {
871 sample_rate: 0,
872 channel_mask: AUDIO_CHANNEL_NONE,
873 format: AUDIO_FORMAT_DEFAULT,
874 offload_info: {
875 version: AUDIO_OFFLOAD_INFO_VERSION_CURRENT,
876 size: sizeof(audio_offload_info_t),
877 sample_rate: 0,
878 channel_mask: 0,
879 format: AUDIO_FORMAT_DEFAULT,
880 stream_type: AUDIO_STREAM_VOICE_CALL,
881 bit_rate: 0,
882 duration_us: 0,
883 has_video: false,
884 is_streaming: false
885 },
886 frame_count: 0,
887 };
888
889 struct audio_config_base {
890 uint32_t sample_rate;
891 audio_channel_mask_t channel_mask;
892 audio_format_t format;
893 };
894
895 typedef struct audio_config_base audio_config_base_t;
896
897 static const audio_config_base_t AUDIO_CONFIG_BASE_INITIALIZER = {
898 sample_rate: 0,
899 channel_mask: AUDIO_CHANNEL_NONE,
900 format: AUDIO_FORMAT_DEFAULT
901 };
902
903 /* audio hw module handle functions or structures referencing a module */
904 typedef enum {
905 AUDIO_MODULE_HANDLE_NONE = 0,
906 } audio_module_handle_t;
907
908 /******************************
909 * Volume control
910 *****************************/
911
912 /* If the audio hardware supports gain control on some audio paths,
913 * the platform can expose them in the audio_policy.conf file. The audio HAL
914 * will then implement gain control functions that will use the following data
915 * structures. */
916
917 /* Type of gain control exposed by an audio port */
918 #define AUDIO_GAIN_MODE_JOINT 0x1 /* supports joint channel gain control */
919 #define AUDIO_GAIN_MODE_CHANNELS 0x2 /* supports separate channel gain control */
920 #define AUDIO_GAIN_MODE_RAMP 0x4 /* supports gain ramps */
921
922 typedef uint32_t audio_gain_mode_t;
923
924
925 /* An audio_gain struct is a representation of a gain stage.
926 * A gain stage is always attached to an audio port. */
927 struct audio_gain {
928 audio_gain_mode_t mode; /* e.g. AUDIO_GAIN_MODE_JOINT */
929 audio_channel_mask_t channel_mask; /* channels which gain an be controlled.
930 N/A if AUDIO_GAIN_MODE_CHANNELS is not supported */
931 int min_value; /* minimum gain value in millibels */
932 int max_value; /* maximum gain value in millibels */
933 int default_value; /* default gain value in millibels */
934 unsigned int step_value; /* gain step in millibels */
935 unsigned int min_ramp_ms; /* minimum ramp duration in ms */
936 unsigned int max_ramp_ms; /* maximum ramp duration in ms */
937 };
938
939 /* The gain configuration structure is used to get or set the gain values of a
940 * given port */
941 struct audio_gain_config {
942 int index; /* index of the corresponding audio_gain in the
943 audio_port gains[] table */
944 audio_gain_mode_t mode; /* mode requested for this command */
945 audio_channel_mask_t channel_mask; /* channels which gain value follows.
946 N/A in joint mode */
947
948 // note this "8" is not FCC_8, so it won't need to be changed for > 8 channels
949 int values[sizeof(audio_channel_mask_t) * 8]; /* gain values in millibels
950 for each channel ordered from LSb to MSb in
951 channel mask. The number of values is 1 in joint
952 mode or popcount(channel_mask) */
953 unsigned int ramp_duration_ms; /* ramp duration in ms */
954 };
955
956 /******************************
957 * Routing control
958 *****************************/
959
960 /* Types defined here are used to describe an audio source or sink at internal
961 * framework interfaces (audio policy, patch panel) or at the audio HAL.
962 * Sink and sources are grouped in a concept of “audio port” representing an
963 * audio end point at the edge of the system managed by the module exposing
964 * the interface. */
965
966 /* Audio port role: either source or sink */
967 typedef enum {
968 AUDIO_PORT_ROLE_NONE,
969 AUDIO_PORT_ROLE_SOURCE,
970 AUDIO_PORT_ROLE_SINK,
971 } audio_port_role_t;
972
973 /* Audio port type indicates if it is a session (e.g AudioTrack),
974 * a mix (e.g PlaybackThread output) or a physical device
975 * (e.g AUDIO_DEVICE_OUT_SPEAKER) */
976 typedef enum {
977 AUDIO_PORT_TYPE_NONE,
978 AUDIO_PORT_TYPE_DEVICE,
979 AUDIO_PORT_TYPE_MIX,
980 AUDIO_PORT_TYPE_SESSION,
981 } audio_port_type_t;
982
983 /* Each port has a unique ID or handle allocated by policy manager */
984 typedef int audio_port_handle_t;
985 #define AUDIO_PORT_HANDLE_NONE 0
986
987 /* the maximum length for the human-readable device name */
988 #define AUDIO_PORT_MAX_NAME_LEN 128
989
990 /* maximum audio device address length */
991 #define AUDIO_DEVICE_MAX_ADDRESS_LEN 32
992
993 /* extension for audio port configuration structure when the audio port is a
994 * hardware device */
995 struct audio_port_config_device_ext {
996 audio_module_handle_t hw_module; /* module the device is attached to */
997 audio_devices_t type; /* device type (e.g AUDIO_DEVICE_OUT_SPEAKER) */
998 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN]; /* device address. "" if N/A */
999 };
1000
1001 /* extension for audio port configuration structure when the audio port is a
1002 * sub mix */
1003 struct audio_port_config_mix_ext {
1004 audio_module_handle_t hw_module; /* module the stream is attached to */
1005 audio_io_handle_t handle; /* I/O handle of the input/output stream */
1006 union {
1007 //TODO: change use case for output streams: use strategy and mixer attributes
1008 audio_stream_type_t stream;
1009 audio_source_t source;
1010 } usecase;
1011 };
1012
1013 /* extension for audio port configuration structure when the audio port is an
1014 * audio session */
1015 struct audio_port_config_session_ext {
1016 audio_session_t session; /* audio session */
1017 };
1018
1019 /* Flags indicating which fields are to be considered in struct audio_port_config */
1020 #define AUDIO_PORT_CONFIG_SAMPLE_RATE 0x1
1021 #define AUDIO_PORT_CONFIG_CHANNEL_MASK 0x2
1022 #define AUDIO_PORT_CONFIG_FORMAT 0x4
1023 #define AUDIO_PORT_CONFIG_GAIN 0x8
1024 #define AUDIO_PORT_CONFIG_ALL (AUDIO_PORT_CONFIG_SAMPLE_RATE | \
1025 AUDIO_PORT_CONFIG_CHANNEL_MASK | \
1026 AUDIO_PORT_CONFIG_FORMAT | \
1027 AUDIO_PORT_CONFIG_GAIN)
1028
1029 /* audio port configuration structure used to specify a particular configuration of
1030 * an audio port */
1031 struct audio_port_config {
1032 audio_port_handle_t id; /* port unique ID */
1033 audio_port_role_t role; /* sink or source */
1034 audio_port_type_t type; /* device, mix ... */
1035 unsigned int config_mask; /* e.g AUDIO_PORT_CONFIG_ALL */
1036 unsigned int sample_rate; /* sampling rate in Hz */
1037 audio_channel_mask_t channel_mask; /* channel mask if applicable */
1038 audio_format_t format; /* format if applicable */
1039 struct audio_gain_config gain; /* gain to apply if applicable */
1040 union {
1041 struct audio_port_config_device_ext device; /* device specific info */
1042 struct audio_port_config_mix_ext mix; /* mix specific info */
1043 struct audio_port_config_session_ext session; /* session specific info */
1044 } ext;
1045 };
1046
1047
1048 /* max number of sampling rates in audio port */
1049 #define AUDIO_PORT_MAX_SAMPLING_RATES 16
1050 /* max number of channel masks in audio port */
1051 #define AUDIO_PORT_MAX_CHANNEL_MASKS 16
1052 /* max number of audio formats in audio port */
1053 #define AUDIO_PORT_MAX_FORMATS 16
1054 /* max number of gain controls in audio port */
1055 #define AUDIO_PORT_MAX_GAINS 16
1056
1057 /* extension for audio port structure when the audio port is a hardware device */
1058 struct audio_port_device_ext {
1059 audio_module_handle_t hw_module; /* module the device is attached to */
1060 audio_devices_t type; /* device type (e.g AUDIO_DEVICE_OUT_SPEAKER) */
1061 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN];
1062 };
1063
1064 /* Latency class of the audio mix */
1065 typedef enum {
1066 AUDIO_LATENCY_LOW,
1067 AUDIO_LATENCY_NORMAL,
1068 } audio_mix_latency_class_t;
1069
1070 /* extension for audio port structure when the audio port is a sub mix */
1071 struct audio_port_mix_ext {
1072 audio_module_handle_t hw_module; /* module the stream is attached to */
1073 audio_io_handle_t handle; /* I/O handle of the input.output stream */
1074 audio_mix_latency_class_t latency_class; /* latency class */
1075 // other attributes: routing strategies
1076 };
1077
1078 /* extension for audio port structure when the audio port is an audio session */
1079 struct audio_port_session_ext {
1080 audio_session_t session; /* audio session */
1081 };
1082
1083 struct audio_port {
1084 audio_port_handle_t id; /* port unique ID */
1085 audio_port_role_t role; /* sink or source */
1086 audio_port_type_t type; /* device, mix ... */
1087 char name[AUDIO_PORT_MAX_NAME_LEN];
1088 unsigned int num_sample_rates; /* number of sampling rates in following array */
1089 unsigned int sample_rates[AUDIO_PORT_MAX_SAMPLING_RATES];
1090 unsigned int num_channel_masks; /* number of channel masks in following array */
1091 audio_channel_mask_t channel_masks[AUDIO_PORT_MAX_CHANNEL_MASKS];
1092 unsigned int num_formats; /* number of formats in following array */
1093 audio_format_t formats[AUDIO_PORT_MAX_FORMATS];
1094 unsigned int num_gains; /* number of gains in following array */
1095 struct audio_gain gains[AUDIO_PORT_MAX_GAINS];
1096 struct audio_port_config active_config; /* current audio port configuration */
1097 union {
1098 struct audio_port_device_ext device;
1099 struct audio_port_mix_ext mix;
1100 struct audio_port_session_ext session;
1101 } ext;
1102 };
1103
1104 /* An audio patch represents a connection between one or more source ports and
1105 * one or more sink ports. Patches are connected and disconnected by audio policy manager or by
1106 * applications via framework APIs.
1107 * Each patch is identified by a handle at the interface used to create that patch. For instance,
1108 * when a patch is created by the audio HAL, the HAL allocates and returns a handle.
1109 * This handle is unique to a given audio HAL hardware module.
1110 * But the same patch receives another system wide unique handle allocated by the framework.
1111 * This unique handle is used for all transactions inside the framework.
1112 */
1113 typedef enum {
1114 AUDIO_PATCH_HANDLE_NONE = 0,
1115 } audio_patch_handle_t;
1116
1117 #define AUDIO_PATCH_PORTS_MAX 16
1118
1119 struct audio_patch {
1120 audio_patch_handle_t id; /* patch unique ID */
1121 unsigned int num_sources; /* number of sources in following array */
1122 struct audio_port_config sources[AUDIO_PATCH_PORTS_MAX];
1123 unsigned int num_sinks; /* number of sinks in following array */
1124 struct audio_port_config sinks[AUDIO_PATCH_PORTS_MAX];
1125 };
1126
1127
1128
1129 /* a HW synchronization source returned by the audio HAL */
1130 typedef uint32_t audio_hw_sync_t;
1131
1132 /* an invalid HW synchronization source indicating an error */
1133 #define AUDIO_HW_SYNC_INVALID 0
1134
audio_is_output_device(audio_devices_t device)1135 static inline bool audio_is_output_device(audio_devices_t device)
1136 {
1137 if (((device & AUDIO_DEVICE_BIT_IN) == 0) &&
1138 (popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL) == 0))
1139 return true;
1140 else
1141 return false;
1142 }
1143
audio_is_input_device(audio_devices_t device)1144 static inline bool audio_is_input_device(audio_devices_t device)
1145 {
1146 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1147 device &= ~AUDIO_DEVICE_BIT_IN;
1148 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_IN_ALL) == 0))
1149 return true;
1150 }
1151 return false;
1152 }
1153
audio_is_output_devices(audio_devices_t device)1154 static inline bool audio_is_output_devices(audio_devices_t device)
1155 {
1156 return (device & AUDIO_DEVICE_BIT_IN) == 0;
1157 }
1158
audio_is_a2dp_in_device(audio_devices_t device)1159 static inline bool audio_is_a2dp_in_device(audio_devices_t device)
1160 {
1161 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1162 device &= ~AUDIO_DEVICE_BIT_IN;
1163 if ((popcount(device) == 1) && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP))
1164 return true;
1165 }
1166 return false;
1167 }
1168
audio_is_a2dp_out_device(audio_devices_t device)1169 static inline bool audio_is_a2dp_out_device(audio_devices_t device)
1170 {
1171 if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_ALL_A2DP))
1172 return true;
1173 else
1174 return false;
1175 }
1176
1177 // Deprecated - use audio_is_a2dp_out_device() instead
audio_is_a2dp_device(audio_devices_t device)1178 static inline bool audio_is_a2dp_device(audio_devices_t device)
1179 {
1180 return audio_is_a2dp_out_device(device);
1181 }
1182
audio_is_bluetooth_sco_device(audio_devices_t device)1183 static inline bool audio_is_bluetooth_sco_device(audio_devices_t device)
1184 {
1185 if ((device & AUDIO_DEVICE_BIT_IN) == 0) {
1186 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL_SCO) == 0))
1187 return true;
1188 } else {
1189 device &= ~AUDIO_DEVICE_BIT_IN;
1190 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) == 0))
1191 return true;
1192 }
1193
1194 return false;
1195 }
1196
audio_is_usb_out_device(audio_devices_t device)1197 static inline bool audio_is_usb_out_device(audio_devices_t device)
1198 {
1199 return ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_ALL_USB));
1200 }
1201
audio_is_usb_in_device(audio_devices_t device)1202 static inline bool audio_is_usb_in_device(audio_devices_t device)
1203 {
1204 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1205 device &= ~AUDIO_DEVICE_BIT_IN;
1206 if (popcount(device) == 1 && (device & AUDIO_DEVICE_IN_ALL_USB) != 0)
1207 return true;
1208 }
1209 return false;
1210 }
1211
1212 /* OBSOLETE - use audio_is_usb_out_device() instead. */
audio_is_usb_device(audio_devices_t device)1213 static inline bool audio_is_usb_device(audio_devices_t device)
1214 {
1215 return audio_is_usb_out_device(device);
1216 }
1217
audio_is_remote_submix_device(audio_devices_t device)1218 static inline bool audio_is_remote_submix_device(audio_devices_t device)
1219 {
1220 if ((audio_is_output_devices(device) &&
1221 (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX) == AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
1222 || (!audio_is_output_devices(device) &&
1223 (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) == AUDIO_DEVICE_IN_REMOTE_SUBMIX))
1224 return true;
1225 else
1226 return false;
1227 }
1228
1229 /* Returns true if:
1230 * representation is valid, and
1231 * there is at least one channel bit set which _could_ correspond to an input channel, and
1232 * there are no channel bits set which could _not_ correspond to an input channel.
1233 * Otherwise returns false.
1234 */
audio_is_input_channel(audio_channel_mask_t channel)1235 static inline bool audio_is_input_channel(audio_channel_mask_t channel)
1236 {
1237 uint32_t bits = audio_channel_mask_get_bits(channel);
1238 switch (audio_channel_mask_get_representation(channel)) {
1239 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1240 if (bits & ~AUDIO_CHANNEL_IN_ALL) {
1241 bits = 0;
1242 }
1243 // fall through
1244 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1245 return bits != 0;
1246 default:
1247 return false;
1248 }
1249 }
1250
1251 /* Returns true if:
1252 * representation is valid, and
1253 * there is at least one channel bit set which _could_ correspond to an output channel, and
1254 * there are no channel bits set which could _not_ correspond to an output channel.
1255 * Otherwise returns false.
1256 */
audio_is_output_channel(audio_channel_mask_t channel)1257 static inline bool audio_is_output_channel(audio_channel_mask_t channel)
1258 {
1259 uint32_t bits = audio_channel_mask_get_bits(channel);
1260 switch (audio_channel_mask_get_representation(channel)) {
1261 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1262 if (bits & ~AUDIO_CHANNEL_OUT_ALL) {
1263 bits = 0;
1264 }
1265 // fall through
1266 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1267 return bits != 0;
1268 default:
1269 return false;
1270 }
1271 }
1272
1273 /* Returns the number of channels from an input channel mask,
1274 * used in the context of audio input or recording.
1275 * If a channel bit is set which could _not_ correspond to an input channel,
1276 * it is excluded from the count.
1277 * Returns zero if the representation is invalid.
1278 */
audio_channel_count_from_in_mask(audio_channel_mask_t channel)1279 static inline uint32_t audio_channel_count_from_in_mask(audio_channel_mask_t channel)
1280 {
1281 uint32_t bits = audio_channel_mask_get_bits(channel);
1282 switch (audio_channel_mask_get_representation(channel)) {
1283 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1284 // TODO: We can now merge with from_out_mask and remove anding
1285 bits &= AUDIO_CHANNEL_IN_ALL;
1286 // fall through
1287 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1288 return popcount(bits);
1289 default:
1290 return 0;
1291 }
1292 }
1293
1294 /* Returns the number of channels from an output channel mask,
1295 * used in the context of audio output or playback.
1296 * If a channel bit is set which could _not_ correspond to an output channel,
1297 * it is excluded from the count.
1298 * Returns zero if the representation is invalid.
1299 */
audio_channel_count_from_out_mask(audio_channel_mask_t channel)1300 static inline uint32_t audio_channel_count_from_out_mask(audio_channel_mask_t channel)
1301 {
1302 uint32_t bits = audio_channel_mask_get_bits(channel);
1303 switch (audio_channel_mask_get_representation(channel)) {
1304 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1305 // TODO: We can now merge with from_in_mask and remove anding
1306 bits &= AUDIO_CHANNEL_OUT_ALL;
1307 // fall through
1308 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1309 return popcount(bits);
1310 default:
1311 return 0;
1312 }
1313 }
1314
1315 /* Derive a channel mask for index assignment from a channel count.
1316 * Returns the matching channel mask,
1317 * or AUDIO_CHANNEL_NONE if the channel count is zero,
1318 * or AUDIO_CHANNEL_INVALID if the channel count exceeds AUDIO_CHANNEL_COUNT_MAX.
1319 */
audio_channel_mask_for_index_assignment_from_count(uint32_t channel_count)1320 static inline audio_channel_mask_t audio_channel_mask_for_index_assignment_from_count(
1321 uint32_t channel_count)
1322 {
1323 if (channel_count == 0) {
1324 return AUDIO_CHANNEL_NONE;
1325 }
1326 if (channel_count > AUDIO_CHANNEL_COUNT_MAX) {
1327 return AUDIO_CHANNEL_INVALID;
1328 }
1329 uint32_t bits = (1 << channel_count) - 1;
1330 return audio_channel_mask_from_representation_and_bits(
1331 AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
1332 }
1333
1334 /* Derive an output channel mask for position assignment from a channel count.
1335 * This is to be used when the content channel mask is unknown. The 1, 2, 4, 5, 6, 7 and 8 channel
1336 * cases are mapped to the standard game/home-theater layouts, but note that 4 is mapped to quad,
1337 * and not stereo + FC + mono surround. A channel count of 3 is arbitrarily mapped to stereo + FC
1338 * for continuity with stereo.
1339 * Returns the matching channel mask,
1340 * or AUDIO_CHANNEL_NONE if the channel count is zero,
1341 * or AUDIO_CHANNEL_INVALID if the channel count exceeds that of the
1342 * configurations for which a default output channel mask is defined.
1343 */
audio_channel_out_mask_from_count(uint32_t channel_count)1344 static inline audio_channel_mask_t audio_channel_out_mask_from_count(uint32_t channel_count)
1345 {
1346 uint32_t bits;
1347 switch (channel_count) {
1348 case 0:
1349 return AUDIO_CHANNEL_NONE;
1350 case 1:
1351 bits = AUDIO_CHANNEL_OUT_MONO;
1352 break;
1353 case 2:
1354 bits = AUDIO_CHANNEL_OUT_STEREO;
1355 break;
1356 case 3:
1357 bits = AUDIO_CHANNEL_OUT_STEREO | AUDIO_CHANNEL_OUT_FRONT_CENTER;
1358 break;
1359 case 4: // 4.0
1360 bits = AUDIO_CHANNEL_OUT_QUAD;
1361 break;
1362 case 5: // 5.0
1363 bits = AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER;
1364 break;
1365 case 6: // 5.1
1366 bits = AUDIO_CHANNEL_OUT_5POINT1;
1367 break;
1368 case 7: // 6.1
1369 bits = AUDIO_CHANNEL_OUT_5POINT1 | AUDIO_CHANNEL_OUT_BACK_CENTER;
1370 break;
1371 case 8:
1372 bits = AUDIO_CHANNEL_OUT_7POINT1;
1373 break;
1374 // FIXME FCC_8
1375 default:
1376 return AUDIO_CHANNEL_INVALID;
1377 }
1378 return audio_channel_mask_from_representation_and_bits(
1379 AUDIO_CHANNEL_REPRESENTATION_POSITION, bits);
1380 }
1381
1382 /* Derive a default input channel mask from a channel count.
1383 * Assumes a position mask for mono and stereo, or an index mask for channel counts > 2.
1384 * Returns the matching channel mask,
1385 * or AUDIO_CHANNEL_NONE if the channel count is zero,
1386 * or AUDIO_CHANNEL_INVALID if the channel count exceeds that of the
1387 * configurations for which a default input channel mask is defined.
1388 */
audio_channel_in_mask_from_count(uint32_t channel_count)1389 static inline audio_channel_mask_t audio_channel_in_mask_from_count(uint32_t channel_count)
1390 {
1391 uint32_t bits;
1392 switch (channel_count) {
1393 case 0:
1394 return AUDIO_CHANNEL_NONE;
1395 case 1:
1396 bits = AUDIO_CHANNEL_IN_MONO;
1397 break;
1398 case 2:
1399 bits = AUDIO_CHANNEL_IN_STEREO;
1400 break;
1401 case 3:
1402 case 4:
1403 case 5:
1404 case 6:
1405 case 7:
1406 case 8:
1407 // FIXME FCC_8
1408 return audio_channel_mask_for_index_assignment_from_count(channel_count);
1409 default:
1410 return AUDIO_CHANNEL_INVALID;
1411 }
1412 return audio_channel_mask_from_representation_and_bits(
1413 AUDIO_CHANNEL_REPRESENTATION_POSITION, bits);
1414 }
1415
audio_is_valid_format(audio_format_t format)1416 static inline bool audio_is_valid_format(audio_format_t format)
1417 {
1418 switch (format & AUDIO_FORMAT_MAIN_MASK) {
1419 case AUDIO_FORMAT_PCM:
1420 switch (format) {
1421 case AUDIO_FORMAT_PCM_16_BIT:
1422 case AUDIO_FORMAT_PCM_8_BIT:
1423 case AUDIO_FORMAT_PCM_32_BIT:
1424 case AUDIO_FORMAT_PCM_8_24_BIT:
1425 case AUDIO_FORMAT_PCM_FLOAT:
1426 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
1427 return true;
1428 default:
1429 return false;
1430 }
1431 /* not reached */
1432 case AUDIO_FORMAT_MP3:
1433 case AUDIO_FORMAT_AMR_NB:
1434 case AUDIO_FORMAT_AMR_WB:
1435 case AUDIO_FORMAT_AAC:
1436 case AUDIO_FORMAT_HE_AAC_V1:
1437 case AUDIO_FORMAT_HE_AAC_V2:
1438 case AUDIO_FORMAT_VORBIS:
1439 case AUDIO_FORMAT_OPUS:
1440 case AUDIO_FORMAT_AC3:
1441 case AUDIO_FORMAT_E_AC3:
1442 case AUDIO_FORMAT_DTS:
1443 case AUDIO_FORMAT_DTS_HD:
1444 case AUDIO_FORMAT_IEC61937:
1445 return true;
1446 default:
1447 return false;
1448 }
1449 }
1450
1451 /**
1452 * Extract the primary format, eg. PCM, AC3, etc.
1453 */
audio_get_main_format(audio_format_t format)1454 static inline audio_format_t audio_get_main_format(audio_format_t format)
1455 {
1456 return (audio_format_t)(format & AUDIO_FORMAT_MAIN_MASK);
1457 }
1458
1459 /**
1460 * Is the data plain PCM samples that can be scaled and mixed?
1461 */
audio_is_linear_pcm(audio_format_t format)1462 static inline bool audio_is_linear_pcm(audio_format_t format)
1463 {
1464 return (audio_get_main_format(format) == AUDIO_FORMAT_PCM);
1465 }
1466
1467 /**
1468 * For this format, is the number of PCM audio frames directly proportional
1469 * to the number of data bytes?
1470 *
1471 * In other words, is the format transported as PCM audio samples,
1472 * but not necessarily scalable or mixable.
1473 * This returns true for real PCM, but also for AUDIO_FORMAT_IEC61937,
1474 * which is transported as 16 bit PCM audio, but where the encoded data
1475 * cannot be mixed or scaled.
1476 */
audio_has_proportional_frames(audio_format_t format)1477 static inline bool audio_has_proportional_frames(audio_format_t format)
1478 {
1479 audio_format_t mainFormat = audio_get_main_format(format);
1480 return (mainFormat == AUDIO_FORMAT_PCM
1481 || mainFormat == AUDIO_FORMAT_IEC61937);
1482 }
1483
audio_bytes_per_sample(audio_format_t format)1484 static inline size_t audio_bytes_per_sample(audio_format_t format)
1485 {
1486 size_t size = 0;
1487
1488 switch (format) {
1489 case AUDIO_FORMAT_PCM_32_BIT:
1490 case AUDIO_FORMAT_PCM_8_24_BIT:
1491 size = sizeof(int32_t);
1492 break;
1493 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
1494 size = sizeof(uint8_t) * 3;
1495 break;
1496 case AUDIO_FORMAT_PCM_16_BIT:
1497 case AUDIO_FORMAT_IEC61937:
1498 size = sizeof(int16_t);
1499 break;
1500 case AUDIO_FORMAT_PCM_8_BIT:
1501 size = sizeof(uint8_t);
1502 break;
1503 case AUDIO_FORMAT_PCM_FLOAT:
1504 size = sizeof(float);
1505 break;
1506 default:
1507 break;
1508 }
1509 return size;
1510 }
1511
1512 /* converts device address to string sent to audio HAL via set_parameters */
audio_device_address_to_parameter(audio_devices_t device,const char * address)1513 static inline char *audio_device_address_to_parameter(audio_devices_t device, const char *address)
1514 {
1515 const size_t kSize = AUDIO_DEVICE_MAX_ADDRESS_LEN + sizeof("a2dp_sink_address=");
1516 char param[kSize];
1517
1518 if (device & AUDIO_DEVICE_OUT_ALL_A2DP)
1519 snprintf(param, kSize, "%s=%s", "a2dp_sink_address", address);
1520 else if (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
1521 snprintf(param, kSize, "%s=%s", "mix", address);
1522 else
1523 snprintf(param, kSize, "%s", address);
1524
1525 return strdup(param);
1526 }
1527
audio_device_is_digital(audio_devices_t device)1528 static inline bool audio_device_is_digital(audio_devices_t device) {
1529 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1530 // input
1531 return (~AUDIO_DEVICE_BIT_IN & device & (AUDIO_DEVICE_IN_ALL_USB |
1532 AUDIO_DEVICE_IN_HDMI |
1533 AUDIO_DEVICE_IN_SPDIF |
1534 AUDIO_DEVICE_IN_IP |
1535 AUDIO_DEVICE_IN_BUS)) != 0;
1536 } else {
1537 // output
1538 return (device & (AUDIO_DEVICE_OUT_ALL_USB |
1539 AUDIO_DEVICE_OUT_HDMI |
1540 AUDIO_DEVICE_OUT_HDMI_ARC |
1541 AUDIO_DEVICE_OUT_SPDIF |
1542 AUDIO_DEVICE_OUT_IP |
1543 AUDIO_DEVICE_OUT_BUS)) != 0;
1544 }
1545 }
1546
1547 __END_DECLS
1548
1549 #endif // ANDROID_AUDIO_CORE_H
1550