1111 lines
49 KiB
C
1111 lines
49 KiB
C
/*
|
||
* Copyright (C) 2017 Amlogic Corporation.
|
||
*
|
||
* 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_control"
|
||
//#define LOG_NDEBUG 0
|
||
|
||
#include <errno.h>
|
||
#include <pthread.h>
|
||
#include <stdint.h>
|
||
#include <stdlib.h>
|
||
#include <fcntl.h>
|
||
#include <time.h>
|
||
#include <inttypes.h>
|
||
#include <sys/time.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/prctl.h>
|
||
#include <cutils/atomic.h>
|
||
#include <cutils/str_parms.h>
|
||
#include <linux/ioctl.h>
|
||
#include <hardware/hardware.h>
|
||
#include <system/audio.h>
|
||
#include <audio_utils/channels.h>
|
||
#include <sys/socket.h>
|
||
#include <linux/netlink.h>
|
||
#include <fcntl.h>
|
||
#include <sys/ioctl.h>
|
||
|
||
#include "aml_audio_timer.h"
|
||
#include "aml_malloc_debug.h"
|
||
#include "aml_audio_stream.h"
|
||
#include "audio_hw_ms12_v2.h"
|
||
#include "audio_hw_ms12_common.h"
|
||
#include "audio_hw_utils.h"
|
||
#include "dolby_lib_api.h"
|
||
#include <aml_alsa_mixer.h>
|
||
#include "tv_patch_format_parser.h"
|
||
#include "aml_capture_output.h"
|
||
#include "audio_controls_utils.h"
|
||
|
||
#define AUDIO_CONTROL_CAPTURE_OPEN "cap_buffer=cap_for_lge,24576"
|
||
#define AUDIO_CONTROL_CAPTURE_CLOSE "cap_buffer=cap_for_lge,0"
|
||
|
||
aml_audio_control g_actrl;
|
||
aml_audio_control* get_audio_control(void) {
|
||
return &g_actrl;
|
||
}
|
||
static aml_audio_patch_handle g_ptle;
|
||
|
||
|
||
static const char* outputMaskType2Str(audio_output_type_e type) {
|
||
ENUM_TYPE_TO_STR_START("AUDIO_OUTPUT_TYPE_");
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_NONE)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_SPK)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_OPTIC)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_OPTIC_LG)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_BLUETOOTH)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_HP)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_ARC)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_WISA)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_SE_BT)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_CAPTURE)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_SE_ARC)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_BT_SUR)
|
||
ENUM_TYPE_TO_STR(AUDIO_OUTPUT_TYPE_MAX)
|
||
ENUM_TYPE_TO_STR_END
|
||
}
|
||
|
||
void parse_earc_coding_type(int codec_type, int *coding_type) {
|
||
switch (codec_type) {
|
||
case SNDOUT_CODEC_PCM:
|
||
*coding_type = EARC_STEREO_LPCM;
|
||
break;
|
||
case SNDOUT_CODEC_AC3:
|
||
*coding_type = EARC_AC3;
|
||
break;
|
||
case SNDOUT_CODEC_AAC:
|
||
*coding_type = EARC_UNDEFINED;
|
||
break;
|
||
case SNDOUT_CODEC_DTS:
|
||
*coding_type = EARC_DTS;
|
||
break;
|
||
case SNDOUT_CODEC_EAC3:
|
||
*coding_type = EARC_EAC3;
|
||
break;
|
||
case SNDOUT_CODEC_TRUEHD:
|
||
*coding_type = EARC_MLP;
|
||
break;
|
||
case SNDOUT_CODEC_MAT2PCM:
|
||
*coding_type = EARC_MLP;
|
||
break;
|
||
case SNDOUT_CODEC_DTSHD:
|
||
*coding_type = EARC_DTS_HD;
|
||
break;
|
||
case SNDOUT_CODEC_MPEG4_AAC:
|
||
*coding_type = EARC_UNDEFINED;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void set_optput_device_gain(output_device_idx_e output_type, int vol) {
|
||
struct audio_port_config config;
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
|
||
memset(&config, 0, sizeof(config));
|
||
config.type = AUDIO_PORT_TYPE_DEVICE;
|
||
config.config_mask = AUDIO_PORT_CONFIG_GAIN;
|
||
config.role = AUDIO_PORT_ROLE_SINK;
|
||
|
||
if (output_type == OUTPUT_DEVICE_SPK) {
|
||
config.ext.device.type = AUDIO_DEVICE_OUT_SPEAKER;
|
||
} else if (output_type == OUTPUT_DEVICE_HP) {
|
||
config.ext.device.type = AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
|
||
} else if (output_type == OUTPUT_DEVICE_ARC) {
|
||
if (is_STB(aml_dev)) {
|
||
aml_dev->hw_device.set_master_volume(&aml_dev->hw_device, (float)(vol/100.0));
|
||
return;
|
||
} else
|
||
config.ext.device.type = AUDIO_DEVICE_OUT_HDMI_ARC;
|
||
} else if (output_type == OUTPUT_DEVICE_OPTIC || output_type == OUTPUT_DEVICE_OPTIC_LG) {
|
||
config.ext.device.type = AUDIO_DEVICE_OUT_SPDIF;
|
||
} else if (output_type == OUTPUT_DEVICE_BLUETOOTH) {
|
||
config.ext.device.type = AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
|
||
} else if (output_type == OUTPUT_DEVICE_SE_BT) {
|
||
config.ext.device.type = AUDIO_DEVICE_OUT_BLUETOOTH_SCO;
|
||
} else if (output_type == OUTPUT_DEVICE_SE_BT_SUR) {
|
||
config.ext.device.type = OUTPORT_BT_SCO_HEADSET;
|
||
}
|
||
|
||
config.gain.values[0] = AmplToDb(vol/100.0) * 100;
|
||
aml_dev->hw_device.set_audio_port_config(&aml_dev->hw_device, &config);
|
||
}
|
||
|
||
static int map_source_to_audio_device_type(input_source_type_e source_type) {
|
||
int ret = -1;
|
||
switch (source_type) {
|
||
case INPUT_SOURCE_ATV:
|
||
ret = AUDIO_DEVICE_IN_FM_TUNER;
|
||
break;
|
||
case INPUT_SOURCE_DTV:
|
||
ret = AUDIO_DEVICE_IN_TV_TUNER;
|
||
break;
|
||
case INPUT_SOURCE_AV:
|
||
ret = AUDIO_DEVICE_IN_LINE;
|
||
break;
|
||
case INPUT_SOURCE_HDMI:
|
||
ret = AUDIO_DEVICE_IN_HDMI;
|
||
break;
|
||
default:
|
||
ret = AUDIO_DEVICE_IN_LINE;
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static void mute_amixer_by_id(int device_id, int mute) {
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
aml_actrl->amixer_mute[device_id] = mute;
|
||
|
||
if (mute) {
|
||
aml_actrl->amixer_gain[device_id].target_gain = 0;
|
||
} else {
|
||
aml_actrl->amixer_gain[device_id].target_gain = aml_actrl->amixer_gain[device_id].save_gain;
|
||
}
|
||
|
||
// when mute or unmute , we fadeing 5ms
|
||
aml_actrl->amixer_gain[device_id].fade_frames = 5 * 48;// YY to do : duration * sample_rate, but now I do not know the sample rate
|
||
aml_actrl->amixer_gain[device_id].gain_step = (aml_actrl->amixer_gain[device_id].target_gain - aml_actrl->amixer_gain[device_id].current_gain) / aml_actrl->amixer_gain[device_id].fade_frames;
|
||
ALOGI("[%s:%d] device_id(%d) mute(%d) target_gain(%f) current_gain(%f) fade_frames(%d) gain_step(%f)", __FUNCTION__, __LINE__,
|
||
device_id, mute, aml_actrl->amixer_gain[device_id].target_gain, aml_actrl->amixer_gain[device_id].current_gain, aml_actrl->amixer_gain[device_id].fade_frames, aml_actrl->amixer_gain[device_id].gain_step);
|
||
}
|
||
|
||
int get_set_audio_handle(input_source_type_e source_type, audio_patch_handle_t handle_id, int mode) {
|
||
if (mode) {
|
||
switch (source_type) {
|
||
case INPUT_SOURCE_ATV :
|
||
g_ptle.atv_patch_handle = handle_id;
|
||
break;
|
||
case INPUT_SOURCE_DTV :
|
||
g_ptle.dtv_patch_handle = handle_id;
|
||
break;
|
||
case INPUT_SOURCE_AV :
|
||
g_ptle.av_patch_handle = handle_id;
|
||
break;
|
||
case INPUT_SOURCE_HDMI :
|
||
g_ptle.hdmi_patch_handle = handle_id;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
} else {
|
||
switch (source_type) {
|
||
case INPUT_SOURCE_ATV :
|
||
return g_ptle.atv_patch_handle;
|
||
case INPUT_SOURCE_DTV :
|
||
return g_ptle.dtv_patch_handle;
|
||
case INPUT_SOURCE_AV :
|
||
return g_ptle.av_patch_handle;
|
||
case INPUT_SOURCE_HDMI :
|
||
return g_ptle.hdmi_patch_handle;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static void mapping_codec_from_kernel_to_hal(adec_src_codec_type_t adec_codec, audio_format_t* hal_codec) {
|
||
switch (adec_codec) {
|
||
case ADEC_CODEC_PCM:
|
||
case ADEC_CODEC_SIF:
|
||
case ADEC_CODEC_SIF_BTSC:
|
||
case ADEC_CODEC_SIF_A2:
|
||
*hal_codec = AUDIO_FORMAT_PCM_16_BIT;
|
||
break;
|
||
case ADEC_CODEC_AC3:
|
||
*hal_codec = AUDIO_FORMAT_AC3;
|
||
break;
|
||
case ADEC_CODEC_EAC3:
|
||
case ADEC_CODEC_EAC3_ATMOS:
|
||
*hal_codec = AUDIO_FORMAT_E_AC3;
|
||
break;
|
||
case ADEC_CODEC_AC4:
|
||
case ADEC_CODEC_AC4_ATMOS:
|
||
*hal_codec = AUDIO_FORMAT_AC4;
|
||
break;
|
||
case ADEC_CODEC_MAT:
|
||
case ADEC_CODEC_MAT_ATMOS:
|
||
*hal_codec = AUDIO_FORMAT_MAT;
|
||
break;
|
||
case ADEC_CODEC_TRUEHD:
|
||
case ADEC_CODEC_TRUEHD_ATMOS:
|
||
*hal_codec = AUDIO_FORMAT_DOLBY_TRUEHD;
|
||
break;
|
||
case ADEC_CODEC_AAC:
|
||
*hal_codec = AUDIO_FORMAT_AAC;
|
||
break;
|
||
case ADEC_CODEC_HEAAC:
|
||
*hal_codec = AUDIO_FORMAT_HE_AAC_V1;
|
||
break;
|
||
case ADEC_CODEC_MPEG:
|
||
case ADEC_CODEC_MPEG_H:
|
||
*hal_codec = AUDIO_FORMAT_MP3;// to do : ??
|
||
break;
|
||
case ADEC_CODEC_DRA:
|
||
*hal_codec = AUDIO_FORMAT_PCM_16_BIT;// to do : ??
|
||
break;
|
||
case ADEC_CODEC_DTS:
|
||
case ADEC_CODEC_DTS_HD_MA:
|
||
case ADEC_CODEC_DTS_EXPRESS:
|
||
case ADEC_CODEC_DTS_CD:
|
||
*hal_codec = AUDIO_FORMAT_DTS;
|
||
break;
|
||
default:
|
||
*hal_codec = AUDIO_FORMAT_PCM_16_BIT;
|
||
break;
|
||
}
|
||
}
|
||
|
||
static int source_connect(input_source_type_e source_type) {
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
struct audio_port_config source;
|
||
struct audio_port_config sink;
|
||
int ret = -1;
|
||
memset(&source, 0 , sizeof(struct audio_port_config));
|
||
source.id = 1;
|
||
source.role = AUDIO_PORT_ROLE_SOURCE;
|
||
source.type = AUDIO_PORT_TYPE_DEVICE;
|
||
source.ext.device.type = map_source_to_audio_device_type(source_type);
|
||
|
||
memset(&sink, 0 , sizeof(struct audio_port_config));
|
||
sink.id = 2;
|
||
sink.role = AUDIO_PORT_ROLE_SINK;
|
||
sink.type = AUDIO_PORT_TYPE_DEVICE;
|
||
sink.ext.device.type = AUDIO_DEVICE_OUT_SPEAKER;
|
||
|
||
ret = aml_dev->hw_device.create_audio_patch(&aml_dev->hw_device,
|
||
1,
|
||
&source,
|
||
1,
|
||
&sink,
|
||
&aml_actrl->patch_handle);
|
||
get_set_audio_handle(source_type, aml_actrl->patch_handle, 1);
|
||
if (0 == ret) {
|
||
ALOGI("[%s:%d] connect to source(%d) success", __FUNCTION__, __LINE__, source_type);
|
||
} else {
|
||
ALOGE("[%s:%d] connect to source(%d) fail", __FUNCTION__, __LINE__, source_type);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static int source_disconnect(input_source_type_e source_type) {
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
aml_actrl->patch_handle = get_set_audio_handle(source_type, aml_actrl->patch_handle, 0);
|
||
int ret = -1;
|
||
ret = aml_dev->hw_device.release_audio_patch(&aml_dev->hw_device, aml_actrl->patch_handle);
|
||
if (0 == ret) {
|
||
ALOGI("[%s:%d] disconnect source(%d) success, handle is %d", __FUNCTION__, __LINE__, source_type, aml_actrl->patch_handle);
|
||
} else {
|
||
ALOGE("[%s:%d] disconnect source(%d) fail", __FUNCTION__, __LINE__, source_type);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static int adec_stop(adec_index_t adec_id) {
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
int ret = -1;
|
||
switch (aml_actrl->adec_play_info[adec_id].src_id) {
|
||
case ADEC_SRC_ATP0:
|
||
case ADEC_SRC_ATP1:
|
||
//ret = dtv_stop(&(aml_actrl->adec_play_info[adec_id]));
|
||
break;
|
||
case ADEC_SRC_HDMI_PORT0:
|
||
case ADEC_SRC_HDMI_PORT1:
|
||
case ADEC_SRC_HDMI_PORT2:
|
||
case ADEC_SRC_HDMI_PORT3:
|
||
ret = source_disconnect(INPUT_SOURCE_HDMI);
|
||
break;
|
||
case ADEC_SRC_AAD:
|
||
ret = source_disconnect(INPUT_SOURCE_ATV);
|
||
aml_actrl->sif_play_state = SIF_STATE_INIT;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static int adec_start(adec_index_t adec_id) {
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
int ret = -1;
|
||
switch (aml_actrl->adec_play_info[adec_id].src_id) {
|
||
case ADEC_SRC_ATP0:
|
||
case ADEC_SRC_ATP1:
|
||
//ret = dtv_start(&(aml_actrl->adec_play_info[adec_id]));
|
||
break;
|
||
case ADEC_SRC_HDMI_PORT0:
|
||
case ADEC_SRC_HDMI_PORT1:
|
||
case ADEC_SRC_HDMI_PORT2:
|
||
case ADEC_SRC_HDMI_PORT3:
|
||
ret = source_connect(INPUT_SOURCE_HDMI);
|
||
break;
|
||
case ADEC_SRC_AAD:
|
||
if (aml_actrl->sif_play_state == SIF_STATE_CONNECTED) {
|
||
ret = 0;
|
||
} else if (aml_actrl->sif_play_state == SIF_STATE_INIT) {
|
||
ret = source_connect(INPUT_SOURCE_ATV);
|
||
aml_actrl->sif_play_state = SIF_STATE_CONNECTED;
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static const char* outputType2Str(output_device_idx_e type) {
|
||
ENUM_TYPE_TO_STR_START("OUTPUT_DEVICE_");
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_UNKNOWN)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_SPK)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_OPTIC)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_OPTIC_LG)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_BLUETOOTH)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_HP)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_ARC)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_WISA)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_SE_BT)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_CAPTURE)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_SE_ARC)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_SE_BT_SUR)
|
||
ENUM_TYPE_TO_STR(OUTPUT_DEVICE_MAX)
|
||
ENUM_TYPE_TO_STR_END
|
||
}
|
||
|
||
static const char* inputType2Str(input_type_e type) {
|
||
ENUM_TYPE_TO_STR_START("INPUT_");
|
||
ENUM_TYPE_TO_STR(INPUT_UNKNOWN)
|
||
ENUM_TYPE_TO_STR(INPUT_ADEC)
|
||
ENUM_TYPE_TO_STR(INPUT_AMIXER)
|
||
ENUM_TYPE_TO_STR_END
|
||
}
|
||
|
||
void control_utils(char *msg) {
|
||
|
||
ALOGI("========================================================\n");
|
||
/*for (int i = 0; i < UEVENT_MSG_LEN; i++) {
|
||
ALOGI("[%d]=%c ", i, msg[i]);
|
||
}*/
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
//char tmpstr[256] = {0};
|
||
while (*msg) {
|
||
|
||
AM_LOGI("msg= %s", msg);
|
||
|
||
if (!strncmp(msg, "GAIN_INPUT=", 11)) {
|
||
int input_type = 0;
|
||
int input_port_num = 0;
|
||
int gain = 0;
|
||
int duration = 0;
|
||
//struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
|
||
msg += 11;
|
||
sscanf(msg ,"%d %d %d %d", &input_type, &input_port_num, &gain, &duration);
|
||
ALOGI("[%s:%d] msg=%s input_type=(%s) input_port_num=%d, gain=%d duration=%d", __FUNCTION__, __LINE__,
|
||
msg, inputType2Str(input_type), input_port_num, gain, duration);
|
||
if (duration == 0) {
|
||
duration = 50; // when set volume, do 50ms fading
|
||
}
|
||
|
||
if (input_type == INPUT_ADEC) {
|
||
aml_actrl->adec_gain[input_port_num] = gain;
|
||
if (aml_actrl->adec_mute[input_port_num] == 0) {// unmute
|
||
//adev_set_master_volume (aml_dev, (float)gain/VOLUME_GAIN_0DB);
|
||
}
|
||
} else if (input_type == INPUT_AMIXER) {
|
||
int device_id = input_port_num;
|
||
aml_actrl->amixer_gain[device_id].save_gain = (float)gain/VOLUME_GAIN_0DB;
|
||
if (aml_actrl->amixer_mute[device_id] == 0) {
|
||
aml_actrl->amixer_gain[device_id].target_gain = aml_actrl->amixer_gain[device_id].save_gain;
|
||
aml_actrl->amixer_gain[device_id].duration = duration;// YY to do : The unit of duration is ms, but I do not know the unit of LG.
|
||
aml_actrl->amixer_gain[device_id].fade_frames = duration * 48;// YY to do : duration * sample_rate, but now I do not know the sample rate
|
||
aml_actrl->amixer_gain[device_id].gain_step = (aml_actrl->amixer_gain[device_id].target_gain - aml_actrl->amixer_gain[device_id].current_gain) / aml_actrl->amixer_gain[device_id].fade_frames;
|
||
}
|
||
ALOGI("[%s:%d] AMIXER_GAIN_INPUT_DURATION device_id(%d) mute(%d) gain(0x%x)(%f) current_gain(%f) duration(%d) fade_frames(%d) gain_step(%f)", __FUNCTION__, __LINE__,
|
||
device_id, aml_actrl->amixer_mute[device_id], gain, aml_actrl->amixer_gain[device_id].target_gain, aml_actrl->amixer_gain[device_id].current_gain, duration,aml_actrl->amixer_gain[device_id].fade_frames, aml_actrl->amixer_gain[device_id].gain_step);
|
||
}
|
||
} else if (!strncmp(msg, "GAIN_OUTPUT=", 12)) {
|
||
int output_type = 0;
|
||
int output_gain = 0;
|
||
|
||
msg += 12;
|
||
sscanf(msg ,"%d %d", &output_type, &output_gain);
|
||
if (output_gain > VOLUME_GAIN_0DB) {
|
||
output_gain = VOLUME_GAIN_0DB;
|
||
} else if (output_gain < 0) {
|
||
output_gain = 0;
|
||
}
|
||
aml_actrl->output_device_gain[output_type] = output_gain * 100 / VOLUME_GAIN_0DB;
|
||
//struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
ALOGI("[%s:%d] GAIN_OUTPUT=%s output_type=(%s) output_gain=%d output_device_gain=%d", __FUNCTION__, __LINE__,
|
||
msg, outputType2Str(output_type), output_gain, aml_actrl->output_device_gain[output_type]);
|
||
if (aml_actrl->output_device_mute[output_type] == 0) {// when unmute, set gain to hal
|
||
if (output_type == OUTPUT_DEVICE_SPK /*&& aml_dev->is_TV*/) {
|
||
ALOGE("***in TV, use 'lgse_var_fn009' to control spk vol");
|
||
} else {
|
||
set_optput_device_gain(output_type, aml_actrl->output_device_gain[output_type]);
|
||
}
|
||
} //to do : need to implement other output gain
|
||
} else if (!strncmp(msg, "lgse_var_fn009=", 15)) {
|
||
output_device_idx_e output_type = OUTPUT_DEVICE_SPK;
|
||
int output_gain = 0;
|
||
|
||
msg += 15;
|
||
sscanf(msg ,"%d", &output_gain);
|
||
if (output_gain > 100) {
|
||
output_gain = 100;
|
||
} else if (output_gain < 0) {
|
||
output_gain = 0;
|
||
}
|
||
aml_actrl->output_device_gain[output_type] = output_gain;
|
||
ALOGI("[%s:%d] msg: %s, output_gain=%d", __FUNCTION__, __LINE__,msg, output_gain);
|
||
if (aml_actrl->output_device_mute[output_type] == 0) {// when unmute, set gain to hal
|
||
set_optput_device_gain(output_type, aml_actrl->output_device_gain[output_type]);
|
||
}
|
||
//to do : need to implement other output gain
|
||
} else if (!strncmp(msg, "MUTE_INPUT=", 11)) {
|
||
int input_type = 0;
|
||
int input_port_num = 0;
|
||
int mute = 0;
|
||
|
||
msg += 11;
|
||
sscanf(msg ,"%d %d %d", &input_type, &input_port_num, &mute);
|
||
ALOGI("[%s:%d] MUTE_INPUT=%s input_type=(%s) input_port_num=%d mute=%d", __FUNCTION__, __LINE__,
|
||
msg, inputType2Str(input_type), input_port_num, mute);
|
||
|
||
if (input_type == INPUT_ADEC) {
|
||
aml_actrl->adec_mute[input_port_num] = mute;
|
||
if (mute) {//mute
|
||
//adev_set_master_volume (aml_dev, (float)0);
|
||
} else {//unmute
|
||
//adev_set_master_volume (aml_dev, (float)aml_actrl->adec_gain[input_port_num]/VOLUME_GAIN_0DB);
|
||
}
|
||
} else if (input_type == INPUT_AMIXER) {
|
||
mute_amixer_by_id(input_port_num, mute);
|
||
}
|
||
} else if (!strncmp(msg, "MUTE_OUTPUT=", 12)) {
|
||
int output_type = 0;
|
||
int output_mute = 0;
|
||
|
||
msg += 12;
|
||
sscanf(msg ,"%d %d", &output_type, &output_mute);
|
||
aml_actrl->output_device_mute[output_type] = output_mute;
|
||
ALOGI("[%s:%d] MUTE_OUTPUT=%s output_type=(%s) output_mute=%d", __FUNCTION__, __LINE__,
|
||
msg, outputType2Str(output_type), output_mute);
|
||
if (aml_actrl->output_device_mute[output_type]) { // mute
|
||
set_optput_device_gain(output_type, 0);
|
||
} else { // unmute
|
||
set_optput_device_gain(output_type, aml_actrl->output_device_gain[output_type]);
|
||
}
|
||
} else if (!strncmp(msg, "GAIN_AUDIODESCRIPTION=", 22)) {
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
struct aml_stream_out *aml_out = direct_active(aml_dev);
|
||
aml_dec_t *aml_dec = NULL;
|
||
if (aml_out != NULL) {
|
||
aml_dec = aml_out->aml_dec;
|
||
} else {
|
||
ALOGI("[%s:%d] aml_out is NULL", __FUNCTION__, __LINE__);
|
||
}
|
||
struct dolby_ms12_desc *ms12 = &(aml_dev->ms12);
|
||
int ad_gain = 0;
|
||
|
||
msg += 22;
|
||
sscanf(msg ,"%d", &ad_gain);
|
||
if (ad_gain > VOLUME_GAIN_0DB) {
|
||
ad_gain = VOLUME_GAIN_0DB;
|
||
} else if (ad_gain < 0) {
|
||
ad_gain = 0;
|
||
}
|
||
aml_dev->advol_level = ad_gain * 100 / VOLUME_GAIN_0DB;
|
||
ALOGI("[%s:%d] GAIN_AUDIODESCRIPTION=%s ad_gain=%d aml_dev->advol_level=%d", __FUNCTION__, __LINE__, msg, ad_gain, aml_dev->advol_level);
|
||
if (aml_out != NULL && aml_dev->advol_level != aml_out->dec_config.advol_level) {
|
||
aml_out->dec_config.advol_level = aml_dev->advol_level;
|
||
if (aml_dec != NULL) {
|
||
aml_decoder_set_config(aml_dec, AML_DEC_CONFIG_AD_VOL, &aml_out->dec_config);
|
||
} else {
|
||
ALOGI("[%s:%d] aml_dec is NULL", __FUNCTION__, __LINE__);
|
||
}
|
||
}
|
||
if (eDolbyMS12Lib == aml_dev->dolby_lib_type_last && ms12->dolby_ms12_enable) {
|
||
pthread_mutex_lock(&ms12->lock);
|
||
//set_ms12_ad_vol(ms12, aml_dev->advol_level);
|
||
pthread_mutex_unlock(&ms12->lock);
|
||
}
|
||
} else if (!strncmp(msg, "ADC_CONNECT", 11)) {
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
if (is_TV(aml_dev))
|
||
source_connect(INPUT_SOURCE_AV);
|
||
} else if (!strncmp(msg, "ADC_DISCONNECT", 14)) {
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
if (is_TV(aml_dev))
|
||
source_disconnect(INPUT_SOURCE_AV);
|
||
} else if (!strncmp(msg, "ADEC_CONNECT=", 13)) {
|
||
msg += 13;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_idx = 0;
|
||
int src_type = 0;
|
||
sscanf(msg ,"%d %d", &adec_idx, &src_type);
|
||
AM_LOGI("adec_idx=%d src_type=%d", adec_idx, src_type);
|
||
aml_actrl->adec_play_info[adec_idx].src_id = src_type;
|
||
aml_actrl->adec_play_info[adec_idx].adec_state = ADEC_STATE_CONNECTED;
|
||
} else if (!strncmp(msg, "ADEC_DISCONNECT=", 16)) {
|
||
msg += 16;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_idx = 0;
|
||
int ret = -1;
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
sscanf(msg ,"%d", &adec_idx);
|
||
AM_LOGI("adec_idx=%d, src_type=%d sif_play_state =%d", adec_idx, aml_actrl->adec_play_info[adec_idx].src_id, aml_actrl->sif_play_state);
|
||
if (aml_actrl->sif_play_state == SIF_STATE_CONNECTED) {
|
||
ret = source_disconnect(INPUT_SOURCE_ATV);
|
||
aml_actrl->sif_play_state = SIF_STATE_INIT;
|
||
} else if ((aml_actrl->adec_play_info[adec_idx].src_id == ADEC_SRC_ATP0 || aml_actrl->adec_play_info[adec_idx].src_id == ADEC_SRC_ATP1)
|
||
&& aml_actrl->adec_play_info[adec_idx].adec_state == ADEC_STATE_RUNNING) {
|
||
ret = adec_stop(adec_idx);
|
||
} else if (is_TV(aml_dev) && ((aml_actrl->adec_play_info[adec_idx].src_id == ADEC_SRC_HDMI_PORT0) ||
|
||
(aml_actrl->adec_play_info[adec_idx].src_id == ADEC_SRC_HDMI_PORT1) ||
|
||
(aml_actrl->adec_play_info[adec_idx].src_id == ADEC_SRC_HDMI_PORT2) ||
|
||
(aml_actrl->adec_play_info[adec_idx].src_id == ADEC_SRC_HDMI_PORT3))
|
||
&& aml_actrl->adec_play_info[adec_idx].adec_state == ADEC_STATE_RUNNING) {
|
||
ret = source_disconnect(INPUT_SOURCE_HDMI);
|
||
}
|
||
if (!ret) {
|
||
aml_actrl->adec_play_info[adec_idx].adec_state = ADEC_STATE_INIT;
|
||
aml_actrl->adec_play_info[adec_idx].src_id = ADEC_SRC_UNKNOWN;
|
||
aml_actrl->adec_play_info[adec_idx].adec_codec = ADEC_CODEC_UNKNOWN;
|
||
}
|
||
} else if (!strncmp(msg, "ADEC_DOWNMIXMODE=", 17)) {
|
||
msg += 17;
|
||
AM_LOGI("msg=%s", msg);
|
||
|
||
int adec_index = 0;
|
||
int downmix_mode = 0; //adec_downmix_mode_ext_type_t 0-LORO 1-LTRT
|
||
sscanf(msg ,"%d %d", &adec_index, &downmix_mode);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
int audio_hal_downmix_mode = 0;// 0-LTRT 1-LORO
|
||
if (downmix_mode == 0) {
|
||
audio_hal_downmix_mode = 1;
|
||
} else if (downmix_mode == 1) {
|
||
audio_hal_downmix_mode = 0;
|
||
}
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-dmx %d", audio_hal_downmix_mode);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_CODEC=", 11)) {
|
||
msg += 11;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_idx = 0;
|
||
int codec = 0;
|
||
sscanf(msg ,"%d %d", &adec_idx, &codec);
|
||
ALOGI("[%s:%d] adec_idx=%d codec=%d", __FUNCTION__, __LINE__, adec_idx, codec);
|
||
audio_format_t hal_codec;
|
||
mapping_codec_from_kernel_to_hal((adec_src_codec_type_t)codec, &hal_codec);
|
||
aml_actrl->adec_play_info[adec_idx].adec_codec = hal_codec;
|
||
} else if (!strncmp(msg, "ADEC_START=", 11)) {
|
||
msg += 11;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_idx = 0;
|
||
sscanf(msg ,"%d", &adec_idx);
|
||
AM_LOGI("adec_idx=%d, src=%d, state %d", adec_idx, aml_actrl->adec_play_info[adec_idx].src_id, aml_actrl->adec_play_info[adec_idx].adec_state);
|
||
if (aml_actrl->adec_play_info[adec_idx].adec_state == ADEC_STATE_CONNECTED) {
|
||
int ret = adec_start(adec_idx);
|
||
if (!ret) {
|
||
aml_actrl->adec_play_info[adec_idx].adec_state = ADEC_STATE_RUNNING;
|
||
}
|
||
}
|
||
} else if (!strncmp(msg, "ADEC_STOP=", 10)) {
|
||
msg += 10;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_idx = 0;
|
||
sscanf(msg ,"%d", &adec_idx);
|
||
AM_LOGI("adec_idx=%d. src=%d, state %d", adec_idx, aml_actrl->adec_play_info[adec_idx].src_id, aml_actrl->adec_play_info[adec_idx].adec_state);
|
||
if (aml_actrl->adec_play_info[adec_idx].adec_state == ADEC_STATE_RUNNING) {
|
||
int ret = adec_stop(adec_idx);
|
||
if (!ret) {
|
||
aml_actrl->adec_play_info[adec_idx].adec_state = ADEC_STATE_CONNECTED;
|
||
}
|
||
}
|
||
} else if (!strncmp(msg, "ADEC_TP_DECODER_OUTPUTMODE=", 27)) {
|
||
msg += 27;
|
||
AM_LOGI("msg=%s", msg);
|
||
|
||
int adec_index = 0;
|
||
int DualMonoMode = 0;//adec_dualmono_mode_t
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
AM_AOUT_OutputMode_t output_mode = DualMonoMode;
|
||
char tmp_msg[50];
|
||
|
||
sscanf(msg ,"%d %d", &adec_index, &DualMonoMode);
|
||
// to do
|
||
//我们的处理在audio_hal_data_processing，LG预期在adec中...
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
if (DualMonoMode == 3) {//ADEC_DUALMONO_MODE_MIX in alsa-ext-adec.h
|
||
output_mode = AM_AOUT_OUTPUT_LRMIX;
|
||
}
|
||
snprintf(tmp_msg, 50, "sound_track=%d", output_mode);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_SYNCMODE=", 14)) {
|
||
msg += 14;
|
||
AM_LOGI("msg=%s", msg);
|
||
|
||
int adec_index = 0;
|
||
int sync_onoff = 0;
|
||
sscanf(msg ,"%d %d", &adec_index, &sync_onoff);
|
||
// to do
|
||
} else if (!strncmp(msg, "ADEC_DOLBYDRCMODE=", 18)) { //set DRC mode : https://confluence.amlogic.com/pages/viewpage.action?pageId=100813927
|
||
msg += 18;
|
||
AM_LOGI("msg=%s", msg);
|
||
|
||
int adec_index = 0;
|
||
int dolyb_drc_mode = 0;
|
||
sscanf(msg ,"%d %d", &adec_index, &dolyb_drc_mode);
|
||
// to do : how to support dual decoder?
|
||
//Does this setting will affect our original DRC setting flow?
|
||
// TO DO
|
||
#if 0
|
||
if (dolyb_drc_mode == 0) { // line reference adec_dolbydrc_mode_ext_type_t in alsa-ext-adec.h
|
||
system("echo drcmode 2 > /sys/class/audiodsp/ac3_drc_control");
|
||
system("echo drchighcutscale 64 > /sys/class/audiodsp/ac3_drc_control");
|
||
system("echo drclowboostscale 64 > /sys/class/audiodsp/ac3_drc_control");
|
||
} else if (dolyb_drc_mode == 1) { //RF
|
||
system("echo drcmode 3 > /sys/class/audiodsp/ac3_drc_control");
|
||
system("echo drchighcutscale 0 > /sys/class/audiodsp/ac3_drc_control");
|
||
system("echo drclowboostscale 0 > /sys/class/audiodsp/ac3_drc_control");
|
||
} else if (dolyb_drc_mode == 2) { //off
|
||
system("echo drcmode 2 > /sys/class/audiodsp/ac3_drc_control");
|
||
system("echo drchighcutscale 0 > /sys/class/audiodsp/ac3_drc_control");
|
||
system("echo drclowboostscale 0 > /sys/class/audiodsp/ac3_drc_control");
|
||
}
|
||
#endif
|
||
|
||
} else if (!strncmp(msg, "ADEC_DEFAULTPRL=", 16)) {
|
||
msg += 16;
|
||
AM_LOGI("msg=%s", msg);
|
||
|
||
int adec_index = 0;
|
||
int default_prl = 0;
|
||
sscanf(msg ,"%d %d", &adec_index, &default_prl);
|
||
// to do : What is prl?
|
||
} else if (!strncmp(msg, "ADEC_AC4_AUTO1STLANG=", 21)) {
|
||
msg += 21;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int lang_type = 0;//adec_ac4_lang_code_ext_type_t
|
||
int first_lang = 0;
|
||
|
||
sscanf(msg ,"%d %d %d", &adec_index, &lang_type, &first_lang);
|
||
// to do : how to support dual decoder?
|
||
if (lang_type == 0) {//ISO639_1
|
||
//to do
|
||
//mapping ISO639_1 to ISO639_2
|
||
;
|
||
}
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
char lang[4];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
lang[0] = first_lang >> 24;
|
||
lang[1] = (first_lang >> 16) & 0xff;
|
||
lang[2] = (first_lang >> 8) & 0xff;
|
||
lang[3] = '\0';
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-lang %s", lang);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_AC4_AUTO2NDLANG=", 21)) {
|
||
msg += 21;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int lang_type = 0;//adec_ac4_lang_code_ext_type_t
|
||
int second_lang = 0;
|
||
|
||
sscanf(msg ,"%d %d %d", &adec_index, &lang_type, &second_lang);
|
||
// to do : how to support dual decoder?
|
||
if (lang_type == 0) {//ISO639_1
|
||
//to do
|
||
//mapping ISO639_1 to ISO639_2
|
||
;
|
||
}
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
char lang[4];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
lang[0] = second_lang >> 24;
|
||
lang[1] = (second_lang >> 16) & 0xff;
|
||
lang[2] = (second_lang >> 8) & 0xff;
|
||
lang[3] = '\0';
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-lang2 %s", lang);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_AC4_AUTO_ADTYPE=", 21)) {
|
||
msg += 21;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int ad_type = 0;//adec_ac4_ad_ext_type_t
|
||
|
||
sscanf(msg ,"%d %d", &adec_index, &ad_type);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-at %d", ad_type);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_AC4_AUTO_PRIORITIZE_ADTYPE=", 32)) {
|
||
msg += 32;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int ac4_prioritize_ad_type = 0;//true or flase
|
||
|
||
sscanf(msg ,"%d %d", &adec_index, &ac4_prioritize_ad_type);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-pat %d", ac4_prioritize_ad_type);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_AC4_DIALOGENHANCEGAIN=", 27)) {
|
||
msg += 27;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int dialogenhance_gain = 0;//true or flase
|
||
sscanf(msg ,"%d %d", &adec_index, &dialogenhance_gain);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
snprintf(tmp_msg, 50, "hal_param_dialogue_enhancement=%d", dialogenhance_gain);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_AC4_AUTO_ADMIXING=", 23)) {
|
||
msg += 23;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int ac4_admixing = 0;//true or flase
|
||
sscanf(msg ,"%d %d", &adec_index, &ac4_admixing);
|
||
// to do :
|
||
} else if (!strncmp(msg, "ADEC_AC4_PRES_GROUP_IDX=", 24)) {
|
||
msg += 24;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_index = 0;
|
||
int ac4_pres_group_idx = 0;
|
||
sscanf(msg ,"%d %d", &adec_index, &ac4_pres_group_idx);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-ac4_pres_group_idx %d", ac4_pres_group_idx);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_DOLBY_OTTMODE=", 19)) {
|
||
msg += 19;
|
||
AM_LOGI("msg=%s", msg);
|
||
int ott_mode = 0; // for linux, dolby always continues output
|
||
int atmos_lock = 0;
|
||
sscanf(msg ,"%d %d", &ott_mode, &atmos_lock);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-atmos_lock %d", atmos_lock);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "ADEC_AC4_ASSOCIATE_AUDIO_VOLUME=", 32)) {
|
||
msg += 32;
|
||
AM_LOGI("msg=%s", msg);
|
||
int ott_mode = 0; // for linux, dolby always continues output
|
||
int ac4_associate_volume = 0;
|
||
sscanf(msg ,"%d %d", &ott_mode, &ac4_associate_volume);
|
||
// to do : how to support dual decoder?
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-xu %d", ac4_associate_volume);
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else if (!strncmp(msg, "SNDOUT_CONNECT=", 15)) {
|
||
int output = 0;
|
||
int input = 0;
|
||
int input_port_number = 0;
|
||
|
||
msg += 15;
|
||
sscanf(msg ,"%d %d %d", &output, &input, &input_port_number);
|
||
ALOGI("[%s:%d] SNDOUT_CONNECT=%s output=%s(%x) input=%s input_port_number=%d", __FUNCTION__, __LINE__,
|
||
msg, outputMaskType2Str(output), output, inputType2Str(input), input_port_number);
|
||
aml_actrl->audio_output_type |= output;
|
||
if (input == INPUT_AMIXER) {
|
||
/* workaround for socts "alsa-sndout-adv-0013: DisconnectTestAdv" (no 'gain_input' setting at beginning in this case). still mute if last case run SNDOUT_DISCONNECT ever*/
|
||
mute_amixer_by_id(input_port_number, 0);
|
||
}
|
||
} else if (!strncmp(msg, "SNDOUT_DISCONNECT=", 18)) {
|
||
int output = 0;
|
||
int input = 0;
|
||
int input_port_number = 0;
|
||
|
||
msg += 18;
|
||
sscanf(msg ,"%d %d %d", &output, &input, &input_port_number);
|
||
ALOGI("[%s:%d] SNDOUT_DISCONNECT=%s output=%s(%x) input=%s input_port_number=%d", __FUNCTION__, __LINE__,
|
||
msg, outputMaskType2Str(output), output, inputType2Str(input), input_port_number);
|
||
aml_actrl->audio_output_type &= ~output;
|
||
if (input == INPUT_AMIXER) {
|
||
mute_amixer_by_id(input_port_number, 1);// workaround for socts-alsa-sndout "alsa-sndout-adv-0013: DisconnectTestAdv", if disconnect amixer from output device, not mix it data
|
||
}
|
||
} else if (!strncmp(msg, "SNDOUT_MAINAUDIO_OUTPUT=", 24)) {
|
||
msg += 24;
|
||
AM_LOGI("msg=%s", msg);
|
||
int input_type= 0; // common_input_ext_type_t
|
||
int port_number= 0;
|
||
sscanf(msg ,"%d %d", &input_type, &port_number);
|
||
// to do : need dual decoder
|
||
} else if (!strncmp(msg, "SNDOUT_SPDIF_OUTPUTTYPE=", 24)) {
|
||
int optic_type = 0;// sndout_optic_mode_ext_type_t
|
||
int arc_type = 0;//sndout_arc_mode_ext_type_t in alsa-ext-sndout.h
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
|
||
msg += 24;
|
||
sscanf(tmp_msg ,"%d %d", &optic_type, &arc_type);
|
||
ALOGI("[%s:%d] SNDOUT_SPDIF_OUTPUTTYPE=%s optic_type=%d arc_type=%d", __FUNCTION__, __LINE__, tmp_msg, optic_type, arc_type);
|
||
if (arc_type == 1) {//SNDOUT_ARC_PCM
|
||
snprintf(tmp_msg, 50, "digital_output_format=pcm");
|
||
} else if (arc_type >= 2 && arc_type <= 9) {//SNDOUT_ARC_AUTO-SNDOUT_ARC_HALF_AUTO_EAC3_AAC
|
||
snprintf(tmp_msg, 50, "digital_output_format=auto");
|
||
} else if (arc_type == 10) {//SNDOUT_ARC_FORCED_AC3
|
||
snprintf(tmp_msg, 50, "digital_output_format=dd");
|
||
} else if (arc_type == 11) {//SNDOUT_ARC_FORCED_EAC3
|
||
snprintf(tmp_msg, 50, "digital_output_format=ddp");
|
||
} else if (arc_type >= 12 && arc_type <= 16) {//SNDOUT_ARC_BYPASS-SNDOUT_ARC_BYPASS_EAC3_MPEG4_AAC
|
||
snprintf(tmp_msg, 50, "digital_output_format=bypass");
|
||
}
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
}/* else if (!strncmp(msg, "SNDOUT_SPDIF_COPYPROTECTIONINFO=", 32)) {
|
||
msg += 32;
|
||
AM_LOGI("msg=%s", msg);
|
||
int optic_cp = 0;
|
||
int arc_cp = 0;
|
||
|
||
sscanf(msg ,"%d %d", &optic_cp, &arc_cp);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_SPDIF_CATERGORYCODE=", 27)) {
|
||
msg += 27;
|
||
AM_LOGI("msg=%s", msg);
|
||
int optic_category = 0;
|
||
int arc_category = 0;
|
||
sscanf(msg ,"%d %d", &optic_category, &arc_category);
|
||
// to do :
|
||
}*/ else if (!strncmp(msg, "SNDOUT_OPTIC_LIGHTONOFF=", 24)) {
|
||
msg += 24;
|
||
AM_LOGI("msg=%s", msg);
|
||
int light_onoff = 0;
|
||
sscanf(msg ,"%d", &light_onoff);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_ARC_ONOFF=", 17)) {
|
||
msg += 17;
|
||
AM_LOGI("msg=%s", msg);
|
||
int arc_onoff = 0;
|
||
sscanf(msg ,"%d", &arc_onoff);
|
||
ALOGI("[%s:%d] SNDOUT_ARC_ONOFF=%s arc_onoff=%d\n", __FUNCTION__, __LINE__, msg, arc_onoff);
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
if (aml_dev == NULL) {
|
||
open_mixer_handle(&aml_dev->alsa_mixer);
|
||
}
|
||
aml_mixer_ctrl_set_int(&aml_dev->alsa_mixer, AML_MIXER_ID_ARC_EARC_TX_ENABLE, arc_onoff);
|
||
} else if (!strncmp(msg, "SNDOUT_OPTIC_LG=", 16)) {
|
||
msg += 16;
|
||
AM_LOGI("msg=%s", msg);
|
||
int barID = 0;
|
||
int volume = 0;
|
||
int bMuteOnOff = 0;
|
||
int bPowerOnOff = 0;
|
||
sscanf(msg ,"%d %d %d %d", &barID, &volume, &bMuteOnOff, &bPowerOnOff);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_SPK_OUTPUT=", 18)) {
|
||
msg += 18;
|
||
AM_LOGI("msg=%s", msg);
|
||
int spk_out_channel = 0;
|
||
sscanf(msg ,"%d", &spk_out_channel);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_CAPTURE_DISABLE=", 23)) {
|
||
msg += 23;
|
||
AM_LOGI("msg=%s", msg);
|
||
int capture_disable_onoff = 0;
|
||
sscanf(msg ,"%d", &capture_disable_onoff);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_CAPTURE_OUTPUT_RESAMPLING=", 33)) {
|
||
msg += 33;
|
||
AM_LOGI("msg=%s", msg);
|
||
int sample_rate = 0;
|
||
sscanf(msg ,"%d", &sample_rate);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_EARC_ONOFF=", 18)) {
|
||
msg += 18;
|
||
AM_LOGI("msg=%s", msg);
|
||
int earc_onoff = 0;
|
||
sscanf(msg ,"%d", &earc_onoff);
|
||
ALOGI("[%s:%d] SNDOUT_EARC_ONOFF=%s earc_onoff=%d\n", __FUNCTION__, __LINE__, msg, earc_onoff);
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
if (aml_dev == NULL) {
|
||
open_mixer_handle(&aml_dev->alsa_mixer);
|
||
}
|
||
aml_mixer_ctrl_set_int(&aml_dev->alsa_mixer, AML_MIXER_ID_EARC_TX_EARC_MODE, earc_onoff);
|
||
} else if (!strncmp(msg, "SNDOUT_EARC_OUTPUT_TYPE=", 24)) {
|
||
msg += 24;
|
||
AM_LOGI("msg=%s", msg);
|
||
int set_type = 0;
|
||
int codec_type = 0;
|
||
int channel_num = 0;
|
||
int sample_rate = 0;
|
||
int mix_option = 0;
|
||
int coding_type = 0;
|
||
sscanf(msg ,"%d %d %d %d %d", &set_type, &codec_type, &channel_num, &sample_rate, &mix_option);
|
||
ALOGI("[%s:%d] SNDOUT_EARC_OUTPUT_TYPE=%s set_type=%d codec_type=%d channel_num=%d sample_rate=%d mix_option=%d\n", __FUNCTION__, __LINE__,
|
||
msg, set_type, codec_type, channel_num, sample_rate, mix_option);
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
parse_earc_coding_type(codec_type, &coding_type);
|
||
aml_mixer_ctrl_set_int(&aml_dev->alsa_mixer, AML_MIXER_ID_EARC_TX_AUDIO_TYPE, codec_type);
|
||
} else if (!strncmp(msg, "SNDOUT_EAC3_ATMOS_ENCODE_ONOFF=", 31)) {
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
char tmp_msg[50];
|
||
int onoff = 0;
|
||
|
||
msg += 31;
|
||
sscanf(msg ,"%d", &onoff);
|
||
ALOGI("[%s:%d] SNDOUT_EAC3_ATMOS_ENCODE_ONOFF=%s onoff=%d", __FUNCTION__, __LINE__, msg, onoff);
|
||
memset(tmp_msg, 0x00, sizeof(tmp_msg));
|
||
if (onoff) {
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-atmos_lock 1");
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-legacy_ddplus_out 0");
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
} else {
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-atmos_lock 0");
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
snprintf(tmp_msg, 50, "ms12_runtime=-legacy_ddplus_out 1");
|
||
aml_dev->hw_device.set_parameters(&aml_dev->hw_device, tmp_msg);
|
||
}
|
||
} else if (!strncmp(msg, "SNDOUT_OPTIC_OUTPUT_TYPE=", 25)) {
|
||
msg += 25;
|
||
AM_LOGI("msg=%s", msg);
|
||
int set_type = 0;
|
||
int codec_type = 0;
|
||
int channel_num = 0;
|
||
int sample_rate = 0;
|
||
int mix_option = 0;
|
||
sscanf(msg ,"%d %d %d %d %d", &set_type, &codec_type, &channel_num, &sample_rate, &mix_option);
|
||
// to do :
|
||
} else if (!strncmp(msg, "SNDOUT_ARC_OUTPUT_TYPE=", 23)) {
|
||
msg += 23;
|
||
AM_LOGI("msg=%s", msg);
|
||
int set_type = 0;
|
||
int codec_type = 0;
|
||
int channel_num = 0;
|
||
int sample_rate = 0;
|
||
int mix_option = 0;
|
||
int coding_type = 0;
|
||
sscanf(msg ,"%d %d %d %d %d", &set_type, &codec_type, &channel_num, &sample_rate, &mix_option);
|
||
ALOGI("[%s:%d] SNDOUT_ARC_OUTPUT_TYPE=%s set_type=%d codec_type=%d channel_num=%d sample_rate=%d mix_option=%d\n", __FUNCTION__, __LINE__,
|
||
msg, set_type, codec_type, channel_num, sample_rate, mix_option);
|
||
parse_earc_coding_type(codec_type, &coding_type);
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
aml_mixer_ctrl_set_int(&aml_dev->alsa_mixer, AML_MIXER_ID_EARC_TX_AUDIO_TYPE, codec_type);
|
||
} else if (!strncmp(msg, "SNDOUT_CAPTURE_PATH_POINT=", 26)) {
|
||
msg += 26;
|
||
AM_LOGI("msg=%s", msg);
|
||
int capture_path = 0;
|
||
sscanf(msg ,"%d", &capture_path);
|
||
// to do :
|
||
} else if (!strncmp(msg, "AENC_INFO=", 10)) {
|
||
msg += 10;
|
||
AM_LOGI("msg=%s", msg);
|
||
int adec_idx = 0, bit_rate = 0, fmt = 0;
|
||
sscanf(msg, "%d %d %d", &adec_idx, &fmt, &bit_rate);
|
||
|
||
AM_LOGI("adec_idx = %d, enc_fmt = %d, bitrate = %d", adec_idx, fmt, bit_rate);
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
memset(&aml_dev->encoder_ctx.enc_cfg, 0, sizeof(aml_dev->encoder_ctx.enc_cfg));
|
||
aml_dev->encoder_ctx.enc_cfg.bitrate = bit_rate;
|
||
aml_dev->encoder_ctx.enc_cfg.format = (enc_encoding_format_t)fmt;
|
||
} else if (!strncmp(msg, "AENC_VOLUME=", 12)) {
|
||
msg += 12;
|
||
AM_LOGI("[%s:%d] msg=%s", __FUNCTION__, __LINE__, msg);
|
||
long val = 0;
|
||
sscanf(msg ,"%ld", &val);
|
||
float vol = (float)val/VOLUME_GAIN_0DB;
|
||
AM_LOGI("val = %ld, vol=%f", val, vol);
|
||
struct aml_audio_device *aml_dev = (struct aml_audio_device *)adev_get_handle();
|
||
aml_dev->encoder_ctx.enc_cfg.volume = vol;
|
||
aml_encoder_config(aml_dev->encoder_ctx.enc_handle, AML_ENC_CONFIG_VOLUME, &aml_dev->encoder_ctx.enc_cfg);
|
||
}
|
||
while (*msg++)
|
||
;
|
||
}
|
||
/*ALOGI("event { '%s', '%s', '%s', '%s', %d, %d }\n",
|
||
luther_gliethttp->action, luther_gliethttp->path, luther_gliethttp->subsystem,
|
||
luther_gliethttp->firmware, luther_gliethttp->major, luther_gliethttp->minor);*/
|
||
return;
|
||
}
|
||
|
||
void audio_control_init(struct aml_audio_device * adev) {
|
||
//int ret = 0;
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
|
||
memset(aml_actrl->amixer_mute, 0x00, sizeof(aml_actrl->amixer_mute));
|
||
memset(aml_actrl->amixer_gain, 0x00, sizeof(aml_actrl->amixer_gain));
|
||
for (int i = 0; i < DEVICE_NUM; i++) {
|
||
aml_actrl->amixer_gain[i].target_gain = 1;//set default gain value to 1 for socts-alsa-sndout "alsa-sndout-adv-0013: DisconnectTestAdv"
|
||
aml_actrl->amixer_gain[i].save_gain = 1;
|
||
}
|
||
for (int i = CAPTURE_START_INDEX; i < CAPTURE_END_INDEX + 1; i++)
|
||
pthread_mutex_init(&aml_actrl->capture_param[i - CAPTURE_START_INDEX].cap_handle_lock, NULL);
|
||
|
||
/*init for adec (adec's source include av/atv/dtv/hdmi)*/
|
||
memset(aml_actrl->adec_gain, 0x00, sizeof(aml_actrl->adec_gain));
|
||
memset(aml_actrl->adec_mute, 0x00, sizeof(aml_actrl->adec_mute));
|
||
memset(aml_actrl->adec_play_info, 0x00, sizeof(aml_actrl->adec_play_info));
|
||
|
||
/*init for output*/
|
||
for (int i = 0; i < OUTPUT_DEVICE_NUM; i++) {
|
||
aml_actrl->output_device_gain[i] = 100;
|
||
}
|
||
memset(aml_actrl->output_device_mute, 0x00, sizeof(aml_actrl->output_device_mute));
|
||
|
||
/*init for encoder*/
|
||
//aml_dev->enc_handle = NULL;
|
||
return;
|
||
}
|
||
|
||
void audio_control_deinit() {
|
||
aml_audio_control *aml_actrl = get_audio_control();
|
||
|
||
if (aml_actrl->aud_dev_fd > 0) {
|
||
int ret = close(aml_actrl->aud_dev_fd);
|
||
if (ret != 0) {
|
||
AM_LOGE("close fd[%d] fail, Error:%s", aml_actrl->aud_dev_fd, strerror(errno));
|
||
} else {
|
||
AM_LOGD("close fd[%d] ok", aml_actrl->aud_dev_fd);
|
||
aml_actrl->aud_dev_fd = 0;
|
||
}
|
||
}
|
||
/*deinit for mixer (alsa c0d0~c0d7 playback)*/
|
||
aml_actrl->input_mixer_thread_exit = 1;
|
||
aml_actrl->output_mixer_thread_exit = 1;
|
||
pthread_join(aml_actrl->input_mixer_threadID, NULL);
|
||
pthread_join(aml_actrl->mixer_output_threadID, NULL);
|
||
ring_buffer_release(&aml_actrl->input_mixer_ring_buffer);
|
||
|
||
/*deinit for uevent*/
|
||
aml_actrl->uevent_thread_exit = 1;
|
||
pthread_join(aml_actrl->uevent_threadID, NULL);
|
||
}
|