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 #include "audio-base.h"
30 #include "audio-base-utils.h"
31
32 /*
33 * Annotation to tell clang that we intend to fall through from one case to
34 * another in a switch (for c++ files). Sourced from android-base/macros.h.
35 */
36 #ifndef FALLTHROUGH_INTENDED
37 #ifdef __cplusplus
38 #define FALLTHROUGH_INTENDED [[fallthrough]]
39 #else
40 #define FALLTHROUGH_INTENDED
41 #endif // __cplusplus
42 #endif // FALLTHROUGH_INTENDED
43
44 __BEGIN_DECLS
45
46 /* The enums were moved here mostly from
47 * frameworks/base/include/media/AudioSystem.h
48 */
49
50 /* represents an invalid uid for tracks; the calling or client uid is often substituted. */
51 #define AUDIO_UID_INVALID ((uid_t)-1)
52
53 /* device address used to refer to the standard remote submix */
54 #define AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS "0"
55
56 /* AudioFlinger and AudioPolicy services use I/O handles to identify audio sources and sinks */
57 typedef int audio_io_handle_t;
58
59 typedef uint32_t audio_flags_mask_t;
60
61 /* Do not change these values without updating their counterparts
62 * in frameworks/base/media/java/android/media/AudioAttributes.java
63 */
64 enum {
65 AUDIO_FLAG_NONE = 0x0,
66 AUDIO_FLAG_AUDIBILITY_ENFORCED = 0x1,
67 AUDIO_FLAG_SECURE = 0x2,
68 AUDIO_FLAG_SCO = 0x4,
69 AUDIO_FLAG_BEACON = 0x8,
70 AUDIO_FLAG_HW_AV_SYNC = 0x10,
71 AUDIO_FLAG_HW_HOTWORD = 0x20,
72 AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY = 0x40,
73 AUDIO_FLAG_BYPASS_MUTE = 0x80,
74 AUDIO_FLAG_LOW_LATENCY = 0x100,
75 AUDIO_FLAG_DEEP_BUFFER = 0x200,
76 AUDIO_FLAG_NO_MEDIA_PROJECTION = 0X400,
77 AUDIO_FLAG_MUTE_HAPTIC = 0x800,
78 AUDIO_FLAG_NO_SYSTEM_CAPTURE = 0X1000,
79 };
80
81 /* Audio attributes */
82 #define AUDIO_ATTRIBUTES_TAGS_MAX_SIZE 256
83 typedef struct {
84 audio_content_type_t content_type;
85 audio_usage_t usage;
86 audio_source_t source;
87 audio_flags_mask_t flags;
88 char tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE]; /* UTF8 */
89 } __attribute__((packed)) audio_attributes_t; // sent through Binder;
90
91 static const audio_attributes_t AUDIO_ATTRIBUTES_INITIALIZER = {
92 /* .content_type = */ AUDIO_CONTENT_TYPE_UNKNOWN,
93 /* .usage = */ AUDIO_USAGE_UNKNOWN,
94 /* .source = */ AUDIO_SOURCE_DEFAULT,
95 /* .flags = */ AUDIO_FLAG_NONE,
96 /* .tags = */ ""
97 };
98
attributes_initializer(audio_usage_t usage)99 static inline audio_attributes_t attributes_initializer(audio_usage_t usage)
100 {
101 audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
102 attributes.usage = usage;
103 return attributes;
104 }
105
audio_flags_to_audio_output_flags(const audio_flags_mask_t audio_flags,audio_output_flags_t * flags)106 static inline void audio_flags_to_audio_output_flags(
107 const audio_flags_mask_t audio_flags,
108 audio_output_flags_t *flags)
109 {
110 if ((audio_flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
111 *flags = (audio_output_flags_t)(*flags |
112 AUDIO_OUTPUT_FLAG_HW_AV_SYNC | AUDIO_OUTPUT_FLAG_DIRECT);
113 }
114 if ((audio_flags & AUDIO_FLAG_LOW_LATENCY) != 0) {
115 *flags = (audio_output_flags_t)(*flags | AUDIO_OUTPUT_FLAG_FAST);
116 }
117 // check deep buffer after flags have been modified above
118 if (*flags == AUDIO_OUTPUT_FLAG_NONE && (audio_flags & AUDIO_FLAG_DEEP_BUFFER) != 0) {
119 *flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
120 }
121 }
122
123
124 /* a unique ID allocated by AudioFlinger for use as an audio_io_handle_t, audio_session_t,
125 * effect ID (int), audio_module_handle_t, and audio_patch_handle_t.
126 * Audio port IDs (audio_port_handle_t) are allocated by AudioPolicy
127 * in a different namespace than AudioFlinger unique IDs.
128 */
129 typedef int audio_unique_id_t;
130
131 /* Possible uses for an audio_unique_id_t */
132 typedef enum {
133 AUDIO_UNIQUE_ID_USE_UNSPECIFIED = 0,
134 AUDIO_UNIQUE_ID_USE_SESSION = 1, // for allocated sessions, not special AUDIO_SESSION_*
135 AUDIO_UNIQUE_ID_USE_MODULE = 2,
136 AUDIO_UNIQUE_ID_USE_EFFECT = 3,
137 AUDIO_UNIQUE_ID_USE_PATCH = 4,
138 AUDIO_UNIQUE_ID_USE_OUTPUT = 5,
139 AUDIO_UNIQUE_ID_USE_INPUT = 6,
140 AUDIO_UNIQUE_ID_USE_CLIENT = 7, // client-side players and recorders
141 AUDIO_UNIQUE_ID_USE_MAX = 8, // must be a power-of-two
142 AUDIO_UNIQUE_ID_USE_MASK = AUDIO_UNIQUE_ID_USE_MAX - 1
143 } audio_unique_id_use_t;
144
145 /* Return the use of an audio_unique_id_t */
audio_unique_id_get_use(audio_unique_id_t id)146 static inline audio_unique_id_use_t audio_unique_id_get_use(audio_unique_id_t id)
147 {
148 return (audio_unique_id_use_t) (id & AUDIO_UNIQUE_ID_USE_MASK);
149 }
150
151 /* Reserved audio_unique_id_t values. FIXME: not a complete list. */
152 #define AUDIO_UNIQUE_ID_ALLOCATE AUDIO_SESSION_ALLOCATE
153
154 /* A channel mask per se only defines the presence or absence of a channel, not the order.
155 * But see AUDIO_INTERLEAVE_* below for the platform convention of order.
156 *
157 * audio_channel_mask_t is an opaque type and its internal layout should not
158 * be assumed as it may change in the future.
159 * Instead, always use the functions declared in this header to examine.
160 *
161 * These are the current representations:
162 *
163 * AUDIO_CHANNEL_REPRESENTATION_POSITION
164 * is a channel mask representation for position assignment.
165 * Each low-order bit corresponds to the spatial position of a transducer (output),
166 * or interpretation of channel (input).
167 * The user of a channel mask needs to know the context of whether it is for output or input.
168 * The constants AUDIO_CHANNEL_OUT_* or AUDIO_CHANNEL_IN_* apply to the bits portion.
169 * It is not permitted for no bits to be set.
170 *
171 * AUDIO_CHANNEL_REPRESENTATION_INDEX
172 * is a channel mask representation for index assignment.
173 * Each low-order bit corresponds to a selected channel.
174 * There is no platform interpretation of the various bits.
175 * There is no concept of output or input.
176 * It is not permitted for no bits to be set.
177 *
178 * All other representations are reserved for future use.
179 *
180 * Warning: current representation distinguishes between input and output, but this will not the be
181 * case in future revisions of the platform. Wherever there is an ambiguity between input and output
182 * that is currently resolved by checking the channel mask, the implementer should look for ways to
183 * fix it with additional information outside of the mask.
184 */
185 typedef uint32_t audio_channel_mask_t;
186
187 /* log(2) of maximum number of representations, not part of public API */
188 #define AUDIO_CHANNEL_REPRESENTATION_LOG2 2
189
190 /* The return value is undefined if the channel mask is invalid. */
audio_channel_mask_get_bits(audio_channel_mask_t channel)191 static inline uint32_t audio_channel_mask_get_bits(audio_channel_mask_t channel)
192 {
193 return channel & ((1 << AUDIO_CHANNEL_COUNT_MAX) - 1);
194 }
195
196 typedef uint32_t audio_channel_representation_t;
197
198 /* The return value is undefined if the channel mask is invalid. */
audio_channel_mask_get_representation(audio_channel_mask_t channel)199 static inline audio_channel_representation_t audio_channel_mask_get_representation(
200 audio_channel_mask_t channel)
201 {
202 // The right shift should be sufficient, but also "and" for safety in case mask is not 32 bits
203 return (audio_channel_representation_t)
204 ((channel >> AUDIO_CHANNEL_COUNT_MAX) & ((1 << AUDIO_CHANNEL_REPRESENTATION_LOG2) - 1));
205 }
206
207 /* Returns true if the channel mask is valid,
208 * or returns false for AUDIO_CHANNEL_NONE, AUDIO_CHANNEL_INVALID, and other invalid values.
209 * This function is unable to determine whether a channel mask for position assignment
210 * is invalid because an output mask has an invalid output bit set,
211 * or because an input mask has an invalid input bit set.
212 * All other APIs that take a channel mask assume that it is valid.
213 */
audio_channel_mask_is_valid(audio_channel_mask_t channel)214 static inline bool audio_channel_mask_is_valid(audio_channel_mask_t channel)
215 {
216 uint32_t bits = audio_channel_mask_get_bits(channel);
217 audio_channel_representation_t representation = audio_channel_mask_get_representation(channel);
218 switch (representation) {
219 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
220 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
221 break;
222 default:
223 bits = 0;
224 break;
225 }
226 return bits != 0;
227 }
228
229 /* Not part of public API */
audio_channel_mask_from_representation_and_bits(audio_channel_representation_t representation,uint32_t bits)230 static inline audio_channel_mask_t audio_channel_mask_from_representation_and_bits(
231 audio_channel_representation_t representation, uint32_t bits)
232 {
233 return (audio_channel_mask_t) ((representation << AUDIO_CHANNEL_COUNT_MAX) | bits);
234 }
235
236 /**
237 * Expresses the convention when stereo audio samples are stored interleaved
238 * in an array. This should improve readability by allowing code to use
239 * symbolic indices instead of hard-coded [0] and [1].
240 *
241 * For multi-channel beyond stereo, the platform convention is that channels
242 * are interleaved in order from least significant channel mask bit to most
243 * significant channel mask bit, with unused bits skipped. Any exceptions
244 * to this convention will be noted at the appropriate API.
245 */
246 enum {
247 AUDIO_INTERLEAVE_LEFT = 0,
248 AUDIO_INTERLEAVE_RIGHT = 1,
249 };
250
251 /* This enum is deprecated */
252 typedef enum {
253 AUDIO_IN_ACOUSTICS_NONE = 0,
254 AUDIO_IN_ACOUSTICS_AGC_ENABLE = 0x0001,
255 AUDIO_IN_ACOUSTICS_AGC_DISABLE = 0,
256 AUDIO_IN_ACOUSTICS_NS_ENABLE = 0x0002,
257 AUDIO_IN_ACOUSTICS_NS_DISABLE = 0,
258 AUDIO_IN_ACOUSTICS_TX_IIR_ENABLE = 0x0004,
259 AUDIO_IN_ACOUSTICS_TX_DISABLE = 0,
260 } audio_in_acoustics_t;
261
262 typedef uint32_t audio_devices_t;
263 /**
264 * Stub audio output device. Used in policy configuration file on platforms without audio outputs.
265 * This alias value to AUDIO_DEVICE_OUT_DEFAULT is only used in the audio policy context.
266 */
267 #define AUDIO_DEVICE_OUT_STUB AUDIO_DEVICE_OUT_DEFAULT
268 /**
269 * Stub audio input device. Used in policy configuration file on platforms without audio inputs.
270 * This alias value to AUDIO_DEVICE_IN_DEFAULT is only used in the audio policy context.
271 */
272 #define AUDIO_DEVICE_IN_STUB AUDIO_DEVICE_IN_DEFAULT
273
274 /* Additional information about compressed streams offloaded to
275 * hardware playback
276 * The version and size fields must be initialized by the caller by using
277 * one of the constants defined here.
278 * Must be aligned to transmit as raw memory through Binder.
279 */
280 typedef struct {
281 uint16_t version; // version of the info structure
282 uint16_t size; // total size of the structure including version and size
283 uint32_t sample_rate; // sample rate in Hz
284 audio_channel_mask_t channel_mask; // channel mask
285 audio_format_t format; // audio format
286 audio_stream_type_t stream_type; // stream type
287 uint32_t bit_rate; // bit rate in bits per second
288 int64_t duration_us; // duration in microseconds, -1 if unknown
289 bool has_video; // true if stream is tied to a video stream
290 bool is_streaming; // true if streaming, false if local playback
291 uint32_t bit_width;
292 uint32_t offload_buffer_size; // offload fragment size
293 audio_usage_t usage;
294 } __attribute__((aligned(8))) audio_offload_info_t;
295
296 #define AUDIO_MAKE_OFFLOAD_INFO_VERSION(maj,min) \
297 ((((maj) & 0xff) << 8) | ((min) & 0xff))
298
299 #define AUDIO_OFFLOAD_INFO_VERSION_0_1 AUDIO_MAKE_OFFLOAD_INFO_VERSION(0, 1)
300 #define AUDIO_OFFLOAD_INFO_VERSION_CURRENT AUDIO_OFFLOAD_INFO_VERSION_0_1
301
302 static const audio_offload_info_t AUDIO_INFO_INITIALIZER = {
303 /* .version = */ AUDIO_OFFLOAD_INFO_VERSION_CURRENT,
304 /* .size = */ sizeof(audio_offload_info_t),
305 /* .sample_rate = */ 0,
306 /* .channel_mask = */ 0,
307 /* .format = */ AUDIO_FORMAT_DEFAULT,
308 /* .stream_type = */ AUDIO_STREAM_VOICE_CALL,
309 /* .bit_rate = */ 0,
310 /* .duration_us = */ 0,
311 /* .has_video = */ false,
312 /* .is_streaming = */ false,
313 /* .bit_width = */ 16,
314 /* .offload_buffer_size = */ 0,
315 /* .usage = */ AUDIO_USAGE_UNKNOWN
316 };
317
318 /* common audio stream configuration parameters
319 * You should memset() the entire structure to zero before use to
320 * ensure forward compatibility
321 * Must be aligned to transmit as raw memory through Binder.
322 */
323 struct __attribute__((aligned(8))) audio_config {
324 uint32_t sample_rate;
325 audio_channel_mask_t channel_mask;
326 audio_format_t format;
327 audio_offload_info_t offload_info;
328 uint32_t frame_count;
329 };
330 typedef struct audio_config audio_config_t;
331
332 static const audio_config_t AUDIO_CONFIG_INITIALIZER = {
333 /* .sample_rate = */ 0,
334 /* .channel_mask = */ AUDIO_CHANNEL_NONE,
335 /* .format = */ AUDIO_FORMAT_DEFAULT,
336 /* .offload_info = */ {
337 /* .version = */ AUDIO_OFFLOAD_INFO_VERSION_CURRENT,
338 /* .size = */ sizeof(audio_offload_info_t),
339 /* .sample_rate = */ 0,
340 /* .channel_mask = */ 0,
341 /* .format = */ AUDIO_FORMAT_DEFAULT,
342 /* .stream_type = */ AUDIO_STREAM_VOICE_CALL,
343 /* .bit_rate = */ 0,
344 /* .duration_us = */ 0,
345 /* .has_video = */ false,
346 /* .is_streaming = */ false,
347 /* .bit_width = */ 16,
348 /* .offload_buffer_size = */ 0,
349 /* .usage = */ AUDIO_USAGE_UNKNOWN
350 },
351 /* .frame_count = */ 0,
352 };
353
354 struct audio_config_base {
355 uint32_t sample_rate;
356 audio_channel_mask_t channel_mask;
357 audio_format_t format;
358 };
359
360 typedef struct audio_config_base audio_config_base_t;
361
362 static const audio_config_base_t AUDIO_CONFIG_BASE_INITIALIZER = {
363 /* .sample_rate = */ 0,
364 /* .channel_mask = */ AUDIO_CHANNEL_NONE,
365 /* .format = */ AUDIO_FORMAT_DEFAULT
366 };
367
368 /* audio hw module handle functions or structures referencing a module */
369 typedef int audio_module_handle_t;
370
371 /******************************
372 * Volume control
373 *****************************/
374
375 /** 3 dB headroom are allowed on float samples (3db = 10^(3/20) = 1.412538).
376 * See: https://developer.android.com/reference/android/media/AudioTrack.html#write(float[], int, int, int)
377 */
378 #define FLOAT_NOMINAL_RANGE_HEADROOM 1.412538
379
380 /* If the audio hardware supports gain control on some audio paths,
381 * the platform can expose them in the audio_policy.conf file. The audio HAL
382 * will then implement gain control functions that will use the following data
383 * structures. */
384
385 typedef uint32_t audio_gain_mode_t;
386
387
388 /* An audio_gain struct is a representation of a gain stage.
389 * A gain stage is always attached to an audio port. */
390 struct audio_gain {
391 audio_gain_mode_t mode; /* e.g. AUDIO_GAIN_MODE_JOINT */
392 audio_channel_mask_t channel_mask; /* channels which gain an be controlled.
393 N/A if AUDIO_GAIN_MODE_CHANNELS is not supported */
394 int min_value; /* minimum gain value in millibels */
395 int max_value; /* maximum gain value in millibels */
396 int default_value; /* default gain value in millibels */
397 unsigned int step_value; /* gain step in millibels */
398 unsigned int min_ramp_ms; /* minimum ramp duration in ms */
399 unsigned int max_ramp_ms; /* maximum ramp duration in ms */
400 };
401
402 /* The gain configuration structure is used to get or set the gain values of a
403 * given port */
404 struct audio_gain_config {
405 int index; /* index of the corresponding audio_gain in the
406 audio_port gains[] table */
407 audio_gain_mode_t mode; /* mode requested for this command */
408 audio_channel_mask_t channel_mask; /* channels which gain value follows.
409 N/A in joint mode */
410
411 // note this "8" is not FCC_8, so it won't need to be changed for > 8 channels
412 int values[sizeof(audio_channel_mask_t) * 8]; /* gain values in millibels
413 for each channel ordered from LSb to MSb in
414 channel mask. The number of values is 1 in joint
415 mode or popcount(channel_mask) */
416 unsigned int ramp_duration_ms; /* ramp duration in ms */
417 };
418
419 /******************************
420 * Routing control
421 *****************************/
422
423 /* Types defined here are used to describe an audio source or sink at internal
424 * framework interfaces (audio policy, patch panel) or at the audio HAL.
425 * Sink and sources are grouped in a concept of “audio port” representing an
426 * audio end point at the edge of the system managed by the module exposing
427 * the interface. */
428
429 /* Each port has a unique ID or handle allocated by policy manager */
430 typedef int audio_port_handle_t;
431
432 /* the maximum length for the human-readable device name */
433 #define AUDIO_PORT_MAX_NAME_LEN 128
434
435 /* a union to store port configuration flags. Declared as a type so can be reused
436 in framework code */
437 union audio_io_flags {
438 audio_input_flags_t input;
439 audio_output_flags_t output;
440 };
441
442 /* maximum audio device address length */
443 #define AUDIO_DEVICE_MAX_ADDRESS_LEN 32
444
445 /* extension for audio port configuration structure when the audio port is a
446 * hardware device */
447 struct audio_port_config_device_ext {
448 audio_module_handle_t hw_module; /* module the device is attached to */
449 audio_devices_t type; /* device type (e.g AUDIO_DEVICE_OUT_SPEAKER) */
450 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN]; /* device address. "" if N/A */
451 };
452
453 /* extension for audio port configuration structure when the audio port is a
454 * sub mix */
455 struct audio_port_config_mix_ext {
456 audio_module_handle_t hw_module; /* module the stream is attached to */
457 audio_io_handle_t handle; /* I/O handle of the input/output stream */
458 union {
459 //TODO: change use case for output streams: use strategy and mixer attributes
460 audio_stream_type_t stream;
461 audio_source_t source;
462 } usecase;
463 };
464
465 /* extension for audio port configuration structure when the audio port is an
466 * audio session */
467 struct audio_port_config_session_ext {
468 audio_session_t session; /* audio session */
469 };
470
471 /* audio port configuration structure used to specify a particular configuration of
472 * an audio port */
473 struct audio_port_config {
474 audio_port_handle_t id; /* port unique ID */
475 audio_port_role_t role; /* sink or source */
476 audio_port_type_t type; /* device, mix ... */
477 unsigned int config_mask; /* e.g AUDIO_PORT_CONFIG_ALL */
478 unsigned int sample_rate; /* sampling rate in Hz */
479 audio_channel_mask_t channel_mask; /* channel mask if applicable */
480 audio_format_t format; /* format if applicable */
481 struct audio_gain_config gain; /* gain to apply if applicable */
482 #ifndef AUDIO_NO_SYSTEM_DECLARATIONS
483 union audio_io_flags flags; /* framework only: HW_AV_SYNC, DIRECT, ... */
484 #endif
485 union {
486 struct audio_port_config_device_ext device; /* device specific info */
487 struct audio_port_config_mix_ext mix; /* mix specific info */
488 struct audio_port_config_session_ext session; /* session specific info */
489 } ext;
490 };
491
492
493 /* max number of sampling rates in audio port */
494 #define AUDIO_PORT_MAX_SAMPLING_RATES 32
495 /* max number of channel masks in audio port */
496 #define AUDIO_PORT_MAX_CHANNEL_MASKS 32
497 /* max number of audio formats in audio port */
498 #define AUDIO_PORT_MAX_FORMATS 32
499 /* max number of gain controls in audio port */
500 #define AUDIO_PORT_MAX_GAINS 16
501
502 /* extension for audio port structure when the audio port is a hardware device */
503 struct audio_port_device_ext {
504 audio_module_handle_t hw_module; /* module the device is attached to */
505 audio_devices_t type; /* device type (e.g AUDIO_DEVICE_OUT_SPEAKER) */
506 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN];
507 };
508
509 /* extension for audio port structure when the audio port is a sub mix */
510 struct audio_port_mix_ext {
511 audio_module_handle_t hw_module; /* module the stream is attached to */
512 audio_io_handle_t handle; /* I/O handle of the input.output stream */
513 audio_mix_latency_class_t latency_class; /* latency class */
514 // other attributes: routing strategies
515 };
516
517 /* extension for audio port structure when the audio port is an audio session */
518 struct audio_port_session_ext {
519 audio_session_t session; /* audio session */
520 };
521
522 struct audio_port {
523 audio_port_handle_t id; /* port unique ID */
524 audio_port_role_t role; /* sink or source */
525 audio_port_type_t type; /* device, mix ... */
526 char name[AUDIO_PORT_MAX_NAME_LEN];
527 unsigned int num_sample_rates; /* number of sampling rates in following array */
528 unsigned int sample_rates[AUDIO_PORT_MAX_SAMPLING_RATES];
529 unsigned int num_channel_masks; /* number of channel masks in following array */
530 audio_channel_mask_t channel_masks[AUDIO_PORT_MAX_CHANNEL_MASKS];
531 unsigned int num_formats; /* number of formats in following array */
532 audio_format_t formats[AUDIO_PORT_MAX_FORMATS];
533 unsigned int num_gains; /* number of gains in following array */
534 struct audio_gain gains[AUDIO_PORT_MAX_GAINS];
535 struct audio_port_config active_config; /* current audio port configuration */
536 union {
537 struct audio_port_device_ext device;
538 struct audio_port_mix_ext mix;
539 struct audio_port_session_ext session;
540 } ext;
541 };
542
543 /* An audio patch represents a connection between one or more source ports and
544 * one or more sink ports. Patches are connected and disconnected by audio policy manager or by
545 * applications via framework APIs.
546 * Each patch is identified by a handle at the interface used to create that patch. For instance,
547 * when a patch is created by the audio HAL, the HAL allocates and returns a handle.
548 * This handle is unique to a given audio HAL hardware module.
549 * But the same patch receives another system wide unique handle allocated by the framework.
550 * This unique handle is used for all transactions inside the framework.
551 */
552 typedef int audio_patch_handle_t;
553
554 #define AUDIO_PATCH_PORTS_MAX 16
555
556 struct audio_patch {
557 audio_patch_handle_t id; /* patch unique ID */
558 unsigned int num_sources; /* number of sources in following array */
559 struct audio_port_config sources[AUDIO_PATCH_PORTS_MAX];
560 unsigned int num_sinks; /* number of sinks in following array */
561 struct audio_port_config sinks[AUDIO_PATCH_PORTS_MAX];
562 };
563
564
565
566 /* a HW synchronization source returned by the audio HAL */
567 typedef uint32_t audio_hw_sync_t;
568
569 /* an invalid HW synchronization source indicating an error */
570 #define AUDIO_HW_SYNC_INVALID 0
571
572 /** @TODO export from .hal */
573 typedef enum {
574 NONE = 0x0,
575 /**
576 * Only set this flag if applications can access the audio buffer memory
577 * shared with the backend (usually DSP) _without_ security issue.
578 *
579 * Setting this flag also implies that Binder will allow passing the shared memory FD
580 * to applications.
581 *
582 * That usually implies that the kernel will prevent any access to the
583 * memory surrounding the audio buffer as it could lead to a security breach.
584 *
585 * For example, a "/dev/snd/" file descriptor generally is not shareable,
586 * but an "anon_inode:dmabuffer" file descriptor is shareable.
587 * See also Linux kernel's dma_buf.
588 *
589 * This flag is required to support AAudio exclusive mode:
590 * See: https://source.android.com/devices/audio/aaudio
591 */
592 AUDIO_MMAP_APPLICATION_SHAREABLE = 0x1,
593 } audio_mmap_buffer_flag;
594
595 /**
596 * Mmap buffer descriptor returned by audio_stream->create_mmap_buffer().
597 * note\ Used by streams opened in mmap mode.
598 */
599 struct audio_mmap_buffer_info {
600 void* shared_memory_address; /**< base address of mmap memory buffer.
601 For use by local process only */
602 int32_t shared_memory_fd; /**< FD for mmap memory buffer */
603 int32_t buffer_size_frames; /**< total buffer size in frames */
604 int32_t burst_size_frames; /**< transfer size granularity in frames */
605 audio_mmap_buffer_flag flags; /**< Attributes describing the buffer. */
606 };
607
608 /**
609 * Mmap buffer read/write position returned by audio_stream->get_mmap_position().
610 * note\ Used by streams opened in mmap mode.
611 */
612 struct audio_mmap_position {
613 int64_t time_nanoseconds; /**< timestamp in ns, CLOCK_MONOTONIC */
614 int32_t position_frames; /**< increasing 32 bit frame count reset when stream->stop()
615 is called */
616 };
617
618 /** Metadata of a playback track for an in stream. */
619 typedef struct playback_track_metadata {
620 audio_usage_t usage;
621 audio_content_type_t content_type;
622 float gain; // Normalized linear volume. 0=silence, 1=0dbfs...
623 } playback_track_metadata_t;
624
625 /** Metadata of a record track for an out stream. */
626 typedef struct record_track_metadata {
627 audio_source_t source;
628 float gain; // Normalized linear volume. 0=silence, 1=0dbfs...
629 // For record tracks originating from a software patch, the dest_device
630 // fields provide information about the downstream device.
631 audio_devices_t dest_device;
632 char dest_device_address[AUDIO_DEVICE_MAX_ADDRESS_LEN];
633 } record_track_metadata_t;
634
635
636 /******************************
637 * Helper functions
638 *****************************/
639
audio_is_output_device(audio_devices_t device)640 static inline bool audio_is_output_device(audio_devices_t device)
641 {
642 if (((device & AUDIO_DEVICE_BIT_IN) == 0) &&
643 (popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL) == 0))
644 return true;
645 else
646 return false;
647 }
648
audio_is_input_device(audio_devices_t device)649 static inline bool audio_is_input_device(audio_devices_t device)
650 {
651 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
652 device &= ~AUDIO_DEVICE_BIT_IN;
653 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_IN_ALL) == 0))
654 return true;
655 }
656 return false;
657 }
658
audio_is_output_devices(audio_devices_t device)659 static inline bool audio_is_output_devices(audio_devices_t device)
660 {
661 return (device & AUDIO_DEVICE_BIT_IN) == 0;
662 }
663
audio_is_a2dp_in_device(audio_devices_t device)664 static inline bool audio_is_a2dp_in_device(audio_devices_t device)
665 {
666 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
667 device &= ~AUDIO_DEVICE_BIT_IN;
668 if ((popcount(device) == 1) && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP))
669 return true;
670 }
671 return false;
672 }
673
audio_is_a2dp_out_device(audio_devices_t device)674 static inline bool audio_is_a2dp_out_device(audio_devices_t device)
675 {
676 if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_ALL_A2DP))
677 return true;
678 else
679 return false;
680 }
681
682 // Deprecated - use audio_is_a2dp_out_device() instead
audio_is_a2dp_device(audio_devices_t device)683 static inline bool audio_is_a2dp_device(audio_devices_t device)
684 {
685 return audio_is_a2dp_out_device(device);
686 }
687
audio_is_bluetooth_sco_device(audio_devices_t device)688 static inline bool audio_is_bluetooth_sco_device(audio_devices_t device)
689 {
690 if ((device & AUDIO_DEVICE_BIT_IN) == 0) {
691 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_OUT_ALL_SCO) == 0))
692 return true;
693 } else {
694 device &= ~AUDIO_DEVICE_BIT_IN;
695 if ((popcount(device) == 1) && ((device & ~AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) == 0))
696 return true;
697 }
698
699 return false;
700 }
701
audio_is_hearing_aid_out_device(audio_devices_t device)702 static inline bool audio_is_hearing_aid_out_device(audio_devices_t device)
703 {
704 return device == AUDIO_DEVICE_OUT_HEARING_AID;
705 }
706
audio_is_usb_out_device(audio_devices_t device)707 static inline bool audio_is_usb_out_device(audio_devices_t device)
708 {
709 return ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_ALL_USB));
710 }
711
audio_is_usb_in_device(audio_devices_t device)712 static inline bool audio_is_usb_in_device(audio_devices_t device)
713 {
714 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
715 device &= ~AUDIO_DEVICE_BIT_IN;
716 if (popcount(device) == 1 && (device & AUDIO_DEVICE_IN_ALL_USB) != 0)
717 return true;
718 }
719 return false;
720 }
721
722 /* OBSOLETE - use audio_is_usb_out_device() instead. */
audio_is_usb_device(audio_devices_t device)723 static inline bool audio_is_usb_device(audio_devices_t device)
724 {
725 return audio_is_usb_out_device(device);
726 }
727
audio_is_remote_submix_device(audio_devices_t device)728 static inline bool audio_is_remote_submix_device(audio_devices_t device)
729 {
730 if ((audio_is_output_devices(device) &&
731 (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX) == AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
732 || (!audio_is_output_devices(device) &&
733 (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) == AUDIO_DEVICE_IN_REMOTE_SUBMIX))
734 return true;
735 else
736 return false;
737 }
738
739 /* Returns true if:
740 * representation is valid, and
741 * there is at least one channel bit set which _could_ correspond to an input channel, and
742 * there are no channel bits set which could _not_ correspond to an input channel.
743 * Otherwise returns false.
744 */
audio_is_input_channel(audio_channel_mask_t channel)745 static inline bool audio_is_input_channel(audio_channel_mask_t channel)
746 {
747 uint32_t bits = audio_channel_mask_get_bits(channel);
748 switch (audio_channel_mask_get_representation(channel)) {
749 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
750 if (bits & ~AUDIO_CHANNEL_IN_ALL) {
751 bits = 0;
752 }
753 FALLTHROUGH_INTENDED;
754 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
755 return bits != 0;
756 default:
757 return false;
758 }
759 }
760
761 /* Returns true if:
762 * representation is valid, and
763 * there is at least one channel bit set which _could_ correspond to an output channel, and
764 * there are no channel bits set which could _not_ correspond to an output channel.
765 * Otherwise returns false.
766 */
audio_is_output_channel(audio_channel_mask_t channel)767 static inline bool audio_is_output_channel(audio_channel_mask_t channel)
768 {
769 uint32_t bits = audio_channel_mask_get_bits(channel);
770 switch (audio_channel_mask_get_representation(channel)) {
771 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
772 if (bits & ~AUDIO_CHANNEL_OUT_ALL) {
773 bits = 0;
774 }
775 FALLTHROUGH_INTENDED;
776 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
777 return bits != 0;
778 default:
779 return false;
780 }
781 }
782
783 /* Returns the number of channels from an input channel mask,
784 * used in the context of audio input or recording.
785 * If a channel bit is set which could _not_ correspond to an input channel,
786 * it is excluded from the count.
787 * Returns zero if the representation is invalid.
788 */
audio_channel_count_from_in_mask(audio_channel_mask_t channel)789 static inline uint32_t audio_channel_count_from_in_mask(audio_channel_mask_t channel)
790 {
791 uint32_t bits = audio_channel_mask_get_bits(channel);
792 switch (audio_channel_mask_get_representation(channel)) {
793 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
794 // TODO: We can now merge with from_out_mask and remove anding
795 bits &= AUDIO_CHANNEL_IN_ALL;
796 FALLTHROUGH_INTENDED;
797 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
798 return popcount(bits);
799 default:
800 return 0;
801 }
802 }
803
804 /* Returns the number of channels from an output channel mask,
805 * used in the context of audio output or playback.
806 * If a channel bit is set which could _not_ correspond to an output channel,
807 * it is excluded from the count.
808 * Returns zero if the representation is invalid.
809 */
audio_channel_count_from_out_mask(audio_channel_mask_t channel)810 static inline uint32_t audio_channel_count_from_out_mask(audio_channel_mask_t channel)
811 {
812 uint32_t bits = audio_channel_mask_get_bits(channel);
813 switch (audio_channel_mask_get_representation(channel)) {
814 case AUDIO_CHANNEL_REPRESENTATION_POSITION:
815 // TODO: We can now merge with from_in_mask and remove anding
816 bits &= AUDIO_CHANNEL_OUT_ALL;
817 FALLTHROUGH_INTENDED;
818 case AUDIO_CHANNEL_REPRESENTATION_INDEX:
819 return popcount(bits);
820 default:
821 return 0;
822 }
823 }
824
825 /* Derive a channel mask for index assignment from a channel count.
826 * Returns the matching channel mask,
827 * or AUDIO_CHANNEL_NONE if the channel count is zero,
828 * or AUDIO_CHANNEL_INVALID if the channel count exceeds AUDIO_CHANNEL_COUNT_MAX.
829 */
audio_channel_mask_for_index_assignment_from_count(uint32_t channel_count)830 static inline audio_channel_mask_t audio_channel_mask_for_index_assignment_from_count(
831 uint32_t channel_count)
832 {
833 if (channel_count == 0) {
834 return AUDIO_CHANNEL_NONE;
835 }
836 if (channel_count > AUDIO_CHANNEL_COUNT_MAX) {
837 return AUDIO_CHANNEL_INVALID;
838 }
839 uint32_t bits = (1 << channel_count) - 1;
840 return audio_channel_mask_from_representation_and_bits(
841 AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
842 }
843
844 /* Derive an output channel mask for position assignment from a channel count.
845 * This is to be used when the content channel mask is unknown. The 1, 2, 4, 5, 6, 7 and 8 channel
846 * cases are mapped to the standard game/home-theater layouts, but note that 4 is mapped to quad,
847 * and not stereo + FC + mono surround. A channel count of 3 is arbitrarily mapped to stereo + FC
848 * for continuity with stereo.
849 * Returns the matching channel mask,
850 * or AUDIO_CHANNEL_NONE if the channel count is zero,
851 * or AUDIO_CHANNEL_INVALID if the channel count exceeds that of the
852 * configurations for which a default output channel mask is defined.
853 */
audio_channel_out_mask_from_count(uint32_t channel_count)854 static inline audio_channel_mask_t audio_channel_out_mask_from_count(uint32_t channel_count)
855 {
856 uint32_t bits;
857 switch (channel_count) {
858 case 0:
859 return AUDIO_CHANNEL_NONE;
860 case 1:
861 bits = AUDIO_CHANNEL_OUT_MONO;
862 break;
863 case 2:
864 bits = AUDIO_CHANNEL_OUT_STEREO;
865 break;
866 case 3: // 2.1
867 bits = AUDIO_CHANNEL_OUT_STEREO | AUDIO_CHANNEL_OUT_LOW_FREQUENCY;
868 break;
869 case 4: // 4.0
870 bits = AUDIO_CHANNEL_OUT_QUAD;
871 break;
872 case 5: // 5.0
873 bits = AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER;
874 break;
875 case 6: // 5.1
876 bits = AUDIO_CHANNEL_OUT_5POINT1;
877 break;
878 case 7: // 6.1
879 bits = AUDIO_CHANNEL_OUT_5POINT1 | AUDIO_CHANNEL_OUT_BACK_CENTER;
880 break;
881 case 8:
882 bits = AUDIO_CHANNEL_OUT_7POINT1;
883 break;
884 // FIXME FCC_8
885 default:
886 return AUDIO_CHANNEL_INVALID;
887 }
888 return audio_channel_mask_from_representation_and_bits(
889 AUDIO_CHANNEL_REPRESENTATION_POSITION, bits);
890 }
891
892 /* Derive a default input channel mask from a channel count.
893 * Assumes a position mask for mono and stereo, or an index mask for channel counts > 2.
894 * Returns the matching channel mask,
895 * or AUDIO_CHANNEL_NONE if the channel count is zero,
896 * or AUDIO_CHANNEL_INVALID if the channel count exceeds that of the
897 * configurations for which a default input channel mask is defined.
898 */
audio_channel_in_mask_from_count(uint32_t channel_count)899 static inline audio_channel_mask_t audio_channel_in_mask_from_count(uint32_t channel_count)
900 {
901 uint32_t bits;
902 switch (channel_count) {
903 case 0:
904 return AUDIO_CHANNEL_NONE;
905 case 1:
906 bits = AUDIO_CHANNEL_IN_MONO;
907 break;
908 case 2:
909 bits = AUDIO_CHANNEL_IN_STEREO;
910 break;
911 case 3:
912 case 4:
913 case 5:
914 case 6:
915 case 7:
916 case 8:
917 // FIXME FCC_8
918 return audio_channel_mask_for_index_assignment_from_count(channel_count);
919 default:
920 return AUDIO_CHANNEL_INVALID;
921 }
922 return audio_channel_mask_from_representation_and_bits(
923 AUDIO_CHANNEL_REPRESENTATION_POSITION, bits);
924 }
925
926 /* Derive a default haptic channel mask from a channel count.
927 */
haptic_channel_mask_from_count(uint32_t channel_count)928 static inline audio_channel_mask_t haptic_channel_mask_from_count(uint32_t channel_count)
929 {
930 switch(channel_count) {
931 case 0:
932 return AUDIO_CHANNEL_NONE;
933 case 1:
934 return AUDIO_CHANNEL_OUT_HAPTIC_A;
935 case 2:
936 return AUDIO_CHANNEL_OUT_HAPTIC_AB;
937 default:
938 return AUDIO_CHANNEL_INVALID;
939 }
940 }
941
audio_channel_mask_in_to_out(audio_channel_mask_t in)942 static inline audio_channel_mask_t audio_channel_mask_in_to_out(audio_channel_mask_t in)
943 {
944 switch (in) {
945 case AUDIO_CHANNEL_IN_MONO:
946 return AUDIO_CHANNEL_OUT_MONO;
947 case AUDIO_CHANNEL_IN_STEREO:
948 return AUDIO_CHANNEL_OUT_STEREO;
949 case AUDIO_CHANNEL_IN_5POINT1:
950 return AUDIO_CHANNEL_OUT_5POINT1;
951 case AUDIO_CHANNEL_IN_3POINT1POINT2:
952 return AUDIO_CHANNEL_OUT_3POINT1POINT2;
953 case AUDIO_CHANNEL_IN_3POINT0POINT2:
954 return AUDIO_CHANNEL_OUT_3POINT0POINT2;
955 case AUDIO_CHANNEL_IN_2POINT1POINT2:
956 return AUDIO_CHANNEL_OUT_2POINT1POINT2;
957 case AUDIO_CHANNEL_IN_2POINT0POINT2:
958 return AUDIO_CHANNEL_OUT_2POINT0POINT2;
959 default:
960 return AUDIO_CHANNEL_INVALID;
961 }
962 }
963
audio_channel_mask_out_to_in(audio_channel_mask_t out)964 static inline audio_channel_mask_t audio_channel_mask_out_to_in(audio_channel_mask_t out)
965 {
966 switch (out) {
967 case AUDIO_CHANNEL_OUT_MONO:
968 return AUDIO_CHANNEL_IN_MONO;
969 case AUDIO_CHANNEL_OUT_STEREO:
970 return AUDIO_CHANNEL_IN_STEREO;
971 case AUDIO_CHANNEL_OUT_5POINT1:
972 return AUDIO_CHANNEL_IN_5POINT1;
973 case AUDIO_CHANNEL_OUT_3POINT1POINT2:
974 return AUDIO_CHANNEL_IN_3POINT1POINT2;
975 case AUDIO_CHANNEL_OUT_3POINT0POINT2:
976 return AUDIO_CHANNEL_IN_3POINT0POINT2;
977 case AUDIO_CHANNEL_OUT_2POINT1POINT2:
978 return AUDIO_CHANNEL_IN_2POINT1POINT2;
979 case AUDIO_CHANNEL_OUT_2POINT0POINT2:
980 return AUDIO_CHANNEL_IN_2POINT0POINT2;
981 default:
982 return AUDIO_CHANNEL_INVALID;
983 }
984 }
985
audio_channel_position_mask_is_out_canonical(audio_channel_mask_t channelMask)986 static inline bool audio_channel_position_mask_is_out_canonical(audio_channel_mask_t channelMask)
987 {
988 if (audio_channel_mask_get_representation(channelMask)
989 != AUDIO_CHANNEL_REPRESENTATION_POSITION) {
990 return false;
991 }
992 const uint32_t audioChannelCount = audio_channel_count_from_out_mask(
993 channelMask & ~AUDIO_CHANNEL_HAPTIC_ALL);
994 const uint32_t hapticChannelCount = audio_channel_count_from_out_mask(
995 channelMask & AUDIO_CHANNEL_HAPTIC_ALL);
996 return channelMask == (audio_channel_out_mask_from_count(audioChannelCount) |
997 haptic_channel_mask_from_count(hapticChannelCount));
998 }
999
audio_is_valid_format(audio_format_t format)1000 static inline bool audio_is_valid_format(audio_format_t format)
1001 {
1002 switch (format & AUDIO_FORMAT_MAIN_MASK) {
1003 case AUDIO_FORMAT_PCM:
1004 switch (format) {
1005 case AUDIO_FORMAT_PCM_16_BIT:
1006 case AUDIO_FORMAT_PCM_8_BIT:
1007 case AUDIO_FORMAT_PCM_32_BIT:
1008 case AUDIO_FORMAT_PCM_8_24_BIT:
1009 case AUDIO_FORMAT_PCM_FLOAT:
1010 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
1011 return true;
1012 default:
1013 return false;
1014 }
1015 /* not reached */
1016 case AUDIO_FORMAT_MP3:
1017 case AUDIO_FORMAT_AMR_NB:
1018 case AUDIO_FORMAT_AMR_WB:
1019 return true;
1020 case AUDIO_FORMAT_AAC:
1021 switch (format) {
1022 case AUDIO_FORMAT_AAC:
1023 case AUDIO_FORMAT_AAC_MAIN:
1024 case AUDIO_FORMAT_AAC_LC:
1025 case AUDIO_FORMAT_AAC_SSR:
1026 case AUDIO_FORMAT_AAC_LTP:
1027 case AUDIO_FORMAT_AAC_HE_V1:
1028 case AUDIO_FORMAT_AAC_SCALABLE:
1029 case AUDIO_FORMAT_AAC_ERLC:
1030 case AUDIO_FORMAT_AAC_LD:
1031 case AUDIO_FORMAT_AAC_HE_V2:
1032 case AUDIO_FORMAT_AAC_ELD:
1033 case AUDIO_FORMAT_AAC_XHE:
1034 return true;
1035 default:
1036 return false;
1037 }
1038 /* not reached */
1039 case AUDIO_FORMAT_HE_AAC_V1:
1040 case AUDIO_FORMAT_HE_AAC_V2:
1041 case AUDIO_FORMAT_VORBIS:
1042 case AUDIO_FORMAT_OPUS:
1043 case AUDIO_FORMAT_AC3:
1044 return true;
1045 case AUDIO_FORMAT_E_AC3:
1046 switch (format) {
1047 case AUDIO_FORMAT_E_AC3:
1048 case AUDIO_FORMAT_E_AC3_JOC:
1049 return true;
1050 default:
1051 return false;
1052 }
1053 /* not reached */
1054 case AUDIO_FORMAT_DTS:
1055 case AUDIO_FORMAT_DTS_HD:
1056 case AUDIO_FORMAT_IEC61937:
1057 case AUDIO_FORMAT_DOLBY_TRUEHD:
1058 case AUDIO_FORMAT_EVRC:
1059 case AUDIO_FORMAT_EVRCB:
1060 case AUDIO_FORMAT_EVRCWB:
1061 case AUDIO_FORMAT_EVRCNW:
1062 case AUDIO_FORMAT_AAC_ADIF:
1063 case AUDIO_FORMAT_WMA:
1064 case AUDIO_FORMAT_WMA_PRO:
1065 case AUDIO_FORMAT_AMR_WB_PLUS:
1066 case AUDIO_FORMAT_MP2:
1067 case AUDIO_FORMAT_QCELP:
1068 case AUDIO_FORMAT_DSD:
1069 case AUDIO_FORMAT_FLAC:
1070 case AUDIO_FORMAT_ALAC:
1071 case AUDIO_FORMAT_APE:
1072 return true;
1073 case AUDIO_FORMAT_AAC_ADTS:
1074 switch (format) {
1075 case AUDIO_FORMAT_AAC_ADTS:
1076 case AUDIO_FORMAT_AAC_ADTS_MAIN:
1077 case AUDIO_FORMAT_AAC_ADTS_LC:
1078 case AUDIO_FORMAT_AAC_ADTS_SSR:
1079 case AUDIO_FORMAT_AAC_ADTS_LTP:
1080 case AUDIO_FORMAT_AAC_ADTS_HE_V1:
1081 case AUDIO_FORMAT_AAC_ADTS_SCALABLE:
1082 case AUDIO_FORMAT_AAC_ADTS_ERLC:
1083 case AUDIO_FORMAT_AAC_ADTS_LD:
1084 case AUDIO_FORMAT_AAC_ADTS_HE_V2:
1085 case AUDIO_FORMAT_AAC_ADTS_ELD:
1086 case AUDIO_FORMAT_AAC_ADTS_XHE:
1087 return true;
1088 default:
1089 return false;
1090 }
1091 /* not reached */
1092 case AUDIO_FORMAT_SBC:
1093 case AUDIO_FORMAT_APTX:
1094 case AUDIO_FORMAT_APTX_HD:
1095 case AUDIO_FORMAT_AC4:
1096 case AUDIO_FORMAT_LDAC:
1097 return true;
1098 case AUDIO_FORMAT_MAT:
1099 switch (format) {
1100 case AUDIO_FORMAT_MAT:
1101 case AUDIO_FORMAT_MAT_1_0:
1102 case AUDIO_FORMAT_MAT_2_0:
1103 case AUDIO_FORMAT_MAT_2_1:
1104 return true;
1105 default:
1106 return false;
1107 }
1108 /* not reached */
1109 case AUDIO_FORMAT_AAC_LATM:
1110 switch (format) {
1111 case AUDIO_FORMAT_AAC_LATM:
1112 case AUDIO_FORMAT_AAC_LATM_LC:
1113 case AUDIO_FORMAT_AAC_LATM_HE_V1:
1114 case AUDIO_FORMAT_AAC_LATM_HE_V2:
1115 return true;
1116 default:
1117 return false;
1118 }
1119 /* not reached */
1120 case AUDIO_FORMAT_CELT:
1121 case AUDIO_FORMAT_APTX_ADAPTIVE:
1122 case AUDIO_FORMAT_LHDC:
1123 case AUDIO_FORMAT_LHDC_LL:
1124 case AUDIO_FORMAT_APTX_TWSP:
1125 return true;
1126 default:
1127 return false;
1128 }
1129 }
1130
1131 /**
1132 * Extract the primary format, eg. PCM, AC3, etc.
1133 */
audio_get_main_format(audio_format_t format)1134 static inline audio_format_t audio_get_main_format(audio_format_t format)
1135 {
1136 return (audio_format_t)(format & AUDIO_FORMAT_MAIN_MASK);
1137 }
1138
1139 /**
1140 * Is the data plain PCM samples that can be scaled and mixed?
1141 */
audio_is_linear_pcm(audio_format_t format)1142 static inline bool audio_is_linear_pcm(audio_format_t format)
1143 {
1144 return (audio_get_main_format(format) == AUDIO_FORMAT_PCM);
1145 }
1146
1147 /**
1148 * For this format, is the number of PCM audio frames directly proportional
1149 * to the number of data bytes?
1150 *
1151 * In other words, is the format transported as PCM audio samples,
1152 * but not necessarily scalable or mixable.
1153 * This returns true for real PCM, but also for AUDIO_FORMAT_IEC61937,
1154 * which is transported as 16 bit PCM audio, but where the encoded data
1155 * cannot be mixed or scaled.
1156 */
audio_has_proportional_frames(audio_format_t format)1157 static inline bool audio_has_proportional_frames(audio_format_t format)
1158 {
1159 audio_format_t mainFormat = audio_get_main_format(format);
1160 return (mainFormat == AUDIO_FORMAT_PCM
1161 || mainFormat == AUDIO_FORMAT_IEC61937);
1162 }
1163
audio_bytes_per_sample(audio_format_t format)1164 static inline size_t audio_bytes_per_sample(audio_format_t format)
1165 {
1166 size_t size = 0;
1167
1168 switch (format) {
1169 case AUDIO_FORMAT_PCM_32_BIT:
1170 case AUDIO_FORMAT_PCM_8_24_BIT:
1171 size = sizeof(int32_t);
1172 break;
1173 case AUDIO_FORMAT_PCM_24_BIT_PACKED:
1174 size = sizeof(uint8_t) * 3;
1175 break;
1176 case AUDIO_FORMAT_PCM_16_BIT:
1177 case AUDIO_FORMAT_IEC61937:
1178 size = sizeof(int16_t);
1179 break;
1180 case AUDIO_FORMAT_PCM_8_BIT:
1181 size = sizeof(uint8_t);
1182 break;
1183 case AUDIO_FORMAT_PCM_FLOAT:
1184 size = sizeof(float);
1185 break;
1186 default:
1187 break;
1188 }
1189 return size;
1190 }
1191
audio_bytes_per_frame(uint32_t channel_count,audio_format_t format)1192 static inline size_t audio_bytes_per_frame(uint32_t channel_count, audio_format_t format)
1193 {
1194 // cannot overflow for reasonable channel_count
1195 return channel_count * audio_bytes_per_sample(format);
1196 }
1197
1198 /* converts device address to string sent to audio HAL via set_parameters */
audio_device_address_to_parameter(audio_devices_t device,const char * address)1199 static inline char *audio_device_address_to_parameter(audio_devices_t device, const char *address)
1200 {
1201 const size_t kSize = AUDIO_DEVICE_MAX_ADDRESS_LEN + sizeof("a2dp_sink_address=");
1202 char param[kSize];
1203
1204 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1205 device &= ~AUDIO_DEVICE_BIT_IN;
1206 if (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP)
1207 snprintf(param, kSize, "%s=%s", "a2dp_source_address", address);
1208 else if (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX)
1209 snprintf(param, kSize, "%s=%s", "mix", address);
1210 else
1211 snprintf(param, kSize, "%s", address);
1212 } else {
1213 if (device & AUDIO_DEVICE_OUT_ALL_A2DP)
1214 snprintf(param, kSize, "%s=%s", "a2dp_sink_address", address);
1215 else if (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
1216 snprintf(param, kSize, "%s=%s", "mix", address);
1217 else
1218 snprintf(param, kSize, "%s", address);
1219 }
1220 return strdup(param);
1221 }
1222
audio_device_is_digital(audio_devices_t device)1223 static inline bool audio_device_is_digital(audio_devices_t device) {
1224 if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
1225 // input
1226 return (~AUDIO_DEVICE_BIT_IN & device & (AUDIO_DEVICE_IN_ALL_USB |
1227 AUDIO_DEVICE_IN_HDMI |
1228 AUDIO_DEVICE_IN_HDMI_ARC |
1229 AUDIO_DEVICE_IN_SPDIF |
1230 AUDIO_DEVICE_IN_IP |
1231 AUDIO_DEVICE_IN_BUS)) != 0;
1232 } else {
1233 // output
1234 return (device & (AUDIO_DEVICE_OUT_ALL_USB |
1235 AUDIO_DEVICE_OUT_HDMI |
1236 AUDIO_DEVICE_OUT_HDMI_ARC |
1237 AUDIO_DEVICE_OUT_SPDIF |
1238 AUDIO_DEVICE_OUT_IP |
1239 AUDIO_DEVICE_OUT_BUS)) != 0;
1240 }
1241 }
1242
1243 #ifndef AUDIO_NO_SYSTEM_DECLARATIONS
1244
audio_gain_config_are_equal(const struct audio_gain_config * lhs,const struct audio_gain_config * rhs)1245 static inline bool audio_gain_config_are_equal(
1246 const struct audio_gain_config *lhs, const struct audio_gain_config *rhs) {
1247 if (lhs->mode != rhs->mode) return false;
1248 switch (lhs->mode) {
1249 case AUDIO_GAIN_MODE_JOINT:
1250 if (lhs->values[0] != rhs->values[0]) return false;
1251 break;
1252 case AUDIO_GAIN_MODE_CHANNELS:
1253 case AUDIO_GAIN_MODE_RAMP:
1254 if (lhs->channel_mask != rhs->channel_mask) return false;
1255 for (int i = 0; i < popcount(lhs->channel_mask); ++i) {
1256 if (lhs->values[i] != rhs->values[i]) return false;
1257 }
1258 break;
1259 default: return false;
1260 }
1261 return lhs->ramp_duration_ms == rhs->ramp_duration_ms;
1262 }
1263
audio_port_config_has_input_direction(const struct audio_port_config * port_cfg)1264 static inline bool audio_port_config_has_input_direction(const struct audio_port_config *port_cfg) {
1265 switch (port_cfg->type) {
1266 case AUDIO_PORT_TYPE_DEVICE:
1267 switch (port_cfg->role) {
1268 case AUDIO_PORT_ROLE_SOURCE: return true;
1269 case AUDIO_PORT_ROLE_SINK: return false;
1270 default: return false;
1271 }
1272 case AUDIO_PORT_TYPE_MIX:
1273 switch (port_cfg->role) {
1274 case AUDIO_PORT_ROLE_SOURCE: return false;
1275 case AUDIO_PORT_ROLE_SINK: return true;
1276 default: return false;
1277 }
1278 default: return false;
1279 }
1280 }
1281
audio_port_configs_are_equal(const struct audio_port_config * lhs,const struct audio_port_config * rhs)1282 static inline bool audio_port_configs_are_equal(
1283 const struct audio_port_config *lhs, const struct audio_port_config *rhs) {
1284 if (lhs->role != rhs->role || lhs->type != rhs->type) return false;
1285 switch (lhs->type) {
1286 case AUDIO_PORT_TYPE_NONE: break;
1287 case AUDIO_PORT_TYPE_DEVICE:
1288 if (lhs->ext.device.hw_module != rhs->ext.device.hw_module ||
1289 lhs->ext.device.type != rhs->ext.device.type ||
1290 strncmp(lhs->ext.device.address, rhs->ext.device.address,
1291 AUDIO_DEVICE_MAX_ADDRESS_LEN) != 0) {
1292 return false;
1293 }
1294 break;
1295 case AUDIO_PORT_TYPE_MIX:
1296 if (lhs->ext.mix.hw_module != rhs->ext.mix.hw_module ||
1297 lhs->ext.mix.handle != rhs->ext.mix.handle) return false;
1298 if (lhs->role == AUDIO_PORT_ROLE_SOURCE &&
1299 lhs->ext.mix.usecase.stream != rhs->ext.mix.usecase.stream) return false;
1300 else if (lhs->role == AUDIO_PORT_ROLE_SINK &&
1301 lhs->ext.mix.usecase.source != rhs->ext.mix.usecase.source) return false;
1302 break;
1303 case AUDIO_PORT_TYPE_SESSION:
1304 if (lhs->ext.session.session != rhs->ext.session.session) return false;
1305 break;
1306 default: return false;
1307 }
1308 return lhs->config_mask == rhs->config_mask &&
1309 ((lhs->config_mask & AUDIO_PORT_CONFIG_SAMPLE_RATE) == 0 ||
1310 lhs->sample_rate == rhs->sample_rate) &&
1311 ((lhs->config_mask & AUDIO_PORT_CONFIG_CHANNEL_MASK) == 0 ||
1312 lhs->channel_mask == rhs->channel_mask) &&
1313 ((lhs->config_mask & AUDIO_PORT_CONFIG_FORMAT) == 0 ||
1314 lhs->format == rhs->format) &&
1315 ((lhs->config_mask & AUDIO_PORT_CONFIG_GAIN) == 0 ||
1316 audio_gain_config_are_equal(&lhs->gain, &rhs->gain)) &&
1317 ((lhs->config_mask & AUDIO_PORT_CONFIG_FLAGS) == 0 ||
1318 (audio_port_config_has_input_direction(lhs) ?
1319 lhs->flags.input == rhs->flags.input :
1320 lhs->flags.output == rhs->flags.output));
1321 }
1322
audio_port_config_has_hw_av_sync(const struct audio_port_config * port_cfg)1323 static inline bool audio_port_config_has_hw_av_sync(const struct audio_port_config *port_cfg) {
1324 if (!(port_cfg->config_mask & AUDIO_PORT_CONFIG_FLAGS)) {
1325 return false;
1326 }
1327 return audio_port_config_has_input_direction(port_cfg) ?
1328 port_cfg->flags.input & AUDIO_INPUT_FLAG_HW_AV_SYNC
1329 : port_cfg->flags.output & AUDIO_OUTPUT_FLAG_HW_AV_SYNC;
1330 }
1331
audio_patch_has_hw_av_sync(const struct audio_patch * patch)1332 static inline bool audio_patch_has_hw_av_sync(const struct audio_patch *patch) {
1333 for (unsigned int i = 0; i < patch->num_sources; ++i) {
1334 if (audio_port_config_has_hw_av_sync(&patch->sources[i])) return true;
1335 }
1336 for (unsigned int i = 0; i < patch->num_sinks; ++i) {
1337 if (audio_port_config_has_hw_av_sync(&patch->sinks[i])) return true;
1338 }
1339 return false;
1340 }
1341
audio_patch_is_valid(const struct audio_patch * patch)1342 static inline bool audio_patch_is_valid(const struct audio_patch *patch) {
1343 // Note that patch can have no sinks.
1344 return patch->num_sources != 0 && patch->num_sources <= AUDIO_PATCH_PORTS_MAX &&
1345 patch->num_sinks <= AUDIO_PATCH_PORTS_MAX;
1346 }
1347
1348 // Note that when checking for equality the order of ports must match.
1349 // Patches will not be equivalent if they contain the same ports but they are permuted differently.
audio_patches_are_equal(const struct audio_patch * lhs,const struct audio_patch * rhs)1350 static inline bool audio_patches_are_equal(
1351 const struct audio_patch *lhs, const struct audio_patch *rhs) {
1352 if (!audio_patch_is_valid(lhs) || !audio_patch_is_valid(rhs)) return false;
1353 if (lhs->num_sources != rhs->num_sources || lhs->num_sinks != rhs->num_sinks) return false;
1354 for (unsigned int i = 0; i < lhs->num_sources; ++i) {
1355 if (!audio_port_configs_are_equal(&lhs->sources[i], &rhs->sources[i])) return false;
1356 }
1357 for (unsigned int i = 0; i < lhs->num_sinks; ++i) {
1358 if (!audio_port_configs_are_equal(&lhs->sinks[i], &rhs->sinks[i])) return false;
1359 }
1360 return true;
1361 }
1362
1363 #endif
1364
1365 // Unique effect ID (can be generated from the following site:
1366 // http://www.itu.int/ITU-T/asn1/uuid.html)
1367 // This struct is used for effects identification and in soundtrigger.
1368 typedef struct audio_uuid_s {
1369 uint32_t timeLow;
1370 uint16_t timeMid;
1371 uint16_t timeHiAndVersion;
1372 uint16_t clockSeq;
1373 uint8_t node[6];
1374 } audio_uuid_t;
1375
1376 //TODO: audio_microphone_location_t need to move to HAL v4.0
1377 typedef enum {
1378 AUDIO_MICROPHONE_LOCATION_UNKNOWN = 0,
1379 AUDIO_MICROPHONE_LOCATION_MAINBODY = 1,
1380 AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE = 2,
1381 AUDIO_MICROPHONE_LOCATION_PERIPHERAL = 3,
1382 AUDIO_MICROPHONE_LOCATION_CNT = 4,
1383 } audio_microphone_location_t;
1384
1385 //TODO: audio_microphone_directionality_t need to move to HAL v4.0
1386 typedef enum {
1387 AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN = 0,
1388 AUDIO_MICROPHONE_DIRECTIONALITY_OMNI = 1,
1389 AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL = 2,
1390 AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID = 3,
1391 AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID = 4,
1392 AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID = 5,
1393 AUDIO_MICROPHONE_DIRECTIONALITY_CNT = 6,
1394 } audio_microphone_directionality_t;
1395
1396 /* A 3D point which could be used to represent geometric location
1397 * or orientation of a microphone.
1398 */
1399 struct audio_microphone_coordinate {
1400 float x;
1401 float y;
1402 float z;
1403 };
1404
1405 /* An number to indicate which group the microphone locate. Main body is
1406 * usually group 0. Developer could use this value to group the microphones
1407 * that locate on the same peripheral or attachments.
1408 */
1409 typedef int audio_microphone_group_t;
1410
1411 typedef enum {
1412 AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED = 0,
1413 AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT = 1,
1414 AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED = 2,
1415 AUDIO_MICROPHONE_CHANNEL_MAPPING_CNT = 3,
1416 } audio_microphone_channel_mapping_t;
1417
1418 /* the maximum length for the microphone id */
1419 #define AUDIO_MICROPHONE_ID_MAX_LEN 32
1420 /* max number of frequency responses in a frequency response table */
1421 #define AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES 256
1422 /* max number of microphone */
1423 #define AUDIO_MICROPHONE_MAX_COUNT 32
1424 /* the value of unknown spl */
1425 #define AUDIO_MICROPHONE_SPL_UNKNOWN -FLT_MAX
1426 /* the value of unknown sensitivity */
1427 #define AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN -FLT_MAX
1428 /* the value of unknown coordinate */
1429 #define AUDIO_MICROPHONE_COORDINATE_UNKNOWN -FLT_MAX
1430 /* the value used as address when the address of bottom microphone is empty */
1431 #define AUDIO_BOTTOM_MICROPHONE_ADDRESS "bottom"
1432 /* the value used as address when the address of back microphone is empty */
1433 #define AUDIO_BACK_MICROPHONE_ADDRESS "back"
1434
1435 struct audio_microphone_characteristic_t {
1436 char device_id[AUDIO_MICROPHONE_ID_MAX_LEN];
1437 audio_port_handle_t id;
1438 audio_devices_t device;
1439 char address[AUDIO_DEVICE_MAX_ADDRESS_LEN];
1440 audio_microphone_channel_mapping_t channel_mapping[AUDIO_CHANNEL_COUNT_MAX];
1441 audio_microphone_location_t location;
1442 audio_microphone_group_t group;
1443 unsigned int index_in_the_group;
1444 float sensitivity;
1445 float max_spl;
1446 float min_spl;
1447 audio_microphone_directionality_t directionality;
1448 unsigned int num_frequency_responses;
1449 float frequency_responses[2][AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES];
1450 struct audio_microphone_coordinate geometric_location;
1451 struct audio_microphone_coordinate orientation;
1452 };
1453
1454 __END_DECLS
1455
1456 /**
1457 * List of known audio HAL modules. This is the base name of the audio HAL
1458 * library composed of the "audio." prefix, one of the base names below and
1459 * a suffix specific to the device.
1460 * e.g: audio.primary.goldfish.so or audio.a2dp.default.so
1461 *
1462 * The same module names are used in audio policy configuration files.
1463 */
1464
1465 #define AUDIO_HARDWARE_MODULE_ID_PRIMARY "primary"
1466 #define AUDIO_HARDWARE_MODULE_ID_A2DP "a2dp"
1467 #define AUDIO_HARDWARE_MODULE_ID_USB "usb"
1468 #define AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX "r_submix"
1469 #define AUDIO_HARDWARE_MODULE_ID_CODEC_OFFLOAD "codec_offload"
1470 #define AUDIO_HARDWARE_MODULE_ID_STUB "stub"
1471 #define AUDIO_HARDWARE_MODULE_ID_HEARING_AID "hearing_aid"
1472 #define AUDIO_HARDWARE_MODULE_ID_MSD "msd"
1473
1474 /**
1475 * Multi-Stream Decoder (MSD) HAL service name. MSD HAL is used to mix
1476 * encoded streams together with PCM streams, producing re-encoded
1477 * streams or PCM streams.
1478 *
1479 * The service must register itself using this name, and audioserver
1480 * tries to instantiate a device factory using this name as well.
1481 * Note that the HIDL implementation library file name *must* have the
1482 * suffix "msd" in order to be picked up by HIDL that is:
1483 *
1484 * android.hardware.audio@x.x-implmsd.so
1485 */
1486 #define AUDIO_HAL_SERVICE_NAME_MSD "msd"
1487
1488 /**
1489 * Parameter definitions.
1490 * Note that in the framework code it's recommended to use AudioParameter.h
1491 * instead of these preprocessor defines, and for sure avoid just copying
1492 * the constant values.
1493 */
1494
1495 #define AUDIO_PARAMETER_VALUE_ON "on"
1496 #define AUDIO_PARAMETER_VALUE_OFF "off"
1497
1498 /**
1499 * audio device parameters
1500 */
1501
1502 /* BT SCO Noise Reduction + Echo Cancellation parameters */
1503 #define AUDIO_PARAMETER_KEY_BT_NREC "bt_headset_nrec"
1504
1505 /* Get a new HW synchronization source identifier.
1506 * Return a valid source (positive integer) or AUDIO_HW_SYNC_INVALID if an error occurs
1507 * or no HW sync is available. */
1508 #define AUDIO_PARAMETER_HW_AV_SYNC "hw_av_sync"
1509
1510 /* Screen state */
1511 #define AUDIO_PARAMETER_KEY_SCREEN_STATE "screen_state"
1512
1513 /* User's preferred audio language setting (in ISO 639-2/T three-letter string code)
1514 * used to select a specific language presentation for next generation audio codecs. */
1515 #define AUDIO_PARAMETER_KEY_AUDIO_LANGUAGE_PREFERRED "audio_language_preferred"
1516
1517 /**
1518 * audio stream parameters
1519 */
1520
1521 #define AUDIO_PARAMETER_STREAM_ROUTING "routing" /* audio_devices_t */
1522 #define AUDIO_PARAMETER_STREAM_FORMAT "format" /* audio_format_t */
1523 #define AUDIO_PARAMETER_STREAM_CHANNELS "channels" /* audio_channel_mask_t */
1524 #define AUDIO_PARAMETER_STREAM_FRAME_COUNT "frame_count" /* size_t */
1525 #define AUDIO_PARAMETER_STREAM_INPUT_SOURCE "input_source" /* audio_source_t */
1526 #define AUDIO_PARAMETER_STREAM_SAMPLING_RATE "sampling_rate" /* uint32_t */
1527
1528 /* Request the presentation id to be decoded by a next gen audio decoder */
1529 #define AUDIO_PARAMETER_STREAM_PRESENTATION_ID "presentation_id" /* int32_t */
1530
1531 /* Request the program id to be decoded by a next gen audio decoder */
1532 #define AUDIO_PARAMETER_STREAM_PROGRAM_ID "program_id" /* int32_t */
1533
1534 #define AUDIO_PARAMETER_DEVICE_CONNECT "connect" /* audio_devices_t */
1535 #define AUDIO_PARAMETER_DEVICE_DISCONNECT "disconnect" /* audio_devices_t */
1536
1537 /* Enable mono audio playback if 1, else should be 0. */
1538 #define AUDIO_PARAMETER_MONO_OUTPUT "mono_output"
1539
1540 /* Set the HW synchronization source for an output stream. */
1541 #define AUDIO_PARAMETER_STREAM_HW_AV_SYNC "hw_av_sync"
1542
1543 /* Query supported formats. The response is a '|' separated list of strings from
1544 * audio_format_t enum e.g: "sup_formats=AUDIO_FORMAT_PCM_16_BIT" */
1545 #define AUDIO_PARAMETER_STREAM_SUP_FORMATS "sup_formats"
1546 /* Query supported channel masks. The response is a '|' separated list of strings from
1547 * audio_channel_mask_t enum e.g: "sup_channels=AUDIO_CHANNEL_OUT_STEREO|AUDIO_CHANNEL_OUT_MONO" */
1548 #define AUDIO_PARAMETER_STREAM_SUP_CHANNELS "sup_channels"
1549 /* Query supported sampling rates. The response is a '|' separated list of integer values e.g:
1550 * "sup_sampling_rates=44100|48000" */
1551 #define AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES "sup_sampling_rates"
1552
1553 #define AUDIO_PARAMETER_VALUE_LIST_SEPARATOR "|"
1554
1555 /* Reconfigure offloaded A2DP codec */
1556 #define AUDIO_PARAMETER_RECONFIG_A2DP "reconfigA2dp"
1557 /* Query if HwModule supports reconfiguration of offloaded A2DP codec */
1558 #define AUDIO_PARAMETER_A2DP_RECONFIG_SUPPORTED "isReconfigA2dpSupported"
1559
1560 /**
1561 * audio codec parameters
1562 */
1563
1564 #define AUDIO_OFFLOAD_CODEC_PARAMS "music_offload_codec_param"
1565 #define AUDIO_OFFLOAD_CODEC_BIT_PER_SAMPLE "music_offload_bit_per_sample"
1566 #define AUDIO_OFFLOAD_CODEC_BIT_RATE "music_offload_bit_rate"
1567 #define AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE "music_offload_avg_bit_rate"
1568 #define AUDIO_OFFLOAD_CODEC_ID "music_offload_codec_id"
1569 #define AUDIO_OFFLOAD_CODEC_BLOCK_ALIGN "music_offload_block_align"
1570 #define AUDIO_OFFLOAD_CODEC_SAMPLE_RATE "music_offload_sample_rate"
1571 #define AUDIO_OFFLOAD_CODEC_ENCODE_OPTION "music_offload_encode_option"
1572 #define AUDIO_OFFLOAD_CODEC_NUM_CHANNEL "music_offload_num_channels"
1573 #define AUDIO_OFFLOAD_CODEC_DOWN_SAMPLING "music_offload_down_sampling"
1574 #define AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES "delay_samples"
1575 #define AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES "padding_samples"
1576
1577 #endif // ANDROID_AUDIO_CORE_H
1578