/* * Copyright (c) 2014-2021, The Linux Foundation. All rights reserved. * Not a Contribution. * * Copyright (C) 2014 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. */ #define LOG_TAG "audio_hw_utils" /* #define LOG_NDEBUG 0 */ #include #include #include #include #include #include #include #include #include #include #include #include "audio_hw.h" #include "platform.h" #include "platform_api.h" #include "audio_extn.h" #include "voice_extn.h" #include "voice.h" #include #include #include #include #ifdef DYNAMIC_LOG_ENABLED #include #define LOG_MASK HAL_MOD_FILE_UTILS #include #endif #ifdef AUDIO_EXTERNAL_HDMI_ENABLED #include "audio_parsers.h" #endif #define AUDIO_IO_POLICY_VENDOR_CONFIG_FILE_NAME "audio_io_policy.conf" #define AUDIO_OUTPUT_POLICY_VENDOR_CONFIG_FILE_NAME "audio_output_policy.conf" #define OUTPUTS_TAG "outputs" #define INPUTS_TAG "inputs" #define DYNAMIC_VALUE_TAG "dynamic" #define FLAGS_TAG "flags" #define PROFILES_TAG "profile" #define FORMATS_TAG "formats" #define SAMPLING_RATES_TAG "sampling_rates" #define BIT_WIDTH_TAG "bit_width" #define APP_TYPE_TAG "app_type" #define STRING_TO_ENUM(string) { #string, string } #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) #define BASE_TABLE_SIZE 64 #define MAX_BASEINDEX_LEN 256 #ifndef SND_AUDIOCODEC_TRUEHD #define SND_AUDIOCODEC_TRUEHD 0x00000023 #endif #define APP_TYPE_VOIP_AUDIO 0x1113A #ifdef AUDIO_EXTERNAL_HDMI_ENABLED #define PROFESSIONAL (1<<0) /* 0 = consumer, 1 = professional */ #define NON_LPCM (1<<1) /* 0 = audio, 1 = non-audio */ #define SR_44100 (0<<0) /* 44.1kHz */ #define SR_NOTID (1<<0) /* non indicated */ #define SR_48000 (2<<0) /* 48kHz */ #define SR_32000 (3<<0) /* 32kHz */ #define SR_22050 (4<<0) /* 22.05kHz */ #define SR_24000 (6<<0) /* 24kHz */ #define SR_88200 (8<<0) /* 88.2kHz */ #define SR_96000 (10<<0) /* 96kHz */ #define SR_176400 (12<<0) /* 176.4kHz */ #define SR_192000 (14<<0) /* 192kHz */ #endif /* ToDo: Check and update a proper value in msec */ #define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 50 #define PCM_OFFLOAD_PLAYBACK_DSP_PATHDELAY 62 #define PCM_OFFLOAD_PLAYBACK_LATENCY PCM_OFFLOAD_PLAYBACK_DSP_PATHDELAY #ifndef MAX_CHANNELS_SUPPORTED #define MAX_CHANNELS_SUPPORTED 8 #endif #ifdef __LP64__ #define VNDK_FWK_LIB_PATH "/vendor/lib64/libqti_vndfwk_detect.so" #else #define VNDK_FWK_LIB_PATH "/vendor/lib/libqti_vndfwk_detect.so" #endif typedef struct vndkfwk_s { void *lib_handle; int (*isVendorEnhancedFwk)(void); int (*getVendorEnhancedInfo)(void); const char *lib_name; } vndkfwk_t; static vndkfwk_t mVndkFwk = { NULL, NULL, NULL, VNDK_FWK_LIB_PATH}; typedef struct { const char *id_string; const int value; } mixer_config_lookup; struct string_to_enum { const char *name; uint32_t value; }; const struct string_to_enum s_flag_name_to_enum_table[] = { STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_DIRECT), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_PRIMARY), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_FAST), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_RAW), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_DEEP_BUFFER), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_NON_BLOCKING), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_HW_AV_SYNC), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_INCALL_MUSIC), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_TIMESTAMP), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_VOIP_RX), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_BD), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_INTERACTIVE), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_MEDIA), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_SYS_NOTIFICATION), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_NAV_GUIDANCE), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_PHONE), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_FRONT_PASSENGER), STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_REAR_SEAT), STRING_TO_ENUM(AUDIO_INPUT_FLAG_NONE), STRING_TO_ENUM(AUDIO_INPUT_FLAG_FAST), STRING_TO_ENUM(AUDIO_INPUT_FLAG_HW_HOTWORD), STRING_TO_ENUM(AUDIO_INPUT_FLAG_RAW), STRING_TO_ENUM(AUDIO_INPUT_FLAG_SYNC), STRING_TO_ENUM(AUDIO_INPUT_FLAG_TIMESTAMP), STRING_TO_ENUM(AUDIO_INPUT_FLAG_COMPRESS), STRING_TO_ENUM(AUDIO_INPUT_FLAG_PASSTHROUGH), STRING_TO_ENUM(AUDIO_INPUT_FLAG_MMAP_NOIRQ), STRING_TO_ENUM(AUDIO_INPUT_FLAG_VOIP_TX), STRING_TO_ENUM(AUDIO_INPUT_FLAG_HW_AV_SYNC), STRING_TO_ENUM(AUDIO_INPUT_FLAG_DIRECT), }; const struct string_to_enum s_format_name_to_enum_table[] = { STRING_TO_ENUM(AUDIO_FORMAT_PCM_8_BIT), STRING_TO_ENUM(AUDIO_FORMAT_PCM_16_BIT), STRING_TO_ENUM(AUDIO_FORMAT_PCM_24_BIT_PACKED), STRING_TO_ENUM(AUDIO_FORMAT_PCM_8_24_BIT), STRING_TO_ENUM(AUDIO_FORMAT_PCM_32_BIT), STRING_TO_ENUM(AUDIO_FORMAT_MP3), STRING_TO_ENUM(AUDIO_FORMAT_AAC), STRING_TO_ENUM(AUDIO_FORMAT_VORBIS), STRING_TO_ENUM(AUDIO_FORMAT_AMR_NB), STRING_TO_ENUM(AUDIO_FORMAT_AMR_WB), STRING_TO_ENUM(AUDIO_FORMAT_AC3), STRING_TO_ENUM(AUDIO_FORMAT_E_AC3), STRING_TO_ENUM(AUDIO_FORMAT_DTS), STRING_TO_ENUM(AUDIO_FORMAT_DTS_HD), STRING_TO_ENUM(AUDIO_FORMAT_DOLBY_TRUEHD), STRING_TO_ENUM(AUDIO_FORMAT_IEC61937), STRING_TO_ENUM(AUDIO_FORMAT_E_AC3_JOC), STRING_TO_ENUM(AUDIO_FORMAT_WMA), STRING_TO_ENUM(AUDIO_FORMAT_WMA_PRO), STRING_TO_ENUM(AUDIO_FORMAT_AAC_ADIF), STRING_TO_ENUM(AUDIO_FORMAT_AMR_WB_PLUS), STRING_TO_ENUM(AUDIO_FORMAT_EVRC), STRING_TO_ENUM(AUDIO_FORMAT_EVRCB), STRING_TO_ENUM(AUDIO_FORMAT_EVRCWB), STRING_TO_ENUM(AUDIO_FORMAT_QCELP), STRING_TO_ENUM(AUDIO_FORMAT_MP2), STRING_TO_ENUM(AUDIO_FORMAT_EVRCNW), STRING_TO_ENUM(AUDIO_FORMAT_FLAC), STRING_TO_ENUM(AUDIO_FORMAT_ALAC), STRING_TO_ENUM(AUDIO_FORMAT_APE), STRING_TO_ENUM(AUDIO_FORMAT_AAC_LC), STRING_TO_ENUM(AUDIO_FORMAT_AAC_HE_V1), STRING_TO_ENUM(AUDIO_FORMAT_AAC_HE_V2), STRING_TO_ENUM(AUDIO_FORMAT_AAC_ADTS), STRING_TO_ENUM(AUDIO_FORMAT_AAC_ADTS_LC), STRING_TO_ENUM(AUDIO_FORMAT_AAC_ADTS_HE_V1), STRING_TO_ENUM(AUDIO_FORMAT_AAC_ADTS_HE_V2), STRING_TO_ENUM(AUDIO_FORMAT_DSD), STRING_TO_ENUM(AUDIO_FORMAT_AAC_LATM), STRING_TO_ENUM(AUDIO_FORMAT_AAC_LATM_LC), STRING_TO_ENUM(AUDIO_FORMAT_AAC_LATM_HE_V1), STRING_TO_ENUM(AUDIO_FORMAT_AAC_LATM_HE_V2), STRING_TO_ENUM(AUDIO_FORMAT_APTX), }; /* payload structure avt_device drift query */ struct audio_avt_device_drift_stats { uint32_t minor_version; /* Indicates the device interface direction as either * source (Tx) or sink (Rx). */ uint16_t device_direction; /* Reference timer for drift accumulation and time stamp information. * currently it only support AFE_REF_TIMER_TYPE_AVTIMER */ uint16_t reference_timer; struct audio_avt_device_drift_param drift_param; } __attribute__((packed)); static char bTable[BASE_TABLE_SIZE] = { 'A','B','C','D','E','F','G','H','I','J','K','L', 'M','N','O','P','Q','R','S','T','U','V','W','X', 'Y','Z','a','b','c','d','e','f','g','h','i','j', 'k','l','m','n','o','p','q','r','s','t','u','v', 'w','x','y','z','0','1','2','3','4','5','6','7', '8','9','+','/' }; static uint32_t string_to_enum(const struct string_to_enum *table, size_t size, const char *name) { size_t i; for (i = 0; i < size; i++) { if (strcmp(table[i].name, name) == 0) { ALOGV("%s found %s", __func__, table[i].name); return table[i].value; } } ALOGE("%s cound not find %s", __func__, name); return 0; } static audio_io_flags_t parse_flag_names(char *name) { uint32_t flag = 0; audio_io_flags_t io_flags; char *last_r; char *flag_name = strtok_r(name, "|", &last_r); while (flag_name != NULL) { if (strlen(flag_name) != 0) { flag |= string_to_enum(s_flag_name_to_enum_table, ARRAY_SIZE(s_flag_name_to_enum_table), flag_name); } flag_name = strtok_r(NULL, "|", &last_r); } ALOGV("parse_flag_names: flag - %x", flag); io_flags.in_flags = (audio_input_flags_t)flag; io_flags.out_flags = (audio_output_flags_t)flag; return io_flags; } static void parse_format_names(char *name, struct streams_io_cfg *s_info) { struct stream_format *sf_info = NULL; char *last_r; char *str = strtok_r(name, "|", &last_r); if (str != NULL && strcmp(str, DYNAMIC_VALUE_TAG) == 0) return; list_init(&s_info->format_list); while (str != NULL) { audio_format_t format = (audio_format_t)string_to_enum(s_format_name_to_enum_table, ARRAY_SIZE(s_format_name_to_enum_table), str); ALOGV("%s: format - %d", __func__, format); if (format != 0) { sf_info = (struct stream_format *)calloc(1, sizeof(struct stream_format)); if (sf_info == NULL) break; /* return whatever was parsed */ sf_info->format = format; list_add_tail(&s_info->format_list, &sf_info->list); } str = strtok_r(NULL, "|", &last_r); } } static void parse_sample_rate_names(char *name, struct streams_io_cfg *s_info) { struct stream_sample_rate *ss_info = NULL; uint32_t sample_rate = 48000; char *last_r; char *str = strtok_r(name, "|", &last_r); if (str != NULL && 0 == strcmp(str, DYNAMIC_VALUE_TAG)) return; list_init(&s_info->sample_rate_list); while (str != NULL) { sample_rate = (uint32_t)strtol(str, (char **)NULL, 10); ALOGV("%s: sample_rate - %d", __func__, sample_rate); if (0 != sample_rate) { ss_info = (struct stream_sample_rate *)calloc(1, sizeof(struct stream_sample_rate)); if (!ss_info) { ALOGE("%s: memory allocation failure", __func__); return; } ss_info->sample_rate = sample_rate; list_add_tail(&s_info->sample_rate_list, &ss_info->list); } str = strtok_r(NULL, "|", &last_r); } } static int parse_bit_width_names(char *name) { int bit_width = 16; char *last_r; char *str = strtok_r(name, "|", &last_r); if (str != NULL && strcmp(str, DYNAMIC_VALUE_TAG)) bit_width = (int)strtol(str, (char **)NULL, 10); ALOGV("%s: bit_width - %d", __func__, bit_width); return bit_width; } static int parse_app_type_names(void *platform, char *name) { int app_type = platform_get_default_app_type(platform); char *last_r; char *str = strtok_r(name, "|", &last_r); if (str != NULL && strcmp(str, DYNAMIC_VALUE_TAG)) app_type = (int)strtol(str, (char **)NULL, 10); ALOGV("%s: app_type - %d", __func__, app_type); return app_type; } static void update_streams_cfg_list(cnode *root, void *platform, struct listnode *streams_cfg_list) { cnode *node = root->first_child; struct streams_io_cfg *s_info; ALOGV("%s", __func__); s_info = (struct streams_io_cfg *)calloc(1, sizeof(struct streams_io_cfg)); if (!s_info) { ALOGE("failed to allocate mem for s_info list element"); return; } while (node) { if (strcmp(node->name, FLAGS_TAG) == 0) { s_info->flags = parse_flag_names((char *)node->value); } else if (strcmp(node->name, PROFILES_TAG) == 0) { strlcpy(s_info->profile, (char *)node->value, sizeof(s_info->profile)); } else if (strcmp(node->name, FORMATS_TAG) == 0) { parse_format_names((char *)node->value, s_info); } else if (strcmp(node->name, SAMPLING_RATES_TAG) == 0) { s_info->app_type_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; parse_sample_rate_names((char *)node->value, s_info); } else if (strcmp(node->name, BIT_WIDTH_TAG) == 0) { s_info->app_type_cfg.bit_width = parse_bit_width_names((char *)node->value); } else if (strcmp(node->name, APP_TYPE_TAG) == 0) { s_info->app_type_cfg.app_type = parse_app_type_names(platform, (char *)node->value); } node = node->next; } list_add_tail(streams_cfg_list, &s_info->list); } static void load_cfg_list(cnode *root, void *platform, struct listnode *streams_output_cfg_list, struct listnode *streams_input_cfg_list) { cnode *node = NULL; node = config_find(root, OUTPUTS_TAG); if (node != NULL) { node = node->first_child; while (node) { ALOGV("%s: loading output %s", __func__, node->name); update_streams_cfg_list(node, platform, streams_output_cfg_list); node = node->next; } } else { ALOGI("%s: could not load output, node is NULL", __func__); } node = config_find(root, INPUTS_TAG); if (node != NULL) { node = node->first_child; while (node) { ALOGV("%s: loading input %s", __func__, node->name); update_streams_cfg_list(node, platform, streams_input_cfg_list); node = node->next; } } else { ALOGI("%s: could not load input, node is NULL", __func__); } } static void send_app_type_cfg(void *platform, struct mixer *mixer, struct listnode *streams_output_cfg_list, struct listnode *streams_input_cfg_list) { size_t app_type_cfg[MAX_LENGTH_MIXER_CONTROL_IN_INT] = {0}; int length = 0, i, num_app_types = 0; struct listnode *node; bool update; struct mixer_ctl *ctl = NULL; const char *mixer_ctl_name = "App Type Config"; struct streams_io_cfg *s_info = NULL; uint32_t target_bit_width = 0; if (!mixer) { ALOGE("%s: mixer is null",__func__); return; } ctl = mixer_get_ctl_by_name(mixer, mixer_ctl_name); if (!ctl) { ALOGE("%s: Could not get ctl for mixer cmd - %s",__func__, mixer_ctl_name); return; } app_type_cfg[length++] = num_app_types; if (list_empty(streams_output_cfg_list)) { app_type_cfg[length++] = platform_get_default_app_type_v2(platform, PCM_PLAYBACK); app_type_cfg[length++] = 48000; app_type_cfg[length++] = 16; num_app_types += 1; } if (list_empty(streams_input_cfg_list)) { app_type_cfg[length++] = platform_get_default_app_type_v2(platform, PCM_CAPTURE); app_type_cfg[length++] = 48000; app_type_cfg[length++] = 16; num_app_types += 1; } /* get target bit width for ADM enforce mode */ target_bit_width = adev_get_dsp_bit_width_enforce_mode(); list_for_each(node, streams_output_cfg_list) { s_info = node_to_item(node, struct streams_io_cfg, list); update = true; for (i=0; iapp_type_cfg.app_type) { if (app_type_cfg[i+2] < (size_t)s_info->app_type_cfg.sample_rate) app_type_cfg[i+2] = s_info->app_type_cfg.sample_rate; if (app_type_cfg[i+3] < (size_t)s_info->app_type_cfg.bit_width) app_type_cfg[i+3] = s_info->app_type_cfg.bit_width; /* ADM bit width = max(enforce_bit_width, bit_width from s_info */ if (audio_extn_is_dsp_bit_width_enforce_mode_supported(s_info->flags.out_flags) && (target_bit_width > app_type_cfg[i+3])) app_type_cfg[i+3] = target_bit_width; update = false; break; } } if (update && ((length + 3) <= MAX_LENGTH_MIXER_CONTROL_IN_INT)) { num_app_types += 1; app_type_cfg[length++] = s_info->app_type_cfg.app_type; app_type_cfg[length++] = s_info->app_type_cfg.sample_rate; app_type_cfg[length] = s_info->app_type_cfg.bit_width; if (audio_extn_is_dsp_bit_width_enforce_mode_supported(s_info->flags.out_flags) && (target_bit_width > app_type_cfg[length])) app_type_cfg[length] = target_bit_width; length++; } } list_for_each(node, streams_input_cfg_list) { s_info = node_to_item(node, struct streams_io_cfg, list); update = true; for (i=0; iapp_type_cfg.app_type) { if (app_type_cfg[i+2] < (size_t)s_info->app_type_cfg.sample_rate) app_type_cfg[i+2] = s_info->app_type_cfg.sample_rate; if (app_type_cfg[i+3] < (size_t)s_info->app_type_cfg.bit_width) app_type_cfg[i+3] = s_info->app_type_cfg.bit_width; update = false; break; } } if (update && ((length + 3) <= MAX_LENGTH_MIXER_CONTROL_IN_INT)) { num_app_types += 1; app_type_cfg[length++] = s_info->app_type_cfg.app_type; app_type_cfg[length++] = s_info->app_type_cfg.sample_rate; app_type_cfg[length++] = s_info->app_type_cfg.bit_width; } } ALOGV("%s: num_app_types: %d", __func__, num_app_types); if (num_app_types) { app_type_cfg[0] = num_app_types; mixer_ctl_set_array(ctl, app_type_cfg, length); } } /* Function to retrieve audio vendor configs path */ void audio_get_vendor_config_path (char* config_file_path, int path_size) { char vendor_sku[PROPERTY_VALUE_MAX] = {'\0'}; if (property_get("ro.boot.product.vendor.sku", vendor_sku, "") <= 0) { #ifdef LINUX_ENABLED /* Audio configs are stored in /etc */ snprintf(config_file_path, path_size, "%s", "/etc"); #else /* Audio configs are stored in /vendor/etc */ snprintf(config_file_path, path_size, "%s", "/vendor/etc"); #endif } else { /* Audio configs are stored in /vendor/etc/audio/sku_${vendor_sku} */ snprintf(config_file_path, path_size, "%s%s", "/vendor/etc/audio/sku_", vendor_sku); } } void audio_extn_utils_update_streams_cfg_lists(void *platform, struct mixer *mixer, struct listnode *streams_output_cfg_list, struct listnode *streams_input_cfg_list) { cnode *root; char *data = NULL; char vendor_config_path[VENDOR_CONFIG_PATH_MAX_LENGTH]; char audio_io_policy_file[VENDOR_CONFIG_FILE_MAX_LENGTH]; char audio_output_policy_file[VENDOR_CONFIG_FILE_MAX_LENGTH]; ALOGV("%s", __func__); list_init(streams_output_cfg_list); list_init(streams_input_cfg_list); root = config_node("", ""); if (root == NULL) { ALOGE("cfg_list, NULL config root"); return; } /* Get path for audio configuration files in vendor */ audio_get_vendor_config_path(vendor_config_path, sizeof(vendor_config_path)); /* Get path for audio_io_policy_file in vendor */ snprintf(audio_io_policy_file, sizeof(audio_io_policy_file), "%s/%s", vendor_config_path, AUDIO_IO_POLICY_VENDOR_CONFIG_FILE_NAME); /* Load audio_io_policy_file from vendor */ data = (char *)load_file(audio_io_policy_file, NULL); if (data == NULL) { ALOGD("%s: failed to open io config file(%s), trying older config file", __func__, audio_io_policy_file); /* Get path for audio_output_policy_file in vendor */ snprintf(audio_output_policy_file, sizeof(audio_output_policy_file), "%s/%s", vendor_config_path, AUDIO_OUTPUT_POLICY_VENDOR_CONFIG_FILE_NAME); /* Load audio_output_policy_file from vendor */ data = (char *)load_file(audio_output_policy_file, NULL); if (data == NULL) { send_app_type_cfg(platform, mixer, streams_output_cfg_list, streams_input_cfg_list); ALOGE("%s: could not load io policy config!", __func__); free(root); return; } } config_load(root, data); load_cfg_list(root, platform, streams_output_cfg_list, streams_input_cfg_list); send_app_type_cfg(platform, mixer, streams_output_cfg_list, streams_input_cfg_list); config_free(root); free(root); free(data); } static void audio_extn_utils_dump_streams_cfg_list( struct listnode *streams_cfg_list) { struct listnode *node_i, *node_j; struct streams_io_cfg *s_info; struct stream_format *sf_info; struct stream_sample_rate *ss_info; list_for_each(node_i, streams_cfg_list) { s_info = node_to_item(node_i, struct streams_io_cfg, list); ALOGV("%s: flags-%d, sample_rate-%d, bit_width-%d, app_type-%d", __func__, s_info->flags.out_flags, s_info->app_type_cfg.sample_rate, s_info->app_type_cfg.bit_width, s_info->app_type_cfg.app_type); list_for_each(node_j, &s_info->format_list) { sf_info = node_to_item(node_j, struct stream_format, list); ALOGV("format-%x", sf_info->format); } list_for_each(node_j, &s_info->sample_rate_list) { ss_info = node_to_item(node_j, struct stream_sample_rate, list); ALOGV("sample rate-%d", ss_info->sample_rate); } } } void audio_extn_utils_dump_streams_cfg_lists( struct listnode *streams_output_cfg_list, struct listnode *streams_input_cfg_list) { ALOGV("%s", __func__); audio_extn_utils_dump_streams_cfg_list(streams_output_cfg_list); audio_extn_utils_dump_streams_cfg_list(streams_input_cfg_list); } static void audio_extn_utils_release_streams_cfg_list( struct listnode *streams_cfg_list) { struct listnode *node_i, *node_j; struct streams_io_cfg *s_info; ALOGV("%s", __func__); while (!list_empty(streams_cfg_list)) { node_i = list_head(streams_cfg_list); s_info = node_to_item(node_i, struct streams_io_cfg, list); while (!list_empty(&s_info->format_list)) { node_j = list_head(&s_info->format_list); list_remove(node_j); free(node_to_item(node_j, struct stream_format, list)); } while (!list_empty(&s_info->sample_rate_list)) { node_j = list_head(&s_info->sample_rate_list); list_remove(node_j); free(node_to_item(node_j, struct stream_sample_rate, list)); } list_remove(node_i); free(node_to_item(node_i, struct streams_io_cfg, list)); } } void audio_extn_utils_release_streams_cfg_lists( struct listnode *streams_output_cfg_list, struct listnode *streams_input_cfg_list) { ALOGV("%s", __func__); audio_extn_utils_release_streams_cfg_list(streams_output_cfg_list); audio_extn_utils_release_streams_cfg_list(streams_input_cfg_list); } static bool set_app_type_cfg(struct streams_io_cfg *s_info, struct stream_app_type_cfg *app_type_cfg, uint32_t sample_rate, uint32_t bit_width) { struct listnode *node_i; struct stream_sample_rate *ss_info; list_for_each(node_i, &s_info->sample_rate_list) { ss_info = node_to_item(node_i, struct stream_sample_rate, list); if ((sample_rate <= ss_info->sample_rate) && (bit_width == s_info->app_type_cfg.bit_width)) { app_type_cfg->app_type = s_info->app_type_cfg.app_type; app_type_cfg->sample_rate = ss_info->sample_rate; app_type_cfg->bit_width = s_info->app_type_cfg.bit_width; ALOGV("%s app_type_cfg->app_type %d, app_type_cfg->sample_rate %d, app_type_cfg->bit_width %d", __func__, app_type_cfg->app_type, app_type_cfg->sample_rate, app_type_cfg->bit_width); return true; } } /* * Reiterate through the list assuming dafault sample rate. * Handles scenario where input sample rate is higher * than all sample rates in list for the input bit width. */ sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; list_for_each(node_i, &s_info->sample_rate_list) { ss_info = node_to_item(node_i, struct stream_sample_rate, list); if ((sample_rate <= ss_info->sample_rate) && (bit_width == s_info->app_type_cfg.bit_width)) { app_type_cfg->app_type = s_info->app_type_cfg.app_type; app_type_cfg->sample_rate = sample_rate; app_type_cfg->bit_width = s_info->app_type_cfg.bit_width; ALOGV("%s Assuming sample rate. app_type_cfg->app_type %d, app_type_cfg->sample_rate %d, app_type_cfg->bit_width %d", __func__, app_type_cfg->app_type, app_type_cfg->sample_rate, app_type_cfg->bit_width); return true; } } return false; } void audio_extn_utils_update_stream_input_app_type_cfg(void *platform, struct listnode *streams_input_cfg_list, struct listnode *devices __unused, audio_input_flags_t flags, audio_format_t format, uint32_t sample_rate, uint32_t bit_width, char* profile, struct stream_app_type_cfg *app_type_cfg) { struct listnode *node_i, *node_j; struct streams_io_cfg *s_info; struct stream_format *sf_info; ALOGV("%s: flags: 0x%x, format: 0x%x sample_rate %d, profile %s", __func__, flags, format, sample_rate, profile); list_for_each(node_i, streams_input_cfg_list) { s_info = node_to_item(node_i, struct streams_io_cfg, list); /* Along with flags do profile matching if set at either end.*/ if (s_info->flags.in_flags == flags && ((profile[0] == '\0' && s_info->profile[0] == '\0') || strncmp(s_info->profile, profile, sizeof(s_info->profile)) == 0)) { list_for_each(node_j, &s_info->format_list) { sf_info = node_to_item(node_j, struct stream_format, list); if (sf_info->format == format) { if (set_app_type_cfg(s_info, app_type_cfg, sample_rate, bit_width)) return; } } } } ALOGW("%s: App type could not be selected. Falling back to default", __func__); app_type_cfg->app_type = platform_get_default_app_type_v2(platform, PCM_CAPTURE); app_type_cfg->sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; app_type_cfg->bit_width = 16; } void audio_extn_utils_update_stream_output_app_type_cfg(void *platform, struct listnode *streams_output_cfg_list, struct listnode *devices, audio_output_flags_t flags, audio_format_t format, uint32_t sample_rate, uint32_t bit_width, audio_channel_mask_t channel_mask, char *profile, struct stream_app_type_cfg *app_type_cfg) { struct listnode *node_i, *node_j; struct streams_io_cfg *s_info; struct stream_format *sf_info; char value[PROPERTY_VALUE_MAX] = {0}; if (compare_device_type(devices, AUDIO_DEVICE_OUT_SPEAKER)) { int bw = platform_get_snd_device_bit_width(SND_DEVICE_OUT_SPEAKER); if ((-ENOSYS != bw) && (bit_width > (uint32_t)bw)) bit_width = (uint32_t)bw; else if (-ENOSYS == bw) bit_width = CODEC_BACKEND_DEFAULT_BIT_WIDTH; sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; ALOGI("%s Allowing 24 and above bits playback on speaker ONLY at default sampling rate", __func__); } property_get("vendor.audio.playback.mch.downsample",value,""); if (!strncmp("true", value, sizeof("true"))) { if ((popcount(channel_mask) > 2) && (sample_rate > CODEC_BACKEND_DEFAULT_SAMPLE_RATE) && !(flags & (audio_output_flags_t)AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH)) { sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; ALOGD("%s: MCH session defaulting sample rate to %d", __func__, sample_rate); } } /* Set sampling rate to 176.4 for DSD64 * and 352.8Khz for DSD128. * Set Bit Width to 16. output will be 16 bit * post DoP in ASM. */ if ((flags & (audio_output_flags_t)AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH) && (format == AUDIO_FORMAT_DSD)) { bit_width = 16; if (sample_rate == INPUT_SAMPLING_RATE_DSD64) sample_rate = OUTPUT_SAMPLING_RATE_DSD64; else if (sample_rate == INPUT_SAMPLING_RATE_DSD128) sample_rate = OUTPUT_SAMPLING_RATE_DSD128; } ALOGV("%s: flags: %x, format: %x sample_rate %d, profile %s, app_type %d", __func__, flags, format, sample_rate, profile, app_type_cfg->app_type); list_for_each(node_i, streams_output_cfg_list) { s_info = node_to_item(node_i, struct streams_io_cfg, list); /* Along with flags do profile matching if set at either end.*/ if (s_info->flags.out_flags == flags && ((profile[0] == '\0' && s_info->profile[0] == '\0') || strncmp(s_info->profile, profile, sizeof(s_info->profile)) == 0)) { list_for_each(node_j, &s_info->format_list) { sf_info = node_to_item(node_j, struct stream_format, list); if (sf_info->format == format) { if (set_app_type_cfg(s_info, app_type_cfg, sample_rate, bit_width)) return; } } } } list_for_each(node_i, streams_output_cfg_list) { s_info = node_to_item(node_i, struct streams_io_cfg, list); if (s_info->flags.out_flags == AUDIO_OUTPUT_FLAG_PRIMARY) { ALOGV("Compatible output profile not found."); app_type_cfg->app_type = s_info->app_type_cfg.app_type; app_type_cfg->sample_rate = s_info->app_type_cfg.sample_rate; app_type_cfg->bit_width = s_info->app_type_cfg.bit_width; ALOGV("%s Default to primary output: App type: %d sample_rate %d", __func__, s_info->app_type_cfg.app_type, app_type_cfg->sample_rate); return; } } ALOGW("%s: App type could not be selected. Falling back to default", __func__); app_type_cfg->app_type = platform_get_default_app_type(platform); app_type_cfg->sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; app_type_cfg->bit_width = 16; } static bool audio_is_this_native_usecase(struct audio_usecase *uc) { bool native_usecase = false; struct stream_out *out = (struct stream_out*) uc->stream.out; if (PCM_PLAYBACK == uc->type && out != NULL && NATIVE_AUDIO_MODE_INVALID != platform_get_native_support() && is_offload_usecase(uc->id) && (out->sample_rate == OUTPUT_SAMPLING_RATE_44100)) native_usecase = true; return native_usecase; } bool audio_extn_is_dsp_bit_width_enforce_mode_supported(audio_output_flags_t flags) { /* DSP bitwidth enforce mode for ADM and AFE: * includes: * deep buffer, low latency, direct pcm and offload. * excludes: * ull(raw+fast), VOIP. */ if ((flags & AUDIO_OUTPUT_FLAG_VOIP_RX) || ((flags & AUDIO_OUTPUT_FLAG_RAW) && (flags & AUDIO_OUTPUT_FLAG_FAST))) return false; if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) || (flags & AUDIO_OUTPUT_FLAG_DIRECT) || (flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) || (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) return true; else return false; } static inline bool audio_is_vr_mode_on(struct audio_device *(__attribute__((unused)) adev)) { return adev->vr_audio_mode_enabled; } static void audio_extn_btsco_get_sample_rate(int snd_device, int *sample_rate) { switch (snd_device) { case SND_DEVICE_OUT_BT_SCO: case SND_DEVICE_IN_BT_SCO_MIC: case SND_DEVICE_IN_BT_SCO_MIC_NREC: *sample_rate = 8000; break; case SND_DEVICE_OUT_BT_SCO_WB: case SND_DEVICE_IN_BT_SCO_MIC_WB: case SND_DEVICE_IN_BT_SCO_MIC_WB_NREC: *sample_rate = 16000; break; default: ALOGD("%s:Not a BT SCO device, need not update sampling rate\n", __func__); break; } } void audio_extn_utils_update_stream_app_type_cfg_for_usecase( struct audio_device *adev, struct audio_usecase *usecase) { ALOGV("%s", __func__); switch(usecase->type) { case PCM_PLAYBACK: audio_extn_utils_update_stream_output_app_type_cfg(adev->platform, &adev->streams_output_cfg_list, &usecase->stream.out->device_list, usecase->stream.out->flags, usecase->stream.out->hal_op_format, usecase->stream.out->sample_rate, usecase->stream.out->bit_width, usecase->stream.out->channel_mask, usecase->stream.out->profile, &usecase->stream.out->app_type_cfg); ALOGV("%s Selected apptype: %d", __func__, usecase->stream.out->app_type_cfg.app_type); break; case PCM_CAPTURE: if (usecase->id == USECASE_AUDIO_RECORD_VOIP) usecase->stream.in->app_type_cfg.app_type = APP_TYPE_VOIP_AUDIO; else audio_extn_utils_update_stream_input_app_type_cfg(adev->platform, &adev->streams_input_cfg_list, &usecase->stream.in->device_list, usecase->stream.in->flags, usecase->stream.in->format, usecase->stream.in->sample_rate, usecase->stream.in->bit_width, usecase->stream.in->profile, &usecase->stream.in->app_type_cfg); ALOGV("%s Selected apptype: %d", __func__, usecase->stream.in->app_type_cfg.app_type); break; case TRANSCODE_LOOPBACK_RX : audio_extn_utils_update_stream_output_app_type_cfg(adev->platform, &adev->streams_output_cfg_list, &usecase->stream.inout->out_config.device_list, 0, usecase->stream.inout->out_config.format, usecase->stream.inout->out_config.sample_rate, usecase->stream.inout->out_config.bit_width, usecase->stream.inout->out_config.channel_mask, usecase->stream.inout->profile, &usecase->stream.inout->out_app_type_cfg); ALOGV("%s Selected apptype: %d", __func__, usecase->stream.inout->out_app_type_cfg.app_type); break; case PCM_HFP_CALL: switch (usecase->id) { case USECASE_AUDIO_HFP_SCO: case USECASE_AUDIO_HFP_SCO_WB: audio_extn_btsco_get_sample_rate(usecase->out_snd_device, &usecase->out_app_type_cfg.sample_rate); usecase->in_app_type_cfg.sample_rate = usecase->out_app_type_cfg.sample_rate; break; case USECASE_AUDIO_HFP_SCO_DOWNLINK: case USECASE_AUDIO_HFP_SCO_WB_DOWNLINK: audio_extn_btsco_get_sample_rate(usecase->in_snd_device, &usecase->in_app_type_cfg.sample_rate); usecase->out_app_type_cfg.sample_rate = usecase->in_app_type_cfg.sample_rate; break; default: ALOGE("%s: usecase id (%d) not supported, use default sample rate", __func__, usecase->id); usecase->in_app_type_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; usecase->out_app_type_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; break; } /* update out_app_type_cfg */ usecase->out_app_type_cfg.bit_width = platform_get_snd_device_bit_width(usecase->out_snd_device); usecase->out_app_type_cfg.app_type = platform_get_default_app_type_v2(adev->platform, PCM_PLAYBACK); /* update in_app_type_cfg */ usecase->in_app_type_cfg.bit_width = platform_get_snd_device_bit_width(usecase->in_snd_device); usecase->in_app_type_cfg.app_type = platform_get_default_app_type_v2(adev->platform, PCM_CAPTURE); ALOGV("%s Selected apptype: playback %d capture %d", __func__, usecase->out_app_type_cfg.app_type, usecase->in_app_type_cfg.app_type); break; default: ALOGE("%s: app type cfg not supported for usecase type (%d)", __func__, usecase->type); } } static int set_stream_app_type_mixer_ctrl(struct audio_device *adev, int pcm_device_id, int app_type, int acdb_dev_id, int sample_rate, int stream_type, snd_device_t snd_device) { char mixer_ctl_name[MAX_LENGTH_MIXER_CONTROL_IN_INT]; struct mixer_ctl *ctl; int app_type_cfg[MAX_LENGTH_MIXER_CONTROL_IN_INT], len = 0, rc = 0; int snd_device_be_idx = -1; if (stream_type == PCM_PLAYBACK) { snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Audio Stream %d App Type Cfg", pcm_device_id); } else if (stream_type == PCM_CAPTURE) { snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Audio Stream Capture %d App Type Cfg", pcm_device_id); } ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); if (!ctl) { ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, mixer_ctl_name); rc = -EINVAL; goto exit; } app_type_cfg[len++] = app_type; app_type_cfg[len++] = acdb_dev_id; app_type_cfg[len++] = sample_rate; snd_device_be_idx = platform_get_snd_device_backend_index(snd_device); if (snd_device_be_idx > 0) app_type_cfg[len++] = snd_device_be_idx; ALOGV("%s: stream type %d app_type %d, acdb_dev_id %d " "sample rate %d, snd_device_be_idx %d", __func__, stream_type, app_type, acdb_dev_id, sample_rate, snd_device_be_idx); mixer_ctl_set_array(ctl, app_type_cfg, len); exit: return rc; } static int audio_extn_utils_send_app_type_cfg_hfp(struct audio_device *adev, struct audio_usecase *usecase) { int pcm_device_id, acdb_dev_id = 0, snd_device = usecase->out_snd_device; int32_t sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; int app_type = 0, rc = 0; bool is_bus_dev_usecase = false; ALOGV("%s", __func__); if (usecase->type != PCM_HFP_CALL) { ALOGV("%s: not a HFP path, no need to cfg app type", __func__); rc = 0; goto exit_send_app_type_cfg; } if ((usecase->id != USECASE_AUDIO_HFP_SCO) && (usecase->id != USECASE_AUDIO_HFP_SCO_WB) && (usecase->id != USECASE_AUDIO_HFP_SCO_DOWNLINK) && (usecase->id != USECASE_AUDIO_HFP_SCO_WB_DOWNLINK)) { ALOGV("%s: a usecase where app type cfg is not required", __func__); rc = 0; goto exit_send_app_type_cfg; } if (compare_device_type(&usecase->device_list, AUDIO_DEVICE_OUT_BUS)) is_bus_dev_usecase = true; snd_device = usecase->out_snd_device; pcm_device_id = platform_get_pcm_device_id(usecase->id, PCM_PLAYBACK); acdb_dev_id = platform_get_snd_device_acdb_id(snd_device); if (acdb_dev_id < 0) { ALOGE("%s: Couldn't get the acdb dev id", __func__); rc = -EINVAL; goto exit_send_app_type_cfg; } if (usecase->type == PCM_HFP_CALL) { /* config HFP session:1 playback path */ if (is_bus_dev_usecase) { app_type = usecase->out_app_type_cfg.app_type; sample_rate= usecase->out_app_type_cfg.sample_rate; } else { snd_device = SND_DEVICE_NONE; // use legacy behavior app_type = platform_get_default_app_type_v2(adev->platform, PCM_PLAYBACK); sample_rate= CODEC_BACKEND_DEFAULT_SAMPLE_RATE; } rc = set_stream_app_type_mixer_ctrl(adev, pcm_device_id, app_type, acdb_dev_id, sample_rate, PCM_PLAYBACK, snd_device); if (rc < 0) goto exit_send_app_type_cfg; /* config HFP session:1 capture path */ if (is_bus_dev_usecase) { snd_device = usecase->in_snd_device; pcm_device_id = platform_get_pcm_device_id(usecase->id, PCM_CAPTURE); acdb_dev_id = platform_get_snd_device_acdb_id(snd_device); if (acdb_dev_id < 0) { ALOGE("%s: Couldn't get the acdb dev id", __func__); rc = -EINVAL; goto exit_send_app_type_cfg; } app_type = usecase->in_app_type_cfg.app_type; sample_rate= usecase->in_app_type_cfg.sample_rate; } else { snd_device = SND_DEVICE_NONE; // use legacy behavior app_type = platform_get_default_app_type_v2(adev->platform, PCM_CAPTURE); } rc = set_stream_app_type_mixer_ctrl(adev, pcm_device_id, app_type, acdb_dev_id, sample_rate, PCM_CAPTURE, snd_device); if (rc < 0) goto exit_send_app_type_cfg; if (is_bus_dev_usecase) goto exit_send_app_type_cfg; /* config HFP session:2 capture path */ pcm_device_id = HFP_ASM_RX_TX; snd_device = usecase->in_snd_device; acdb_dev_id = platform_get_snd_device_acdb_id(snd_device); if (acdb_dev_id <= 0) { ALOGE("%s: Couldn't get the acdb dev id", __func__); rc = -EINVAL; goto exit_send_app_type_cfg; } app_type = platform_get_default_app_type_v2(adev->platform, PCM_CAPTURE); rc = set_stream_app_type_mixer_ctrl(adev, pcm_device_id, app_type, acdb_dev_id, sample_rate, PCM_CAPTURE, SND_DEVICE_NONE); if (rc < 0) goto exit_send_app_type_cfg; /* config HFP session:2 playback path */ app_type = platform_get_default_app_type_v2(adev->platform, PCM_PLAYBACK); rc = set_stream_app_type_mixer_ctrl(adev, pcm_device_id, app_type, acdb_dev_id, sample_rate, PCM_PLAYBACK, SND_DEVICE_NONE); if (rc < 0) goto exit_send_app_type_cfg; } rc = 0; exit_send_app_type_cfg: return rc; } int audio_extn_utils_get_app_sample_rate_for_device( struct audio_device *adev, struct audio_usecase *usecase, int snd_device) { char value[PROPERTY_VALUE_MAX] = {0}; int sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; if ((usecase->type == PCM_PLAYBACK) && (usecase->stream.out != NULL)) { property_get("vendor.audio.playback.mch.downsample",value,""); if (!strncmp("true", value, sizeof("true"))) { if ((popcount(usecase->stream.out->channel_mask) > 2) && (usecase->stream.out->app_type_cfg.sample_rate > CODEC_BACKEND_DEFAULT_SAMPLE_RATE) && !(usecase->stream.out->flags & (audio_output_flags_t)AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH)) sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE; } if (usecase->id == USECASE_AUDIO_PLAYBACK_VOIP) { usecase->stream.out->app_type_cfg.sample_rate = usecase->stream.out->sample_rate; } else if ((snd_device == SND_DEVICE_OUT_HDMI || snd_device == SND_DEVICE_OUT_USB_HEADSET || snd_device == SND_DEVICE_OUT_DISPLAY_PORT) && (usecase->stream.out->sample_rate >= OUTPUT_SAMPLING_RATE_44100)) { /* * To best utlize DSP, check if the stream sample rate is supported/multiple of * configured device sample rate, if not update the COPP rate to be equal to the * device sample rate, else open COPP at stream sample rate */ platform_check_and_update_copp_sample_rate(adev->platform, snd_device, usecase->stream.out->sample_rate, &usecase->stream.out->app_type_cfg.sample_rate); } else if (((snd_device != SND_DEVICE_OUT_HEADPHONES_44_1 && !audio_is_this_native_usecase(usecase)) && usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) || (usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) { /* Reset to default if no native stream is active*/ usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; } else if (snd_device == SND_DEVICE_OUT_BT_A2DP) { /* * For a2dp playback get encoder sampling rate and set copp sampling rate, * for bit width use the stream param only. */ audio_extn_a2dp_get_enc_sample_rate(&usecase->stream.out->app_type_cfg.sample_rate); ALOGI("%s using %d sample rate rate for A2DP CoPP", __func__, usecase->stream.out->app_type_cfg.sample_rate); } else if (compare_device_type(&usecase->stream.out->device_list, AUDIO_DEVICE_OUT_SPEAKER)) { usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; } audio_extn_btsco_get_sample_rate(snd_device, &usecase->stream.out->app_type_cfg.sample_rate); sample_rate = usecase->stream.out->app_type_cfg.sample_rate; if (((usecase->stream.out->format == AUDIO_FORMAT_E_AC3) || (usecase->stream.out->format == AUDIO_FORMAT_E_AC3_JOC) || (usecase->stream.out->format == AUDIO_FORMAT_DOLBY_TRUEHD)) && audio_extn_passthru_is_passthrough_stream(usecase->stream.out) && !audio_extn_passthru_is_convert_supported(adev, usecase->stream.out)) { sample_rate = sample_rate * 4; if (sample_rate > HDMI_PASSTHROUGH_MAX_SAMPLE_RATE) sample_rate = HDMI_PASSTHROUGH_MAX_SAMPLE_RATE; } } else if (usecase->type == PCM_CAPTURE) { if (usecase->stream.in != NULL) { if (usecase->id == USECASE_AUDIO_RECORD_VOIP) usecase->stream.in->app_type_cfg.sample_rate = usecase->stream.in->sample_rate; if (voice_is_in_call_rec_stream(usecase->stream.in)) { audio_extn_btsco_get_sample_rate(usecase->in_snd_device, &usecase->stream.in->app_type_cfg.sample_rate); } else { audio_extn_btsco_get_sample_rate(snd_device, &usecase->stream.in->app_type_cfg.sample_rate); } sample_rate = usecase->stream.in->app_type_cfg.sample_rate; } else if (usecase->id == USECASE_AUDIO_SPKR_CALIB_TX) { if ((property_get("vendor.audio.spkr_prot.tx.sampling_rate", value, NULL) > 0)) sample_rate = atoi(value); else sample_rate = SAMPLE_RATE_8000; } } else if (usecase->type == TRANSCODE_LOOPBACK_RX) { sample_rate = usecase->stream.inout->out_config.sample_rate; } return sample_rate; } static int send_app_type_cfg_for_device(struct audio_device *adev, struct audio_usecase *usecase, int split_snd_device) { char mixer_ctl_name[MAX_LENGTH_MIXER_CONTROL_IN_INT]; size_t app_type_cfg[MAX_LENGTH_MIXER_CONTROL_IN_INT] = {0}; int len = 0, rc; struct mixer_ctl *ctl; int pcm_device_id = 0, acdb_dev_id, app_type; int snd_device = split_snd_device, snd_device_be_idx = -1; int32_t sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; struct streams_io_cfg *s_info = NULL; struct listnode *node = NULL; int bd_app_type = 0; ALOGV("%s: usecase->out_snd_device %s, usecase->in_snd_device %s, split_snd_device %s", __func__, platform_get_snd_device_name(usecase->out_snd_device), platform_get_snd_device_name(usecase->in_snd_device), platform_get_snd_device_name(split_snd_device)); if (usecase->type != PCM_PLAYBACK && usecase->type != PCM_CAPTURE && usecase->type != TRANSCODE_LOOPBACK_RX) { ALOGE("%s: not a playback/capture path, no need to cfg app type", __func__); rc = 0; goto exit_send_app_type_cfg; } if ((usecase->id != USECASE_AUDIO_PLAYBACK_DEEP_BUFFER) && (usecase->id != USECASE_AUDIO_PLAYBACK_WITH_HAPTICS) && (usecase->id != USECASE_AUDIO_PLAYBACK_LOW_LATENCY) && (usecase->id != USECASE_AUDIO_PLAYBACK_MULTI_CH) && (usecase->id != USECASE_AUDIO_PLAYBACK_ULL) && (usecase->id != USECASE_AUDIO_PLAYBACK_VOIP) && (usecase->id != USECASE_AUDIO_TRANSCODE_LOOPBACK_RX) && (!is_interactive_usecase(usecase->id)) && (!is_offload_usecase(usecase->id)) && (usecase->type != PCM_CAPTURE) && (!audio_extn_auto_hal_is_bus_device_usecase(usecase->id))) { ALOGV("%s: a rx/tx/loopback path where app type cfg is not required %d", __func__, usecase->id); rc = 0; goto exit_send_app_type_cfg; } //if VR is active then only send the mixer control if (usecase->id == USECASE_AUDIO_PLAYBACK_ULL && !audio_is_vr_mode_on(adev)) { ALOGI("ULL doesnt need sending app type cfg, returning"); rc = 0; goto exit_send_app_type_cfg; } if (usecase->type == PCM_PLAYBACK || usecase->type == TRANSCODE_LOOPBACK_RX) { pcm_device_id = platform_get_pcm_device_id(usecase->id, PCM_PLAYBACK); snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Audio Stream %d App Type Cfg", pcm_device_id); } else if (usecase->type == PCM_CAPTURE) { pcm_device_id = platform_get_pcm_device_id(usecase->id, PCM_CAPTURE); snprintf(mixer_ctl_name, sizeof(mixer_ctl_name), "Audio Stream Capture %d App Type Cfg", pcm_device_id); } ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); if (!ctl) { ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, mixer_ctl_name); rc = -EINVAL; goto exit_send_app_type_cfg; } snd_device = platform_get_spkr_prot_snd_device(snd_device); if (voice_is_in_call_rec_stream(usecase->stream.in) && usecase->type == PCM_CAPTURE) { snd_device_t voice_device = voice_get_incall_rec_snd_device(usecase->in_snd_device); acdb_dev_id = platform_get_snd_device_acdb_id(voice_device); ALOGV("acdb id for voice call use case %d", acdb_dev_id); } else { acdb_dev_id = platform_get_snd_device_acdb_id(snd_device); } if (acdb_dev_id <= 0) { ALOGE("%s: Couldn't get the acdb dev id", __func__); rc = -EINVAL; goto exit_send_app_type_cfg; } snd_device_be_idx = platform_get_snd_device_backend_index(snd_device); if (snd_device_be_idx < 0) { ALOGE("%s: Couldn't get the backend index for snd device %s ret=%d", __func__, platform_get_snd_device_name(snd_device), snd_device_be_idx); } sample_rate = audio_extn_utils_get_app_sample_rate_for_device(adev, usecase, snd_device); if ((usecase->type == PCM_PLAYBACK) && (usecase->stream.out != NULL)) { /* Interactive streams are supported with only direct app type id. * Get Direct profile app type and use it for interactive streams */ list_for_each(node, &adev->streams_output_cfg_list) { s_info = node_to_item(node, struct streams_io_cfg, list); if (s_info->flags.out_flags == (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_BD | AUDIO_OUTPUT_FLAG_DIRECT_PCM | AUDIO_OUTPUT_FLAG_DIRECT)) bd_app_type = s_info->app_type_cfg.app_type; } if (usecase->stream.out->flags == (audio_output_flags_t)AUDIO_OUTPUT_FLAG_INTERACTIVE) app_type = bd_app_type; else app_type = usecase->stream.out->app_type_cfg.app_type; app_type_cfg[len++] = app_type; app_type_cfg[len++] = acdb_dev_id; app_type_cfg[len++] = sample_rate; if (snd_device_be_idx > 0) app_type_cfg[len++] = snd_device_be_idx; ALOGI("%s PLAYBACK app_type %d, acdb_dev_id %d, sample_rate %d, snd_device_be_idx %d", __func__, app_type, acdb_dev_id, sample_rate, snd_device_be_idx); } else if ((usecase->type == PCM_CAPTURE) && (usecase->stream.in != NULL)) { app_type = usecase->stream.in->app_type_cfg.app_type; app_type_cfg[len++] = app_type; app_type_cfg[len++] = acdb_dev_id; app_type_cfg[len++] = sample_rate; if (snd_device_be_idx > 0) app_type_cfg[len++] = snd_device_be_idx; ALOGI("%s CAPTURE app_type %d, acdb_dev_id %d, sample_rate %d, snd_device_be_idx %d", __func__, app_type, acdb_dev_id, sample_rate, snd_device_be_idx); } else { app_type = platform_get_default_app_type_v2(adev->platform, usecase->type); if(usecase->type == TRANSCODE_LOOPBACK_RX) { app_type = usecase->stream.inout->out_app_type_cfg.app_type; } app_type_cfg[len++] = app_type; app_type_cfg[len++] = acdb_dev_id; app_type_cfg[len++] = sample_rate; if (snd_device_be_idx > 0) app_type_cfg[len++] = snd_device_be_idx; ALOGI("%s default app_type %d, acdb_dev_id %d, sample_rate %d, snd_device_be_idx %d", __func__, app_type, acdb_dev_id, sample_rate, snd_device_be_idx); } if(ctl) mixer_ctl_set_array(ctl, app_type_cfg, len); rc = 0; exit_send_app_type_cfg: return rc; } static int audio_extn_utils_check_input_parameters(uint32_t sample_rate, audio_format_t format, int channel_count) { int ret = 0; if (((format != AUDIO_FORMAT_PCM_16_BIT) && (format != AUDIO_FORMAT_PCM_8_24_BIT) && (format != AUDIO_FORMAT_PCM_24_BIT_PACKED) && (format != AUDIO_FORMAT_PCM_32_BIT) && (format != AUDIO_FORMAT_PCM_FLOAT)) && !voice_extn_compress_voip_is_format_supported(format) && !audio_extn_compr_cap_format_supported(format) && !audio_extn_cin_format_supported(format)) ret = -EINVAL; switch (channel_count) { case 1: case 2: case 3: case 4: case 6: case 8: break; default: ret = -EINVAL; } switch (sample_rate) { case 8000: case 11025: case 12000: case 16000: case 22050: case 24000: case 32000: case 44100: case 48000: case 88200: case 96000: case 176400: case 192000: break; default: ret = -EINVAL; } return ret; } static inline uint32_t audio_extn_utils_nearest_multiple(uint32_t num, uint32_t multiplier) { uint32_t remainder = 0; if (!multiplier) return num; remainder = num % multiplier; if (remainder) num += (multiplier - remainder); return num; } static inline uint32_t audio_extn_utils_lcm(uint32_t num1, uint32_t num2) { uint32_t high = num1, low = num2, temp = 0; if (!num1 || !num2) return 0; if (num1 < num2) { high = num2; low = num1; } while (low != 0) { temp = low; low = high % low; high = temp; } return (num1 * num2)/high; } int audio_extn_utils_send_app_type_cfg(struct audio_device *adev, struct audio_usecase *usecase) { int i, num_devices = 0; snd_device_t new_snd_devices[SND_DEVICE_OUT_END] = {0}; snd_device_t in_snd_device = usecase->in_snd_device; int rc = 0; if (usecase->type == PCM_HFP_CALL) { return audio_extn_utils_send_app_type_cfg_hfp(adev, usecase); } switch (usecase->type) { case PCM_PLAYBACK: case TRANSCODE_LOOPBACK_RX: ALOGD("%s: usecase->out_snd_device %s", __func__, platform_get_snd_device_name(usecase->out_snd_device)); /* check for out combo device */ if (platform_split_snd_device(adev->platform, usecase->out_snd_device, &num_devices, new_snd_devices)) { new_snd_devices[0] = usecase->out_snd_device; num_devices = 1; } break; case PCM_CAPTURE: ALOGD("%s: usecase->in_snd_device %s", __func__, platform_get_snd_device_name(usecase->in_snd_device)); if (voice_is_in_call_rec_stream(usecase->stream.in)) { in_snd_device = voice_get_incall_rec_backend_device(usecase->stream.in); } /* check for in combo device */ if (platform_split_snd_device(adev->platform, in_snd_device, &num_devices, new_snd_devices)) { new_snd_devices[0] = in_snd_device; num_devices = 1; } break; default: ALOGI("%s: not a playback/capture path, no need to cfg app type", __func__); rc = 0; break; } for (i = 0; i < num_devices; i++) { rc = send_app_type_cfg_for_device(adev, usecase, new_snd_devices[i]); if (rc) break; } return rc; } int read_line_from_file(const char *path, char *buf, size_t count) { char * fgets_ret; FILE * fd; int rv; fd = fopen(path, "r"); if (fd == NULL) return -1; fgets_ret = fgets(buf, (int)count, fd); if (NULL != fgets_ret) { rv = (int)strlen(buf); } else { rv = ferror(fd); } fclose(fd); return rv; } /*Translates ALSA formats to AOSP PCM formats*/ audio_format_t alsa_format_to_hal(uint32_t alsa_format) { audio_format_t format; switch(alsa_format) { case SNDRV_PCM_FORMAT_S16_LE: format = AUDIO_FORMAT_PCM_16_BIT; break; case SNDRV_PCM_FORMAT_S24_3LE: format = AUDIO_FORMAT_PCM_24_BIT_PACKED; break; case SNDRV_PCM_FORMAT_S24_LE: format = AUDIO_FORMAT_PCM_8_24_BIT; break; case SNDRV_PCM_FORMAT_S32_LE: format = AUDIO_FORMAT_PCM_32_BIT; break; default: ALOGW("Incorrect ALSA format"); format = AUDIO_FORMAT_INVALID; } return format; } /*Translates hal format (AOSP) to alsa formats*/ uint32_t hal_format_to_alsa(audio_format_t hal_format) { uint32_t alsa_format; switch (hal_format) { case AUDIO_FORMAT_PCM_32_BIT: { if (platform_supports_true_32bit()) alsa_format = SNDRV_PCM_FORMAT_S32_LE; else alsa_format = SNDRV_PCM_FORMAT_S24_3LE; } break; case AUDIO_FORMAT_PCM_8_BIT: alsa_format = SNDRV_PCM_FORMAT_S8; break; case AUDIO_FORMAT_PCM_24_BIT_PACKED: alsa_format = SNDRV_PCM_FORMAT_S24_3LE; break; case AUDIO_FORMAT_PCM_8_24_BIT: { if (platform_supports_true_32bit()) alsa_format = SNDRV_PCM_FORMAT_S32_LE; else alsa_format = SNDRV_PCM_FORMAT_S24_3LE; } break; case AUDIO_FORMAT_PCM_FLOAT: alsa_format = SNDRV_PCM_FORMAT_S24_3LE; break; default: case AUDIO_FORMAT_PCM_16_BIT: alsa_format = SNDRV_PCM_FORMAT_S16_LE; break; } return alsa_format; } /*Translates PCM formats to AOSP formats*/ audio_format_t pcm_format_to_hal(uint32_t pcm_format) { audio_format_t format = AUDIO_FORMAT_INVALID; switch(pcm_format) { case PCM_FORMAT_S16_LE: format = AUDIO_FORMAT_PCM_16_BIT; break; case PCM_FORMAT_S24_3LE: format = AUDIO_FORMAT_PCM_24_BIT_PACKED; break; case PCM_FORMAT_S24_LE: format = AUDIO_FORMAT_PCM_8_24_BIT; break; case PCM_FORMAT_S32_LE: format = AUDIO_FORMAT_PCM_32_BIT; break; default: ALOGW("Incorrect PCM format"); format = AUDIO_FORMAT_INVALID; } return format; } /*Translates hal format (AOSP) to alsa formats*/ uint32_t hal_format_to_pcm(audio_format_t hal_format) { uint32_t pcm_format; switch (hal_format) { case AUDIO_FORMAT_PCM_32_BIT: case AUDIO_FORMAT_PCM_8_24_BIT: case AUDIO_FORMAT_PCM_FLOAT: { if (platform_supports_true_32bit()) pcm_format = PCM_FORMAT_S32_LE; else pcm_format = PCM_FORMAT_S24_3LE; } break; case AUDIO_FORMAT_PCM_8_BIT: pcm_format = PCM_FORMAT_S8; break; case AUDIO_FORMAT_PCM_24_BIT_PACKED: pcm_format = PCM_FORMAT_S24_3LE; break; default: case AUDIO_FORMAT_PCM_16_BIT: pcm_format = PCM_FORMAT_S16_LE; break; } return pcm_format; } uint32_t get_alsa_fragment_size(uint32_t bytes_per_sample, uint32_t sample_rate, uint32_t noOfChannels, int64_t duration_ms) { uint32_t fragment_size = 0; uint32_t pcm_offload_time = PCM_OFFLOAD_BUFFER_DURATION; if (duration_ms >= MIN_OFFLOAD_BUFFER_DURATION_MS && duration_ms <= MAX_OFFLOAD_BUFFER_DURATION_MS) pcm_offload_time = duration_ms; fragment_size = (pcm_offload_time * sample_rate * bytes_per_sample * noOfChannels)/1000; if (fragment_size < MIN_PCM_OFFLOAD_FRAGMENT_SIZE) fragment_size = MIN_PCM_OFFLOAD_FRAGMENT_SIZE; else if (fragment_size > MAX_PCM_OFFLOAD_FRAGMENT_SIZE) fragment_size = MAX_PCM_OFFLOAD_FRAGMENT_SIZE; /*To have same PCM samples for all channels, the buffer size requires to *be multiple of (number of channels * bytes per sample) *For writes to succeed, the buffer must be written at address which is multiple of 32 */ fragment_size = ALIGN(fragment_size, (bytes_per_sample * noOfChannels * 32)); ALOGI("PCM offload Fragment size to %d bytes", fragment_size); return fragment_size; } /* Calculates the fragment size required to configure compress session. * Based on the alsa format selected, decide if conversion is needed in * HAL ( e.g. convert AUDIO_FORMAT_PCM_FLOAT input format to * AUDIO_FORMAT_PCM_24_BIT_PACKED before writing to the compress driver. */ void audio_extn_utils_update_direct_pcm_fragment_size(struct stream_out *out) { audio_format_t dst_format = out->hal_op_format; audio_format_t src_format = out->hal_ip_format; uint32_t hal_op_bytes_per_sample = audio_bytes_per_sample(dst_format); uint32_t hal_ip_bytes_per_sample = audio_bytes_per_sample(src_format); out->compr_config.fragment_size = get_alsa_fragment_size(hal_op_bytes_per_sample, out->sample_rate, popcount(out->channel_mask), out->info.duration_us / 1000); if ((src_format != dst_format) && hal_op_bytes_per_sample != hal_ip_bytes_per_sample) { out->hal_fragment_size = ((out->compr_config.fragment_size * hal_ip_bytes_per_sample) / hal_op_bytes_per_sample); ALOGI("enable conversion hal_input_fragment_size is %d src_format %x dst_format %x", out->hal_fragment_size, src_format, dst_format); } else { out->hal_fragment_size = out->compr_config.fragment_size; } } /* converts pcm format 24_8 to 8_24 inplace */ size_t audio_extn_utils_convert_format_24_8_to_8_24(void *buf, size_t bytes) { size_t i = 0; int *int_buf_stream = buf; if ((bytes % 4) != 0) { ALOGE("%s: wrong inout buffer! ... is not 32 bit aligned ", __func__); return -EINVAL; } for (; i < (bytes / 4); i++) int_buf_stream[i] >>= 8; return bytes; } #ifdef AUDIO_GKI_ENABLED int get_snd_codec_id(audio_format_t format) { int id = 0; switch (format & AUDIO_FORMAT_MAIN_MASK) { case AUDIO_FORMAT_MP3: id = SND_AUDIOCODEC_MP3; break; case AUDIO_FORMAT_AAC: id = SND_AUDIOCODEC_AAC; break; case AUDIO_FORMAT_AAC_ADTS: id = SND_AUDIOCODEC_AAC; break; case AUDIO_FORMAT_AAC_LATM: id = SND_AUDIOCODEC_AAC; break; case AUDIO_FORMAT_PCM: id = SND_AUDIOCODEC_PCM; break; case AUDIO_FORMAT_FLAC: case AUDIO_FORMAT_ALAC: case AUDIO_FORMAT_APE: case AUDIO_FORMAT_VORBIS: case AUDIO_FORMAT_WMA: case AUDIO_FORMAT_WMA_PRO: case AUDIO_FORMAT_DSD: case AUDIO_FORMAT_APTX: id = SND_AUDIOCODEC_BESPOKE; break; case AUDIO_FORMAT_MP2: id = SND_AUDIOCODEC_MP2; break; case AUDIO_FORMAT_AC3: id = SND_AUDIOCODEC_AC3; break; case AUDIO_FORMAT_E_AC3: case AUDIO_FORMAT_E_AC3_JOC: id = SND_AUDIOCODEC_EAC3; break; case AUDIO_FORMAT_DTS: case AUDIO_FORMAT_DTS_HD: id = SND_AUDIOCODEC_DTS; break; case AUDIO_FORMAT_DOLBY_TRUEHD: id = SND_AUDIOCODEC_TRUEHD; break; case AUDIO_FORMAT_IEC61937: id = SND_AUDIOCODEC_IEC61937; break; default: ALOGE("%s: Unsupported audio format :%x", __func__, format); } return id; } #else int get_snd_codec_id(audio_format_t format) { int id = 0; switch (format & AUDIO_FORMAT_MAIN_MASK) { case AUDIO_FORMAT_MP3: id = SND_AUDIOCODEC_MP3; break; case AUDIO_FORMAT_AAC: id = SND_AUDIOCODEC_AAC; break; case AUDIO_FORMAT_AAC_ADTS: id = SND_AUDIOCODEC_AAC; break; case AUDIO_FORMAT_AAC_LATM: id = SND_AUDIOCODEC_AAC; break; case AUDIO_FORMAT_PCM: id = SND_AUDIOCODEC_PCM; break; case AUDIO_FORMAT_FLAC: id = SND_AUDIOCODEC_FLAC; break; case AUDIO_FORMAT_ALAC: id = SND_AUDIOCODEC_ALAC; break; case AUDIO_FORMAT_APE: id = SND_AUDIOCODEC_APE; break; case AUDIO_FORMAT_VORBIS: id = SND_AUDIOCODEC_VORBIS; break; case AUDIO_FORMAT_WMA: id = SND_AUDIOCODEC_WMA; break; case AUDIO_FORMAT_WMA_PRO: id = SND_AUDIOCODEC_WMA_PRO; break; case AUDIO_FORMAT_MP2: id = SND_AUDIOCODEC_MP2; break; case AUDIO_FORMAT_AC3: id = SND_AUDIOCODEC_AC3; break; case AUDIO_FORMAT_E_AC3: case AUDIO_FORMAT_E_AC3_JOC: id = SND_AUDIOCODEC_EAC3; break; case AUDIO_FORMAT_DTS: case AUDIO_FORMAT_DTS_HD: id = SND_AUDIOCODEC_DTS; break; case AUDIO_FORMAT_DOLBY_TRUEHD: id = SND_AUDIOCODEC_TRUEHD; break; case AUDIO_FORMAT_IEC61937: id = SND_AUDIOCODEC_IEC61937; break; case AUDIO_FORMAT_DSD: id = SND_AUDIOCODEC_DSD; break; case AUDIO_FORMAT_APTX: id = SND_AUDIOCODEC_APTX; break; default: ALOGE("%s: Unsupported audio format :%x", __func__, format); } return id; } #endif void audio_extn_utils_send_audio_calibration(struct audio_device *adev, struct audio_usecase *usecase) { int type = usecase->type; if (type == PCM_PLAYBACK && usecase->stream.out != NULL) { platform_send_audio_calibration(adev->platform, usecase, usecase->stream.out->app_type_cfg.app_type); } else if (type == PCM_CAPTURE && usecase->stream.in != NULL) { platform_send_audio_calibration(adev->platform, usecase, usecase->stream.in->app_type_cfg.app_type); } else if ((type == PCM_HFP_CALL) || (type == PCM_CAPTURE) || (type == TRANSCODE_LOOPBACK_RX && usecase->stream.inout != NULL)) { platform_send_audio_calibration(adev->platform, usecase, platform_get_default_app_type_v2(adev->platform, usecase->type)); } else { /* No need to send audio calibration for voice and voip call usecases */ if ((type != VOICE_CALL) && (type != VOIP_CALL)) ALOGW("%s: No audio calibration for usecase type = %d", __func__, type); } } // Base64 Encode and Decode // Not all features supported. This must be used only with following conditions. // Decode Modes: Support with and without padding // CRLF not handling. So no CRLF in string to decode. // Encode Modes: Supports only padding int b64decode(char *inp, int ilen, uint8_t* outp) { int i, j, k, ii, num; int rem, pcnt; uint32_t res=0; uint8_t getIndex[MAX_BASEINDEX_LEN]; uint8_t tmp, cflag; if(inp == NULL || outp == NULL || ilen <= 0) { ALOGE("[%s] received NULL pointer or zero length",__func__); return -1; } memset(getIndex, MAX_BASEINDEX_LEN-1, sizeof(getIndex)); for(i=0;i> 16; if(pcnt == 2) goto done; outp[k++] = (res>>8)&0xFF; if(pcnt == 1) goto done; outp[k++] = res&0xFF; } else { //without padding res = 0; for(i=0;i> 16; if(pcnt == 2) goto done; outp[k++] = (res>>8)&0xFF; if(pcnt == 1) goto done; outp[k++] = res&0xFF; } done: if(cflag == 0xFF) { ALOGE("[%s] base64 decode failed. Invalid character found %s", __func__, inp); return 0; } return k; } int b64encode(uint8_t *inp, int ilen, char* outp) { int i,j,k, num; int rem=0; uint32_t res=0; if(inp == NULL || outp == NULL || ilen<=0) { ALOGE("[%s] received NULL pointer or zero input length",__func__); return -1; } num = ilen/3; rem = ilen%3; j=0;k=0; for(i=0; i>18)&0x3F]; outp[k++] = (char) bTable[(res>>12)&0x3F]; outp[k++] = (char) bTable[(res>>6)&0x3F]; outp[k++] = (char) bTable[res&0x3F]; } switch(rem) { case 1: res = inp[j++]<<16; outp[k++] = (char) bTable[res>>18]; outp[k++] = (char) bTable[(res>>12)&0x3F]; //outp[k++] = '='; //outp[k++] = '='; break; case 2: res = inp[j++]<<16; res = res | inp[j++]<<8; outp[k++] = (char) bTable[res>>18]; outp[k++] = (char) bTable[(res>>12)&0x3F]; outp[k++] = (char) bTable[(res>>6)&0x3F]; //outp[k++] = '='; break; default: break; } outp[k] = '\0'; return k; } int audio_extn_utils_get_codec_version(const char *snd_card_name, int card_num, char *codec_version) { char procfs_path[50]; FILE *fp; if (strstr(snd_card_name, "tasha")) { snprintf(procfs_path, sizeof(procfs_path), "/proc/asound/card%d/codecs/tasha/version", card_num); if ((fp = fopen(procfs_path, "r")) != NULL) { fgets(codec_version, CODEC_VERSION_MAX_LENGTH, fp); fclose(fp); } else { ALOGE("%s: ERROR. cannot open %s", __func__, procfs_path); return -ENOENT; } ALOGD("%s: codec version %s", __func__, codec_version); } return 0; } int audio_extn_utils_get_codec_variant(int card_num, char *codec_variant) { char procfs_path[50]; FILE *fp; snprintf(procfs_path, sizeof(procfs_path), "/proc/asound/card%d/codecs/wcd938x/variant", card_num); if ((fp = fopen(procfs_path, "r")) == NULL) { snprintf(procfs_path, sizeof(procfs_path), "/proc/asound/card%d/codecs/wcd937x/variant", card_num); if ((fp = fopen(procfs_path, "r")) == NULL) { ALOGE("%s: ERROR. cannot open %s", __func__, procfs_path); return -ENOENT; } } fgets(codec_variant, CODEC_VARIANT_MAX_LENGTH, fp); fclose(fp); ALOGD("%s: codec variant is %s", __func__, codec_variant); return 0; } #ifdef AUDIO_EXTERNAL_HDMI_ENABLED void get_default_compressed_channel_status( unsigned char *channel_status) { memset(channel_status,0,24); /* block start bit in preamble bit 3 */ channel_status[0] |= PROFESSIONAL; //compre out channel_status[0] |= NON_LPCM; // sample rate; fixed 48K for default/transcode channel_status[3] |= SR_48000; } int32_t get_compressed_channel_status(void *audio_stream_data, uint32_t audio_frame_size, unsigned char *channel_status, enum audio_parser_code_type codec_type) // codec_type - AUDIO_PARSER_CODEC_AC3 // - AUDIO_PARSER_CODEC_DTS { unsigned char *stream; int ret = 0; stream = (unsigned char *)audio_stream_data; if (audio_stream_data == NULL || audio_frame_size == 0) { ALOGW("no buffer to get channel status, return default for compress"); get_default_compressed_channel_status(channel_status); return ret; } memset(channel_status,0,24); if(init_audio_parser(stream, audio_frame_size, codec_type) == -1) { ALOGE("init audio parser failed"); return -1; } ret = get_channel_status(channel_status, codec_type); return ret; } void get_lpcm_channel_status(uint32_t sampleRate, unsigned char *channel_status) { int32_t status = 0; memset(channel_status,0,24); /* block start bit in preamble bit 3 */ channel_status[0] |= PROFESSIONAL; //LPCM OUT channel_status[0] &= ~NON_LPCM; switch (sampleRate) { case 8000: case 11025: case 12000: case 16000: case 22050: channel_status[3] |= SR_NOTID; break; case 24000: channel_status[3] |= SR_24000; break; case 32000: channel_status[3] |= SR_32000; break; case 44100: channel_status[3] |= SR_44100; break; case 48000: channel_status[3] |= SR_48000; break; case 88200: channel_status[3] |= SR_88200; break; case 96000: channel_status[3] |= SR_96000; break; case 176400: channel_status[3] |= SR_176400; break; case 192000: channel_status[3] |= SR_192000; break; default: ALOGV("Invalid sample_rate %u\n", sampleRate); status = -1; break; } } void audio_utils_set_hdmi_channel_status(struct stream_out *out, char * buffer, size_t bytes) { unsigned char channel_status[24]={0}; struct snd_aes_iec958 iec958; const char *mixer_ctl_name = "IEC958 Playback PCM Stream"; struct mixer_ctl *ctl; ALOGV("%s: buffer %s bytes %zd", __func__, buffer, bytes); if (audio_extn_utils_is_dolby_format(out->format) && /*TODO:Extend code to support DTS passthrough*/ /*set compressed channel status bits*/ audio_extn_passthru_is_passthrough_stream(out) && audio_extn_is_hdmi_passthru_enabled()) { get_compressed_channel_status(buffer, bytes, channel_status, AUDIO_PARSER_CODEC_AC3); } else { /*set channel status bit for LPCM*/ get_lpcm_channel_status(out->sample_rate, channel_status); } memcpy(iec958.status, channel_status,sizeof(iec958.status)); ctl = mixer_get_ctl_by_name(out->dev->mixer, mixer_ctl_name); if (!ctl) { ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, mixer_ctl_name); return; } if (mixer_ctl_set_array(ctl, &iec958, sizeof(iec958)) < 0) { ALOGE("%s: Could not set channel status for ext HDMI ", __func__); return; } } #endif int audio_extn_utils_get_avt_device_drift( struct audio_usecase *usecase, struct audio_avt_device_drift_param *drift_param) { int ret = 0, count = 0; char avt_device_drift_mixer_ctl_name[MIXER_PATH_MAX_LENGTH] = {0}; const char *backend = NULL; struct mixer_ctl *ctl = NULL; struct audio_avt_device_drift_stats drift_stats; struct audio_device *adev = NULL; if (usecase != NULL && usecase->type == PCM_PLAYBACK) { backend = platform_get_snd_device_backend_interface(usecase->out_snd_device); if (!backend) { ALOGE("%s: Unsupported device %d", __func__, get_device_types(&usecase->stream.out->device_list)); ret = -EINVAL; goto done; } strlcpy(avt_device_drift_mixer_ctl_name, backend, MIXER_PATH_MAX_LENGTH); count = strlen(backend); if (MIXER_PATH_MAX_LENGTH - count > 0) { strlcat(&avt_device_drift_mixer_ctl_name[count], " DRIFT", MIXER_PATH_MAX_LENGTH - count); } else { ret = -EINVAL; goto done; } } else { ALOGE("%s: Invalid usecase",__func__); ret = -EINVAL; goto done; } adev = usecase->stream.out->dev; ctl = mixer_get_ctl_by_name(adev->mixer, avt_device_drift_mixer_ctl_name); if (!ctl) { ALOGE("%s: Could not get ctl for mixer cmd - %s", __func__, avt_device_drift_mixer_ctl_name); ret = -EINVAL; goto done; } ALOGV("%s: Getting AV Timer vs Device Drift mixer ctrl name %s", __func__, avt_device_drift_mixer_ctl_name); mixer_ctl_update(ctl); count = mixer_ctl_get_num_values(ctl); if (count != sizeof(struct audio_avt_device_drift_stats)) { ALOGE("%s: mixer_ctl_get_num_values() invalid drift_stats data size", __func__); ret = -EINVAL; goto done; } ret = mixer_ctl_get_array(ctl, (void *)&drift_stats, count); if (ret != 0) { ALOGE("%s: mixer_ctl_get_array() failed to get drift_stats Params", __func__); ret = -EINVAL; goto done; } memcpy(drift_param, &drift_stats.drift_param, sizeof(struct audio_avt_device_drift_param)); done: return ret; } #ifdef SNDRV_COMPRESS_PATH_DELAY int audio_extn_utils_compress_get_dsp_latency(struct stream_out *out) { int ret = -EINVAL; struct snd_compr_metadata metadata; int delay_ms = COMPRESS_OFFLOAD_PLAYBACK_LATENCY; /* override the latency for pcm offload use case */ if ((out->flags & AUDIO_OUTPUT_FLAG_DIRECT) && !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)) { delay_ms = PCM_OFFLOAD_PLAYBACK_LATENCY; } if (property_get_bool("vendor.audio.playback.dsp.pathdelay", false)) { ALOGD("%s:: Quering DSP delay %d",__func__, __LINE__); if (!(is_offload_usecase(out->usecase))) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if (!out->compr) { ALOGD("%s:: Invalid compress handle,returning default dsp latency", __func__); goto exit; } metadata.key = SNDRV_COMPRESS_PATH_DELAY; ret = compress_get_metadata(out->compr, &metadata); if(ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); goto exit; } delay_ms = metadata.value[0] / 1000; /*convert to ms*/ } else { ALOGD("%s:: Using Fix DSP delay",__func__); } exit: ALOGD("%s:: delay in ms is %d",__func__, delay_ms); return delay_ms; } #else int audio_extn_utils_compress_get_dsp_latency(struct stream_out *out __unused) { return COMPRESS_OFFLOAD_PLAYBACK_LATENCY; } #endif #ifdef SNDRV_COMPRESS_RENDER_MODE int audio_extn_utils_compress_set_render_mode(struct stream_out *out) { struct snd_compr_metadata metadata; int ret = -EINVAL; if (!(is_offload_usecase(out->usecase))) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if (!out->compr) { ALOGD("%s:: Invalid compress handle", __func__); goto exit; } ALOGD("%s:: render mode %d", __func__, out->render_mode); metadata.key = SNDRV_COMPRESS_RENDER_MODE; if (out->render_mode == RENDER_MODE_AUDIO_MASTER) { metadata.value[0] = SNDRV_COMPRESS_RENDER_MODE_AUDIO_MASTER; } else if (out->render_mode == RENDER_MODE_AUDIO_STC_MASTER) { metadata.value[0] = SNDRV_COMPRESS_RENDER_MODE_STC_MASTER; } else { ret = 0; goto exit; } ret = compress_set_metadata(out->compr, &metadata); if(ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); } exit: return ret; } #else int audio_extn_utils_compress_set_render_mode(struct stream_out *out __unused) { ALOGD("%s:: configuring render mode not supported", __func__); return 0; } #endif #ifdef SNDRV_COMPRESS_CLK_REC_MODE int audio_extn_utils_compress_set_clk_rec_mode( struct audio_usecase *usecase) { struct snd_compr_metadata metadata; struct stream_out *out = NULL; int ret = -EINVAL; if (usecase == NULL || usecase->type != PCM_PLAYBACK) { ALOGE("%s:: Invalid use case", __func__); goto exit; } out = usecase->stream.out; if (!out) { ALOGE("%s:: invalid stream", __func__); goto exit; } if (!is_offload_usecase(out->usecase)) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if (out->render_mode != RENDER_MODE_AUDIO_STC_MASTER) { ALOGD("%s:: clk recovery is only supported in STC render mode", __func__); ret = 0; goto exit; } if (!out->compr) { ALOGD("%s:: Invalid compress handle", __func__); goto exit; } metadata.key = SNDRV_COMPRESS_CLK_REC_MODE; switch(usecase->out_snd_device) { case SND_DEVICE_OUT_HDMI: case SND_DEVICE_OUT_SPEAKER_AND_HDMI: case SND_DEVICE_OUT_DISPLAY_PORT: case SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT: metadata.value[0] = SNDRV_COMPRESS_CLK_REC_MODE_NONE; break; default: metadata.value[0] = SNDRV_COMPRESS_CLK_REC_MODE_AUTO; break; } ALOGD("%s:: clk recovery mode %d",__func__, metadata.value[0]); ret = compress_set_metadata(out->compr, &metadata); if(ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); } exit: return ret; } #else int audio_extn_utils_compress_set_clk_rec_mode( struct audio_usecase *usecase __unused) { ALOGD("%s:: configuring render mode not supported", __func__); return 0; } #endif #ifdef SNDRV_COMPRESS_RENDER_WINDOW int audio_extn_utils_compress_set_render_window( struct stream_out *out, struct audio_out_render_window_param *render_window) { struct snd_compr_metadata metadata; int ret = -EINVAL; if(render_window == NULL) { ALOGE("%s:: Invalid render_window", __func__); goto exit; } ALOGD("%s:: render window start 0x%"PRIx64" end 0x%"PRIx64"", __func__,render_window->render_ws, render_window->render_we); if (!is_offload_usecase(out->usecase)) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if ((out->render_mode != RENDER_MODE_AUDIO_MASTER) && (out->render_mode != RENDER_MODE_AUDIO_STC_MASTER)) { ALOGD("%s:: only supported in timestamp mode, current " "render mode mode %d", __func__, out->render_mode); goto exit; } if (!out->compr) { ALOGW("%s:: offload session not yet opened," "render window will be configure later", __func__); /* store render window to reconfigure in start_output_stream() */ goto exit; } metadata.key = SNDRV_COMPRESS_RENDER_WINDOW; /*render window start value */ metadata.value[0] = 0xFFFFFFFF & render_window->render_ws; /* lsb */ metadata.value[1] = \ (0xFFFFFFFF00000000 & render_window->render_ws) >> 32; /* msb*/ /*render window end value */ metadata.value[2] = 0xFFFFFFFF & render_window->render_we; /* lsb */ metadata.value[3] = \ (0xFFFFFFFF00000000 & render_window->render_we) >> 32; /* msb*/ ret = compress_set_metadata(out->compr, &metadata); if(ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); } exit: return ret; } #else int audio_extn_utils_compress_set_render_window( struct stream_out *out __unused, struct audio_out_render_window_param *render_window __unused) { ALOGD("%s:: configuring render window not supported", __func__); return 0; } #endif #ifdef SNDRV_COMPRESS_START_DELAY int audio_extn_utils_compress_set_start_delay( struct stream_out *out, struct audio_out_start_delay_param *delay_param) { struct snd_compr_metadata metadata; int ret = -EINVAL; if(delay_param == NULL) { ALOGE("%s:: Invalid delay_param", __func__); goto exit; } ALOGD("%s:: render start delay 0x%"PRIx64" ", __func__, delay_param->start_delay); if (!is_offload_usecase(out->usecase)) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if ((out->render_mode != RENDER_MODE_AUDIO_MASTER) && (out->render_mode != RENDER_MODE_AUDIO_STC_MASTER)) { ALOGD("%s:: only supported in timestamp mode, current " "render mode mode %d", __func__, out->render_mode); goto exit; } if (!out->compr) { ALOGW("%s:: offload session not yet opened," "start delay will be configure later", __func__); goto exit; } metadata.key = SNDRV_COMPRESS_START_DELAY; metadata.value[0] = 0xFFFFFFFF & delay_param->start_delay; /* lsb */ metadata.value[1] = \ (0xFFFFFFFF00000000 & delay_param->start_delay) >> 32; /* msb*/ ret = compress_set_metadata(out->compr, &metadata); if(ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); } exit: return ret; } #else int audio_extn_utils_compress_set_start_delay( struct stream_out *out __unused, struct audio_out_start_delay_param *delay_param __unused) { ALOGD("%s:: configuring render window not supported", __func__); return 0; } #endif #ifdef SNDRV_COMPRESS_DSP_POSITION int audio_extn_utils_compress_get_dsp_presentation_pos(struct stream_out *out, uint64_t *frames, struct timespec *timestamp, int32_t clock_id) { int ret = -EINVAL; uint64_t *val = NULL; uint64_t time = 0; struct snd_compr_metadata metadata; ALOGV("%s:: Quering DSP position with clock id %d",__func__, clock_id); metadata.key = SNDRV_COMPRESS_DSP_POSITION; metadata.value[0] = clock_id; ret = compress_get_metadata(out->compr, &metadata); if (ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); ret = -errno; goto exit; } val = (uint64_t *)&metadata.value[1]; *frames = *val; time = *(val + 1); timestamp->tv_sec = time / 1000000; timestamp->tv_nsec = (time % 1000000)*1000; exit: return ret; } #else int audio_extn_utils_compress_get_dsp_presentation_pos(struct stream_out *out __unused, uint64_t *frames __unused, struct timespec *timestamp __unused, int32_t clock_id __unused) { ALOGD("%s:: dsp presentation position not supported", __func__); return 0; } #endif #ifdef SNDRV_PCM_IOCTL_DSP_POSITION int audio_extn_utils_pcm_get_dsp_presentation_pos(struct stream_out *out, uint64_t *frames, struct timespec *timestamp, int32_t clock_id) { int ret = -EINVAL; uint64_t time = 0; struct snd_pcm_prsnt_position prsnt_position; ALOGV("%s:: Quering DSP position with clock id %d",__func__, clock_id); prsnt_position.clock_id = clock_id; ret = pcm_ioctl(out->pcm, SNDRV_PCM_IOCTL_DSP_POSITION, &prsnt_position); if (ret) { ALOGE("%s::error %d", __func__, ret); ret = -EIO; goto exit; } *frames = prsnt_position.frames; time = prsnt_position.timestamp; timestamp->tv_sec = time / 1000000; timestamp->tv_nsec = (time % 1000000)*1000; exit: return ret; } #else int audio_extn_utils_pcm_get_dsp_presentation_pos(struct stream_out *out __unused, uint64_t *frames __unused, struct timespec *timestamp __unused, int32_t clock_id __unused) { ALOGD("%s:: dsp presentation position not supported", __func__); return 0; } #endif #define MAX_SND_CARD 8 #define RETRY_US 1000000 #define RETRY_NUMBER 40 #define PLATFORM_INFO_XML_PATH "audio_platform_info.xml" #define PLATFORM_INFO_XML_BASE_STRING "audio_platform_info" bool audio_extn_utils_resolve_config_file(char file_name[MIXER_PATH_MAX_LENGTH]) { char full_config_path[MIXER_PATH_MAX_LENGTH]; char vendor_config_path[VENDOR_CONFIG_PATH_MAX_LENGTH]; /* Get path for audio configuration files in vendor */ audio_get_vendor_config_path(vendor_config_path, sizeof(vendor_config_path)); snprintf(full_config_path, sizeof(full_config_path), "%s/%s", vendor_config_path, file_name); if (F_OK == access(full_config_path, 0)) { strlcpy(file_name, full_config_path, MIXER_PATH_MAX_LENGTH); return true; } return false; } /* platform_info_file should be size 'MIXER_PATH_MAX_LENGTH' */ int audio_extn_utils_get_platform_info(const char* snd_card_name, char* platform_info_file) { if (NULL == snd_card_name) { return -1; } struct snd_card_split *snd_split_handle = NULL; int ret = 0; audio_extn_set_snd_card_split(snd_card_name); snd_split_handle = audio_extn_get_snd_card_split(); snprintf(platform_info_file, MIXER_PATH_MAX_LENGTH, "%s_%s_%s.xml", PLATFORM_INFO_XML_BASE_STRING, snd_split_handle->snd_card, snd_split_handle->form_factor); if (!audio_extn_utils_resolve_config_file(platform_info_file)) { memset(platform_info_file, 0, MIXER_PATH_MAX_LENGTH); snprintf(platform_info_file, MIXER_PATH_MAX_LENGTH, "%s_%s.xml", PLATFORM_INFO_XML_BASE_STRING, snd_split_handle->snd_card); if (!audio_extn_utils_resolve_config_file(platform_info_file)) { memset(platform_info_file, 0, MIXER_PATH_MAX_LENGTH); strlcpy(platform_info_file, PLATFORM_INFO_XML_PATH, MIXER_PATH_MAX_LENGTH); ret = audio_extn_utils_resolve_config_file(platform_info_file) ? 0 : -1; } } return ret; } int audio_extn_utils_get_snd_card_num() { int snd_card_num = 0; struct mixer *mixer = NULL; snd_card_num = audio_extn_utils_open_snd_mixer(&mixer); if (mixer) mixer_close(mixer); return snd_card_num; } int audio_extn_utils_open_snd_mixer(struct mixer **mixer_handle) { void *hw_info = NULL; struct mixer *mixer = NULL; int retry_num = 0; int snd_card_num = 0; char* snd_card_name = NULL; int snd_card_detection_info[MAX_SND_CARD] = {0}; if (!mixer_handle) { ALOGE("invalid mixer handle"); return -1; } *mixer_handle = NULL; /* * Try with all the sound cards ( 0 to 7 ) and if none of them were detected * sleep for 1 sec and try detections with sound card 0 again. * If sound card gets detected, check if it is relevant, if not check with the * other sound cards. To ensure that the irrelevant sound card is not check again, * we maintain it in min_snd_card_num. */ while (retry_num < RETRY_NUMBER) { snd_card_num = 0; while (snd_card_num < MAX_SND_CARD) { if (snd_card_detection_info[snd_card_num] == 0) { mixer = mixer_open(snd_card_num); if (!mixer) snd_card_num++; else break; } else snd_card_num++; } if (!mixer) { usleep(RETRY_US); retry_num++; ALOGD("%s: retry, retry_num %d", __func__, retry_num); continue; } snd_card_name = strdup(mixer_get_name(mixer)); if (!snd_card_name) { ALOGE("failed to allocate memory for snd_card_name\n"); mixer_close(mixer); return -1; } ALOGD("%s: snd_card_name: %s", __func__, snd_card_name); snd_card_detection_info[snd_card_num] = 1; hw_info = hw_info_init(snd_card_name); if (hw_info) { ALOGD("%s: Opened sound card:%d", __func__, snd_card_num); break; } ALOGE("%s: Failed to init hardware info, snd_card_num:%d", __func__, snd_card_num); free(snd_card_name); snd_card_name = NULL; mixer_close(mixer); mixer = NULL; } if (snd_card_name) free(snd_card_name); if (hw_info) hw_info_deinit(hw_info); if (retry_num >= RETRY_NUMBER) { ALOGE("%s: Unable to find correct sound card, aborting.", __func__); return -1; } if (mixer) *mixer_handle = mixer; return snd_card_num; } void audio_extn_utils_close_snd_mixer(struct mixer *mixer) { if (mixer) mixer_close(mixer); } #ifdef SNDRV_COMPRESS_ENABLE_ADJUST_SESSION_CLOCK int audio_extn_utils_compress_enable_drift_correction( struct stream_out *out, struct audio_out_enable_drift_correction *drift) { struct snd_compr_metadata metadata; int ret = -EINVAL; if(drift == NULL) { ALOGE("%s:: Invalid param", __func__); goto exit; } ALOGD("%s:: drift enable %d", __func__,drift->enable); if (!is_offload_usecase(out->usecase)) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if (!out->compr) { ALOGW("%s:: offload session not yet opened," "start delay will be configure later", __func__); goto exit; } metadata.key = SNDRV_COMPRESS_ENABLE_ADJUST_SESSION_CLOCK; metadata.value[0] = drift->enable; out->drift_correction_enabled = drift->enable; ret = compress_set_metadata(out->compr, &metadata); if(ret) { ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); out->drift_correction_enabled = false; } exit: return ret; } #else int audio_extn_utils_compress_enable_drift_correction( struct stream_out *out __unused, struct audio_out_enable_drift_correction *drift __unused) { ALOGD("%s:: configuring drift enablement not supported", __func__); return 0; } #endif #ifdef SNDRV_COMPRESS_ADJUST_SESSION_CLOCK int audio_extn_utils_compress_correct_drift( struct stream_out *out, struct audio_out_correct_drift *drift_param) { struct snd_compr_metadata metadata; int ret = -EINVAL; if (drift_param == NULL) { ALOGE("%s:: Invalid drift_param", __func__); goto exit; } ALOGD("%s:: adjust time 0x%"PRIx64" ", __func__, drift_param->adjust_time); if (!is_offload_usecase(out->usecase)) { ALOGE("%s:: not supported for non offload session", __func__); goto exit; } if (!out->compr) { ALOGW("%s:: offload session not yet opened", __func__); goto exit; } if (!out->drift_correction_enabled) { ALOGE("%s:: drift correction not enabled", __func__); goto exit; } metadata.key = SNDRV_COMPRESS_ADJUST_SESSION_CLOCK; metadata.value[0] = 0xFFFFFFFF & drift_param->adjust_time; /* lsb */ metadata.value[1] = \ (0xFFFFFFFF00000000 & drift_param->adjust_time) >> 32; /* msb*/ ret = compress_set_metadata(out->compr, &metadata); if(ret) ALOGE("%s::error %s", __func__, compress_get_error(out->compr)); exit: return ret; } #else int audio_extn_utils_compress_correct_drift( struct stream_out *out __unused, struct audio_out_correct_drift *drift_param __unused) { ALOGD("%s:: setting adjust clock not supported", __func__); return 0; } #endif int audio_extn_utils_set_channel_map( struct stream_out *out, struct audio_out_channel_map_param *channel_map_param) { int ret = -EINVAL, i = 0; int channels = audio_channel_count_from_out_mask(out->channel_mask); if (channel_map_param == NULL) { ALOGE("%s:: Invalid channel_map", __func__); goto exit; } if (channel_map_param->channels != channels) { ALOGE("%s:: Channels(%d) does not match stream channels(%d)", __func__, channel_map_param->channels, channels); goto exit; } for ( i = 0; i < channels; i++) { ALOGV("%s:: channel_map[%d]- %d", __func__, i, channel_map_param->channel_map[i]); out->channel_map_param.channel_map[i] = channel_map_param->channel_map[i]; } ret = 0; exit: return ret; } int audio_extn_utils_set_pan_scale_params( struct stream_out *out, struct mix_matrix_params *mm_params) { int ret = -EINVAL, i = 0, j = 0; if (mm_params == NULL || out == NULL) { ALOGE("%s:: Invalid mix matrix or out param", __func__); goto exit; } if (mm_params->num_output_channels > MAX_CHANNELS_SUPPORTED || mm_params->num_output_channels <= 0 || mm_params->num_input_channels > MAX_CHANNELS_SUPPORTED || mm_params->num_input_channels <= 0) goto exit; out->pan_scale_params.num_output_channels = mm_params->num_output_channels; out->pan_scale_params.num_input_channels = mm_params->num_input_channels; out->pan_scale_params.has_output_channel_map = mm_params->has_output_channel_map; for (i = 0; i < mm_params->num_output_channels; i++) out->pan_scale_params.output_channel_map[i] = mm_params->output_channel_map[i]; out->pan_scale_params.has_input_channel_map = mm_params->has_input_channel_map; for (i = 0; i < mm_params->num_input_channels; i++) out->pan_scale_params.input_channel_map[i] = mm_params->input_channel_map[i]; out->pan_scale_params.has_mixer_coeffs = mm_params->has_mixer_coeffs; for (i = 0; i < mm_params->num_output_channels; i++) for (j = 0; j < mm_params->num_input_channels; j++) { //Convert the channel coefficient gains in Q14 format out->pan_scale_params.mixer_coeffs[i][j] = mm_params->mixer_coeffs[i][j] * (2 << 13); } ret = platform_set_stream_pan_scale_params(out->dev->platform, out->pcm_device_id, out->pan_scale_params); exit: return ret; } int audio_extn_utils_set_downmix_params( struct stream_out *out, struct mix_matrix_params *mm_params) { int ret = -EINVAL, i = 0, j = 0; struct audio_usecase *usecase = NULL; if (mm_params == NULL || out == NULL) { ALOGE("%s:: Invalid mix matrix or out param", __func__); goto exit; } if (mm_params->num_output_channels > MAX_CHANNELS_SUPPORTED || mm_params->num_output_channels <= 0 || mm_params->num_input_channels > MAX_CHANNELS_SUPPORTED || mm_params->num_input_channels <= 0) goto exit; usecase = get_usecase_from_list(out->dev, out->usecase); if (!usecase) { ALOGE("%s: Get usecase list failed!", __func__); goto exit; } out->downmix_params.num_output_channels = mm_params->num_output_channels; out->downmix_params.num_input_channels = mm_params->num_input_channels; out->downmix_params.has_output_channel_map = mm_params->has_output_channel_map; for (i = 0; i < mm_params->num_output_channels; i++) { out->downmix_params.output_channel_map[i] = mm_params->output_channel_map[i]; } out->downmix_params.has_input_channel_map = mm_params->has_input_channel_map; for (i = 0; i < mm_params->num_input_channels; i++) out->downmix_params.input_channel_map[i] = mm_params->input_channel_map[i]; out->downmix_params.has_mixer_coeffs = mm_params->has_mixer_coeffs; for (i = 0; i < mm_params->num_output_channels; i++) for (j = 0; j < mm_params->num_input_channels; j++) { //Convert the channel coefficient gains in Q14 format out->downmix_params.mixer_coeffs[i][j] = mm_params->mixer_coeffs[i][j] * (2 << 13); } ret = platform_set_stream_downmix_params(out->dev->platform, out->pcm_device_id, usecase->out_snd_device, out->downmix_params); exit: return ret; } bool audio_extn_utils_is_dolby_format(audio_format_t format) { if (format == AUDIO_FORMAT_AC3 || format == AUDIO_FORMAT_E_AC3 || format == AUDIO_FORMAT_E_AC3_JOC) return true; else return false; } int audio_extn_utils_get_bit_width_from_string(const char *id_string) { int i; const mixer_config_lookup mixer_bitwidth_config[] = {{"S24_3LE", 24}, {"S32_LE", 32}, {"S24_LE", 24}, {"S16_LE", 16}}; int num_configs = sizeof(mixer_bitwidth_config) / sizeof(mixer_bitwidth_config[0]); for (i = 0; i < num_configs; i++) { if (!strcmp(id_string, mixer_bitwidth_config[i].id_string)) return mixer_bitwidth_config[i].value; } return -EINVAL; } int audio_extn_utils_get_sample_rate_from_string(const char *id_string) { int i; const mixer_config_lookup mixer_samplerate_config[] = {{"KHZ_8", 8000}, {"KHZ_11P025", 11025}, {"KHZ_16", 16000}, {"KHZ_22P05", 22050}, {"KHZ_32", 32000}, {"KHZ_48", 48000}, {"KHZ_96", 96000}, {"KHZ_144", 144000}, {"KHZ_192", 192000}, {"KHZ_384", 384000}, {"KHZ_44P1", 44100}, {"KHZ_88P2", 88200}, {"KHZ_176P4", 176400}, {"KHZ_352P8", 352800}}; int num_configs = sizeof(mixer_samplerate_config) / sizeof(mixer_samplerate_config[0]); for (i = 0; i < num_configs; i++) { if (!strcmp(id_string, mixer_samplerate_config[i].id_string)) return mixer_samplerate_config[i].value; } return -EINVAL; } int audio_extn_utils_get_channels_from_string(const char *id_string) { int i; const mixer_config_lookup mixer_channels_config[] = {{"One", 1}, {"Two", 2}, {"Three",3}, {"Four", 4}, {"Five", 5}, {"Six", 6}, {"Seven", 7}, {"Eight", 8}}; int num_configs = sizeof(mixer_channels_config) / sizeof(mixer_channels_config[0]); for (i = 0; i < num_configs; i++) { if (!strcmp(id_string, mixer_channels_config[i].id_string)) return mixer_channels_config[i].value; } return -EINVAL; } void audio_extn_utils_release_snd_device(snd_device_t snd_device) { audio_extn_dev_arbi_release(snd_device); audio_extn_sound_trigger_update_device_status(snd_device, ST_EVENT_SND_DEVICE_FREE); audio_extn_listen_update_device_status(snd_device, LISTEN_EVENT_SND_DEVICE_FREE); } int audio_extn_utils_get_license_params( const struct audio_device *adev, struct audio_license_params *license_params) { if(!license_params) return -EINVAL; return platform_get_license_by_product(adev->platform, (const char*)license_params->product, &license_params->key, license_params->license); } int audio_extn_utils_send_app_type_gain(struct audio_device *adev, int app_type, int *gain) { int gain_cfg[4]; const char *mixer_ctl_name = "App Type Gain"; struct mixer_ctl *ctl; ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); if (!ctl) { ALOGE("%s: Could not get volume ctl mixer %s", __func__, mixer_ctl_name); return -EINVAL; } gain_cfg[0] = 0; gain_cfg[1] = app_type; gain_cfg[2] = gain[0]; gain_cfg[3] = gain[1]; ALOGV("%s app_type %d l(%d) r(%d)", __func__, app_type, gain[0], gain[1]); return mixer_ctl_set_array(ctl, gain_cfg, sizeof(gain_cfg)/sizeof(gain_cfg[0])); } static void vndk_fwk_init() { if (mVndkFwk.lib_handle != NULL) return; mVndkFwk.lib_handle = dlopen(VNDK_FWK_LIB_PATH, RTLD_NOW); if (mVndkFwk.lib_handle == NULL) { ALOGW("%s: failed to dlopen VNDK_FWK_LIB %s", __func__, strerror(errno)); return; } *(void **)(&mVndkFwk.isVendorEnhancedFwk) = dlsym(mVndkFwk.lib_handle, "isRunningWithVendorEnhancedFramework"); if (mVndkFwk.isVendorEnhancedFwk == NULL) { ALOGW("%s: dlsym failed %s", __func__, strerror(errno)); if (mVndkFwk.lib_handle) { dlclose(mVndkFwk.lib_handle); mVndkFwk.lib_handle = NULL; } return; } *(void **)(&mVndkFwk.getVendorEnhancedInfo) = dlsym(mVndkFwk.lib_handle, "getVendorEnhancedInfo"); if (mVndkFwk.getVendorEnhancedInfo == NULL) { ALOGW("%s: dlsym failed %s", __func__, strerror(errno)); if (mVndkFwk.lib_handle) { dlclose(mVndkFwk.lib_handle); mVndkFwk.lib_handle = NULL; } } return; } bool audio_extn_utils_is_vendor_enhanced_fwk() { static int is_vendor_enhanced_fwk = -EINVAL; if (is_vendor_enhanced_fwk != -EINVAL) return (bool)is_vendor_enhanced_fwk; vndk_fwk_init(); if (mVndkFwk.isVendorEnhancedFwk != NULL) { is_vendor_enhanced_fwk = mVndkFwk.isVendorEnhancedFwk(); ALOGW("%s: is_vendor_enhanced_fwk %d", __func__, is_vendor_enhanced_fwk); } else { is_vendor_enhanced_fwk = 0; ALOGW("%s: default to non enhanced_fwk config", __func__); } return (bool)is_vendor_enhanced_fwk; } int audio_extn_utils_get_vendor_enhanced_info() { static int vendor_enhanced_info = -EINVAL; if (vendor_enhanced_info != -EINVAL) return vendor_enhanced_info; vndk_fwk_init(); if (mVndkFwk.getVendorEnhancedInfo != NULL) { vendor_enhanced_info = mVndkFwk.getVendorEnhancedInfo(); ALOGW("%s: vendor_enhanced_info 0x%x", __func__, vendor_enhanced_info); } else { vendor_enhanced_info = 0x0; ALOGW("%s: default to vendor_enhanced_info 0x0", __func__); } return vendor_enhanced_info; } int audio_extn_utils_get_perf_mode_flag(void) { #ifdef COMPRESSED_PERF_MODE_FLAG return COMPRESSED_PERF_MODE_FLAG; #else return 0; #endif } size_t audio_extn_utils_get_input_buffer_size(uint32_t sample_rate, audio_format_t format, int channel_count, int64_t duration_ms, bool is_low_latency) { size_t size = 0; size_t capture_duration = AUDIO_CAPTURE_PERIOD_DURATION_MSEC; uint32_t bytes_per_period_sample = 0; if (audio_extn_utils_check_input_parameters(sample_rate, format, channel_count) != 0) return 0; if (duration_ms >= MIN_OFFLOAD_BUFFER_DURATION_MS && duration_ms <= MAX_OFFLOAD_BUFFER_DURATION_MS) capture_duration = duration_ms; size = (sample_rate * capture_duration) / 1000; if (is_low_latency) size = LOW_LATENCY_CAPTURE_PERIOD_SIZE; bytes_per_period_sample = audio_bytes_per_sample(format) * channel_count; size *= bytes_per_period_sample; /* make sure the size is multiple of 32 bytes and additionally multiple of * the frame_size (required for 24bit samples and non-power-of-2 channel counts) * At 48 kHz mono 16-bit PCM: * 5.000 ms = 240 frames = 15*16*1*2 = 480, a whole multiple of 32 (15) * 3.333 ms = 160 frames = 10*16*1*2 = 320, a whole multiple of 32 (10) * * The loop reaches result within 32 iterations, as initial size is * already a multiple of frame_size */ size = audio_extn_utils_nearest_multiple(size, audio_extn_utils_lcm(32, bytes_per_period_sample)); return size; } int audio_extn_utils_hash_fn(void *key) { return (int)key; } bool audio_extn_utils_hash_eq(void *key1, void *key2) { return (key1 == key2); }