/* * Copyright (c) 2019-2021, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of The Linux Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Changes from Qualcomm Innovation Center, Inc. are provided under the following license: * * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause-Clear */ /** \file pal_defs.h * \brief struture, enum constant defintions of the * PAL(Platform Audio Layer). * * This file contains macros, constants, or global variables * exposed to the client of PAL(Platform Audio Layer). */ #ifndef PAL_DEFS_H #define PAL_DEFS_H #include #include #include // { SEC_AUDIO_COMMON #include #include "SecProductFeature_BLUETOOTH.h" // } SEC_AUDIO_COMMON #ifdef __cplusplus #include #include extern "C" { #endif #define MIXER_PATH_MAX_LENGTH 100 #define PAL_MAX_CHANNELS_SUPPORTED 64 #define MAX_KEYWORD_SUPPORTED 8 #define PAL_MAX_LATENCY_MODES 8 #define PAL_VERSION "1.0" /** Audio stream handle */ typedef uint64_t pal_stream_handle_t; /** Sound Trigger handle */ typedef uint64_t pal_st_handle_t; /** PAL Audio format enumeration */ typedef enum { PAL_AUDIO_FMT_DEFAULT_PCM = 0x1, /**< PCM*/ PAL_AUDIO_FMT_PCM_S16_LE = PAL_AUDIO_FMT_DEFAULT_PCM, /**< 16 bit little endian PCM*/ PAL_AUDIO_FMT_DEFAULT_COMPRESSED = 0x2, /**< Default Compressed*/ PAL_AUDIO_FMT_MP3 = PAL_AUDIO_FMT_DEFAULT_COMPRESSED, PAL_AUDIO_FMT_AAC = 0x3, PAL_AUDIO_FMT_AAC_ADTS = 0x4, PAL_AUDIO_FMT_AAC_ADIF = 0x5, PAL_AUDIO_FMT_AAC_LATM = 0x6, PAL_AUDIO_FMT_WMA_STD = 0x7, PAL_AUDIO_FMT_ALAC = 0x8, PAL_AUDIO_FMT_APE = 0x9, PAL_AUDIO_FMT_WMA_PRO = 0xA, PAL_AUDIO_FMT_FLAC = 0xB, PAL_AUDIO_FMT_FLAC_OGG = 0xC, PAL_AUDIO_FMT_VORBIS = 0xD, PAL_AUDIO_FMT_AMR_NB = 0xE, PAL_AUDIO_FMT_AMR_WB = 0xF, PAL_AUDIO_FMT_AMR_WB_PLUS = 0x10, PAL_AUDIO_FMT_EVRC = 0x11, PAL_AUDIO_FMT_G711 = 0x12, PAL_AUDIO_FMT_QCELP = 0x13, PAL_AUDIO_FMT_PCM_S8 = 0x14, /**< 8 Bit PCM*/ PAL_AUDIO_FMT_PCM_S24_3LE = 0x15, /**<24 bit packed little endian PCM*/ PAL_AUDIO_FMT_PCM_S24_LE = 0x16, /**<24bit in 32bit word (LSB aligned) little endian PCM*/ PAL_AUDIO_FMT_PCM_S32_LE = 0x17, /**< 32bit little endian PCM*/ PAL_AUDIO_FMT_OPUS = 0x18, PAL_AUDIO_FMT_NON_PCM = 0xE0000000, /* Internal Constant used for Non PCM format identification */ PAL_AUDIO_FMT_COMPRESSED_RANGE_BEGIN = 0xF0000000, /* Reserved for beginning of compressed codecs */ PAL_AUDIO_FMT_COMPRESSED_EXTENDED_RANGE_BEGIN = 0xF0000F00, /* Reserved for beginning of 3rd party codecs */ PAL_AUDIO_FMT_COMPRESSED_EXTENDED_RANGE_END = 0xF0000FFF, /* Reserved for beginning of 3rd party codecs */ PAL_AUDIO_FMT_COMPRESSED_RANGE_END = PAL_AUDIO_FMT_COMPRESSED_EXTENDED_RANGE_END /* Reserved for beginning of 3rd party codecs */ } pal_audio_fmt_t; typedef enum { PAL_NOTIFY_START = 1, PAL_NOTIFY_STOP, PAL_NOTIFY_DEVICESWITCH } pal_notification_t; #define PCM_24_BIT_PACKED (0x6u) #define PCM_32_BIT (0x3u) #define PCM_16_BIT (0x1u) #define SAMPLE_RATE_192000 192000 #ifdef __cplusplus static const std::map PalAudioFormatMap { { "PCM", PAL_AUDIO_FMT_PCM_S16_LE}, { "PCM_S8", PAL_AUDIO_FMT_PCM_S8}, { "PCM_S16_LE", PAL_AUDIO_FMT_PCM_S16_LE}, { "PCM_S24_3LE", PAL_AUDIO_FMT_PCM_S24_3LE}, { "PCM_S24_LE", PAL_AUDIO_FMT_PCM_S24_LE}, { "PCM_S32_LE", PAL_AUDIO_FMT_PCM_S32_LE}, { "MP3", PAL_AUDIO_FMT_MP3}, { "AAC", PAL_AUDIO_FMT_AAC}, { "AAC_ADTS", PAL_AUDIO_FMT_AAC_ADTS}, { "AAC_ADIF", PAL_AUDIO_FMT_AAC_ADIF}, { "AAC_LATM", PAL_AUDIO_FMT_AAC_LATM}, { "WMA_STD", PAL_AUDIO_FMT_WMA_STD}, { "ALAC", PAL_AUDIO_FMT_ALAC}, { "APE", PAL_AUDIO_FMT_APE}, { "WMA_PRO", PAL_AUDIO_FMT_WMA_PRO}, { "FLAC", PAL_AUDIO_FMT_FLAC}, { "FLAC_OGG", PAL_AUDIO_FMT_FLAC_OGG}, { "VORBIS", PAL_AUDIO_FMT_VORBIS}, { "AMR_NB", PAL_AUDIO_FMT_AMR_NB}, { "AMR_WB", PAL_AUDIO_FMT_AMR_WB}, { "AMR_WB_PLUS", PAL_AUDIO_FMT_AMR_WB_PLUS}, { "EVRC", PAL_AUDIO_FMT_EVRC}, { "G711", PAL_AUDIO_FMT_G711}, { "QCELP", PAL_AUDIO_FMT_QCELP}, { "OPUS", PAL_AUDIO_FMT_OPUS} }; #endif struct aac_enc_cfg { uint16_t aac_enc_mode; /**< AAC encoder mode */ uint16_t aac_fmt_flag; /**< AAC format flag */ }; struct pal_snd_enc_aac { uint32_t aac_bit_rate; uint32_t global_cutoff_freq; struct aac_enc_cfg enc_cfg; }; struct pal_snd_dec_aac { uint16_t audio_obj_type; uint16_t pce_bits_size; }; struct pal_snd_dec_wma { uint32_t fmt_tag; uint32_t super_block_align; uint32_t bits_per_sample; uint32_t channelmask; uint32_t encodeopt; uint32_t encodeopt1; uint32_t encodeopt2; uint32_t avg_bit_rate; }; struct pal_snd_dec_alac { uint32_t frame_length; uint8_t compatible_version; uint8_t bit_depth; uint8_t pb; uint8_t mb; uint8_t kb; uint8_t num_channels; uint16_t max_run; uint32_t max_frame_bytes; uint32_t avg_bit_rate; uint32_t sample_rate; uint32_t channel_layout_tag; }; struct pal_snd_dec_ape { uint16_t compatible_version; uint16_t compression_level; uint32_t format_flags; uint32_t blocks_per_frame; uint32_t final_frame_blocks; uint32_t total_frames; uint16_t bits_per_sample; uint16_t num_channels; uint32_t sample_rate; uint32_t seek_table_present; }; struct pal_snd_dec_flac { uint16_t sample_size; uint16_t min_blk_size; uint16_t max_blk_size; uint16_t min_frame_size; uint16_t max_frame_size; }; struct pal_snd_dec_vorbis { uint32_t bit_stream_fmt; }; struct pal_snd_dec_opus { uint16_t bitstream_format; uint16_t payload_type; uint8_t version; uint8_t num_channels; uint16_t pre_skip; uint32_t sample_rate; uint16_t output_gain; uint8_t mapping_family; uint8_t stream_count; uint8_t coupled_count; uint8_t channel_map[8]; }; typedef struct pal_key_value_pair_s { uint32_t key; /**< key */ uint32_t value; /**< value */ } pal_key_value_pair_t; typedef struct pal_key_vector_s { size_t num_tkvs; /**< number of key value pairs */ pal_key_value_pair_t kvp[]; /**< vector of key value pairs */ } pal_key_vector_t; typedef enum { PARAM_NONTKV, PARAM_TKV, } pal_param_type_t; typedef struct pal_effect_custom_payload_s { uint32_t paramId; uint32_t data[]; } pal_effect_custom_payload_t; typedef struct effect_pal_payload_s { pal_param_type_t isTKV; /* payload type: 0->non-tkv 1->tkv*/ uint32_t tag; uint32_t payloadSize; uint32_t payload[]; /* TKV uses pal_key_vector_t, while nonTKV uses pal_effect_custom_payload_t */ } effect_pal_payload_t; /* Type of Modes for Haptics Device Protection */ typedef enum { PAL_HAP_MODE_DYNAMIC_CAL = 1, PAL_HAP_MODE_FACTORY_TEST, } pal_haptics_mode; /* Payload For ID: PAL_PARAM_ID_HAPTICS_MODE * Description : Values for haptics modes */ typedef struct pal_haptics_payload { pal_haptics_mode operationMode;/* Type of mode for which request is raised */ } pal_haptics_payload; /* Type of Modes for Speaker Protection */ typedef enum { PAL_SP_MODE_DYNAMIC_CAL = 1, PAL_SP_MODE_FACTORY_TEST, PAL_SP_MODE_V_VALIDATION, } pal_spkr_prot_mode; /* Payload For ID: PAL_PARAM_ID_SP_MODE * Description : Values for Speaker protection modes */ typedef struct pal_spkr_prot_payload { uint32_t spkrHeatupTime; /* Wait time in mili seconds to heat up the * speaker before collecting statistics */ uint32_t operationModeRunTime; /* Time period in milli seconds when * statistics are collected */ pal_spkr_prot_mode operationMode;/* Type of mode for which request is raised */ } pal_spkr_prot_payload; typedef enum { GEF_PARAM_READ = 0, GEF_PARAM_WRITE, } gef_param_rw_t; /** Audio parameter data*/ typedef union { struct pal_snd_dec_aac aac_dec; struct pal_snd_dec_wma wma_dec; struct pal_snd_dec_alac alac_dec; struct pal_snd_dec_ape ape_dec; struct pal_snd_dec_flac flac_dec; struct pal_snd_dec_vorbis vorbis_dec; struct pal_snd_dec_opus opus_dec; } pal_snd_dec_t; /** Audio encoder parameter data*/ typedef union { struct pal_snd_enc_aac aac_enc; } pal_snd_enc_t; /** Audio parameter data*/ typedef struct pal_param_payload_s { uint32_t payload_size; uint8_t payload[]; } pal_param_payload; typedef struct gef_payload_s { pal_key_vector_t *graph; bool persist; effect_pal_payload_t data; } gef_payload_t; typedef enum { LPI_VOTE, NLPI_VOTE, AVOID_VOTE, } vote_type_t; /** Audio channel map enumeration*/ typedef enum { PAL_CHMAP_CHANNEL_FL = 1, /**< Front right channel. */ PAL_CHMAP_CHANNEL_FR = 2, /**< Front center channel. */ PAL_CHMAP_CHANNEL_C = 3, /**< Left surround channel. */ PAL_CHMAP_CHANNEL_LS = 4, /** Right surround channel. */ PAL_CHMAP_CHANNEL_RS = 5, /** Low frequency effect channel. */ PAL_CHMAP_CHANNEL_LFE = 6, /** Center surround channel; */ PAL_CHMAP_CHANNEL_RC = 7, /**< rear center channel. */ PAL_CHMAP_CHANNEL_CB = PAL_CHMAP_CHANNEL_RC, /**< center back channel. */ PAL_CHMAP_CHANNEL_LB = 8, /**< rear left channel. */ PAL_CHMAP_CHANNEL_RB = 9, /**< rear right channel. */ PAL_CHMAP_CHANNEL_TS = 10, /**< Top surround channel. */ PAL_CHMAP_CHANNEL_CVH = 11, /**< Center vertical height channel.*/ PAL_CHMAP_CHANNEL_TFC = PAL_CHMAP_CHANNEL_CVH, /**< Top front center channel. */ PAL_CHMAP_CHANNEL_MS = 12, /**< Mono surround channel. */ PAL_CHMAP_CHANNEL_FLC = 13, /**< Front left of center channel. */ PAL_CHMAP_CHANNEL_FRC = 14, /**< Front right of center channel. */ PAL_CHMAP_CHANNEL_RLC = 15, /**< Rear left of center channel. */ PAL_CHMAP_CHANNEL_RRC = 16, /**< Rear right of center channel. */ PAL_CHMAP_CHANNEL_LFE2 = 17, /**< Secondary low frequency effect channel. */ PAL_CHMAP_CHANNEL_SL = 18, /**< Side left channel. */ PAL_CHMAP_CHANNEL_SR = 19, /**< Side right channel. */ PAL_CHMAP_CHANNEL_TFL = 20, /**< Top front left channel. */ PAL_CHMAP_CHANNEL_LVH = PAL_CHMAP_CHANNEL_TFL, /**< Right vertical height channel */ PAL_CHMAP_CHANNEL_TFR = 21, /**< Top front right channel. */ PAL_CHMAP_CHANNEL_RVH = PAL_CHMAP_CHANNEL_TFR, /**< Right vertical height channel. */ PAL_CHMAP_CHANNEL_TC = 22, /**< Top center channel. */ PAL_CHMAP_CHANNEL_TBL = 23, /**< Top back left channel. */ PAL_CHMAP_CHANNEL_TBR = 24, /**< Top back right channel. */ PAL_CHMAP_CHANNEL_TSL = 25, /**< Top side left channel. */ PAL_CHMAP_CHANNEL_TSR = 26, /**< Top side right channel. */ PAL_CHMAP_CHANNEL_TBC = 27, /**< Top back center channel. */ PAL_CHMAP_CHANNEL_BFC = 28, /**< Bottom front center channel. */ PAL_CHMAP_CHANNEL_BFL = 29, /**< Bottom front left channel. */ PAL_CHMAP_CHANNEL_BFR = 30, /**< Bottom front right channel. */ PAL_CHMAP_CHANNEL_LW = 31, /**< Left wide channel. */ PAL_CHMAP_CHANNEL_RW = 32, /**< Right wide channel. */ PAL_CHMAP_CHANNEL_LSD = 33, /**< Left side direct channel. */ PAL_CHMAP_CHANNEL_RSD = 34, /**< Left side direct channel. */ } pal_channel_map; /** Audio channel info data structure */ struct pal_channel_info { uint16_t channels; /**< number of channels*/ uint8_t ch_map[PAL_MAX_CHANNELS_SUPPORTED]; /**< ch_map value per channel. */ }; /** Audio stream direction enumeration */ typedef enum { PAL_AUDIO_OUTPUT = 0x1, /**< playback usecases*/ PAL_AUDIO_INPUT = 0x2, /**< capture/voice activation usecases*/ PAL_AUDIO_INPUT_OUTPUT = 0x3, /**< transcode usecases*/ } pal_stream_direction_t; /** Audio Voip TX Effect enumeration */ typedef enum { PAL_AUDIO_EFFECT_NONE = 0x0, /**< No audio effect ie., EC_OFF_NS_OFF*/ PAL_AUDIO_EFFECT_EC = 0x1, /**< Echo Cancellation ie., EC_ON_NS_OFF*/ PAL_AUDIO_EFFECT_NS = 0x2, /**< Noise Suppression ie., NS_ON_EC_OFF*/ PAL_AUDIO_EFFECT_ECNS = 0x3, /**< EC + NS*/ } pal_audio_effect_t; /** Audio stream types */ typedef enum { PAL_STREAM_LOW_LATENCY = 1, /**< :low latency, higher power*/ PAL_STREAM_DEEP_BUFFER = 2, /**< :low power, higher latency*/ PAL_STREAM_COMPRESSED = 3, /**< :compresssed audio*/ PAL_STREAM_VOIP = 4, /**< :pcm voip audio*/ PAL_STREAM_VOIP_RX = 5, /**< :pcm voip audio downlink*/ PAL_STREAM_VOIP_TX = 6, /**< :pcm voip audio uplink*/ PAL_STREAM_VOICE_CALL_MUSIC = 7, /**< :incall music */ PAL_STREAM_GENERIC = 8, /**< :generic playback audio*/ PAL_STREAM_RAW = 9, /**< pcm no post processing*/ PAL_STREAM_VOICE_RECOGNITION = 10, /**< voice recognition*/ PAL_STREAM_VOICE_CALL_RECORD = 11, /**< incall record */ PAL_STREAM_VOICE_CALL_TX = 12, /**< incall record, uplink */ PAL_STREAM_VOICE_CALL_RX_TX = 13, /**< incall record, uplink & Downlink */ PAL_STREAM_VOICE_CALL = 14, /**< voice call */ PAL_STREAM_LOOPBACK = 15, /**< loopback */ PAL_STREAM_TRANSCODE = 16, /**< audio transcode */ PAL_STREAM_VOICE_UI = 17, /**< voice ui */ PAL_STREAM_PCM_OFFLOAD = 18, /**< pcm offload audio */ PAL_STREAM_ULTRA_LOW_LATENCY = 19, /**< pcm ULL audio */ PAL_STREAM_PROXY = 20, /**< pcm proxy audio */ PAL_STREAM_NON_TUNNEL = 21, /**< NT Mode session */ PAL_STREAM_HAPTICS = 22, /**< Haptics Stream */ PAL_STREAM_ACD = 23, /**< ACD Stream */ PAL_STREAM_CONTEXT_PROXY = 24, /**< Context Proxy Stream */ PAL_STREAM_SENSOR_PCM_DATA = 25, /**< Sensor Pcm Data Stream */ PAL_STREAM_ULTRASOUND = 26, /**< Ultrasound Proximity detection */ PAL_STREAM_SPATIAL_AUDIO = 27, /**< Spatial audio playback */ PAL_STREAM_COMMON_PROXY = 28, /**< AFS's WakeUp Algo library detection */ PAL_STREAM_SENSOR_PCM_RENDERER = 29, /**< Sensor Pcm Rendering Stream */ PAL_STREAM_ASR = 30, /**< ASR Stream */ #ifdef SEC_AUDIO_SOUND_TRIGGER_TYPE PAL_STREAM_HOTWORD = 31, #endif PAL_STREAM_MAX, /**< max stream types - add new ones above */ } pal_stream_type_t; /** Audio devices available for enabling streams */ typedef enum { //OUTPUT DEVICES PAL_DEVICE_OUT_MIN = 0, PAL_DEVICE_NONE = 1, /**< for transcode usecases*/ PAL_DEVICE_OUT_HANDSET = 2, PAL_DEVICE_OUT_SPEAKER = 3, PAL_DEVICE_OUT_WIRED_HEADSET = 4, PAL_DEVICE_OUT_WIRED_HEADPHONE = 5, /**< Wired headphones without mic*/ PAL_DEVICE_OUT_LINE = 6, PAL_DEVICE_OUT_BLUETOOTH_SCO = 7, PAL_DEVICE_OUT_BLUETOOTH_A2DP = 8, PAL_DEVICE_OUT_AUX_DIGITAL = 9, PAL_DEVICE_OUT_HDMI = 10, PAL_DEVICE_OUT_USB_DEVICE = 11, PAL_DEVICE_OUT_USB_HEADSET = 12, PAL_DEVICE_OUT_SPDIF = 13, PAL_DEVICE_OUT_FM = 14, PAL_DEVICE_OUT_AUX_LINE = 15, PAL_DEVICE_OUT_PROXY = 16, PAL_DEVICE_OUT_AUX_DIGITAL_1 = 17, PAL_DEVICE_OUT_HEARING_AID = 18, PAL_DEVICE_OUT_HAPTICS_DEVICE = 19, PAL_DEVICE_OUT_ULTRASOUND = 20, PAL_DEVICE_OUT_ULTRASOUND_DEDICATED = 21, PAL_DEVICE_OUT_BLUETOOTH_BLE = 22, PAL_DEVICE_OUT_BLUETOOTH_BLE_BROADCAST = 23, PAL_DEVICE_OUT_DUMMY = 24, PAL_DEVICE_OUT_RECORD_PROXY = 25, // { SEC_AUDIO_COMMON PAL_DEVICE_OUT_SEC_DEVICE, PAL_DEVICE_OUT_EXT_MODEM = PAL_DEVICE_OUT_SEC_DEVICE, // SEC_AUDIO_CALL_SATELLITE // Add new sec OUT devices here, increment MAX and MIN below when you do so PAL_DEVICE_OUT_MAX = PAL_DEVICE_OUT_SEC_DEVICE + 1, // } SEC_AUDIO_COMMON /* { Qcom original code // Add new OUT devices here, increment MAX and MIN below when you do so PAL_DEVICE_OUT_MAX = 26, } Qcom original code */ //INPUT DEVICES PAL_DEVICE_IN_MIN = PAL_DEVICE_OUT_MAX, PAL_DEVICE_IN_HANDSET_MIC = PAL_DEVICE_IN_MIN +1, PAL_DEVICE_IN_SPEAKER_MIC = PAL_DEVICE_IN_MIN + 2, PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET = PAL_DEVICE_IN_MIN + 3, PAL_DEVICE_IN_WIRED_HEADSET = PAL_DEVICE_IN_MIN + 4, PAL_DEVICE_IN_AUX_DIGITAL = PAL_DEVICE_IN_MIN + 5, PAL_DEVICE_IN_HDMI = PAL_DEVICE_IN_MIN + 6, PAL_DEVICE_IN_USB_ACCESSORY = PAL_DEVICE_IN_MIN + 7, PAL_DEVICE_IN_USB_DEVICE = PAL_DEVICE_IN_MIN + 8, PAL_DEVICE_IN_USB_HEADSET = PAL_DEVICE_IN_MIN + 9, PAL_DEVICE_IN_FM_TUNER = PAL_DEVICE_IN_MIN + 10, PAL_DEVICE_IN_LINE = PAL_DEVICE_IN_MIN + 11, PAL_DEVICE_IN_SPDIF = PAL_DEVICE_IN_MIN + 12, PAL_DEVICE_IN_PROXY = PAL_DEVICE_IN_MIN + 13, PAL_DEVICE_IN_HANDSET_VA_MIC = PAL_DEVICE_IN_MIN + 14, PAL_DEVICE_IN_BLUETOOTH_A2DP = PAL_DEVICE_IN_MIN + 15, PAL_DEVICE_IN_HEADSET_VA_MIC = PAL_DEVICE_IN_MIN + 16, PAL_DEVICE_IN_VI_FEEDBACK = PAL_DEVICE_IN_MIN + 17, PAL_DEVICE_IN_TELEPHONY_RX = PAL_DEVICE_IN_MIN + 18, PAL_DEVICE_IN_ULTRASOUND_MIC = PAL_DEVICE_IN_MIN +19, PAL_DEVICE_IN_EXT_EC_REF = PAL_DEVICE_IN_MIN + 20, PAL_DEVICE_IN_ECHO_REF = PAL_DEVICE_IN_MIN + 21, PAL_DEVICE_IN_HAPTICS_VI_FEEDBACK = PAL_DEVICE_IN_MIN + 22, PAL_DEVICE_IN_BLUETOOTH_BLE = PAL_DEVICE_IN_MIN + 23, PAL_DEVICE_IN_CPS_FEEDBACK = PAL_DEVICE_IN_MIN + 24, PAL_DEVICE_IN_DUMMY = PAL_DEVICE_IN_MIN + 25, PAL_DEVICE_IN_CPS2_FEEDBACK = PAL_DEVICE_IN_MIN + 26, PAL_DEVICE_IN_RECORD_PROXY = PAL_DEVICE_IN_MIN + 27, // { SEC_AUDIO_COMMON PAL_DEVICE_IN_SEC_DEVICE, PAL_DEVICE_IN_EXT_MODEM_MIC = PAL_DEVICE_IN_SEC_DEVICE, // SEC_AUDIO_CALL_SATELLITE // Add new sec OUT devices here, increment MAX and MIN below when you do so PAL_DEVICE_IN_MAX = PAL_DEVICE_IN_SEC_DEVICE + 1, // } SEC_AUDIO_COMMON /* { Qcom original code // Add new IN devices here, increment MAX and MIN below when you do so PAL_DEVICE_IN_MAX = PAL_DEVICE_IN_MIN + 28, } Qcom original code */ } pal_device_id_t; typedef enum { VOICEMMODE1 = 0x11C05000, VOICEMMODE2 = 0x11DC5000, VOICELBMMODE1 = 0x12006000, VOICELBMMODE2 = 0x121C6000, } pal_VSID_t; typedef enum { PAL_STREAM_LOOPBACK_PCM, PAL_STREAM_LOOPBACK_HFP_RX, PAL_STREAM_LOOPBACK_HFP_TX, PAL_STREAM_LOOPBACK_COMPRESS, PAL_STREAM_LOOPBACK_FM, PAL_STREAM_LOOPBACK_KARAOKE, PAL_STREAM_LOOPBACK_PLAYBACK_ONLY, PAL_STREAM_LOOPBACK_CAPTURE_ONLY, // { SEC_AUDIO_CALL_SATELLITE PAL_STREAM_LOOPBACK_EXT_MODEM_RX, PAL_STREAM_LOOPBACK_EXT_MODEM_TX, // } SEC_AUDIO_CALL_SATELLITE } pal_stream_loopback_type_t; typedef enum { PAL_STREAM_PROXY_TX_VISUALIZER, PAL_STREAM_PROXY_TX_WFD, PAL_STREAM_PROXY_TX_TELEPHONY_RX, } pal_stream_proxy_tx_type_t; typedef enum { PAL_STREAM_PROXY_RX_WFD = 1, } pal_stream_proxy_rx_type_t; typedef enum { PAL_STREAM_HAPTICS_RINGTONE, PAL_STREAM_HAPTICS_TOUCH = 1, PAL_STREAM_HAPTICS_PCM = 2, } pal_stream_haptics_type_t; #ifdef __cplusplus static const std::map deviceIdLUT { {std::string{ "PAL_DEVICE_OUT_MIN" }, PAL_DEVICE_OUT_MIN}, {std::string{ "PAL_DEVICE_NONE" }, PAL_DEVICE_NONE}, {std::string{ "PAL_DEVICE_OUT_HANDSET" }, PAL_DEVICE_OUT_HANDSET}, {std::string{ "PAL_DEVICE_OUT_SPEAKER" }, PAL_DEVICE_OUT_SPEAKER}, {std::string{ "PAL_DEVICE_OUT_WIRED_HEADSET" }, PAL_DEVICE_OUT_WIRED_HEADSET}, {std::string{ "PAL_DEVICE_OUT_WIRED_HEADPHONE" }, PAL_DEVICE_OUT_WIRED_HEADPHONE}, {std::string{ "PAL_DEVICE_OUT_LINE" }, PAL_DEVICE_OUT_LINE}, {std::string{ "PAL_DEVICE_OUT_BLUETOOTH_SCO" }, PAL_DEVICE_OUT_BLUETOOTH_SCO}, {std::string{ "PAL_DEVICE_OUT_BLUETOOTH_A2DP" }, PAL_DEVICE_OUT_BLUETOOTH_A2DP}, {std::string{ "PAL_DEVICE_OUT_BLUETOOTH_BLE" }, PAL_DEVICE_OUT_BLUETOOTH_BLE}, {std::string{ "PAL_DEVICE_OUT_BLUETOOTH_BLE_BROADCAST" }, PAL_DEVICE_OUT_BLUETOOTH_BLE_BROADCAST}, {std::string{ "PAL_DEVICE_OUT_AUX_DIGITAL" }, PAL_DEVICE_OUT_AUX_DIGITAL}, {std::string{ "PAL_DEVICE_OUT_HDMI" }, PAL_DEVICE_OUT_HDMI}, {std::string{ "PAL_DEVICE_OUT_USB_DEVICE" }, PAL_DEVICE_OUT_USB_DEVICE}, {std::string{ "PAL_DEVICE_OUT_USB_HEADSET" }, PAL_DEVICE_OUT_USB_HEADSET}, {std::string{ "PAL_DEVICE_OUT_SPDIF" }, PAL_DEVICE_OUT_SPDIF}, {std::string{ "PAL_DEVICE_OUT_FM" }, PAL_DEVICE_OUT_FM}, {std::string{ "PAL_DEVICE_OUT_AUX_LINE" }, PAL_DEVICE_OUT_AUX_LINE}, {std::string{ "PAL_DEVICE_OUT_PROXY" }, PAL_DEVICE_OUT_PROXY}, {std::string{ "PAL_DEVICE_OUT_RECORD_PROXY" }, PAL_DEVICE_OUT_RECORD_PROXY}, {std::string{ "PAL_DEVICE_OUT_AUX_DIGITAL_1" }, PAL_DEVICE_OUT_AUX_DIGITAL_1}, {std::string{ "PAL_DEVICE_OUT_HEARING_AID" }, PAL_DEVICE_OUT_HEARING_AID}, {std::string{ "PAL_DEVICE_OUT_HAPTICS_DEVICE" }, PAL_DEVICE_OUT_HAPTICS_DEVICE}, {std::string{ "PAL_DEVICE_OUT_ULTRASOUND" }, PAL_DEVICE_OUT_ULTRASOUND}, {std::string{ "PAL_DEVICE_OUT_ULTRASOUND_DEDICATED" }, PAL_DEVICE_OUT_ULTRASOUND_DEDICATED}, {std::string{ "PAL_DEVICE_OUT_DUMMY" }, PAL_DEVICE_OUT_DUMMY}, #ifdef SEC_AUDIO_CALL_SATELLITE {std::string{ "PAL_DEVICE_OUT_EXT_MODEM" }, PAL_DEVICE_OUT_EXT_MODEM}, #endif {std::string{ "PAL_DEVICE_OUT_MAX" }, PAL_DEVICE_OUT_MAX}, {std::string{ "PAL_DEVICE_IN_HANDSET_MIC" }, PAL_DEVICE_IN_HANDSET_MIC}, {std::string{ "PAL_DEVICE_IN_SPEAKER_MIC" }, PAL_DEVICE_IN_SPEAKER_MIC}, {std::string{ "PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET" }, PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET}, {std::string{ "PAL_DEVICE_IN_WIRED_HEADSET" }, PAL_DEVICE_IN_WIRED_HEADSET}, {std::string{ "PAL_DEVICE_IN_AUX_DIGITAL" }, PAL_DEVICE_IN_AUX_DIGITAL}, {std::string{ "PAL_DEVICE_IN_HDMI" }, PAL_DEVICE_IN_HDMI}, {std::string{ "PAL_DEVICE_IN_USB_ACCESSORY" }, PAL_DEVICE_IN_USB_ACCESSORY}, {std::string{ "PAL_DEVICE_IN_USB_DEVICE" }, PAL_DEVICE_IN_USB_DEVICE}, {std::string{ "PAL_DEVICE_IN_USB_HEADSET" }, PAL_DEVICE_IN_USB_HEADSET}, {std::string{ "PAL_DEVICE_IN_FM_TUNER" }, PAL_DEVICE_IN_FM_TUNER}, {std::string{ "PAL_DEVICE_IN_LINE" }, PAL_DEVICE_IN_LINE}, {std::string{ "PAL_DEVICE_IN_SPDIF" }, PAL_DEVICE_IN_SPDIF}, {std::string{ "PAL_DEVICE_IN_PROXY" }, PAL_DEVICE_IN_PROXY}, {std::string{ "PAL_DEVICE_IN_RECORD_PROXY" }, PAL_DEVICE_IN_RECORD_PROXY}, {std::string{ "PAL_DEVICE_IN_HANDSET_VA_MIC" }, PAL_DEVICE_IN_HANDSET_VA_MIC}, {std::string{ "PAL_DEVICE_IN_BLUETOOTH_A2DP" }, PAL_DEVICE_IN_BLUETOOTH_A2DP}, {std::string{ "PAL_DEVICE_IN_BLUETOOTH_BLE" }, PAL_DEVICE_IN_BLUETOOTH_BLE}, {std::string{ "PAL_DEVICE_IN_HEADSET_VA_MIC" }, PAL_DEVICE_IN_HEADSET_VA_MIC}, {std::string{ "PAL_DEVICE_IN_VI_FEEDBACK" }, PAL_DEVICE_IN_VI_FEEDBACK}, {std::string{ "PAL_DEVICE_IN_TELEPHONY_RX" }, PAL_DEVICE_IN_TELEPHONY_RX}, {std::string{ "PAL_DEVICE_IN_ULTRASOUND_MIC" }, PAL_DEVICE_IN_ULTRASOUND_MIC}, {std::string{ "PAL_DEVICE_IN_EXT_EC_REF" }, PAL_DEVICE_IN_EXT_EC_REF}, {std::string{ "PAL_DEVICE_IN_ECHO_REF" }, PAL_DEVICE_IN_ECHO_REF}, {std::string{ "PAL_DEVICE_IN_HAPTICS_VI_FEEDBACK" }, PAL_DEVICE_IN_HAPTICS_VI_FEEDBACK}, {std::string{ "PAL_DEVICE_IN_CPS_FEEDBACK" }, PAL_DEVICE_IN_CPS_FEEDBACK}, {std::string{ "PAL_DEVICE_IN_DUMMY" }, PAL_DEVICE_IN_DUMMY}, #ifdef SEC_AUDIO_CALL_SATELLITE {std::string{ "PAL_DEVICE_IN_EXT_MODEM_MIC" }, PAL_DEVICE_IN_EXT_MODEM_MIC}, #endif }; //reverse mapping static const std::map deviceNameLUT { {PAL_DEVICE_OUT_MIN, std::string{"PAL_DEVICE_OUT_MIN"}}, {PAL_DEVICE_NONE, std::string{"PAL_DEVICE_NONE"}}, {PAL_DEVICE_OUT_HANDSET, std::string{"PAL_DEVICE_OUT_HANDSET"}}, {PAL_DEVICE_OUT_SPEAKER, std::string{"PAL_DEVICE_OUT_SPEAKER"}}, {PAL_DEVICE_OUT_WIRED_HEADSET, std::string{"PAL_DEVICE_OUT_WIRED_HEADSET"}}, {PAL_DEVICE_OUT_WIRED_HEADPHONE, std::string{"PAL_DEVICE_OUT_WIRED_HEADPHONE"}}, {PAL_DEVICE_OUT_LINE, std::string{"PAL_DEVICE_OUT_LINE"}}, {PAL_DEVICE_OUT_BLUETOOTH_SCO, std::string{"PAL_DEVICE_OUT_BLUETOOTH_SCO"}}, {PAL_DEVICE_OUT_BLUETOOTH_A2DP, std::string{"PAL_DEVICE_OUT_BLUETOOTH_A2DP"}}, {PAL_DEVICE_OUT_BLUETOOTH_BLE, std::string{"PAL_DEVICE_OUT_BLUETOOTH_BLE"}}, {PAL_DEVICE_OUT_BLUETOOTH_BLE_BROADCAST, std::string{"PAL_DEVICE_OUT_BLUETOOTH_BLE_BROADCAST"}}, {PAL_DEVICE_OUT_AUX_DIGITAL, std::string{"PAL_DEVICE_OUT_AUX_DIGITAL"}}, {PAL_DEVICE_OUT_HDMI, std::string{"PAL_DEVICE_OUT_HDMI"}}, {PAL_DEVICE_OUT_USB_DEVICE, std::string{"PAL_DEVICE_OUT_USB_DEVICE"}}, {PAL_DEVICE_OUT_USB_HEADSET, std::string{"PAL_DEVICE_OUT_USB_HEADSET"}}, {PAL_DEVICE_OUT_SPDIF, std::string{"PAL_DEVICE_OUT_SPDIF"}}, {PAL_DEVICE_OUT_FM, std::string{"PAL_DEVICE_OUT_FM"}}, {PAL_DEVICE_OUT_AUX_LINE, std::string{"PAL_DEVICE_OUT_AUX_LINE"}}, {PAL_DEVICE_OUT_PROXY, std::string{"PAL_DEVICE_OUT_PROXY"}}, {PAL_DEVICE_OUT_RECORD_PROXY, std::string{"PAL_DEVICE_OUT_RECORD_PROXY"}}, {PAL_DEVICE_OUT_AUX_DIGITAL_1, std::string{"PAL_DEVICE_OUT_AUX_DIGITAL_1"}}, {PAL_DEVICE_OUT_HEARING_AID, std::string{"PAL_DEVICE_OUT_HEARING_AID"}}, {PAL_DEVICE_OUT_HAPTICS_DEVICE, std::string{"PAL_DEVICE_OUT_HAPTICS_DEVICE"}}, {PAL_DEVICE_OUT_ULTRASOUND, std::string{"PAL_DEVICE_OUT_ULTRASOUND"}}, {PAL_DEVICE_OUT_ULTRASOUND_DEDICATED, std::string{"PAL_DEVICE_OUT_ULTRASOUND_DEDICATED"}}, {PAL_DEVICE_OUT_DUMMY, std::string{"PAL_DEVICE_OUT_DUMMY"}}, #ifdef SEC_AUDIO_CALL_SATELLITE {PAL_DEVICE_OUT_EXT_MODEM, std::string{"PAL_DEVICE_OUT_EXT_MODEM"}}, #endif {PAL_DEVICE_OUT_MAX, std::string{"PAL_DEVICE_OUT_MAX"}}, {PAL_DEVICE_IN_HANDSET_MIC, std::string{"PAL_DEVICE_IN_HANDSET_MIC"}}, {PAL_DEVICE_IN_SPEAKER_MIC, std::string{"PAL_DEVICE_IN_SPEAKER_MIC"}}, {PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET, std::string{"PAL_DEVICE_IN_BLUETOOTH_SCO_HEADSET"}}, {PAL_DEVICE_IN_WIRED_HEADSET, std::string{"PAL_DEVICE_IN_WIRED_HEADSET"}}, {PAL_DEVICE_IN_AUX_DIGITAL, std::string{"PAL_DEVICE_IN_AUX_DIGITAL"}}, {PAL_DEVICE_IN_HDMI, std::string{"PAL_DEVICE_IN_HDMI"}}, {PAL_DEVICE_IN_USB_ACCESSORY, std::string{"PAL_DEVICE_IN_USB_ACCESSORY"}}, {PAL_DEVICE_IN_USB_DEVICE, std::string{"PAL_DEVICE_IN_USB_DEVICE"}}, {PAL_DEVICE_IN_USB_HEADSET, std::string{"PAL_DEVICE_IN_USB_HEADSET"}}, {PAL_DEVICE_IN_FM_TUNER, std::string{"PAL_DEVICE_IN_FM_TUNER"}}, {PAL_DEVICE_IN_LINE, std::string{"PAL_DEVICE_IN_LINE"}}, {PAL_DEVICE_IN_SPDIF, std::string{"PAL_DEVICE_IN_SPDIF"}}, {PAL_DEVICE_IN_PROXY, std::string{"PAL_DEVICE_IN_PROXY"}}, {PAL_DEVICE_IN_RECORD_PROXY, std::string{"PAL_DEVICE_IN_RECORD_PROXY"}}, {PAL_DEVICE_IN_HANDSET_VA_MIC, std::string{"PAL_DEVICE_IN_HANDSET_VA_MIC"}}, {PAL_DEVICE_IN_BLUETOOTH_A2DP, std::string{"PAL_DEVICE_IN_BLUETOOTH_A2DP"}}, {PAL_DEVICE_IN_BLUETOOTH_BLE, std::string{"PAL_DEVICE_IN_BLUETOOTH_BLE"}}, {PAL_DEVICE_IN_HEADSET_VA_MIC, std::string{"PAL_DEVICE_IN_HEADSET_VA_MIC"}}, {PAL_DEVICE_IN_VI_FEEDBACK, std::string{"PAL_DEVICE_IN_VI_FEEDBACK"}}, {PAL_DEVICE_IN_TELEPHONY_RX, std::string{"PAL_DEVICE_IN_TELEPHONY_RX"}}, {PAL_DEVICE_IN_ULTRASOUND_MIC, std::string{"PAL_DEVICE_IN_ULTRASOUND_MIC"}}, {PAL_DEVICE_IN_EXT_EC_REF, std::string{"PAL_DEVICE_IN_EXT_EC_REF"}}, {PAL_DEVICE_IN_ECHO_REF, std::string{"PAL_DEVICE_IN_ECHO_REF"}}, {PAL_DEVICE_IN_HAPTICS_VI_FEEDBACK, std::string{"PAL_DEVICE_IN_HAPTICS_VI_FEEDBACK"}}, {PAL_DEVICE_IN_CPS_FEEDBACK, std::string{"PAL_DEVICE_IN_CPS_FEEDBACK"}}, {PAL_DEVICE_IN_DUMMY, std::string{"PAL_DEVICE_IN_DUMMY"}}, #ifdef SEC_AUDIO_CALL_SATELLITE {PAL_DEVICE_IN_EXT_MODEM_MIC, std::string{"PAL_DEVICE_IN_EXT_MODEM_MIC"}}, #endif }; const std::map usecaseIdLUT { {std::string{ "PAL_STREAM_LOW_LATENCY" }, PAL_STREAM_LOW_LATENCY}, {std::string{ "PAL_STREAM_DEEP_BUFFER" }, PAL_STREAM_DEEP_BUFFER}, {std::string{ "PAL_STREAM_COMPRESSED" }, PAL_STREAM_COMPRESSED}, {std::string{ "PAL_STREAM_VOIP" }, PAL_STREAM_VOIP}, {std::string{ "PAL_STREAM_VOIP_RX" }, PAL_STREAM_VOIP_RX}, {std::string{ "PAL_STREAM_VOIP_TX" }, PAL_STREAM_VOIP_TX}, {std::string{ "PAL_STREAM_VOICE_CALL_MUSIC" }, PAL_STREAM_VOICE_CALL_MUSIC}, {std::string{ "PAL_STREAM_GENERIC" }, PAL_STREAM_GENERIC}, {std::string{ "PAL_STREAM_RAW" }, PAL_STREAM_RAW}, {std::string{ "PAL_STREAM_VOICE_RECOGNITION" }, PAL_STREAM_VOICE_RECOGNITION}, {std::string{ "PAL_STREAM_VOICE_CALL_RECORD" }, PAL_STREAM_VOICE_CALL_RECORD}, {std::string{ "PAL_STREAM_VOICE_CALL_TX" }, PAL_STREAM_VOICE_CALL_TX}, {std::string{ "PAL_STREAM_VOICE_CALL_RX_TX" }, PAL_STREAM_VOICE_CALL_RX_TX}, {std::string{ "PAL_STREAM_VOICE_CALL" }, PAL_STREAM_VOICE_CALL}, {std::string{ "PAL_STREAM_LOOPBACK" }, PAL_STREAM_LOOPBACK}, {std::string{ "PAL_STREAM_TRANSCODE" }, PAL_STREAM_TRANSCODE}, {std::string{ "PAL_STREAM_VOICE_UI" }, PAL_STREAM_VOICE_UI}, {std::string{ "PAL_STREAM_PCM_OFFLOAD" }, PAL_STREAM_PCM_OFFLOAD}, {std::string{ "PAL_STREAM_ULTRA_LOW_LATENCY" }, PAL_STREAM_ULTRA_LOW_LATENCY}, {std::string{ "PAL_STREAM_PROXY" }, PAL_STREAM_PROXY}, {std::string{ "PAL_STREAM_NON_TUNNEL" }, PAL_STREAM_NON_TUNNEL}, {std::string{ "PAL_STREAM_HAPTICS" }, PAL_STREAM_HAPTICS}, {std::string{ "PAL_STREAM_ACD" }, PAL_STREAM_ACD}, {std::string{ "PAL_STREAM_ASR" }, PAL_STREAM_ASR}, {std::string{ "PAL_STREAM_ULTRASOUND" }, PAL_STREAM_ULTRASOUND}, {std::string{ "PAL_STREAM_SENSOR_PCM_DATA" }, PAL_STREAM_SENSOR_PCM_DATA}, {std::string{ "PAL_STREAM_SPATIAL_AUDIO" }, PAL_STREAM_SPATIAL_AUDIO}, {std::string{ "PAL_STREAM_CONTEXT_PROXY" }, PAL_STREAM_CONTEXT_PROXY}, {std::string{ "PAL_STREAM_COMMON_PROXY" }, PAL_STREAM_COMMON_PROXY}, {std::string{ "PAL_STREAM_SENSOR_PCM_RENDERER" }, PAL_STREAM_SENSOR_PCM_RENDERER}, }; /* Update the reverse mapping as well when new stream is added */ const std::map streamNameLUT { {PAL_STREAM_LOW_LATENCY, std::string{ "PAL_STREAM_LOW_LATENCY" } }, {PAL_STREAM_DEEP_BUFFER, std::string{ "PAL_STREAM_DEEP_BUFFER" } }, {PAL_STREAM_COMPRESSED, std::string{ "PAL_STREAM_COMPRESSED" } }, {PAL_STREAM_VOIP, std::string{ "PAL_STREAM_VOIP" } }, {PAL_STREAM_VOIP_RX, std::string{ "PAL_STREAM_VOIP_RX" } }, {PAL_STREAM_VOIP_TX, std::string{ "PAL_STREAM_VOIP_TX" } }, {PAL_STREAM_VOICE_CALL_MUSIC, std::string{ "PAL_STREAM_VOICE_CALL_MUSIC" } }, {PAL_STREAM_GENERIC, std::string{ "PAL_STREAM_GENERIC" } }, {PAL_STREAM_RAW, std::string{ "PAL_STREAM_RAW" } }, {PAL_STREAM_VOICE_RECOGNITION, std::string{ "PAL_STREAM_VOICE_RECOGNITION" } }, {PAL_STREAM_VOICE_CALL_RECORD, std::string{ "PAL_STREAM_VOICE_CALL_RECORD" } }, {PAL_STREAM_VOICE_CALL_TX, std::string{ "PAL_STREAM_VOICE_CALL_TX" } }, {PAL_STREAM_VOICE_CALL_RX_TX, std::string{ "PAL_STREAM_VOICE_CALL_RX_TX" } }, {PAL_STREAM_VOICE_CALL, std::string{ "PAL_STREAM_VOICE_CALL" } }, {PAL_STREAM_LOOPBACK, std::string{ "PAL_STREAM_LOOPBACK" } }, {PAL_STREAM_TRANSCODE, std::string{ "PAL_STREAM_TRANSCODE" } }, {PAL_STREAM_VOICE_UI, std::string{ "PAL_STREAM_VOICE_UI" } }, {PAL_STREAM_PCM_OFFLOAD, std::string{ "PAL_STREAM_PCM_OFFLOAD" } }, {PAL_STREAM_ULTRA_LOW_LATENCY, std::string{ "PAL_STREAM_ULTRA_LOW_LATENCY" } }, {PAL_STREAM_PROXY, std::string{ "PAL_STREAM_PROXY" } }, {PAL_STREAM_NON_TUNNEL, std::string{ "PAL_STREAM_NON_TUNNEL" } }, {PAL_STREAM_HAPTICS, std::string{ "PAL_STREAM_HAPTICS" } }, {PAL_STREAM_CONTEXT_PROXY, std::string{ "PAL_STREAM_CONTEXT_PROXY" } }, {PAL_STREAM_ACD, std::string{ "PAL_STREAM_ACD" } }, {PAL_STREAM_ASR, std::string{ "PAL_STREAM_ASR" } }, {PAL_STREAM_ULTRASOUND, std::string{ "PAL_STREAM_ULTRASOUND" } }, {PAL_STREAM_SENSOR_PCM_DATA, std::string{ "PAL_STREAM_SENSOR_PCM_DATA" } }, {PAL_STREAM_SPATIAL_AUDIO, std::string{ "PAL_STREAM_SPATIAL_AUDIO" } }, {PAL_STREAM_COMMON_PROXY, std::string{ "PAL_STREAM_COMMON_PROXY" } }, {PAL_STREAM_SENSOR_PCM_RENDERER,std::string{ "PAL_STREAM_SENSOR_PCM_RENDERER" } }, }; const std::map vsidLUT { {VOICEMMODE1, std::string{ "VOICEMMODE1" } }, {VOICEMMODE2, std::string{ "VOICEMMODE2" } }, {VOICELBMMODE1, std::string{ "VOICELBMMODE1" } }, {VOICELBMMODE2, std::string{ "VOICELBMMODE2" } }, }; const std::map loopbackLUT { {PAL_STREAM_LOOPBACK_PCM, std::string{ "PAL_STREAM_LOOPBACK_PCM" } }, {PAL_STREAM_LOOPBACK_HFP_RX, std::string{ "PAL_STREAM_LOOPBACK_HFP_RX" } }, {PAL_STREAM_LOOPBACK_HFP_TX, std::string{ "PAL_STREAM_LOOPBACK_HFP_TX" } }, {PAL_STREAM_LOOPBACK_COMPRESS, std::string{ "PAL_STREAM_LOOPBACK_COMPRESS" } }, {PAL_STREAM_LOOPBACK_FM, std::string{ "PAL_STREAM_LOOPBACK_FM" } }, {PAL_STREAM_LOOPBACK_KARAOKE, std::string{ "PAL_STREAM_LOOPBACK_KARAOKE" }}, {PAL_STREAM_LOOPBACK_PLAYBACK_ONLY, std::string{ "PAL_STREAM_LOOPBACK_PLAYBACK_ONLY" } }, {PAL_STREAM_LOOPBACK_CAPTURE_ONLY, std::string{ "PAL_STREAM_LOOPBACK_CAPTURE_ONLY" } }, #ifdef SEC_AUDIO_CALL_SATELLITE {PAL_STREAM_LOOPBACK_EXT_MODEM_RX, std::string{ "PAL_STREAM_LOOPBACK_EXT_MODEM_RX" } }, {PAL_STREAM_LOOPBACK_EXT_MODEM_TX, std::string{ "PAL_STREAM_LOOPBACK_EXT_MODEM_TX" } }, #endif }; const std::map hapticsLUT { {PAL_STREAM_HAPTICS_TOUCH, std::string{ "PAL_STREAM_HAPTICS_TOUCH" } }, {PAL_STREAM_HAPTICS_RINGTONE, std::string{ "PAL_STREAM_HAPTICS_RINGTONE" } }, }; #endif /* type of asynchronous write callback events. Mutually exclusive */ typedef enum { PAL_STREAM_CBK_EVENT_WRITE_READY, /* non blocking write completed */ PAL_STREAM_CBK_EVENT_DRAIN_READY, /* drain completed */ PAL_STREAM_CBK_EVENT_PARTIAL_DRAIN_READY, /* partial drain completed */ PAL_STREAM_CBK_EVENT_READ_DONE, /* non blocking read completed */ PAL_STREAM_CBK_EVENT_ERROR, /* stream hit some error, let AF take action */ PAL_STREAM_CBK_MAX = 0xFFFF, } pal_stream_callback_event_t; /* type of global callback events. */ typedef enum { PAL_SND_CARD_STATE, } pal_global_callback_event_t; struct pal_stream_info { int64_t version; /** version of structure*/ int64_t size; /** size of structure*/ int64_t duration_us; /** duration in microseconds, -1 if unknown */ bool has_video; /** optional, true if stream is tied to a video stream */ bool is_streaming; /** true if streaming, false if local playback */ int32_t loopback_type; /** used only if stream_type is LOOPBACK. One of the */ /** enums defined in enum pal_stream_loopback_type */ int32_t tx_proxy_type; /** enums defined in enum pal_stream_proxy_tx_types */ int32_t rx_proxy_type; /** enums defined in enum pal_stream_proxy_rx_types */ int32_t haptics_type; /** enums defined in enum pal_sream_haptics_types */ //pal_audio_attributes_t usage; /** Not sure if we make use of this */ }; typedef enum { INCALL_RECORD_VOICE_UPLINK = 1, INCALL_RECORD_VOICE_DOWNLINK, INCALL_RECORD_VOICE_UPLINK_DOWNLINK, } pal_incall_record_direction; struct pal_voice_record_info { int64_t version; /** version of structure*/ int64_t size; /** size of structure*/ pal_incall_record_direction record_direction; /** use direction enum to indicate content to be record */ }; struct pal_voice_call_info { uint32_t VSID; uint32_t tty_mode; }; typedef enum { PAL_TTY_OFF = 0, PAL_TTY_HCO = 1, PAL_TTY_VCO = 2, PAL_TTY_FULL = 3, } pal_tty_t; struct pal_incall_music_info { bool local_playback; }; #ifdef SEC_AUDIO_SUPPORT_LOWLATENCY_MEDIA struct pal_lowlatency_media { bool mode; }; #endif typedef union { struct pal_stream_info opt_stream_info; /* optional */ struct pal_voice_record_info voice_rec_info; /* mandatory */ struct pal_voice_call_info voice_call_info; /* manatory for voice call*/ struct pal_incall_music_info incall_music_info; #ifdef SEC_AUDIO_SUPPORT_LOWLATENCY_MEDIA struct pal_lowlatency_media lowlatency_media; #endif } pal_stream_info_t; /** Media configuraiton */ struct pal_media_config { uint32_t sample_rate; /**< sample rate */ uint32_t bit_width; /**< bit width */ pal_audio_fmt_t aud_fmt_id; /**< audio format id*/ struct pal_channel_info ch_info; /**< channel info */ }; /** Android Media configuraiton */ /* dynamic media config for plugin devices, +1 so that the last entry is always 0 */ #define MAX_SUPPORTED_CHANNEL_MASKS (2 * 8) #define MAX_SUPPORTED_FORMATS 15 #define MAX_SUPPORTED_SAMPLE_RATES 7 typedef struct dynamic_media_config { uint32_t sample_rate[MAX_SUPPORTED_SAMPLE_RATES+1]; /**< sample rate */ uint32_t format[MAX_SUPPORTED_FORMATS+1]; /**< format */ uint32_t mask[MAX_SUPPORTED_CHANNEL_MASKS + 1]; /**< channel mask */ bool jack_status; /**< input/output jack status*/ } dynamic_media_config_t; /** Available stream flags of an audio session*/ typedef enum { PAL_STREAM_FLAG_TIMESTAMP = 0x1, /**< Enable time stamps associated to audio buffers */ PAL_STREAM_FLAG_NON_BLOCKING = 0x2, /**< Stream IO operations are non blocking */ PAL_STREAM_FLAG_MMAP = 0x4, /**< Stream Mode should be in MMAP*/ PAL_STREAM_FLAG_MMAP_NO_IRQ = 0x8, /**< Stream Mode should be No IRQ */ PAL_STREAM_FLAG_EXTERN_MEM = 0x10, /**< Shared memory buffers allocated by client*/ PAL_STREAM_FLAG_SRCM_INBAND = 0x20, /**< MediaFormat change event inband with data buffers*/ PAL_STREAM_FLAG_EOF = 0x40, /**< MediaFormat change event inband with data buffers*/ } pal_stream_flags_t; #define PAL_STREAM_FLAG_NON_BLOCKING_MASK 0x2 #define PAL_STREAM_FLAG_MMAP_MASK 0x4 #define PAL_STREAM_FLAG_MMAP_NO_IRQ_MASK 0x8 /**< PAL stream attributes to be specified, used in pal_stream_open cmd */ struct pal_stream_attributes { pal_stream_type_t type; /**< stream type */ pal_stream_info_t info; /**< stream info */ pal_stream_flags_t flags; /**< stream flags */ pal_stream_direction_t direction; /**< direction of the streams */ struct pal_media_config in_media_config; /**< media config of the input audio samples */ struct pal_media_config out_media_config; /**< media config of the output audio samples */ }; typedef struct pal_callback_config { int32_t noOfPrevDevices, noOfCurrentDevices; pal_device_id_t *prevDevices, *currentDevices; struct pal_stream_attributes streamAttributes; } pal_callback_config_t; /**< Key value pair to identify the topology of a usecase from default */ struct modifier_kv { uint32_t key; uint32_t value; }; /** Metadata flags */ enum { PAL_META_DATA_FLAGS_NONE = 0, }; /** metadata flags, can be OR'able */ typedef uint32_t pal_meta_data_flags_t; typedef struct pal_extern_alloc_buff_info { int alloc_handle;/**< unique memory handle identifying extern mem allocation */ uint32_t alloc_size; /**< size of external allocation */ uint32_t offset; /**< offset of buffer within extern allocation */ } pal_extern_alloc_buff_info_t; /** PAL buffer structure used for reading/writing buffers from/to the stream */ struct pal_buffer { uint8_t *buffer; /**< buffer pointer */ size_t size; /**< number of bytes */ size_t offset; /**< offset in buffer from where valid byte starts */ struct timespec *ts; /**< timestmap */ uint32_t flags; /**< flags */ size_t metadata_size; /**< size of metadata buffer in bytes */ uint8_t *metadata; /**< metadata buffer. Can contain multiple metadata*/ pal_extern_alloc_buff_info_t alloc_info; /**< holds info for extern buff */ uint64_t frame_index; /**< frame index of the buffer */ }; struct pal_clbk_buffer_info { uint64_t frame_index; /**< frame index of the buffer */ uint32_t sample_rate; /**< updated sample rate */ uint32_t bit_width; /**< updated bit width */ uint16_t channel_count; /**< updated channel count */ }; struct pal_callback_buffer { uint8_t *buffer; /**< buffer pointer */ size_t size; /**< filled length of the buffer */ struct timespec *ts; /**< timestamp */ uint32_t status; /**< status of callback payload */ struct pal_clbk_buffer_info cb_buf_info; /**< callback buffer info */ }; /** pal_mmap_buffer flags */ enum { PAL_MMMAP_BUFF_FLAGS_NONE = 0, /** * Only set this flag if applications can access the audio buffer memory * shared with the backend (usually DSP) _without_ security issue. * * Setting this flag also implies that Binder will allow passing the shared memory FD * to applications. * * That usually implies that the kernel will prevent any access to the * memory surrounding the audio buffer as it could lead to a security breach. * * For example, a "/dev/snd/" file descriptor generally is not shareable, * but an "anon_inode:dmabuffer" file descriptor is shareable. * See also Linux kernel's dma_buf. * */ PAL_MMMAP_BUFF_FLAGS_APP_SHAREABLE = 1, }; /** pal_mmap_buffer flags, can be OR'able */ typedef uint32_t pal_mmap_buffer_flags_t; /** PAL buffer structure used for reading/writing buffers from/to the stream */ struct pal_mmap_buffer { void* buffer; /**< base address of mmap memory buffer, for use by local proces only */ int32_t fd; /**< fd for mmap memory buffer */ uint32_t buffer_size_frames; /**< total buffer size in frames */ uint32_t burst_size_frames; /**< transfer size granularity in frames */ pal_mmap_buffer_flags_t flags; /**< Attributes describing the buffer. */ }; /** * Mmap buffer read/write position returned by GetMmapPosition. * note\ Used by streams opened in mmap mode. */ struct pal_mmap_position { int64_t time_nanoseconds; /**< timestamp in ns, CLOCK_MONOTONIC */ int32_t position_frames; /**< increasing 32 bit frame count reset when stop() is called */ }; /** channel mask and volume pair */ struct pal_channel_vol_kv { uint32_t channel_mask; /**< channel mask */ float vol; /**< gain of the channel mask */ }; /** Volume data strucutre defintion used as argument for volume command */ struct pal_volume_data { uint32_t no_of_volpair; /**< no of volume pairs*/ struct pal_channel_vol_kv volume_pair[]; /**< channel mask and volume pair */ }; /** Gain data strucutre defintion used as argument for gain command */ struct pal_gain_data { uint16_t gain; /** Gain value in q13 format **/ uint16_t reserved; }; struct pal_time_us { uint32_t value_lsw; /** Lower 32 bits of 64 bit time value in microseconds */ uint32_t value_msw; /** Upper 32 bits of 64 bit time value in microseconds */ }; /** Timestamp strucutre defintion used as argument for * gettimestamp api */ struct pal_session_time { struct pal_time_us session_time; /** Value of the current session time in microseconds */ struct pal_time_us absolute_time; /** Value of the absolute time in microseconds */ struct pal_time_us timestamp; /** Value of the last processed time stamp in microseconds */ }; /** EVENT configurations data strucutre defintion used as * argument for mute command */ //typedef union { //} pal_event_cfg_t; /** event id of the event generated*/ typedef uint32_t pal_event_id; typedef enum { /** request notification when all accumlated data has be * drained.*/ PAL_DRAIN, /** request notification when drain completes shortly before all * accumlated data of the current track has been played out */ PAL_DRAIN_PARTIAL, } pal_drain_type_t; typedef enum { PAL_PARAM_ID_LOAD_SOUND_MODEL = 0, PAL_PARAM_ID_RECOGNITION_CONFIG = 1, PAL_PARAM_ID_ECNS_ON_OFF = 2, PAL_PARAM_ID_DIRECTION_OF_ARRIVAL = 3, PAL_PARAM_ID_UIEFFECT = 4, PAL_PARAM_ID_STOP_BUFFERING = 5, PAL_PARAM_ID_CODEC_CONFIGURATION = 6, /* Non-Stream Specific Parameters*/ PAL_PARAM_ID_DEVICE_CONNECTION = 7, PAL_PARAM_ID_SCREEN_STATE = 8, PAL_PARAM_ID_CHARGING_STATE = 9, PAL_PARAM_ID_DEVICE_ROTATION = 10, PAL_PARAM_ID_BT_SCO = 11, PAL_PARAM_ID_BT_SCO_WB = 12, PAL_PARAM_ID_BT_SCO_SWB = 13, PAL_PARAM_ID_BT_A2DP_RECONFIG = 14, PAL_PARAM_ID_BT_A2DP_RECONFIG_SUPPORTED = 15, PAL_PARAM_ID_BT_A2DP_SUSPENDED = 16, PAL_PARAM_ID_BT_A2DP_TWS_CONFIG = 17, PAL_PARAM_ID_BT_A2DP_ENCODER_LATENCY = 18, PAL_PARAM_ID_DEVICE_CAPABILITY = 19, PAL_PARAM_ID_GET_SOUND_TRIGGER_PROPERTIES = 20, PAL_PARAM_ID_TTY_MODE = 21, PAL_PARAM_ID_VOLUME_BOOST = 22, PAL_PARAM_ID_SLOW_TALK = 23, PAL_PARAM_ID_SPEAKER_RAS = 24, PAL_PARAM_ID_SP_MODE = 25, PAL_PARAM_ID_GAIN_LVL_MAP = 26, PAL_PARAM_ID_GAIN_LVL_CAL = 27, PAL_PARAM_ID_GAPLESS_MDATA = 28, PAL_PARAM_ID_HD_VOICE = 29, PAL_PARAM_ID_WAKEUP_ENGINE_CONFIG = 30, PAL_PARAM_ID_WAKEUP_BUFFERING_CONFIG = 31, PAL_PARAM_ID_WAKEUP_ENGINE_RESET = 32, PAL_PARAM_ID_WAKEUP_MODULE_VERSION = 33, PAL_PARAM_ID_WAKEUP_CUSTOM_CONFIG = 34, PAL_PARAM_ID_UNLOAD_SOUND_MODEL = 35, PAL_PARAM_ID_MODULE_CONFIG = 36, /*Clients directly configure DSP modules*/ PAL_PARAM_ID_BT_A2DP_LC3_CONFIG = 37, PAL_PARAM_ID_PROXY_CHANNEL_CONFIG = 38, PAL_PARAM_ID_CONTEXT_LIST = 39, PAL_PARAM_ID_HAPTICS_INTENSITY = 40, PAL_PARAM_ID_HAPTICS_VOLUME = 41, PAL_PARAM_ID_BT_A2DP_DECODER_LATENCY = 42, PAL_PARAM_ID_CUSTOM_CONFIGURATION = 43, PAL_PARAM_ID_KW_TRANSFER_LATENCY = 44, PAL_PARAM_ID_BT_A2DP_FORCE_SWITCH = 45, PAL_PARAM_ID_BT_SCO_LC3 = 46, PAL_PARAM_ID_DEVICE_MUTE = 47, PAL_PARAM_ID_UPD_REGISTER_FOR_EVENTS = 48, PAL_PARAM_ID_SP_GET_CAL = 49, PAL_PARAM_ID_BT_A2DP_CAPTURE_SUSPENDED = 50, PAL_PARAM_ID_SNDCARD_STATE = 51, PAL_PARAM_ID_HIFI_PCM_FILTER = 52, PAL_PARAM_ID_CHARGER_STATE = 53, PAL_PARAM_ID_BT_SCO_NREC = 54, PAL_PARAM_ID_VOLUME_USING_SET_PARAM = 55, PAL_PARAM_ID_UHQA_FLAG = 56, PAL_PARAM_ID_STREAM_ATTRIBUTES = 57, PAL_PARAM_ID_SET_UPD_DUTY_CYCLE = 58, PAL_PARAM_ID_MSPP_LINEAR_GAIN = 59, PAL_PARAM_ID_SET_SOURCE_METADATA = 60, PAL_PARAM_ID_SET_SINK_METADATA = 61, PAL_PARAM_ID_ULTRASOUND_RAMPDOWN = 62, PAL_PARAM_ID_VOLUME_CTRL_RAMP = 63, PAL_PARAM_ID_SVA_WAKEUP_MODULE_VERSION = 64, PAL_PARAM_ID_GAIN_USING_SET_PARAM = 65, PAL_PARAM_ID_HAPTICS_CNFG = 66, PAL_PARAM_ID_WAKEUP_ENGINE_PER_MODEL_RESET = 67, PAL_PARAM_ID_RECONFIG_ENCODER = 68, PAL_PARAM_ID_VUI_SET_META_DATA = 69, PAL_PARAM_ID_VUI_GET_META_DATA = 70, PAL_PARAM_ID_VUI_CAPTURE_META_DATA = 71, PAL_PARAM_ID_TIMESTRETCH_PARAMS = 72, PAL_PARAM_ID_LATENCY_MODE = 73, PAL_PARAM_ID_ST_CAPTURE_INFO = 74, PAL_PARAM_ID_RESOURCES_AVAILABLE = 75, PAL_PARAM_ID_PROXY_RECORD_SESSION = 76, PAL_PARAM_ID_ASR_MODEL = 77, PAL_PARAM_ID_ASR_CONFIG = 78, PAL_PARAM_ID_ASR_CUSTOM = 79, PAL_PARAM_ID_ASR_FORCE_OUTPUT = 80, PAL_PARAM_ID_ASR_OUTPUT = 81, PAL_PARAM_ID_ASR_SET_PARAM = 82, PAL_PARAM_ID_HAPTICS_MODE = 83, #ifdef SEC_AUDIO_LOOPBACK_TEST PAL_PARAM_ID_LOOPBACK_MODE = 1001, #endif #if defined(SEC_AUDIO_DUAL_SPEAKER) || defined(SEC_AUDIO_SCREEN_MIRRORING) // { SUPPORT_VOIP_VIA_SMART_VIEW PAL_PARAM_ID_SPEAKER_STATUS = 1002, #endif // } SUPPORT_VOIP_VIA_SMART_VIEW #ifdef SEC_AUDIO_FMRADIO PAL_PARAM_ID_FMRADIO_USB_GAIN = 1004, #endif #ifdef SEC_AUDIO_SUPPORT_HAPTIC_PLAYBACK PAL_PARAM_ID_HAPTIC_SOURCE = 1005, #endif #ifdef SEC_AUDIO_CALL_VOIP PAL_PARAM_ID_MIC_MODE = 1006, PAL_PARAM_ID_VOIP_MIC_MODE = 1007, #endif #ifdef SEC_PRODUCT_FEATURE_BLUETOOTH_SUPPORT_A2DP_OFFLOAD PAL_PARAM_ID_BT_A2DP_DYN_BITRATE = 2001, PAL_PARAM_ID_BT_A2DP_SBM_CONFIG = 2002, PAL_PARAM_ID_BT_A2DP_DELAY_REPORT = 2003, #endif #ifdef SEC_AUDIO_BLE_OFFLOAD PAL_PARAM_ID_BT_A2DP_SUSPENDED_FOR_BLE = 2004, #endif #ifdef SEC_AUDIO_BLUETOOTH PAL_PARAM_ID_BT_SCO_CODEC_TYPE = 2005, #endif #ifdef SEC_AUDIO_SPEAKER_CALIBRATION PAL_PARAM_ID_SEPAKER_AMP_RUN_CAL = 3000, #endif #ifdef SEC_AUDIO_AMP_SDHMS PAL_PARAM_ID_SPEAKER_AMP_TEMPERATURE_RCV = 3001, PAL_PARAM_ID_SPEAKER_AMP_TEMPERATURE_SPK = 3002, #endif #ifdef SEC_AUDIO_AMP_BIGDATA PAL_PARAM_ID_SPEAKER_AMP_BIGDATA_SAVE_RESET = 3003, PAL_PARAM_ID_SPEAKER_AMP_BIGDATA_SAVE = 3004, PAL_PARAM_ID_SPEAKER_AMP_BIGDATA_START = 3005, PAL_PARAM_ID_SPEAKER_AMP_BIGDATA_STOP = 3006, #endif #ifdef SEC_AUDIO_BARGEIN_MODE PAL_PARAM_ID_BARGEIN_MODE = 3007, #endif #ifdef SEC_AUDIO_INTERPRETER_MODE PAL_PARAM_ID_INTERPRETER_MODE = 3008, #endif #ifdef SEC_AUDIO_RECORDALIVE_SUPPORT_MULTIDEVICE_PROVIDEO PAL_PARAM_ID_BTMIX_RECORD = 3009, #endif } pal_param_id_type_t; /** HDMI/DP */ // START: MST ================================================== #define MAX_CONTROLLERS 1 #define MAX_STREAMS_PER_CONTROLLER 2 // END: MST ================================================== /** Audio parameter data*/ typedef struct pal_param_proxy_channel_config { uint32_t num_proxy_channels; } pal_param_proxy_channel_config_t; struct pal_param_context_list { uint32_t num_contexts; uint32_t context_id[]; /* list of num_contexts context_id */ }; struct pal_param_disp_port_config_params { int controller; int stream; }; struct pal_usb_device_address { int card_id; int device_num; #ifdef SEC_AUDIO_USB_GAIN_CONTROL int vid; int pid; struct audio_route *usb_ar; #endif }; typedef union { struct pal_param_disp_port_config_params dp_config; struct pal_usb_device_address usb_addr; } pal_device_config_t; struct pal_amp_db_and_gain_table { float amp; float db; uint32_t level; }; struct pal_vol_ctrl_ramp_param { uint32_t ramp_period_ms; }; /* Payload For ID: PAL_PARAM_ID_DEVICE_CONNECTION * Description : Device Connection */ typedef struct pal_param_device_connection { pal_device_id_t id; bool connection_state; pal_device_config_t device_config; #ifdef SEC_AUDIO_BT_OFFLOAD bool is_bt_offload_enabled; #endif } pal_param_device_connection_t; /* Payload For ID: PAL_PARAM_ID_GAIN_LVL_MAP * Description : get gain level mapping */ typedef struct pal_param_gain_lvl_map { struct pal_amp_db_and_gain_table *mapping_tbl; int table_size; int filled_size; } pal_param_gain_lvl_map_t; /* Payload For ID: PAL_PARAM_ID_GAIN_LVL_CAL * Description : set gain level calibration */ typedef struct pal_param_gain_lvl_cal { int level; } pal_param_gain_lvl_cal_t; /* Payload For ID: PAL_PARAM_ID_MSPP_LINEAR_GAIN * Description : set linear gain for MSPP */ typedef struct pal_param_mspp_linear_gain { int32_t gain; } pal_param_mspp_linear_gain_t; /* * payload for playspeed and pitch */ typedef struct pal_param_playback_rate { float speed; float pitch; } pal_param_playback_rate_t; /* Payload For ID: PAL_PARAM_ID_DEVICE_CAPABILITY * Description : get Device Capability */ typedef struct pal_param_device_capability { pal_device_id_t id; struct pal_usb_device_address addr; bool is_playback; struct dynamic_media_config *config; } pal_param_device_capability_t; /* Payload For ID: PAL_PARAM_ID_SCREEN_STATE * Description : Screen State */ typedef struct pal_param_screen_state { bool screen_state; } pal_param_screen_state_t; /* Payload For ID: PAL_PARAM_ID_CHARGING_STATE * Description : Charging State */ typedef struct pal_param_charging_state { bool charging_state; } pal_param_charging_state_t; /* Payload For ID: PAL_PARAM_ID_CHARGER_STATE * Description : Charger State */ typedef struct pal_param_charger_state { bool is_charger_online; bool is_concurrent_boost_enable; } pal_param_charger_state_t; /* Payload For ID: PAL_PARAM_ID_ST_CAPTURE_INFO * Description : Capture pal_handle in resource_manager */ typedef struct pal_param_st_capture_info { int capture_handle; pal_stream_handle_t *pal_handle; } pal_param_st_capture_info_t; /* Payload For ID: PAL_PARAM_ID_RESOURCES_AVAILABLE * Description : capture callback and cookie in resource_manager */ typedef struct pal_param_resources_available { void* callback; uint64_t cookie; } pal_param_resources_available_t; /* * Used to identify the swapping type */ typedef enum { PAL_SPEAKER_ROTATION_LR, /* Default position. It will be set when device * is at angle 0, 90 or 180 degree. */ PAL_SPEAKER_ROTATION_RL /* This will be set if device is rotated by 270 * degree */ } pal_speaker_rotation_type; #ifdef SEC_AUDIO_CALL_RECORD enum { PAL_CALL_RECORD_RX_TX_NON_MIX = PAL_SPEAKER_ROTATION_RL }; #endif /* Payload For ID: PAL_PARAM_ID_DEVICE_ROTATION * Description : Device Rotation */ typedef struct pal_param_device_rotation { pal_speaker_rotation_type rotation_type; } pal_param_device_rotation_t; #ifndef SEC_AUDIO_SUPPORT_UHQ // use pal_param_uhqa_state define on SecPalDefs.h /* Payload For ID: PAL_PARAM_ID_UHQA_FLAG * Description : use to enable/disable USB high quality audio from userend */ typedef struct pal_param_uhqa_state { bool uhqa_state; } pal_param_uhqa_t; #endif /* Payload For ID: PAL_PARAM_ID_HAPTICS_CNFG * Description : Store the haptics param and use while extracting info from xml */ typedef struct pal_param_haptics_cnfg_t { pal_stream_haptics_type_t mode; int16_t effect_id; float amplitude; int16_t strength; int32_t time; int16_t ch_mask; bool isCompose; int32_t buffer_size; uint8_t *buffer_ptr; } pal_param_haptics_cnfg_t; /* Payload For ID: PAL_PARAM_ID_BT_SCO* * Description : BT SCO related device parameters */ static const char* lc3_reserved_params[] = { "StreamMap", "Codec", "FrameDuration", "rxconfig_index", "txconfig_index", "version", "Blocks_forSDU", "vendor", }; enum { LC3_STREAM_MAP_BIT = 0x1, LC3_CODEC_BIT = 0x1 << 1, LC3_FRAME_DURATION_BIT = 0x1 << 2, LC3_RXCFG_IDX_BIT = 0x1 << 3, LC3_TXCFG_IDX_BIT = 0x1 << 4, LC3_VERSION_BIT = 0x1 << 5, LC3_BLOCKS_FORSDU_BIT = 0x1 << 6, LC3_VENDOR_BIT = 0x1 << 7, LC3_BIT_ALL = LC3_STREAM_MAP_BIT | LC3_CODEC_BIT | LC3_FRAME_DURATION_BIT | LC3_RXCFG_IDX_BIT | LC3_TXCFG_IDX_BIT | LC3_VERSION_BIT | LC3_BLOCKS_FORSDU_BIT | LC3_VENDOR_BIT, LC3_BIT_MASK = LC3_BIT_ALL & ~LC3_FRAME_DURATION_BIT, // frame duration is optional LC3_BIT_VALID = LC3_BIT_MASK, }; /* max length of streamMap string, up to 16 stream id supported */ #define PAL_LC3_MAX_STRING_LEN 200 typedef struct btsco_lc3_cfg { uint32_t fields_map; uint32_t rxconfig_index; uint32_t txconfig_index; uint32_t api_version; uint32_t frame_duration; uint32_t num_blocks; uint32_t mode; char streamMap[PAL_LC3_MAX_STRING_LEN]; char vendor[PAL_LC3_MAX_STRING_LEN]; } btsco_lc3_cfg_t; #ifdef SEC_AUDIO_BLUETOOTH typedef enum { PAL_BT_SCO_CODEC_TYPE_NONE, PAL_BT_SCO_CODEC_TYPE_RVP, } pal_bt_sco_codec_t; #endif typedef struct pal_param_btsco { bool bt_sco_on; bool bt_wb_speech_enabled; bool bt_sco_nrec; int bt_swb_speech_mode; bool bt_lc3_speech_enabled; btsco_lc3_cfg_t lc3_cfg; bool is_bt_hfp; #ifdef SEC_AUDIO_BLUETOOTH pal_bt_sco_codec_t bt_sco_codec_type; #endif } pal_param_btsco_t; /* Payload For ID: PAL_PARAM_ID_BT_A2DP* * Description : A2DP related device setParameters */ typedef struct pal_param_bta2dp { int32_t reconfig_supported; bool reconfig; bool a2dp_suspended; bool a2dp_capture_suspended; bool is_tws_mono_mode_on; bool is_lc3_mono_mode_on; bool is_force_switch; uint32_t latency; pal_device_id_t dev_id; bool is_suspend_setparam; bool is_in_call; #ifdef SEC_AUDIO_BT_OFFLOAD bool is_bt_offload_enabled; #endif #ifdef SEC_AUDIO_BLE_OFFLOAD bool a2dp_suspended_for_ble; uint32_t bt_mix_latency; #endif } pal_param_bta2dp_t; /* Payload For ID: PAL_PARAM_ID_LATENCY_MODE * Description : Get supported or set latency modes */ typedef struct pal_param_latency_mode { pal_device_id_t dev_id; size_t num_modes; /* number of supported modes */ uint32_t modes[PAL_MAX_LATENCY_MODES]; /* list of supported modes or use mode[0] for set latency mode */ } pal_param_latency_mode_t; typedef struct pal_param_upd_event_detection { bool register_status; } pal_param_upd_event_detection_t; typedef struct pal_bt_tws_payload_s { bool isTwsMonoModeOn; uint32_t codecFormat; } pal_bt_tws_payload; /* Payload For Custom Config * Description : Used by PAL client to customize * the device related information. */ #define PAL_MAX_CUSTOM_KEY_SIZE 128 typedef struct pal_device_custom_config { char custom_key[PAL_MAX_CUSTOM_KEY_SIZE]; } pal_device_custom_config_t; #ifdef SEC_AUDIO_LOOPBACK_TEST /* * Used to identify the factory loopback mode type */ typedef enum { PAL_LOOPBACK_PACKET_DELAY_MODE, PAL_LOOPBACK_PACKET_NO_DELAY_MODE, PAL_LOOPBACK_MODE_MAX } pal_loopback_mode; /* Payload For ID: PAL_PARAM_ID_LOOPBACK_MODE * Description : loopback mode */ typedef struct pal_param_loopback { pal_loopback_mode loopback_mode; } pal_param_loopback_t; #endif #ifdef SEC_PRODUCT_FEATURE_BLUETOOTH_SUPPORT_A2DP_OFFLOAD typedef struct pal_param_ss_pack_a2dp_suspend { uint16_t a2dp_suspend; } pal_param_ss_pack_a2dp_suspend_t; typedef struct pal_param_bta2dp_dynbitrate { uint32_t bitrate; } pal_param_bta2dp_dynbitrate_t; typedef struct pal_param_bta2dp_delay_report { uint32_t delay_report; } pal_param_bta2dp_delay_report_t; typedef struct pal_param_bta2dp_sbm { int firstParam; int secondParam; } pal_param_bta2dp_sbm_t; #endif typedef struct pal_bt_lc3_payload_s { bool isLC3MonoModeOn; } pal_bt_lc3_payload; typedef struct pal_param_haptics_intensity { int intensity; } pal_param_haptics_intensity_t; #ifdef SEC_AUDIO_BARGEIN_MODE typedef struct pal_param_bargein_mode { int mode; } pal_param_bargein_mode_t; #endif #ifdef SEC_AUDIO_INTERPRETER_MODE typedef struct pal_param_interpreter_mode { int mode; } pal_param_interpreter_mode_t; #endif #ifdef SEC_AUDIO_RECORDALIVE_SUPPORT_MULTIDEVICE_PROVIDEO typedef struct pal_param_btmix_record { bool enable; } pal_param_btmix_record_t; #endif /**< PAL device */ #define DEVICE_NAME_MAX_SIZE 128 struct pal_device { pal_device_id_t id; /**< device id */ struct pal_media_config config; /**< media config of the device */ struct pal_usb_device_address address; char sndDevName[DEVICE_NAME_MAX_SIZE]; pal_device_custom_config_t custom_config; /**< Optional */ }; /** * Maps the modules instance id to module id for a single module */ struct module_info { uint32_t module_id; /**< module id */ uint32_t module_iid; /**< globally unique module instance id */ }; /** * Structure mapping the tag_id to module info (mid and miid) */ struct pal_tag_module_mapping { uint32_t tag_id; /**< tag id of the module */ uint32_t num_modules; /**< number of modules matching the tag_id */ struct module_info mod_list[]; /**< module list */ }; /** * Used to return tags and module info data to client given a graph key vector */ struct pal_tag_module_info { /**< number of tags */ uint32_t num_tags; /**< variable payload of type struct pal_tag_module_mapping*/ uint8_t pal_tag_module_list[]; }; #define PAL_SOUND_TRIGGER_MAX_STRING_LEN 64 /* max length of strings in properties or descriptor structs */ #define PAL_SOUND_TRIGGER_MAX_LOCALE_LEN 6 /* max length of locale string. e.g en_US */ #define PAL_SOUND_TRIGGER_MAX_USERS 10 /* max number of concurrent users */ #define PAL_SOUND_TRIGGER_MAX_PHRASES 10 /* max number of concurrent phrases */ #define PAL_RECOGNITION_MODE_VOICE_TRIGGER 0x1 /* simple voice trigger */ #define PAL_RECOGNITION_MODE_USER_IDENTIFICATION 0x2 /* trigger only if one user in model identified */ #define PAL_RECOGNITION_MODE_USER_AUTHENTICATION 0x4 /* trigger only if one user in mode authenticated */ #define PAL_RECOGNITION_MODE_GENERIC_TRIGGER 0x8 /* generic sound trigger */ #define PAL_RECOGNITION_STATUS_SUCCESS 0 #define PAL_RECOGNITION_STATUS_ABORT 1 #define PAL_RECOGNITION_STATUS_FAILURE 2 #define PAL_RECOGNITION_STATUS_GET_STATE_RESPONSE 3 /* Indicates that the recognition event is in response to a state request and was not triggered by a real DSP recognition */ /** used to identify the sound model type for the session */ typedef enum { PAL_SOUND_MODEL_TYPE_UNKNOWN = -1, /* use for unspecified sound model type */ PAL_SOUND_MODEL_TYPE_KEYPHRASE = 0, /* use for key phrase sound models */ PAL_SOUND_MODEL_TYPE_GENERIC = 1 /* use for all models other than keyphrase */ } pal_st_sound_model_type_t; struct st_uuid { uint32_t timeLow; uint16_t timeMid; uint16_t timeHiAndVersion; uint16_t clockSeq; uint8_t node[6]; }; /** * sound trigger implementation descriptor read by the framework via get_properties(). * Used by SoundTrigger service to report to applications and manage concurrency and policy. */ struct pal_st_properties { int8_t implementor[PAL_SOUND_TRIGGER_MAX_STRING_LEN]; /* implementor name */ int8_t description[PAL_SOUND_TRIGGER_MAX_STRING_LEN]; /* implementation description */ uint32_t version; /* implementation version */ struct st_uuid uuid; /* unique implementation ID. Must change with version each version */ uint32_t max_sound_models; /* maximum number of concurrent sound models loaded */ uint32_t max_key_phrases; /* maximum number of key phrases */ uint32_t max_users; /* maximum number of concurrent users detected */ uint32_t recognition_modes; /* all supported modes. e.g PAL_RECOGNITION_MODE_VOICE_TRIGGER */ bool capture_transition; /* supports seamless transition from detection to capture */ uint32_t max_buffer_ms; /* maximum buffering capacity in ms if capture_transition is true*/ bool concurrent_capture; /* supports capture by other use cases while detection is active */ bool trigger_in_event; /* returns the trigger capture in event */ uint32_t power_consumption_mw; /* Rated power consumption when detection is active with TDB silence/sound/speech ratio */ }; /** sound model structure passed in by ST Client during pal_st_load_sound_model() */ struct pal_st_sound_model { pal_st_sound_model_type_t type; /* model type. e.g. PAL_SOUND_MODEL_TYPE_KEYPHRASE */ struct st_uuid uuid; /* unique sound model ID. */ struct st_uuid vendor_uuid; /* unique vendor ID. Identifies the engine the sound model was build for */ uint32_t data_size; /* size of opaque model data */ uint32_t data_offset; /* offset of opaque data start from head of struct e.g sizeof struct pal_st_sound_model) */ }; /** key phrase descriptor */ struct pal_st_phrase { uint32_t id; /**< keyphrase ID */ uint32_t recognition_mode; /**< recognition modes supported by this key phrase */ uint32_t num_users; /**< number of users in the key phrase */ uint32_t users[PAL_SOUND_TRIGGER_MAX_USERS]; /**< users ids: (not uid_t but sound trigger specific IDs */ char locale[PAL_SOUND_TRIGGER_MAX_LOCALE_LEN]; /**< locale - JAVA Locale style (e.g. en_US) */ char text[PAL_SOUND_TRIGGER_MAX_STRING_LEN]; /**< phrase text in UTF-8 format. */ }; /** * Specialized sound model for key phrase detection. * Proprietary representation of key phrases in binary data must match information indicated * by phrases field use this when not sending */ struct pal_st_phrase_sound_model { struct pal_st_sound_model common; /** common sound model */ uint32_t num_phrases; /** number of key phrases in model */ struct pal_st_phrase phrases[PAL_SOUND_TRIGGER_MAX_PHRASES]; }; struct pal_st_confidence_level { uint32_t user_id; /* user ID */ uint32_t level; /* confidence level in percent (0 - 100). - min level for recognition configuration - detected level for recognition event */ }; /** Specialized recognition event for key phrase detection */ struct pal_st_phrase_recognition_extra { uint32_t id; /* keyphrase ID */ uint32_t recognition_modes; /* recognition modes used for this keyphrase */ uint32_t confidence_level; /* confidence level for mode RECOGNITION_MODE_VOICE_TRIGGER */ uint32_t num_levels; /* number of user confidence levels */ struct pal_st_confidence_level levels[PAL_SOUND_TRIGGER_MAX_USERS]; }; struct pal_st_recognition_event { int32_t status; /**< recognition status e.g. RECOGNITION_STATUS_SUCCESS */ pal_st_sound_model_type_t type; /**< event type, same as sound model type. e.g. SOUND_MODEL_TYPE_KEYPHRASE */ pal_st_handle_t *st_handle; /**< handle of sound trigger session */ bool capture_available; /**< it is possible to capture audio from this utterance buffered by the implementation */ int32_t capture_session; /**< audio session ID. framework use */ int32_t capture_delay_ms; /**< delay in ms between end of model detection and start of audio available for capture. A negative value is possible (e.g. if key phrase is also available for capture */ int32_t capture_preamble_ms; /**< duration in ms of audio captured before the start of the trigger. 0 if none. */ bool trigger_in_data; /**< the opaque data is the capture of the trigger sound */ struct pal_media_config media_config; /**< media format of either the trigger in event data or to use for capture of the rest of the utterance */ uint32_t data_size; /**< size of opaque event data */ uint32_t data_offset; /**< offset of opaque data start from start of this struct (e.g sizeof struct sound_trigger_phrase_recognition_event) */ }; typedef void(*pal_st_recognition_callback_t)(struct pal_st_recognition_event *event, uint8_t *cookie); /* Payload for pal_st_start_recognition() */ struct pal_st_recognition_config { int32_t capture_handle; /**< IO handle that will be used for capture. N/A if capture_requested is false */ uint32_t capture_device; /**< input device requested for detection capture */ bool capture_requested; /**< capture and buffer audio for this recognition instance */ uint32_t num_phrases; /**< number of key phrases recognition extras */ struct pal_st_phrase_recognition_extra phrases[PAL_SOUND_TRIGGER_MAX_PHRASES]; /**< configuration for each key phrase */ pal_st_recognition_callback_t callback; /**< callback for recognition events */ uint8_t * cookie; /**< cookie set from client*/ uint32_t data_size; /**< size of opaque capture configuration data */ uint32_t data_offset; /**< offset of opaque data start from start of this struct (e.g sizeof struct sound_trigger_recognition_config) */ }; struct pal_st_phrase_recognition_event { struct pal_st_recognition_event common; uint32_t num_phrases; struct pal_st_phrase_recognition_extra phrase_extras[PAL_SOUND_TRIGGER_MAX_PHRASES]; }; struct pal_st_generic_recognition_event { struct pal_st_recognition_event common; }; struct detection_engine_config_voice_wakeup { uint16_t mode; uint16_t custom_payload_size; uint8_t num_active_models; uint8_t reserved; uint8_t confidence_levels[PAL_SOUND_TRIGGER_MAX_USERS]; uint8_t keyword_user_enables[PAL_SOUND_TRIGGER_MAX_USERS]; }; struct detection_engine_config_stage1_pdk { uint16_t mode; uint16_t custom_payload_size; uint32_t model_id; uint32_t num_keywords; uint32_t confidence_levels[MAX_KEYWORD_SUPPORTED]; }; struct detection_engine_multi_model_buffering_config { uint32_t model_id; uint32_t hist_buffer_duration_in_ms; uint32_t pre_roll_duration_in_ms; }; struct ffv_doa_tracking_monitor_t { int16_t target_angle_L16[2]; int16_t interf_angle_L16[2]; int8_t polarActivityGUI[360]; }; struct __attribute__((__packed__)) version_arch_payload { unsigned int version; char arch[64]; }; typedef enum { PAL_ASR_EVENT_STATUS_SUCCESS = 0, PAL_ASR_EVENT_STATUS_ABORTED = 1, } pal_asr_event_status_t; typedef enum { PAL_ASR_STATUS_SUCCESS = 0, PAL_ASR_STATUS_INVALID = -1, PAL_ASR_STATUS_RESOURCE_CONTENTION = -2, PAL_ASR_STATUS_OPERATION_NOT_SUPPORTED = -3, PAL_ASR_STATUS_FAILURE = -4, } pal_asr_status_t; /* Payload for ID : PAL_PARAM_ID_ASR_MODEL. * Description: To be used to pass ASR model. */ struct pal_asr_model { struct st_uuid vendor_uuid; /**< Unique vendor ID. Identifies the engine the model was build for */ int32_t fd; /**< ASR model */ uint32_t size; /**< ASR model size */ }; /* Payload for ID : PAL_PARAM_ID_ASR_CONFIG. * Description: To be used to pass ASR input configuration. */ struct pal_asr_config { int32_t input_language_code; /**< input language code */ int32_t output_language_code; /**< output language code */ bool enable_language_detection; /**< language detection switch enable/disable flag */ bool enable_translation; /**< translation switch enable/disable flag */ bool enable_continuous_mode; /**< continuous mode enable/disable flag */ bool enable_partial_transcription; /**< partial transcription switch enable/disable flag */ uint32_t threshold; /**< Confidence threshold for ASR transcription */ uint32_t timeout_duration; /**< ASR processing timeout, in milliseconds, if silence is not detected after the speech processing is started*/ uint32_t silence_detection_duration; /**< "No speech" duration needed before determining speech has ended (in ms) */ bool outputBufferMode; /**< Buffer mode enable/disable */ uint32_t data_size; /**< Additional Engine specific custom data size */ uint8_t data[]; /**< custom data offset from the start of this structure */ }; #define MAX_TRANSCRIPTION_CHAR_SIZE 1024 #define MAX_JSON_CHAR_SIZE 4096 struct pal_asr_engine_event { bool is_final; /**< Final transcription after end of speech is detected. */ uint32_t confidence; /**< Confidence for the entire transcription */ uint32_t text_size; /**< Size of text to sent to the client */ char text[MAX_TRANSCRIPTION_CHAR_SIZE]; /**< Text to be sent to the client */ uint32_t json_size; /**< size of JSON output, to be sent to client */ char result_json[MAX_JSON_CHAR_SIZE]; /**< JSON result */ uint32_t data_size; /**< event payload size */ uint8_t data[]; /**< event payload offset from the start of this structure */ }; /* Payload to be used for callback for ASR event through pal_stream_callback */ struct pal_asr_event { pal_asr_event_status_t status; uint32_t num_events; struct pal_asr_engine_event event[]; }; struct pal_compr_gapless_mdata { uint32_t encoderDelay; uint32_t encoderPadding; }; typedef struct pal_device_mute_t { pal_stream_direction_t dir; bool mute; }pal_device_mute_t; /** * Event payload passed to client with PAL_STREAM_CBK_EVENT_READ_DONE and * PAL_STREAM_CBK_EVENT_WRITE_READY events */ struct pal_event_read_write_done_payload { uint32_t tag; /**< tag that was used to read/write this buffer */ uint32_t status; /**< data buffer status as defined in ar_osal_error.h */ uint32_t md_status; /**< meta-data status as defined in ar_osal_error.h */ struct pal_buffer buff; /**< buffer that was passed to pal_stream_read/pal_stream_write */ }; /** @brief Callback function prototype to be given for * pal_open_stream. * * \param[in] stream_handle - stream handle associated with the * callback event. * \param[in] event_id - event id of the event raised on the * stream. * \param[in] event_data - event_data specific to the event * raised. * \param[in] cookie - cookie speificied in the * pal_stream_open() */ typedef int32_t (*pal_stream_callback)(pal_stream_handle_t *stream_handle, uint32_t event_id, uint32_t *event_data, uint32_t event_data_size, uint64_t cookie); /** @brief Callback function prototype to be given for * pal_audio_event_callback. * * \param[in] config - configuration data related to * stream and device. * \param[in] event - event raised on the stream. * \param[in] isregister - specifies if it is called * during register of callback. */ typedef int32_t (*pal_audio_event_callback)(pal_callback_config_t *config, uint32_t event, bool isregister); /** @brief Callback function prototype to be given for * pal_register_callback. * * \param[in] event_id - event id of the event raised on the * stream. * \param[in] event_data - event_data specific to the event * raised. * \param[in] cookie - cookie specified in the * pal_register_global_callback. */ typedef int32_t (*pal_global_callback)(uint32_t event_id, uint32_t *event_data, uint64_t cookie); /** Sound card state */ typedef enum card_status_t { CARD_STATUS_OFFLINE = 0, CARD_STATUS_ONLINE, CARD_STATUS_STANDBY, CARD_STATUS_NONE, } card_status_t; #define PAL_CARD_STATUS_DOWN(n) (n == CARD_STATUS_OFFLINE || n == CARD_STATUS_STANDBY) #define PAL_CARD_STATUS_UP(n) (n == CARD_STATUS_ONLINE) typedef struct pal_buffer_config { size_t buf_count; /**< number of buffers*/ size_t buf_size; /**< This would be the size of each buffer*/ size_t max_metadata_size; /** < max metadata size associated with each buffer*/ } pal_buffer_config_t; #define PAL_GENERIC_PLATFORM_DELAY (29*1000LL) #define PAL_DEEP_BUFFER_PLATFORM_DELAY (29*1000LL) #define PAL_SPATIAL_AUDIO_PLATFORM_DELAY (13*1000LL) #define PAL_PCM_OFFLOAD_PLATFORM_DELAY (30*1000LL) #define PAL_LOW_LATENCY_PLATFORM_DELAY (13*1000LL) #define PAL_MMAP_PLATFORM_DELAY (3*1000LL) #define PAL_ULL_PLATFORM_DELAY (4*1000LL) #define PAL_VOIP_PLATFORM_DELAY (29*1000LL) #define PAL_GENERIC_OUTPUT_PERIOD_DURATION 40 #define PAL_DEEP_BUFFER_OUTPUT_PERIOD_DURATION 40 #define PAL_PCM_OFFLOAD_OUTPUT_PERIOD_DURATION 80 #define PAL_LOW_LATENCY_OUTPUT_PERIOD_DURATION 5 #define PAL_SPATIAL_AUDIO_PERIOD_DURATION 10 #define PAL_VOIP_OUTPUT_PERIOD_DURATION 20 #define PAL_ULL_OUTPUT_PERIOD_DURATION 10 #define PAL_GENERIC_PLAYBACK_PERIOD_COUNT 2 #define PAL_DEEP_BUFFER_PLAYBACK_PERIOD_COUNT 2 #define PAL_PCM_OFFLOAD_PLAYBACK_PERIOD_COUNT 2 #define PAL_LOW_LATENCY_PLAYBACK_PERIOD_COUNT 2 #define PAL_SPATIAL_AUDIO_PLAYBACK_PERIOD_COUNT 2 #define PAL_VOIP_PLAYBACK_PERIOD_COUNT 2 #define PAL_ULL_PLAYBACK_PERIOD_COUNT 2 #ifdef __cplusplus } /* extern "C" */ #endif #endif /*PAL_DEFS_H*/