/* **************************************************************** * 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