lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7567ddc0883a6fb596606ff9e0c818cf5300ca3b
99_7018_lmx/cpu/br28/audio_hearing/audio_hearing_aid.c

1987 lines
61 KiB
C
Raw Normal View History

first
2025-10-29 13:10:02 +08:00
/*
****************************************************************
* Audio Hearing-Aid
* File : audio_hearing_aid.c
* By :
* Notes : DHA = Digital Hearing-Aid
* Usage :
****************************************************************
*/
#include "generic/typedef.h"
#include "board_config.h"
#include "media/includes.h"
#include "audio_config.h"
#include "sound_device.h"
#include "audio_hearing_aid.h"
#include "howling_api.h"
#include "audio_codec_clock.h"
#include "application/eq_config.h"
#include "application/audio_drc.h"
#include "audio_dec_eff.h"
#include "audio_enc.h"
#include "audio_llns.h"
#include "audio_dvol.h"
#include "circular_buf.h"
#include "audio_gain_process.h"
#include "bt_tws.h"
#include "audio_noise_gate.h"
#include "amplitude_statistic.h"
#include "audio_hearing_aid_lp.h"
#include "media/audio_howling.h"
#if TCFG_AUTO_SHUT_DOWN_TIME
#include "bt_edr_fun.h"
#endif /*TCFG_AUTO_SHUT_DOWN_TIME*/
#if TCFG_AUDIO_HEARING_AID_ENABLE
extern struct audio_dac_hdl dac_hdl;
extern struct audio_adc_hdl adc_hdl;
#define HEARING_AID_TASK_NAME "HearingAid"
//*********************************************************************************//
// 数字信号处理配置(Digital Hearing_Aid[DHA] Process Config) //
//*********************************************************************************//
/*mic声音淡入使能*/
#define DHA_FADEIN_ENABLE 1
/*均衡器*/
#define DHA_EQ_ENABLE 1
/*均衡器2*/
#define DHA_EQ2_ENABLE 0
/*动态范围控制*/
#define DHA_DRC_ENABLE 1
/*[啸叫抑制-移频法]Howling Suppress - FreqShift*/
#define DHA_HS_FS_ENABLE 1
/*[啸叫抑制-陷波法]Howling Suppress - Notch*/
#define DHA_HS_NOTCH_ENABLE 1
/*噪声抑制Noise Suppress*/
#define DHA_NS_ENABLE 0
/*变采样模块：如果输入输出采样率一致，条件编译自动关闭使能*/
#define DHA_SRC_ENABLE 1
/*音量控制模块*/
#define DHA_VOLUME_ENABLE 1
/*Noise-Gate噪声门限控制*/
#define DHA_NOISE_GATE_ENABLE 0
//*********************************************************************************//
// 数据结构定义 //
//*********************************************************************************//
typedef struct {
u16 mic_ch_sel;
u16 sample_rate;
u16 adc_irq_points;
u16 adc_buf_num;
u16 dac_delay;
u16 mic_gain;
} hearing_adda_param_t;
/*Microphone采样率和采样点数配置*/
#if DHA_NS_ENABLE
#define HEARING_AID_CLK (160 * 1000000L)
#define DHA_MIC_SAMPLE_RATE TCFG_AUDIO_DHA_MIC_SAMPLE_RATE
#define DHA_MIC_SAMPLE_POINT (DHA_MIC_SAMPLE_RATE / 200)
#else
#define HEARING_AID_CLK (160 * 1000000L)
#define DHA_MIC_SAMPLE_RATE TCFG_AUDIO_DHA_MIC_SAMPLE_RATE
#define DHA_MIC_SAMPLE_POINT 64
#endif/*DHA_NS_ENABLE*/
#if (DHA_MIC_SAMPLE_RATE == TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE)
/*输入输出采样率一致，条件编译自动关闭SRC使能*/
#undef DHA_SRC_ENABLE
#define DHA_SRC_ENABLE 0
#endif/*DHA_MIC_SAMPLE_RATE*/
static const hearing_adda_param_t hearing_adda_param = {
.mic_ch_sel = TCFG_AD2DA_LOW_LATENCY_MIC_CHANNEL,
.mic_gain = 12,
.sample_rate = DHA_MIC_SAMPLE_RATE,//采样率
.adc_irq_points = DHA_MIC_SAMPLE_POINT,//一次处理数据的数据单元， 单位点 4对齐(要配合mic起中断点数修改)
.adc_buf_num = 3,
#if (TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE == 44100)
.dac_delay = (DHA_MIC_SAMPLE_POINT *TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE / DHA_MIC_SAMPLE_RATE) /
(TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE / 1000) + 5,//dac硬件混响延时， 单位ms 要大于 point_unit*2
#else
.dac_delay = (DHA_MIC_SAMPLE_POINT *TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE / DHA_MIC_SAMPLE_RATE) /
(TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE / 1000) + 3,//dac硬件混响延时， 单位ms 要大于 point_unit*2
#endif
};
//*********************************************************************************//
// mic能量检测处理配置 //
//*********************************************************************************//
typedef struct {
struct audio_dac_channel dac_ch;
struct adc_mic_ch mic_ch;
struct audio_adc_output_hdl adc_output;
s16 *adc_dma_buf;
OS_SEM sem;
#if DHA_MIC_DATA_CBUF_ENABLE
s16 *run_buf;
u8 *data_buf;
cbuffer_t mic_cbuf;
#else
s16 *mic_data_addr;
s32 mic_data_len;
#endif /*DHA_MIC_DATA_CBUF_ENABLE*/
u8 task_release;
u8 task_exit;
volatile u8 task_busy;
u16 fade_in_gain;
#if DHA_HS_FS_ENABLE
HOWLING_API_STRUCT *hs_fs;
HOWLING_API_STRUCT *hs_fs_1;
#endif /*DHA_HS_FS_ENABLE*/
#if DHA_HS_NOTCH_ENABLE
HOWLING_API_STRUCT *hs_notch;
HOWLING_API_STRUCT *hs_notch_1;
#endif /*DHA_HS_NOTCH_ENABLE*/
#if (DHA_EQ_ENABLE || DHA_DRC_ENABLE)
struct dec_eq_drc *hearing_eq_drc;
#endif /*(DHA_EQ_ENABLE || DHA_DRC_ENABLE)*/
#if (DHA_EQ2_ENABLE)
struct audio_eq *hearing_eq2;
#endif /*(DHA_EQ2_ENABLE)*/
#if DHA_NS_ENABLE
void *llns;
void *llns_1;
#endif /*DHA_NS_ENABLE*/
#if DHA_SRC_ENABLE
#if DHA_SRC_USE_HW_ENABLE
struct audio_src_handle *hw_src;
#else
s16 src_out_data[480];
#endif/*DHA_SRC_USE_HW_ENABLE*/
#endif /*DHA_SRC_ENABLE*/
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
s16 mono_to_dual[(DHA_MIC_SAMPLE_POINT * TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE / DHA_MIC_SAMPLE_RATE) * 2 + 8];
#endif/*TCFG_AUDIO_DAC_CONNECT_MODE*/
/*双声道处理双变单，单变双使用*/
s16 *tmp_buf;
s16 *tmp_buf_1;
u8 channel;
} hearing_aid_t;
static hearing_aid_t *hearing_hdl = NULL;
static u32 start_ts = 0;
static u32 end_ts = 0;
enum {
DHA_STATE_CLOSE,
DHA_STATE_OPEN,
DHA_STATE_SUSPEND,
};
typedef struct {
volatile u8 state; /*辅听状态*/
volatile u8 fitting_state; /*验配状态*/
u8 fitting; /*听力验配模式标识*/
u8 volume;
u16 timer;
} hearing_aid_schedule_t;
hearing_aid_schedule_t dha_schedule = {0};
/*保留EQ段，做自定义滤波使用*/
#define DHA_REV0_FREQ 100
#define DHA_REV1_FREQ 16000
#define MIC_EQ_SECTION 8
static struct eq_seg_info audio_mic_eq_tab[MIC_EQ_SECTION] = {
{0, EQ_IIR_TYPE_BAND_PASS, DHA_CH0_FREQ, 0, 1.0f},
{1, EQ_IIR_TYPE_BAND_PASS, DHA_CH1_FREQ, 0, 1.0f},
{2, EQ_IIR_TYPE_BAND_PASS, DHA_CH2_FREQ, 0, 1.4f},
{3, EQ_IIR_TYPE_BAND_PASS, DHA_CH3_FREQ, 0, 1.4f},
{4, EQ_IIR_TYPE_BAND_PASS, DHA_CH4_FREQ, 0, 1.4f},
{5, EQ_IIR_TYPE_BAND_PASS, DHA_CH5_FREQ, 0, 2.0f},
{6, EQ_IIR_TYPE_HIGH_PASS, DHA_REV0_FREQ, 0, 1.0f},
{7, EQ_IIR_TYPE_LOW_PASS, DHA_REV1_FREQ, 0, 0.7f},
};
/*听力验配频点列表*/
static u16 sine_freq[] = {
DHA_CH0_FREQ,
DHA_CH1_FREQ,
DHA_CH2_FREQ,
DHA_CH3_FREQ,
DHA_CH4_FREQ,
DHA_CH5_FREQ
};
static u8 sine_idx = 2;
static u16 dac_digital_vol = 0;
int audio_dac_set_digital_vol(struct audio_dac_hdl *dac, u16 vol);
u16 audio_dac_get_digital_vol(void)
{
u16 vol = 0;
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_L)
vol = JL_AUDIO->DAC_VL0 & 0x0000ffff;
#else
vol = (JL_AUDIO->DAC_VL0 >> 16) & 0x0000ffff;
#endif
return vol;
}
extern void put_float(double fv);
/*
*********************************************************************
* Audio Hearing-aid Fitting
* Description: Hearing Level Fitting
* Arguments : NULL
* Return : NULL
* Note(s) : 听力验配
*********************************************************************
*/
dha_fitting_adjust_t dha_fitting_result[DHA_FITTING_CHANNEL_MAX];
int fitting_param_write(u8 LR, void *buf);
extern u32 hearing_aid_rcsp_response(u8 *data, u16 data_len);
extern u32 hearing_aid_rcsp_notify(u8 *data, u16 data_len);
static int hearing_aid_eq_filter_updata(float *EQGain);
int hearing_aid_fitting_parse(u8 *data, u16 len)
{
u8 tmp[4];
u8 cmd = data[0];
u16 data_len = (data[2] << 8) | data[1];
printf("cmd %x, data_len %d\n", cmd, data_len);
switch (cmd) {
case DHA_FITTING_CMD_INFO:
break;
case DHA_FITTING_CMD_ADJUST:
printf("DHA_FITTING_CMD_ADJUST\n");
dha_fitting_adjust_t adjust;
if (data_len > sizeof(dha_fitting_adjust_t)) {
/*数据长度错误*/
printf("data_len err !!!");
return 0;
}
memcpy(&adjust, &data[3], data_len);
hearing_aid_fitting_start(adjust.sine);
if (adjust.sine) {//开始验配，需要波单频音
audio_dac_set_digital_vol(&dac_hdl, (u16)(16384 * adjust.gain / 100));
printf("dval : %d\n", (u16)(16384 * adjust.gain / 100));
#if TCFG_USER_TWS_ENABLE
enum audio_channel channel = tws_api_get_local_channel() == 'R' ? AUDIO_CH_R : AUDIO_CH_L;
if ((channel == AUDIO_CH_L) && (adjust.channel == 0)) { //当前是左耳,并且数据是设置左耳时
for (int i = 0; i < DHA_FITTING_CHANNEL_MAX; i++) {
if (audio_mic_eq_tab[i].freq == adjust.freq) {
/* audio_mic_eq_tab[i].gain = adjust.gain; */
sine_idx = i;
printf("L idx %d, freq %d, gain %d\n", sine_idx, audio_mic_eq_tab[i].freq, (int)adjust.gain);
break;
}
}
} else if ((channel == AUDIO_CH_R) && (adjust.channel == 1)) { //当前是右耳，并且数据是设置右耳时
for (int i = 0; i < DHA_FITTING_CHANNEL_MAX; i++) {
if (audio_mic_eq_tab[i].freq == adjust.freq) {
/* audio_mic_eq_tab[i].gain = adjust.gain; */
sine_idx = i;
printf("R idx %d, freq %d, gain %d\n", sine_idx, audio_mic_eq_tab[i].freq, (int)adjust.gain);
break;
}
}
}
#else
//没有TWS时,不判断左右耳直接设置单频音
for (int i = 0; i < DHA_FITTING_CHANNEL_MAX; i++) {
if (audio_mic_eq_tab[i].freq == adjust.freq) {
/* audio_mic_eq_tab[i].gain = adjust.gain; */
sine_idx = i;
printf("L idx %d, freq %d, gain %d\n", sine_idx, audio_mic_eq_tab[i].freq, (int)adjust.gain);
break;
}
}
#endif /*TCFG_USER_TWS_ENABLE*/
}
/*回复辅听状态信息*/
get_hearing_aid_state_cmd_info(tmp);
hearing_aid_rcsp_response(tmp, 4);
break;
case DHA_FITTING_CMD_UPDATE:
printf("DHA_FITTING_CMD_UPDATE\n");
float EQGain[12];
if (data_len > sizeof(EQGain)) {
/*数据长度错误*/
printf("data_len err !!!");
return 0;
}
/*回复辅听状态信息*/
get_hearing_aid_state_cmd_info(tmp);
hearing_aid_rcsp_response(tmp, 4);
/*退出验配状态*/
dha_schedule.fitting = 0;
dha_schedule.fitting_state = 0;
u8 LR = data[3]; //左右耳数据标志
memcpy(EQGain, &data[4], data_len);
/*更新验配数据到辅听*/
hearing_aid_eq_filter_updata(EQGain);
/*保存验配数据到vm*/
fitting_param_write(LR, EQGain);
for (int i = 0; i < data_len / 4; i++) {
put_float(EQGain[i]);
}
/*恢复允许播歌*/
if (get_hearing_aid_fitting_state() == 0) {
extern void a2dp_tws_dec_resume(void);
a2dp_tws_dec_resume();
}
break;
}
return 0;
}
/*获取辅听左右耳状态信息*/
int get_hearing_aid_state_cmd_info(u8 *data)
{
dha_fitting_state_t dha_fitting_state;
#if TCFG_USER_TWS_ENABLE
if (get_bt_tws_connect_status()) { //对耳已经配对
dha_fitting_state.state_left = dha_schedule.state == DHA_STATE_OPEN ? 1 : 0;
dha_fitting_state.state_right = dha_schedule.state == DHA_STATE_OPEN ? 1 : 0;
} else { /*tws 单只耳时*/
enum audio_channel channel = tws_api_get_local_channel() == 'R' ? AUDIO_CH_R : AUDIO_CH_L;
if (channel == AUDIO_CH_L) { //当前是左耳
dha_fitting_state.state_left = dha_schedule.state == DHA_STATE_OPEN ? 1 : 0;
dha_fitting_state.state_right = 0;
} else if (channel == AUDIO_CH_R) { //当前是右耳
dha_fitting_state.state_left = 0;
dha_fitting_state.state_right = dha_schedule.state == DHA_STATE_OPEN ? 1 : 0;
}
}
#else /*没有开tws单只耳当作左耳*/
dha_fitting_state.state_left = dha_schedule.state == DHA_STATE_OPEN ? 1 : 0;
dha_fitting_state.state_right = 0;
#endif /*TCFG_USER_TWS_ENABLE*/
data[0] = DHA_FITTING_CMD_STATE;
data[1] = sizeof(dha_fitting_state);
data[2] = 0;
data[3] = ((u8 *)&dha_fitting_state)[0];
put_buf(data, 4);
return 0;
}
/*获取辅听验配状态*/
u8 get_hearing_aid_fitting_state(void)
{
return dha_schedule.fitting || dha_schedule.fitting_state ? 1 : 0;
}
/*获取验配信息*/
int get_hearing_aid_fitting_info(u8 *data)
{
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
if (data && hearing_hdl) {
dha_fitting_info_t dha_info = {
.version = DHA_FITTING_VERSION,
.ch_num = DHA_FITTING_CHANNEL_MAX,
.ch_freq[0] = DHA_CH0_FREQ,
.ch_freq[1] = DHA_CH1_FREQ,
.ch_freq[2] = DHA_CH2_FREQ,
.ch_freq[3] = DHA_CH3_FREQ,
.ch_freq[4] = DHA_CH4_FREQ,
.ch_freq[5] = DHA_CH5_FREQ,
};
memcpy(data, &dha_info, sizeof(dha_info));
return sizeof(dha_info);
} else {
return 0;
}
}
/*判断是否播放单频音
* en:
* BIT(0) = 1 左耳播单频音，BIT(0) = 0 左耳静音
* BIT(1) = 1 右耳播单频音，BIT(1) = 0 右耳静音
* */
int hearing_aid_fitting_start(u8 en)
{
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
printf("fitting en: %d", en);
if (hdl) {
#if TCFG_USER_TWS_ENABLE
if (en) { //需要播单频音
enum audio_channel channel = tws_api_get_local_channel() == 'R' ? AUDIO_CH_R : AUDIO_CH_L;
if (channel == AUDIO_CH_L) { //当前是左耳
//判断是否设置左耳
if (en & BIT(0)) { //设置左耳时左耳播放单频音
dha_schedule.fitting = 1;
} else { //设置右耳时左耳静音
dha_schedule.fitting = 2;
}
} else if (channel == AUDIO_CH_R) { //当前是右耳
//判断是否设置右耳
if (en & BIT(1)) { //设置右耳时右耳播放单频音
dha_schedule.fitting = 1;
} else { //设置左耳时右耳静音
dha_schedule.fitting = 2;
}
}
} else { //关闭单频音
dha_schedule.fitting = en;
}
#else
//没有TWS时
dha_schedule.fitting = en ? 1 : 0;
#endif /*TCFG_USER_TWS_ENABLE*/
if (dha_schedule.fitting == 0) {
audio_dac_set_digital_vol(&dac_hdl, dac_digital_vol);
}
dha_schedule.fitting_state = dha_schedule.fitting;
printf("dha_schedule.fitting : %d", dha_schedule.fitting);
return dha_schedule.fitting;
}
return -1;
}
u8 set_hearing_aid_fitting_state(u8 state)
{
dha_schedule.fitting_state = state;
return dha_schedule.fitting_state;
}
/*同步关闭辅听验配*/
void audio_dha_fitting_sync_close(void)
{
#if TCFG_USER_TWS_ENABLE
if (get_tws_sibling_connect_state()) {
if (tws_api_get_role() == TWS_ROLE_MASTER) {
printf("[tws_master]fitting close");
bt_tws_play_tone_at_same_time(SYNC_TONE_DHA_FITTING_CLOSE, 400);
}
} else {
hearing_aid_fitting_start(0);
}
#else
hearing_aid_fitting_start(0);
#endif/*TCFG_USER_TWS_ENABLE*/
set_hearing_aid_fitting_state(0);
}
/*
* 保存验配参数
* LR: 0 保存左耳，1 保存右耳，2 保存对耳
* buf:需要保存的参数
*/
int fitting_param_write(u8 LR, void *buf)
{
float EQGain[DHA_FITTING_CHANNEL_MAX * 2];
int ret = 0;
ret = syscfg_read(CFG_DHA_FITTING_ID, EQGain, DHA_FITTING_CHANNEL_MAX * 2 * 4);
if (ret != DHA_FITTING_CHANNEL_MAX * 2 * 4) {
printf("vm fitting param empty\n");
}
if (LR == 0) { /*写左耳数据*/
memcpy(EQGain, (u8 *)buf, DHA_FITTING_CHANNEL_MAX * 4);
} else if (LR == 1) { /*写右耳数据*/
memcpy(EQGain + DHA_FITTING_CHANNEL_MAX, (u8 *)buf, DHA_FITTING_CHANNEL_MAX * 4);
} else if (LR == 2) { /*写对耳数据*/
memcpy(EQGain, (u8 *)buf, DHA_FITTING_CHANNEL_MAX * 2 * 4);
}
syscfg_write(CFG_DHA_FITTING_ID, EQGain, sizeof(EQGain));
return 0;
}
/*读取当前耳机(左耳/右耳)验配参数*/
int fitting_param_read(void *buf)
{
float EQGain[DHA_FITTING_CHANNEL_MAX * 2];
int ret = 0;
ret = syscfg_read(CFG_DHA_FITTING_ID, EQGain, DHA_FITTING_CHANNEL_MAX * 2 * 4);
if (ret != DHA_FITTING_CHANNEL_MAX * 2 * 4) {
printf("vm fitting param read err\n");
return 0;
}
/*判断是否清除过数据,全是0xFF表示是清除过数据*/
u8 *data = (u8 *)EQGain;
u8 cnt = 0;
for (u8 i = 0; i < 4; i++) {
if (data[i] == 0xFF) {
cnt++;
}
}
if (cnt >= 4) {
return 0;
}
#if TCFG_USER_TWS_ENABLE
if (get_bt_tws_connect_status()) { //对耳已经配对
enum audio_channel channel = tws_api_get_local_channel() == 'R' ? AUDIO_CH_R : AUDIO_CH_L;
if (channel == AUDIO_CH_L) { //当前是左耳,使用第一组数据
memcpy((u8 *)buf, EQGain, DHA_FITTING_CHANNEL_MAX * 4);
} else if (channel == AUDIO_CH_R) { //当前是右耳,使用第二组数据
memcpy((u8 *)buf, EQGain + DHA_FITTING_CHANNEL_MAX, DHA_FITTING_CHANNEL_MAX * 4);
}
} else
#endif /*TCFG_USER_TWS_ENABLE*/
{
//没有配对时，使用第一组数据
memcpy((u8 *)buf, EQGain, DHA_FITTING_CHANNEL_MAX * 4);
}
return ret >> 1;
}
/*清除验配参数
* LR: 0 清除左耳，1 清除右耳，2 清除对耳
*/
int clear_fitting_patam(u8 LR)
{
float EQGain[DHA_FITTING_CHANNEL_MAX * 2];
int ret = 0;
ret = syscfg_read(CFG_DHA_FITTING_ID, EQGain, DHA_FITTING_CHANNEL_MAX * 2 * 4);
if (ret != DHA_FITTING_CHANNEL_MAX * 2 * 4) {
printf("vm fitting param empty\n");
}
if (LR == 0) { /*清楚左耳参数*/
memset(EQGain, 0xFF, DHA_FITTING_CHANNEL_MAX * 4);
} else if (LR == 1) { /*清楚右耳参数*/
memset(EQGain + DHA_FITTING_CHANNEL_MAX, 0xFF, DHA_FITTING_CHANNEL_MAX * 4);
} else if (LR == 2) { /*清楚对耳参数*/
memset(EQGain, 0xFF, DHA_FITTING_CHANNEL_MAX * 2 * 4);
}
syscfg_write(CFG_DHA_FITTING_ID, EQGain, sizeof(EQGain));
return 0;
}
#if DHA_SRC_ENABLE
#include "Resample_api.h"
static RS_STUCT_API *sw_src_api = NULL;
static u8 *sw_src_buf = NULL;
int hearing_output(hearing_aid_t *hdl, s16 *data, u16 len);
static int hearing_aid_hw_src_output_handler(void *priv, s16 *data, int len);
static int hearing_src_init(hearing_aid_t *hdl, u8 nch, u16 insample, u16 outsample)
{
printf("hearing_src_init,insr:%d,outsr:%d\n", insample, outsample);
#if DHA_SRC_USE_HW_ENABLE
if (insample != TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE) {
printf("hw src in %d, out %d\n", insample, TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE);
hdl->hw_src = zalloc(sizeof(struct audio_src_handle));
if (hdl->hw_src) {
u8 channel = nch;
audio_hw_src_open(hdl->hw_src, channel, AUDIO_RESAMPLE_SYNC_OUTPUT);
audio_hw_src_set_rate(hdl->hw_src, insample, TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE);
audio_src_set_output_handler(hdl->hw_src, hdl, (void (*)(void *, void *, int))hearing_output);
printf("audio hw src open succ %x", hdl->hw_src);
} else {
printf("hdl->hw_src malloc fail !!!\n");
}
}
#else
if (insample != outsample) {
sw_src_api = get_rs16_context();
/* sw_src_api = get_rsfast_context(); */
printf("sw_src_api:0x%x\n", sw_src_api);
ASSERT(sw_src_api);
u32 sw_src_need_buf = sw_src_api->need_buf();
printf("sw_src_buf:%d\n", sw_src_need_buf);
sw_src_buf = zalloc(sw_src_need_buf);
ASSERT(sw_src_buf);
RS_PARA_STRUCT rs_para_obj;
rs_para_obj.nch = nch;
rs_para_obj.new_insample = insample;
rs_para_obj.new_outsample = outsample;
printf("sw src,in = %d,out = %d\n", rs_para_obj.new_insample, rs_para_obj.new_outsample);
sw_src_api->open(sw_src_buf, &rs_para_obj);
}
return 0;
#endif/*DHA_SRC_USE_HW_ENABLE*/
}
static int hearing_src_run(hearing_aid_t *hdl, s16 *indata, s16 *outdata, u16 len)
{
#if DHA_SRC_USE_HW_ENABLE
if (hdl->hw_src) {
return audio_src_resample_write(hdl->hw_src, indata, len);
}
#else
int outlen = len;
if (sw_src_api && sw_src_buf) {
outlen = sw_src_api->run(sw_src_buf, indata, len >> 1, outdata);
/* ASSERT(outlen <= (sizeof(outdata) >> 1)); */
outlen = outlen << 1;
/* printf("%d\n",outlen); */
} else {
memcpy(outdata, indata, len);
}
return outlen;
#endif/*DHA_SRC_USE_HW_ENABLE*/
}
static void hearing_src_exit(hearing_aid_t *hdl)
{
#if DHA_SRC_USE_HW_ENABLE
printf("[HW]hearing_src_exit\n");
if (hdl->hw_src) {
audio_hw_src_stop(hdl->hw_src);
audio_hw_src_close(hdl->hw_src);
free(hdl->hw_src);
hdl->hw_src = NULL;
}
#else
printf("[SW]hearing_src_exit\n");
if (sw_src_buf) {
free(sw_src_buf);
sw_src_buf = NULL;
sw_src_api = NULL;
}
#endif/*DHA_SRC_USE_HW_ENABLE*/
}
#endif /*DHA_SRC_ENABLE*/
#if DHA_SRC_ENABLE
static void hearing_volume_run(s16 *data, int len);
static int hearing_aid_hw_src_output_handler(void *priv, s16 *data, int len)
{
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
if (!hdl) {
return 0;
}
s16 *mic_data = data;
int data_len = len;
int wlen = 0;
#if DHA_VOLUME_ENABLE
hearing_volume_run(mic_data, data_len);
#endif/*DHA_VOLUME_ENABLE*/
#if DHA_RUN_TIME_TRACE_ENABLE
end_ts = jiffies_msec();
printf("run_time:%d - %d = %d\n", end_ts, start_ts, (end_ts - start_ts));
#endif/*DHA_RUN_TIME_TRACE_ENABLE*/
DHA_IO_DEBUG_0();
// 写入DAC
wlen = sound_pcm_dev_write(&hdl->dac_ch, data, len);
hdl->task_busy = 0;
return len;
}
#endif /*DHA_SRC_ENABLE*/
#if DHA_NS_ENABLE
/*
* 低延时降噪只支持16k 和32k
* 16k采样率时,一帧处理80个点的数据(5ms)
* 32k采样率时 一帧处理160个点的数据(5ms)
*/
static const u16 llns_frame_size[2][2] = {
{16000, 160},//80点
{32000, 320},//160点
/* {44100, 440},//220点 */
/* {48000, 480},//240点 */
};
typedef struct {
char *private_buf;
char *share_buf;
s16 inbuf[160];
s16 in_pool[320];
cbuffer_t in_cbuf;
int frame_size;
void *llns;
} llns_hdl_t;
/* static llns_hdl_t *llns_hdl = NULL; */
static int llns_exit(void *hdl);
static void *llns_init(int sr, float gainfloor, float suppress_level)
{
llns_hdl_t *llns_hdl = zalloc(sizeof(llns_hdl_t));
if (llns_hdl == NULL) {
printf("llns_hdl zalloc err !!!!\n");
return -1;
}
cbuf_init(&llns_hdl->in_cbuf, llns_hdl->in_pool, sizeof(llns_hdl->in_pool));
printf("%s %d", __func__, __LINE__);
int private_heap_size, share_heap_size;
audio_llns_heap_query(&share_heap_size, &private_heap_size, sr);
printf("private_heap_size:%d,share_heap_size:%d\n", private_heap_size, share_heap_size);
llns_hdl->private_buf = (char *)zalloc(private_heap_size);
llns_hdl->share_buf = (char *)zalloc(share_heap_size);
/*判断是否支持的采样率*/
llns_hdl->frame_size = 0;
for (int i = 0; i < ARRAY_SIZE(llns_frame_size); i++) {
//printf("llns_frame_size[%d] = %d",i,llns_frame_size[i][0]);
if (llns_frame_size[i][0] == sr) {
//printf("llns sr math:%d\n",sr);
llns_hdl->frame_size = llns_frame_size[i][1];
}
}
if (llns_hdl->frame_size == 0) {
printf("samplerate only support 16k or 32k !!!\n");
return -1;
}
printf("sr: %d, gainfloor: %d/100\n", sr, (int)(gainfloor * 100));
llns_hdl->llns = audio_llns_init(llns_hdl->private_buf, private_heap_size, llns_hdl->share_buf, share_heap_size, sr, gainfloor, suppress_level);
ASSERT(llns_hdl->llns);
printf("llns init ok\n");
return llns_hdl;
}
static int llns_run(void *hdl, s16 *data, int len)
{
llns_hdl_t *llns_hdl = (llns_hdl_t *)hdl;
int llns_outsize = 0, llns_outsize1 = 0;
if (llns_hdl) {
if (len != llns_hdl->frame_size) {
putchar('B');
}
cbuf_write(&llns_hdl->in_cbuf, data, len);
if (cbuf_read(&llns_hdl->in_cbuf, llns_hdl->inbuf, llns_hdl->frame_size) == llns_hdl->frame_size) {
llns_outsize = audio_llns_run(llns_hdl->llns, llns_hdl->inbuf, llns_hdl->frame_size, data);
//llns_outsize = len >> 1;
}
}
return llns_outsize << 1;
}
static int llns_exit(void *hdl)
{
llns_hdl_t *llns_hdl = (llns_hdl_t *)hdl;
if (llns_hdl) {
audio_llns_close(llns_hdl->llns);
llns_hdl->llns = NULL;
if (llns_hdl->private_buf) {
free(llns_hdl->private_buf);
llns_hdl->private_buf = NULL;
}
if (llns_hdl->share_buf) {
free(llns_hdl->share_buf);
llns_hdl->share_buf = NULL;
}
free(llns_hdl);
llns_hdl = NULL;
}
return 0;
}
#endif /*DHA_NS_ENABLE*/
#if (DHA_EQ_ENABLE || DHA_DRC_ENABLE)
static int hearing_aid_eq_get_filter_info(void *eq, int sr, struct audio_eq_filter_info *info)
{
struct audio_eq *eq_hdl = (struct audio_eq *)eq;
if (!eq_hdl) {
return -1;
}
local_irq_disable();
u8 nsection = ARRAY_SIZE(audio_mic_eq_tab);
if (!eq_hdl->eq_coeff_tab) {
eq_hdl->eq_coeff_tab = zalloc(sizeof(int) * 5 * nsection);
}
for (int i = 0; i < nsection; i++) {
eq_seg_design(&audio_mic_eq_tab[i], sr, &eq_hdl->eq_coeff_tab[5 * i]);
}
local_irq_enable();
info->L_coeff = info->R_coeff = (void *)eq_hdl->eq_coeff_tab;
info->L_gain = info->R_gain = 0;
info->nsection = nsection;
return 0;
}
/*限幅器drc*/
static float Gain_dB = 1;
static struct drc_ch mic_drc_p = {0};
static int hearing_aid_drc_get_filter_info(void *drc, struct audio_drc_filter_info *info)
{
float th = -10.0f;//单位:dB 范围:-60dB~0dB,限幅器阈值
Gain_dB = 7.0f; /*drc压制后要放大的dB数*/
Gain_dB = powf(10.0f, Gain_dB / 20.0f);
int threshold = roundf(powf(10.0f, th / 20.0f) * 32768);
mic_drc_p.nband = 1;
mic_drc_p.type = 1; //1:限幅器
mic_drc_p._p.limiter[0].attacktime = 5;
mic_drc_p._p.limiter[0].releasetime = 500;
mic_drc_p._p.limiter[0].threshold[0] = threshold;
mic_drc_p._p.limiter[0].threshold[1] = 32768;
info->R_pch = info->pch = &mic_drc_p;
return 0;
}
#define FITTING_EQ_THR 30
static int hearing_aid_eq_filter_updata(float *EQGain)
{
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
if (hdl == NULL) {
return -1;
}
float max = 100 - FITTING_EQ_THR;
for (int i = 0; i < DHA_FITTING_CHANNEL_MAX; i++) {
if (EQGain[i] > FITTING_EQ_THR) {
audio_mic_eq_tab[i].gain = (EQGain[i] - FITTING_EQ_THR) * 12.0f / max;
} else {
audio_mic_eq_tab[i].gain = 0;
}
put_float(audio_mic_eq_tab[i].gain);
}
struct dec_eq_drc *eq_drc = hdl->hearing_eq_drc;
struct audio_eq *eq = eq_drc->eq;
if (eq_drc == NULL || eq == NULL) {
return -1;
}
eq->updata = 1;
return 0;
}
void *hearing_eq_drc_open(u32 sample_rate, u8 ch_num)
{
#if TCFG_EQ_ENABLE
struct dec_eq_drc *eff = zalloc(sizeof(struct dec_eq_drc));
/* struct audio_eq_drc *eff = zalloc(sizeof(struct audio_eq_drc)); */
struct audio_eq_param eq_param = {0};
/* eff->priv = priv; */
/* eff->out_cb = eq_output_cb; */
eq_param.channels = ch_num;
eq_param.online_en = 1;
eq_param.mode_en = 0;
eq_param.remain_en = 0;
eq_param.no_wait = 0;
eq_param.out_32bit = 0;
#if TCFG_AUDIO_DHA_FITTING_ENABLE
eq_param.max_nsection = MIC_EQ_SECTION;
eq_param.cb = hearing_aid_eq_get_filter_info;
#else
eq_param.max_nsection = EQ_SECTION_MAX;
eq_param.cb = eq_get_filter_info;
#endif /*TCFG_AUDIO_DHA_FITTING_ENABLE*/
eq_param.eq_name = hearing_aid_mode;
eq_param.sr = sample_rate;
/* eq_param.priv = eff; */
/* eq_param.output = eq_output; */
eff->eq = audio_dec_eq_open(&eq_param);
#if (TCFG_DRC_ENABLE && DHA_DRC_ENABLE)
struct audio_drc_param drc_param = {0};
drc_param.sr = sample_rate;
drc_param.channels = ch_num;
drc_param.online_en = 1;
drc_param.remain_en = 0;
drc_param.out_32bit = 0;
#if DHA_USE_WDRC_ENABLE
drc_param.cb = drc_get_filter_info;
#else
drc_param.cb = hearing_aid_drc_get_filter_info;
#endif /*DHA_USE_WDRC_ENABLE*/
drc_param.drc_name = hearing_aid_mode;
eff->drc = audio_dec_drc_open(&drc_param);
eff->async = 0;
#endif //TCFG_DRC_ENABLE
return eff;
#else
return NULL;
#endif//TCFG_EQ_ENABLE
}
void hearing_eq_drc_run(struct dec_eq_drc *eq_drc, void *data, u32 len)
{
struct dec_eq_drc *eff_hdl = (struct dec_eq_drc *)eq_drc;
#if DHA_EQ_ENABLE
if (eff_hdl->eq) {
audio_eq_run(eff_hdl->eq, data, len);
}
#endif/*DHA_EQ_ENABLE*/
#if DHA_DRC_ENABLE
if (eff_hdl->drc) {
audio_drc_run(eff_hdl->drc, data, len);
#if (DHA_USE_WDRC_ENABLE == 0)
GainProcess_16Bit(data, data, Gain_dB, 1, 1, 1, len >> 1);
#endif /*DHA_USE_WDRC_ENABLE == 0*/
}
#endif/*DHA_DRC_ENABLE*/
}
void hearing_eq_drc_close(struct dec_eq_drc *eq_drc)
{
#if TCFG_EQ_ENABLE
struct dec_eq_drc *eff_hdl = (struct dec_eq_drc *)eq_drc;
/* struct audio_eq_drc *eff_hdl = (struct audio_eq_drc *)eq_drc; */
if (eff_hdl->eq) {
audio_dec_eq_close(eff_hdl->eq);
eff_hdl->eq = NULL;
}
if (eff_hdl->drc) {
audio_dec_drc_close(eff_hdl->drc);
eff_hdl->drc = NULL;
}
free(eff_hdl);
#endif
return;
}
#endif /*(DHA_EQ_ENABLE || DHA_DRC_ENABLE)*/
#if (TCFG_EQ_ENABLE && DHA_EQ2_ENABLE)
void *hearing_eq2_open(u32 sample_rate, u8 ch_num)
{
struct audio_eq *eq;
struct audio_eq_param eq_param = {0};
/* eff->priv = priv; */
/* eff->out_cb = eq_output_cb; */
eq_param.channels = ch_num;
eq_param.online_en = 1;
eq_param.mode_en = 0;
eq_param.remain_en = 0;
eq_param.no_wait = 0;
eq_param.out_32bit = 0;
eq_param.max_nsection = EQ_SECTION_MAX;
eq_param.cb = eq_get_filter_info;
eq_param.eq_name = hearing_aid_mode2;
eq_param.sr = sample_rate;
/* eq_param.priv = eff; */
/* eq_param.output = eq_output; */
eq = audio_dec_eq_open(&eq_param);
return eq;
}
void hearing_eq2_run(struct audio_eq *eq, void *data, u32 len)
{
if (eq) {
audio_eq_run(eq, data, len);
}
}
void hearing_eq2_close(struct audio_eq *eq)
{
if (eq) {
audio_dec_eq_close(eq);
eq = NULL;
}
}
#endif /*TCFG_EQ_ENABLE && DHA_EQ2_ENABLE*/
/*
*********************************************************************
* Audio Hearing-aid Fade In
* Description:
* Arguments : data
* points
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
#define HEARING_AID_FADEIN_SHIFT (14)
#define HEARING_AID_FADEIN_GAIN_MAX (1 << HEARING_AID_FADEIN_SHIFT)
static void hearing_fade_in_run(s16 *data, u16 points)
{
if (hearing_hdl->fade_in_gain < HEARING_AID_FADEIN_GAIN_MAX) {
s32 tmp_data;
for (int i = 0; i < points; i++) {
tmp_data = data[i];
data[i] = (tmp_data * hearing_hdl->fade_in_gain) >> HEARING_AID_FADEIN_SHIFT;
if (++hearing_hdl->fade_in_gain >= HEARING_AID_FADEIN_GAIN_MAX) {
return;
}
}
}
}
#if DHA_VOLUME_ENABLE
/*
*********************************************************************
* Audio Hearing-aid Volume
* Description:
* Arguments : data
* points
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
/*数字音量*/
static void hearing_volume_run(s16 *data, int len)
{
#if 0
static u16 vol_dbg = 0;
if (vol_dbg++ > 500) {
vol_dbg = 0;
printf("[DHA]Volume:%d\n", audio_digital_vol_get(HEARING_DVOL));
}
#endif
audio_digital_vol_run(HEARING_DVOL, data, len);
}
/*设置音量*/
static void hearing_volume_set(u8 volume)
{
dha_schedule.volume = volume;
audio_digital_vol_set(HEARING_DVOL, volume);
}
/*获取当前音量大小*/
static int hearing_volume_get(void)
{
return audio_digital_vol_get(HEARING_DVOL);
}
/*打开数字音量*/
static void hearing_volume_open(u8 volume)
{
dha_schedule.volume = (volume > HEARING_DVOL_MAX) ? HEARING_DVOL_MAX : volume;
audio_digital_vol_open(HEARING_DVOL, dha_schedule.volume, HEARING_DVOL_MAX, HEARING_DVOL_FS, -1);
}
/*关闭数字音量*/
static void hearing_volume_close(void)
{
audio_digital_vol_close(HEARING_DVOL);
}
#endif /*DHA_VOLUME_ENABLE*/
/*
*********************************************************************
* Audio Hearing-aid TDE
* Description: 全路径延时估计Time Delay Estimation
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
typedef struct {
u16 tick;
u16 delay_points_max;
u16 delay_time_max;
} hearing_aid_tde_t;
hearing_aid_tde_t dha_dte;
void hearing_tde_run(void)
{
if (dha_dte.tick ++ > 2000) {
dha_dte.tick = 0;
extern int audio_dac_data_len();
u16 time_unit = DHA_MIC_SAMPLE_RATE / 1000;
u16 delay_points = audio_dac_data_len();
u16 delay_time = (delay_points + (time_unit >> 1)) / time_unit;
delay_time = delay_time + ((DHA_MIC_SAMPLE_POINT * 1000) / DHA_MIC_SAMPLE_RATE);
if (delay_points > dha_dte.delay_points_max) {
dha_dte.delay_points_max = delay_points;
}
if (delay_time > dha_dte.delay_time_max) {
dha_dte.delay_time_max = delay_time;
}
printf("[DHA]delay_est:%d(points),%d(ms)\n", delay_points, delay_time);
//printf("[DHA]delay_est_max:%d(points),%d(ms)\n",dha_dte.delay_points_max,dha_dte.delay_time_max);
}
}
/*
*********************************************************************
* Audio Hearing-aid Mic Raw Data Handle
* Description:
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
static void hearing_mic_output_handler(void *priv, s16 *data, int len)
{
hearing_aid_t *hdl = (hearing_aid_t *)priv;
DHA_IO_INTERVAL();
if (hdl == NULL) {
return;
}
len = len * hdl->channel;
#if DHA_MIC_DATA_CBUF_ENABLE
int wlen = cbuf_write(&hdl->mic_cbuf, data, len);
if (wlen != len) {
/* putchar('f'); */
printf("hearing aid mic cbuf full !!!\n");
/* audio_codec_clock_check(); */
}
#else
hdl->mic_data_addr = data;
hdl->mic_data_len = len;
/*判断上一次数据是否已经处理完了*/
if (hdl->task_busy) {
putchar('&');
/* audio_codec_clock_check(); */
/* printf("hearing aid need to increase sys_clock"); */
}
#endif /*DHA_MIC_DATA_CBUF_ENABLE*/
os_sem_set(&hdl->sem, 0);
os_sem_post(&hdl->sem);
}
static int hearing_aid_mic_en(u8 en, hearing_adda_param_t *param)
{
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
if (hdl == NULL) {
printf("hearing_aid_mic_en error! hdl == NULL");
return -1;;
}
if (en) {
printf("dha mic en, ch %d, sr %d, gain %d", param->mic_ch_sel, param->sample_rate, param->mic_gain);
u16 mic_ch = param->mic_ch_sel;
u16 mic0_gain = param->mic_gain;
u16 mic1_gain = param->mic_gain;
u16 mic2_gain = param->mic_gain;
u16 mic3_gain = param->mic_gain;
audio_mic_pwr_ctl(MIC_PWR_ON);
if (mic_ch & AUDIO_ADC_MIC_0) {
audio_adc_mic_open(&hdl->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic_set_gain(&hdl->mic_ch, mic0_gain);
}
if (mic_ch & AUDIO_ADC_MIC_1) {
audio_adc_mic1_open(&hdl->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic1_set_gain(&hdl->mic_ch, mic1_gain);
}
if (mic_ch & AUDIO_ADC_MIC_2) {
audio_adc_mic2_open(&hdl->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic2_set_gain(&hdl->mic_ch, mic2_gain);
}
if (mic_ch & AUDIO_ADC_MIC_3) {
audio_adc_mic3_open(&hdl->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic3_set_gain(&hdl->mic_ch, mic3_gain);
}
audio_adc_mic_set_sample_rate(&hdl->mic_ch, param->sample_rate);
printf("adc_dma_buf: %x, size: %d", hdl->adc_dma_buf, param->adc_irq_points * 2 * param->adc_buf_num * hdl->channel);
audio_adc_mic_set_buffs(&hdl->mic_ch, hdl->adc_dma_buf,
param->adc_irq_points * 2, param->adc_buf_num);
hdl->adc_output.handler = hearing_mic_output_handler;
hdl->adc_output.priv = hdl;
audio_adc_add_output_handler(&adc_hdl, &hdl->adc_output);
audio_adc_mic_start(&hdl->mic_ch);
} else {
audio_adc_mic_close(&hdl->mic_ch);
audio_adc_del_output_handler(&adc_hdl, &hdl->adc_output);
audio_mic_pwr_ctl(MIC_PWR_OFF);
}
return 0;
}
/*
*********************************************************************
* Audio Hearing-aid Output
* Description:
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
int hearing_output(hearing_aid_t *hdl, s16 *data, u16 len)
{
s16 *mic_data = data;
u16 data_len = len;
int wlen = 0;
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
if (hdl->channel == 1) {
/*单变双*/
for (u16 i = 0; i < (len >> 1); i++) {
hdl->mono_to_dual[2 * i] = mic_data[i];
hdl->mono_to_dual[2 * i + 1] = mic_data[i];
}
mic_data = hdl->mono_to_dual;
data_len = len + data_len;
}
#else /*单声道*/
if (hdl->channel == 2) {
/*双变单*/
for (u16 i = 0; i < (len >> 2); i++) {
/*左右声道混合成单声道会变成杂音*/
mic_data[i] = mic_data[2 * i];
/* mic_data[i] = mic_data[2 * i + 1]; */
/* mic_data[i] = ((int)mic_data[2 * i] + (int)mic_data[2 * i + 1]) / 2; */
}
data_len = len / 2;
}
#endif/*TCFG_AUDIO_DAC_CONNECT_MODE*/
// 写入DAC
//putchar('o');
int offset = 0;
int cnt = 0;
do {
wlen = sound_pcm_dev_write(&hdl->dac_ch, mic_data + (offset >> 1), data_len - offset);
offset = offset + wlen;
cnt ++;
} while ((offset != data_len) && (cnt < 1000));
if (offset != data_len) {
/* putchar('D'); */
printf("dac write err :%d %d\n", data_len, offset);
}
return len;
}
/*
*********************************************************************
* Audio Hearing-aid Task
* Description:
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
static LOUDNESS_M_STRUCT dha_in_loudness;
static LOUDNESS_M_STRUCT dha_out_loudness;
static void audio_hearing_aid_task(void *p)
{
int err = 0;
int wlen = 0;
s16 *mic_data = NULL;
int data_len = 0;
hearing_aid_t *hdl = (hearing_aid_t *)p;
while (1) {
err = os_sem_pend(&hdl->sem, 0);
if (err || hdl->task_release) {
break;
}
#if DHA_RUN_TIME_TRACE_ENABLE
start_ts = jiffies_msec();
#endif/*DHA_RUN_TIME_TRACE_ENABLE*/
DHA_IO_DEBUG_1();
hdl->task_busy = 1;
#if DHA_MIC_DATA_CBUF_ENABLE
mic_data = hdl->run_buf;
data_len = cbuf_read(&hdl->mic_cbuf, mic_data, DHA_MIC_SAMPLE_POINT * sizeof(short) * hdl->channel);
#else
mic_data = hdl->mic_data_addr;
data_len = hdl->mic_data_len;
#endif /*DHA_MIC_DATA_CBUF_ENABLE*/
int clk = clk_get("sys");
if (clk < HEARING_AID_CLK) {
clk_set("sys", HEARING_AID_CLK);
}
#if ((defined TCFG_AUDIO_DHA_LOW_POWER_ENABLE) && TCFG_AUDIO_DHA_LOW_POWER_ENABLE)
audio_hearing_aid_lp_detect(NULL, mic_data, data_len);
#endif /*TCFG_AUDIO_DHA_LOW_POWER_ENABLE*/
#if DHA_IN_LOUDNESS_TRACE_ENABLE
loudness_meter_short(&dha_in_loudness, mic_data, data_len >> 1);
#endif /*DHA_IN_LOUDNESS_TRACE_ENABLE*/
//数据导出
#if DHA_DATA_EXPORT_ENABLE
aec_uart_fill(0, mic_data, data_len);
#endif /*DHA_DATA_EXPORT_ENABLE*/
#if TCFG_AUDIO_DHA_FITTING_ENABLE
if (dha_schedule.fitting) {
if (dha_schedule.fitting == 1) {
/*生成听力验配对应的频点声音*/
extern void sin_pcm_fill(int fc, int fs, void *buf, u32 len);
sin_pcm_fill(sine_freq[sine_idx], DHA_MIC_SAMPLE_RATE, mic_data, data_len);
} else if (dha_schedule.fitting == 2) {
memset(mic_data, 0, data_len);
}
} else
#endif /*TCFG_AUDIO_DHA_FITTING_ENABLE*/
{
// 算法处理
if (hdl->channel == 1) {
#if DHA_HS_FS_ENABLE
if (hdl->hs_fs) {
run_howling(hdl->hs_fs, mic_data, mic_data, data_len >> 1);
}
#endif/*DHA_HS_FS_ENABLE*/
#if DHA_HS_NOTCH_ENABLE
if (hdl->hs_notch) {
run_howling(hdl->hs_notch, mic_data, mic_data, data_len >> 1);
}
#endif/*DHA_HS_NOTCH_ENABLE*/
} else {
/*双变单*/
for (int i = 0; i < data_len / 4; i++) {
hdl->tmp_buf[i] = mic_data[2 * i];
hdl->tmp_buf_1[i] = mic_data[2 * i + 1];
}
#if DHA_HS_FS_ENABLE
if (hdl->hs_fs && hdl->hs_fs_1) {
run_howling(hdl->hs_fs, hdl->tmp_buf, hdl->tmp_buf, data_len >> 2);
run_howling(hdl->hs_fs_1, hdl->tmp_buf_1, hdl->tmp_buf_1, data_len >> 2);
}
#endif/*DHA_HS_FS_ENABLE*/
#if DHA_HS_NOTCH_ENABLE
if (hdl->hs_notch && hdl->hs_notch_1) {
run_howling(hdl->hs_notch, hdl->tmp_buf, hdl->tmp_buf, data_len >> 2);
run_howling(hdl->hs_notch_1, hdl->tmp_buf_1, hdl->tmp_buf_1, data_len >> 2);
}
#endif/*DHA_HS_NOTCH_ENABLE*/
/*单变双*/
for (int i = 0; i < data_len / 4; i++) {
mic_data[2 * i] = hdl->tmp_buf[i];
mic_data[2 * i + 1] = hdl->tmp_buf_1[i];
}
}
#if (DHA_EQ_ENABLE || DHA_DRC_ENABLE)
if (hdl->hearing_eq_drc) {
hearing_eq_drc_run(hdl->hearing_eq_drc, mic_data, data_len);
}
#endif/*DHA_EQ_ENABLE || DHA_DRC_ENABLE*/
#if (TCFG_EQ_ENABLE && DHA_EQ2_ENABLE)
if (hdl->hearing_eq2) {
hearing_eq2_run(hdl->hearing_eq2, mic_data, data_len);
}
#endif /*TCFG_EQ_ENABLE && DHA_EQ2_ENABLE*/
#if DHA_NOISE_GATE_ENABLE
audio_noise_gate_run(mic_data, mic_data, data_len);
#endif/*DHA_NOISE_GATE_ENABLE*/
#if DHA_NS_ENABLE
if (hdl->channel == 1) {
if (hdl->llns) {
data_len = llns_run(hdl->llns, mic_data, data_len);
}
} else {
/*双变单*/
for (int i = 0; i < data_len / 4; i++) {
hdl->tmp_buf[i] = mic_data[2 * i];
hdl->tmp_buf_1[i] = mic_data[2 * i + 1];
}
if (hdl->llns) {
llns_run(hdl->llns, hdl->tmp_buf, data_len / 2);
}
if (hdl->llns_1) {
llns_run(hdl->llns_1, hdl->tmp_buf_1, data_len / 2);
}
/*单变双*/
for (int i = 0; i < data_len / 4; i++) {
mic_data[2 * i] = hdl->tmp_buf[i];
mic_data[2 * i + 1] = hdl->tmp_buf_1[i];
}
}
#endif /*DHA_NS_ENABLE*/
#if DHA_FADEIN_ENABLE
hearing_fade_in_run(mic_data, (data_len >> 1));
#endif/*DHA_FADEIN_ENABLE*/
}
#if DHA_VOLUME_ENABLE
hearing_volume_run(mic_data, data_len);
#endif/*DHA_VOLUME_ENABLE*/
//数据导出
#if DHA_DATA_EXPORT_ENABLE
aec_uart_fill(1, mic_data, data_len);
aec_uart_write();
#endif /*DHA_DATA_EXPORT_ENABLE*/
#if DHA_OUT_LOUDNESS_TRACE_ENABLE
loudness_meter_short(&dha_out_loudness, mic_data, data_len >> 1);
#endif /*DHA_OUT_LOUDNESS_TRACE_ENABLE*/
#if DHA_SRC_ENABLE
#if DHA_SRC_USE_HW_ENABLE
hearing_src_run(hdl, mic_data, NULL, data_len);
continue;
#else
data_len = hearing_src_run(hdl, mic_data, hdl->src_out_data, data_len);
if (data_len) {
mic_data = hdl->src_out_data;
}
#endif/*DHA_SRC_USE_HW_ENABLE*/
#endif /*DHA_SRC_ENABLE*/
//result output
hearing_output(hdl, mic_data, data_len);
#if DHA_TDE_ENABLE
hearing_tde_run();
#endif/*DHA_TDE_ENABLE*/
#if DHA_RUN_TIME_TRACE_ENABLE
end_ts = jiffies_msec();
printf("run_time:%d - %d = %d\n", end_ts, start_ts, (end_ts - start_ts));
#endif/*DHA_RUN_TIME_TRACE_ENABLE*/
DHA_IO_DEBUG_0();
hdl->task_busy = 0;
}
hdl->task_exit = 1;
while (1) {
os_time_dly(100);
}
}
/*
*********************************************************************
* Audio Hearing-aid Open
* Description:
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
int audio_hearing_aid_open(void)
{
printf("audi_hearing_aid_open\n");
int err = 0;
hearing_adda_param_t *param = &hearing_adda_param;
hearing_aid_t *hdl = hearing_hdl;
if (hdl != NULL) {
printf("hdl != NULL!");
return err;
}
#if TCFG_AUDIO_DHA_AND_MUSIC_MUTEX
/*播歌互斥时播歌不开辅听*/
extern u8 bt_media_is_running(void);
if (bt_media_is_running()) {
dha_schedule.state = DHA_STATE_SUSPEND;
return 0;
}
#endif /*TCFG_AUDIO_DHA_AND_MUSIC_MUTEX*/
#if TCFG_AUDIO_DHA_AND_CALL_MUTEX
/*通话互斥时通话不开辅听*/
extern u8 bt_phone_dec_is_running();
if (bt_phone_dec_is_running()) {
dha_schedule.state = DHA_STATE_SUSPEND;
return 0;
}
#endif /*TCFG_AUDIO_DHA_AND_CALL_MUTEX*/
#if TCFG_AUDIO_DHA_AND_TONE_MUTEX
/*提示音互斥时播提示音不开辅听*/
extern int tone_get_status();
extern int sine_get_status();
if (tone_get_status() || sine_get_status()) {
dha_schedule.state = DHA_STATE_SUSPEND;
return 0;
}
#endif /*TCFG_AUDIO_DHA_AND_TONE_MUTEX*/
#if TCFG_AUTO_SHUT_DOWN_TIME
sys_auto_shut_down_disable();
#endif/*TCFG_AUTO_SHUT_DOWN_TIME*/
mem_stats();
hdl = zalloc(sizeof(hearing_aid_t));
if (hdl == NULL) {
printf("hdl malloc error!");
goto __err;
}
hearing_hdl = hdl;
hdl->channel = 0;
u8 mic_ch = hearing_adda_param.mic_ch_sel;
if (mic_ch & AUDIO_ADC_MIC_0) {
hdl->channel++;
}
if (mic_ch & AUDIO_ADC_MIC_1) {
hdl->channel++;
}
if (mic_ch & AUDIO_ADC_MIC_2) {
hdl->channel++;
}
if (mic_ch & AUDIO_ADC_MIC_3) {
hdl->channel++;
}
printf(" hdl channel %d", hdl->channel);
u32 adc_dma_size = param->adc_irq_points * param->adc_buf_num * sizeof(short) * hdl->channel;
if (adc_dma_size == 0) {
printf("adc_dma_size == NULL!");
goto __err;
}
hdl->adc_dma_buf = zalloc(adc_dma_size);
if (hdl->adc_dma_buf == NULL) {
printf("hdl->adc_dma_buf malloc error!");
goto __err;
}
#if DHA_MIC_DATA_CBUF_ENABLE
hdl->run_buf = zalloc(DHA_MIC_SAMPLE_POINT * sizeof(short) * hdl->channel);
hdl->data_buf = zalloc(DHA_MIC_SAMPLE_POINT * sizeof(short) * hdl->channel * 3);
cbuf_init(&hdl->mic_cbuf, hdl->data_buf, DHA_MIC_SAMPLE_POINT * sizeof(short) * hdl->channel * 3);
#endif /*DHA_MIC_DATA_CBUF_ENABLE*/
if (hdl->channel == 2) {
hdl->tmp_buf = zalloc(DHA_MIC_SAMPLE_POINT * sizeof(short));
hdl->tmp_buf_1 = zalloc(DHA_MIC_SAMPLE_POINT * sizeof(short));
}
clk_set("sys", HEARING_AID_CLK);
/* audio_codec_clock_set(HEARING_AID_MODE, AUDIO_CODING_PCM, 0); */
#if TCFG_AUDIO_DHA_FITTING_ENABLE
/*读取验配参数*/
float EQGain[DHA_FITTING_CHANNEL_MAX];
err = fitting_param_read(EQGain);
if (err == DHA_FITTING_CHANNEL_MAX * 4) {
put_buf(EQGain, DHA_FITTING_CHANNEL_MAX * 4);
/*更新验配数据到辅听*/
hearing_aid_eq_filter_updata(EQGain);
} else {
printf("default fitting param !!!\n");
}
#endif /*TCFG_AUDIO_DHA_FITTING_ENABLE*/
#if DHA_IN_LOUDNESS_TRACE_ENABLE
loudness_meter_init(&dha_in_loudness, param->sample_rate, 50, 0);
#endif /*DHA_IN_LOUDNESS_TRACE_ENABLE*/
#if DHA_OUT_LOUDNESS_TRACE_ENABLE
loudness_meter_init(&dha_out_loudness, param->sample_rate, 50, 1);
#endif /*DHA_IN_LOUDNESS_TRACE_ENABLE*/
//memcpy(&hdl->param, param, sizeof(struct __ad2da_low_latency_param));
os_sem_create(&hdl->sem, 0);
err = task_create(audio_hearing_aid_task, (void *)hdl, HEARING_AID_TASK_NAME);
if (err != OS_NO_ERR) {
printf("task create error!");
goto __err;
}
dha_schedule.fitting = 0;
dha_schedule.fitting_state = 0;
//mem_stats();
#if ((defined TCFG_AUDIO_DHA_LOW_POWER_ENABLE) && TCFG_AUDIO_DHA_LOW_POWER_ENABLE)
audio_hearing_aid_lp_open(1, audio_hearing_aid_open, audio_hearing_aid_close);
#endif /*TCFG_AUDIO_DHA_LOW_POWER_ENABLE*/
//数据导出
#if DHA_DATA_EXPORT_ENABLE
aec_uart_open(2, param->adc_irq_points * 2);
#endif /*DHA_DATA_EXPORT_ENABLE*/
// 算法初始化
#if DHA_HS_FS_ENABLE
///啸叫抑制初始化
hdl->hs_fs = open_howling(NULL, param->sample_rate, 0, 1);//mode 1:移频
printf("open_howling %x\n\n\n", hdl->hs_fs);
if (hdl->channel == 2) {
hdl->hs_fs_1 = open_howling(NULL, param->sample_rate, 0, 1);//mode 1:移频
printf("open_howling_1 %x\n\n\n", hdl->hs_fs_1);
}
//mem_stats();
#endif/*DHA_HS_FS_ENABLE*/
#if DHA_HS_NOTCH_ENABLE
HOWLING_PARM_SET howling_param_default = {
.threshold = 25,
.sample_rate = param->sample_rate,
.channel = 1,
.fade_time = 10,
.notch_Q = 2.0f,
.notch_gain = -20.0f,
};
hdl->hs_notch = open_howling(&howling_param_default, param->sample_rate, 0, 0);//mode 0:陷波
printf("open_notch howling %x\n\n\n", hdl->hs_notch);
if (hdl->channel == 2) {
hdl->hs_notch_1 = open_howling(&howling_param_default, param->sample_rate, 0, 0);//mode 0:陷波
printf("open_notch howling_1 %x\n\n\n", hdl->hs_notch_1);
}
//mem_stats();
#endif/*DHA_HS_NOTCH_ENABLE*/
#if DHA_NOISE_GATE_ENABLE
/*限幅器上限*/
#define LIMITER_THR -3000 /*-12000 = -12dB,放大1000倍,(-10000参考)*/
/*小于CONST_NOISE_GATE的当成噪声处理,防止清0近端声音*/
#define LIMITER_NOISE_GATE -40000 /*-12000 = -12dB,放大1000倍,(-30000参考)*/
/*低于噪声门限阈值的增益 */
#define LIMITER_NOISE_GAIN ((int) (0.2 * (1 << 30))) /*(0~1)*2^30*/
audio_noise_gate_open(param->sample_rate, LIMITER_THR, LIMITER_NOISE_GATE, LIMITER_NOISE_GAIN);
#endif/*DHA_NOISE_GATE_ENABLE*/
#if (DHA_EQ_ENABLE || DHA_DRC_ENABLE)
hdl->hearing_eq_drc = hearing_eq_drc_open(param->sample_rate, hdl->channel);
printf("hearing_eq_drc open %x\n\n\n", hdl->hearing_eq_drc);
//mem_stats();
#endif/*DHA_EQ_ENABLE || DHA_DRC_ENABLE*/
#if (TCFG_EQ_ENABLE && DHA_EQ2_ENABLE)
hdl->hearing_eq2 = hearing_eq2_open(param->sample_rate, hdl->channel);
printf("hearing_eq2 open %x\n\n\n", hdl->hearing_eq2);
#endif /*TCFG_EQ_ENABLE && DHA_EQ2_ENABLE*/
#if DHA_NS_ENABLE
hdl->llns = llns_init(param->sample_rate, 0.05f, 1.0f);
if (hdl->channel == 2) {
hdl->llns_1 = llns_init(param->sample_rate, 0.05f, 1.0f);
}
//mem_stats();
#endif /*DHA_NS_ENABLE*/
#if DHA_SRC_ENABLE
hearing_src_init(hdl, hdl->channel, param->sample_rate, TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE);
//mem_stats();
#endif /*DHA_SRC_ENABLE*/
app_audio_state_switch(APP_AUDIO_STATE_MUSIC, get_max_sys_vol());
app_audio_set_volume(APP_AUDIO_STATE_MUSIC, get_max_sys_vol(), 1);
#if DHA_VOLUME_ENABLE
hearing_volume_open(HEARING_DVOL_MAX);
#endif /*DHA_VOLUME_ENABLE*/
// DAC 初始化
audio_dac_new_channel(&dac_hdl, &hdl->dac_ch);
struct audio_dac_channel_attr attr;
attr.delay_time = param->dac_delay;
attr.protect_time = 8;
attr.write_mode = WRITE_MODE_FORCE;
audio_dac_channel_set_attr(&hdl->dac_ch, &attr);
sound_pcm_dev_start(&hdl->dac_ch, TCFG_AD2DA_LOW_LATENCY_SAMPLE_RATE, app_audio_get_volume(APP_AUDIO_STATE_MUSIC));
#if DHA_DAC_OUTPUT_ENHANCE_ENABLE
//DAC输出音量增强使能
app_audio_dac_vol_mode_set(1);
#endif /*DHA_DAC_OUTPUT_ENHANCE_ENABLE*/
dac_digital_vol = audio_dac_get_digital_vol();
printf("dac_digital_vol : %d\n", dac_digital_vol);
#if DHA_TDE_ENABLE
memset(&dha_dte, 0, sizeof(dha_dte));
#endif/*DHA_TDE_ENABLE*/
/* hearing_volume_set(14); */
DHA_IO_DEBUG_INIT();
// ADC 初始化
hearing_aid_mic_en(1, param);
dha_schedule.state = DHA_STATE_OPEN;
printf("audio_hearing_aid_open success!");
mem_stats();
return 0;
__err:
if (hdl) {
if (hdl->adc_dma_buf) {
free(hdl->adc_dma_buf);
}
free(hdl);
}
hearing_hdl = NULL;
#if TCFG_AUTO_SHUT_DOWN_TIME
sys_auto_shut_down_enable();
#endif/*TCFG_AUTO_SHUT_DOWN_TIME*/
printf("audio_hearing_aid_open error!");
return -1;
}
void audio_hearing_aid_sync_open(void)
{
#if TCFG_USER_TWS_ENABLE
if (get_tws_sibling_connect_state()) {
if (tws_api_get_role() == TWS_ROLE_MASTER) {
printf("[tws_master]dha open");
bt_tws_play_tone_at_same_time(SYNC_TONE_HEARING_AID_OPEN, 400);
}
} else {
audio_hearing_aid_open();
}
#else
audio_hearing_aid_open();
#endif/*TCFG_USER_TWS_ENABLE*/
}
/*
*********************************************************************
* Audio Hearing-aid Close
* Description:
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
int audio_hearing_aid_close(void)
{
int err = 0;
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
printf("[DHA]audio_hearing_aid_close\n");
if (hdl == NULL) {
if (dha_schedule.state == DHA_STATE_SUSPEND) {
printf("[DHA]hearing-aid suspend now\n");
dha_schedule.state = DHA_STATE_CLOSE;
return 0;
}
printf("audio_hearing_aid_close error! hdl == NULL");
return -1;
}
// ADC 关闭
hearing_aid_mic_en(0, NULL);
hdl->task_release = 1;
os_sem_set(&hdl->sem, 0);
os_sem_post(&hdl->sem);
while (hdl->task_exit == 0) {
os_time_dly(1);
}
err = task_kill(HEARING_AID_TASK_NAME);
os_sem_del(&hdl->sem, 0);
// DAC 关闭
sound_pcm_dev_stop(&hdl->dac_ch);
#if DHA_DAC_OUTPUT_ENHANCE_ENABLE
app_audio_dac_vol_mode_set(0);
#endif /*DHA_DAC_OUTPUT_ENHANCE_ENABLE*/
#if DHA_HS_FS_ENABLE
if (hdl->hs_fs) {
printf("close_howling\n\n\n");
close_howling(hdl->hs_fs);
}
if (hdl->hs_fs_1) {
printf("close_howling_1\n\n\n");
close_howling(hdl->hs_fs_1);
}
#endif/*DHA_HS_FS_ENABLE*/
#if DHA_HS_NOTCH_ENABLE
if (hdl->hs_notch) {
printf("close_howling\n\n\n");
close_howling(hdl->hs_notch);
}
if (hdl->hs_notch_1) {
printf("close_howling\n\n\n");
close_howling(hdl->hs_notch_1);
}
#endif/*DHA_HS_NOTCH_ENABLE*/
#if DHA_NOISE_GATE_ENABLE
audio_noise_gate_close();
#endif/*DHA_NOISE_GATE_ENABLE*/
#if (DHA_EQ_ENABLE || DHA_DRC_ENABLE)
if (hdl->hearing_eq_drc) {
hearing_eq_drc_close(hdl->hearing_eq_drc);
}
#endif/*DHA_EQ_ENABLE || DHA_DRC_ENABLE*/
#if (TCFG_EQ_ENABLE && DHA_EQ2_ENABLE)
if (hdl->hearing_eq2) {
hearing_eq2_close(hdl->hearing_eq2);
}
#endif /*TCFG_EQ_ENABLE && DHA_EQ2_ENABLE*/
#if DHA_NS_ENABLE
if (hdl->llns) {
llns_exit(hdl->llns);
hdl->llns = NULL;
if (hdl->llns_1) {
llns_exit(hdl->llns_1);
hdl->llns_1 = NULL;
}
}
#endif /*DHA_NS_ENABLE*/
#if DHA_SRC_ENABLE
hearing_src_exit(hdl);
#endif /*DHA_SRC_ENABLE*/
#if DHA_VOLUME_ENABLE
hearing_volume_close();
#endif /*DHA_VOLUME_ENABLE*/
//数据导出
#if DHA_DATA_EXPORT_ENABLE
aec_uart_close();
#endif /*DHA_DATA_EXPORT_ENABLE*/
#if DHA_MIC_DATA_CBUF_ENABLE
if (hdl->run_buf) {
free(hdl->run_buf);
hdl->run_buf = NULL;
}
if (hdl->data_buf) {
free(hdl->data_buf);
hdl->data_buf = NULL;
}
#endif /*DHA_MIC_DATA_CBUF_ENABLE*/
if (hdl->adc_dma_buf) {
free(hdl->adc_dma_buf);
hdl->adc_dma_buf = NULL;
}
if (hdl->tmp_buf) {
free(hdl->tmp_buf);
hdl->tmp_buf = NULL;
}
if (hdl->tmp_buf_1) {
free(hdl->tmp_buf_1);
hdl->tmp_buf_1 = NULL;
}
free(hdl);
hearing_hdl = NULL;
/* audio_codec_clock_del(HEARING_AID_MODE); */
// 算法关闭
dha_schedule.state = DHA_STATE_CLOSE;
#if TCFG_AUDIO_DHA_FITTING_ENABLE
/*验配过程关闭辅听主动告诉app*/
extern u8 get_rcsp_connect_status(void);
if (get_rcsp_connect_status()) {
/*主动推送辅听状态信息*/
u8 tmp[4];
get_hearing_aid_state_cmd_info(tmp);
hearing_aid_rcsp_notify(tmp, 4);
}
#endif /*TCFG_AUDIO_DHA_FITTING_ENABLE*/
dha_schedule.fitting = 0;
dha_schedule.fitting_state = 0;
#if TCFG_AUTO_SHUT_DOWN_TIME
sys_auto_shut_down_enable();
#endif/*TCFG_AUTO_SHUT_DOWN_TIME*/
printf("audio_hearing_aid_close success!\n");
return 0;
}
char *dha_state_str[] = {
"close",
"open",
"suspend",
"error",
};
/*TWS配对后，状态同步*/
u8 get_hearing_aid_state(void)
{
return dha_schedule.state;
}
static void hearing_aid_state_sync_deal(void *param)
{
printf("[DHA]sync open,cur_state = %s\n", dha_state_str[dha_schedule.state]);
if (dha_schedule.timer) {
sys_timer_del(dha_schedule.timer);
dha_schedule.timer = 0;
}
if (dha_schedule.state == DHA_STATE_OPEN) {
audio_hearing_aid_open();
}
}
void hearing_aid_state_sync(u8 state)
{
if (dha_schedule.state != state) {
dha_schedule.state = state;
printf("[DHA]open, cur_state= %s,timer:0x%x\n", dha_state_str[dha_schedule.state], dha_schedule.timer);
if ((dha_schedule.state == DHA_STATE_OPEN) && (dha_schedule.timer == 0)) {
dha_schedule.timer = sys_timer_add(NULL, hearing_aid_state_sync_deal, 1500);
}
}
}
/*
*********************************************************************
* Audio Hearing-aid Demo
* Description:
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
void audio_hearing_aid_demo(void)
{
hearing_aid_t *hdl = (hearing_aid_t *)hearing_hdl;
printf("audio_hearing_aid_demo,toggle = %x\n", hdl);
if (hdl == NULL) {
audio_hearing_aid_sync_open();
} else {
/*验配过程中不允许按键关闭辅听*/
if (get_hearing_aid_fitting_state()) {
return;
}
audio_hearing_aid_close();
}
}
/*
*********************************************************************
* Audio Hearing-aid Schedule
* Description: suspend or resume
* Arguments : NULL
* Return : NULL
* Note(s) : NULL
*********************************************************************
*/
void audio_hearing_aid_suspend(void)
{
#if DHA_AND_MEDIA_MUTEX_ENABLE
printf("[DHA]suspend,cur_state = %s\n", dha_state_str[dha_schedule.state]);
if (dha_schedule.timer) {
printf("[DHA]schedule timer delete\n");
sys_timer_del(dha_schedule.timer);
dha_schedule.timer = 0;
}
if (hearing_hdl) {
audio_hearing_aid_close();
dha_schedule.state = DHA_STATE_SUSPEND;
}
#endif/*DHA_AND_MEDIA_MUTEX_ENABLE*/
}
static void hearing_aid_schedule(void *priv)
{
printf("[DHA]schedule,cur_state = %s\n", dha_state_str[dha_schedule.state]);
sys_timer_del(dha_schedule.timer);
dha_schedule.timer = 0;
if (dha_schedule.state == DHA_STATE_SUSPEND) {
audio_hearing_aid_sync_open();
}
}
void audio_hearing_aid_resume(void)
{
#if DHA_AND_MEDIA_MUTEX_ENABLE
printf("[DHA]resume, cur_state= %s,timer:0x%x\n", dha_state_str[dha_schedule.state], dha_schedule.timer);
if ((dha_schedule.state == DHA_STATE_SUSPEND) && (dha_schedule.timer == 0)) {
dha_schedule.timer = sys_timer_add(NULL, hearing_aid_schedule, 2500);
}
#endif/*DHA_AND_MEDIA_MUTEX_ENABLE*/
}
static u8 hearing_aid_idle_query()
{
#if ((defined TCFG_AUDIO_DHA_LOW_POWER_ENABLE) && TCFG_AUDIO_DHA_LOW_POWER_ENABLE)
if (audio_hearing_aid_lp_flag()) {
return 1; //进入低功耗
} else {
return 0; //不能进
}
#else
return hearing_hdl ? 0 : 1;
#endif /*TCFG_AUDIO_DHA_LOW_POWER_ENABLE*/
}
REGISTER_LP_TARGET(hearing_aid_lp_target) = {
.name = "hearing_aid",
.is_idle = hearing_aid_idle_query,
};
#endif //TCFG_AUDIO_HEARING_AID_ENABLE
Reference in New Issue Copy Permalink