From: Mikhail Naganov Date: Tue, 11 Oct 2016 00:23:05 +0000 (-0700) Subject: Remove redundant prefixes from enums in audio common types and effects HAL X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=c1158951544817f1433c68aaef3e1f42ab6e780e;p=android-x86%2Fhardware-interfaces.git Remove redundant prefixes from enums in audio common types and effects HAL Since in generated C++ code class enums are used, the names of enum values are scoped anyway, thus carrying the prefix only clutters code. For C enums, newly introduced "value_prefix" annotation is used to add the required prefix. Added annotations for effects HAL types are just informational, but can be used would C headers generation ever be required. Also: - renamed AudioInputFlags -> AudioInputFlag for consistency; - moved AUDIO_INTERLEAVE_... constants into their own enum. Bug: 31800672 Change-Id: I5b325f3440e0057ca98c4617040c7e5a89d2283d Test: make --- diff --git a/audio/common/2.0/types.hal b/audio/common/2.0/types.hal index dd75706c..a5ec68d0 100644 --- a/audio/common/2.0/types.hal +++ b/audio/common/2.0/types.hal @@ -85,90 +85,88 @@ struct Uuid { /* * Audio stream type describing the intented use case of a stream. */ -@export(name="audio_stream_type_t") +@export(name="audio_stream_type_t", value_prefix="AUDIO_STREAM_") enum AudioStreamType : int32_t { // These values must kept in sync with // frameworks/base/media/java/android/media/AudioSystem.java // TODO: Synchronization should be done automatically by tools - AUDIO_STREAM_DEFAULT = -1, - AUDIO_STREAM_MIN = 0, - AUDIO_STREAM_VOICE_CALL = 0, - AUDIO_STREAM_SYSTEM = 1, - AUDIO_STREAM_RING = 2, - AUDIO_STREAM_MUSIC = 3, - AUDIO_STREAM_ALARM = 4, - AUDIO_STREAM_NOTIFICATION = 5, - AUDIO_STREAM_BLUETOOTH_SCO = 6, - AUDIO_STREAM_ENFORCED_AUDIBLE = 7, // Sounds that cannot be muted by user - // and must be routed to speaker - AUDIO_STREAM_DTMF = 8, - AUDIO_STREAM_TTS = 9, // Transmitted Through Speaker - // Plays over speaker only, silent - // on other devices - AUDIO_STREAM_ACCESSIBILITY = 10, // For accessibility talk back prompts - AUDIO_STREAM_REROUTING = 11, // For dynamic policy output mixes - AUDIO_STREAM_PATCH = 12, // For internal audio flinger tracks. - // Fixed volume - AUDIO_STREAM_PUBLIC_CNT = AUDIO_STREAM_TTS + 1, + DEFAULT = -1, + MIN = 0, + VOICE_CALL = 0, + SYSTEM = 1, + RING = 2, + MUSIC = 3, + ALARM = 4, + NOTIFICATION = 5, + BLUETOOTH_SCO = 6, + ENFORCED_AUDIBLE = 7, // Sounds that cannot be muted by user and must be + // routed to speaker + DTMF = 8, + TTS = 9, // Transmitted Through Speaker. Plays over speaker + // only, silent on other devices + ACCESSIBILITY = 10, // For accessibility talk back prompts + REROUTING = 11, // For dynamic policy output mixes + PATCH = 12, // For internal audio flinger tracks. Fixed volume + PUBLIC_CNT = TTS + 1, // Number of streams considered by audio policy for volume and routing - AUDIO_STREAM_FOR_POLICY_CNT = AUDIO_STREAM_PATCH, - AUDIO_STREAM_CNT = AUDIO_STREAM_PATCH + 1 + FOR_POLICY_CNT = PATCH, + CNT = PATCH + 1 }; -@export(name="audio_source_t") +@export(name="audio_source_t", value_prefix="AUDIO_SOURCE_") enum AudioSource { // These values must kept in sync with // frameworks/base/media/java/android/media/MediaRecorder.java, // frameworks/av/services/audiopolicy/AudioPolicyService.cpp, // system/media/audio_effects/include/audio_effects/audio_effects_conf.h - AUDIO_SOURCE_DEFAULT = 0, - AUDIO_SOURCE_MIC = 1, - AUDIO_SOURCE_VOICE_UPLINK = 2, - AUDIO_SOURCE_VOICE_DOWNLINK = 3, - AUDIO_SOURCE_VOICE_CALL = 4, - AUDIO_SOURCE_CAMCORDER = 5, - AUDIO_SOURCE_VOICE_RECOGNITION = 6, - AUDIO_SOURCE_VOICE_COMMUNICATION = 7, + DEFAULT = 0, + MIC = 1, + VOICE_UPLINK = 2, + VOICE_DOWNLINK = 3, + VOICE_CALL = 4, + CAMCORDER = 5, + VOICE_RECOGNITION = 6, + VOICE_COMMUNICATION = 7, /* * Source for the mix to be presented remotely. An example of remote * presentation is Wifi Display where a dongle attached to a TV can be used * to play the mix captured by this audio source. */ - AUDIO_SOURCE_REMOTE_SUBMIX = 8, + REMOTE_SUBMIX = 8, /* * Source for unprocessed sound. Usage examples include level measurement * and raw signal analysis. */ - AUDIO_SOURCE_UNPROCESSED = 9, + UNPROCESSED = 9, - AUDIO_SOURCE_CNT, - AUDIO_SOURCE_MAX = AUDIO_SOURCE_CNT - 1, - AUDIO_SOURCE_FM_TUNER = 1998, + CNT, + MAX = CNT - 1, + FM_TUNER = 1998, /* * A low-priority, preemptible audio source for for background software - * hotword detection. Same tuning as AUDIO_SOURCE_VOICE_RECOGNITION. - * Used only internally to the framework. + * hotword detection. Same tuning as VOICE_RECOGNITION. Used only + * internally by the framework. */ - AUDIO_SOURCE_HOTWORD = 1999 + HOTWORD = 1999 }; typedef int32_t AudioSession; /* * Special audio session values. */ -@export(name="audio_session_t") +@export(name="audio_session_t", value_prefix="AUDIO_SESSION_") enum AudioSessionConsts : int32_t { /* * Session for effects attached to a particular output stream * (value must be less than 0) */ - AUDIO_SESSION_OUTPUT_STAGE = -1, + OUTPUT_STAGE = -1, /* * Session for effects applied to output mix. These effects can * be moved by audio policy manager to another output stream * (value must be 0) */ - AUDIO_SESSION_OUTPUT_MIX = 0, + OUTPUT_MIX = 0, /* * Application does not specify an explicit session ID to be used, and * requests a new session ID to be allocated TODO use unique values for @@ -177,13 +175,13 @@ enum AudioSessionConsts : int32_t { * Corresponds to AudioManager.AUDIO_SESSION_ID_GENERATE and * AudioSystem.AUDIO_SESSION_ALLOCATE. */ - AUDIO_SESSION_ALLOCATE = 0, + ALLOCATE = 0, /* * For use with AudioRecord::start(), this indicates no trigger session. * It is also used with output tracks and patch tracks, which never have a * session. */ - AUDIO_SESSION_NONE = 0 + NONE = 0 }; /* @@ -197,91 +195,73 @@ enum AudioSessionConsts : int32_t { * also be used for certain formats to give informations not present in the * encoded audio stream (e.g. octet alignement for AMR). */ -@export(name="audio_format_t") +@export(name="audio_format_t", value_prefix="AUDIO_FORMAT_") enum AudioFormat : uint32_t { - AUDIO_FORMAT_INVALID = 0xFFFFFFFFUL, - AUDIO_FORMAT_DEFAULT = 0, - AUDIO_FORMAT_PCM = 0x00000000UL, /* DO NOT CHANGE */ - AUDIO_FORMAT_MP3 = 0x01000000UL, - AUDIO_FORMAT_AMR_NB = 0x02000000UL, - AUDIO_FORMAT_AMR_WB = 0x03000000UL, - AUDIO_FORMAT_AAC = 0x04000000UL, - /* Deprecated, Use AUDIO_FORMAT_AAC_HE_V1*/ - AUDIO_FORMAT_HE_AAC_V1 = 0x05000000UL, - /* Deprecated, Use AUDIO_FORMAT_AAC_HE_V2*/ - AUDIO_FORMAT_HE_AAC_V2 = 0x06000000UL, - AUDIO_FORMAT_VORBIS = 0x07000000UL, - AUDIO_FORMAT_OPUS = 0x08000000UL, - AUDIO_FORMAT_AC3 = 0x09000000UL, - AUDIO_FORMAT_E_AC3 = 0x0A000000UL, - AUDIO_FORMAT_DTS = 0x0B000000UL, - AUDIO_FORMAT_DTS_HD = 0x0C000000UL, + INVALID = 0xFFFFFFFFUL, + DEFAULT = 0, + PCM = 0x00000000UL, /* DO NOT CHANGE */ + MP3 = 0x01000000UL, + AMR_NB = 0x02000000UL, + AMR_WB = 0x03000000UL, + AAC = 0x04000000UL, + HE_AAC_V1 = 0x05000000UL, /* Deprecated, Use AAC_HE_V1*/ + HE_AAC_V2 = 0x06000000UL, /* Deprecated, Use AAC_HE_V2*/ + VORBIS = 0x07000000UL, + OPUS = 0x08000000UL, + AC3 = 0x09000000UL, + E_AC3 = 0x0A000000UL, + DTS = 0x0B000000UL, + DTS_HD = 0x0C000000UL, // IEC61937 is encoded audio wrapped in 16-bit PCM. - AUDIO_FORMAT_IEC61937 = 0x0D000000UL, - AUDIO_FORMAT_DOLBY_TRUEHD = 0x0E000000UL, - AUDIO_FORMAT_MAIN_MASK = 0xFF000000UL, /* Deprecated */ - AUDIO_FORMAT_SUB_MASK = 0x00FFFFFFUL, + IEC61937 = 0x0D000000UL, + DOLBY_TRUEHD = 0x0E000000UL, + MAIN_MASK = 0xFF000000UL, /* Deprecated */ + SUB_MASK = 0x00FFFFFFUL, /* Subformats */ - AUDIO_FORMAT_PCM_SUB_16_BIT = 0x1, // PCM signed 16 bits - AUDIO_FORMAT_PCM_SUB_8_BIT = 0x2, // PCM unsigned 8 bits - AUDIO_FORMAT_PCM_SUB_32_BIT = 0x3, // PCM signed .31 fixed point - AUDIO_FORMAT_PCM_SUB_8_24_BIT = 0x4, // PCM signed 8.23 fixed point - AUDIO_FORMAT_PCM_SUB_FLOAT = 0x5, // PCM single-precision float pt - AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED = 0x6, // PCM signed .23 fix pt (3 bytes) - - AUDIO_FORMAT_MP3_SUB_NONE = 0x0, - - AUDIO_FORMAT_AMR_SUB_NONE = 0x0, - - AUDIO_FORMAT_AAC_SUB_MAIN = 0x1, - AUDIO_FORMAT_AAC_SUB_LC = 0x2, - AUDIO_FORMAT_AAC_SUB_SSR = 0x4, - AUDIO_FORMAT_AAC_SUB_LTP = 0x8, - AUDIO_FORMAT_AAC_SUB_HE_V1 = 0x10, - AUDIO_FORMAT_AAC_SUB_SCALABLE = 0x20, - AUDIO_FORMAT_AAC_SUB_ERLC = 0x40, - AUDIO_FORMAT_AAC_SUB_LD = 0x80, - AUDIO_FORMAT_AAC_SUB_HE_V2 = 0x100, - AUDIO_FORMAT_AAC_SUB_ELD = 0x200, - - AUDIO_FORMAT_VORBIS_SUB_NONE = 0x0, + PCM_SUB_16_BIT = 0x1, // PCM signed 16 bits + PCM_SUB_8_BIT = 0x2, // PCM unsigned 8 bits + PCM_SUB_32_BIT = 0x3, // PCM signed .31 fixed point + PCM_SUB_8_24_BIT = 0x4, // PCM signed 8.23 fixed point + PCM_SUB_FLOAT = 0x5, // PCM single-precision float pt + PCM_SUB_24_BIT_PACKED = 0x6, // PCM signed .23 fix pt (3 bytes) + + MP3_SUB_NONE = 0x0, + + AMR_SUB_NONE = 0x0, + + AAC_SUB_MAIN = 0x1, + AAC_SUB_LC = 0x2, + AAC_SUB_SSR = 0x4, + AAC_SUB_LTP = 0x8, + AAC_SUB_HE_V1 = 0x10, + AAC_SUB_SCALABLE = 0x20, + AAC_SUB_ERLC = 0x40, + AAC_SUB_LD = 0x80, + AAC_SUB_HE_V2 = 0x100, + AAC_SUB_ELD = 0x200, + + VORBIS_SUB_NONE = 0x0, /* Aliases */ /* note != AudioFormat.ENCODING_PCM_16BIT */ - AUDIO_FORMAT_PCM_16_BIT = (AUDIO_FORMAT_PCM | - AUDIO_FORMAT_PCM_SUB_16_BIT), + PCM_16_BIT = (PCM | PCM_SUB_16_BIT), /* note != AudioFormat.ENCODING_PCM_8BIT */ - AUDIO_FORMAT_PCM_8_BIT = (AUDIO_FORMAT_PCM | - AUDIO_FORMAT_PCM_SUB_8_BIT), - AUDIO_FORMAT_PCM_32_BIT = (AUDIO_FORMAT_PCM | - AUDIO_FORMAT_PCM_SUB_32_BIT), - AUDIO_FORMAT_PCM_8_24_BIT = (AUDIO_FORMAT_PCM | - AUDIO_FORMAT_PCM_SUB_8_24_BIT), - AUDIO_FORMAT_PCM_FLOAT = (AUDIO_FORMAT_PCM | - AUDIO_FORMAT_PCM_SUB_FLOAT), - AUDIO_FORMAT_PCM_24_BIT_PACKED = (AUDIO_FORMAT_PCM | - AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED), - AUDIO_FORMAT_AAC_MAIN = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_MAIN), - AUDIO_FORMAT_AAC_LC = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_LC), - AUDIO_FORMAT_AAC_SSR = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_SSR), - AUDIO_FORMAT_AAC_LTP = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_LTP), - AUDIO_FORMAT_AAC_HE_V1 = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_HE_V1), - AUDIO_FORMAT_AAC_SCALABLE = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_SCALABLE), - AUDIO_FORMAT_AAC_ERLC = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_ERLC), - AUDIO_FORMAT_AAC_LD = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_LD), - AUDIO_FORMAT_AAC_HE_V2 = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_HE_V2), - AUDIO_FORMAT_AAC_ELD = (AUDIO_FORMAT_AAC | - AUDIO_FORMAT_AAC_SUB_ELD) + PCM_8_BIT = (PCM | PCM_SUB_8_BIT), + PCM_32_BIT = (PCM | PCM_SUB_32_BIT), + PCM_8_24_BIT = (PCM | PCM_SUB_8_24_BIT), + PCM_FLOAT = (PCM | PCM_SUB_FLOAT), + PCM_24_BIT_PACKED = (PCM | PCM_SUB_24_BIT_PACKED), + AAC_MAIN = (AAC | AAC_SUB_MAIN), + AAC_LC = (AAC | AAC_SUB_LC), + AAC_SSR = (AAC | AAC_SUB_SSR), + AAC_LTP = (AAC | AAC_SUB_LTP), + AAC_HE_V1 = (AAC | AAC_SUB_HE_V1), + AAC_SCALABLE = (AAC | AAC_SUB_SCALABLE), + AAC_ERLC = (AAC | AAC_SUB_ERLC), + AAC_LD = (AAC | AAC_SUB_LD), + AAC_HE_V2 = (AAC | AAC_SUB_HE_V2), + AAC_ELD = (AAC | AAC_SUB_ELD) }; /* @@ -304,15 +284,15 @@ enum FixedChannelCount { * * These are the current representations: * - * AUDIO_CHANNEL_REPRESENTATION_POSITION + * REPRESENTATION_POSITION * is a channel mask representation for position assignment. Each low-order * bit corresponds to the spatial position of a transducer (output), or * interpretation of channel (input). The user of a channel mask needs to * know the context of whether it is for output or input. The constants - * AUDIO_CHANNEL_OUT_* or AUDIO_CHANNEL_IN_* apply to the bits portion. It - * is not permitted for no bits to be set. + * OUT_* or IN_* apply to the bits portion. It is not permitted for no bits + * to be set. * - * AUDIO_CHANNEL_REPRESENTATION_INDEX + * REPRESENTATION_INDEX * is a channel mask representation for index assignment. Each low-order * bit corresponds to a selected channel. There is no platform * interpretation of the various bits. There is no concept of output or @@ -326,314 +306,282 @@ enum FixedChannelCount { * checking the channel mask, the implementer should look for ways to fix it * with additional information outside of the mask. */ -@export(name="") +@export(name="", value_prefix="AUDIO_CHANNEL_") enum AudioChannelMask : uint32_t { - AUDIO_CHANNEL_REPRESENTATION_POSITION = 0, /* must be 0 for compatibility */ + REPRESENTATION_POSITION = 0, /* must be 0 for compatibility */ /* 1 is reserved for future use */ - AUDIO_CHANNEL_REPRESENTATION_INDEX = 2, + REPRESENTATION_INDEX = 2, /* 3 is reserved for future use */ /* These can be a complete value of AudioChannelMask */ - AUDIO_CHANNEL_NONE = 0x0, - AUDIO_CHANNEL_INVALID = 0xC0000000, + NONE = 0x0, + INVALID = 0xC0000000, /* * These can be the bits portion of an AudioChannelMask - * with representation AUDIO_CHANNEL_REPRESENTATION_POSITION. + * with representation REPRESENTATION_POSITION. */ /* output channels */ - AUDIO_CHANNEL_OUT_FRONT_LEFT = 0x1, - AUDIO_CHANNEL_OUT_FRONT_RIGHT = 0x2, - AUDIO_CHANNEL_OUT_FRONT_CENTER = 0x4, - AUDIO_CHANNEL_OUT_LOW_FREQUENCY = 0x8, - AUDIO_CHANNEL_OUT_BACK_LEFT = 0x10, - AUDIO_CHANNEL_OUT_BACK_RIGHT = 0x20, - AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x40, - AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x80, - AUDIO_CHANNEL_OUT_BACK_CENTER = 0x100, - AUDIO_CHANNEL_OUT_SIDE_LEFT = 0x200, - AUDIO_CHANNEL_OUT_SIDE_RIGHT = 0x400, - AUDIO_CHANNEL_OUT_TOP_CENTER = 0x800, - AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT = 0x1000, - AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER = 0x2000, - AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT = 0x4000, - AUDIO_CHANNEL_OUT_TOP_BACK_LEFT = 0x8000, - AUDIO_CHANNEL_OUT_TOP_BACK_CENTER = 0x10000, - AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT = 0x20000, - - AUDIO_CHANNEL_OUT_MONO = AUDIO_CHANNEL_OUT_FRONT_LEFT, - AUDIO_CHANNEL_OUT_STEREO = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT), - AUDIO_CHANNEL_OUT_QUAD = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT | - AUDIO_CHANNEL_OUT_BACK_LEFT | - AUDIO_CHANNEL_OUT_BACK_RIGHT), - AUDIO_CHANNEL_OUT_QUAD_BACK = AUDIO_CHANNEL_OUT_QUAD, - /* like AUDIO_CHANNEL_OUT_QUAD_BACK with *_SIDE_* instead of *_BACK_* */ - AUDIO_CHANNEL_OUT_QUAD_SIDE = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT | - AUDIO_CHANNEL_OUT_SIDE_LEFT | - AUDIO_CHANNEL_OUT_SIDE_RIGHT), - AUDIO_CHANNEL_OUT_5POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT | - AUDIO_CHANNEL_OUT_FRONT_CENTER | - AUDIO_CHANNEL_OUT_LOW_FREQUENCY | - AUDIO_CHANNEL_OUT_BACK_LEFT | - AUDIO_CHANNEL_OUT_BACK_RIGHT), - AUDIO_CHANNEL_OUT_5POINT1_BACK = AUDIO_CHANNEL_OUT_5POINT1, - /* like AUDIO_CHANNEL_OUT_5POINT1_BACK with *_SIDE_* instead of *_BACK_* */ - AUDIO_CHANNEL_OUT_5POINT1_SIDE = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT | - AUDIO_CHANNEL_OUT_FRONT_CENTER | - AUDIO_CHANNEL_OUT_LOW_FREQUENCY | - AUDIO_CHANNEL_OUT_SIDE_LEFT | - AUDIO_CHANNEL_OUT_SIDE_RIGHT), + OUT_FRONT_LEFT = 0x1, + OUT_FRONT_RIGHT = 0x2, + OUT_FRONT_CENTER = 0x4, + OUT_LOW_FREQUENCY = 0x8, + OUT_BACK_LEFT = 0x10, + OUT_BACK_RIGHT = 0x20, + OUT_FRONT_LEFT_OF_CENTER = 0x40, + OUT_FRONT_RIGHT_OF_CENTER = 0x80, + OUT_BACK_CENTER = 0x100, + OUT_SIDE_LEFT = 0x200, + OUT_SIDE_RIGHT = 0x400, + OUT_TOP_CENTER = 0x800, + OUT_TOP_FRONT_LEFT = 0x1000, + OUT_TOP_FRONT_CENTER = 0x2000, + OUT_TOP_FRONT_RIGHT = 0x4000, + OUT_TOP_BACK_LEFT = 0x8000, + OUT_TOP_BACK_CENTER = 0x10000, + OUT_TOP_BACK_RIGHT = 0x20000, + + OUT_MONO = OUT_FRONT_LEFT, + OUT_STEREO = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT), + OUT_QUAD = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | + OUT_BACK_LEFT | OUT_BACK_RIGHT), + OUT_QUAD_BACK = OUT_QUAD, + /* like OUT_QUAD_BACK with *_SIDE_* instead of *_BACK_* */ + OUT_QUAD_SIDE = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | + OUT_SIDE_LEFT | OUT_SIDE_RIGHT), + OUT_5POINT1 = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | + OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | + OUT_BACK_LEFT | OUT_BACK_RIGHT), + OUT_5POINT1_BACK = OUT_5POINT1, + /* like OUT_5POINT1_BACK with *_SIDE_* instead of *_BACK_* */ + OUT_5POINT1_SIDE = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | + OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | + OUT_SIDE_LEFT | OUT_SIDE_RIGHT), /* matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND */ - AUDIO_CHANNEL_OUT_7POINT1 = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT | - AUDIO_CHANNEL_OUT_FRONT_CENTER | - AUDIO_CHANNEL_OUT_LOW_FREQUENCY | - AUDIO_CHANNEL_OUT_BACK_LEFT | - AUDIO_CHANNEL_OUT_BACK_RIGHT | - AUDIO_CHANNEL_OUT_SIDE_LEFT | - AUDIO_CHANNEL_OUT_SIDE_RIGHT), - AUDIO_CHANNEL_OUT_ALL = (AUDIO_CHANNEL_OUT_FRONT_LEFT | - AUDIO_CHANNEL_OUT_FRONT_RIGHT | - AUDIO_CHANNEL_OUT_FRONT_CENTER | - AUDIO_CHANNEL_OUT_LOW_FREQUENCY | - AUDIO_CHANNEL_OUT_BACK_LEFT | - AUDIO_CHANNEL_OUT_BACK_RIGHT | - AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER | - AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER | - AUDIO_CHANNEL_OUT_BACK_CENTER| - AUDIO_CHANNEL_OUT_SIDE_LEFT| - AUDIO_CHANNEL_OUT_SIDE_RIGHT| - AUDIO_CHANNEL_OUT_TOP_CENTER| - AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT| - AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER| - AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT| - AUDIO_CHANNEL_OUT_TOP_BACK_LEFT| - AUDIO_CHANNEL_OUT_TOP_BACK_CENTER| - AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT), + OUT_7POINT1 = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | + OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | + OUT_BACK_LEFT | OUT_BACK_RIGHT | + OUT_SIDE_LEFT | OUT_SIDE_RIGHT), + OUT_ALL = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | + OUT_FRONT_CENTER | OUT_LOW_FREQUENCY | + OUT_BACK_LEFT | OUT_BACK_RIGHT | + OUT_FRONT_LEFT_OF_CENTER | OUT_FRONT_RIGHT_OF_CENTER | + OUT_BACK_CENTER | + OUT_SIDE_LEFT | OUT_SIDE_RIGHT | + OUT_TOP_CENTER | + OUT_TOP_FRONT_LEFT | OUT_TOP_FRONT_CENTER | OUT_TOP_FRONT_RIGHT | + OUT_TOP_BACK_LEFT | OUT_TOP_BACK_CENTER | OUT_TOP_BACK_RIGHT), /* These are bits only, not complete values */ /* input channels */ - AUDIO_CHANNEL_IN_LEFT = 0x4, - AUDIO_CHANNEL_IN_RIGHT = 0x8, - AUDIO_CHANNEL_IN_FRONT = 0x10, - AUDIO_CHANNEL_IN_BACK = 0x20, - AUDIO_CHANNEL_IN_LEFT_PROCESSED = 0x40, - AUDIO_CHANNEL_IN_RIGHT_PROCESSED = 0x80, - AUDIO_CHANNEL_IN_FRONT_PROCESSED = 0x100, - AUDIO_CHANNEL_IN_BACK_PROCESSED = 0x200, - AUDIO_CHANNEL_IN_PRESSURE = 0x400, - AUDIO_CHANNEL_IN_X_AXIS = 0x800, - AUDIO_CHANNEL_IN_Y_AXIS = 0x1000, - AUDIO_CHANNEL_IN_Z_AXIS = 0x2000, - AUDIO_CHANNEL_IN_VOICE_UPLINK = 0x4000, - AUDIO_CHANNEL_IN_VOICE_DNLINK = 0x8000, - - AUDIO_CHANNEL_IN_MONO = AUDIO_CHANNEL_IN_FRONT, - AUDIO_CHANNEL_IN_STEREO = (AUDIO_CHANNEL_IN_LEFT | AUDIO_CHANNEL_IN_RIGHT), - AUDIO_CHANNEL_IN_FRONT_BACK = (AUDIO_CHANNEL_IN_FRONT | - AUDIO_CHANNEL_IN_BACK), - AUDIO_CHANNEL_IN_ALL = (AUDIO_CHANNEL_IN_LEFT | - AUDIO_CHANNEL_IN_RIGHT | - AUDIO_CHANNEL_IN_FRONT | - AUDIO_CHANNEL_IN_BACK| - AUDIO_CHANNEL_IN_LEFT_PROCESSED | - AUDIO_CHANNEL_IN_RIGHT_PROCESSED | - AUDIO_CHANNEL_IN_FRONT_PROCESSED | - AUDIO_CHANNEL_IN_BACK_PROCESSED| - AUDIO_CHANNEL_IN_PRESSURE | - AUDIO_CHANNEL_IN_X_AXIS | - AUDIO_CHANNEL_IN_Y_AXIS | - AUDIO_CHANNEL_IN_Z_AXIS | - AUDIO_CHANNEL_IN_VOICE_UPLINK | - AUDIO_CHANNEL_IN_VOICE_DNLINK), + IN_LEFT = 0x4, + IN_RIGHT = 0x8, + IN_FRONT = 0x10, + IN_BACK = 0x20, + IN_LEFT_PROCESSED = 0x40, + IN_RIGHT_PROCESSED = 0x80, + IN_FRONT_PROCESSED = 0x100, + IN_BACK_PROCESSED = 0x200, + IN_PRESSURE = 0x400, + IN_X_AXIS = 0x800, + IN_Y_AXIS = 0x1000, + IN_Z_AXIS = 0x2000, + IN_VOICE_UPLINK = 0x4000, + IN_VOICE_DNLINK = 0x8000, + + IN_MONO = IN_FRONT, + IN_STEREO = (IN_LEFT | IN_RIGHT), + IN_FRONT_BACK = (IN_FRONT | IN_BACK), + IN_ALL = (IN_LEFT | IN_RIGHT | IN_FRONT | IN_BACK| + IN_LEFT_PROCESSED | IN_RIGHT_PROCESSED | + IN_FRONT_PROCESSED | IN_BACK_PROCESSED| + IN_PRESSURE | + IN_X_AXIS | IN_Y_AXIS | IN_Z_AXIS | + IN_VOICE_UPLINK | IN_VOICE_DNLINK), + + COUNT_MAX = 30, + INDEX_HDR = REPRESENTATION_INDEX << COUNT_MAX, + INDEX_MASK_1 = INDEX_HDR | ((1 << 1) - 1), + INDEX_MASK_2 = INDEX_HDR | ((1 << 2) - 1), + INDEX_MASK_3 = INDEX_HDR | ((1 << 3) - 1), + INDEX_MASK_4 = INDEX_HDR | ((1 << 4) - 1), + INDEX_MASK_5 = INDEX_HDR | ((1 << 5) - 1), + INDEX_MASK_6 = INDEX_HDR | ((1 << 6) - 1), + INDEX_MASK_7 = INDEX_HDR | ((1 << 7) - 1), + INDEX_MASK_8 = INDEX_HDR | ((1 << 8) - 1) +}; - /* - * Expresses the convention when stereo audio samples are stored interleaved - * in an array. This should improve readability by allowing code to use - * symbolic indices instead of hard-coded [0] and [1]. - * - * For multi-channel beyond stereo, the platform convention is that channels - * are interleaved in order from least significant channel mask bit to most - * significant channel mask bit, with unused bits skipped. Any exceptions - * to this convention will be noted at the appropriate API. - */ - AUDIO_INTERLEAVE_LEFT = 0, - AUDIO_INTERLEAVE_RIGHT = 1, - - AUDIO_CHANNEL_COUNT_MAX = 30, - AUDIO_CHANNEL_INDEX_HDR = - AUDIO_CHANNEL_REPRESENTATION_INDEX << AUDIO_CHANNEL_COUNT_MAX, - AUDIO_CHANNEL_INDEX_MASK_1 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 1) - 1), - AUDIO_CHANNEL_INDEX_MASK_2 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 2) - 1), - AUDIO_CHANNEL_INDEX_MASK_3 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 3) - 1), - AUDIO_CHANNEL_INDEX_MASK_4 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 4) - 1), - AUDIO_CHANNEL_INDEX_MASK_5 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 5) - 1), - AUDIO_CHANNEL_INDEX_MASK_6 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 6) - 1), - AUDIO_CHANNEL_INDEX_MASK_7 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 7) - 1), - AUDIO_CHANNEL_INDEX_MASK_8 = AUDIO_CHANNEL_INDEX_HDR | ((1 << 8) - 1) + +/* + * Expresses the convention when stereo audio samples are stored interleaved + * in an array. This should improve readability by allowing code to use + * symbolic indices instead of hard-coded [0] and [1]. + * + * For multi-channel beyond stereo, the platform convention is that channels + * are interleaved in order from least significant channel mask bit to most + * significant channel mask bit, with unused bits skipped. Any exceptions + * to this convention will be noted at the appropriate API. + */ +@export(name="", value_prefix="AUDIO_INTERLEAVE_") +enum AudioInterleave { + LEFT = 0, + RIGHT = 1, }; /* * Major modes for a mobile device. The current mode setting affects audio * routing. */ -@export(name="audio_mode_t") +@export(name="audio_mode_t", value_prefix="AUDIO_MODE_") enum AudioMode { - AUDIO_MODE_INVALID = -2, - AUDIO_MODE_CURRENT = -1, - AUDIO_MODE_NORMAL = 0, - AUDIO_MODE_RINGTONE = 1, - AUDIO_MODE_IN_CALL = 2, - AUDIO_MODE_IN_COMMUNICATION = 3, - - AUDIO_MODE_CNT, - AUDIO_MODE_MAX = AUDIO_MODE_CNT - 1, + INVALID = -2, + CURRENT = -1, + NORMAL = 0, + RINGTONE = 1, + IN_CALL = 2, + IN_COMMUNICATION = 3, + + CNT, + MAX = CNT - 1, }; -@export(name="") +@export(name="", value_prefix="AUDIO_DEVICE_") enum AudioDevice : uint32_t { - AUDIO_DEVICE_NONE = 0x0, + NONE = 0x0, /* reserved bits */ - AUDIO_DEVICE_BIT_IN = 0x80000000, - AUDIO_DEVICE_BIT_DEFAULT = 0x40000000, + BIT_IN = 0x80000000, + BIT_DEFAULT = 0x40000000, /* output devices */ - AUDIO_DEVICE_OUT_EARPIECE = 0x1, - AUDIO_DEVICE_OUT_SPEAKER = 0x2, - AUDIO_DEVICE_OUT_WIRED_HEADSET = 0x4, - AUDIO_DEVICE_OUT_WIRED_HEADPHONE = 0x8, - AUDIO_DEVICE_OUT_BLUETOOTH_SCO = 0x10, - AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20, - AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40, - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP = 0x80, - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100, - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200, - AUDIO_DEVICE_OUT_AUX_DIGITAL = 0x400, - AUDIO_DEVICE_OUT_HDMI = AUDIO_DEVICE_OUT_AUX_DIGITAL, + OUT_EARPIECE = 0x1, + OUT_SPEAKER = 0x2, + OUT_WIRED_HEADSET = 0x4, + OUT_WIRED_HEADPHONE = 0x8, + OUT_BLUETOOTH_SCO = 0x10, + OUT_BLUETOOTH_SCO_HEADSET = 0x20, + OUT_BLUETOOTH_SCO_CARKIT = 0x40, + OUT_BLUETOOTH_A2DP = 0x80, + OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100, + OUT_BLUETOOTH_A2DP_SPEAKER = 0x200, + OUT_AUX_DIGITAL = 0x400, + OUT_HDMI = OUT_AUX_DIGITAL, /* uses an analog connection (multiplexed over the USB pins for instance) */ - AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800, - AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000, + OUT_ANLG_DOCK_HEADSET = 0x800, + OUT_DGTL_DOCK_HEADSET = 0x1000, /* USB accessory mode: Android device is USB device and dock is USB host */ - AUDIO_DEVICE_OUT_USB_ACCESSORY = 0x2000, + OUT_USB_ACCESSORY = 0x2000, /* USB host mode: Android device is USB host and dock is USB device */ - AUDIO_DEVICE_OUT_USB_DEVICE = 0x4000, - AUDIO_DEVICE_OUT_REMOTE_SUBMIX = 0x8000, + OUT_USB_DEVICE = 0x4000, + OUT_REMOTE_SUBMIX = 0x8000, /* Telephony voice TX path */ - AUDIO_DEVICE_OUT_TELEPHONY_TX = 0x10000, + OUT_TELEPHONY_TX = 0x10000, /* Analog jack with line impedance detected */ - AUDIO_DEVICE_OUT_LINE = 0x20000, + OUT_LINE = 0x20000, /* HDMI Audio Return Channel */ - AUDIO_DEVICE_OUT_HDMI_ARC = 0x40000, + OUT_HDMI_ARC = 0x40000, /* S/PDIF out */ - AUDIO_DEVICE_OUT_SPDIF = 0x80000, + OUT_SPDIF = 0x80000, /* FM transmitter out */ - AUDIO_DEVICE_OUT_FM = 0x100000, + OUT_FM = 0x100000, /* Line out for av devices */ - AUDIO_DEVICE_OUT_AUX_LINE = 0x200000, + OUT_AUX_LINE = 0x200000, /* limited-output speaker device for acoustic safety */ - AUDIO_DEVICE_OUT_SPEAKER_SAFE = 0x400000, - AUDIO_DEVICE_OUT_IP = 0x800000, + OUT_SPEAKER_SAFE = 0x400000, + OUT_IP = 0x800000, /* audio bus implemented by the audio system (e.g an MOST stereo channel) */ - AUDIO_DEVICE_OUT_BUS = 0x1000000, - AUDIO_DEVICE_OUT_DEFAULT = AUDIO_DEVICE_BIT_DEFAULT, - AUDIO_DEVICE_OUT_ALL = (AUDIO_DEVICE_OUT_EARPIECE | - AUDIO_DEVICE_OUT_SPEAKER | - AUDIO_DEVICE_OUT_WIRED_HEADSET | - AUDIO_DEVICE_OUT_WIRED_HEADPHONE | - AUDIO_DEVICE_OUT_BLUETOOTH_SCO | - AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET | - AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT | - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP | - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER | - AUDIO_DEVICE_OUT_HDMI | - AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET | - AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET | - AUDIO_DEVICE_OUT_USB_ACCESSORY | - AUDIO_DEVICE_OUT_USB_DEVICE | - AUDIO_DEVICE_OUT_REMOTE_SUBMIX | - AUDIO_DEVICE_OUT_TELEPHONY_TX | - AUDIO_DEVICE_OUT_LINE | - AUDIO_DEVICE_OUT_HDMI_ARC | - AUDIO_DEVICE_OUT_SPDIF | - AUDIO_DEVICE_OUT_FM | - AUDIO_DEVICE_OUT_AUX_LINE | - AUDIO_DEVICE_OUT_SPEAKER_SAFE | - AUDIO_DEVICE_OUT_IP | - AUDIO_DEVICE_OUT_BUS | - AUDIO_DEVICE_OUT_DEFAULT), - AUDIO_DEVICE_OUT_ALL_A2DP = (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP | - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | - AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER), - AUDIO_DEVICE_OUT_ALL_SCO = (AUDIO_DEVICE_OUT_BLUETOOTH_SCO | - AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET | - AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT), - AUDIO_DEVICE_OUT_ALL_USB = (AUDIO_DEVICE_OUT_USB_ACCESSORY | - AUDIO_DEVICE_OUT_USB_DEVICE), + OUT_BUS = 0x1000000, + OUT_DEFAULT = BIT_DEFAULT, + OUT_ALL = (OUT_EARPIECE | + OUT_SPEAKER | + OUT_WIRED_HEADSET | + OUT_WIRED_HEADPHONE | + OUT_BLUETOOTH_SCO | + OUT_BLUETOOTH_SCO_HEADSET | + OUT_BLUETOOTH_SCO_CARKIT | + OUT_BLUETOOTH_A2DP | + OUT_BLUETOOTH_A2DP_HEADPHONES | + OUT_BLUETOOTH_A2DP_SPEAKER | + OUT_HDMI | + OUT_ANLG_DOCK_HEADSET | + OUT_DGTL_DOCK_HEADSET | + OUT_USB_ACCESSORY | + OUT_USB_DEVICE | + OUT_REMOTE_SUBMIX | + OUT_TELEPHONY_TX | + OUT_LINE | + OUT_HDMI_ARC | + OUT_SPDIF | + OUT_FM | + OUT_AUX_LINE | + OUT_SPEAKER_SAFE | + OUT_IP | + OUT_BUS | + OUT_DEFAULT), + OUT_ALL_A2DP = (OUT_BLUETOOTH_A2DP | + OUT_BLUETOOTH_A2DP_HEADPHONES | + OUT_BLUETOOTH_A2DP_SPEAKER), + OUT_ALL_SCO = (OUT_BLUETOOTH_SCO | + OUT_BLUETOOTH_SCO_HEADSET | + OUT_BLUETOOTH_SCO_CARKIT), + OUT_ALL_USB = (OUT_USB_ACCESSORY | OUT_USB_DEVICE), /* input devices */ - AUDIO_DEVICE_IN_COMMUNICATION = AUDIO_DEVICE_BIT_IN | 0x1, - AUDIO_DEVICE_IN_AMBIENT = AUDIO_DEVICE_BIT_IN | 0x2, - AUDIO_DEVICE_IN_BUILTIN_MIC = AUDIO_DEVICE_BIT_IN | 0x4, - AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET = AUDIO_DEVICE_BIT_IN | 0x8, - AUDIO_DEVICE_IN_WIRED_HEADSET = AUDIO_DEVICE_BIT_IN | 0x10, - AUDIO_DEVICE_IN_AUX_DIGITAL = AUDIO_DEVICE_BIT_IN | 0x20, - AUDIO_DEVICE_IN_HDMI = AUDIO_DEVICE_IN_AUX_DIGITAL, + IN_COMMUNICATION = BIT_IN | 0x1, + IN_AMBIENT = BIT_IN | 0x2, + IN_BUILTIN_MIC = BIT_IN | 0x4, + IN_BLUETOOTH_SCO_HEADSET = BIT_IN | 0x8, + IN_WIRED_HEADSET = BIT_IN | 0x10, + IN_AUX_DIGITAL = BIT_IN | 0x20, + IN_HDMI = IN_AUX_DIGITAL, /* Telephony voice RX path */ - AUDIO_DEVICE_IN_VOICE_CALL = AUDIO_DEVICE_BIT_IN | 0x40, - AUDIO_DEVICE_IN_TELEPHONY_RX = AUDIO_DEVICE_IN_VOICE_CALL, - AUDIO_DEVICE_IN_BACK_MIC = AUDIO_DEVICE_BIT_IN | 0x80, - AUDIO_DEVICE_IN_REMOTE_SUBMIX = AUDIO_DEVICE_BIT_IN | 0x100, - AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x200, - AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET = AUDIO_DEVICE_BIT_IN | 0x400, - AUDIO_DEVICE_IN_USB_ACCESSORY = AUDIO_DEVICE_BIT_IN | 0x800, - AUDIO_DEVICE_IN_USB_DEVICE = AUDIO_DEVICE_BIT_IN | 0x1000, + IN_VOICE_CALL = BIT_IN | 0x40, + IN_TELEPHONY_RX = IN_VOICE_CALL, + IN_BACK_MIC = BIT_IN | 0x80, + IN_REMOTE_SUBMIX = BIT_IN | 0x100, + IN_ANLG_DOCK_HEADSET = BIT_IN | 0x200, + IN_DGTL_DOCK_HEADSET = BIT_IN | 0x400, + IN_USB_ACCESSORY = BIT_IN | 0x800, + IN_USB_DEVICE = BIT_IN | 0x1000, /* FM tuner input */ - AUDIO_DEVICE_IN_FM_TUNER = AUDIO_DEVICE_BIT_IN | 0x2000, + IN_FM_TUNER = BIT_IN | 0x2000, /* TV tuner input */ - AUDIO_DEVICE_IN_TV_TUNER = AUDIO_DEVICE_BIT_IN | 0x4000, + IN_TV_TUNER = BIT_IN | 0x4000, /* Analog jack with line impedance detected */ - AUDIO_DEVICE_IN_LINE = AUDIO_DEVICE_BIT_IN | 0x8000, + IN_LINE = BIT_IN | 0x8000, /* S/PDIF in */ - AUDIO_DEVICE_IN_SPDIF = AUDIO_DEVICE_BIT_IN | 0x10000, - AUDIO_DEVICE_IN_BLUETOOTH_A2DP = AUDIO_DEVICE_BIT_IN | 0x20000, - AUDIO_DEVICE_IN_LOOPBACK = AUDIO_DEVICE_BIT_IN | 0x40000, - AUDIO_DEVICE_IN_IP = AUDIO_DEVICE_BIT_IN | 0x80000, + IN_SPDIF = BIT_IN | 0x10000, + IN_BLUETOOTH_A2DP = BIT_IN | 0x20000, + IN_LOOPBACK = BIT_IN | 0x40000, + IN_IP = BIT_IN | 0x80000, /* audio bus implemented by the audio system (e.g an MOST stereo channel) */ - AUDIO_DEVICE_IN_BUS = AUDIO_DEVICE_BIT_IN | 0x100000, - AUDIO_DEVICE_IN_DEFAULT = AUDIO_DEVICE_BIT_IN | - AUDIO_DEVICE_BIT_DEFAULT, - - AUDIO_DEVICE_IN_ALL = (AUDIO_DEVICE_IN_COMMUNICATION | - AUDIO_DEVICE_IN_AMBIENT | - AUDIO_DEVICE_IN_BUILTIN_MIC | - AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET | - AUDIO_DEVICE_IN_WIRED_HEADSET | - AUDIO_DEVICE_IN_HDMI | - AUDIO_DEVICE_IN_TELEPHONY_RX | - AUDIO_DEVICE_IN_BACK_MIC | - AUDIO_DEVICE_IN_REMOTE_SUBMIX | - AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET | - AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET | - AUDIO_DEVICE_IN_USB_ACCESSORY | - AUDIO_DEVICE_IN_USB_DEVICE | - AUDIO_DEVICE_IN_FM_TUNER | - AUDIO_DEVICE_IN_TV_TUNER | - AUDIO_DEVICE_IN_LINE | - AUDIO_DEVICE_IN_SPDIF | - AUDIO_DEVICE_IN_BLUETOOTH_A2DP | - AUDIO_DEVICE_IN_LOOPBACK | - AUDIO_DEVICE_IN_IP | - AUDIO_DEVICE_IN_BUS | - AUDIO_DEVICE_IN_DEFAULT), - AUDIO_DEVICE_IN_ALL_SCO = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, - AUDIO_DEVICE_IN_ALL_USB = (AUDIO_DEVICE_IN_USB_ACCESSORY | - AUDIO_DEVICE_IN_USB_DEVICE), + IN_BUS = BIT_IN | 0x100000, + IN_DEFAULT = BIT_IN | + BIT_DEFAULT, + + IN_ALL = (IN_COMMUNICATION | + IN_AMBIENT | + IN_BUILTIN_MIC | + IN_BLUETOOTH_SCO_HEADSET | + IN_WIRED_HEADSET | + IN_HDMI | + IN_TELEPHONY_RX | + IN_BACK_MIC | + IN_REMOTE_SUBMIX | + IN_ANLG_DOCK_HEADSET | + IN_DGTL_DOCK_HEADSET | + IN_USB_ACCESSORY | + IN_USB_DEVICE | + IN_FM_TUNER | + IN_TV_TUNER | + IN_LINE | + IN_SPDIF | + IN_BLUETOOTH_A2DP | + IN_LOOPBACK | + IN_IP | + IN_BUS | + IN_DEFAULT), + IN_ALL_SCO = IN_BLUETOOTH_SCO_HEADSET, + IN_ALL_USB = (IN_USB_ACCESSORY | IN_USB_DEVICE), }; /* @@ -649,31 +597,28 @@ enum AudioDevice : uint32_t { * The audio policy manager will try to match the flags in the request * (when getOuput() is called) to an available output stream. */ -@export(name="audio_output_flags_t") +@export(name="audio_output_flags_t", value_prefix="AUDIO_OUTPUT_FLAG_") enum AudioOutputFlag { - AUDIO_OUTPUT_FLAG_NONE = 0x0, // no attributes - AUDIO_OUTPUT_FLAG_DIRECT = 0x1, // this output directly connects a track - // to one output stream: no software mixer - AUDIO_OUTPUT_FLAG_PRIMARY = 0x2, // this output is the primary output of - // the device. It is unique and must be - // present. It is opened by default and - // receives routing, audio mode and volume - // controls related to voice calls. - AUDIO_OUTPUT_FLAG_FAST = 0x4, // output supports "fast tracks", - // defined elsewhere - AUDIO_OUTPUT_FLAG_DEEP_BUFFER = 0x8, // use deep audio buffers - AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD = 0x10, // offload playback of compressed - // streams to hardware codec - AUDIO_OUTPUT_FLAG_NON_BLOCKING = 0x20, // use non-blocking write - AUDIO_OUTPUT_FLAG_HW_AV_SYNC = 0x40, // output uses a hardware A/V sync - AUDIO_OUTPUT_FLAG_TTS = 0x80, // output for streams transmitted through - // speaker at a sample rate high enough - // to accommodate lower-range ultrasonic p/b - AUDIO_OUTPUT_FLAG_RAW = 0x100, // minimize signal processing - AUDIO_OUTPUT_FLAG_SYNC = 0x200, // synchronize I/O streams - AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO = 0x400, // Audio stream contains - // compressed audio in - // SPDIF data bursts, not PCM. + NONE = 0x0, // no attributes + DIRECT = 0x1, // this output directly connects a track + // to one output stream: no software mixer + PRIMARY = 0x2, // this output is the primary output of the device. It is + // unique and must be present. It is opened by default and + // receives routing, audio mode and volume controls related + // to voice calls. + FAST = 0x4, // output supports "fast tracks", defined elsewhere + DEEP_BUFFER = 0x8, // use deep audio buffers + COMPRESS_OFFLOAD = 0x10, // offload playback of compressed streams to + // hardware codec + NON_BLOCKING = 0x20, // use non-blocking write + HW_AV_SYNC = 0x40, // output uses a hardware A/V sync + TTS = 0x80, // output for streams transmitted through speaker at a + // sample rate high enough to accommodate lower-range + // ultrasonic p/b + RAW = 0x100, // minimize signal processing + SYNC = 0x200, // synchronize I/O streams + IEC958_NONAUDIO = 0x400, // Audio stream contains compressed audio in SPDIF + // data bursts, not PCM. }; /* @@ -682,15 +627,13 @@ enum AudioOutputFlag { * to indicate a preference to be connected to an input stream with * attributes corresponding to the specified flags. */ -@export(name="audio_input_flags_t") -enum AudioInputFlags { - AUDIO_INPUT_FLAG_NONE = 0x0, // no attributes - AUDIO_INPUT_FLAG_FAST = 0x1, // prefer an input that supports - // "fast tracks" - AUDIO_INPUT_FLAG_HW_HOTWORD = 0x2, // prefer an input that captures from - // hw hotword source - AUDIO_INPUT_FLAG_RAW = 0x4, // minimize signal processing - AUDIO_INPUT_FLAG_SYNC = 0x8, // synchronize I/O streams +@export(name="audio_input_flags_t", value_prefix="AUDIO_INPUT_FLAG_") +enum AudioInputFlag { + NONE = 0x0, // no attributes + FAST = 0x1, // prefer an input that supports "fast tracks" + HW_HOTWORD = 0x2, // prefer an input that captures from hw hotword source + RAW = 0x4, // minimize signal processing + SYNC = 0x8, // synchronize I/O streams }; /* @@ -728,11 +671,11 @@ struct AudioConfig { /* * Type of gain control exposed by an audio port. */ -@export(name="") +@export(name="", value_prefix="AUDIO_GAIN_MODE_") enum AudioGainMode : uint32_t { - AUDIO_GAIN_MODE_JOINT = 0x1, // supports joint channel gain control - AUDIO_GAIN_MODE_CHANNELS = 0x2, // supports separate channel gain control - AUDIO_GAIN_MODE_RAMP = 0x4 // supports gain ramps + JOINT = 0x1, // supports joint channel gain control + CHANNELS = 0x2, // supports separate channel gain control + RAMP = 0x4 // supports gain ramps }; /* @@ -785,24 +728,23 @@ struct AudioGainConfig { */ /* Audio port role: either source or sink */ -@export(name="audio_port_role_t") +@export(name="audio_port_role_t", value_prefix="AUDIO_PORT_ROLE_") enum AudioPortRole { - AUDIO_PORT_ROLE_NONE, - AUDIO_PORT_ROLE_SOURCE, - AUDIO_PORT_ROLE_SINK, + NONE, + SOURCE, + SINK, }; /* - * Audio port type indicates if it is a session (e.g AudioTrack), - * a mix (e.g PlaybackThread output) or a physical device - * (e.g AUDIO_DEVICE_OUT_SPEAKER) + * Audio port type indicates if it is a session (e.g AudioTrack), a mix (e.g + * PlaybackThread output) or a physical device (e.g OUT_SPEAKER) */ -@export(name="audio_port_type_t") +@export(name="audio_port_type_t", value_prefix="AUDIO_PORT_TYPE_") enum AudioPortType { - AUDIO_PORT_TYPE_NONE, - AUDIO_PORT_TYPE_DEVICE, - AUDIO_PORT_TYPE_MIX, - AUDIO_PORT_TYPE_SESSION, + NONE, + DEVICE, + MIX, + SESSION, }; /* @@ -811,7 +753,7 @@ enum AudioPortType { */ struct AudioPortConfigDeviceExt { AudioModuleHandle hwModule; // module the device is attached to - AudioDevice type; // device type (e.g AUDIO_DEVICE_OUT_SPEAKER) + AudioDevice type; // device type (e.g OUT_SPEAKER) uint8_t[32] address; // device address. "" if N/A }; @@ -826,16 +768,13 @@ struct AudioPortConfigSessionExt { /* * Flags indicating which fields are to be considered in AudioPortConfig. */ -@export(name="") +@export(name="", value_prefix="AUDIO_PORT_CONFIG_") enum AudioPortConfigMask : uint32_t { - AUDIO_PORT_CONFIG_SAMPLE_RATE = 0x1, - AUDIO_PORT_CONFIG_CHANNEL_MASK = 0x2, - AUDIO_PORT_CONFIG_FORMAT = 0x4, - AUDIO_PORT_CONFIG_GAIN = 0x8, - AUDIO_PORT_CONFIG_ALL = AUDIO_PORT_CONFIG_SAMPLE_RATE | - AUDIO_PORT_CONFIG_CHANNEL_MASK | - AUDIO_PORT_CONFIG_FORMAT | - AUDIO_PORT_CONFIG_GAIN + SAMPLE_RATE = 0x1, + CHANNEL_MASK = 0x2, + FORMAT = 0x4, + GAIN = 0x8, + ALL = SAMPLE_RATE | CHANNEL_MASK | FORMAT | GAIN }; /* @@ -877,10 +816,10 @@ struct AudioPortDeviceExt { /* * Latency class of the audio mix. */ -@export(name="audio_mix_latency_class_t") +@export(name="audio_mix_latency_class_t", value_prefix="AUDIO_LATENCY_") enum AudioMixLatencyClass { - AUDIO_LATENCY_LOW, - AUDIO_LATENCY_NORMAL + LOW, + NORMAL } ; struct AudioPortMixExt { diff --git a/audio/effect/2.0/types.hal b/audio/effect/2.0/types.hal index 3560382f..82f6766a 100644 --- a/audio/effect/2.0/types.hal +++ b/audio/effect/2.0/types.hal @@ -108,109 +108,90 @@ enum Result { * | | | have to implement a process function. * +----------------+--------+-------------------------------------------------- */ -// TODO(mnaganov): Consider if "EFFECT_FLAG_" prefix can be dropped. +@export(name="", value_prefix="EFFECT_FLAG_") enum EffectFlags { // Insert mode - EFFECT_FLAG_TYPE_SHIFT = 0, - EFFECT_FLAG_TYPE_SIZE = 3, - EFFECT_FLAG_TYPE_MASK = - ((1 << EFFECT_FLAG_TYPE_SIZE) -1) << EFFECT_FLAG_TYPE_SHIFT, - EFFECT_FLAG_TYPE_INSERT = 0 << EFFECT_FLAG_TYPE_SHIFT, - EFFECT_FLAG_TYPE_AUXILIARY = 1 << EFFECT_FLAG_TYPE_SHIFT, - EFFECT_FLAG_TYPE_REPLACE = 2 << EFFECT_FLAG_TYPE_SHIFT, - EFFECT_FLAG_TYPE_PRE_PROC = 3 << EFFECT_FLAG_TYPE_SHIFT, - EFFECT_FLAG_TYPE_POST_PROC = 4 << EFFECT_FLAG_TYPE_SHIFT, + TYPE_SHIFT = 0, + TYPE_SIZE = 3, + TYPE_MASK = ((1 << TYPE_SIZE) -1) << TYPE_SHIFT, + TYPE_INSERT = 0 << TYPE_SHIFT, + TYPE_AUXILIARY = 1 << TYPE_SHIFT, + TYPE_REPLACE = 2 << TYPE_SHIFT, + TYPE_PRE_PROC = 3 << TYPE_SHIFT, + TYPE_POST_PROC = 4 << TYPE_SHIFT, // Insert preference - EFFECT_FLAG_INSERT_SHIFT = EFFECT_FLAG_TYPE_SHIFT + EFFECT_FLAG_TYPE_SIZE, - EFFECT_FLAG_INSERT_SIZE = 3, - EFFECT_FLAG_INSERT_MASK = - ((1 << EFFECT_FLAG_INSERT_SIZE) -1) << EFFECT_FLAG_INSERT_SHIFT, - EFFECT_FLAG_INSERT_ANY = 0 << EFFECT_FLAG_INSERT_SHIFT, - EFFECT_FLAG_INSERT_FIRST = 1 << EFFECT_FLAG_INSERT_SHIFT, - EFFECT_FLAG_INSERT_LAST = 2 << EFFECT_FLAG_INSERT_SHIFT, - EFFECT_FLAG_INSERT_EXCLUSIVE = 3 << EFFECT_FLAG_INSERT_SHIFT, + INSERT_SHIFT = TYPE_SHIFT + TYPE_SIZE, + INSERT_SIZE = 3, + INSERT_MASK = ((1 << INSERT_SIZE) -1) << INSERT_SHIFT, + INSERT_ANY = 0 << INSERT_SHIFT, + INSERT_FIRST = 1 << INSERT_SHIFT, + INSERT_LAST = 2 << INSERT_SHIFT, + INSERT_EXCLUSIVE = 3 << INSERT_SHIFT, // Volume control - EFFECT_FLAG_VOLUME_SHIFT = - EFFECT_FLAG_INSERT_SHIFT + EFFECT_FLAG_INSERT_SIZE, - EFFECT_FLAG_VOLUME_SIZE = 3, - EFFECT_FLAG_VOLUME_MASK = - ((1 << EFFECT_FLAG_VOLUME_SIZE) -1) << EFFECT_FLAG_VOLUME_SHIFT, - EFFECT_FLAG_VOLUME_CTRL = 1 << EFFECT_FLAG_VOLUME_SHIFT, - EFFECT_FLAG_VOLUME_IND = 2 << EFFECT_FLAG_VOLUME_SHIFT, - EFFECT_FLAG_VOLUME_NONE = 0 << EFFECT_FLAG_VOLUME_SHIFT, + VOLUME_SHIFT = INSERT_SHIFT + INSERT_SIZE, + VOLUME_SIZE = 3, + VOLUME_MASK = ((1 << VOLUME_SIZE) -1) << VOLUME_SHIFT, + VOLUME_CTRL = 1 << VOLUME_SHIFT, + VOLUME_IND = 2 << VOLUME_SHIFT, + VOLUME_NONE = 0 << VOLUME_SHIFT, // Device indication - EFFECT_FLAG_DEVICE_SHIFT = - EFFECT_FLAG_VOLUME_SHIFT + EFFECT_FLAG_VOLUME_SIZE, - EFFECT_FLAG_DEVICE_SIZE = 3, - EFFECT_FLAG_DEVICE_MASK = - ((1 << EFFECT_FLAG_DEVICE_SIZE) -1) << EFFECT_FLAG_DEVICE_SHIFT, - EFFECT_FLAG_DEVICE_IND = 1 << EFFECT_FLAG_DEVICE_SHIFT, - EFFECT_FLAG_DEVICE_NONE = 0 << EFFECT_FLAG_DEVICE_SHIFT, + DEVICE_SHIFT = VOLUME_SHIFT + VOLUME_SIZE, + DEVICE_SIZE = 3, + DEVICE_MASK = ((1 << DEVICE_SIZE) -1) << DEVICE_SHIFT, + DEVICE_IND = 1 << DEVICE_SHIFT, + DEVICE_NONE = 0 << DEVICE_SHIFT, // Sample input modes - EFFECT_FLAG_INPUT_SHIFT = - EFFECT_FLAG_DEVICE_SHIFT + EFFECT_FLAG_DEVICE_SIZE, - EFFECT_FLAG_INPUT_SIZE = 2, - EFFECT_FLAG_INPUT_MASK = - ((1 << EFFECT_FLAG_INPUT_SIZE) -1) << EFFECT_FLAG_INPUT_SHIFT, - EFFECT_FLAG_INPUT_DIRECT = 1 << EFFECT_FLAG_INPUT_SHIFT, - EFFECT_FLAG_INPUT_PROVIDER = 2 << EFFECT_FLAG_INPUT_SHIFT, - EFFECT_FLAG_INPUT_BOTH = 3 << EFFECT_FLAG_INPUT_SHIFT, + INPUT_SHIFT = DEVICE_SHIFT + DEVICE_SIZE, + INPUT_SIZE = 2, + INPUT_MASK = ((1 << INPUT_SIZE) -1) << INPUT_SHIFT, + INPUT_DIRECT = 1 << INPUT_SHIFT, + INPUT_PROVIDER = 2 << INPUT_SHIFT, + INPUT_BOTH = 3 << INPUT_SHIFT, // Sample output modes - EFFECT_FLAG_OUTPUT_SHIFT = EFFECT_FLAG_INPUT_SHIFT + EFFECT_FLAG_INPUT_SIZE, - EFFECT_FLAG_OUTPUT_SIZE = 2, - EFFECT_FLAG_OUTPUT_MASK = - ((1 << EFFECT_FLAG_OUTPUT_SIZE) -1) << EFFECT_FLAG_OUTPUT_SHIFT, - EFFECT_FLAG_OUTPUT_DIRECT = 1 << EFFECT_FLAG_OUTPUT_SHIFT, - EFFECT_FLAG_OUTPUT_PROVIDER = 2 << EFFECT_FLAG_OUTPUT_SHIFT, - EFFECT_FLAG_OUTPUT_BOTH = 3 << EFFECT_FLAG_OUTPUT_SHIFT, + OUTPUT_SHIFT = INPUT_SHIFT + INPUT_SIZE, + OUTPUT_SIZE = 2, + OUTPUT_MASK = ((1 << OUTPUT_SIZE) -1) << OUTPUT_SHIFT, + OUTPUT_DIRECT = 1 << OUTPUT_SHIFT, + OUTPUT_PROVIDER = 2 << OUTPUT_SHIFT, + OUTPUT_BOTH = 3 << OUTPUT_SHIFT, // Hardware acceleration mode - EFFECT_FLAG_HW_ACC_SHIFT = - EFFECT_FLAG_OUTPUT_SHIFT + EFFECT_FLAG_OUTPUT_SIZE, - EFFECT_FLAG_HW_ACC_SIZE = 2, - EFFECT_FLAG_HW_ACC_MASK = - ((1 << EFFECT_FLAG_HW_ACC_SIZE) -1) << EFFECT_FLAG_HW_ACC_SHIFT, - EFFECT_FLAG_HW_ACC_SIMPLE = 1 << EFFECT_FLAG_HW_ACC_SHIFT, - EFFECT_FLAG_HW_ACC_TUNNEL = 2 << EFFECT_FLAG_HW_ACC_SHIFT, + HW_ACC_SHIFT = OUTPUT_SHIFT + OUTPUT_SIZE, + HW_ACC_SIZE = 2, + HW_ACC_MASK = ((1 << HW_ACC_SIZE) -1) << HW_ACC_SHIFT, + HW_ACC_SIMPLE = 1 << HW_ACC_SHIFT, + HW_ACC_TUNNEL = 2 << HW_ACC_SHIFT, // Audio mode indication - EFFECT_FLAG_AUDIO_MODE_SHIFT = - EFFECT_FLAG_HW_ACC_SHIFT + EFFECT_FLAG_HW_ACC_SIZE, - EFFECT_FLAG_AUDIO_MODE_SIZE = 2, - EFFECT_FLAG_AUDIO_MODE_MASK = - ((1 << EFFECT_FLAG_AUDIO_MODE_SIZE) -1) << EFFECT_FLAG_AUDIO_MODE_SHIFT, - EFFECT_FLAG_AUDIO_MODE_IND = 1 << EFFECT_FLAG_AUDIO_MODE_SHIFT, - EFFECT_FLAG_AUDIO_MODE_NONE = 0 << EFFECT_FLAG_AUDIO_MODE_SHIFT, + AUDIO_MODE_SHIFT = HW_ACC_SHIFT + HW_ACC_SIZE, + AUDIO_MODE_SIZE = 2, + AUDIO_MODE_MASK = ((1 << AUDIO_MODE_SIZE) -1) << AUDIO_MODE_SHIFT, + AUDIO_MODE_IND = 1 << AUDIO_MODE_SHIFT, + AUDIO_MODE_NONE = 0 << AUDIO_MODE_SHIFT, // Audio source indication - EFFECT_FLAG_AUDIO_SOURCE_SHIFT = - EFFECT_FLAG_AUDIO_MODE_SHIFT + EFFECT_FLAG_AUDIO_MODE_SIZE, - EFFECT_FLAG_AUDIO_SOURCE_SIZE = 2, - EFFECT_FLAG_AUDIO_SOURCE_MASK = ((1 << EFFECT_FLAG_AUDIO_SOURCE_SIZE) -1) - << EFFECT_FLAG_AUDIO_SOURCE_SHIFT, - EFFECT_FLAG_AUDIO_SOURCE_IND = 1 << EFFECT_FLAG_AUDIO_SOURCE_SHIFT, - EFFECT_FLAG_AUDIO_SOURCE_NONE = 0 << EFFECT_FLAG_AUDIO_SOURCE_SHIFT, + AUDIO_SOURCE_SHIFT = AUDIO_MODE_SHIFT + AUDIO_MODE_SIZE, + AUDIO_SOURCE_SIZE = 2, + AUDIO_SOURCE_MASK = ((1 << AUDIO_SOURCE_SIZE) -1) << AUDIO_SOURCE_SHIFT, + AUDIO_SOURCE_IND = 1 << AUDIO_SOURCE_SHIFT, + AUDIO_SOURCE_NONE = 0 << AUDIO_SOURCE_SHIFT, // Effect offload indication - EFFECT_FLAG_OFFLOAD_SHIFT = - EFFECT_FLAG_AUDIO_SOURCE_SHIFT + EFFECT_FLAG_AUDIO_SOURCE_SIZE, - EFFECT_FLAG_OFFLOAD_SIZE = 1, - EFFECT_FLAG_OFFLOAD_MASK = - ((1 << EFFECT_FLAG_OFFLOAD_SIZE) -1) << EFFECT_FLAG_OFFLOAD_SHIFT, - EFFECT_FLAG_OFFLOAD_SUPPORTED = 1 << EFFECT_FLAG_OFFLOAD_SHIFT, + OFFLOAD_SHIFT = AUDIO_SOURCE_SHIFT + AUDIO_SOURCE_SIZE, + OFFLOAD_SIZE = 1, + OFFLOAD_MASK = ((1 << OFFLOAD_SIZE) -1) << OFFLOAD_SHIFT, + OFFLOAD_SUPPORTED = 1 << OFFLOAD_SHIFT, // Effect has no process indication - EFFECT_FLAG_NO_PROCESS_SHIFT = - EFFECT_FLAG_OFFLOAD_SHIFT + EFFECT_FLAG_OFFLOAD_SIZE, - EFFECT_FLAG_NO_PROCESS_SIZE = 1, - EFFECT_FLAG_NO_PROCESS_MASK = - ((1 << EFFECT_FLAG_NO_PROCESS_SIZE) -1) << EFFECT_FLAG_NO_PROCESS_SHIFT, - EFFECT_FLAG_NO_PROCESS = 1 << EFFECT_FLAG_NO_PROCESS_SHIFT + NO_PROCESS_SHIFT = OFFLOAD_SHIFT + OFFLOAD_SIZE, + NO_PROCESS_SIZE = 1, + NO_PROCESS_MASK = ((1 << NO_PROCESS_SIZE) -1) << NO_PROCESS_SHIFT, + NO_PROCESS = 1 << NO_PROCESS_SHIFT }; /* @@ -246,24 +227,24 @@ struct AudioBuffer { vec data; }; +@export(name="effect_buffer_access_e", value_prefix="EFFECT_BUFFER_") enum EffectBufferAccess { - EFFECT_BUFFER_ACCESS_WRITE, - EFFECT_BUFFER_ACCESS_READ, - EFFECT_BUFFER_ACCESS_ACCUMULATE + ACCESS_WRITE, + ACCESS_READ, + ACCESS_ACCUMULATE }; /* * Determines what fields of EffectBufferConfig need to be considered. */ +@export(name="", value_prefix="EFFECT_CONFIG_") enum EffectConfigParameters { - EFFECT_CONFIG_BUFFER = 0x0001, // buffer field - EFFECT_CONFIG_SMP_RATE = 0x0002, // samplingRate - EFFECT_CONFIG_CHANNELS = 0x0004, // channels - EFFECT_CONFIG_FORMAT = 0x0008, // format - EFFECT_CONFIG_ACC_MODE = 0x0010, // accessMode - EFFECT_CONFIG_ALL = EFFECT_CONFIG_BUFFER | EFFECT_CONFIG_SMP_RATE | - EFFECT_CONFIG_CHANNELS | EFFECT_CONFIG_FORMAT | - EFFECT_CONFIG_ACC_MODE + BUFFER = 0x0001, // buffer field + SMP_RATE = 0x0002, // samplingRate + CHANNELS = 0x0004, // channels + FORMAT = 0x0008, // format + ACC_MODE = 0x0010, // accessMode + ALL = BUFFER | SMP_RATE | CHANNELS | FORMAT | ACC_MODE }; /* @@ -284,10 +265,11 @@ struct EffectConfig { EffectBufferConfig outputCfg; }; +@export(name="effect_feature_e", value_prefix="EFFECT_FEATURE_") enum EffectFeature { - EFFECT_FEATURE_AUX_CHANNELS, // supports auxiliary channels - // (e.g. dual mic noise suppressor) - EFFECT_FEATURE_CNT + AUX_CHANNELS, // supports auxiliary channels + // (e.g. dual mic noise suppressor) + CNT }; struct EffectFeatureConfig {