/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.hardware.audio.common@5.0;

/*
 *
 *  IDs and Handles
 *
 */

/**
 * Handle type for identifying audio sources and sinks.
 */
typedef int32_t AudioIoHandle;

/**
 * Audio hw module handle functions or structures referencing a module.
 */
typedef int32_t AudioModuleHandle;

/**
 * Each port has a unique ID or handle allocated by policy manager.
 */
typedef int32_t AudioPortHandle;

/**
 * Each patch is identified by a handle at the interface used to create that
 * patch. For instance, when a patch is created by the audio HAL, the HAL
 * allocates and returns a handle.  This handle is unique to a given audio HAL
 * hardware module.  But the same patch receives another system wide unique
 * handle allocated by the framework.  This unique handle is used for all
 * transactions inside the framework.
 */
typedef int32_t AudioPatchHandle;

/**
 * A HW synchronization source returned by the audio HAL.
 */
typedef uint32_t AudioHwSync;

/**
 * Each port has a unique ID or handle allocated by policy manager.
 */
@export(name="")
enum AudioHandleConsts : int32_t {
    AUDIO_IO_HANDLE_NONE = 0,
    AUDIO_MODULE_HANDLE_NONE = 0,
    AUDIO_PORT_HANDLE_NONE = 0,
    AUDIO_PATCH_HANDLE_NONE = 0,
};

/**
 * Commonly used structure for passing unique identifieds (UUID).
 * For the definition of UUID, refer to ITU-T X.667 spec.
 */
struct Uuid {
    uint32_t timeLow;
    uint16_t timeMid;
    uint16_t versionAndTimeHigh;
    uint16_t variantAndClockSeqHigh;
    uint8_t[6] node;
};


/*
 *
 *  Audio streams
 *
 */

/**
 * Audio stream type describing the intended use case of a stream.
 */
@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
    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
};

@export(name="audio_source_t", value_prefix="AUDIO_SOURCE_")
enum AudioSource : int32_t {
    // 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
    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.
     */
    REMOTE_SUBMIX       = 8,
    /**
     * Source for unprocessed sound. Usage examples include level measurement
     * and raw signal analysis.
     */
    UNPROCESSED         = 9,

    FM_TUNER            = 1998,
};

typedef int32_t AudioSession;
/**
 * Special audio session values.
 */
@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)
     */
    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)
     */
    OUTPUT_MIX = 0,
    /**
     * Application does not specify an explicit session ID to be used, and
     * requests a new session ID to be allocated. Corresponds to
     * AudioManager.AUDIO_SESSION_ID_GENERATE and
     * AudioSystem.AUDIO_SESSION_ALLOCATE.
     */
    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.
     */
    NONE = 0
};

/**
 * Audio format  is a 32-bit word that consists of:
 *   main format field (upper 8 bits)
 *   sub format field (lower 24 bits).
 *
 * The main format indicates the main codec type. The sub format field indicates
 * options and parameters for each format. The sub format is mainly used for
 * record to indicate for instance the requested bitrate or profile.  It can
 * 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", value_prefix="AUDIO_FORMAT_")
enum AudioFormat : uint32_t {
    INVALID             = 0xFFFFFFFFUL,
    DEFAULT             = 0,
    PCM                 = 0x00000000UL,
    MP3                 = 0x01000000UL,
    AMR_NB              = 0x02000000UL,
    AMR_WB              = 0x03000000UL,
    AAC                 = 0x04000000UL,
    /** Deprecated, Use AAC_HE_V1 */
    HE_AAC_V1           = 0x05000000UL,
    /** Deprecated, Use AAC_HE_V2 */
    HE_AAC_V2           = 0x06000000UL,
    VORBIS              = 0x07000000UL,
    OPUS                = 0x08000000UL,
    AC3                 = 0x09000000UL,
    E_AC3               = 0x0A000000UL,
    DTS                 = 0x0B000000UL,
    DTS_HD              = 0x0C000000UL,
    /** IEC61937 is encoded audio wrapped in 16-bit PCM. */
    IEC61937            = 0x0D000000UL,
    DOLBY_TRUEHD        = 0x0E000000UL,
    EVRC                = 0x10000000UL,
    EVRCB               = 0x11000000UL,
    EVRCWB              = 0x12000000UL,
    EVRCNW              = 0x13000000UL,
    AAC_ADIF            = 0x14000000UL,
    WMA                 = 0x15000000UL,
    WMA_PRO             = 0x16000000UL,
    AMR_WB_PLUS         = 0x17000000UL,
    MP2                 = 0x18000000UL,
    QCELP               = 0x19000000UL,
    DSD                 = 0x1A000000UL,
    FLAC                = 0x1B000000UL,
    ALAC                = 0x1C000000UL,
    APE                 = 0x1D000000UL,
    AAC_ADTS            = 0x1E000000UL,
    SBC                 = 0x1F000000UL,
    APTX                = 0x20000000UL,
    APTX_HD             = 0x21000000UL,
    AC4                 = 0x22000000UL,
    LDAC                = 0x23000000UL,
    /** Dolby Metadata-enhanced Audio Transmission */
    MAT                 = 0x24000000UL,
    /** Deprecated */
    MAIN_MASK           = 0xFF000000UL,
    SUB_MASK            = 0x00FFFFFFUL,

    /* Subformats */
    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,
    AAC_SUB_XHE           = 0x300,

    VORBIS_SUB_NONE       = 0x0,

    E_AC3_SUB_JOC         = 0x1,

    MAT_SUB_1_0           = 0x1,
    MAT_SUB_2_0           = 0x2,
    MAT_SUB_2_1           = 0x3,

    /* Aliases */
    /** note != AudioFormat.ENCODING_PCM_16BIT */
    PCM_16_BIT          = (PCM | PCM_SUB_16_BIT),
    /** note != AudioFormat.ENCODING_PCM_8BIT */
    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),
    AAC_XHE             = (AAC | AAC_SUB_XHE),
    AAC_ADTS_MAIN       = (AAC_ADTS | AAC_SUB_MAIN),
    AAC_ADTS_LC         = (AAC_ADTS | AAC_SUB_LC),
    AAC_ADTS_SSR        = (AAC_ADTS | AAC_SUB_SSR),
    AAC_ADTS_LTP        = (AAC_ADTS | AAC_SUB_LTP),
    AAC_ADTS_HE_V1      = (AAC_ADTS | AAC_SUB_HE_V1),
    AAC_ADTS_SCALABLE   = (AAC_ADTS | AAC_SUB_SCALABLE),
    AAC_ADTS_ERLC       = (AAC_ADTS | AAC_SUB_ERLC),
    AAC_ADTS_LD         = (AAC_ADTS | AAC_SUB_LD),
    AAC_ADTS_HE_V2      = (AAC_ADTS | AAC_SUB_HE_V2),
    AAC_ADTS_ELD        = (AAC_ADTS | AAC_SUB_ELD),
    AAC_ADTS_XHE        = (AAC_ADTS | AAC_SUB_XHE),
    E_AC3_JOC           = (E_AC3 | E_AC3_SUB_JOC),
    MAT_1_0             = (MAT | MAT_SUB_1_0),
    MAT_2_0             = (MAT | MAT_SUB_2_0),
    MAT_2_1             = (MAT | MAT_SUB_2_1),
};

/**
 * Usage of these values highlights places in the code that use 2- or 8- channel
 * assumptions.
 */
@export(name="")
enum FixedChannelCount : int32_t {
    FCC_2 = 2, // This is typically due to legacy implementation of stereo I/O
    FCC_8 = 8  // This is typically due to audio mixer and resampler limitations
};

/**
 * A channel mask per se only defines the presence or absence of a channel, not
 * the order.  See AUDIO_INTERLEAVE_* for the platform convention of order.
 *
 * AudioChannelMask is an opaque type and its internal layout should not be
 * assumed as it may change in the future.  Instead, always use functions
 * to examine it.
 *
 * These are the current representations:
 *
 *   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
 *     OUT_* or IN_* apply to the bits portion.  It is not permitted for no bits
 *     to be set.
 *
 *   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
 *     input.  It is not permitted for no bits to be set.
 *
 * All other representations are reserved for future use.
 *
 * Warning: current representation distinguishes between input and output, but
 * this will not the be case in future revisions of the platform. Wherever there
 * is an ambiguity between input and output that is currently resolved by
 * checking the channel mask, the implementer should look for ways to fix it
 * with additional information outside of the mask.
 */
@export(name="", value_prefix="AUDIO_CHANNEL_")
enum AudioChannelMask : uint32_t {
    /** must be 0 for compatibility */
    REPRESENTATION_POSITION = 0,
    /** 1 is reserved for future use */
    REPRESENTATION_INDEX    = 2,
    /* 3 is reserved for future use */

    /** These can be a complete value of AudioChannelMask */
    NONE                      = 0x0,
    INVALID                   = 0xC0000000,

   /*
    * These can be the bits portion of an AudioChannelMask
    * with representation REPRESENTATION_POSITION.
    */

    /** output channels */
    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_TOP_SIDE_LEFT         = 0x40000,
    OUT_TOP_SIDE_RIGHT        = 0x80000,

    /**
     * Haptic channel characteristics are specific to a device and
     * only used to play device specific resources (eg: ringtones).
     * The HAL can freely map A and B to haptic controllers, the
     * framework shall not interpret those values and forward them
     * from the device audio assets.
     */
    OUT_HAPTIC_A              = 0x20000000,
    OUT_HAPTIC_B              = 0x10000000,

    OUT_MONO     = OUT_FRONT_LEFT,
    OUT_STEREO   = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT),
    OUT_2POINT1  = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_LOW_FREQUENCY),
    OUT_2POINT0POINT2 = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT |
                         OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT),
    OUT_2POINT1POINT2 = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT |
                         OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT |
                         OUT_LOW_FREQUENCY),
    OUT_3POINT0POINT2 = (OUT_FRONT_LEFT | OUT_FRONT_CENTER | OUT_FRONT_RIGHT |
                         OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT),
    OUT_3POINT1POINT2 = (OUT_FRONT_LEFT | OUT_FRONT_CENTER | OUT_FRONT_RIGHT |
                        OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT |
                        OUT_LOW_FREQUENCY),
    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_SURROUND = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT |
            OUT_FRONT_CENTER | OUT_BACK_CENTER),
    OUT_PENTA = (OUT_QUAD | OUT_FRONT_CENTER),
    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),
    OUT_5POINT1POINT2  = (OUT_5POINT1 | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT),
    OUT_5POINT1POINT4  = (OUT_5POINT1 |
            OUT_TOP_FRONT_LEFT | OUT_TOP_FRONT_RIGHT |
            OUT_TOP_BACK_LEFT | OUT_TOP_BACK_RIGHT),
    OUT_6POINT1 = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT |
            OUT_FRONT_CENTER | OUT_LOW_FREQUENCY |
            OUT_BACK_LEFT | OUT_BACK_RIGHT |
            OUT_BACK_CENTER),
    /** matches the correct AudioFormat.CHANNEL_OUT_7POINT1_SURROUND */
    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_7POINT1POINT2  = (OUT_7POINT1 | OUT_TOP_SIDE_LEFT | OUT_TOP_SIDE_RIGHT),
    OUT_7POINT1POINT4  = (OUT_7POINT1 |
            OUT_TOP_FRONT_LEFT | OUT_TOP_FRONT_RIGHT |
            OUT_TOP_BACK_LEFT | OUT_TOP_BACK_RIGHT),
    OUT_MONO_HAPTIC_A = (OUT_FRONT_LEFT | OUT_HAPTIC_A),
    OUT_STEREO_HAPTIC_A = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT | OUT_HAPTIC_A),
    OUT_HAPTIC_AB = (OUT_HAPTIC_A | OUT_HAPTIC_B),
    OUT_MONO_HAPTIC_AB = (OUT_FRONT_LEFT | OUT_HAPTIC_A | OUT_HAPTIC_B),
    OUT_STEREO_HAPTIC_AB = (OUT_FRONT_LEFT | OUT_FRONT_RIGHT |
            OUT_HAPTIC_A | OUT_HAPTIC_B),
    // Note that the 2.0 OUT_ALL* have been moved to helper functions

    /* These are bits only, not complete values */

    /** input channels */
    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_BACK_LEFT       = 0x10000,
    IN_BACK_RIGHT      = 0x20000,
    IN_CENTER          = 0x40000,
    IN_LOW_FREQUENCY   = 0x100000,
    IN_TOP_LEFT        = 0x200000,
    IN_TOP_RIGHT       = 0x400000,

    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_6 = (IN_LEFT | IN_RIGHT |
            IN_FRONT | IN_BACK |
            IN_LEFT_PROCESSED | IN_RIGHT_PROCESSED),
    IN_2POINT0POINT2 = (IN_LEFT | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT),
    IN_2POINT1POINT2 = (IN_LEFT | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT |
            IN_LOW_FREQUENCY),
    IN_3POINT0POINT2 = (IN_LEFT | IN_CENTER | IN_RIGHT | IN_TOP_LEFT | IN_TOP_RIGHT),
    IN_3POINT1POINT2 = (IN_LEFT | IN_CENTER | IN_RIGHT |
            IN_TOP_LEFT | IN_TOP_RIGHT | IN_LOW_FREQUENCY),
    IN_5POINT1 = (IN_LEFT | IN_CENTER | IN_RIGHT |
                  IN_BACK_LEFT | IN_BACK_RIGHT | IN_LOW_FREQUENCY),
    IN_VOICE_UPLINK_MONO = (IN_VOICE_UPLINK | IN_MONO),
    IN_VOICE_DNLINK_MONO = (IN_VOICE_DNLINK | IN_MONO),
    IN_VOICE_CALL_MONO   = (IN_VOICE_UPLINK_MONO |
            IN_VOICE_DNLINK_MONO),
    // Note that the 2.0 IN_ALL* have been moved to helper functions

    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)
};

/**
 * Major modes for a mobile device. The current mode setting affects audio
 * routing.
 */
@export(name="audio_mode_t", value_prefix="AUDIO_MODE_")
enum AudioMode : int32_t {
    NORMAL           = 0,
    RINGTONE         = 1,
    /** Calls handled by the telephony stack (Eg: PSTN). */
    IN_CALL          = 2,
    /** Calls handled by apps (Eg: Hangout). */
    IN_COMMUNICATION = 3,
};

@export(name="", value_prefix="AUDIO_DEVICE_")
enum AudioDevice : uint32_t {
    NONE                          = 0x0,
    /** reserved bits */
    BIT_IN                        = 0x80000000,
    BIT_DEFAULT                   = 0x40000000,
    /** output devices */
    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) */
    OUT_ANLG_DOCK_HEADSET         = 0x800,
    OUT_DGTL_DOCK_HEADSET         = 0x1000,
    /** USB accessory mode: Android device is USB device and dock is USB host */
    OUT_USB_ACCESSORY             = 0x2000,
    /** USB host mode: Android device is USB host and dock is USB device */
    OUT_USB_DEVICE                = 0x4000,
    OUT_REMOTE_SUBMIX             = 0x8000,
    /** Telephony voice TX path */
    OUT_TELEPHONY_TX              = 0x10000,
    /** Analog jack with line impedance detected */
    OUT_LINE                      = 0x20000,
    /** HDMI Audio Return Channel */
    OUT_HDMI_ARC                  = 0x40000,
    /** S/PDIF out */
    OUT_SPDIF                     = 0x80000,
    /** FM transmitter out */
    OUT_FM                        = 0x100000,
    /** Line out for av devices */
    OUT_AUX_LINE                  = 0x200000,
    /** limited-output speaker device for acoustic safety */
    OUT_SPEAKER_SAFE              = 0x400000,
    OUT_IP                        = 0x800000,
    /** audio bus implemented by the audio system (e.g an MOST stereo channel) */
    OUT_BUS                       = 0x1000000,
    OUT_PROXY                     = 0x2000000,
    OUT_USB_HEADSET               = 0x4000000,
    OUT_HEARING_AID               = 0x8000000,
    OUT_ECHO_CANCELLER            = 0x10000000,
    OUT_DEFAULT                   = BIT_DEFAULT,
    // Note that the 2.0 OUT_ALL* have been moved to helper functions

    /** input devices */
    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 */
    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 */
    IN_FM_TUNER              = BIT_IN | 0x2000,
    /** TV tuner input */
    IN_TV_TUNER              = BIT_IN | 0x4000,
    /** Analog jack with line impedance detected */
    IN_LINE                  = BIT_IN | 0x8000,
    /** S/PDIF in */
    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) */
    IN_BUS                   = BIT_IN | 0x100000,
    IN_PROXY                 = BIT_IN | 0x1000000,
    IN_USB_HEADSET           = BIT_IN | 0x2000000,
    IN_BLUETOOTH_BLE         = BIT_IN | 0x4000000,
    IN_DEFAULT               = BIT_IN | BIT_DEFAULT,

    // Note that the 2.0 IN_ALL* have been moved to helper functions
};

/**
 * The audio output flags serve two purposes:
 *
 *  - when an AudioTrack is created they indicate a "wish" to be connected to an
 *    output stream with attributes corresponding to the specified flags;
 *
 *  - when present in an output profile descriptor listed for a particular audio
 *    hardware module, they indicate that an output stream can be opened that
 *    supports the attributes indicated by the flags.
 *
 * 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", value_prefix="AUDIO_OUTPUT_FLAG_")
enum AudioOutputFlag : int32_t {
    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.
    DIRECT_PCM = 0x2000,     // Audio stream containing PCM data that needs
                             // to pass through compress path for DSP post proc.
    MMAP_NOIRQ = 0x4000, // output operates in MMAP no IRQ mode.
    VOIP_RX = 0x8000,    // preferred output for VoIP calls.
    /** preferred output for call music */
    INCALL_MUSIC = 0x10000,
};

/**
 * The audio input flags are analogous to audio output flags.
 * Currently they are used only when an AudioRecord is created,
 * to indicate a preference to be connected to an input stream with
 * attributes corresponding to the specified flags.
 */
@export(name="audio_input_flags_t", value_prefix="AUDIO_INPUT_FLAG_")
enum AudioInputFlag : int32_t {
    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
    MMAP_NOIRQ   = 0x10, // input operates in MMAP no IRQ mode.
    VOIP_TX      = 0x20, // preferred input for VoIP calls.
    HW_AV_SYNC   = 0x40, // input connected to an output that uses a hardware A/V sync
};

@export(name="audio_usage_t", value_prefix="AUDIO_USAGE_")
enum AudioUsage : int32_t {
    // These values must kept in sync with
    //  frameworks/base/media/java/android/media/AudioAttributes.java
    // Note that not all framework values are exposed
    UNKNOWN                            = 0,
    MEDIA                              = 1,
    VOICE_COMMUNICATION                = 2,
    VOICE_COMMUNICATION_SIGNALLING     = 3,
    ALARM                              = 4,
    NOTIFICATION                       = 5,
    NOTIFICATION_TELEPHONY_RINGTONE    = 6,
    ASSISTANCE_ACCESSIBILITY           = 11,
    ASSISTANCE_NAVIGATION_GUIDANCE     = 12,
    ASSISTANCE_SONIFICATION            = 13,
    GAME                               = 14,
    VIRTUAL_SOURCE                     = 15,
    ASSISTANT                          = 16,
};

/** Type of audio generated by an application. */
@export(name="audio_content_type_t", value_prefix="AUDIO_CONTENT_TYPE_")
enum AudioContentType : uint32_t {
    // Do not change these values without updating their counterparts
    // in frameworks/base/media/java/android/media/AudioAttributes.java
    UNKNOWN      = 0,
    SPEECH       = 1,
    MUSIC        = 2,
    MOVIE        = 3,
    SONIFICATION = 4,
};

/**
 * Additional information about the stream passed to hardware decoders.
 */
struct AudioOffloadInfo {
    uint32_t sampleRateHz;
    bitfield<AudioChannelMask> channelMask;
    AudioFormat format;
    AudioStreamType streamType;
    uint32_t bitRatePerSecond;
    int64_t durationMicroseconds;  // -1 if unknown
    bool hasVideo;
    bool isStreaming;
    uint32_t bitWidth;
    uint32_t bufferSize;
    AudioUsage usage;
};

/**
 * Commonly used audio stream configuration parameters.
 */
struct AudioConfig {
    uint32_t sampleRateHz;
    bitfield<AudioChannelMask> channelMask;
    AudioFormat format;
    AudioOffloadInfo offloadInfo;
    uint64_t frameCount;
};

/** Metadata of a playback track for a StreamOut. */
struct PlaybackTrackMetadata {
    AudioUsage usage;
    AudioContentType contentType;
    /**
     * Positive linear gain applied to the track samples. 0 being muted and 1 is no attenuation,
     * 2 means double amplification...
     * Must not be negative.
     */
    float gain;
};

/** Metadatas of the source of a StreamOut. */
struct SourceMetadata {
    vec<PlaybackTrackMetadata> tracks;
};

/** Metadata of a record track for a StreamIn. */
struct RecordTrackMetadata {
    AudioSource source;
    /**
     * Positive linear gain applied to the track samples. 0 being muted and 1 is no attenuation,
     * 2 means double amplification...
     * Must not be negative.
     */
    float gain;
};

/** Metadatas of the source of a StreamIn. */
struct SinkMetadata {
    vec<RecordTrackMetadata> tracks;
};


/*
 *
 *  Volume control
 *
 */

/**
 * Type of gain control exposed by an audio port.
 */
@export(name="", value_prefix="AUDIO_GAIN_MODE_")
enum AudioGainMode : uint32_t {
    JOINT = 0x1,    // supports joint channel gain control
    CHANNELS = 0x2, // supports separate channel gain control
    RAMP = 0x4      // supports gain ramps
};

/**
 * An audio_gain struct is a representation of a gain stage.
 * A gain stage is always attached to an audio port.
 */
struct AudioGain {
    bitfield<AudioGainMode> mode;
    bitfield<AudioChannelMask> channelMask; // channels which gain an be controlled
    int32_t minValue;     // minimum gain value in millibels
    int32_t maxValue;     // maximum gain value in millibels
    int32_t defaultValue; // default gain value in millibels
    uint32_t stepValue;   // gain step in millibels
    uint32_t minRampMs;   // minimum ramp duration in ms
    uint32_t maxRampMs;   // maximum ramp duration in ms
};

/**
 * The gain configuration structure is used to get or set the gain values of a
 * given port.
 */
struct AudioGainConfig {
    int32_t index;  // index of the corresponding AudioGain in AudioPort.gains
    AudioGainMode mode;
    AudioChannelMask channelMask;  // channels which gain value follows
    /**
     * 4 = sizeof(AudioChannelMask),
     * 8 is not "FCC_8", so it won't need to be changed for > 8 channels.
     * Gain values in millibels for each channel ordered from LSb to MSb in
     * channel mask. The number of values is 1 in joint mode or
     * popcount(channel_mask).
     */
    int32_t[4 * 8] values;
    uint32_t rampDurationMs;  // ramp duration in ms
};


/*
 *
 *  Routing control
 *
 */

/*
 * Types defined here are used to describe an audio source or sink at internal
 * framework interfaces (audio policy, patch panel) or at the audio HAL.
 * Sink and sources are grouped in a concept of “audio port” representing an
 * audio end point at the edge of the system managed by the module exposing
 * the interface.
 */

/** Audio port role: either source or sink */
@export(name="audio_port_role_t", value_prefix="AUDIO_PORT_ROLE_")
enum AudioPortRole : int32_t {
    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 OUT_SPEAKER)
 */
@export(name="audio_port_type_t", value_prefix="AUDIO_PORT_TYPE_")
enum AudioPortType : int32_t {
    NONE,
    DEVICE,
    MIX,
    SESSION,
};

/**
 * Extension for audio port configuration structure when the audio port is a
 * hardware device.
 */
struct AudioPortConfigDeviceExt {
    AudioModuleHandle hwModule;  // module the device is attached to
    AudioDevice type;            // device type (e.g OUT_SPEAKER)
    uint8_t[32] address;         // device address. "" if N/A
};

/**
 * Extension for audio port configuration structure when the audio port is an
 * audio session.
 */
struct AudioPortConfigSessionExt {
    AudioSession session;
};

/**
 * Flags indicating which fields are to be considered in AudioPortConfig.
 */
@export(name="", value_prefix="AUDIO_PORT_CONFIG_")
enum AudioPortConfigMask : uint32_t {
    SAMPLE_RATE = 0x1,
    CHANNEL_MASK =  0x2,
    FORMAT = 0x4,
    GAIN = 0x8,
};

/**
 * Audio port configuration structure used to specify a particular configuration
 * of an audio port.
 */
struct AudioPortConfig {
    AudioPortHandle id;
    bitfield<AudioPortConfigMask> configMask;
    uint32_t sampleRateHz;
    bitfield<AudioChannelMask> channelMask;
    AudioFormat format;
    AudioGainConfig gain;
    AudioPortType type;  // type is used as a discriminator for Ext union
    AudioPortRole role;  // role is used as a discriminator for UseCase union
    union Ext {
        AudioPortConfigDeviceExt device;
        struct AudioPortConfigMixExt {
            AudioModuleHandle hwModule; // module the stream is attached to
            AudioIoHandle ioHandle;     // I/O handle of the input/output stream
            union UseCase {
                AudioStreamType stream;
                AudioSource source;
            } useCase;
        } mix;
        AudioPortConfigSessionExt session;
    } ext;
};

/**
 * Extension for audio port structure when the audio port is a hardware device.
 */
struct AudioPortDeviceExt {
    AudioModuleHandle hwModule;    // module the device is attached to
    AudioDevice type;
    /** 32 byte string identifying the port. */
    uint8_t[32] address;
};

/**
 * Latency class of the audio mix.
 */
@export(name="audio_mix_latency_class_t", value_prefix="AUDIO_LATENCY_")
enum AudioMixLatencyClass : int32_t {
    LOW,
    NORMAL
};

struct AudioPortMixExt {
    AudioModuleHandle hwModule;     // module the stream is attached to
    AudioIoHandle ioHandle;         // I/O handle of the stream
    AudioMixLatencyClass latencyClass;
};

/**
 * Extension for audio port structure when the audio port is an audio session.
 */
struct AudioPortSessionExt {
    AudioSession session;
};

struct AudioPort {
    AudioPortHandle id;
    AudioPortRole role;
    string name;
    vec<uint32_t> sampleRates;
    vec<bitfield<AudioChannelMask>> channelMasks;
    vec<AudioFormat> formats;
    vec<AudioGain> gains;
    AudioPortConfig activeConfig; // current audio port configuration
    AudioPortType type;  // type is used as a discriminator
    union Ext {
        AudioPortDeviceExt device;
        AudioPortMixExt mix;
        AudioPortSessionExt session;
    } ext;
};

struct ThreadInfo {
    int64_t pid;
    int64_t tid;
};