628 lines
20 KiB
C
628 lines
20 KiB
C
|
/*
|
||
|
|
* Copyright (C) 2018 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define LOG_TAG "audio_hw_waves"
|
||
|
|
/*#define LOG_NDEBUG 0*/
|
||
|
|
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <dlfcn.h>
|
||
|
|
#include <pthread.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <cutils/str_parms.h>
|
||
|
|
#include <log/log.h>
|
||
|
|
#include <audio_hw.h>
|
||
|
|
#include <system/audio.h>
|
||
|
|
#include <platform_api.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <math.h>
|
||
|
|
#include "audio_extn.h"
|
||
|
|
#include "maxxaudio.h"
|
||
|
|
|
||
|
|
#define LIB_MA_PARAM "libmaqdspparams.so"
|
||
|
|
#define LIB_MA_PATH "vendor/lib/"
|
||
|
|
#define PRESET_PATH "/vendor/etc/default.mps"
|
||
|
|
#define USER_PRESET_PATH ""
|
||
|
|
#define CONFIG_PATH "/vendor/etc/maxx_conf.ini"
|
||
|
|
#define CAL_PRESIST_STR "cal_persist"
|
||
|
|
#define CAL_SAMPLERATE_STR "cal_samplerate"
|
||
|
|
|
||
|
|
#define MA_QDSP_PARAM_INIT "maxxaudio_qdsp_parameters_initialize"
|
||
|
|
#define MA_QDSP_PARAM_DEINIT "maxxaudio_qdsp_parameters_uninitialize"
|
||
|
|
#define MA_QDSP_SET_LR_SWAP "maxxaudio_qdsp_set_lr_swap"
|
||
|
|
#define MA_QDSP_SET_MODE "maxxaudio_qdsp_set_sound_mode"
|
||
|
|
#define MA_QDSP_SET_VOL "maxxaudio_qdsp_set_volume"
|
||
|
|
#define MA_QDSP_SET_VOLT "maxxaudio_qdsp_set_volume_table"
|
||
|
|
|
||
|
|
#define SUPPORT_DEV "Blackbird"
|
||
|
|
#define SUPPORTED_USB 0x01
|
||
|
|
|
||
|
|
struct ma_audio_cal_settings {
|
||
|
|
void *platform;
|
||
|
|
int app_type;
|
||
|
|
audio_devices_t device;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct ma_state {
|
||
|
|
float vol;
|
||
|
|
bool active;
|
||
|
|
};
|
||
|
|
|
||
|
|
typedef enum MA_STREAM_TYPE {
|
||
|
|
STREAM_MIN_STREAM_TYPES,
|
||
|
|
STREAM_VOICE = STREAM_MIN_STREAM_TYPES,
|
||
|
|
STREAM_SYSTEM,
|
||
|
|
STREAM_RING,
|
||
|
|
STREAM_MUSIC,
|
||
|
|
STREAM_ALARM,
|
||
|
|
STREAM_NOTIFICATION ,
|
||
|
|
STREAM_MAX_TYPES,
|
||
|
|
} ma_stream_type_t;
|
||
|
|
|
||
|
|
typedef enum MA_CMD {
|
||
|
|
MA_CMD_VOL,
|
||
|
|
MA_CMD_SWAP_ENABLE,
|
||
|
|
MA_CMD_SWAP_DISABLE,
|
||
|
|
} ma_cmd_t;
|
||
|
|
|
||
|
|
typedef void *ma_audio_cal_handle_t;
|
||
|
|
typedef int (*set_audio_cal_t)(const struct ma_audio_cal_settings *, const char *);
|
||
|
|
|
||
|
|
typedef bool (*ma_param_init_t)(
|
||
|
|
ma_audio_cal_handle_t *,
|
||
|
|
void *, const char *, const char *,
|
||
|
|
const char *, set_audio_cal_t);
|
||
|
|
|
||
|
|
typedef bool (*ma_param_deinit_t)(ma_audio_cal_handle_t);
|
||
|
|
|
||
|
|
typedef bool (*ma_set_lr_swap_t)(
|
||
|
|
ma_audio_cal_handle_t,
|
||
|
|
const struct ma_audio_cal_settings *, bool);
|
||
|
|
|
||
|
|
typedef bool (*ma_set_sound_mode_t)(
|
||
|
|
ma_audio_cal_handle_t,
|
||
|
|
const struct ma_audio_cal_settings *, unsigned int);
|
||
|
|
|
||
|
|
typedef bool (*ma_set_volume_t)(
|
||
|
|
ma_audio_cal_handle_t,
|
||
|
|
const struct ma_audio_cal_settings *, double);
|
||
|
|
|
||
|
|
typedef bool (*ma_set_volume_table_t)(
|
||
|
|
ma_audio_cal_handle_t,
|
||
|
|
const struct ma_audio_cal_settings *,
|
||
|
|
size_t, struct ma_state *);
|
||
|
|
|
||
|
|
struct ma_platform_data {
|
||
|
|
void *waves_handle;
|
||
|
|
pthread_mutex_t lock;
|
||
|
|
ma_param_init_t ma_param_init;
|
||
|
|
ma_param_deinit_t ma_param_deinit;
|
||
|
|
ma_set_lr_swap_t ma_set_lr_swap;
|
||
|
|
ma_set_sound_mode_t ma_set_sound_mode;
|
||
|
|
ma_set_volume_t ma_set_volume;
|
||
|
|
ma_set_volume_table_t ma_set_volume_table;
|
||
|
|
};
|
||
|
|
|
||
|
|
ma_audio_cal_handle_t g_ma_audio_cal_handle = NULL;
|
||
|
|
static uint16_t g_supported_dev = 0;
|
||
|
|
static struct ma_state ma_cur_state_table[STREAM_MAX_TYPES];
|
||
|
|
static struct ma_platform_data *my_data = NULL;
|
||
|
|
|
||
|
|
static int set_audio_cal(
|
||
|
|
const struct ma_audio_cal_settings *audio_cal_settings,
|
||
|
|
const char *audio_cal)
|
||
|
|
|
||
|
|
{
|
||
|
|
ALOGV("set_audio_cal: %s", audio_cal);
|
||
|
|
|
||
|
|
return platform_set_parameters(audio_cal_settings->platform,
|
||
|
|
str_parms_create_str(audio_cal));
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool ma_set_lr_swap_l(
|
||
|
|
const struct ma_audio_cal_settings *audio_cal_settings,
|
||
|
|
bool swap)
|
||
|
|
{
|
||
|
|
return my_data->ma_set_lr_swap(g_ma_audio_cal_handle, audio_cal_settings, swap);
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool ma_set_sound_mode_l(
|
||
|
|
const struct ma_audio_cal_settings *audio_cal_settings,
|
||
|
|
int sound_mode)
|
||
|
|
{
|
||
|
|
return my_data->ma_set_sound_mode(g_ma_audio_cal_handle,
|
||
|
|
audio_cal_settings, sound_mode);
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool ma_set_volume_l(
|
||
|
|
const struct ma_audio_cal_settings *audio_cal_settings,
|
||
|
|
double volume)
|
||
|
|
{
|
||
|
|
return my_data->ma_set_volume(g_ma_audio_cal_handle, audio_cal_settings, volume);
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool ma_set_volume_table_l(
|
||
|
|
const struct ma_audio_cal_settings *audio_cal_settings,
|
||
|
|
size_t num_streams, struct ma_state *volume_table)
|
||
|
|
{
|
||
|
|
return my_data->ma_set_volume_table(
|
||
|
|
g_ma_audio_cal_handle,
|
||
|
|
audio_cal_settings,
|
||
|
|
num_streams,
|
||
|
|
volume_table);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static inline bool valid_usecase(struct audio_usecase *usecase)
|
||
|
|
{
|
||
|
|
if ((usecase->type == PCM_PLAYBACK) &&
|
||
|
|
/* supported usecases */
|
||
|
|
((usecase->id == USECASE_AUDIO_PLAYBACK_DEEP_BUFFER) ||
|
||
|
|
(usecase->id == USECASE_AUDIO_PLAYBACK_LOW_LATENCY) ||
|
||
|
|
(usecase->id == USECASE_AUDIO_PLAYBACK_OFFLOAD)) &&
|
||
|
|
/* support devices */
|
||
|
|
((usecase->devices & AUDIO_DEVICE_OUT_SPEAKER) ||
|
||
|
|
(usecase->devices & AUDIO_DEVICE_OUT_SPEAKER_SAFE) ||
|
||
|
|
(usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP) ||
|
||
|
|
(usecase->devices & AUDIO_DEVICE_OUT_ALL_USB)))
|
||
|
|
|
||
|
|
return true;
|
||
|
|
|
||
|
|
ALOGV("%s: not support type %d usecase %d device %d",
|
||
|
|
__func__, usecase->type, usecase->id, usecase->devices);
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// already hold lock
|
||
|
|
static inline bool is_active()
|
||
|
|
{
|
||
|
|
ma_stream_type_t i = 0;
|
||
|
|
|
||
|
|
for (i = 0; i < STREAM_MAX_TYPES; i++)
|
||
|
|
if (ma_cur_state_table[i].active &&
|
||
|
|
(ma_cur_state_table[i].vol != 0))
|
||
|
|
return true;
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool check_and_send_all_audio_cal(struct audio_device *adev, ma_cmd_t cmd)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
bool ret = false;
|
||
|
|
float vol = 0;
|
||
|
|
struct listnode *node;
|
||
|
|
struct audio_usecase *usecase;
|
||
|
|
struct ma_audio_cal_settings *ma_cal = NULL;
|
||
|
|
|
||
|
|
// alloct
|
||
|
|
ma_cal = (struct ma_audio_cal_settings *)malloc(sizeof(struct ma_audio_cal_settings));
|
||
|
|
|
||
|
|
if (ma_cal == NULL) {
|
||
|
|
ALOGE("%s: ma_cal alloct fail", __func__);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
list_for_each(node, &adev->usecase_list) {
|
||
|
|
usecase = node_to_item(node, struct audio_usecase, list);
|
||
|
|
if (valid_usecase(usecase)) {
|
||
|
|
ma_cal->platform = adev->platform;
|
||
|
|
ma_cal->app_type = usecase->stream.out->app_type_cfg.app_type;
|
||
|
|
ma_cal->device = usecase->stream.out->devices;
|
||
|
|
ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",
|
||
|
|
__func__, usecase->id, ma_cal->app_type, ma_cal->device);
|
||
|
|
|
||
|
|
switch (cmd) {
|
||
|
|
case MA_CMD_VOL:
|
||
|
|
ret = ma_set_volume_table_l(ma_cal, STREAM_MAX_TYPES,
|
||
|
|
ma_cur_state_table);
|
||
|
|
if (ret)
|
||
|
|
ALOGV("Waves: ma_set_volume_table_l success");
|
||
|
|
else
|
||
|
|
ALOGE("Waves: ma_set_volume_table_l %f returned with error.", vol);
|
||
|
|
|
||
|
|
ALOGV("%s: send volume table === Start", __func__);
|
||
|
|
for (i = 0; i < STREAM_MAX_TYPES; i++)
|
||
|
|
ALOGV("%s: stream(%d) volume(%f) active(%s)", __func__, i,
|
||
|
|
ma_cur_state_table[i].vol,
|
||
|
|
ma_cur_state_table[i].active ? "T" : "F");
|
||
|
|
ALOGV("%s: send volume table === End", __func__);
|
||
|
|
break;
|
||
|
|
case MA_CMD_SWAP_ENABLE:
|
||
|
|
ret = ma_set_lr_swap_l(ma_cal, true);
|
||
|
|
if (ret)
|
||
|
|
ALOGV("Waves: ma_set_lr_swap_l enable returned with success.");
|
||
|
|
else
|
||
|
|
ALOGE("Waves: ma_set_lr_swap_l enable returned with error.");
|
||
|
|
break;
|
||
|
|
case MA_CMD_SWAP_DISABLE:
|
||
|
|
ret = ma_set_lr_swap_l(ma_cal, false);
|
||
|
|
if (ret)
|
||
|
|
ALOGV("Waves: ma_set_lr_swap_l disable returned with success.");
|
||
|
|
else
|
||
|
|
ALOGE("Waves: ma_set_lr_swap_l disable returned with error.");
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
ALOGE("%s: unsupported cmd %d", __func__, cmd);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
free(ma_cal);
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool find_sup_dev(char *name)
|
||
|
|
{
|
||
|
|
char *token;
|
||
|
|
const char s[2] = ",";
|
||
|
|
bool ret = false;
|
||
|
|
char sup_devs[128];
|
||
|
|
|
||
|
|
// the rule of comforming suppored dev's name
|
||
|
|
// 1. Both string len are equal
|
||
|
|
// 2. Both string content are equal
|
||
|
|
|
||
|
|
strncpy(sup_devs, SUPPORT_DEV, sizeof(sup_devs));
|
||
|
|
token = strtok(sup_devs, s);
|
||
|
|
while (token != NULL) {
|
||
|
|
if (strncmp(token, name, strlen(token)) == 0 &&
|
||
|
|
strlen(token) == strlen(name)) {
|
||
|
|
ALOGD("%s: support dev %s", __func__, token);
|
||
|
|
ret = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
token = strtok(NULL, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void ma_set_swap_l(struct audio_device *adev, bool enable)
|
||
|
|
{
|
||
|
|
if (!my_data) {
|
||
|
|
ALOGE("%s: maxxaudio isn't initialized.", __func__);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (enable)
|
||
|
|
check_and_send_all_audio_cal(adev, MA_CMD_SWAP_ENABLE);
|
||
|
|
else
|
||
|
|
check_and_send_all_audio_cal(adev, MA_CMD_SWAP_DISABLE);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void ma_support_usb(bool enable, int card)
|
||
|
|
{
|
||
|
|
char path[128];
|
||
|
|
char id[32];
|
||
|
|
int ret = 0;
|
||
|
|
int32_t fd = -1;
|
||
|
|
char *idd;
|
||
|
|
|
||
|
|
if (enable) {
|
||
|
|
ret = snprintf(path, sizeof(path), "/proc/asound/card%u/id", card);
|
||
|
|
if (ret < 0) {
|
||
|
|
ALOGE("%s: failed on snprintf (%d) to path %s\n",
|
||
|
|
__func__, ret, path);
|
||
|
|
goto done;
|
||
|
|
}
|
||
|
|
fd = open(path, O_RDONLY);
|
||
|
|
if (fd < 0) {
|
||
|
|
ALOGE("%s: error failed to open id file %s error: %d\n",
|
||
|
|
__func__, path, errno);
|
||
|
|
goto done;
|
||
|
|
}
|
||
|
|
if (read(fd, id, sizeof(id)) < 0) {
|
||
|
|
ALOGE("%s: file read error", __func__);
|
||
|
|
goto done;
|
||
|
|
}
|
||
|
|
//replace '\n' to '\0'
|
||
|
|
idd = strtok(id, "\n");
|
||
|
|
|
||
|
|
if (find_sup_dev(idd)) {
|
||
|
|
ALOGV("%s: support device name is %s", __func__, id);
|
||
|
|
g_supported_dev |= SUPPORTED_USB;
|
||
|
|
} else
|
||
|
|
ALOGV("%s: device %s isn't found from %s", __func__, id, SUPPORT_DEV);
|
||
|
|
} else {
|
||
|
|
g_supported_dev &= ~SUPPORTED_USB;
|
||
|
|
}
|
||
|
|
|
||
|
|
done:
|
||
|
|
if (fd >= 0) close(fd);
|
||
|
|
}
|
||
|
|
|
||
|
|
// adev_init lock held
|
||
|
|
void audio_extn_ma_init(void *platform)
|
||
|
|
{
|
||
|
|
ma_stream_type_t i = 0;
|
||
|
|
int ret = 0;
|
||
|
|
char lib_path[256];
|
||
|
|
|
||
|
|
if (platform == NULL) {
|
||
|
|
ALOGE("%s: platform is NULL", __func__);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (my_data) { free(my_data); }
|
||
|
|
my_data = calloc(1, sizeof(struct ma_platform_data));
|
||
|
|
if (my_data == NULL) {
|
||
|
|
ALOGE("%s: ma_cal alloct fail", __func__);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
pthread_mutex_init(&my_data->lock, NULL);
|
||
|
|
|
||
|
|
ret = snprintf(lib_path, sizeof(lib_path), "%s/%s", LIB_MA_PATH, LIB_MA_PARAM);
|
||
|
|
if (ret < 0) {
|
||
|
|
ALOGE("%s: snprintf failed for lib %s, ret %d", __func__, LIB_MA_PARAM, ret);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
my_data->waves_handle = dlopen(lib_path, RTLD_NOW);
|
||
|
|
if (my_data->waves_handle == NULL) {
|
||
|
|
ALOGE("%s: DLOPEN failed for %s", __func__, LIB_MA_PARAM);
|
||
|
|
goto error;
|
||
|
|
} else {
|
||
|
|
ALOGV("%s: DLOPEN successful for %s", __func__, LIB_MA_PARAM);
|
||
|
|
|
||
|
|
my_data->ma_param_init = (ma_param_init_t)dlsym(my_data->waves_handle,
|
||
|
|
MA_QDSP_PARAM_INIT);
|
||
|
|
if (!my_data->ma_param_init) {
|
||
|
|
ALOGE("%s: dlsym error %s for ma_param_init", __func__, dlerror());
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
my_data->ma_param_deinit = (ma_param_deinit_t)dlsym(my_data->waves_handle,
|
||
|
|
MA_QDSP_PARAM_DEINIT);
|
||
|
|
if (!my_data->ma_param_deinit) {
|
||
|
|
ALOGE("%s: dlsym error %s for ma_param_deinit", __func__, dlerror());
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
my_data->ma_set_lr_swap = (ma_set_lr_swap_t)dlsym(my_data->waves_handle,
|
||
|
|
MA_QDSP_SET_LR_SWAP);
|
||
|
|
if (!my_data->ma_set_lr_swap) {
|
||
|
|
ALOGE("%s: dlsym error %s for ma_set_lr_swap", __func__, dlerror());
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
my_data->ma_set_sound_mode = (ma_set_sound_mode_t)dlsym(my_data->waves_handle,
|
||
|
|
MA_QDSP_SET_MODE);
|
||
|
|
if (!my_data->ma_set_sound_mode) {
|
||
|
|
ALOGE("%s: dlsym error %s for ma_set_sound_mode", __func__, dlerror());
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
my_data->ma_set_volume = (ma_set_volume_t)dlsym(my_data->waves_handle,
|
||
|
|
MA_QDSP_SET_VOL);
|
||
|
|
if (!my_data->ma_set_volume) {
|
||
|
|
ALOGE("%s: dlsym error %s for ma_set_volume", __func__, dlerror());
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
my_data->ma_set_volume_table = (ma_set_volume_table_t)dlsym(my_data->waves_handle,
|
||
|
|
MA_QDSP_SET_VOLT);
|
||
|
|
if (!my_data->ma_set_volume_table) {
|
||
|
|
ALOGE("%s: dlsym error %s for ma_set_volume_table", __func__, dlerror());
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* check file */
|
||
|
|
if (access(PRESET_PATH, F_OK) < 0) {
|
||
|
|
ALOGW("%s: file %s isn't existed.", __func__, PRESET_PATH);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
/* TODO: check user preset table once the feature is enabled
|
||
|
|
if (access(USER_PRESET_PATH, F_OK) < 0 ){
|
||
|
|
ALOGW("%s: file %s isn't existed.", __func__, USER_PRESET_PATH);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
if (access(CONFIG_PATH, F_OK) < 0) {
|
||
|
|
ALOGW("%s: file %s isn't existed.", __func__, CONFIG_PATH);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* init ma parameter */
|
||
|
|
if (my_data->ma_param_init(&g_ma_audio_cal_handle,
|
||
|
|
platform, /* TODO: remove this on next version*/
|
||
|
|
PRESET_PATH,
|
||
|
|
USER_PRESET_PATH, /* useless */
|
||
|
|
CONFIG_PATH,
|
||
|
|
&set_audio_cal)) {
|
||
|
|
if (!g_ma_audio_cal_handle) {
|
||
|
|
ALOGE("%s: ma parameters initialize failed", __func__);
|
||
|
|
my_data->ma_param_deinit(&g_ma_audio_cal_handle);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
ALOGD("%s: ma parameters initialize successful", __func__);
|
||
|
|
} else {
|
||
|
|
ALOGE("%s: ma parameters initialize failed", __func__);
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* init volume table */
|
||
|
|
for (i = 0; i < STREAM_MAX_TYPES; i++) {
|
||
|
|
ma_cur_state_table[i].vol = 0.0;
|
||
|
|
ma_cur_state_table[i].active = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
|
||
|
|
error:
|
||
|
|
if (my_data) { free(my_data); }
|
||
|
|
my_data = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//adev_init lock held
|
||
|
|
void audio_extn_ma_deinit()
|
||
|
|
{
|
||
|
|
if (my_data) {
|
||
|
|
/* deinit ma parameter */
|
||
|
|
if (my_data->ma_param_deinit &&
|
||
|
|
my_data->ma_param_deinit(&g_ma_audio_cal_handle))
|
||
|
|
ALOGD("%s: ma parameters uninitialize successful", __func__);
|
||
|
|
else
|
||
|
|
ALOGD("%s: ma parameters uninitialize failed", __func__);
|
||
|
|
|
||
|
|
pthread_mutex_destroy(&my_data->lock);
|
||
|
|
free(my_data);
|
||
|
|
my_data = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// adev_init and adev lock held
|
||
|
|
bool audio_extn_ma_set_state(
|
||
|
|
struct audio_device *adev, int stream_type, float vol, bool active)
|
||
|
|
{
|
||
|
|
bool ret = false;
|
||
|
|
ma_stream_type_t stype = (ma_stream_type_t)stream_type;
|
||
|
|
|
||
|
|
ALOGV("%s: stream[%d] vol[%f] active[%s]",
|
||
|
|
__func__, stream_type, vol, active ? "true" : "false");
|
||
|
|
|
||
|
|
if (!my_data) {
|
||
|
|
ALOGE("%s: maxxaudio isn't initialized.", __func__);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
// update condition
|
||
|
|
// 1. start track: active and volume isn't zero
|
||
|
|
// 2. stop track: no tracks are active
|
||
|
|
if ((active && vol != 0) ||
|
||
|
|
(!active)) {
|
||
|
|
pthread_mutex_lock(&my_data->lock);
|
||
|
|
|
||
|
|
ma_cur_state_table[stype].vol = vol;
|
||
|
|
ma_cur_state_table[stype].active = active;
|
||
|
|
if (is_active())
|
||
|
|
ret = check_and_send_all_audio_cal(adev, MA_CMD_VOL);
|
||
|
|
|
||
|
|
pthread_mutex_unlock(&my_data->lock);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
void audio_extn_ma_set_device(struct audio_device *adev, struct audio_usecase *usecase)
|
||
|
|
{
|
||
|
|
int i = 0;
|
||
|
|
int u_index = -1;
|
||
|
|
float vol = 0;
|
||
|
|
struct ma_audio_cal_settings *ma_cal = NULL;
|
||
|
|
|
||
|
|
if (!my_data) {
|
||
|
|
ALOGV("%s: maxxaudio isn't initialized.", __func__);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!valid_usecase(usecase)) {
|
||
|
|
ALOGV("%s: %d is not supported usecase", __func__, usecase->id);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
ma_cal = (struct ma_audio_cal_settings *)malloc(sizeof(struct ma_audio_cal_settings));
|
||
|
|
|
||
|
|
/* update audio_cal and send it */
|
||
|
|
if (ma_cal != NULL){
|
||
|
|
ma_cal->platform = adev->platform;
|
||
|
|
ma_cal->app_type = usecase->stream.out->app_type_cfg.app_type;
|
||
|
|
ma_cal->device = usecase->stream.out->devices;
|
||
|
|
ALOGV("%s: send usecase(%d) app_type(%d) device(%d)",
|
||
|
|
__func__, usecase->id, ma_cal->app_type, ma_cal->device);
|
||
|
|
|
||
|
|
pthread_mutex_lock(&my_data->lock);
|
||
|
|
|
||
|
|
if (is_active()) {
|
||
|
|
ALOGV("%s: send volume table === Start", __func__);
|
||
|
|
for (i = 0; i < STREAM_MAX_TYPES; i++)
|
||
|
|
ALOGV("%s: stream(%d) volume(%f) active(%s)", __func__, i,
|
||
|
|
ma_cur_state_table[i].vol,
|
||
|
|
ma_cur_state_table[i].active ? "T" : "F");
|
||
|
|
ALOGV("%s: send volume table === End", __func__);
|
||
|
|
|
||
|
|
if (!ma_set_volume_table_l(ma_cal,
|
||
|
|
STREAM_MAX_TYPES,
|
||
|
|
ma_cur_state_table))
|
||
|
|
ALOGE("Waves: ma_set_volume_table_l %f returned with error.", vol);
|
||
|
|
else
|
||
|
|
ALOGV("Waves: ma_set_volume_table_l success");
|
||
|
|
|
||
|
|
}
|
||
|
|
pthread_mutex_unlock(&my_data->lock);
|
||
|
|
free(ma_cal);
|
||
|
|
} else {
|
||
|
|
ALOGE("%s: ma_cal alloct fail", __func__);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void audio_extn_ma_set_parameters(struct audio_device *adev, struct str_parms *parms)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
bool ret_b;
|
||
|
|
int val;
|
||
|
|
char value[128];
|
||
|
|
|
||
|
|
// do LR swap and usb recognition
|
||
|
|
ret = str_parms_get_int(parms, "rotation", &val);
|
||
|
|
if (ret >= 0) {
|
||
|
|
switch (val) {
|
||
|
|
case 270:
|
||
|
|
ma_set_swap_l(adev, true);
|
||
|
|
break;
|
||
|
|
case 0:
|
||
|
|
case 90:
|
||
|
|
case 180:
|
||
|
|
ma_set_swap_l(adev, false);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// check connect status
|
||
|
|
ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_CONNECT, value, sizeof(value));
|
||
|
|
if (ret >= 0) {
|
||
|
|
audio_devices_t device = (audio_devices_t)strtoul(value, NULL, 10);
|
||
|
|
if (audio_is_usb_out_device(device)) {
|
||
|
|
ret = str_parms_get_str(parms, "card", value, sizeof(value));
|
||
|
|
if (ret >= 0) {
|
||
|
|
const int card = atoi(value);
|
||
|
|
ma_support_usb(true, card);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// check disconnect status
|
||
|
|
ret = str_parms_get_str(parms, AUDIO_PARAMETER_DEVICE_DISCONNECT, value, sizeof(value));
|
||
|
|
if (ret >= 0) {
|
||
|
|
audio_devices_t device = (audio_devices_t)strtoul(value, NULL, 10);
|
||
|
|
if (audio_is_usb_out_device(device)) {
|
||
|
|
ret = str_parms_get_str(parms, "card", value, sizeof(value));
|
||
|
|
if (ret >= 0) {
|
||
|
|
const int card = atoi(value);
|
||
|
|
ma_support_usb(false, card /*useless*/);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool audio_extn_ma_supported_usb()
|
||
|
|
{
|
||
|
|
ALOGV("%s: current support 0x%x", __func__, g_supported_dev);
|
||
|
|
return (g_supported_dev & SUPPORTED_USB) ? true : false;
|
||
|
|
}
|