#include "audio_dec_eff.h" #include "debug.h" #include "system/syscfg_id.h" #if TCFG_AUDIO_CVP_DUT_ENABLE #include "audio_cvp_dut.h" #endif/*TCFG_AUDIO_CVP_DUT_ENABLE*/ extern struct audio_dac_hdl dac_hdl; extern const int const_surround_en; void user_sat16(s32 *in, s16 *out, u32 npoint); void a2dp_surround_set(u8 eff); int audio_out_eq_get_filter_info(void *eq, int sr, struct audio_eq_filter_info *info); int audio_out_eq_spec_set_info(struct audio_eq *eq, u8 idx, int freq, float gain); void *dec_eq_drc_setup_new(void *priv, int (*eq_output_cb)(void *, void *, int), u32 sample_rate, u8 channel, u8 async, u8 drc_en); void eq_cfg_default_init(EQ_CFG *eq_cfg); void drc_default_init(EQ_CFG *eq_cfg, u8 mode); /*----------------------------------------------------------------------------*/ /**@brief 环绕音效切换测试例子 @param @return @note */ /*----------------------------------------------------------------------------*/ void surround_switch_test(void *p) { #if 0 if (!p) { return; } static u8 cnt_type = 0; if (EFFECT_OFF == cnt_type) { //中途关开测试 static u8 en = 0; en = !en; audio_surround_parm_update(p, cnt_type, (surround_update_parm *)en); } else { //音效切换测试 audio_surround_parm_update(p, cnt_type, NULL); } printf("cnt_type 0x%x\n", cnt_type); if (++cnt_type > EFFECT_OFF) { cnt_type = EFFECT_3D_PANORAMA; } #endif } void *audio_surround_setup(u8 channel, u8 eff) { #if AUDIO_SURROUND_CONFIG struct dec_sur *sur = zalloc(sizeof(struct dec_sur)); u8 nch = EFFECT_CH_L; if (channel == AUDIO_CH_L) { nch = EFFECT_CH_L; } else if (channel == AUDIO_CH_R) { nch = EFFECT_CH_R; } else if (channel == AUDIO_CH_LR) { nch = 2; } else if (channel == AUDIO_CH_DUAL_L) { nch = EFFECT_CH2_L; } else if (channel == AUDIO_CH_DUAL_R) { nch = EFFECT_CH2_R; } else { if (sur) { free(sur); } log_e("surround ch_type err %d\n", channel); return NULL; } surround_open_parm parm = {0}; parm.channel = nch; parm.surround_effect_type = EFFECT_3D_PANORAMA;//打开时默认使用3d全景音,使用者，根据需求修改 sur->surround = audio_surround_open(&parm); sur->surround_eff = eff; audio_surround_voice(sur, sur->surround_eff);//还原按键触发的音效 //sur_test = sys_timer_add(sur->surround, surround_switch_test, 10000); return sur; #else return NULL; #endif//AUDIO_SURROUND_CONFIG } void audio_surround_free(void *sur) { #if AUDIO_SURROUND_CONFIG struct dec_sur *surh = (struct dec_sur *)sur; if (!surh) { return; } if (surh->surround) { audio_surround_close(surh->surround); surh->surround = NULL; } free(surh); #endif//AUDIO_SURROUND_CONFIG } void audio_surround_set_ch(void *sur, u8 channel) { #if AUDIO_SURROUND_CONFIG struct dec_sur *surh = (struct dec_sur *)sur; if (!surh) { return; } u8 nch = EFFECT_CH_L; if (channel == AUDIO_CH_L) { nch = EFFECT_CH_L; } else if (channel == AUDIO_CH_R) { nch = EFFECT_CH_R; } else if (channel == AUDIO_CH_LR) { nch = 2; } else if (channel == AUDIO_CH_DUAL_L) { nch = EFFECT_CH2_L; } else if (channel == AUDIO_CH_DUAL_R) { nch = EFFECT_CH2_R; } else { log_e("surround ch_type err %d\n", channel); return ; } if (surh->surround) { audio_surround_switch_nch(surh->surround, nch); } #endif//AUDIO_SURROUND_CONFIG } /* *环绕音效开关控制 * */ void audio_surround_voice(void *sur, u8 en) { #if AUDIO_SURROUND_CONFIG struct dec_sur *surh = (struct dec_sur *)sur; surround_hdl *surround = (surround_hdl *)surh->surround; if (surround) { if (en) { if (const_surround_en & BIT(2)) { surround_update_parm parm = {0}; parm.surround_type = EFFECT_3D_LRDRIFT2;//音效类型 parm.rotatestep = 4; //建议1~6,环绕速度 parm.damping = 40;//混响音量（0~70）,空间感 parm.feedback = 100;//干声音量(0~100),清晰度 parm.roomsize = 128;//无效参数 audio_surround_parm_update(surround, EFFECT_SUR2, &parm); } else { audio_surround_parm_update(surround, EFFECT_3D_ROTATES, NULL); } } else { surround_update_parm parm = {0}; audio_surround_parm_update(surround, EFFECT_OFF2, &parm);//关音效 } } #endif /* AUDIO_SURROUND_CONFIG */ } #if AUDIO_VBASS_CONFIG /*----------------------------------------------------------------------------*/ /**@brief 虚拟低音参数更新例子 @param @return @note */ /*----------------------------------------------------------------------------*/ #define AEID_MUSIC_VBASS 1 vbass_hdl *audio_vbass_open_demo(u32 vbass_name, u32 sample_rate, u8 ch_num) { VirtualBassParam parm = {0}; u8 tar = 0; struct virtual_bass_tool_set *param = get_vbass_parm(); u8 bypass = 0; parm.ratio = param->parm.ratio; parm.boost = param->parm.boost; parm.fc = param->parm.fc; parm.channel = ch_num; parm.SampleRate = sample_rate; parm.pcm_info.IndataBit = DATA_INT_16BIT; parm.pcm_info.OutdataBit = DATA_INT_16BIT; parm.pcm_info.IndataInc = (ch_num == 2) ? 2 : 1; parm.pcm_info.OutdataInc = (ch_num == 2) ? 2 : 1; parm.pcm_info.Qval = 15; //printf("vbass ratio %d, boost %d, fc %d, channel %d, SampleRate %d\n", parm.ratio, parm.boost, parm.fc,parm.channel, parm.SampleRate); vbass_hdl *vbass = audio_vbass_open(vbass_name, &parm); vbass->lowfreq_en = 1; //1：保留低频；0：不保留 audio_vbass_bypass(vbass_name, bypass); /* clock_add(DEC_VBASS_CLK); */ return vbass; } void audio_vbass_close_demo(vbass_hdl *vbass) { if (vbass) { audio_vbass_close(vbass); vbass = NULL; } /* clock_remove(DEC_VBASS_CLK); */ } void audio_vbass_update_demo(u32 vbass_name, VirtualBassUdateParam *parm, u32 bypass) { audio_vbass_parm_update(vbass_name, parm); audio_vbass_bypass(vbass_name, bypass); } void vbass_udate_parm_test(void *p) { #if 0 //虚拟低音增益调节例子 vbass_parm.ratio = 56;//比率(0~100),越大，低音强度越大 vbass_parm.boost = 1;//(低音增强0, 1) vbass_parm.fc = 100;//截止频率(30~300Hz) audio_vbass_parm_update(AEID_MUSIC_VBASS, &vbass_parm); audio_vbass_bypass(AEID_MUSIC_VBASS, 0); #endif #if 0 //开关虚拟低音例子 static u8 bypass = 0; /* bypass = 1;//关 */ /* bypass = 0;//开 */ bypass = !bypass; audio_vbass_bypass(AEID_MUSIC_VBASS, bypass); #endif } vbass_hdl *audio_vbass_setup(u32 sample_rate, u8 channel) { return audio_vbass_open_demo(AEID_MUSIC_VBASS, sample_rate, channel); } void audio_vbass_free(vbass_hdl *vbass) { audio_vbass_close_demo(vbass); } #endif//AUDIO_VBASS_CONFIG void eq_32bit_out(struct dec_eq_drc *eff) { if (!config_eq_lite_en) { int wlen = 0; int point_len = 2; #if defined(TCFG_AUDIO_DAC_24BIT_MODE) && TCFG_AUDIO_DAC_24BIT_MODE point_len = 4; s32 *out_tmp = eff->eq_out_buf; #else s16 *out_tmp = eff->eq_out_buf; #endif if (eff->priv && eff->out_cb) { wlen = eff->out_cb(eff->priv, &out_tmp[eff->eq_out_points], (eff->eq_out_total - eff->eq_out_points) * point_len); } eff->eq_out_points += wlen / point_len; } } static int eq_output(void *priv, void *buf, u32 len) { if (!config_eq_lite_en) { int wlen = 0; int rlen = len; s16 *data = (s16 *)buf; struct dec_eq_drc *eff = priv; if (!eff->async) { return rlen; } if (eff->drc && eff->async) { if (eff->eq_out_buf && (eff->eq_out_points < eff->eq_out_total)) { eq_32bit_out(eff); if (eff->eq_out_points < eff->eq_out_total) { return 0; } } audio_drc_run(eff->drc, data, len); #if defined(TCFG_AUDIO_DAC_24BIT_MODE) && TCFG_AUDIO_DAC_24BIT_MODE if ((!eff->eq_out_buf) || (eff->eq_out_buf_len < len)) { if (eff->eq_out_buf) { free(eff->eq_out_buf); } eff->eq_out_buf_len = len; eff->eq_out_buf = malloc(eff->eq_out_buf_len); ASSERT(eff->eq_out_buf); } memcpy(eff->eq_out_buf, data, len); eff->eq_out_points = 0; eff->eq_out_total = len / 4; #else if ((!eff->eq_out_buf) || (eff->eq_out_buf_len < len / 2)) { if (eff->eq_out_buf) { free(eff->eq_out_buf); } eff->eq_out_buf_len = len / 2; eff->eq_out_buf = malloc(eff->eq_out_buf_len); ASSERT(eff->eq_out_buf); } user_sat16((s32 *)data, (s16 *)eff->eq_out_buf, len / 4); eff->eq_out_points = 0; eff->eq_out_total = len / 4; #endif eq_32bit_out(eff); return len; } int out_len = 0; if (eff->priv && eff->out_cb) { out_len = eff->out_cb(eff->priv, data, len); } return out_len; } else { return len; } } int wdrc_get_filter_info(void *drc, struct audio_drc_filter_info *info) { static struct drc_ch wdrc_p = {0}; struct threshold_group threshold[5] = {{-100 + 90.3f, -91.9f + 90.3f}, {-87 + 90.3f, -72.5f + 90.3f}, {-58.6f + 90.3f, -60.3f + 90.3f}, {-43.5f + 90.3f, -29.7f + 90.3f}, {0 + 90.3f, -10.9f + 90.3f}}; /* struct threshold_group threshold[3] = {{0x42166666, 0x0}, {0x42580000, 0x42a40000},{0x42f00000, 0x42c50000}}; */ wdrc_p.nband = 1; wdrc_p.type = 3;//wdrc //left int i = 0; wdrc_p._p.wdrc[i].attacktime = 1; wdrc_p._p.wdrc[i].releasetime = 500; memcpy(wdrc_p._p.wdrc[i].threshold, threshold, sizeof(threshold)); wdrc_p._p.wdrc[i].threshold_num = ARRAY_SIZE(threshold); wdrc_p._p.wdrc[i].rms_time = 25; wdrc_p._p.wdrc[i].algorithm = 0; wdrc_p._p.wdrc[i].mode = 1; info->R_pch = info->pch = &wdrc_p; return 0; } u8 left_or_right_earphone() { #if 0//TCFG_USER_TWS_ENABLE if (config_wdrc_en) { u8 channel = 0; int state = 0; u8 dac_connect_mode; state = tws_api_get_tws_state(); if (state & TWS_STA_SIBLING_CONNECTED) { dac_connect_mode = audio_dac_get_channel(&dac_hdl); if (dac_connect_mode == DAC_OUTPUT_LR) { if (tws_api_get_local_channel() == 'L') { channel |= LL_wdrc; } else { channel |= RR_wdrc; } } else { if (tws_api_get_local_channel() == 'L') { channel |= L_wdrc; } else { channel |= R_wdrc; } } } return channel; } #endif return 0; } void *dec_eq_drc_setup(void *priv, int (*eq_output_cb)(void *, void *, int), u32 sample_rate, u8 channel, u8 async, u8 drc_en) { #if TCFG_EQ_ENABLE if (config_eq_lite_en) { //仅支持同步方式eq处理 async = 0;// } #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG async = 0; #endif #if defined(AUDIO_GAME_EFFECT_CONFIG) && AUDIO_GAME_EFFECT_CONFIG if (drc_en & BIT(1)) { //game eff drc return dec_eq_drc_setup_new(priv, eq_output_cb, sample_rate, channel, async, drc_en); } #endif/* AUDIO_GAME_EFFECT_CONFIG */ struct dec_eq_drc *eff = zalloc(sizeof(struct dec_eq_drc)); struct audio_eq_param eq_param = {0}; eff->priv = priv; eff->out_cb = eq_output_cb; eq_param.channels = channel; eq_param.online_en = 1; eq_param.mode_en = 1; eq_param.remain_en = 1; eq_param.no_wait = async; if (drc_en) { eq_param.out_32bit = 1; } eq_param.max_nsection = EQ_SECTION_MAX; eq_param.cb = eq_get_filter_info; eq_param.eq_name = song_eq_mode; eq_param.sr = sample_rate; eq_param.priv = eff; eq_param.output = eq_output; eff->eq = audio_dec_eq_open(&eq_param); eff->async = async; #if TCFG_DRC_ENABLE if (drc_en) { struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = channel | left_or_right_earphone(); drc_param.online_en = 1; drc_param.remain_en = 1; drc_param.out_32bit = 1; drc_param.cb = drc_get_filter_info; drc_param.drc_name = song_eq_mode; eff->drc = audio_dec_drc_open(&drc_param); } #endif//TCFG_DRC_ENABLE #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG eff->spk_eq = spk_eq_open(sample_rate, channel, drc_en ? 1 : 0); #endif/*AUDIO_SPK_EQ_CONFIG*/ return eff; #else return NULL; #endif//TCFG_EQ_ENABLE } void dec_eq_drc_free(void *eff) { #if TCFG_EQ_ENABLE struct dec_eq_drc *eff_hdl = (struct dec_eq_drc *)eff; if (!eff_hdl) { return; } u8 tmp = 0; if (eff_hdl->drc_bef_eq) { tmp = 1; } if (eff_hdl->drc_prev) { audio_dec_drc_close(eff_hdl->drc_prev); eff_hdl->drc_prev = NULL; } 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; } #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG if (eff_hdl->spk_eq) { spk_eq_close(eff_hdl->spk_eq); eff_hdl->spk_eq = NULL; } #endif if (eff_hdl->eq_out_buf) { free(eff_hdl->eq_out_buf); eff_hdl->eq_out_buf = NULL; } #if AUDIO_EQ_FADE_EN if (eff_hdl->fade.tmr) { sys_hi_timer_del(eff_hdl->fade.tmr); eff_hdl->fade.tmr = 0; } #endif free(eff_hdl); if (tmp) { //还原非游戏音效eq drc 效果 EQ_CFG *eq_cfg = get_eq_cfg_hdl(); eq_cfg->eq_type = EQ_TYPE_MODE_TAB; eq_cfg_default_init(get_eq_cfg_hdl()); drc_default_init(get_eq_cfg_hdl(), song_eq_mode); if (!eq_file_get_cfg(get_eq_cfg_hdl(), (u8 *)SDFILE_RES_ROOT_PATH"eq_cfg_hw.bin")) { eq_cfg->eq_type = EQ_TYPE_FILE; } } #endif//TCFG_EQ_ENABLE } struct drc_ch esco_drc_p = {0}; int esco_drc_get_filter_info(void *drc, struct audio_drc_filter_info *info) { float th = -0.5f;//db -60db~0db,限幅器阈值 int threshold = roundf(powf(10.0f, th / 20.0f) * 32768); esco_drc_p.nband = 1; esco_drc_p.type = 1; esco_drc_p._p.limiter[0].attacktime = 5; esco_drc_p._p.limiter[0].releasetime = 500; esco_drc_p._p.limiter[0].threshold[0] = threshold; esco_drc_p._p.limiter[0].threshold[1] = 32768; info->R_pch = info->pch = &esco_drc_p; return 0; } void *esco_eq_drc_setup(void *priv, int (*eq_output_cb)(void *, void *, int), u32 sample_rate, u8 channel, u8 async, u8 drc_en) { #if TCFG_EQ_ENABLE && TCFG_PHONE_EQ_ENABLE if (config_eq_lite_en) { //仅支持同步方式eq处理 async = 0;// } struct dec_eq_drc *eff = zalloc(sizeof(struct dec_eq_drc)); #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG eff->spk_eq = spk_eq_open(sample_rate, channel, drc_en ? 1 : 0); #endif/*AUDIO_SPK_EQ_CONFIG*/ struct audio_eq_param eq_param = {0}; eff->priv = priv; eff->out_cb = eq_output_cb; eq_param.channels = channel; eq_param.online_en = 1; eq_param.mode_en = 0; eq_param.remain_en = 0; eq_param.no_wait = async;//a2dp_low_latency ? 0 : 1; if (drc_en) { eq_param.out_32bit = 1; } eq_param.max_nsection = EQ_SECTION_MAX; eq_param.cb = eq_phone_get_filter_info; eq_param.eq_name = call_eq_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 if (drc_en) { struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = channel; drc_param.online_en = 0; drc_param.remain_en = 0; drc_param.out_32bit = 1; drc_param.cb = esco_drc_get_filter_info; drc_param.drc_name = call_eq_mode; eff->drc = audio_dec_drc_open(&drc_param); eff->async = async; } #endif//TCFG_DRC_ENABLE return eff; #else return NULL; #endif//TCFG_EQ_ENABLE && TCFG_PHONE_EQ_ENABLE } void esco_eq_drc_free(void *eff) { dec_eq_drc_free(eff); } #define audio_out_drc_get_filter esco_drc_get_filter_info//可复用通话下行限幅器系数 void *audio_out_eq_drc_setup(void *priv, int (*eq_output_cb)(void *, void *, int), u32 sample_rate, u8 channel, u8 async, u8 drc_en) { #if TCFG_EQ_ENABLE &&AUDIO_OUT_EQ_USE_SPEC_NUM if (config_eq_lite_en) { //仅支持同步方式eq处理 async = 0;// } struct dec_eq_drc *eff = zalloc(sizeof(struct dec_eq_drc)); struct audio_eq_param eq_param = {0}; eff->priv = priv; eff->out_cb = eq_output_cb; eq_param.channels = channel; eq_param.online_en = 0; eq_param.mode_en = 0; eq_param.remain_en = 0; eq_param.no_wait = async; if (drc_en) { eq_param.out_32bit = 1; } eq_param.max_nsection = AUDIO_OUT_EQ_USE_SPEC_NUM; eq_param.cb = audio_out_eq_get_filter_info; eq_param.eq_name = song_eq_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 if (drc_en) { struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = channel; drc_param.online_en = 0; drc_param.remain_en = 0; drc_param.out_32bit = 1; drc_param.cb = audio_out_drc_get_filter; drc_param.drc_name = song_eq_mode; eff->drc = audio_dec_drc_open(&drc_param); eff->async = async; } #endif //TCFG_DRC_ENABLE return eff; #else return NULL; #endif//TCFG_EQ_ENABLE &&AUDIO_OUT_EQ_USE_SPEC_NUM } void audio_out_eq_drc_free(void *eff) { #if AUDIO_OUT_EQ_USE_SPEC_NUM dec_eq_drc_free(eff); #endif//AUDIO_OUT_EQ_USE_SPEC_NUM } __attribute__((always_inline)) void sat16_to_sat32(s16 *in, s32 *out, u32 npoint, int factor) { #if 0 for (int i = 0; i < npoint; i ++) { out[i] = in[i] * factor; } #else s64 tmp; __asm__ volatile( "1: \n\t" "rep %2 { \n\t" //循环 "%3 = h[%1 ++= 2]*%4(s) \n\t" "[%0 ++= 4] = %3.l \n\t" //%3.l意思是取tmp的低32位 "} \n\t" "if(%2 != 0) goto 1b \n\t" : "=&r"(out), "=&r"(in), "=&r"(npoint), "=&r"(tmp) : "r"(factor), "0"(out), "1"(in), "2"(npoint), "3"(tmp) : ); #endif } int eq_drc_run(void *priv, void *data, u32 len) { #if TCFG_EQ_ENABLE struct dec_eq_drc *eff = (struct dec_eq_drc *)priv; if (!eff) { return 0; } #if TCFG_AUDIO_CVP_DUT_ENABLE if (audio_dec_dut_en_get(1) == AUDIO_DEC_DUT_MODE_SPK_EQ) { #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG spk_eq_run(eff->spk_eq, data, data, len); return 0; #endif } #endif/*TCFG_AUDIO_CVP_DUT_ENABLE*/ #if defined(TCFG_AUDIO_DAC_24BIT_MODE) && TCFG_AUDIO_DAC_24BIT_MODE if (!eff->async) { if (eff->eq_out_buf && (eff->eq_out_points < eff->eq_out_total)) { eq_32bit_out(eff); if (eff->eq_out_points < eff->eq_out_total) { return 0; } } } #endif #if TCFG_DRC_ENABLE if (eff->drc && !eff->async) {//同步32bit eq drc 处理 if ((!eff->eq_out_buf) || (eff->eq_out_buf_len < len * 2)) { if (eff->eq_out_buf) { free(eff->eq_out_buf); } eff->eq_out_buf_len = len * 2; eff->eq_out_buf = malloc(eff->eq_out_buf_len); ASSERT(eff->eq_out_buf); } audio_eq_set_output_buf(eff->eq, eff->eq_out_buf, len); if (eff->drc_bef_eq && eff->drc_prev) { sat16_to_sat32((short *)data, (int *)eff->eq_out_buf, len >> 1, 1); audio_drc_run(eff->drc_prev, eff->eq_out_buf, len * 2); } } #endif//TCFG_DRC_ENABLE int eqlen = 0; if (eff->drc_bef_eq) { eqlen = audio_eq_run(eff->eq, eff->eq_out_buf, len * 2); } else { eqlen = audio_eq_run(eff->eq, data, len); } #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG if (!eff->async) { if (eff->drc) { spk_eq_run(eff->spk_eq, eff->eq_out_buf, eff->eq_out_buf, len * 2); } else { spk_eq_run(eff->spk_eq, data, data, len); } } #endif #if TCFG_DRC_ENABLE if (eff->drc && !eff->async) {//同步32bit eq drc 处理 audio_drc_run(eff->drc, eff->eq_out_buf, len * 2); #if defined(TCFG_AUDIO_DAC_24BIT_MODE) && TCFG_AUDIO_DAC_24BIT_MODE eff->eq_out_points = 0; eff->eq_out_total = (len * 2) / 4; eq_32bit_out(eff); return len;//返回16bit位宽长度 #else user_sat16((s32 *)eff->eq_out_buf, (s16 *)data, (len * 2) / 4); #endif } #endif//TCFG_DRC_ENABLE if (eff->drc && !eff->async) { return len; } return eqlen; #else return len; #endif } #if AUDIO_OUT_EQ_USE_SPEC_NUM static struct eq_seg_info audio_out_eq_tab[AUDIO_OUT_EQ_USE_SPEC_NUM] = { #ifdef EQ_CORE_V1 {0, EQ_IIR_TYPE_BAND_PASS, 125, 0, 0.7f}, {1, EQ_IIR_TYPE_BAND_PASS, 12000, 0, 0.3f}, #else {0, EQ_IIR_TYPE_BAND_PASS, 125, 0 * (1 << 20), 0.7f * (1 << 24)}, {1, EQ_IIR_TYPE_BAND_PASS, 12000, 0 * (1 << 20), 0.3f * (1 << 24)}, #endif }; int audio_out_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_out_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_out_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; } int audio_out_eq_spec_set_info(struct audio_eq *eq, u8 idx, int freq, float gain) { if (idx >= AUDIO_OUT_EQ_USE_SPEC_NUM) { return false; } if (gain > 12) { gain = 12; } if (gain < -12) { gain = -12; } if (freq) { audio_out_eq_tab[idx].freq = freq; } #ifdef EQ_CORE_V1 audio_out_eq_tab[idx].gain = gain; #else audio_out_eq_tab[idx].gain = gain * (1 << 20); #endif /* printf("audio out eq, idx:%d, freq:%d,%d, gain:%d,%d \n", idx, freq, audio_out_eq_tab[idx].freq, gain, audio_out_eq_tab[idx].gain); */ #if !AUDIO_EQ_FADE_EN local_irq_disable(); if (eq) { eq->updata = 1; } local_irq_enable(); #endif return true; } #if AUDIO_EQ_FADE_EN void eq_fade_run(void *p) { struct dec_eq_drc *eff = (struct dec_eq_drc *)p; struct eq_filter_fade *fade = &eff->fade; struct audio_eq *eq = (struct audio_eq *)eff->eq; u8 update = 0; u8 design = 0; for (int i = 0; i < ARRAY_SIZE(audio_out_eq_tab); i++) { if (fade->cur_gain[i] > fade->use_gain[i]) { #ifdef EQ_CORE_V1 fade->cur_gain[i] -= HIGH_BASS_EQ_FADE_STEP; #else fade->cur_gain[i] -= HIGH_BASS_EQ_FADE_STEP * (1 << 20); #endif if (fade->cur_gain[i] < fade->use_gain[i]) { fade->cur_gain[i] = fade->use_gain[i]; } design = 1; } else if (fade->cur_gain[i] < fade->use_gain[i]) { #ifdef EQ_CORE_V1 fade->cur_gain[i] += HIGH_BASS_EQ_FADE_STEP; #else fade->cur_gain[i] += HIGH_BASS_EQ_FADE_STEP * (1 << 20); #endif if (fade->cur_gain[i] > fade->use_gain[i]) { fade->cur_gain[i] = fade->use_gain[i]; } design = 1; } if (design) { design = 0; update = 1; /* audio_out_eq_spec_set_info(p, i, 0, fade->cur_gain[i]); */ /* if (eq) { */ audio_out_eq_tab[i].gain = fade->cur_gain[i];//gain;//gain << 20; /* } */ } } if (update) { update = 0; local_irq_disable(); if (eq) { eq->updata = 1; } local_irq_enable(); } } #endif int audio_out_eq_set_gain(void *eff, u8 idx, int gain) { struct dec_eq_drc *eff_hdl = (struct dec_eq_drc *)eff; if (!eff_hdl) { return 0; } if (!idx) { idx = 0; } else { idx = 1; } #if AUDIO_EQ_FADE_EN eff_hdl->fade.use_gain[idx] = gain; if (eff_hdl->fade.tmr == 0) { eff_hdl->fade.tmr = sys_hi_timer_add(eff_hdl, eq_fade_run, 20); } #else if (!idx) { audio_out_eq_spec_set_info(eff_hdl->eq, 0, 0, gain);//低音 } else { audio_out_eq_spec_set_info(eff_hdl->eq, 1, 0, gain);//高音 } #endif return true; } #endif /*AUDIO_OUT_EQ_USE_SPEC_NUM*/ static struct audio_drc *mix_out_drc = NULL; static float mix_out_drc_threadhold = -0.5f;//db -60db~0db,限幅器阈值 static struct drc_ch mix_out_drc_p = {0}; int mix_out_drc_get_filter_info(void *drc, struct audio_drc_filter_info *info) { float th = mix_out_drc_threadhold;//db -60db~0db,限幅器阈值 int threshold = roundf(powf(10.0f, th / 20.0f) * 32768); mix_out_drc_p.nband = 1; mix_out_drc_p.type = 1; mix_out_drc_p._p.limiter[0].attacktime = 5; mix_out_drc_p._p.limiter[0].releasetime = 500; mix_out_drc_p._p.limiter[0].threshold[0] = threshold; mix_out_drc_p._p.limiter[0].threshold[1] = 32768; info->R_pch = info->pch = &mix_out_drc_p; return 0; } void mix_out_drc_open(u16 sample_rate) { u8 ch_num; #if TCFG_APP_FM_EMITTER_EN ch_num = 2; #else u8 dac_connect_mode = audio_dac_get_channel(&dac_hdl); if (dac_connect_mode == DAC_OUTPUT_LR) { ch_num = 2; } else { ch_num = 1; } #endif//TCFG_APP_FM_EMITTER_EN #if TCFG_DRC_ENABLE struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = ch_num; drc_param.online_en = 0; drc_param.remain_en = 0; drc_param.out_32bit = 0; drc_param.cb = mix_out_drc_get_filter_info; drc_param.drc_name = song_eq_mode; mix_out_drc = audio_dec_drc_open(&drc_param); #endif//TCFG_DRC_ENABLE } void mix_out_drc_close() { #if TCFG_DRC_ENABLE if (mix_out_drc) { audio_dec_drc_close(mix_out_drc); mix_out_drc = NULL; } #endif//TCFG_DRC_ENABLE } void mix_out_drc_run(s16 *data, u32 len) { u8 en = 1; #if TCFG_DRC_ENABLE #if TCFG_AUDIO_ANC_ENABLE en = anc_status_get(); #endif/*TCFG_AUDIO_ANC_ENABLE*/ if (mix_out_drc && en) { audio_drc_run(mix_out_drc, data, len); } #endif//TCFG_DRC_ENABLE } /*----------------------------------------------------------------------------*/ /**@brief mix_out后限幅器系数更新 @param threadhold限幅器阈值，-60~0,单位db @return @note */ /*----------------------------------------------------------------------------*/ void mix_out_drc_threadhold_update(float threadhold) { #if TCFG_DRC_ENABLE mix_out_drc_threadhold = threadhold; local_irq_disable(); if (mix_out_drc) { mix_out_drc->updata = 1; } local_irq_enable(); #endif//TCFG_DRC_ENABLE } struct audio_eq *audio_dec_eq_open_new(struct audio_eq_param *parm, struct eq_parm_new *par_new) { struct audio_eq_param *eq_param = parm; struct audio_eq *eq = zalloc(sizeof(struct audio_eq) + sizeof(struct hw_eq_ch)); if (eq) { eq->eq_ch = (struct hw_eq_ch *)((int)eq + sizeof(struct audio_eq)); audio_eq_open(eq, eq_param); audio_eq_set_samplerate(eq, eq_param->sr); audio_eq_set_info_new(eq, eq_param->channels, par_new->in_mode, eq_param->out_32bit, par_new->run_mode, par_new->data_in_mode, par_new->data_out_mode); /* log_info("eq_param->sr %d, eq_param->channels %d\n", eq_param->sr, eq_param->channels); */ audio_eq_set_output_handle(eq, eq_param->output, eq_param->priv); audio_eq_start(eq); /* log_info("audio_dec_eq_open name %d\n", eq_param->eq_name); */ } return eq; } #if defined(AUDIO_GAME_EFFECT_CONFIG) && AUDIO_GAME_EFFECT_CONFIG struct drc_ch dec_drc_p = {0}; int dec_drc_get_filter_info(void *drc, struct audio_drc_filter_info *info) { float th = -0.5f;//db -60db~0db,限幅器阈值 int threshold = roundf(powf(10.0f, th / 20.0f) * 32768); dec_drc_p.nband = 1; dec_drc_p.type = 1; dec_drc_p._p.limiter[0].attacktime = 5; dec_drc_p._p.limiter[0].releasetime = 500; dec_drc_p._p.limiter[0].threshold[0] = threshold; dec_drc_p._p.limiter[0].threshold[1] = 32768; info->R_pch = info->pch = &dec_drc_p; return 0; } void *dec_eq_drc_setup_new(void *priv, int (*eq_output_cb)(void *, void *, int), u32 sample_rate, u8 channel, u8 async, u8 drc_en) { #if TCFG_EQ_ENABLE struct dec_eq_drc *eff = zalloc(sizeof(struct dec_eq_drc)); if (config_eq_lite_en) { //仅支持同步方式eq处理 async = 0;// } #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG eff->spk_eq = spk_eq_open(sample_rate, channel, drc_en ? 1 : 0); #endif/*AUDIO_SPK_EQ_CONFIG*/ #if TCFG_DRC_ENABLE if (drc_en & BIT(1)) { //game eff drc if (!eq_file_get_cfg(get_eq_cfg_hdl(), (u8 *)SDFILE_RES_ROOT_PATH"eq_game_eff.bin")) { //加载游戏音效 EQ_CFG *eq_cfg = get_eq_cfg_hdl(); eq_cfg->eq_type = EQ_TYPE_FILE; } eff->drc_bef_eq = 1; async = 0; struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = channel; drc_param.online_en = 1; drc_param.remain_en = 1; drc_param.out_32bit = 1; drc_param.cb = drc_get_filter_info; drc_param.drc_name = song_eq_mode; eff->drc_prev = audio_dec_drc_open(&drc_param); } #endif//TCFG_DRC_ENABLE eff->priv = priv; eff->out_cb = eq_output_cb; struct audio_eq_param eq_param = {0}; eq_param.channels = channel; eq_param.online_en = 1; eq_param.mode_en = 1; eq_param.remain_en = 1; eq_param.no_wait = async; if (drc_en) { eq_param.out_32bit = 1; } eq_param.max_nsection = EQ_SECTION_MAX; eq_param.cb = eq_get_filter_info; eq_param.eq_name = song_eq_mode; eq_param.sr = sample_rate; eq_param.priv = eff; eq_param.output = eq_output; struct eq_parm_new par_new = {0}; par_new.in_mode = DATI_INT; par_new.run_mode = NORMAL; par_new.data_in_mode = SEQUENCE_DAT_IN; par_new.data_out_mode = SEQUENCE_DAT_OUT; eff->eq = audio_dec_eq_open_new(&eq_param, &par_new); eff->async = async; #if TCFG_DRC_ENABLE if (drc_en) { struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = channel; if (eff->drc_bef_eq) { drc_param.online_en = 0; drc_param.remain_en = 0; drc_param.out_32bit = 1; drc_param.cb = dec_drc_get_filter_info; drc_param.drc_name = mic_eq_mode; } else { drc_param.online_en = 1; drc_param.remain_en = 1; drc_param.out_32bit = 1; drc_param.cb = drc_get_filter_info; drc_param.drc_name = song_eq_mode; } eff->drc = audio_dec_drc_open(&drc_param); } #endif//TCFG_DRC_ENABLE return eff; #else return NULL; #endif//TCFG_EQ_ENABLE } #endif /*AUDIO_GAME_EFFECT_CONFIG*/ #if TCFG_AUDIO_ESCO_LIMITER_ENABLE #if !TCFG_DRC_ENABLE #error "需打开宏TCFG_DRC_ENABLE" #endif #ifndef ESCO_DL_LIMITER_THR #define ESCO_DL_LIMITER_THR 0 #endif static struct drc_ch esco_drc = {0}; int esco_limiter_get_filter_info(void *drc, struct audio_drc_filter_info *info) { float th = ESCO_DL_LIMITER_THR;//db -60db~0db,限幅器阈值 int threshold = roundf(powf(10.0f, th / 20.0f) * 32768); esco_drc.nband = 1; esco_drc.type = 1; esco_drc._p.limiter[0].attacktime = 5; esco_drc._p.limiter[0].releasetime = 500; esco_drc._p.limiter[0].threshold[0] = threshold; esco_drc._p.limiter[0].threshold[1] = 32768; info->R_pch = info->pch = &esco_drc; return 0; } struct audio_drc *esco_limiter_open(u16 sample_rate, u16 ch_num) { #if TCFG_DRC_ENABLE struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = ch_num; drc_param.cb = esco_limiter_get_filter_info; drc_param.drc_name = call_eq_mode; return audio_dec_drc_open(&drc_param); #else return NULL; #endif//TCFG_DRC_ENABLE } void esco_limiter_close(struct audio_drc *limiter) { #if TCFG_DRC_ENABLE if (limiter) { audio_dec_drc_close(limiter); limiter = NULL; } #endif//TCFG_DRC_ENABLE } void esco_limiter_run(struct audio_drc *limiter, s16 *data, u32 len) { #if TCFG_DRC_ENABLE if (limiter) { audio_drc_run(limiter, data, len); } #endif//TCFG_DRC_ENABLE } #endif/*TCFG_AUDIO_ESCO_LIMITER_ENABLE*/ #if defined(AUDIO_SPK_EQ_CONFIG) && AUDIO_SPK_EQ_CONFIG #define AUDIO_SPK_EQ_STERO 1//支持左右声道独立的spk_eq /* *spk_eq系数表 * */ static struct eq_seg_info spk_eq_seg_tab[] = { /*L*/ {0, EQ_IIR_TYPE_BAND_PASS, 31, 0, 0.7f}, {1, EQ_IIR_TYPE_BAND_PASS, 62, 0, 0.7f}, {2, EQ_IIR_TYPE_BAND_PASS, 125, 0, 0.7f}, {3, EQ_IIR_TYPE_BAND_PASS, 250, 0, 0.7f}, {4, EQ_IIR_TYPE_BAND_PASS, 500, 0, 0.7f}, {5, EQ_IIR_TYPE_BAND_PASS, 1000, 0, 0.7f}, {6, EQ_IIR_TYPE_BAND_PASS, 2000, 0, 0.7f}, {7, EQ_IIR_TYPE_BAND_PASS, 4000, 0, 0.7f}, {8, EQ_IIR_TYPE_BAND_PASS, 8000, 0, 0.7f}, {9, EQ_IIR_TYPE_BAND_PASS, 16000, 0, 0.7f}, #if AUDIO_SPK_EQ_STERO /*R*/ {0, EQ_IIR_TYPE_BAND_PASS, 31, 0, 0.7f}, {1, EQ_IIR_TYPE_BAND_PASS, 62, 0, 0.7f}, {2, EQ_IIR_TYPE_BAND_PASS, 125, 0, 0.7f}, {3, EQ_IIR_TYPE_BAND_PASS, 250, 0, 0.7f}, {4, EQ_IIR_TYPE_BAND_PASS, 500, 0, 0.7f}, {5, EQ_IIR_TYPE_BAND_PASS, 1000, 0, 0.7f}, {6, EQ_IIR_TYPE_BAND_PASS, 2000, 0, 0.7f}, {7, EQ_IIR_TYPE_BAND_PASS, 4000, 0, 0.7f}, {8, EQ_IIR_TYPE_BAND_PASS, 8000, 0, 0.7f}, {9, EQ_IIR_TYPE_BAND_PASS, 16000, 0, 0.7f} #endif }; #if AUDIO_SPK_EQ_STERO static struct eq_seg_info *spk_eq_seg_tab_R = &spk_eq_seg_tab[10]; #endif /* *spk_eq系数表运算后存放的buf * */ static float spk_eq_coeff_tab[10][5]; static float spk_eq_coeff_tab_R[10][5]; /* *spk_eq 总增益 * */ static float spk_eq_global_gain[2] = {0};//[0]：左声道 [1]:右声道 static u32 seg_sel = 0; static u32 seg_sel_R = 0; static u32 spk_eq_sample_rate = 0; /* *spk_eq系数回调函数 * */ int spk_eq_get_filter_info(void *_eq, int sr, struct audio_eq_filter_info *info) { struct audio_eq *eq = _eq; if (!sr) { sr = spk_eq_sample_rate; } u8 ch_num; #if TCFG_APP_FM_EMITTER_EN ch_num = 2; #else u8 dac_connect_mode = audio_dac_get_channel(&dac_hdl); if (dac_connect_mode == DAC_OUTPUT_LR) { ch_num = 2; } else { ch_num = 1; } #endif//TCFG_APP_FM_EMITTER_EN local_irq_disable(); u8 cnt = 1; #if AUDIO_SPK_EQ_STERO cnt = 2; #endif u8 nsection = ARRAY_SIZE(spk_eq_seg_tab) / cnt; for (int i = 0; i < nsection; i++) { if (seg_sel & BIT(i)) { seg_sel &= ~BIT(i); eq_seg_design(&spk_eq_seg_tab[i], sr, &spk_eq_coeff_tab[i]); /* float *tar_buf = &spk_eq_coeff_tab[i]; */ /* printf("cal coeff:0x%x, 0x%x, 0x%x, 0x%x, 0x%x " */ /* , *(int *)&tar_buf[0] */ /* , *(int *)&tar_buf[1] */ /* , *(int *)&tar_buf[2] */ /* , *(int *)&tar_buf[3] */ /* , *(int *)&tar_buf[4] */ /* ); */ } #if AUDIO_SPK_EQ_STERO if (ch_num == 2) { if (seg_sel_R & BIT(i)) { seg_sel_R &= ~BIT(i); eq_seg_design(&spk_eq_seg_tab_R[i], sr, &spk_eq_coeff_tab_R[i]); } } #endif } /* printf("spk_eq_global_gain[0] %d\n",(int)spk_eq_global_gain[0]); */ /* printf("spk_eq_global_gain[1] %d\n",(int)spk_eq_global_gain[1]); */ local_irq_enable(); #if AUDIO_SPK_EQ_STERO if (ch_num == 2) { info->L_coeff = (void *)spk_eq_coeff_tab;//系数指针赋值 info->R_coeff = (void *)spk_eq_coeff_tab_R;//系数指针赋值 info->L_gain = spk_eq_global_gain[0];//总增益填写，用户可修改（-20~20db） info->R_gain = spk_eq_global_gain[1];//总增益填写，用户可修改（-20~20db） } else #endif { info->L_coeff = info->R_coeff = (void *)spk_eq_coeff_tab;//系数指针赋值 info->L_gain = info->R_gain = spk_eq_global_gain[0];//总增益填写，用户可修改（-20~20db） } info->nsection = nsection;//eq段数，根据提供给的系数表来填写，例子是2 return 0; } static struct audio_eq *spk_eq = NULL; /* *spk_eq 系数更新接口,更新第几段eq系数 *parm: *seg *seg->index:第几段(0~9) *seg->iir_type:滤波器类型(EQ_IIR_TYPE) *seg->freq:中心截止频率(20~20kHz) *seg->gain:增益（-12~13dB） * */ void spk_eq_seg_update(struct eq_seg_info *seg) { if (!seg) { log_e("spk_eq seg null\n"); return ; } u8 i = seg->index; u8 cnt = 1; #if AUDIO_SPK_EQ_STERO cnt = 2; #endif if (i >= ARRAY_SIZE(spk_eq_seg_tab) / cnt) { log_e("spk_eq index err: %d >= %d\n", seg->index, ARRAY_SIZE(spk_eq_seg_tab) / cnt); return ; } local_irq_disable(); memcpy(&spk_eq_seg_tab[i], seg, sizeof(struct eq_seg_info)); seg_sel |= BIT(i); if (spk_eq) { struct audio_eq *eq = spk_eq; eq->updata = 1;//设置更新标志 } local_irq_enable(); } /* *spk_eq 右声道系数更新接口,更新第几段eq系数 *parm: *seg *seg->index:第几段(0~9) *seg->iir_type:滤波器类型(EQ_IIR_TYPE) *seg->freq:中心截止频率(20~20kHz) *seg->gain:增益（-12~13dB） * */ void spk_eq_seg_update_R(struct eq_seg_info *seg) { u8 cnt = 1; #if AUDIO_SPK_EQ_STERO if (!seg) { log_e("spk_eq seg null\n"); return ; } u8 i = seg->index; cnt = 2; if (i >= ARRAY_SIZE(spk_eq_seg_tab) / cnt) { log_e("spk_eq index err: %d >= %d\n", seg->index, ARRAY_SIZE(spk_eq_seg_tab) / cnt); return ; } local_irq_disable(); memcpy(&spk_eq_seg_tab_R[i], seg, sizeof(struct eq_seg_info)); seg_sel_R |= BIT(i); if (spk_eq) { struct audio_eq *eq = spk_eq; eq->updata = 1;//设置更新标志 } local_irq_enable(); #endif } /* *spk_eq 总增益更新 * */ void spk_eq_global_gain_udapte(float global_gain) { spk_eq_global_gain[0] = global_gain; local_irq_disable(); if (spk_eq) { /* printf("spk_eq_global_gain[L] %d\n",(int)spk_eq_global_gain[0]); */ struct audio_eq *eq = spk_eq; eq->updata = 1;//设置更新标志 } local_irq_enable(); } void spk_eq_global_gain_udapte_R(float global_gain) { spk_eq_global_gain[1] = global_gain; local_irq_disable(); if (spk_eq) { /* printf("spk_eq_global_gain[R] %d\n",(int)spk_eq_global_gain[1]); */ struct audio_eq *eq = spk_eq; eq->updata = 1;//设置更新标志 } local_irq_enable(); } /* *spk_eq 打开 * */ void *spk_eq_open(u32 sample_rate, u8 ch_num, u8 bitwide) { #if TCFG_AUDIO_CVP_DUT_ENABLE //DEC_DUT模式默认仅保留spk_eq, 因此改为16bit位宽 if (audio_dec_dut_en_get(1) == AUDIO_DEC_DUT_MODE_SPK_EQ) { bitwide = 0; } #endif/*TCFG_AUDIO_CVP_DUT_ENABLE*/ spk_eq_sample_rate = sample_rate; seg_sel = 0xffff; seg_sel_R = 0xffff; struct audio_eq_param eq_param = {0}; eq_param.channels = ch_num; eq_param.max_nsection = EQ_SECTION_MAX; eq_param.cb = spk_eq_get_filter_info; eq_param.eq_name = song_eq_mode; eq_param.sr = sample_rate; eq_param.out_32bit = bitwide ? 1 : 0; struct eq_parm_new par_new = {0}; par_new.in_mode = bitwide ? DATI_INT : DATI_SHORT; par_new.run_mode = NORMAL; par_new.data_in_mode = SEQUENCE_DAT_IN; par_new.data_out_mode = SEQUENCE_DAT_OUT; void *eq = audio_dec_eq_open_new(&eq_param, &par_new); local_irq_disable(); spk_eq = eq;//记录spk_eq 指针,用于系数更新调用 local_irq_enable(); /* sys_timer_add(NULL, spk_eq_global_gain_udpate_test, 5000); */ /* sys_timer_add(NULL,spk_eq_seg_udpate_test , 5000); */ return eq; } /* *spk_eq 关闭 * */ void spk_eq_close(void *eq) { if (eq) { local_irq_disable(); spk_eq = NULL; local_irq_enable(); audio_dec_eq_close(eq); } } /* *spk_eq 数据处理 * */ void spk_eq_run(void *eq, void *in, void *out, u16 len) { if (!eq) { return ; } audio_eq_set_output_buf(eq, out, len); audio_eq_run(eq, in, len); } /* *spk_eq 系数表保存到vm * */ int spk_eq_save_to_vm(void) { int ret_tmp = 0; /* puts("====jj===========to save \n"); */ /* printf("sizeof(spk_eq_seg_tab) %d, %d\n", sizeof(spk_eq_seg_tab), sizeof(float)); */ /* printf("%d %d\n", CFG_SPK_EQ_SEG_SAVE, CFG_SPK_EQ_GLOBAL_GAIN_SAVE); */ int ret = syscfg_write(CFG_SPK_EQ_SEG_SAVE, spk_eq_seg_tab, sizeof(spk_eq_seg_tab)); if (ret <= 0) { printf("spk_eq tab write to vm err, ret %d\n", ret); ret_tmp = -1; } ret = syscfg_write(CFG_SPK_EQ_GLOBAL_GAIN_SAVE, spk_eq_global_gain, sizeof(spk_eq_global_gain)); if (ret <= 0) { printf("spk_eq global gain write to vm err ret %d\n", ret); ret_tmp = -1; } /* puts("===============to save end\n"); */ return ret_tmp; } /* *spk_eq 系数表从vm中读取 * */ void spk_eq_read_from_vm() { int ret = syscfg_read(CFG_SPK_EQ_SEG_SAVE, spk_eq_seg_tab, sizeof(spk_eq_seg_tab)); if (ret <= 0) { printf("skp_eq read from vm err\n"); } ret = syscfg_read(CFG_SPK_EQ_GLOBAL_GAIN_SAVE, spk_eq_global_gain, sizeof(spk_eq_global_gain)); if (ret <= 0) { printf("spk_eq global gain read from vm err\n"); } } /* typedef struct { */ /* u8 cmd; */ /* struct eq_seg_info seg; */ /* }spk_seg_info; */ /* typedef struct { */ /* u8 cmd; */ /* float global_gain; */ /* }spk_global_gain_info; */ typedef struct { u16 magic; //0x3344 u16 crc; //data crc u8 data[32]; //data } SPK_EQ_PACK; #define CMD_SEG 0x1 #define CMD_GLOBAL 0x2 #define CMD_SAVE_PARM 0x3 #define CMD_RESET_PARM 0x4 /* *右声道更新命令 * */ #define CMD_SEG_R 0x5 #define CMD_GLOBAL_R 0x6 #define CMD_SUPPORT_GLOBAL_GAIN 0x7 #define CMD_READ_SEG_L 0x8//左声道或者单声道获取系数表 #define CMD_READ_SEG_R 0x9//右声道获取系数表 #define CMD_READ_GLOBAL_L 0xa //左声道或者单声道获取总增益 #define CMD_READ_GLOBAL_R 0xb //右声道获取总增益 #define SPK_EQ_CRC_EN 0//是否使能crc校验 static u8 parse_seq = 0; void (*send_data_handler)(u8 seq, u8 *packet, u8 size); static spk_eq_ack_packet(u8 seq, u8 *packet, u8 size) { if (send_data_handler) { send_data_handler(seq, packet, size); } else { app_online_db_ack(seq, packet, size); } } int spk_eq_spp_rx_packet(u8 *packet, u8 len) { SPK_EQ_PACK pack = {0};//packet; memcpy(&pack, packet, len); if (pack.magic != 0x3344) { printf("magic err 0x%x\n", pack.magic); return -1; } struct eq_seg_info seg = {0}; float global_gain = 0; u8 cmd = pack.data[0]; u16 crc; printf("cmd %d\n", cmd); switch (cmd) { case CMD_SEG: #if SPK_EQ_CRC_EN crc = CRC16(pack.data, len - 4); if (crc != pack.crc) { printf("spk_seg pack crc err %x, %x\n", crc, pack.crc); return -1; } #endif memcpy(&seg, &pack.data[1], sizeof(struct eq_seg_info)); spk_eq_seg_update(&seg); printf("idx:%d, iir:%d, frq:%d, gain:0x%x, q:0x%x \n", seg.index, seg.iir_type, seg.freq, *(int *)&seg.gain, *(int *)&seg.q); break; case CMD_GLOBAL: #if SPK_EQ_CRC_EN crc = CRC16(pack.data, len - 4); if (crc != pack.crc) { printf("spk global gain info pack crc err %x, %x\n", crc, pack.crc); return -1; } #endif memcpy(&global_gain, &pack.data[1], sizeof(float)); spk_eq_global_gain_udapte(global_gain); printf("global_gain 0x%x\n", *(int *)&global_gain); break; case CMD_SEG_R: #if SPK_EQ_CRC_EN crc = CRC16(pack.data, len - 4); if (crc != pack.crc) { printf("spk_seg_r pack crc err %x, %x\n", crc, pack.crc); return -1; } #endif memcpy(&seg, &pack.data[1], sizeof(struct eq_seg_info)); spk_eq_seg_update_R(&seg); printf("R idx:%d, iir:%d, frq:%d, gain:0x%x, q:0x%x \n", seg.index, seg.iir_type, seg.freq, *(int *)&seg.gain, *(int *)&seg.q); break; case CMD_GLOBAL_R: #if SPK_EQ_CRC_EN crc = CRC16(pack.data, len - 4); if (crc != pack.crc) { printf("spk global gain info pack crc err %x, %x\n", crc, pack.crc); return -1; } #endif memcpy(&global_gain, &pack.data[1], sizeof(float)); spk_eq_global_gain_udapte_R(global_gain); printf("R global_gain 0x%x\n", *(int *)&global_gain); break; case CMD_SAVE_PARM: return spk_eq_save_to_vm(); break; case CMD_RESET_PARM: local_irq_disable(); u8 cnt = 1; #if AUDIO_SPK_EQ_STERO cnt = 2; #endif for (int i = 0; i < ARRAY_SIZE(spk_eq_seg_tab) / cnt; i++) { spk_eq_seg_tab[i].index = i; spk_eq_seg_tab[i].freq = 100; spk_eq_seg_tab[i].iir_type = EQ_IIR_TYPE_BAND_PASS; spk_eq_seg_tab[i].gain = 0.0f; spk_eq_seg_tab[i].q = 0.7f; seg_sel |= BIT(i); #if AUDIO_SPK_EQ_STERO spk_eq_seg_tab_R[i].index = i; spk_eq_seg_tab_R[i].freq = 100; spk_eq_seg_tab_R[i].iir_type = EQ_IIR_TYPE_BAND_PASS; spk_eq_seg_tab_R[i].gain = 0.0f; spk_eq_seg_tab_R[i].q = 0.7f; seg_sel_R |= BIT(i); #endif } local_irq_enable(); spk_eq_global_gain_udapte(0); spk_eq_global_gain_udapte_R(0); return spk_eq_save_to_vm(); break; case CMD_SUPPORT_GLOBAL_GAIN: //support global_gain break; case CMD_READ_SEG_L: spk_eq_ack_packet(parse_seq, spk_eq_seg_tab, sizeof(spk_eq_seg_tab) / 2); return 1; case CMD_READ_SEG_R: spk_eq_ack_packet(parse_seq, &spk_eq_seg_tab[10], sizeof(spk_eq_seg_tab) / 2); return 1; case CMD_READ_GLOBAL_L: spk_eq_ack_packet(parse_seq, &spk_eq_global_gain[0], 4); return 1; case CMD_READ_GLOBAL_R: spk_eq_ack_packet(parse_seq, &spk_eq_global_gain[1], 4); return 1; default: printf("crc %d\n", pack.crc); printf("cmd err %x\n", cmd); return -1; } return 0; } int spk_eq_read_seg_l(u8 **buf) { *buf = (u8 *)(&spk_eq_seg_tab[0]); return sizeof(spk_eq_seg_tab) / 2; } int spk_eq_read_seg_r(u8 **buf) { #if AUDIO_SPK_EQ_STERO *buf = (u8 *)(&spk_eq_seg_tab[10]); return sizeof(spk_eq_seg_tab) / 2; #else return 0; #endif } int spk_eq_app_online_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size) { if (ext_data) { parse_seq = ext_data[1]; } else { parse_seq = 0xff; } printf("parse_seq %x\n", parse_seq); int ret = spk_eq_spp_rx_packet(packet, size); if (!ret) { u8 ack[] = "OK"; spk_eq_ack_packet(parse_seq, ack, sizeof(ack)); /* spk_eq_ack_packet(parse_seq, packet, size); */ } else if (ret != 1) { u8 ack[] = "ER"; spk_eq_ack_packet(parse_seq, ack, sizeof(ack)); /* spk_eq_ack_packet(parse_seq, packet, size); */ } return 0; } void spk_eq_set_send_data_handler(void (*handler)(u8 seq, u8 *packet, u8 size)) { send_data_handler = handler; } int spk_eq_init(void) { #if APP_ONLINE_DEBUG app_online_db_register_handle(DB_PKT_TYPE_SPK_EQ, spk_eq_app_online_parse); #endif return 0; } __initcall(spk_eq_init); #endif/*AUDIO_SPK_EQ_CONFIG*/ #if defined(TCFG_AUDIO_BASS_BOOST) && TCFG_AUDIO_BASS_BOOST #if TCFG_AUDIO_BASS_BOOST_TEST static u8 bass_boost_run = 1; u8 test_bass_boost = 1; #else static u8 bass_boost_run = 1; #endif/*TCFG_AUDIO_BASS_BOOST_TEST*/ #if TCFG_AUDIO_BASS_BOOST_TEST #define TWS_FUNC_ID_BASS_EFF \ ((int)(('A' + '2' + 'D' + 'P') << (2 * 8)) | \ (int)(('E' + 'F' + 'F') << (1 * 8)) | \ (int)(('S' + 'Y' + 'N' + 'C') << (0 * 8))) void audio_bass_ctrl() { int state = tws_api_get_tws_state(); if (state & TWS_STA_SIBLING_CONNECTED) { test_bass_boost = !test_bass_boost; if (test_bass_boost) { //对耳链接，进入低音增强，播个提示音 /* tone_play_index(TONE_NORMAL, 1); */ } else { } tws_api_send_data_to_sibling((u8 *)&test_bass_boost, sizeof(int), TWS_FUNC_ID_BASS_EFF); } else { test_bass_boost = !test_bass_boost; bass_boost_run = test_bass_boost; } } static void tws_a2dp_eff_align_bass(void *data, u16 len, bool rx) { int a2dp_eff; memcpy(&a2dp_eff, data, sizeof(int)); bass_boost_run = a2dp_eff; test_bass_boost = bass_boost_run; } REGISTER_TWS_FUNC_STUB(a2dp_align_bass) = { .func_id = TWS_FUNC_ID_BASS_EFF, .func = tws_a2dp_eff_align_bass, }; #endif/*TCFG_AUDIO_BASS_BOOST_TEST*/ static int bass_boost_get_filter_info(void *drc, struct audio_drc_filter_info *info) { #if (TCFG_AUDIO_BASS_BOOST && TCFG_DRC_ENABLE) static struct drc_ch wdrc_p = {0}; struct threshold_group low_threshold[] = {//低频 {0, 0}, {79, 79}, {140, 80}, }; struct threshold_group mid_threshold[] = {//中频 {0, 0}, {82, 82}, {140, 82} }; wdrc_p.nband = 2; wdrc_p.type = 3;//wdrc wdrc_p.low_freq = 90; //低中分频点 （20~600hz） wdrc_p.high_freq = 2000;//中高分频点 (0~20000hz) wdrc_p.order = 2;////分频阶数 2或者4 int i = 0; //低频 wdrc_p._p.wdrc[0].attacktime = 10; wdrc_p._p.wdrc[0].releasetime = 100; memcpy(wdrc_p._p.wdrc[0].threshold, low_threshold, sizeof(low_threshold)); wdrc_p._p.wdrc[0].threshold_num = ARRAY_SIZE(low_threshold); wdrc_p._p.wdrc[0].rms_time = 25; wdrc_p._p.wdrc[0].algorithm = 0; wdrc_p._p.wdrc[0].mode = 1; wdrc_p._p.wdrc[0].inputgain = 0; wdrc_p._p.wdrc[0].outputgain = 8; //高频 //right wdrc_p._p.wdrc[1].attacktime = 10; wdrc_p._p.wdrc[1].releasetime = 100; memcpy(wdrc_p._p.wdrc[1].threshold, mid_threshold, sizeof(mid_threshold)); wdrc_p._p.wdrc[1].threshold_num = ARRAY_SIZE(mid_threshold); wdrc_p._p.wdrc[1].rms_time = 25; wdrc_p._p.wdrc[1].algorithm = wdrc_p._p.wdrc[0].algorithm; wdrc_p._p.wdrc[1].mode = wdrc_p._p.wdrc[0].mode; wdrc_p._p.wdrc[1].inputgain = wdrc_p._p.wdrc[0].inputgain; wdrc_p._p.wdrc[1].outputgain = wdrc_p._p.wdrc[0].outputgain; info->R_pch = info->pch = &wdrc_p; #endif/*TCFG_AUDIO_BASS_BOOST*/ return 0; } void *audio_bass_boost_open(u32 sample_rate, u8 ch_num) { struct audio_drc *bass_boost = NULL; struct audio_drc_param drc_param = {0}; drc_param.sr = sample_rate; drc_param.channels = ch_num; drc_param.cb = bass_boost_get_filter_info; bass_boost = audio_dec_drc_open(&drc_param); return bass_boost; } void audio_bass_boost_run(void *hdl, s16 *data, int len) { if (!hdl) { return; } if (bass_boost_run) { audio_drc_run(hdl, data, len); } } void audio_bass_boost_close(void *hdl) { if (!hdl) { return; } audio_dec_drc_close(hdl); } #endif