dereference
/
android_hardware_qcom_audio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android_hardware_qcom_audio/hal/audio_extn/utils.c

1218 lines
42 KiB
C
Raw Blame History

/*
* Copyright (c) 2014-2016, 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 <errno.h>
#include <cutils/properties.h>
#include <cutils/config_utils.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <cutils/str_parms.h>
#include <cutils/log.h>
#include <cutils/misc.h>
#include "audio_hw.h"
#include "platform.h"
#include "platform_api.h"
#include "audio_extn.h"
#include "voice.h"
#ifdef AUDIO_EXTERNAL_HDMI_ENABLED
#ifdef HDMI_PASSTHROUGH_ENABLED
#include "audio_parsers.h"
#endif
#endif
#define AUDIO_OUTPUT_POLICY_VENDOR_CONFIG_FILE "/vendor/etc/audio_output_policy.conf"
#define OUTPUTS_TAG "outputs"
#define DYNAMIC_VALUE_TAG "dynamic"
#define FLAGS_TAG "flags"
#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
#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
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_DIRECT_PCM),
STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_PRIMARY),
STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_FAST),
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),
#ifdef INCALL_MUSIC_ENABLED
STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_INCALL_MUSIC),
#endif
STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH),
};
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),
#ifdef AUDIO_EXTN_FORMATS_ENABLED
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_E_AC3_JOC),
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),
#endif
};
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;
}
}
return 0;
}
static audio_output_flags_t parse_flag_names(char *name)
{
uint32_t flag = 0;
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 - %d", flag);
return (audio_output_flags_t)flag;
}
static void parse_format_names(char *name, struct streams_output_cfg *so_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(&so_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(&so_info->format_list, &sf_info->list);
}
str = strtok_r(NULL, "|", &last_r);
}
}
static void parse_sample_rate_names(char *name, struct streams_output_cfg *so_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(&so_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(&so_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_output_cfg_list(cnode *root, void *platform,
struct listnode *streams_output_cfg_list)
{
cnode *node = root->first_child;
struct streams_output_cfg *so_info;
ALOGV("%s", __func__);
so_info = (struct streams_output_cfg *)calloc(1, sizeof(struct streams_output_cfg));
if (!so_info) {
ALOGE("failed to allocate mem for so_info list element");
return;
}
while (node) {
if (strcmp(node->name, FLAGS_TAG) == 0) {
so_info->flags = parse_flag_names((char *)node->value);
} else if (strcmp(node->name, FORMATS_TAG) == 0) {
parse_format_names((char *)node->value, so_info);
} else if (strcmp(node->name, SAMPLING_RATES_TAG) == 0) {
so_info->app_type_cfg.sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
parse_sample_rate_names((char *)node->value, so_info);
} else if (strcmp(node->name, BIT_WIDTH_TAG) == 0) {
so_info->app_type_cfg.bit_width = parse_bit_width_names((char *)node->value);
} else if (strcmp(node->name, APP_TYPE_TAG) == 0) {
so_info->app_type_cfg.app_type = parse_app_type_names(platform, (char *)node->value);
}
node = node->next;
}
list_add_tail(streams_output_cfg_list, &so_info->list);
}
static void load_output(cnode *root, void *platform,
struct listnode *streams_output_cfg_list)
{
cnode *node = config_find(root, OUTPUTS_TAG);
if (node == NULL) {
ALOGE("%s: could not load output, node is NULL", __func__);
return;
}
node = node->first_child;
while (node) {
ALOGV("%s: loading output %s", __func__, node->name);
update_streams_output_cfg_list(node, platform, streams_output_cfg_list);
node = node->next;
}
}
static void send_app_type_cfg(void *platform, struct mixer *mixer,
struct listnode *streams_output_cfg_list)
{
int app_type_cfg[MAX_LENGTH_MIXER_CONTROL_IN_INT] = {-1};
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_output_cfg *so_info;
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;
}
if (streams_output_cfg_list == NULL) {
app_type_cfg[length++] = 1;
app_type_cfg[length++] = platform_get_default_app_type(platform);
app_type_cfg[length++] = 48000;
app_type_cfg[length++] = 16;
mixer_ctl_set_array(ctl, app_type_cfg, length);
return;
}
app_type_cfg[length++] = num_app_types;
list_for_each(node, streams_output_cfg_list) {
so_info = node_to_item(node, struct streams_output_cfg, list);
update = true;
for (i=0; i<length; i=i+3) {
if (app_type_cfg[i+1] == -1)
break;
else if (app_type_cfg[i+1] == so_info->app_type_cfg.app_type) {
update = false;
break;
}
}
if (update && ((length + 3) <= MAX_LENGTH_MIXER_CONTROL_IN_INT)) {
num_app_types += 1 ;
app_type_cfg[length++] = so_info->app_type_cfg.app_type;
app_type_cfg[length++] = so_info->app_type_cfg.sample_rate;
app_type_cfg[length++] = so_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);
}
}
void audio_extn_utils_update_streams_output_cfg_list(void *platform,
struct mixer *mixer,
struct listnode *streams_output_cfg_list)
{
cnode *root;
char *data;
ALOGV("%s", __func__);
list_init(streams_output_cfg_list);
data = (char *)load_file(AUDIO_OUTPUT_POLICY_VENDOR_CONFIG_FILE, NULL);
if (data == NULL) {
send_app_type_cfg(platform, mixer, NULL);
ALOGE("%s: could not load output policy config file", __func__);
return;
}
root = config_node("", "");
if (root == NULL) {
ALOGE("cfg_list, NULL config root");
free(data);
return;
}
config_load(root, data);
load_output(root, platform, streams_output_cfg_list);
send_app_type_cfg(platform, mixer, streams_output_cfg_list);
config_free(root);
free(data);
}
void audio_extn_utils_dump_streams_output_cfg_list(
struct listnode *streams_output_cfg_list)
{
struct listnode *node_i, *node_j;
struct streams_output_cfg *so_info;
struct stream_format *sf_info;
struct stream_sample_rate *ss_info;
ALOGV("%s", __func__);
list_for_each(node_i, streams_output_cfg_list) {
so_info = node_to_item(node_i, struct streams_output_cfg, list);
ALOGV("%s: flags-%d, output_sample_rate-%d, output_bit_width-%d, app_type-%d",
__func__, so_info->flags, so_info->app_type_cfg.sample_rate,
so_info->app_type_cfg.bit_width, so_info->app_type_cfg.app_type);
list_for_each(node_j, &so_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, &so_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_release_streams_output_cfg_list(
struct listnode *streams_output_cfg_list)
{
struct listnode *node_i, *node_j;
struct streams_output_cfg *so_info;
ALOGV("%s", __func__);
while (!list_empty(streams_output_cfg_list)) {
node_i = list_head(streams_output_cfg_list);
so_info = node_to_item(node_i, struct streams_output_cfg, list);
while (!list_empty(&so_info->format_list)) {
node_j = list_head(&so_info->format_list);
list_remove(node_j);
free(node_to_item(node_j, struct stream_format, list));
}
while (!list_empty(&so_info->sample_rate_list)) {
node_j = list_head(&so_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_output_cfg, list));
}
}
static bool set_output_cfg(struct streams_output_cfg *so_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, &so_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 == so_info->app_type_cfg.bit_width)) {
app_type_cfg->app_type = so_info->app_type_cfg.app_type;
app_type_cfg->sample_rate = ss_info->sample_rate;
app_type_cfg->bit_width = so_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, &so_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 == so_info->app_type_cfg.bit_width)) {
app_type_cfg->app_type = so_info->app_type_cfg.app_type;
app_type_cfg->sample_rate = sample_rate;
app_type_cfg->bit_width = so_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_app_type_cfg(void *platform,
struct listnode *streams_output_cfg_list,
audio_devices_t devices,
audio_output_flags_t flags,
audio_format_t format,
uint32_t sample_rate,
uint32_t bit_width,
audio_channel_mask_t channel_mask,
struct stream_app_type_cfg *app_type_cfg)
{
struct listnode *node_i, *node_j;
struct streams_output_cfg *so_info;
struct stream_format *sf_info;
char value[PROPERTY_VALUE_MAX] = {0};
if ((bit_width >= 24) &&
(devices & AUDIO_DEVICE_OUT_SPEAKER)) {
int32_t bw = platform_get_snd_device_bit_width(SND_DEVICE_OUT_SPEAKER);
if (-ENOSYS != bw)
bit_width = (uint32_t)bw;
sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
ALOGI("%s Allowing 24-bit playback on speaker ONLY at default sampling rate", __func__);
}
property_get("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_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_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;
}
if(devices & AUDIO_DEVICE_OUT_ALL_A2DP) {
//TODO: Handle fractional sampling rate configuration for LL
audio_extn_a2dp_get_apptype_params(&sample_rate, &bit_width);
ALOGI("%s using %d sampling rate %d bit width for A2DP CoPP",
__func__, sample_rate, bit_width);
}
ALOGV("%s: flags: %x, format: %x sample_rate %d",
__func__, flags, format, sample_rate);
list_for_each(node_i, streams_output_cfg_list) {
so_info = node_to_item(node_i, struct streams_output_cfg, list);
if (so_info->flags == flags) {
list_for_each(node_j, &so_info->format_list) {
sf_info = node_to_item(node_j, struct stream_format, list);
if (sf_info->format == format) {
if (set_output_cfg(so_info, app_type_cfg, sample_rate, bit_width))
return;
}
}
}
}
list_for_each(node_i, streams_output_cfg_list) {
so_info = node_to_item(node_i, struct streams_output_cfg, list);
if (so_info->flags == AUDIO_OUTPUT_FLAG_PRIMARY) {
ALOGV("Compatible output profile not found.");
app_type_cfg->app_type = so_info->app_type_cfg.app_type;
app_type_cfg->sample_rate = so_info->app_type_cfg.sample_rate;
app_type_cfg->bit_width = so_info->app_type_cfg.bit_width;
ALOGV("%s Default to primary output: App type: %d sample_rate %d",
__func__, so_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;
}
int audio_extn_utils_send_app_type_cfg(struct audio_device *adev,
struct audio_usecase *usecase)
{
char mixer_ctl_name[MAX_LENGTH_MIXER_CONTROL_IN_INT];
int app_type_cfg[MAX_LENGTH_MIXER_CONTROL_IN_INT], len = 0, rc;
struct mixer_ctl *ctl;
int pcm_device_id = 0, acdb_dev_id, snd_device = usecase->out_snd_device;
int32_t sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
char value[PROPERTY_VALUE_MAX] = {0};
ALOGV("%s", __func__);
if (usecase->type != PCM_PLAYBACK && usecase->type != PCM_CAPTURE) {
ALOGE("%s: not a playback or 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_LOW_LATENCY) &&
(usecase->id != USECASE_AUDIO_PLAYBACK_MULTI_CH) &&
(!is_offload_usecase(usecase->id)) &&
(usecase->type != PCM_CAPTURE)) {
ALOGV("%s: a rx/tx path where app type cfg is not required %d", __func__, usecase->id);
rc = 0;
goto exit_send_app_type_cfg;
}
if (usecase->type == PCM_PLAYBACK) {
snd_device = usecase->out_snd_device;
pcm_device_id = platform_get_pcm_device_id(usecase->id, PCM_PLAYBACK);
} else if (usecase->type == PCM_CAPTURE) {
snd_device = usecase->in_snd_device;
pcm_device_id = platform_get_pcm_device_id(usecase->id, PCM_CAPTURE);
}
snprintf(mixer_ctl_name, sizeof(mixer_ctl_name),
"Audio Stream %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 = (snd_device == SND_DEVICE_OUT_SPEAKER) ?
platform_get_spkr_prot_snd_device(snd_device) : 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;
}
if ((usecase->type == PCM_PLAYBACK) && (usecase->stream.out == NULL)) {
sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
app_type_cfg[len++] = platform_get_default_app_type(adev->platform);
app_type_cfg[len++] = acdb_dev_id;
app_type_cfg[len++] = sample_rate;
ALOGI("%s:%d PLAYBACK app_type %d, acdb_dev_id %d, sample_rate %d",
__func__, __LINE__,
platform_get_default_app_type(adev->platform),
acdb_dev_id, sample_rate);
} else if (usecase->type == PCM_PLAYBACK) {
if (usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER) {
usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
} else if ((usecase->stream.out->app_type_cfg.sample_rate == OUTPUT_SAMPLING_RATE_44100 &&
!(audio_is_this_native_usecase(usecase))) ||
(usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) {
usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
}
sample_rate = usecase->stream.out->app_type_cfg.sample_rate;
property_get("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_FLAG_COMPRESS_PASSTHROUGH))
sample_rate = CODEC_BACKEND_DEFAULT_SAMPLE_RATE;
}
if ((24 == usecase->stream.out->bit_width) &&
(usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER)) {
usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
} else if ((snd_device != SND_DEVICE_OUT_HEADPHONES_44_1 &&
usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) ||
(usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) {
usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
}
sample_rate = usecase->stream.out->app_type_cfg.sample_rate;
app_type_cfg[len++] = usecase->stream.out->app_type_cfg.app_type;
app_type_cfg[len++] = acdb_dev_id;
if (((usecase->stream.out->format == AUDIO_FORMAT_E_AC3) ||
(usecase->stream.out->format == AUDIO_FORMAT_E_AC3_JOC))
&& audio_extn_passthru_is_passthrough_stream(usecase->stream.out)) {
app_type_cfg[len++] = sample_rate * 4;
} else {
app_type_cfg[len++] = sample_rate;
}
ALOGI("%s PLAYBACK app_type %d, acdb_dev_id %d, sample_rate %d",
__func__, usecase->stream.out->app_type_cfg.app_type, acdb_dev_id, sample_rate);
} else if (usecase->type == PCM_CAPTURE) {
app_type_cfg[len++] = platform_get_default_app_type_v2(adev->platform, usecase->type);
app_type_cfg[len++] = acdb_dev_id;
app_type_cfg[len++] = sample_rate;
ALOGI("%s CAPTURE app_type %d, acdb_dev_id %d, sample_rate %d",
__func__, platform_get_default_app_type_v2(adev->platform, usecase->type),
acdb_dev_id, sample_rate);
}
mixer_ctl_set_array(ctl, app_type_cfg, len);
rc = 0;
ALOGI("%s:becf: adm: app_type %d, acdb_dev_id %d, sample_rate %d",
__func__,
platform_get_default_app_type_v2(adev->platform, usecase->type),
acdb_dev_id, sample_rate);
exit_send_app_type_cfg:
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)
{
uint32_t fragment_size = 0;
uint32_t pcm_offload_time = PCM_OFFLOAD_BUFFER_DURATION;
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));
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;
}
}
void audio_extn_utils_send_audio_calibration(struct audio_device *adev,
struct audio_usecase *usecase)
{
int type = usecase->type;
if (type == PCM_PLAYBACK) {
struct stream_out *out = usecase->stream.out;
int snd_device = usecase->out_snd_device;
snd_device = (snd_device == SND_DEVICE_OUT_SPEAKER) ?
platform_get_spkr_prot_snd_device(snd_device) : snd_device;
platform_send_audio_calibration(adev->platform, usecase,
out->app_type_cfg.app_type,
usecase->stream.out->app_type_cfg.sample_rate);
}
if ((type == PCM_HFP_CALL) || (type == PCM_CAPTURE)) {
/* when app type is default. the sample rate is not used to send cal */
platform_send_audio_calibration(adev->platform, usecase,
platform_get_default_app_type_v2(adev->platform, usecase->type),
48000);
}
}
// 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<BASE_TABLE_SIZE;i++) {
getIndex[(uint8_t)bTable[i]] = (uint8_t)i;
}
getIndex[(uint8_t)'=']=0;
j=0;k=0;
num = ilen/4;
rem = ilen%4;
if(rem==0)
num = num-1;
cflag=0;
for(i=0; i<num; i++) {
res=0;
for(ii=0;ii<4;ii++) {
res = res << 6;
tmp = getIndex[(uint8_t)inp[j++]];
res = res | tmp;
cflag = cflag | tmp;
}
outp[k++] = (res >> 16)&0xFF;
outp[k++] = (res >> 8)&0xFF;
outp[k++] = res & 0xFF;
}
// Handle last bytes special
pcnt=0;
if(rem == 0) {
//With padding or full data
res = 0;
for(ii=0;ii<4;ii++) {
if(inp[j] == '=')
pcnt++;
res = res << 6;
tmp = getIndex[(uint8_t)inp[j++]];
res = res | tmp;
cflag = cflag | tmp;
}
outp[k++] = res >> 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<rem;i++) {
res = res << 6;
tmp = getIndex[(uint8_t)inp[j++]];
res = res | tmp;
cflag = cflag | tmp;
}
for(i=rem;i<4;i++) {
res = res << 6;
pcnt++;
}
outp[k++] = res >> 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<num; i++) {
//prepare index
res = inp[j++]<<16;
res = res | inp[j++]<<8;
res = res | inp[j++];
//get output map from index
outp[k++] = (char) bTable[(res>>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;
}
#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;
}
#ifdef HDMI_PASSTHROUGH_ENABLED
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;
}
#endif
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);
#ifdef HDMI_PASSTHROUGH_ENABLED
if (audio_extn_is_dolby_format(out->format) &&
/*TODO:Extend code to support DTS passthrough*/
/*set compressed channel status bits*/
audio_extn_passthru_is_passthrough_stream(out)){
get_compressed_channel_status(buffer, bytes, channel_status, AUDIO_PARSER_CODEC_AC3);
} else
#endif
{
/*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
Reference in New Issue View Git Blame Copy Permalink