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_DOLBY_TRUEHD = 0x0E000000UL,
320 AUDIO_FORMAT_MAIN_MASK = 0xFF000000UL, /* Deprecated. Use audio_get_main_format() */
321 AUDIO_FORMAT_SUB_MASK = 0x00FFFFFFUL,
322
323 /* Aliases */
324 /* note != AudioFormat.ENCODING_PCM_16BIT */
325 AUDIO_FORMAT_PCM_16_BIT = (AUDIO_FORMAT_PCM |
326 AUDIO_FORMAT_PCM_SUB_16_BIT),
327 /* note != AudioFormat.ENCODING_PCM_8BIT */
328 AUDIO_FORMAT_PCM_8_BIT = (AUDIO_FORMAT_PCM |
329 AUDIO_FORMAT_PCM_SUB_8_BIT),
330 AUDIO_FORMAT_PCM_32_BIT = (AUDIO_FORMAT_PCM |
331 AUDIO_FORMAT_PCM_SUB_32_BIT),
332 AUDIO_FORMAT_PCM_8_24_BIT = (AUDIO_FORMAT_PCM |
333 AUDIO_FORMAT_PCM_SUB_8_24_BIT),
334 AUDIO_FORMAT_PCM_FLOAT = (AUDIO_FORMAT_PCM |
335 AUDIO_FORMAT_PCM_SUB_FLOAT),
336 AUDIO_FORMAT_PCM_24_BIT_PACKED = (AUDIO_FORMAT_PCM |
337 AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED),
338 AUDIO_FORMAT_AAC_MAIN = (AUDIO_FORMAT_AAC |
339 AUDIO_FORMAT_AAC_SUB_MAIN),
340 AUDIO_FORMAT_AAC_LC = (AUDIO_FORMAT_AAC |
341 AUDIO_FORMAT_AAC_SUB_LC),
342 AUDIO_FORMAT_AAC_SSR = (AUDIO_FORMAT_AAC |
343 AUDIO_FORMAT_AAC_SUB_SSR),
344 AUDIO_FORMAT_AAC_LTP = (AUDIO_FORMAT_AAC |
345 AUDIO_FORMAT_AAC_SUB_LTP),
346 AUDIO_FORMAT_AAC_HE_V1 = (AUDIO_FORMAT_AAC |
347 AUDIO_FORMAT_AAC_SUB_HE_V1),
348 AUDIO_FORMAT_AAC_SCALABLE = (AUDIO_FORMAT_AAC |
349 AUDIO_FORMAT_AAC_SUB_SCALABLE),
350 AUDIO_FORMAT_AAC_ERLC = (AUDIO_FORMAT_AAC |
351 AUDIO_FORMAT_AAC_SUB_ERLC),
352 AUDIO_FORMAT_AAC_LD = (AUDIO_FORMAT_AAC |
353 AUDIO_FORMAT_AAC_SUB_LD),
354 AUDIO_FORMAT_AAC_HE_V2 = (AUDIO_FORMAT_AAC |
355 AUDIO_FORMAT_AAC_SUB_HE_V2),
356 AUDIO_FORMAT_AAC_ELD = (AUDIO_FORMAT_AAC |
357 AUDIO_FORMAT_AAC_SUB_ELD),
358 } audio_format_t;
359
360 /* For the channel mask for position assignment representation */
361 enum {
362
363 /* These can be a complete audio_channel_mask_t. */
364
365 AUDIO_CHANNEL_NONE = 0x0,
366 AUDIO_CHANNEL_INVALID = 0xC0000000,
367
368 /* These can be the bits portion of an audio_channel_mask_t
369 * with representation AUDIO_CHANNEL_REPRESENTATION_POSITION.
370 * Using these bits as a complete audio_channel_mask_t is deprecated.
371 */
372
373 /* output channels */
374 AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1,
375 AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2,
376 AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4,
377 AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8,
378 AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10,
379 AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20,
380 AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40,
381 AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80,
382 AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100,
383 AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200,
384 AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400,
385 AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800,
386 AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000,
387 AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000,
388 AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000,
389 AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000,
390 AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000,
391 AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000,
392
393 /* TODO: should these be considered complete channel masks, or only bits? */
394
395 AUDIO_CHANNEL_OUT_MONO = AUDIO_CHANNEL_OUT_FRONT_LEFT,
396 AUDIO_CHANNEL_OUT_STEREO = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
397 AUDIO_CHANNEL_OUT_FRONT_RIGHT),
398 AUDIO_CHANNEL_OUT_QUAD = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
399 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
400 AUDIO_CHANNEL_OUT_BACK_LEFT |
401 AUDIO_CHANNEL_OUT_BACK_RIGHT),
402 AUDIO_CHANNEL_OUT_QUAD_BACK = AUDIO_CHANNEL_OUT_QUAD,
403 /* like AUDIO_CHANNEL_OUT_QUAD_BACK with *_SIDE_* instead of *_BACK_* */
404 AUDIO_CHANNEL_OUT_QUAD_SIDE = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
405 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
406 AUDIO_CHANNEL_OUT_SIDE_LEFT |
407 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
408 AUDIO_CHANNEL_OUT_5POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
409 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
410 AUDIO_CHANNEL_OUT_FRONT_CENTER |
411 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
412 AUDIO_CHANNEL_OUT_BACK_LEFT |
413 AUDIO_CHANNEL_OUT_BACK_RIGHT),
414 AUDIO_CHANNEL_OUT_5POINT1_BACK = AUDIO_CHANNEL_OUT_5POINT1,
415 /* like AUDIO_CHANNEL_OUT_5POINT1_BACK with *_SIDE_* instead of *_BACK_* */
416 AUDIO_CHANNEL_OUT_5POINT1_SIDE = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
417 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
418 AUDIO_CHANNEL_OUT_FRONT_CENTER |
419 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
420 AUDIO_CHANNEL_OUT_SIDE_LEFT |
421 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
422 // matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND definition for 7.1
423 AUDIO_CHANNEL_OUT_7POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
424 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
425 AUDIO_CHANNEL_OUT_FRONT_CENTER |
426 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
427 AUDIO_CHANNEL_OUT_BACK_LEFT |
428 AUDIO_CHANNEL_OUT_BACK_RIGHT |
429 AUDIO_CHANNEL_OUT_SIDE_LEFT |
430 AUDIO_CHANNEL_OUT_SIDE_RIGHT),
431 AUDIO_CHANNEL_OUT_ALL = (AUDIO_CHANNEL_OUT_FRONT_LEFT |
432 AUDIO_CHANNEL_OUT_FRONT_RIGHT |
433 AUDIO_CHANNEL_OUT_FRONT_CENTER |
434 AUDIO_CHANNEL_OUT_LOW_FREQUENCY |
435 AUDIO_CHANNEL_OUT_BACK_LEFT |
436 AUDIO_CHANNEL_OUT_BACK_RIGHT |
437 AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER |
438 AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER |
439 AUDIO_CHANNEL_OUT_BACK_CENTER|
440 AUDIO_CHANNEL_OUT_SIDE_LEFT|
441 AUDIO_CHANNEL_OUT_SIDE_RIGHT|
442 AUDIO_CHANNEL_OUT_TOP_CENTER|
443 AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT|
444 AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER|
445 AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT|
446 AUDIO_CHANNEL_OUT_TOP_BACK_LEFT|
447 AUDIO_CHANNEL_OUT_TOP_BACK_CENTER|
448 AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT),
449
450 /* These are bits only, not complete values */
451
452 /* input channels */
453 AUDIO_CHANNEL_IN_LEFT = 0x4,
454 AUDIO_CHANNEL_IN_RIGHT = 0x8,
455 AUDIO_CHANNEL_IN_FRONT = 0x10,
456 AUDIO_CHANNEL_IN_BACK = 0x20,
457 AUDIO_CHANNEL_IN_LEFT_PROCESSED = 0x40,
458 AUDIO_CHANNEL_IN_RIGHT_PROCESSED = 0x80,
459 AUDIO_CHANNEL_IN_FRONT_PROCESSED = 0x100,
460 AUDIO_CHANNEL_IN_BACK_PROCESSED = 0x200,
461 AUDIO_CHANNEL_IN_PRESSURE = 0x400,
462 AUDIO_CHANNEL_IN_X_AXIS = 0x800,
463 AUDIO_CHANNEL_IN_Y_AXIS = 0x1000,
464 AUDIO_CHANNEL_IN_Z_AXIS = 0x2000,
465 AUDIO_CHANNEL_IN_VOICE_UPLINK = 0x4000,
466 AUDIO_CHANNEL_IN_VOICE_DNLINK = 0x8000,
467
468 /* TODO: should these be considered complete channel masks, or only bits, or deprecated? */
469
470 AUDIO_CHANNEL_IN_MONO = AUDIO_CHANNEL_IN_FRONT,
471 AUDIO_CHANNEL_IN_STEREO = (AUDIO_CHANNEL_IN_LEFT | AUDIO_CHANNEL_IN_RIGHT),
472 AUDIO_CHANNEL_IN_FRONT_BACK = (AUDIO_CHANNEL_IN_FRONT | AUDIO_CHANNEL_IN_BACK),
473 AUDIO_CHANNEL_IN_ALL = (AUDIO_CHANNEL_IN_LEFT |
474 AUDIO_CHANNEL_IN_RIGHT |
475 AUDIO_CHANNEL_IN_FRONT |
476 AUDIO_CHANNEL_IN_BACK|
477 AUDIO_CHANNEL_IN_LEFT_PROCESSED |
478 AUDIO_CHANNEL_IN_RIGHT_PROCESSED |
479 AUDIO_CHANNEL_IN_FRONT_PROCESSED |
480 AUDIO_CHANNEL_IN_BACK_PROCESSED|
481 AUDIO_CHANNEL_IN_PRESSURE |
482 AUDIO_CHANNEL_IN_X_AXIS |
483 AUDIO_CHANNEL_IN_Y_AXIS |
484 AUDIO_CHANNEL_IN_Z_AXIS |
485 AUDIO_CHANNEL_IN_VOICE_UPLINK |
486 AUDIO_CHANNEL_IN_VOICE_DNLINK),
487 };
488
489 /* A channel mask per se only defines the presence or absence of a channel, not the order.
490 * But see AUDIO_INTERLEAVE_* below for the platform convention of order.
491 *
492 * audio_channel_mask_t is an opaque type and its internal layout should not
493 * be assumed as it may change in the future.
494 * Instead, always use the functions declared in this header to examine.
495 *
496 * These are the current representations:
497 *
498 * AUDIO_CHANNEL_REPRESENTATION_POSITION
499 * is a channel mask representation for position assignment.
500 * Each low-order bit corresponds to the spatial position of a transducer (output),
501 * or interpretation of channel (input).
502 * The user of a channel mask needs to know the context of whether it is for output or input.
503 * The constants AUDIO_CHANNEL_OUT_* or AUDIO_CHANNEL_IN_* apply to the bits portion.
504 * It is not permitted for no bits to be set.
505 *
506 * AUDIO_CHANNEL_REPRESENTATION_INDEX
507 * is a channel mask representation for index assignment.
508 * Each low-order bit corresponds to a selected channel.
509 * There is no platform interpretation of the various bits.
510 * There is no concept of output or input.
511 * It is not permitted for no bits to be set.
512 *
513 * All other representations are reserved for future use.
514 *
515 * Warning: current representation distinguishes between input and output, but this will not the be
516 * case in future revisions of the platform. Wherever there is an ambiguity between input and output
517 * that is currently resolved by checking the channel mask, the implementer should look for ways to
518 * fix it with additional information outside of the mask.
519 */
520 typedef uint32_t audio_channel_mask_t;
521
522 /* Maximum number of channels for all representations */
523 #define AUDIO_CHANNEL_COUNT_MAX 30
524
525 /* log(2) of maximum number of representations, not part of public API */
526 #define AUDIO_CHANNEL_REPRESENTATION_LOG2 2
527
528 /* Representations */
529 typedef enum {
530 AUDIO_CHANNEL_REPRESENTATION_POSITION = 0, // must be zero for compatibility
531 // 1 is reserved for future use
532 AUDIO_CHANNEL_REPRESENTATION_INDEX = 2,
533 // 3 is reserved for future use
534 } audio_channel_representation_t;
535
536 /* The channel index masks defined here are the canonical masks for 1 to 8 channel
537 * endpoints and apply to both source and sink.
538 */
539 enum {
540 AUDIO_CHANNEL_INDEX_HDR = AUDIO_CHANNEL_REPRESENTATION_INDEX << AUDIO_CHANNEL_COUNT_MAX,
541 AUDIO_CHANNEL_INDEX_MASK_1 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 1) - 1),
542 AUDIO_CHANNEL_INDEX_MASK_2 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 2) - 1),
543 AUDIO_CHANNEL_INDEX_MASK_3 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 3) - 1),
544 AUDIO_CHANNEL_INDEX_MASK_4 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 4) - 1),
545 AUDIO_CHANNEL_INDEX_MASK_5 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 5) - 1),
546 AUDIO_CHANNEL_INDEX_MASK_6 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 6) - 1),
547 AUDIO_CHANNEL_INDEX_MASK_7 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 7) - 1),
548 AUDIO_CHANNEL_INDEX_MASK_8 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 8) - 1),
549 // FIXME FCC_8
550 };
551
552 /* The return value is undefined if the channel mask is invalid. */
audio_channel_mask_get_bits(audio_channel_mask_t channel)553 static inline uint32_t audio_channel_mask_get_bits(audio_channel_mask_t channel)
554 {
555 return channel & ((1 << AUDIO_CHANNEL_COUNT_MAX) - 1);
556 }
557
558 /* The return value is undefined if the channel mask is invalid. */
audio_channel_mask_get_representation(audio_channel_mask_t channel)559 static inline audio_channel_representation_t audio_channel_mask_get_representation(
560 audio_channel_mask_t channel)
561 {
562 // The right shift should be sufficient, but also "and" for safety in case mask is not 32 bits
563 return (audio_channel_representation_t)
564 ((channel >> AUDIO_CHANNEL_COUNT_MAX) & ((1 << AUDIO_CHANNEL_REPRESENTATION_LOG2) - 1));
565 }
566
567 /* Returns true if the channel mask is valid,
568 * or returns false for AUDIO_CHANNEL_NONE, AUDIO_CHANNEL_INVALID, and other invalid values.
569 * This function is unable to determine whether a channel mask for position assignment
570 * is invalid because an output mask has an invalid output bit set,
571 * or because an input mask has an invalid input bit set.
572 * All other APIs that take a channel mask assume that it is valid.
573 */
audio_channel_mask_is_valid(audio_channel_mask_t channel)574 static inline bool audio_channel_mask_is_valid(audio_channel_mask_t channel)
575 {
576 uint32_t bits = audio_channel_mask_get_bits(channel);
577 audio_channel_representation_t representation = audio_channel_mask_get_representation(channel);
578 switch (representation) {
579 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
580 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
581 break;
582 default:
583 bits = 0;
584 break;
585 }
586 return bits != 0;
587 }
588
589 /* Not part of public API */
audio_channel_mask_from_representation_and_bits(audio_channel_representation_t representation,uint32_t bits)590 static inline audio_channel_mask_t audio_channel_mask_from_representation_and_bits(
591 audio_channel_representation_t representation, uint32_t bits)
592 {
593 return (audio_channel_mask_t) ((representation << AUDIO_CHANNEL_COUNT_MAX) | bits);
594 }
595
596 /* Expresses the convention when stereo audio samples are stored interleaved
597 * in an array. This should improve readability by allowing code to use
598 * symbolic indices instead of hard-coded [0] and [1].
599 *
600 * For multi-channel beyond stereo, the platform convention is that channels
601 * are interleaved in order from least significant channel mask bit
602 * to most significant channel mask bit, with unused bits skipped.
603 * Any exceptions to this convention will be noted at the appropriate API.
604 */
605 enum {
606 AUDIO_INTERLEAVE_LEFT = 0,
607 AUDIO_INTERLEAVE_RIGHT = 1,
608 };
609
610 typedef enum {
611 AUDIO_MODE_INVALID = -2,
612 AUDIO_MODE_CURRENT = -1,
613 AUDIO_MODE_NORMAL = 0,
614 AUDIO_MODE_RINGTONE = 1,
615 AUDIO_MODE_IN_CALL = 2,
616 AUDIO_MODE_IN_COMMUNICATION = 3,
617
618 AUDIO_MODE_CNT,
619 AUDIO_MODE_MAX = AUDIO_MODE_CNT - 1,
620 } audio_mode_t;
621
622 /* This enum is deprecated */
623 typedef enum {
624 AUDIO_IN_ACOUSTICS_NONE = 0,
625 AUDIO_IN_ACOUSTICS_AGC_ENABLE = 0x0001,
626 AUDIO_IN_ACOUSTICS_AGC_DISABLE = 0,
627 AUDIO_IN_ACOUSTICS_NS_ENABLE = 0x0002,
628 AUDIO_IN_ACOUSTICS_NS_DISABLE = 0,
629 AUDIO_IN_ACOUSTICS_TX_IIR_ENABLE = 0x0004,
630 AUDIO_IN_ACOUSTICS_TX_DISABLE = 0,
631 } audio_in_acoustics_t;
632
633 enum {
634 AUDIO_DEVICE_NONE = 0x0,
635 /* reserved bits */
636 AUDIO_DEVICE_BIT_IN = 0x80000000,
637 AUDIO_DEVICE_BIT_DEFAULT = 0x40000000,
638 /* output devices */
639 AUDIO_DEVICE_OUT_EARPIECE = 0x1,
640 AUDIO_DEVICE_OUT_SPEAKER = 0x2,
641 AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4,
642 AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8,
643 AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10,
644 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,
645 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40,
646 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80,
647 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
648 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
649 AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400,
650 AUDIO_DEVICE_OUT_HDMI = AUDIO_DEVICE_OUT_AUX_DIGITAL,
651 /* uses an analog connection (multiplexed over the USB connector pins for instance) */
652 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800,
653 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000,
654 /* USB accessory mode: your Android device is a USB device and the dock is a USB host */
655 AUDIO_DEVICE_OUT_USB_ACCESSORY = 0x2000,
656 /* USB host mode: your Android device is a USB host and the dock is a USB device */
657 AUDIO_DEVICE_OUT_USB_DEVICE = 0x4000,
658 AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 0x8000,
659 /* Telephony voice TX path */
660 AUDIO_DEVICE_OUT_TELEPHONY_TX = 0x10000,
661 /* Analog jack with line impedance detected */
662 AUDIO_DEVICE_OUT_LINE = 0x20000,
663 /* HDMI Audio Return Channel */
664 AUDIO_DEVICE_OUT_HDMI_ARC = 0x40000,
665 /* S/PDIF out */
666 AUDIO_DEVICE_OUT_SPDIF = 0x80000,
667 /* FM transmitter out */
668 AUDIO_DEVICE_OUT_FM = 0x100000,
669 /* Line out for av devices */
670 AUDIO_DEVICE_OUT_AUX_LINE = 0x200000,
671 /* limited-output speaker device for acoustic safety */
672 AUDIO_DEVICE_OUT_SPEAKER_SAFE = 0x400000,
673 AUDIO_DEVICE_OUT_IP = 0x800000,
674 /* audio bus implemented by the audio system (e.g an MOST stereo channel) */
675 AUDIO_DEVICE_OUT_BUS = 0x1000000,
676 AUDIO_DEVICE_OUT_DEFAULT = AUDIO_DEVICE_BIT_DEFAULT,
677 AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_EARPIECE |
678 AUDIO_DEVICE_OUT_SPEAKER |
679 AUDIO_DEVICE_OUT_WIRED_HEADSET |
680 AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
681 AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
682 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
683 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT |
684 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
685 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
686 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER |
687 AUDIO_DEVICE_OUT_HDMI |
688 AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET |
689 AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET |
690 AUDIO_DEVICE_OUT_USB_ACCESSORY |
691 AUDIO_DEVICE_OUT_USB_DEVICE |
692 AUDIO_DEVICE_OUT_REMOTE_SUBMIX |
693 AUDIO_DEVICE_OUT_TELEPHONY_TX |
694 AUDIO_DEVICE_OUT_LINE |
695 AUDIO_DEVICE_OUT_HDMI_ARC |
696 AUDIO_DEVICE_OUT_SPDIF |
697 AUDIO_DEVICE_OUT_FM |
698 AUDIO_DEVICE_OUT_AUX_LINE |
699 AUDIO_DEVICE_OUT_SPEAKER_SAFE |
700 AUDIO_DEVICE_OUT_IP |
701 AUDIO_DEVICE_OUT_BUS |
702 AUDIO_DEVICE_OUT_DEFAULT),
703 AUDIO_DEVICE_OUT_ALL_A2DP = (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
704 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
705 AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
706 AUDIO_DEVICE_OUT_ALL_SCO = (AUDIO_DEVICE_OUT_BLUETOOTH_SCO |
707 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
708 AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT),
709 AUDIO_DEVICE_OUT_ALL_USB = (AUDIO_DEVICE_OUT_USB_ACCESSORY |
710 AUDIO_DEVICE_OUT_USB_DEVICE),
711 /* input devices */
712 AUDIO_DEVICE_IN_COMMUNICATION = AUDIO_DEVICE_BIT_IN | 0x1,
713 AUDIO_DEVICE_IN_AMBIENT = AUDIO_DEVICE_BIT_IN | 0x2,
714 AUDIO_DEVICE_IN_BUILTIN_MIC = AUDIO_DEVICE_BIT_IN | 0x4,
715 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = AUDIO_DEVICE_BIT_IN | 0x8,
716 AUDIO_DEVICE_IN_WIRED_HEADSET = AUDIO_DEVICE_BIT_IN | 0x10,
717 AUDIO_DEVICE_IN_AUX_DIGITAL = AUDIO_DEVICE_BIT_IN | 0x20,
718 AUDIO_DEVICE_IN_HDMI = AUDIO_DEVICE_IN_AUX_DIGITAL,
719 /* Telephony voice RX path */
720 AUDIO_DEVICE_IN_VOICE_CALL = AUDIO_DEVICE_BIT_IN | 0x40,
721 AUDIO_DEVICE_IN_TELEPHONY_RX = AUDIO_DEVICE_IN_VOICE_CALL,
722 AUDIO_DEVICE_IN_BACK_MIC = AUDIO_DEVICE_BIT_IN | 0x80,
723 AUDIO_DEVICE_IN_REMOTE_SUBMIX = AUDIO_DEVICE_BIT_IN | 0x100,
724 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x200,
725 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x400,
726 AUDIO_DEVICE_IN_USB_ACCESSORY = AUDIO_DEVICE_BIT_IN | 0x800,
727 AUDIO_DEVICE_IN_USB_DEVICE = AUDIO_DEVICE_BIT_IN | 0x1000,
728 /* FM tuner input */
729 AUDIO_DEVICE_IN_FM_TUNER = AUDIO_DEVICE_BIT_IN | 0x2000,
730 /* TV tuner input */
731 AUDIO_DEVICE_IN_TV_TUNER = AUDIO_DEVICE_BIT_IN | 0x4000,
732 /* Analog jack with line impedance detected */
733 AUDIO_DEVICE_IN_LINE = AUDIO_DEVICE_BIT_IN | 0x8000,
734 /* S/PDIF in */
735 AUDIO_DEVICE_IN_SPDIF = AUDIO_DEVICE_BIT_IN | 0x10000,
736 AUDIO_DEVICE_IN_BLUETOOTH_A2DP = AUDIO_DEVICE_BIT_IN | 0x20000,
737 AUDIO_DEVICE_IN_LOOPBACK = AUDIO_DEVICE_BIT_IN | 0x40000,
738 AUDIO_DEVICE_IN_IP = AUDIO_DEVICE_BIT_IN | 0x80000,
739 /* audio bus implemented by the audio system (e.g an MOST stereo channel) */
740 AUDIO_DEVICE_IN_BUS = AUDIO_DEVICE_BIT_IN | 0x100000,
741 AUDIO_DEVICE_IN_DEFAULT = AUDIO_DEVICE_BIT_IN | AUDIO_DEVICE_BIT_DEFAULT,
742
743 AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_COMMUNICATION |
744 AUDIO_DEVICE_IN_AMBIENT |
745 AUDIO_DEVICE_IN_BUILTIN_MIC |
746 AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET |
747 AUDIO_DEVICE_IN_WIRED_HEADSET |
748 AUDIO_DEVICE_IN_HDMI |
749 AUDIO_DEVICE_IN_TELEPHONY_RX |
750 AUDIO_DEVICE_IN_BACK_MIC |
751 AUDIO_DEVICE_IN_REMOTE_SUBMIX |
752 AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET |
753 AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET |
754 AUDIO_DEVICE_IN_USB_ACCESSORY |
755 AUDIO_DEVICE_IN_USB_DEVICE |
756 AUDIO_DEVICE_IN_FM_TUNER |
757 AUDIO_DEVICE_IN_TV_TUNER |
758 AUDIO_DEVICE_IN_LINE |
759 AUDIO_DEVICE_IN_SPDIF |
760 AUDIO_DEVICE_IN_BLUETOOTH_A2DP |
761 AUDIO_DEVICE_IN_LOOPBACK |
762 AUDIO_DEVICE_IN_IP |
763 AUDIO_DEVICE_IN_BUS |
764 AUDIO_DEVICE_IN_DEFAULT),
765 AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
766 AUDIO_DEVICE_IN_ALL_USB = (AUDIO_DEVICE_IN_USB_ACCESSORY |
767 AUDIO_DEVICE_IN_USB_DEVICE),
768 };
769
770 typedef uint32_t audio_devices_t;
771
772 /* the audio output flags serve two purposes:
773 * - when an AudioTrack is created they indicate a "wish" to be connected to an
774 * output stream with attributes corresponding to the specified flags
775 * - when present in an output profile descriptor listed for a particular audio
776 * hardware module, they indicate that an output stream can be opened that
777 * supports the attributes indicated by the flags.
778 * the audio policy manager will try to match the flags in the request
779 * (when getOuput() is called) to an available output stream.
780 */
781 typedef enum {
782 AUDIO_OUTPUT_FLAG_NONE = 0x0, // no attributes
783 AUDIO_OUTPUT_FLAG_DIRECT = 0x1, // this output directly connects a track
784 // to one output stream: no software mixer
785 AUDIO_OUTPUT_FLAG_PRIMARY = 0x2, // this output is the primary output of
786 // the device. It is unique and must be
787 // present. It is opened by default and
788 // receives routing, audio mode and volume
789 // controls related to voice calls.
790 AUDIO_OUTPUT_FLAG_FAST = 0x4, // output supports "fast tracks",
791 // defined elsewhere
792 AUDIO_OUTPUT_FLAG_DEEP_BUFFER = 0x8, // use deep audio buffers
793 AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD = 0x10, // offload playback of compressed
794 // streams to hardware codec
795 AUDIO_OUTPUT_FLAG_NON_BLOCKING = 0x20, // use non-blocking write
796 AUDIO_OUTPUT_FLAG_HW_AV_SYNC = 0x40, // output uses a hardware A/V synchronization source
797 AUDIO_OUTPUT_FLAG_TTS = 0x80, // output for streams transmitted through speaker
798 // at a sample rate high enough to accommodate
799 // lower-range ultrasonic playback
800 AUDIO_OUTPUT_FLAG_RAW = 0x100, // minimize signal processing
801 AUDIO_OUTPUT_FLAG_SYNC = 0x200, // synchronize I/O streams
802
803 AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO = 0x400, // Audio stream contains compressed audio in
804 // SPDIF data bursts, not PCM.
805 } audio_output_flags_t;
806
807 /* The audio input flags are analogous to audio output flags.
808 * Currently they are used only when an AudioRecord is created,
809 * to indicate a preference to be connected to an input stream with
810 * attributes corresponding to the specified flags.
811 */
812 typedef enum {
813 AUDIO_INPUT_FLAG_NONE = 0x0, // no attributes
814 AUDIO_INPUT_FLAG_FAST = 0x1, // prefer an input that supports "fast tracks"
815 AUDIO_INPUT_FLAG_HW_HOTWORD = 0x2, // prefer an input that captures from hw hotword source
816 AUDIO_INPUT_FLAG_RAW = 0x4, // minimize signal processing
817 AUDIO_INPUT_FLAG_SYNC = 0x8, // synchronize I/O streams
818
819 } audio_input_flags_t;
820
821 /* Additional information about compressed streams offloaded to
822 * hardware playback
823 * The version and size fields must be initialized by the caller by using
824 * one of the constants defined here.
825 */
826 typedef struct {
827 uint16_t version; // version of the info structure
828 uint16_t size; // total size of the structure including version and size
829 uint32_t sample_rate; // sample rate in Hz
830 audio_channel_mask_t channel_mask; // channel mask
831 audio_format_t format; // audio format
832 audio_stream_type_t stream_type; // stream type
833 uint32_t bit_rate; // bit rate in bits per second
834 int64_t duration_us; // duration in microseconds, -1 if unknown
835 bool has_video; // true if stream is tied to a video stream
836 bool is_streaming; // true if streaming, false if local playback
837 } audio_offload_info_t;
838
839 #define AUDIO_MAKE_OFFLOAD_INFO_VERSION(maj,min) \
840 ((((maj) & 0xff) << 8) | ((min) & 0xff))
841
842 #define AUDIO_OFFLOAD_INFO_VERSION_0_1 AUDIO_MAKE_OFFLOAD_INFO_VERSION(0, 1)
843 #define AUDIO_OFFLOAD_INFO_VERSION_CURRENT AUDIO_OFFLOAD_INFO_VERSION_0_1
844
845 static const audio_offload_info_t AUDIO_INFO_INITIALIZER = {
846 version: AUDIO_OFFLOAD_INFO_VERSION_CURRENT,
847 size: sizeof(audio_offload_info_t),
848 sample_rate: 0,
849 channel_mask: 0,
850 format: AUDIO_FORMAT_DEFAULT,
851 stream_type: AUDIO_STREAM_VOICE_CALL,
852 bit_rate: 0,
853 duration_us: 0,
854 has_video: false,
855 is_streaming: false
856 };
857
858 /* common audio stream configuration parameters
859 * You should memset() the entire structure to zero before use to
860 * ensure forward compatibility
861 */
862 struct audio_config {
863 uint32_t sample_rate;
864 audio_channel_mask_t channel_mask;
865 audio_format_t format;
866 audio_offload_info_t offload_info;
867 size_t frame_count;
868 };
869 typedef struct audio_config audio_config_t;
870
871 static const audio_config_t AUDIO_CONFIG_INITIALIZER = {
872 sample_rate: 0,
873 channel_mask: AUDIO_CHANNEL_NONE,
874 format: AUDIO_FORMAT_DEFAULT,
875 offload_info: {
876 version: AUDIO_OFFLOAD_INFO_VERSION_CURRENT,
877 size: sizeof(audio_offload_info_t),
878 sample_rate: 0,
879 channel_mask: 0,
880 format: AUDIO_FORMAT_DEFAULT,
881 stream_type: AUDIO_STREAM_VOICE_CALL,
882 bit_rate: 0,
883 duration_us: 0,
884 has_video: false,
885 is_streaming: false
886 },
887 frame_count: 0,
888 };
889
890 struct audio_config_base {
891 uint32_t sample_rate;
892 audio_channel_mask_t channel_mask;
893 audio_format_t format;
894 };
895
896 typedef struct audio_config_base audio_config_base_t;
897
898 static const audio_config_base_t AUDIO_CONFIG_BASE_INITIALIZER = {
899 sample_rate: 0,
900 channel_mask: AUDIO_CHANNEL_NONE,
901 format: AUDIO_FORMAT_DEFAULT
902 };
903
904 /* audio hw module handle functions or structures referencing a module */
905 typedef enum {
906 AUDIO_MODULE_HANDLE_NONE = 0,
907 } audio_module_handle_t;
908
909 /******************************
910 * Volume control
911 *****************************/
912
913 /* If the audio hardware supports gain control on some audio paths,
914 * the platform can expose them in the audio_policy.conf file. The audio HAL
915 * will then implement gain control functions that will use the following data
916 * structures. */
917
918 /* Type of gain control exposed by an audio port */
919 #define AUDIO_GAIN_MODE_JOINT 0x1 /* supports joint channel gain control */
920 #define AUDIO_GAIN_MODE_CHANNELS 0x2 /* supports separate channel gain control */
921 #define AUDIO_GAIN_MODE_RAMP 0x4 /* supports gain ramps */
922
923 typedef uint32_t audio_gain_mode_t;
924
925
926 /* An audio_gain struct is a representation of a gain stage.
927 * A gain stage is always attached to an audio port. */
928 struct audio_gain {
929 audio_gain_mode_t mode; /* e.g. AUDIO_GAIN_MODE_JOINT */
930 audio_channel_mask_t channel_mask; /* channels which gain an be controlled.
931 N/A if AUDIO_GAIN_MODE_CHANNELS is not supported */
932 int min_value; /* minimum gain value in millibels */
933 int max_value; /* maximum gain value in millibels */
934 int default_value; /* default gain value in millibels */
935 unsigned int step_value; /* gain step in millibels */
936 unsigned int min_ramp_ms; /* minimum ramp duration in ms */
937 unsigned int max_ramp_ms; /* maximum ramp duration in ms */
938 };
939
940 /* The gain configuration structure is used to get or set the gain values of a
941 * given port */
942 struct audio_gain_config {
943 int index; /* index of the corresponding audio_gain in the
944 audio_port gains[] table */
945 audio_gain_mode_t mode; /* mode requested for this command */
946 audio_channel_mask_t channel_mask; /* channels which gain value follows.
947 N/A in joint mode */
948
949 // note this "8" is not FCC_8, so it won't need to be changed for > 8 channels
950 int values[sizeof(audio_channel_mask_t) * 8]; /* gain values in millibels
951 for each channel ordered from LSb to MSb in
952 channel mask. The number of values is 1 in joint
953 mode or popcount(channel_mask) */
954 unsigned int ramp_duration_ms; /* ramp duration in ms */
955 };
956
957 /******************************
958 * Routing control
959 *****************************/
960
961 /* Types defined here are used to describe an audio source or sink at internal
962 * framework interfaces (audio policy, patch panel) or at the audio HAL.
963 * Sink and sources are grouped in a concept of “audio port” representing an
964 * audio end point at the edge of the system managed by the module exposing
965 * the interface. */
966
967 /* Audio port role: either source or sink */
968 typedef enum {
969 AUDIO_PORT_ROLE_NONE,
970 AUDIO_PORT_ROLE_SOURCE,
971 AUDIO_PORT_ROLE_SINK,
972 } audio_port_role_t;
973
974 /* Audio port type indicates if it is a session (e.g AudioTrack),
975 * a mix (e.g PlaybackThread output) or a physical device
976 * (e.g AUDIO_DEVICE_OUT_SPEAKER) */
977 typedef enum {
978 AUDIO_PORT_TYPE_NONE,
979 AUDIO_PORT_TYPE_DEVICE,
980 AUDIO_PORT_TYPE_MIX,
981 AUDIO_PORT_TYPE_SESSION,
982 } audio_port_type_t;
983
984 /* Each port has a unique ID or handle allocated by policy manager */
985 typedef int audio_port_handle_t;
986 #define AUDIO_PORT_HANDLE_NONE 0
987
988 /* the maximum length for the human-readable device name */
989 #define AUDIO_PORT_MAX_NAME_LEN 128
990
991 /* maximum audio device address length */
992 #define AUDIO_DEVICE_MAX_ADDRESS_LEN 32
993
994 /* extension for audio port configuration structure when the audio port is a
995 * hardware device */
996 struct audio_port_config_device_ext {
997 audio_module_handle_t hw_module; /* module the device is attached to */
998 audio_devices_t type; /* device type (e.g AUDIO_DEVICE_OUT_SPEAKER) */
999 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN]; /* device address. "" if N/A */
1000 };
1001
1002 /* extension for audio port configuration structure when the audio port is a
1003 * sub mix */
1004 struct audio_port_config_mix_ext {
1005 audio_module_handle_t hw_module; /* module the stream is attached to */
1006 audio_io_handle_t handle; /* I/O handle of the input/output stream */
1007 union {
1008 //TODO: change use case for output streams: use strategy and mixer attributes
1009 audio_stream_type_t stream;
1010 audio_source_t source;
1011 } usecase;
1012 };
1013
1014 /* extension for audio port configuration structure when the audio port is an
1015 * audio session */
1016 struct audio_port_config_session_ext {
1017 audio_session_t session; /* audio session */
1018 };
1019
1020 /* Flags indicating which fields are to be considered in struct audio_port_config */
1021 #define AUDIO_PORT_CONFIG_SAMPLE_RATE 0x1
1022 #define AUDIO_PORT_CONFIG_CHANNEL_MASK 0x2
1023 #define AUDIO_PORT_CONFIG_FORMAT 0x4
1024 #define AUDIO_PORT_CONFIG_GAIN 0x8
1025 #define AUDIO_PORT_CONFIG_ALL (AUDIO_PORT_CONFIG_SAMPLE_RATE | \
1026 AUDIO_PORT_CONFIG_CHANNEL_MASK | \
1027 AUDIO_PORT_CONFIG_FORMAT | \
1028 AUDIO_PORT_CONFIG_GAIN)
1029
1030 /* audio port configuration structure used to specify a particular configuration of
1031 * an audio port */
1032 struct audio_port_config {
1033 audio_port_handle_t id; /* port unique ID */
1034 audio_port_role_t role; /* sink or source */
1035 audio_port_type_t type; /* device, mix ... */
1036 unsigned int config_mask; /* e.g AUDIO_PORT_CONFIG_ALL */
1037 unsigned int sample_rate; /* sampling rate in Hz */
1038 audio_channel_mask_t channel_mask; /* channel mask if applicable */
1039 audio_format_t format; /* format if applicable */
1040 struct audio_gain_config gain; /* gain to apply if applicable */
1041 union {
1042 struct audio_port_config_device_ext device; /* device specific info */
1043 struct audio_port_config_mix_ext mix; /* mix specific info */
1044 struct audio_port_config_session_ext session; /* session specific info */
1045 } ext;
1046 };
1047
1048
1049 /* max number of sampling rates in audio port */
1050 #define AUDIO_PORT_MAX_SAMPLING_RATES 16
1051 /* max number of channel masks in audio port */
1052 #define AUDIO_PORT_MAX_CHANNEL_MASKS 16
1053 /* max number of audio formats in audio port */
1054 #define AUDIO_PORT_MAX_FORMATS 16
1055 /* max number of gain controls in audio port */
1056 #define AUDIO_PORT_MAX_GAINS 16
1057
1058 /* extension for audio port structure when the audio port is a hardware device */
1059 struct audio_port_device_ext {
1060 audio_module_handle_t hw_module; /* module the device is attached to */
1061 audio_devices_t type; /* device type (e.g AUDIO_DEVICE_OUT_SPEAKER) */
1062 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN];
1063 };
1064
1065 /* Latency class of the audio mix */
1066 typedef enum {
1067 AUDIO_LATENCY_LOW,
1068 AUDIO_LATENCY_NORMAL,
1069 } audio_mix_latency_class_t;
1070
1071 /* extension for audio port structure when the audio port is a sub mix */
1072 struct audio_port_mix_ext {
1073 audio_module_handle_t hw_module; /* module the stream is attached to */
1074 audio_io_handle_t handle; /* I/O handle of the input.output stream */
1075 audio_mix_latency_class_t latency_class; /* latency class */
1076 // other attributes: routing strategies
1077 };
1078
1079 /* extension for audio port structure when the audio port is an audio session */
1080 struct audio_port_session_ext {
1081 audio_session_t session; /* audio session */
1082 };
1083
1084 struct audio_port {
1085 audio_port_handle_t id; /* port unique ID */
1086 audio_port_role_t role; /* sink or source */
1087 audio_port_type_t type; /* device, mix ... */
1088 char name[AUDIO_PORT_MAX_NAME_LEN];
1089 unsigned int num_sample_rates; /* number of sampling rates in following array */
1090 unsigned int sample_rates[AUDIO_PORT_MAX_SAMPLING_RATES];
1091 unsigned int num_channel_masks; /* number of channel masks in following array */
1092 audio_channel_mask_t channel_masks[AUDIO_PORT_MAX_CHANNEL_MASKS];
1093 unsigned int num_formats; /* number of formats in following array */
1094 audio_format_t formats[AUDIO_PORT_MAX_FORMATS];
1095 unsigned int num_gains; /* number of gains in following array */
1096 struct audio_gain gains[AUDIO_PORT_MAX_GAINS];
1097 struct audio_port_config active_config; /* current audio port configuration */
1098 union {
1099 struct audio_port_device_ext device;
1100 struct audio_port_mix_ext mix;
1101 struct audio_port_session_ext session;
1102 } ext;
1103 };
1104
1105 /* An audio patch represents a connection between one or more source ports and
1106 * one or more sink ports. Patches are connected and disconnected by audio policy manager or by
1107 * applications via framework APIs.
1108 * Each patch is identified by a handle at the interface used to create that patch. For instance,
1109 * when a patch is created by the audio HAL, the HAL allocates and returns a handle.
1110 * This handle is unique to a given audio HAL hardware module.
1111 * But the same patch receives another system wide unique handle allocated by the framework.
1112 * This unique handle is used for all transactions inside the framework.
1113 */
1114 typedef enum {
1115 AUDIO_PATCH_HANDLE_NONE = 0,
1116 } audio_patch_handle_t;
1117
1118 #define AUDIO_PATCH_PORTS_MAX 16
1119
1120 struct audio_patch {
1121 audio_patch_handle_t id; /* patch unique ID */
1122 unsigned int num_sources; /* number of sources in following array */
1123 struct audio_port_config sources[AUDIO_PATCH_PORTS_MAX];
1124 unsigned int num_sinks; /* number of sinks in following array */
1125 struct audio_port_config sinks[AUDIO_PATCH_PORTS_MAX];
1126 };
1127
1128
1129
1130 /* a HW synchronization source returned by the audio HAL */
1131 typedef uint32_t audio_hw_sync_t;
1132
1133 /* an invalid HW synchronization source indicating an error */
1134 #define AUDIO_HW_SYNC_INVALID 0
1135
audio_is_output_device(audio_devices_t device)1136 static inline bool audio_is_output_device(audio_devices_t device)
1137 {
1138 if (((device & AUDIO_DEVICE_BIT_IN) == 0) &&
1139 (popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL) == 0))
1140 return true;
1141 else
1142 return false;
1143 }
1144
audio_is_input_device(audio_devices_t device)1145 static inline bool audio_is_input_device(audio_devices_t device)
1146 {
1147 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1148 device &= ~AUDIO_DEVICE_BIT_IN;
1149 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_IN_ALL) == 0))
1150 return true;
1151 }
1152 return false;
1153 }
1154
audio_is_output_devices(audio_devices_t device)1155 static inline bool audio_is_output_devices(audio_devices_t device)
1156 {
1157 return (device & AUDIO_DEVICE_BIT_IN) == 0;
1158 }
1159
audio_is_a2dp_in_device(audio_devices_t device)1160 static inline bool audio_is_a2dp_in_device(audio_devices_t device)
1161 {
1162 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1163 device &= ~AUDIO_DEVICE_BIT_IN;
1164 if ((popcount(device) == 1) && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP))
1165 return true;
1166 }
1167 return false;
1168 }
1169
audio_is_a2dp_out_device(audio_devices_t device)1170 static inline bool audio_is_a2dp_out_device(audio_devices_t device)
1171 {
1172 if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_ALL_A2DP))
1173 return true;
1174 else
1175 return false;
1176 }
1177
1178 // Deprecated - use audio_is_a2dp_out_device() instead
audio_is_a2dp_device(audio_devices_t device)1179 static inline bool audio_is_a2dp_device(audio_devices_t device)
1180 {
1181 return audio_is_a2dp_out_device(device);
1182 }
1183
audio_is_bluetooth_sco_device(audio_devices_t device)1184 static inline bool audio_is_bluetooth_sco_device(audio_devices_t device)
1185 {
1186 if ((device & AUDIO_DEVICE_BIT_IN) == 0) {
1187 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL_SCO) == 0))
1188 return true;
1189 } else {
1190 device &= ~AUDIO_DEVICE_BIT_IN;
1191 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) == 0))
1192 return true;
1193 }
1194
1195 return false;
1196 }
1197
audio_is_usb_out_device(audio_devices_t device)1198 static inline bool audio_is_usb_out_device(audio_devices_t device)
1199 {
1200 return ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_ALL_USB));
1201 }
1202
audio_is_usb_in_device(audio_devices_t device)1203 static inline bool audio_is_usb_in_device(audio_devices_t device)
1204 {
1205 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1206 device &= ~AUDIO_DEVICE_BIT_IN;
1207 if (popcount(device) == 1 && (device & AUDIO_DEVICE_IN_ALL_USB) != 0)
1208 return true;
1209 }
1210 return false;
1211 }
1212
1213 /* OBSOLETE - use audio_is_usb_out_device() instead. */
audio_is_usb_device(audio_devices_t device)1214 static inline bool audio_is_usb_device(audio_devices_t device)
1215 {
1216 return audio_is_usb_out_device(device);
1217 }
1218
audio_is_remote_submix_device(audio_devices_t device)1219 static inline bool audio_is_remote_submix_device(audio_devices_t device)
1220 {
1221 if ((audio_is_output_devices(device) &&
1222 (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX) == AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
1223 || (!audio_is_output_devices(device) &&
1224 (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) == AUDIO_DEVICE_IN_REMOTE_SUBMIX))
1225 return true;
1226 else
1227 return false;
1228 }
1229
1230 /* Returns true if:
1231 * representation is valid, and
1232 * there is at least one channel bit set which _could_ correspond to an input channel, and
1233 * there are no channel bits set which could _not_ correspond to an input channel.
1234 * Otherwise returns false.
1235 */
audio_is_input_channel(audio_channel_mask_t channel)1236 static inline bool audio_is_input_channel(audio_channel_mask_t channel)
1237 {
1238 uint32_t bits = audio_channel_mask_get_bits(channel);
1239 switch (audio_channel_mask_get_representation(channel)) {
1240 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1241 if (bits & ~AUDIO_CHANNEL_IN_ALL) {
1242 bits = 0;
1243 }
1244 // fall through
1245 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1246 return bits != 0;
1247 default:
1248 return false;
1249 }
1250 }
1251
1252 /* Returns true if:
1253 * representation is valid, and
1254 * there is at least one channel bit set which _could_ correspond to an output channel, and
1255 * there are no channel bits set which could _not_ correspond to an output channel.
1256 * Otherwise returns false.
1257 */
audio_is_output_channel(audio_channel_mask_t channel)1258 static inline bool audio_is_output_channel(audio_channel_mask_t channel)
1259 {
1260 uint32_t bits = audio_channel_mask_get_bits(channel);
1261 switch (audio_channel_mask_get_representation(channel)) {
1262 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1263 if (bits & ~AUDIO_CHANNEL_OUT_ALL) {
1264 bits = 0;
1265 }
1266 // fall through
1267 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1268 return bits != 0;
1269 default:
1270 return false;
1271 }
1272 }
1273
1274 /* Returns the number of channels from an input channel mask,
1275 * used in the context of audio input or recording.
1276 * If a channel bit is set which could _not_ correspond to an input channel,
1277 * it is excluded from the count.
1278 * Returns zero if the representation is invalid.
1279 */
audio_channel_count_from_in_mask(audio_channel_mask_t channel)1280 static inline uint32_t audio_channel_count_from_in_mask(audio_channel_mask_t channel)
1281 {
1282 uint32_t bits = audio_channel_mask_get_bits(channel);
1283 switch (audio_channel_mask_get_representation(channel)) {
1284 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1285 // TODO: We can now merge with from_out_mask and remove anding
1286 bits &= AUDIO_CHANNEL_IN_ALL;
1287 // fall through
1288 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1289 return popcount(bits);
1290 default:
1291 return 0;
1292 }
1293 }
1294
1295 /* Returns the number of channels from an output channel mask,
1296 * used in the context of audio output or playback.
1297 * If a channel bit is set which could _not_ correspond to an output channel,
1298 * it is excluded from the count.
1299 * Returns zero if the representation is invalid.
1300 */
audio_channel_count_from_out_mask(audio_channel_mask_t channel)1301 static inline uint32_t audio_channel_count_from_out_mask(audio_channel_mask_t channel)
1302 {
1303 uint32_t bits = audio_channel_mask_get_bits(channel);
1304 switch (audio_channel_mask_get_representation(channel)) {
1305 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
1306 // TODO: We can now merge with from_in_mask and remove anding
1307 bits &= AUDIO_CHANNEL_OUT_ALL;
1308 // fall through
1309 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
1310 return popcount(bits);
1311 default:
1312 return 0;
1313 }
1314 }
1315
1316 /* Derive a channel mask for index assignment from a channel count.
1317 * Returns the matching channel mask,
1318 * or AUDIO_CHANNEL_NONE if the channel count is zero,
1319 * or AUDIO_CHANNEL_INVALID if the channel count exceeds AUDIO_CHANNEL_COUNT_MAX.
1320 */
audio_channel_mask_for_index_assignment_from_count(uint32_t channel_count)1321 static inline audio_channel_mask_t audio_channel_mask_for_index_assignment_from_count(
1322 uint32_t channel_count)
1323 {
1324 if (channel_count == 0) {
1325 return AUDIO_CHANNEL_NONE;
1326 }
1327 if (channel_count > AUDIO_CHANNEL_COUNT_MAX) {
1328 return AUDIO_CHANNEL_INVALID;
1329 }
1330 uint32_t bits = (1 << channel_count) - 1;
1331 return audio_channel_mask_from_representation_and_bits(
1332 AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
1333 }
1334
1335 /* Derive an output channel mask for position assignment from a channel count.
1336 * This is to be used when the content channel mask is unknown. The 1, 2, 4, 5, 6, 7 and 8 channel
1337 * cases are mapped to the standard game/home-theater layouts, but note that 4 is mapped to quad,
1338 * and not stereo + FC + mono surround. A channel count of 3 is arbitrarily mapped to stereo + FC
1339 * for continuity with stereo.
1340 * Returns the matching channel mask,
1341 * or AUDIO_CHANNEL_NONE if the channel count is zero,
1342 * or AUDIO_CHANNEL_INVALID if the channel count exceeds that of the
1343 * configurations for which a default output channel mask is defined.
1344 */
audio_channel_out_mask_from_count(uint32_t channel_count)1345 static inline audio_channel_mask_t audio_channel_out_mask_from_count(uint32_t channel_count)
1346 {
1347 uint32_t bits;
1348 switch (channel_count) {
1349 case 0:
1350 return AUDIO_CHANNEL_NONE;
1351 case 1:
1352 bits = AUDIO_CHANNEL_OUT_MONO;
1353 break;
1354 case 2:
1355 bits = AUDIO_CHANNEL_OUT_STEREO;
1356 break;
1357 case 3:
1358 bits = AUDIO_CHANNEL_OUT_STEREO | AUDIO_CHANNEL_OUT_FRONT_CENTER;
1359 break;
1360 case 4: // 4.0
1361 bits = AUDIO_CHANNEL_OUT_QUAD;
1362 break;
1363 case 5: // 5.0
1364 bits = AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER;
1365 break;
1366 case 6: // 5.1
1367 bits = AUDIO_CHANNEL_OUT_5POINT1;
1368 break;
1369 case 7: // 6.1
1370 bits = AUDIO_CHANNEL_OUT_5POINT1 | AUDIO_CHANNEL_OUT_BACK_CENTER;
1371 break;
1372 case 8:
1373 bits = AUDIO_CHANNEL_OUT_7POINT1;
1374 break;
1375 // FIXME FCC_8
1376 default:
1377 return AUDIO_CHANNEL_INVALID;
1378 }
1379 return audio_channel_mask_from_representation_and_bits(
1380 AUDIO_CHANNEL_REPRESENTATION_POSITION, bits);
1381 }
1382
1383 /* Derive a default input channel mask from a channel count.
1384 * Assumes a position mask for mono and stereo, or an index mask for channel counts > 2.
1385 * Returns the matching channel mask,
1386 * or AUDIO_CHANNEL_NONE if the channel count is zero,
1387 * or AUDIO_CHANNEL_INVALID if the channel count exceeds that of the
1388 * configurations for which a default input channel mask is defined.
1389 */
audio_channel_in_mask_from_count(uint32_t channel_count)1390 static inline audio_channel_mask_t audio_channel_in_mask_from_count(uint32_t channel_count)
1391 {
1392 uint32_t bits;
1393 switch (channel_count) {
1394 case 0:
1395 return AUDIO_CHANNEL_NONE;
1396 case 1:
1397 bits = AUDIO_CHANNEL_IN_MONO;
1398 break;
1399 case 2:
1400 bits = AUDIO_CHANNEL_IN_STEREO;
1401 break;
1402 case 3:
1403 case 4:
1404 case 5:
1405 case 6:
1406 case 7:
1407 case 8:
1408 // FIXME FCC_8
1409 return audio_channel_mask_for_index_assignment_from_count(channel_count);
1410 default:
1411 return AUDIO_CHANNEL_INVALID;
1412 }
1413 return audio_channel_mask_from_representation_and_bits(
1414 AUDIO_CHANNEL_REPRESENTATION_POSITION, bits);
1415 }
1416
audio_is_valid_format(audio_format_t format)1417 static inline bool audio_is_valid_format(audio_format_t format)
1418 {
1419 switch (format & AUDIO_FORMAT_MAIN_MASK) {
1420 case AUDIO_FORMAT_PCM:
1421 switch (format) {
1422 case AUDIO_FORMAT_PCM_16_BIT:
1423 case AUDIO_FORMAT_PCM_8_BIT:
1424 case AUDIO_FORMAT_PCM_32_BIT:
1425 case AUDIO_FORMAT_PCM_8_24_BIT:
1426 case AUDIO_FORMAT_PCM_FLOAT:
1427 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
1428 return true;
1429 default:
1430 return false;
1431 }
1432 /* not reached */
1433 case AUDIO_FORMAT_MP3:
1434 case AUDIO_FORMAT_AMR_NB:
1435 case AUDIO_FORMAT_AMR_WB:
1436 case AUDIO_FORMAT_AAC:
1437 case AUDIO_FORMAT_HE_AAC_V1:
1438 case AUDIO_FORMAT_HE_AAC_V2:
1439 case AUDIO_FORMAT_VORBIS:
1440 case AUDIO_FORMAT_OPUS:
1441 case AUDIO_FORMAT_AC3:
1442 case AUDIO_FORMAT_E_AC3:
1443 case AUDIO_FORMAT_DTS:
1444 case AUDIO_FORMAT_DTS_HD:
1445 case AUDIO_FORMAT_IEC61937:
1446 case AUDIO_FORMAT_DOLBY_TRUEHD:
1447 return true;
1448 default:
1449 return false;
1450 }
1451 }
1452
1453 /**
1454 * Extract the primary format, eg. PCM, AC3, etc.
1455 */
audio_get_main_format(audio_format_t format)1456 static inline audio_format_t audio_get_main_format(audio_format_t format)
1457 {
1458 return (audio_format_t)(format & AUDIO_FORMAT_MAIN_MASK);
1459 }
1460
1461 /**
1462 * Is the data plain PCM samples that can be scaled and mixed?
1463 */
audio_is_linear_pcm(audio_format_t format)1464 static inline bool audio_is_linear_pcm(audio_format_t format)
1465 {
1466 return (audio_get_main_format(format) == AUDIO_FORMAT_PCM);
1467 }
1468
1469 /**
1470 * For this format, is the number of PCM audio frames directly proportional
1471 * to the number of data bytes?
1472 *
1473 * In other words, is the format transported as PCM audio samples,
1474 * but not necessarily scalable or mixable.
1475 * This returns true for real PCM, but also for AUDIO_FORMAT_IEC61937,
1476 * which is transported as 16 bit PCM audio, but where the encoded data
1477 * cannot be mixed or scaled.
1478 */
audio_has_proportional_frames(audio_format_t format)1479 static inline bool audio_has_proportional_frames(audio_format_t format)
1480 {
1481 audio_format_t mainFormat = audio_get_main_format(format);
1482 return (mainFormat == AUDIO_FORMAT_PCM
1483 || mainFormat == AUDIO_FORMAT_IEC61937);
1484 }
1485
audio_bytes_per_sample(audio_format_t format)1486 static inline size_t audio_bytes_per_sample(audio_format_t format)
1487 {
1488 size_t size = 0;
1489
1490 switch (format) {
1491 case AUDIO_FORMAT_PCM_32_BIT:
1492 case AUDIO_FORMAT_PCM_8_24_BIT:
1493 size = sizeof(int32_t);
1494 break;
1495 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
1496 size = sizeof(uint8_t) * 3;
1497 break;
1498 case AUDIO_FORMAT_PCM_16_BIT:
1499 case AUDIO_FORMAT_IEC61937:
1500 size = sizeof(int16_t);
1501 break;
1502 case AUDIO_FORMAT_PCM_8_BIT:
1503 size = sizeof(uint8_t);
1504 break;
1505 case AUDIO_FORMAT_PCM_FLOAT:
1506 size = sizeof(float);
1507 break;
1508 default:
1509 break;
1510 }
1511 return size;
1512 }
1513
1514 /* converts device address to string sent to audio HAL via set_parameters */
audio_device_address_to_parameter(audio_devices_t device,const char * address)1515 static inline char *audio_device_address_to_parameter(audio_devices_t device, const char *address)
1516 {
1517 const size_t kSize = AUDIO_DEVICE_MAX_ADDRESS_LEN + sizeof("a2dp_sink_address=");
1518 char param[kSize];
1519
1520 if (device & AUDIO_DEVICE_OUT_ALL_A2DP)
1521 snprintf(param, kSize, "%s=%s", "a2dp_sink_address", address);
1522 else if (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
1523 snprintf(param, kSize, "%s=%s", "mix", address);
1524 else
1525 snprintf(param, kSize, "%s", address);
1526
1527 return strdup(param);
1528 }
1529
audio_device_is_digital(audio_devices_t device)1530 static inline bool audio_device_is_digital(audio_devices_t device) {
1531 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1532 // input
1533 return (~AUDIO_DEVICE_BIT_IN & device & (AUDIO_DEVICE_IN_ALL_USB |
1534 AUDIO_DEVICE_IN_HDMI |
1535 AUDIO_DEVICE_IN_SPDIF |
1536 AUDIO_DEVICE_IN_IP |
1537 AUDIO_DEVICE_IN_BUS)) != 0;
1538 } else {
1539 // output
1540 return (device & (AUDIO_DEVICE_OUT_ALL_USB |
1541 AUDIO_DEVICE_OUT_HDMI |
1542 AUDIO_DEVICE_OUT_HDMI_ARC |
1543 AUDIO_DEVICE_OUT_SPDIF |
1544 AUDIO_DEVICE_OUT_IP |
1545 AUDIO_DEVICE_OUT_BUS)) != 0;
1546 }
1547 }
1548
1549 __END_DECLS
1550
1551 #endif // ANDROID_AUDIO_CORE_H
1552