3529 lines
129 KiB
C
3529 lines
129 KiB
C
/*
|
||
****************************************************************
|
||
* AUDIO ANC
|
||
* File : audio_anc.c
|
||
* By :
|
||
* Notes : ref_mic = 参考mic
|
||
* err_mic = 误差mic
|
||
*
|
||
****************************************************************
|
||
*/
|
||
#include "system/includes.h"
|
||
#include "audio_anc.h"
|
||
#include "system/task.h"
|
||
#include "timer.h"
|
||
#include "asm/clock.h"
|
||
#include "asm/power/p33.h"
|
||
#include "online_db_deal.h"
|
||
#include "app_config.h"
|
||
#include "tone_player.h"
|
||
#include "audio_adc.h"
|
||
#include "audio_enc.h"
|
||
#include "asm/dac.h"
|
||
#include "audio_anc_coeff.h"
|
||
#include "btstack/avctp_user.h"
|
||
#include "app_main.h"
|
||
#include "audio_decoder.h"
|
||
#include "adv_adaptive_noise_reduction.h"
|
||
#include "audio_codec_clock.h"
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_EN
|
||
#include "amplitude_statistic.h"
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_EN*/
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
#include "icsd_adt.h"
|
||
#include "icsd_adt_app.h"
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
|
||
#if TCFG_USER_TWS_ENABLE
|
||
#include "bt_tws.h"
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
#ifdef SUPPORT_MS_EXTENSIONS
|
||
#pragma bss_seg(".anc_user_bss")
|
||
#pragma data_seg(".anc_user_data")
|
||
#pragma const_seg(".anc_user_const")
|
||
#pragma code_seg(".anc_user_code")
|
||
#endif/*SUPPORT_MS_EXTENSIONS*/
|
||
|
||
#define AT_VOLATILE_RAM_CODE AT(.volatile_ram_code)
|
||
|
||
#if INEAR_ANC_UI
|
||
extern u8 inear_tws_ancmode;
|
||
#endif/*INEAR_ANC_UI*/
|
||
|
||
#if TCFG_AUDIO_ANC_ENABLE
|
||
|
||
#if 1
|
||
#define user_anc_log printf
|
||
#else
|
||
#define user_anc_log(...)
|
||
#endif/*log_en*/
|
||
|
||
/*************************ANC增益配置******************************/
|
||
#define ANC_DAC_GAIN 13 //ANC Speaker增益
|
||
#define ANC_REF_MIC_GAIN 8 //ANC参考Mic增益
|
||
#define ANC_ERR_MIC_GAIN 8 //ANC误差Mic增益
|
||
#define ANC_FADE_GAIN_DEFAULT 16384 //ANC默认淡入淡出增益，16384 = 0dB
|
||
/*****************************************************************/
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
const u8 CONST_ANC_ADT_EN = 1;
|
||
#else
|
||
const u8 CONST_ANC_ADT_EN = 0;
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
const u8 CONST_ANC_EAR_ADAPTIVE_EN = 1;
|
||
#else
|
||
const u8 CONST_ANC_EAR_ADAPTIVE_EN = 0;
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
#if TCFG_ANC_SELF_DUT_GET_SZ
|
||
const u8 CONST_ANC_DUT_SZ_EN = 1;
|
||
#else
|
||
const u8 CONST_ANC_DUT_SZ_EN = 0;
|
||
#endif/*TCFG_ANC_SELF_DUT_GET_SZ*/
|
||
|
||
#if ANC_ADAPTIVE_EN
|
||
/*自适应增益等级系数表*/
|
||
anc_adap_param_t anc_adap_param[] = {
|
||
{
|
||
.pow_thr = 0XFFFFFFFF, //当前等级能量高阈值
|
||
.default_flag = 1, //默认等级标志
|
||
.trigger_cnt = 20, //当前等级检测时间*500ms */
|
||
.gain = 1024, //当前等级对应增益 */
|
||
.fade_lvl = 10, //当前等级增益淡入时间*100ms */
|
||
/*
|
||
此阈值对应MIC模拟增益为4, 对应差值倍数为1.259,
|
||
如MIC模拟增益为3, 该阈值 = 500*(1.259^(3-4)) = 397
|
||
如MIC模拟增益为6, 该阈值 = 500*(1.259^(6-4)) = 792
|
||
*/
|
||
.pow_lthr = 700, //当前等级能量低阈值
|
||
},
|
||
{
|
||
.pow_thr = 200, //此阈值对应模拟增益为4,计算方法如上
|
||
.trigger_cnt = 20,
|
||
.gain = 350,
|
||
.fade_lvl = 10,
|
||
.pow_lthr = 0,
|
||
},
|
||
};
|
||
|
||
void audio_anc_pow_adap_fade(u16 gain);
|
||
#endif/*ANC_ADAPTIVE_EN*/
|
||
|
||
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
float anc_trans_lfb_gain = 0.0625f;
|
||
|
||
float anc_trans_rfb_gain = 0.0625f;
|
||
|
||
const double anc_trans_lfb_coeff[] = {
|
||
0.195234751212410628795623779296875,
|
||
0.1007948522455990314483642578125,
|
||
0.0427739980514161288738250732421875,
|
||
-1.02504855208098888397216796875,
|
||
0.36385215423069894313812255859375,
|
||
/*
|
||
0.0508266850956715643405914306640625,
|
||
-0.1013386586564593017101287841796875,
|
||
0.0505129448720254004001617431640625,
|
||
-1.99860572628676891326904296875,
|
||
0.9986066981218755245208740234375,
|
||
*/
|
||
};
|
||
|
||
const double anc_trans_rfb_coeff[] = {
|
||
0.195234751212410628795623779296875,
|
||
0.1007948522455990314483642578125,
|
||
0.0427739980514161288738250732421875,
|
||
-1.02504855208098888397216796875,
|
||
0.36385215423069894313812255859375,
|
||
};
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
|
||
|
||
static void anc_mix_out_audio_drc_thr(float thr);
|
||
static void anc_fade_in_timeout(void *arg);
|
||
static void anc_mode_switch_deal(u8 mode);
|
||
static void anc_timer_deal(void *priv);
|
||
static int anc_app_online_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size);
|
||
static anc_coeff_t *anc_cfg_test(u8 coeff_en, u8 gains_en);
|
||
static void anc_fade_in_timer_add(audio_anc_t *param);
|
||
static void audio_anc_adap_tone_play(int ref_lvl, int err_lvl);
|
||
void anc_dmic_io_init(audio_anc_t *param, u8 en);
|
||
u8 anc_btspp_train_again(u8 mode, u32 dat);
|
||
static void anc_tone_play_and_mode_switch(u8 index, u8 preemption, u8 cb_sel);
|
||
void anc_mode_enable_set(u8 mode_enable);
|
||
void audio_anc_post_msg_drc(void);
|
||
void audio_anc_post_msg_debug(void);
|
||
void audio_anc_post_msg_user_train_run(void);
|
||
void audio_anc_adc_ch_set(void);
|
||
void audio_anc_music_dynamic_gain_process(void);
|
||
|
||
static void audio_anc_sz_fft_dac_check_slience_cb(void *buf, int len);
|
||
void audio_anc_post_msg_sz_fft_run(void);
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
int audio_anc_adaptive_data_save(anc_adaptive_iir_t *iir);
|
||
int audio_anc_adaptive_data_read(anc_adaptive_iir_t *iir);
|
||
void audio_anc_ear_adaptive_param_init(audio_anc_t *param);
|
||
|
||
void audio_anc_param_map(u8 coeff_en, u8 gain_en);
|
||
void audio_anc_adaptive_poweron_catch_data(anc_adaptive_iir_t *iir);
|
||
void audio_anc_adaptive_data_format(anc_adaptive_iir_t *iir);
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
|
||
extern u8 bt_phone_dec_is_running();
|
||
extern u8 bt_media_is_running(void);
|
||
extern void anc_user_train_tone_play_cb();
|
||
extern void esco_adc_mic_set_buffs(void);
|
||
|
||
#define ESCO_MIC_DUMP_CNT 10
|
||
extern void esco_mic_dump_set(u16 dump_cnt);
|
||
extern struct audio_dac_hdl dac_hdl;
|
||
|
||
|
||
typedef struct {
|
||
u8 mode_num; /*模式总数*/
|
||
u8 mode_enable; /*使能的模式*/
|
||
u8 anc_parse_seq;
|
||
u8 suspend; /*挂起*/
|
||
u8 ui_mode_sel; /*ui菜单降噪模式选择*/
|
||
u8 new_mode; /*记录模式切换最新的目标模式*/
|
||
u8 last_mode; /*记录模式切换的上一个模式*/
|
||
u8 mic_dy_state; /*动态MIC增益状态*/
|
||
char mic_diff_gain; /*动态MIC增益差值*/
|
||
u16 scene_id; /*多场景滤波器-场景ID*/
|
||
u8 scene_max; /*多场景滤波器-最大场景个数*/
|
||
u16 ui_mode_sel_timer;
|
||
u16 fade_in_timer;
|
||
u16 fade_gain;
|
||
u16 mic_resume_timer; /*动态MIC增益恢复定时器id*/
|
||
float drc_ratio; /*动态MIC增益，对应DRC增益比例*/
|
||
volatile u8 state; /*ANC状态*/
|
||
volatile u8 mode_switch_lock; /*切模式锁存，1表示正在切ANC模式*/
|
||
volatile u8 sync_busy;
|
||
audio_anc_t param; /*ANC lib句柄*/
|
||
audio_adc_mic_mana_t dy_mic_param[4]; /*MIC动态增益参数管理*/
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
u8 ear_adaptive_tws_sync; /*耳道自适应-左右耳平衡使能*/
|
||
u8 ear_adaptive_seq;
|
||
u8 dac_check_slience_flag; /*耳道自适应-DAC静音检测标志*/
|
||
u8 ear_adaptive_data_from; /*耳道自适应-滤波器数据来源*/
|
||
u8 ear_adaptive; /*耳道自适应-模式标志*/
|
||
u8 ear_adaptive_busy; /*耳道自适应-检测繁忙标记*/
|
||
u8 ear_adaptive_dec_wait; /*耳道自适应-音乐播放打断标志*/
|
||
int last_sys_clk; /*上一次系统时钟*/
|
||
anc_adaptive_iir_t adaptive_iir;/*耳道自适应*/
|
||
struct audio_res_wait adaptive_wait; /*耳道自适应，解码任务hdl*/
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_EN
|
||
char loud_dB; /*音乐动态增益-当前音乐幅值*/
|
||
s16 loud_nowgain; /*音乐动态增益-当前增益*/
|
||
s16 loud_targetgain; /*音乐动态增益-目标增益*/
|
||
u16 loud_timeid; /*音乐动态增益-定时器ID*/
|
||
LOUDNESS_M_STRUCT loud_hdl; /*音乐动态增益-操作句柄*/
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_EN*/
|
||
|
||
} anc_t;
|
||
static anc_t *anc_hdl = NULL;
|
||
anc_packet_data_t *anc_adaptive_data = NULL;
|
||
|
||
const u8 anc_tone_tab[3] = {IDEX_TONE_ANC_OFF, IDEX_TONE_ANC_ON, IDEX_TONE_TRANSPARCNCY};
|
||
|
||
u32 get_anc_gains_sign()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.gains.gain_sign;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
u32 get_anc_gains_alogm()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.gains.alogm;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
u32 get_anc_gains_trans_alogm()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.gains.trans_alogm;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
void *get_anc_lfb_coeff()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.lfb_coeff;
|
||
} else {
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
float get_anc_gains_l_fbgain()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.gains.l_fbgain;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
u8 get_anc_l_fbyorder()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.lfb_yorder;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
void *get_anc_lff_coeff()
|
||
{
|
||
if (anc_hdl) {
|
||
printf("anc hdl lff coeff:%x\n", (int)anc_hdl->param.lff_coeff);
|
||
return anc_hdl->param.lff_coeff;
|
||
} else {
|
||
printf("anc hdl NULL~~~~~~~~\n");
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
float get_anc_gains_l_ffgain()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.gains.l_ffgain;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
u8 get_anc_l_ffyorder()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.lff_yorder;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
void *get_anc_ltrans_coeff()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.ltrans_coeff;
|
||
} else {
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
float get_anc_gains_l_transgain()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.gains.l_transgain;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
u8 get_anc_l_transyorder()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.ltrans_yorder;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
void *get_anc_ltrans_fb_coeff()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.ltrans_fb_coeff;
|
||
} else {
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
float get_anc_gains_lfb_transgain()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.ltrans_fbgain;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
u8 get_anc_lfb_transyorder()
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->param.ltrans_fb_yorder;
|
||
} else {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
void set_anc_adt_state(u8 state)
|
||
{
|
||
if (anc_hdl) {
|
||
anc_hdl->param.adt_state = state;
|
||
}
|
||
}
|
||
|
||
static void anc_task(void *p)
|
||
{
|
||
int res;
|
||
int anc_ret = 0;
|
||
int msg[16];
|
||
u8 speak_to_chat_flag = 0;
|
||
u8 adt_flag = 0;
|
||
u8 cur_anc_mode;
|
||
u32 pend_timeout = portMAX_DELAY;
|
||
user_anc_log(">>>ANC TASK<<<\n");
|
||
while (1) {
|
||
res = os_taskq_pend(NULL, msg, ARRAY_SIZE(msg));
|
||
if (res == OS_TASKQ) {
|
||
switch (msg[1]) {
|
||
case ANC_MSG_TRAIN_OPEN:/*启动训练模式*/
|
||
audio_mic_pwr_ctl(MIC_PWR_ON);
|
||
anc_dmic_io_init(&anc_hdl->param, 1);
|
||
user_anc_log("ANC_MSG_TRAIN_OPEN");
|
||
audio_anc_train(&anc_hdl->param, 1);
|
||
os_time_dly(1);
|
||
anc_train_close();
|
||
audio_mic_pwr_ctl(MIC_PWR_OFF);
|
||
break;
|
||
case ANC_MSG_TRAIN_CLOSE:/*训练关闭模式*/
|
||
user_anc_log("ANC_MSG_TRAIN_CLOSE");
|
||
anc_train_close();
|
||
break;
|
||
case ANC_MSG_RUN:
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
if (anc_hdl->param.gains.trans_alogm != 5) {
|
||
ASSERT(0, "ERR!!ANC ADT trans_alogm %d != 5\n", anc_hdl->param.gains.trans_alogm);
|
||
}
|
||
audio_anc_mode_switch_in_adt(anc_hdl->param.mode);
|
||
if (get_adt_open_in_anc_state() && anc_hdl->param.mode == ANC_OFF) {
|
||
user_anc_log("[ADT] ANC_MSG_RUN:%s \n", anc_mode_str[anc_hdl->param.mode]);
|
||
anc_hdl->param.anc_fade_gain = 0;
|
||
anc_hdl->param.mode = ANC_ON;
|
||
speak_to_chat_flag = 1;
|
||
} else {
|
||
anc_hdl->param.anc_fade_gain = 16384;
|
||
speak_to_chat_flag = 0;
|
||
}
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
|
||
cur_anc_mode = anc_hdl->param.mode;/*保存当前anc模式，防止切换过程anc_hdl->param.mode发生切换改变*/
|
||
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
if (cur_anc_mode != ANC_OFF) {
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (anc_hdl->param.anc_coeff_mode == ANC_COEFF_MODE_ADAPTIVE) {
|
||
audio_anc_coeff_adaptive_set(ANC_COEFF_MODE_ADAPTIVE, 0, 0);
|
||
} else {
|
||
anc_mult_scene_set(anc_hdl->scene_id);
|
||
}
|
||
#else
|
||
anc_mult_scene_set(anc_hdl->scene_id);
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
}
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
|
||
user_anc_log("ANC_MSG_RUN:%s \n", anc_mode_str[cur_anc_mode]);
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_EN
|
||
audio_anc_music_dynamic_gain_reset(0); /*音乐动态增益，切模式复位状态*/
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_EN*/
|
||
|
||
#if TCFG_AUDIO_DYNAMIC_ADC_GAIN
|
||
if (anc_hdl->mic_resume_timer) {
|
||
sys_timer_del(anc_hdl->mic_resume_timer);
|
||
anc_hdl->mic_resume_timer = 0;
|
||
}
|
||
#endif/*TCFG_AUDIO_DYNAMIC_ADC_GAIN*/
|
||
#if (TCFG_AUDIO_ADC_MIC_CHA == LADC_CH_PLNK)
|
||
esco_mic_dump_set(ESCO_MIC_DUMP_CNT);
|
||
#endif/*LADC_CH_PLNK*/
|
||
if (anc_hdl->state == ANC_STA_INIT) {
|
||
audio_mic_pwr_ctl(MIC_PWR_ON);
|
||
anc_dmic_io_init(&anc_hdl->param, 1);
|
||
#if ANC_MODE_SYSVDD_EN
|
||
clock_set_lowest_voltage(SYSVDD_VOL_SEL_105V); //进入ANC时提高SYSVDD电压
|
||
#endif/*ANC_MODE_SYSVDD_EN*/
|
||
anc_ret = audio_anc_run(&anc_hdl->param);
|
||
if (anc_ret == 0) {
|
||
anc_hdl->state = ANC_STA_OPEN;
|
||
} else {
|
||
/*
|
||
*-EPERM(-1):不支持ANC(非差分MIC，或混合馈使用4M的flash)
|
||
*-EINVAL(-22):参数错误(anc_coeff.bin参数为空, 或不匹配)
|
||
*/
|
||
user_anc_log("audio_anc open Failed:%d\n", anc_ret);
|
||
anc_hdl->mode_switch_lock = 0;
|
||
anc_hdl->state = ANC_STA_INIT;
|
||
anc_hdl->param.mode = ANC_OFF;
|
||
anc_hdl->new_mode = ANC_OFF;
|
||
/*ANC OFF && esco_dec idle*/
|
||
if (bt_phone_dec_is_running() == 0) {
|
||
audio_mic_pwr_ctl(MIC_PWR_OFF);
|
||
}
|
||
break;
|
||
}
|
||
} else {
|
||
audio_anc_run(&anc_hdl->param);
|
||
if (cur_anc_mode == ANC_OFF) {
|
||
anc_hdl->state = ANC_STA_INIT;
|
||
anc_dmic_io_init(&anc_hdl->param, 0);
|
||
/*ANC OFF && esco_dec idle*/
|
||
if (bt_phone_dec_is_running() == 0) {
|
||
audio_mic_pwr_ctl(MIC_PWR_OFF);
|
||
}
|
||
}
|
||
}
|
||
if (cur_anc_mode == ANC_OFF) {
|
||
#if ANC_MODE_SYSVDD_EN
|
||
clock_set_lowest_voltage(SYSVDD_VOL_SEL_084V); //退出ANC恢复普通模式
|
||
#endif/*ANC_MODE_SYSVDD_EN*/
|
||
/*anc关闭，如果没有连接蓝牙，倒计时进入自动关机*/
|
||
/* extern u8 get_total_connect_dev(void); */
|
||
/* if (get_total_connect_dev() == 0) { //已经没有设备连接 */
|
||
/* sys_auto_shut_down_enable(); */
|
||
/* } */
|
||
}
|
||
#if TCFG_AUDIO_DYNAMIC_ADC_GAIN
|
||
if (bt_phone_dec_is_running() && (anc_hdl->state == ANC_STA_OPEN)) {
|
||
if (anc_hdl->mic_dy_state == ANC_MIC_DY_STA_START) {
|
||
audio_anc_drc_ctrl(&anc_hdl->param, anc_hdl->drc_ratio);
|
||
} else if (anc_hdl->mic_dy_state == ANC_MIC_DY_STA_INIT) {
|
||
anc_dynamic_micgain_start(app_var.aec_mic_gain);
|
||
}
|
||
}
|
||
#endif/*TCFG_AUDIO_DYNAMIC_ADC_GAIN*/
|
||
anc_hdl->mode_switch_lock = 0;
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
if (speak_to_chat_flag) {
|
||
cur_anc_mode = ANC_OFF;
|
||
anc_hdl->param.mode = ANC_OFF;
|
||
speak_to_chat_flag = 0;
|
||
}
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
if ((anc_hdl->param.mode != ANC_OFF) && anc_hdl->param.anc_fade_en) {
|
||
os_time_dly(6); //延时避免切模式反馈有哒哒声
|
||
}
|
||
audio_anc_lvl_set(anc_hdl->param.anc_lvl, 0);
|
||
anc_fade_in_timer_add(&anc_hdl->param);
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
audio_icsd_adt_resume();
|
||
audio_speak_to_chat_open_in_anc_done();
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
anc_hdl->last_mode = cur_anc_mode;
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
audio_anc_mult_scene_coeff_free();
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
break;
|
||
case ANC_MSG_MODE_SYNC:
|
||
user_anc_log("anc_mode_sync:%d", msg[2]);
|
||
anc_mode_switch(msg[2], 0);
|
||
break;
|
||
#if TCFG_USER_TWS_ENABLE
|
||
case ANC_MSG_TONE_SYNC:
|
||
user_anc_log("anc_tone_sync_play:%d", msg[2]);
|
||
#if !ANC_MODE_EN_MODE_NEXT_SW
|
||
if (anc_hdl->mode_switch_lock) {
|
||
user_anc_log("anc mode switch lock\n");
|
||
break;
|
||
}
|
||
anc_hdl->mode_switch_lock = 1;
|
||
#endif/*ANC_MODE_EN_MODE_NEXT_SW*/
|
||
if (msg[2] == SYNC_TONE_ANC_OFF) {
|
||
anc_hdl->param.mode = ANC_OFF;
|
||
} else if (msg[2] == SYNC_TONE_ANC_ON) {
|
||
anc_hdl->param.mode = ANC_ON;
|
||
} else {
|
||
anc_hdl->param.mode = ANC_TRANSPARENCY;
|
||
}
|
||
if (anc_hdl->suspend) {
|
||
anc_hdl->param.tool_enablebit = 0;
|
||
}
|
||
anc_hdl->new_mode = anc_hdl->param.mode; //确保准备切的新模式，与最后一个提示音播放的模式一致
|
||
anc_tone_play_and_mode_switch(anc_tone_tab[anc_hdl->param.mode - 1], ANC_TONE_PREEMPTION, ANC_TONE_END_MODE_SW);
|
||
//anc_mode_switch_deal(anc_hdl->param.mode);
|
||
anc_hdl->sync_busy = 0;
|
||
break;
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
case ANC_MSG_FADE_END:
|
||
break;
|
||
case ANC_MSG_DRC_TIMER:
|
||
audio_anc_drc_process();
|
||
break;
|
||
case ANC_MSG_DEBUG_OUTPUT:
|
||
audio_anc_debug_data_output();
|
||
break;
|
||
#if ANC_ADAPTIVE_EN
|
||
case ANC_MSG_ADAPTIVE_SYNC:
|
||
user_anc_log("anc_pow_adap_sync:%d %d", msg[2], msg[3]);
|
||
audio_anc_adap_tone_play((u8)msg[2], (u8)msg[3]);
|
||
break;
|
||
#endif/*ANC_ADAPTIVE_EN*/
|
||
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_EN
|
||
case ANC_MSG_MUSIC_DYN_GAIN:
|
||
audio_anc_music_dynamic_gain_process();
|
||
break;
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_EN*/
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
case ANC_MSG_ADT:
|
||
icsd_adt_anctask_handle((u8)msg[2]);
|
||
break;
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
case ANC_MSG_ICSD_ANC_CMD:
|
||
icsd_anc_anctask_cmd_handle((u8)msg[2]);
|
||
break;
|
||
case ANC_MSG_USER_TRAIN_INIT:
|
||
/* anc_hdl->last_sys_clk = clk_get("sys"); */
|
||
/* user_anc_log("sys clk:%d\n", anc_hdl->last_sys_clk); */
|
||
/* sys_clk_set(SYS_160M); //自适应跑最高的时钟 */
|
||
audio_codec_clock_set(ANC_EAR_ADAPTIVE_MODE, AUDIO_CODING_PCM, 0);
|
||
//icsd_anc_init(&anc_hdl->param,0);
|
||
if (++anc_hdl->ear_adaptive_seq == 0xff) {
|
||
anc_hdl->ear_adaptive_seq = 0;
|
||
}
|
||
icsd_anc_init(&anc_hdl->param, 1, anc_hdl->ear_adaptive_seq, ANC_ADAPTIVE_TONE_DELAY, anc_hdl->ear_adaptive_tws_sync);
|
||
break;
|
||
case ANC_MSG_USER_TRAIN_RUN:
|
||
icsd_anc_run();
|
||
break;
|
||
case ANC_MSG_USER_TRAIN_SETPARAM:
|
||
icsd_anc_setparam();
|
||
break;
|
||
case ANC_MSG_USER_TRAIN_TIMEOUT:
|
||
icsd_anc_timeout_handler();
|
||
break;
|
||
case ANC_MSG_USER_TRAIN_END:
|
||
icsd_anc_end(&anc_hdl->param);
|
||
/* sys_clk_set(anc_hdl->last_sys_clk); //自适应结束恢复时钟 */
|
||
audio_codec_clock_del(ANC_EAR_ADAPTIVE_MODE);
|
||
break;
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
case ANC_MSG_MIC_DATA_GET:
|
||
/* extern void anc_spp_mic_data_get(audio_anc_t *param); */
|
||
/* anc_spp_mic_data_get(&anc_hdl->param); */
|
||
break;
|
||
case ANC_MSG_RESET:
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
adt_flag = audio_icsd_adt_is_running();
|
||
if (adt_flag) { ////免摘挂起
|
||
audio_icsd_adt_suspend();
|
||
}
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
if (msg[2] && anc_hdl->param.anc_fade_en) {
|
||
int alogm = (anc_hdl->param.mode == ANC_TRANSPARENCY) ? anc_hdl->param.gains.trans_alogm : anc_hdl->param.gains.alogm;
|
||
int dly = audio_anc_fade_dly_get(anc_hdl->param.anc_fade_gain, alogm);
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_RESET, AUDIO_ANC_FDAE_CH_ALL, 0);
|
||
os_time_dly(dly / 10 + 1);
|
||
audio_anc_reset(&anc_hdl->param, 1);
|
||
//避免param.anc_fade_gain 被修改，这里使用固定值
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_RESET, AUDIO_ANC_FDAE_CH_ALL, ANC_FADE_GAIN_DEFAULT);
|
||
} else {
|
||
audio_anc_reset(&anc_hdl->param, 0);
|
||
}
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
if (adt_flag) { //免摘恢复, 更新免摘参数coeff gain
|
||
set_icsd_adt_param_updata();
|
||
audio_icsd_adt_resume();
|
||
}
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
audio_anc_mult_scene_coeff_free(); //释放空间
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
break;
|
||
#if TCFG_ANC_SELF_DUT_GET_SZ
|
||
case ANC_MSG_SZ_FFT_OPEN:
|
||
audio_codec_clock_set(ANC_DUT_SZ_FFT_MODE, AUDIO_CODING_PCM, 0);
|
||
anc_hdl->param.mode = ANC_TRAIN;
|
||
anc_hdl->new_mode = ANC_TRAIN;
|
||
anc_hdl->param.test_type = ANC_TEST_TYPE_FFT; //设置当前的测试类型
|
||
anc_hdl->param.sz_fft.alogm = ANC_ALOGM3; //设置当前测试模式采样率
|
||
anc_hdl->param.sz_fft.data_sel = msg[2]; //传入目标数据通道
|
||
anc_hdl->param.sz_fft.check_flag = 1; //检查DAC有效数据段
|
||
audio_anc_train(&anc_hdl->param, 1); //打开训练模式
|
||
audio_dac_write_callback_add(&dac_hdl, audio_anc_sz_fft_dac_check_slience_cb); //注册DAC回调接口-静音检测
|
||
break;
|
||
case ANC_MSG_SZ_FFT_RUN:
|
||
audio_anc_sz_fft_run(&anc_hdl->param); //SZ_FFT 频响计算主体
|
||
break;
|
||
case ANC_MSG_SZ_FFT_CLOSE:
|
||
audio_anc_sz_fft_stop(&anc_hdl->param); //SZ_FFT 停止计算
|
||
anc_train_close(); //关闭ANC，模式设置为ANC_OFF
|
||
break;
|
||
#endif/*TCFG_ANC_SELF_DUT_GET_SZ*/
|
||
case ANC_MSG_MODE_SWITCH_IN_ANCTASK:
|
||
user_anc_log("anc_mode_in_anctask:%d, %d", msg[2], msg[3]);
|
||
anc_mode_switch(msg[2], msg[3]);
|
||
break;
|
||
}
|
||
} else {
|
||
user_anc_log("res:%d,%d", res, msg[1]);
|
||
}
|
||
}
|
||
}
|
||
|
||
void anc_param_gain_t_printf(u8 cmd)
|
||
{
|
||
char *str[2] = {
|
||
"ANC_CFG_READ",
|
||
"ANC_CFG_WRITE"
|
||
};
|
||
anc_gain_param_t *gains = &anc_hdl->param.gains;
|
||
user_anc_log("-------------anc_param anc_gain_t-%s--------------\n", str[cmd - 1]);
|
||
user_anc_log("developer_mode %d\n", gains->developer_mode);
|
||
user_anc_log("dac_gain %d\n", gains->dac_gain);
|
||
user_anc_log("l_ffmic_gain %d\n", gains->l_ffmic_gain);
|
||
user_anc_log("l_fbmic_gain %d\n", gains->l_fbmic_gain);
|
||
user_anc_log("r_ffmic_gain %d\n", gains->r_ffmic_gain);
|
||
user_anc_log("r_fbmic_gain %d\n", gains->r_fbmic_gain);
|
||
user_anc_log("cmp_en %d\n", gains->cmp_en);
|
||
user_anc_log("drc_en %d\n", gains->drc_en);
|
||
user_anc_log("ahs_en %d\n", gains->ahs_en);
|
||
user_anc_log("ff_1st_dcc %d\n", gains->ff_1st_dcc);
|
||
user_anc_log("fb_1st_dcc %d\n", gains->fb_1st_dcc);
|
||
user_anc_log("ff_2nd_dcc %d\n", gains->ff_2nd_dcc);
|
||
user_anc_log("fb_2nd_dcc %d\n", gains->fb_2nd_dcc);
|
||
user_anc_log("drc_ff_2dcc %d\n", gains->drc_ff_2dcc);
|
||
user_anc_log("drc_fb_2dcc %d\n", gains->drc_fb_2dcc);
|
||
user_anc_log("drc_dcc_det_time %d\n", gains->drc_dcc_det_time);
|
||
user_anc_log("drc_dcc_res_time %d\n", gains->drc_dcc_res_time);
|
||
|
||
user_anc_log("gain_sign 0X%x\n", gains->gain_sign);
|
||
user_anc_log("noise_lvl 0X%x\n", gains->noise_lvl);
|
||
user_anc_log("fade_step 0X%x\n", gains->fade_step);
|
||
user_anc_log("alogm %d\n", gains->alogm);
|
||
user_anc_log("trans_alogm %d\n", gains->trans_alogm);
|
||
|
||
user_anc_log("ancl_ffgain %d.%d\n", ((int)(gains->l_ffgain * 100.0)) / 100, ((int)(gains->l_ffgain * 100.0)) % 100);
|
||
user_anc_log("ancl_fbgain %d.%d\n", ((int)(gains->l_fbgain * 100.0)) / 100, ((int)(gains->l_fbgain * 100.0)) % 100);
|
||
user_anc_log("ancl_trans_gain %d.%d\n", ((int)(gains->l_transgain * 100.0)) / 100, ((int)(gains->l_transgain * 100.0)) % 100);
|
||
user_anc_log("ancl_cmpgain %d.%d\n", ((int)(gains->l_cmpgain * 100.0)) / 100, ((int)(gains->l_cmpgain * 100.0)) % 100);
|
||
user_anc_log("ancr_ffgain %d.%d\n", ((int)(gains->r_ffgain * 100.0)) / 100, ((int)(gains->r_ffgain * 100.0)) % 100);
|
||
user_anc_log("ancr_fbgain %d.%d\n", ((int)(gains->r_fbgain * 100.0)) / 100, ((int)(gains->r_fbgain * 100.0)) % 100);
|
||
user_anc_log("ancr_trans_gain %d.%d\n", ((int)(gains->r_transgain * 100.0)) / 100, ((int)(gains->r_transgain * 100.0)) % 100);
|
||
user_anc_log("ancr_cmpgain %d.%d\n", ((int)(gains->r_cmpgain * 100.0)) / 100, ((int)(gains->r_cmpgain * 100.0)) % 100);
|
||
|
||
user_anc_log("drcff_zero_det %d\n", gains->drcff_zero_det);
|
||
user_anc_log("drcff_dat_mode %d\n", gains->drcff_dat_mode);
|
||
user_anc_log("drcff_lpf_sel %d\n", gains->drcff_lpf_sel);
|
||
user_anc_log("drcfb_zero_det %d\n", gains->drcfb_zero_det);
|
||
user_anc_log("drcfb_dat_mode %d\n", gains->drcfb_dat_mode);
|
||
user_anc_log("drcfb_lpf_sel %d\n", gains->drcfb_lpf_sel);
|
||
|
||
user_anc_log("drcff_low_thr %d\n", gains->drcff_lthr);
|
||
user_anc_log("drcff_high_thr %d\n", gains->drcff_hthr);
|
||
user_anc_log("drcff_low_gain %d\n", gains->drcff_lgain);
|
||
user_anc_log("drcff_high_gain %d\n", gains->drcff_hgain);
|
||
user_anc_log("drcff_nor_gain %d\n", gains->drcff_norgain);
|
||
|
||
user_anc_log("drcfb_low_thr %d\n", gains->drcfb_lthr);
|
||
user_anc_log("drcfb_high_thr %d\n", gains->drcfb_hthr);
|
||
user_anc_log("drcfb_low_gain %d\n", gains->drcfb_lgain);
|
||
user_anc_log("drcfb_high_gain %d\n", gains->drcfb_hgain);
|
||
user_anc_log("drcfb_nor_gain %d\n", gains->drcfb_norgain);
|
||
|
||
user_anc_log("drctrans_low_thr %d\n", gains->drctrans_lthr);
|
||
user_anc_log("drctrans_high_thr %d\n", gains->drctrans_hthr);
|
||
user_anc_log("drctrans_low_gain %d\n", gains->drctrans_lgain);
|
||
user_anc_log("drctrans_high_gain %d\n", gains->drctrans_hgain);
|
||
user_anc_log("drctrans_nor_gain %d\n", gains->drctrans_norgain);
|
||
|
||
user_anc_log("ahs_dly %d\n", gains->ahs_dly);
|
||
user_anc_log("ahs_tap %d\n", gains->ahs_tap);
|
||
user_anc_log("ahs_wn_shift %d\n", gains->ahs_wn_shift);
|
||
user_anc_log("ahs_wn_sub %d\n", gains->ahs_wn_sub);
|
||
user_anc_log("ahs_shift %d\n", gains->ahs_shift);
|
||
user_anc_log("ahs_u %d\n", gains->ahs_u);
|
||
user_anc_log("ahs_gain %d\n", gains->ahs_gain);
|
||
user_anc_log("ahs_nlms_sel %d\n", gains->ahs_nlms_sel);
|
||
|
||
user_anc_log("audio_drc_thr %d/10\n", (int)(gains->audio_drc_thr * 10.0));
|
||
|
||
user_anc_log("adaptive_ref_en %d\n", gains->adaptive_ref_en);
|
||
user_anc_log("adaptive_ref_fb_f %d/10\n", (int)(gains->adaptive_ref_fb_f * 10.0));
|
||
user_anc_log("adaptive_ref_fb_g %d/10\n", (int)(gains->adaptive_ref_fb_g * 10.0));
|
||
user_anc_log("adaptive_ref_fb_q %d/10\n", (int)(gains->adaptive_ref_fb_q * 10.0));
|
||
|
||
}
|
||
|
||
/*ANC配置参数填充*/
|
||
void anc_param_fill(u8 cmd, anc_gain_t *cfg)
|
||
{
|
||
if (cmd == ANC_CFG_READ) {
|
||
anc_gain_t *db_gain = (anc_gain_t *)anc_db_get(ANC_DB_GAIN, &anc_hdl->param.gains_size);
|
||
cfg->gains = db_gain->gains; //直接读flash区域
|
||
/* cfg->gains = anc_hdl->param.gains; */
|
||
} else if (cmd == ANC_CFG_WRITE) {
|
||
anc_hdl->param.gains = cfg->gains;
|
||
anc_hdl->param.gains.hd_en = 0;
|
||
anc_hdl->param.gains.hd_corr_thr = 225;
|
||
anc_hdl->param.gains.hd_corr_dly = 13;
|
||
anc_hdl->param.gains.hd_corr_gain = 256;
|
||
anc_hdl->param.gains.hd_pwr_rate = 2;
|
||
anc_hdl->param.gains.hd_pwr_ctl_gain_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_ctl_ahsrst_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_thr = 500;
|
||
anc_hdl->param.gains.hd_pwr_ctl_gain = 1638;
|
||
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_hthr = 2000;
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_lthr1 = 1000;
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_lthr2 = 200;
|
||
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_hthr = 2000;
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_lthr1 = 1000;
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_lthr2 = 200;
|
||
|
||
anc_hdl->param.gains.developer_mode = anc_hdl->param.developer_mode;
|
||
|
||
audio_anc_param_normalize(&anc_hdl->param);
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
if (anc_hdl->param.gains.trans_alogm != anc_hdl->param.gains.alogm) {
|
||
user_anc_log("===========================\n\n");
|
||
// anc_hdl->param.gains.trans_alogm = anc_hdl->param.gains.alogm;
|
||
user_anc_log("err : anc_hdl->param.gains.trans_alogm != anc_hdl->param.gains.alogm !!!");
|
||
user_anc_log("\n\n===========================");
|
||
}
|
||
#endif
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
audio_anc_param_map(0, 1);
|
||
if (anc_hdl->param.anc_coeff_mode == ANC_COEFF_MODE_ADAPTIVE) {
|
||
audio_anc_ear_adaptive_param_init(&anc_hdl->param);
|
||
}
|
||
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
}
|
||
/* anc_param_gain_t_printf(cmd); */
|
||
}
|
||
|
||
//ANC配置文件读取并更新
|
||
int audio_anc_db_cfg_read(void)
|
||
{
|
||
/*读取ANC增益配置*/
|
||
anc_gain_t *db_gain = (anc_gain_t *)anc_db_get(ANC_DB_GAIN, &anc_hdl->param.gains_size);
|
||
if (db_gain) {
|
||
user_anc_log("anc_gain_db get succ,len:%d\n", anc_hdl->param.gains_size);
|
||
if (audio_anc_gains_version_verify(&anc_hdl->param, db_gain)) { //检查版本差异
|
||
user_anc_log("The anc gains version is older,0X%x\n", db_gain->gains.version);
|
||
db_gain = (anc_gain_t *)anc_db_get(ANC_DB_GAIN, &anc_hdl->param.gains_size);
|
||
}
|
||
anc_param_fill(ANC_CFG_WRITE, db_gain);
|
||
} else {
|
||
user_anc_log("anc_gain_db get failed");
|
||
/* anc_param_gain_t_printf(ANC_CFG_READ); */
|
||
return 1;
|
||
}
|
||
/*读取ANC滤波器系数*/
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
return audio_anc_mult_coeff_file_read();
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
anc_coeff_t *db_coeff = (anc_coeff_t *)anc_db_get(ANC_DB_COEFF, &anc_hdl->param.coeff_size);
|
||
|
||
if (!anc_coeff_fill(db_coeff)) {
|
||
user_anc_log("anc_coeff_db get succ,len:%d", anc_hdl->param.coeff_size);
|
||
} else {
|
||
user_anc_log("anc_coeff_db get failed");
|
||
return 1;
|
||
#if 0 //测试数据写入是否正常，或写入自己想要的滤波器数据
|
||
extern anc_coeff_t *anc_cfg_test(audio_anc_t *param, u8 coeff_en, u8 gains_en);
|
||
anc_coeff_t *test_coeff = anc_cfg_test(&anc_hdl->param, 1, 1);
|
||
if (test_coeff) {
|
||
int ret = anc_db_put(&anc_hdl->param, NULL, test_coeff);
|
||
if (ret == 0) {
|
||
user_anc_log("anc_db put test succ\n");
|
||
} else {
|
||
user_anc_log("anc_db put test err\n");
|
||
}
|
||
}
|
||
anc_coeff_t *test_coeff1 = (anc_coeff_t *)anc_db_get(ANC_DB_COEFF, &anc_hdl->param.coeff_size);
|
||
anc_coeff_fill(test_coeff1);
|
||
#endif
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
audio_anc_param_map(1, 0);
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
return 0;
|
||
|
||
}
|
||
|
||
|
||
|
||
/*ANC初始化*/
|
||
void anc_init(void)
|
||
{
|
||
anc_hdl = zalloc(sizeof(anc_t));
|
||
user_anc_log("anc_hdl size:%lu\n", sizeof(anc_t));
|
||
ASSERT(anc_hdl);
|
||
audio_anc_param_init(&anc_hdl->param);
|
||
anc_debug_init(&anc_hdl->param);
|
||
audio_anc_fade_ctr_init();
|
||
#if TCFG_ANC_TOOL_DEBUG_ONLINE
|
||
app_online_db_register_handle(DB_PKT_TYPE_ANC, anc_app_online_parse);
|
||
#endif/*TCFG_ANC_TOOL_DEBUG_ONLINE*/
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
anc_hdl->param.adt = zalloc(sizeof(anc_adt_param_t));
|
||
ASSERT(anc_hdl->param.adt);
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
anc_hdl->param.adaptive = zalloc(sizeof(anc_ear_adaptive_param_t));
|
||
ASSERT(anc_hdl->param.adaptive);
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
anc_mult_init(&anc_hdl->param);
|
||
anc_hdl->scene_id = ANC_MULT_ORDER_NORMAL_ID; //默认使用场景1滤波器
|
||
anc_hdl->param.mult_gain_set = audio_anc_mult_gains_id_set;
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
|
||
anc_hdl->param.post_msg_drc = audio_anc_post_msg_drc;
|
||
anc_hdl->param.post_msg_debug = audio_anc_post_msg_debug;
|
||
anc_hdl->mode_enable = ANC_MODE_ENABLE;
|
||
anc_mode_enable_set(anc_hdl->mode_enable);
|
||
anc_hdl->param.cfg_online_deal_cb = anc_cfg_online_deal;
|
||
anc_hdl->param.adc_set_buffs_cb = esco_adc_mic_set_buffs;
|
||
audio_anc_adc_ch_set();
|
||
anc_hdl->param.mode = ANC_OFF;
|
||
anc_hdl->new_mode = anc_hdl->param.mode;
|
||
anc_hdl->param.production_mode = 0;
|
||
anc_hdl->param.developer_mode = ANC_DEVELOPER_MODE_EN;
|
||
anc_hdl->param.anc_fade_en = ANC_FADE_EN;/*ANC淡入淡出，默认开*/
|
||
anc_hdl->param.anc_fade_gain = 16384;/*ANC淡入淡出增益,16384 (0dB) max:32767*/
|
||
anc_hdl->param.tool_enablebit = ANC_TRAIN_MODE;
|
||
anc_hdl->param.online_busy = 0; //在线调试繁忙标志位
|
||
//36
|
||
anc_hdl->param.dut_audio_enablebit = ANC_DUT_CLOSE;
|
||
anc_hdl->param.fade_time_lvl = ANC_MODE_FADE_LVL;
|
||
anc_hdl->param.enablebit = ANC_TRAIN_MODE;
|
||
anc_hdl->param.adaptive_mode = ANC_ADAPTIVE_MODE;
|
||
anc_hdl->param.ch = ANC_CH;
|
||
anc_hdl->param.mic_type[0] = ANCL_FF_MIC;
|
||
anc_hdl->param.mic_type[1] = ANCL_FB_MIC;
|
||
anc_hdl->param.mic_type[2] = ANCR_FF_MIC;
|
||
anc_hdl->param.mic_type[3] = ANCR_FB_MIC;
|
||
|
||
anc_hdl->param.lff_en = ANC_CONFIG_LFF_EN;
|
||
anc_hdl->param.lfb_en = ANC_CONFIG_LFB_EN;
|
||
anc_hdl->param.rff_en = ANC_CONFIG_RFF_EN;
|
||
anc_hdl->param.rfb_en = ANC_CONFIG_RFB_EN;
|
||
anc_hdl->param.trans_default_coeff = (double *)trans_coeff_test; //推荐通透滤波器
|
||
anc_hdl->param.debug_sel = 0;
|
||
anc_hdl->param.gains.version = ANC_GAINS_VERSION;
|
||
anc_hdl->param.gains.dac_gain = 3;
|
||
anc_hdl->param.gains.l_ffmic_gain = 4;
|
||
anc_hdl->param.gains.l_fbmic_gain = 4;
|
||
anc_hdl->param.gains.r_ffmic_gain = 4;
|
||
anc_hdl->param.gains.r_fbmic_gain = 4;
|
||
anc_hdl->param.gains.cmp_en = 1;
|
||
anc_hdl->param.gains.drc_en = 0;
|
||
anc_hdl->param.gains.ahs_en = 0;
|
||
anc_hdl->param.gains.ff_1st_dcc = 8;
|
||
anc_hdl->param.gains.ff_2nd_dcc = 4;
|
||
anc_hdl->param.gains.fb_1st_dcc = 8;
|
||
anc_hdl->param.gains.fb_2nd_dcc = 1;
|
||
anc_hdl->param.gains.gain_sign = 0;
|
||
anc_hdl->param.gains.alogm = ANC_ALOGM6;
|
||
anc_hdl->param.gains.trans_alogm = ANC_ALOGM4;
|
||
anc_hdl->param.gains.l_ffgain = 1.0f;
|
||
anc_hdl->param.gains.l_fbgain = 1.0f;
|
||
anc_hdl->param.gains.l_cmpgain = 1.0f;
|
||
anc_hdl->param.gains.l_transgain = 1.0f;
|
||
anc_hdl->param.gains.r_ffgain = 1.0f;
|
||
anc_hdl->param.gains.r_fbgain = 1.0f;
|
||
anc_hdl->param.gains.r_cmpgain = 1.0f;
|
||
anc_hdl->param.gains.r_transgain = 1.0f;
|
||
|
||
anc_hdl->param.gains.drcff_zero_det = 0;
|
||
anc_hdl->param.gains.drcff_dat_mode = 0;//hbit control l_gain, lbit control h_gain
|
||
anc_hdl->param.gains.drcff_lpf_sel = 0;
|
||
anc_hdl->param.gains.drcfb_zero_det = 0;
|
||
anc_hdl->param.gains.drcfb_dat_mode = 0;//hbit control l_gain, lbit control h_gain
|
||
anc_hdl->param.gains.drcfb_lpf_sel = 0;
|
||
|
||
anc_hdl->param.gains.drcff_lthr = 0;
|
||
anc_hdl->param.gains.drcff_hthr = 6000 ;
|
||
anc_hdl->param.gains.drcff_lgain = 0;
|
||
anc_hdl->param.gains.drcff_hgain = 512;
|
||
anc_hdl->param.gains.drcff_norgain = 1024 ;
|
||
|
||
anc_hdl->param.gains.drctrans_lthr = 0;
|
||
anc_hdl->param.gains.drctrans_hthr = 32767 ;
|
||
anc_hdl->param.gains.drctrans_lgain = 0;
|
||
anc_hdl->param.gains.drctrans_hgain = 1024;
|
||
anc_hdl->param.gains.drctrans_norgain = 1024 ;
|
||
|
||
anc_hdl->param.gains.drcfb_lthr = 0;
|
||
anc_hdl->param.gains.drcfb_hthr = 6000;
|
||
anc_hdl->param.gains.drcfb_lgain = 0;
|
||
anc_hdl->param.gains.drcfb_hgain = 512;
|
||
anc_hdl->param.gains.drcfb_norgain = 1024;
|
||
|
||
anc_hdl->param.gains.ahs_dly = 1;
|
||
anc_hdl->param.gains.ahs_tap = 100;
|
||
anc_hdl->param.gains.ahs_wn_shift = 9;
|
||
anc_hdl->param.gains.ahs_wn_sub = 1;
|
||
anc_hdl->param.gains.ahs_shift = 210;
|
||
anc_hdl->param.gains.ahs_u = 4000;
|
||
anc_hdl->param.gains.ahs_gain = -1024;
|
||
anc_hdl->param.gains.audio_drc_thr = -6.0f;
|
||
|
||
anc_hdl->param.gains.ahs_nlms_sel = 0;
|
||
|
||
anc_hdl->param.gains.drc_ff_2dcc = 0;
|
||
anc_hdl->param.gains.drc_fb_2dcc = 0;
|
||
anc_hdl->param.gains.drc_dcc_det_time = 300;
|
||
anc_hdl->param.gains.drc_dcc_res_time = 20;
|
||
anc_hdl->param.gains.hd_en = 0;
|
||
anc_hdl->param.gains.hd_corr_thr = 232;
|
||
anc_hdl->param.gains.hd_corr_gain = 256;
|
||
anc_hdl->param.gains.hd_corr_dly = 13;
|
||
anc_hdl->param.gains.hd_pwr_rate = 2;
|
||
anc_hdl->param.gains.hd_pwr_ctl_gain_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_ctl_ahsrst_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_thr = 18000;
|
||
anc_hdl->param.gains.hd_pwr_ctl_gain = 1638;
|
||
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_hthr = 2000;
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_lthr1 = 1000;
|
||
anc_hdl->param.gains.hd_pwr_ref_ctl_lthr2 = 200;
|
||
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_en = 0;
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_hthr = 2000;
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_lthr1 = 1000;
|
||
anc_hdl->param.gains.hd_pwr_err_ctl_lthr2 = 200;
|
||
|
||
anc_hdl->param.gains.adaptive_ref_en = 0;
|
||
anc_hdl->param.gains.adaptive_ref_fb_f = 120.0;
|
||
anc_hdl->param.gains.adaptive_ref_fb_g = 15.0;
|
||
anc_hdl->param.gains.adaptive_ref_fb_q = 0.4;
|
||
|
||
#if ANC_COEFF_SAVE_ENABLE
|
||
//1.先读取ANC默认参数
|
||
anc_db_init();
|
||
audio_anc_db_cfg_read(); //读取anc_gains.bin anc_coeff.bin，更新ANC参数
|
||
#endif/*ANC_COEFF_SAVE_ENABLE*/
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
anc_hdl->param.adt->dma_done_cb = icsd_adt_dma_done;
|
||
anc_hdl->param.ltrans_fbgain = anc_trans_lfb_gain;
|
||
anc_hdl->param.rtrans_fbgain = anc_trans_rfb_gain;
|
||
anc_hdl->param.ltrans_fb_coeff = anc_trans_lfb_coeff;
|
||
anc_hdl->param.rtrans_fb_coeff = anc_trans_rfb_coeff;
|
||
|
||
anc_hdl->param.ltrans_fb_yorder = sizeof(anc_trans_lfb_coeff) / 40;
|
||
anc_hdl->param.rtrans_fb_yorder = sizeof(anc_trans_rfb_coeff) / 40;
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
|
||
anc_hdl->param.biquad2ab = icsd_biquad2ab_out;
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
//2.再读取ANC自适应参数, 若存在则覆盖默认参数
|
||
anc_hdl->param.adaptive->ff_yorder = ANC_ADAPTIVE_FF_ORDER;
|
||
anc_hdl->param.adaptive->fb_yorder = ANC_ADAPTIVE_FB_ORDER;
|
||
anc_hdl->param.adaptive->cmp_yorder = ANC_ADAPTIVE_CMP_ORDER;
|
||
anc_hdl->param.adaptive->dma_done_cb = icsd_anc_dma_done;
|
||
audio_anc_adaptive_data_read(&anc_hdl->adaptive_iir);
|
||
#if ANC_EAR_RECORD_EN
|
||
icsd_anc_vmdata_init(anc_hdl->adaptive_iir.record_FL, anc_hdl->adaptive_iir.record_FR, &anc_hdl->adaptive_iir.record_num);
|
||
#endif/*ANC_EAR_RECORD_EN*/
|
||
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
/* sys_timer_add(NULL, anc_timer_deal, 5000); */
|
||
|
||
#if ANC_ADAPTIVE_EN
|
||
anc_pow_adap_init(&anc_hdl->param, &anc_adap_param, &anc_adap_param, \
|
||
sizeof(anc_adap_param) / sizeof(anc_adap_param_t), \
|
||
sizeof(anc_adap_param) / sizeof(anc_adap_param_t));
|
||
|
||
anc_hdl->param.pow_adap_fade = audio_anc_pow_adap_fade;
|
||
#endif/*ANC_ADAPTIVE_EN*/
|
||
|
||
|
||
#if TCFG_ANC_SELF_DUT_GET_SZ
|
||
anc_hdl->param.sz_fft.dma_run_hdl = audio_anc_post_msg_sz_fft_run;
|
||
#endif/*TCFG_ANC_SELF_DUT_GET_SZ*/
|
||
|
||
audio_anc_mic_management(&anc_hdl->param);
|
||
anc_mix_out_audio_drc_thr(anc_hdl->param.gains.audio_drc_thr);
|
||
task_create(anc_task, NULL, "anc");
|
||
anc_hdl->state = ANC_STA_INIT;
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
anc_adt_init();
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
user_anc_log("anc_init ok");
|
||
}
|
||
|
||
void anc_train_open(u8 mode, u8 debug_sel)
|
||
{
|
||
user_anc_log("ANC_Train_Open\n");
|
||
local_irq_disable();
|
||
if (anc_hdl && (anc_hdl->state == ANC_STA_INIT)) {
|
||
/*防止重复打开训练模式*/
|
||
if (anc_hdl->param.mode == ANC_TRAIN) {
|
||
local_irq_enable();
|
||
return;
|
||
}
|
||
/*anc工作，退出sniff*/
|
||
user_send_cmd_prepare(USER_CTRL_ALL_SNIFF_EXIT, 0, NULL);
|
||
/*anc工作，关闭自动关机*/
|
||
/* sys_auto_shut_down_disable(); */
|
||
|
||
anc_hdl->param.debug_sel = debug_sel;
|
||
anc_hdl->param.mode = mode;
|
||
anc_hdl->new_mode = anc_hdl->param.mode;
|
||
anc_hdl->param.test_type = ANC_TEST_TYPE_PCM;
|
||
/*训练的时候，申请buf用来保存训练参数*/
|
||
local_irq_enable();
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_TRAIN_OPEN);
|
||
user_anc_log("%s ok\n", __FUNCTION__);
|
||
return;
|
||
}
|
||
local_irq_enable();
|
||
}
|
||
|
||
void anc_train_close(void)
|
||
{
|
||
int ret = 0;
|
||
if (anc_hdl == NULL) {
|
||
return;
|
||
}
|
||
if (anc_hdl && (anc_hdl->param.mode == ANC_TRAIN)) {
|
||
anc_hdl->param.train_para.train_busy = 0;
|
||
anc_hdl->param.mode = ANC_OFF;
|
||
anc_hdl->new_mode = anc_hdl->param.mode;
|
||
anc_hdl->state = ANC_STA_INIT;
|
||
audio_anc_train(&anc_hdl->param, 0);
|
||
user_anc_log("anc_train_close ok\n");
|
||
}
|
||
}
|
||
|
||
/*查询当前ANC是否处于训练状态*/
|
||
int anc_train_open_query(void)
|
||
{
|
||
if (anc_hdl) {
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (anc_hdl->ear_adaptive_busy) {
|
||
return 1;
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
if (anc_hdl->param.mode == ANC_TRAIN) {
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
extern void audio_dump();
|
||
static void anc_timer_deal(void *priv)
|
||
{
|
||
u8 dac_again_l = JL_ADDA->DAA_CON1 & 0xF;
|
||
u8 dac_again_r = (JL_ADDA->DAA_CON1 >> 4) & 0xF;
|
||
u32 dac_dgain_l = JL_AUDIO->DAC_VL0 & 0xFFFF;
|
||
u32 dac_dgain_r = (JL_AUDIO->DAC_VL0 >> 16) & 0xFFFF;
|
||
u8 mic0_gain = (JL_ADDA->ADA_CON8) & 0x1F;
|
||
u8 mic1_gain = (JL_ADDA->ADA_CON8 >> 5) & 0x1F;
|
||
u8 mic2_gain = (JL_ADDA->ADA_CON8 >> 10) & 0x1F;
|
||
u8 mic3_gain = (JL_ADDA->ADA_CON8 >> 15) & 0x1F;
|
||
|
||
user_anc_log("MIC_G:%d,%d,%d,%d,DAC_AG:%d,%d,DAC_DG:%d,%d\n", mic0_gain, mic1_gain, mic2_gain, mic3_gain, dac_again_l, dac_again_r, dac_dgain_l, dac_dgain_r);
|
||
/* mem_stats(); */
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (tws_api_get_role() == TWS_ROLE_MASTER) {
|
||
printf("%c, master\n", bt_tws_get_local_channel());
|
||
} else {
|
||
printf("%c, slave\n", bt_tws_get_local_channel());
|
||
}
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
/* audio_dump(); */
|
||
}
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
static void anc_tone_play_pre(u8 next_mode)
|
||
{
|
||
user_anc_log("anc_tone_play_pre:%d %d %d\n", anc_hdl->new_mode, next_mode, anc_hdl->ear_adaptive);
|
||
/* if (anc_hdl->new_mode == next_mode) { */
|
||
if (next_mode == ANC_ON && anc_hdl->ear_adaptive) {
|
||
icsd_anc_tone_play_start();
|
||
}
|
||
/* } */
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
static void anc_tone_play_cb(void *priv, int break_flag)
|
||
{
|
||
u8 next_mode = (u8)priv;
|
||
user_anc_log("anc_tone_play_cb,anc_mode:%d,%d,new_mode:%d, break %d\n", next_mode, anc_hdl->param.mode, anc_hdl->new_mode, break_flag);
|
||
/*
|
||
*当最新的目标ANC模式和即将切过去的模式一致，才进行模式切换实现。
|
||
*否则表示，模式切换操作（比如快速按键切模式）new_mode领先于ANC模式切换实现next_mode
|
||
*则直接在切模式的时候，实现最新的目标模式
|
||
*/
|
||
if (anc_hdl->new_mode == next_mode) {
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (next_mode == ANC_ON && anc_hdl->ear_adaptive) {
|
||
anc_hdl->ear_adaptive = 0;
|
||
if (break_flag) { // 提示音被打断，自适应强制停止
|
||
icsd_anc_forced_exit();
|
||
}
|
||
anc_user_train_tone_play_cb();
|
||
} else
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
{
|
||
anc_mode_switch_deal(next_mode);
|
||
}
|
||
} else {
|
||
anc_hdl->mode_switch_lock = 0;
|
||
}
|
||
}
|
||
|
||
/*
|
||
*********************************************************************
|
||
* Audio ANC Tone Play And Mode Switch
|
||
* Description: ANC提示音播放和模式切换
|
||
* Arguments : index 提示音索引
|
||
* preemption 提示音抢断播放标识
|
||
* cb_sel 切模式方式选择
|
||
* Return : None.
|
||
* Note(s) : 通过cb_sel选择是在播放提示音切模式，还是播提示音同时切
|
||
* 模式
|
||
*********************************************************************
|
||
*/
|
||
static void anc_tone_play_and_mode_switch(u8 index, u8 preemption, u8 cb_sel)
|
||
{
|
||
if (!bt_media_is_running() && !bt_phone_dec_is_running()) { //后台没有音频，提示音默认打断播放
|
||
preemption = 1;
|
||
}
|
||
if (cb_sel) {
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (anc_hdl->ear_adaptive) { //非ANC模式下切自适应，需要提前开MIC，ADC需要稳定时间
|
||
audio_mic_pwr_ctl(MIC_PWR_ON);
|
||
audio_anc_dac_open(anc_hdl->param.gains.dac_gain, anc_hdl->param.gains.dac_gain);
|
||
anc_hdl->param.adc_set_buffs_cb();
|
||
audio_anc_mic_open(anc_hdl->param.mic_param, 0, anc_hdl->param.adc_ch);
|
||
index = (index == IDEX_TONE_ANC_ON) ? IDEX_TONE_ANC_ADAPTIVE : index;
|
||
}
|
||
#if ANC_USER_TRAIN_TONE_MODE
|
||
anc_tone_play_pre(anc_hdl->param.mode); //播放提示音时，先进行自适应训练
|
||
#endif/*ANC_USER_TRAIN_TONE_MODE*/
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
tone_play_index_with_callback(index, preemption, (void(*)(void *))anc_tone_play_cb, (void *)anc_hdl->param.mode);
|
||
/*ANC打开情况下，播提示音的同时，anc效果淡出*/
|
||
if (anc_hdl->state == ANC_STA_OPEN) {
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SWITCH, AUDIO_ANC_FDAE_CH_ALL, 0);
|
||
}
|
||
} else {
|
||
tone_play_index(index, preemption);
|
||
anc_mode_switch_deal(anc_hdl->param.mode);
|
||
}
|
||
}
|
||
|
||
static void anc_tone_stop(void)
|
||
{
|
||
if (anc_hdl && anc_hdl->mode_switch_lock) {
|
||
tone_play_stop();
|
||
}
|
||
}
|
||
|
||
/*
|
||
*********************************************************************
|
||
* anc_fade_in_timer
|
||
* Description: ANC增益淡入函数
|
||
* Arguments : None.
|
||
* Return : None.
|
||
* Note(s) :通过定时器的控制，使ANC的淡入增益一点一点叠加
|
||
*********************************************************************
|
||
*/
|
||
static void anc_fade_in_timer(void *arg)
|
||
{
|
||
anc_hdl->fade_gain += (anc_hdl->param.anc_fade_gain / anc_hdl->param.fade_time_lvl);
|
||
if (anc_hdl->fade_gain > anc_hdl->param.anc_fade_gain) {
|
||
anc_hdl->fade_gain = anc_hdl->param.anc_fade_gain;
|
||
usr_timer_del(anc_hdl->fade_in_timer);
|
||
}
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SWITCH, AUDIO_ANC_FDAE_CH_ALL, anc_hdl->fade_gain);
|
||
}
|
||
|
||
static void anc_fade_in_timer_add(audio_anc_t *param)
|
||
{
|
||
u32 alogm, dly;
|
||
if (param->anc_fade_en) {
|
||
alogm = (param->mode == ANC_TRANSPARENCY) ? param->gains.trans_alogm : param->gains.alogm;
|
||
dly = audio_anc_fade_dly_get(param->anc_fade_gain, alogm);
|
||
anc_hdl->fade_gain = 0;
|
||
if (param->mode == ANC_ON) { //可自定义模式，当前仅在ANC模式下使用
|
||
user_anc_log("anc_fade_time_lvl %d\n", param->fade_time_lvl);
|
||
anc_hdl->fade_gain = (param->anc_fade_gain / param->fade_time_lvl);
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SWITCH, AUDIO_ANC_FDAE_CH_ALL, anc_hdl->fade_gain);
|
||
if (param->fade_time_lvl > 1) {
|
||
anc_hdl->fade_in_timer = usr_timer_add((void *)0, anc_fade_in_timer, dly, 1);
|
||
}
|
||
} else if (param->mode != ANC_OFF) {
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SWITCH, AUDIO_ANC_FDAE_CH_ALL, param->anc_fade_gain);
|
||
}
|
||
}
|
||
}
|
||
static void anc_fade_out_timeout(void *arg)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_RUN);
|
||
}
|
||
|
||
static void anc_fade(u32 gain)
|
||
{
|
||
u32 alogm, dly;
|
||
if (anc_hdl) {
|
||
alogm = (anc_hdl->last_mode == ANC_TRANSPARENCY) ? anc_hdl->param.gains.trans_alogm : anc_hdl->param.gains.alogm;
|
||
dly = audio_anc_fade_dly_get(anc_hdl->param.anc_fade_gain, alogm);
|
||
user_anc_log("anc_fade:%d,dly:%d", gain, dly);
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SWITCH, AUDIO_ANC_FDAE_CH_ALL, gain);
|
||
if (anc_hdl->param.anc_fade_en) {
|
||
usr_timeout_del(anc_hdl->fade_in_timer);
|
||
usr_timeout_add((void *)0, anc_fade_out_timeout, dly, 1);
|
||
} else {/*不淡入淡出，则直接切模式*/
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_RUN);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
*mode:降噪/通透/关闭
|
||
*tone_play:切换模式的时候，是否播放提示音
|
||
*/
|
||
static void anc_mode_switch_deal(u8 mode)
|
||
{
|
||
#if TCFG_ANCLED_ENABLE
|
||
if ((mode == ANC_ON) || (mode == ANC_TRANSPARENCY)) {
|
||
gpio_set_pull_up(TCFG_ANCLED_PIN, 1);//头戴耳机ANC指示灯
|
||
gpio_set_pull_down(TCFG_ANCLED_PIN, 0);
|
||
gpio_set_direction(TCFG_ANCLED_PIN, 0);
|
||
gpio_set_output_value(TCFG_ANCLED_PIN, 1);
|
||
} else {
|
||
gpio_set_pull_up(TCFG_ANCLED_PIN, 0);
|
||
gpio_set_pull_down(TCFG_ANCLED_PIN, 0);
|
||
gpio_set_direction(TCFG_ANCLED_PIN, 1);
|
||
gpio_set_die(TCFG_ANCLED_PIN, 0);
|
||
}
|
||
#endif
|
||
user_anc_log("anc switch,state:%s", anc_state_str[anc_hdl->state]);
|
||
anc_hdl->mode_switch_lock = 1;
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
audio_anc_mode_switch_in_adt(anc_hdl->param.mode);
|
||
#endif
|
||
if (anc_hdl->state == ANC_STA_OPEN) {
|
||
user_anc_log("anc open now,switch mode:%d", mode);
|
||
anc_fade(0);//切模式，先fade_out
|
||
} else if (anc_hdl->state == ANC_STA_INIT) {
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
if ((anc_hdl->param.mode != ANC_OFF) || get_adt_open_in_anc_state()) {
|
||
#else
|
||
if (anc_hdl->param.mode != ANC_OFF) {
|
||
#endif/*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
/*anc工作，关闭自动关机*/
|
||
/* sys_auto_shut_down_disable(); */
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_RUN);
|
||
} else {
|
||
user_anc_log("anc close now,new mode is ANC_OFF\n");
|
||
anc_hdl->mode_switch_lock = 0;
|
||
}
|
||
} else {
|
||
user_anc_log("anc state err:%d\n", anc_hdl->state);
|
||
anc_hdl->mode_switch_lock = 0;
|
||
}
|
||
}
|
||
|
||
void anc_gain_app_value_set(int app_value)
|
||
{
|
||
static int anc_gain_app_value = -1;
|
||
if (-1 == app_value && -1 != anc_gain_app_value) {
|
||
/* anc_hdl->param.anc_ff_gain = anc_gain_app_value; */
|
||
}
|
||
anc_gain_app_value = app_value;
|
||
}
|
||
|
||
static void anc_user_train_timeout(void *arg)
|
||
{
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
anc_user_train_tone_play_cb();
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
}
|
||
|
||
#define TWS_ANC_SYNC_TIMEOUT 600 //ms
|
||
void anc_mode_switch(u8 mode, u8 tone_play)
|
||
{
|
||
u8 ignore_same_mode = 0;
|
||
u8 tws_sync_en = 1;
|
||
if (anc_hdl == NULL) {
|
||
return;
|
||
}
|
||
/*模式切换超出范围*/
|
||
if ((mode > ANC_BYPASS) || (mode < ANC_OFF)) {
|
||
user_anc_log("anc mode switch err:%d", mode);
|
||
return;
|
||
}
|
||
|
||
/*模式切换同一个*/
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (anc_hdl->ear_adaptive) {
|
||
ignore_same_mode = 1;
|
||
if (!anc_hdl->ear_adaptive_tws_sync) {
|
||
tws_sync_en = 0; //自适应状态关闭左右平衡，则不需要同步切模式
|
||
}
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
/*判断adt是否在关闭过程中切anc*/
|
||
u8 adt_off_state = (audio_icsd_adt_is_running() && !get_icsd_adt_mode()) ? 1 : 0;
|
||
/*需要在切anc模式是开adt || adt关闭时切anc off*/
|
||
if ((get_adt_open_in_anc_state() && get_icsd_adt_mode()) || (adt_off_state && (mode == ANC_OFF))) {
|
||
ignore_same_mode = 1;
|
||
}
|
||
#endif/*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
if (anc_hdl->param.mode == mode && (!ignore_same_mode)) {
|
||
|
||
user_anc_log("anc mode switch err:same mode");
|
||
return;
|
||
}
|
||
#if ANC_MODE_EN_MODE_NEXT_SW
|
||
if (anc_hdl->mode_switch_lock) {
|
||
user_anc_log("anc mode switch lock\n");
|
||
return;
|
||
}
|
||
anc_hdl->mode_switch_lock = 1;
|
||
#endif/*ANC_MODE_EN_MODE_NEXT_SW*/
|
||
|
||
anc_hdl->new_mode = mode;/*记录最新的目标ANC模式*/
|
||
#if ANC_TONE_END_MODE_SW && (!ANC_MODE_EN_MODE_NEXT_SW)
|
||
anc_tone_stop();
|
||
#endif/*ANC_TONE_END_MODE_SW*/
|
||
anc_hdl->param.mode = mode;
|
||
|
||
if (anc_hdl->suspend) {
|
||
anc_hdl->param.tool_enablebit = 0;
|
||
}
|
||
|
||
/* anc_gain_app_value_set(-1); */ //没有处理好bypass与ANC_ON的关系
|
||
/*
|
||
*ANC模式提示音播放规则
|
||
*(1)根据应用选择是否播放提示音：tone_play
|
||
*(2)tws连接的时候，主机发起模式提示音同步播放
|
||
*(3)单机的时候，直接播放模式提示音
|
||
*/
|
||
if (tone_play) {
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (get_tws_sibling_connect_state() && tws_sync_en) {
|
||
if (tws_api_get_role() == TWS_ROLE_MASTER) {
|
||
user_anc_log("[tws_master]anc_tone_sync_play");
|
||
anc_hdl->sync_busy = 1;
|
||
if (anc_hdl->param.mode == ANC_ON) {
|
||
bt_tws_play_tone_at_same_time(SYNC_TONE_ANC_ON, TWS_ANC_SYNC_TIMEOUT);
|
||
} else if (anc_hdl->param.mode == ANC_OFF) {
|
||
bt_tws_play_tone_at_same_time(SYNC_TONE_ANC_OFF, TWS_ANC_SYNC_TIMEOUT);
|
||
} else {
|
||
bt_tws_play_tone_at_same_time(SYNC_TONE_ANC_TRANS, TWS_ANC_SYNC_TIMEOUT);
|
||
}
|
||
}
|
||
return;
|
||
} else {
|
||
user_anc_log("anc_tone_play");
|
||
anc_tone_play_and_mode_switch(anc_tone_tab[mode - 1], ANC_TONE_PREEMPTION, ANC_TONE_END_MODE_SW);
|
||
}
|
||
#else
|
||
anc_tone_play_and_mode_switch(anc_tone_tab[mode - 1], ANC_TONE_PREEMPTION, ANC_TONE_END_MODE_SW);
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
} else {
|
||
#if ANC_EAR_ADAPTIVE_EN // 不播提示音进入自适应流程
|
||
if (mode == ANC_ON && anc_hdl->ear_adaptive) {
|
||
anc_hdl->ear_adaptive = 0;
|
||
if (anc_hdl->param.anc_fade_en) {
|
||
u32 dly = audio_anc_fade_dly_get(anc_hdl->param.anc_fade_gain, anc_hdl->param.gains.alogm);
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SWITCH, AUDIO_ANC_FDAE_CH_ALL, 0);
|
||
usr_timeout_add((void *)0, anc_user_train_timeout, dly, 1);
|
||
} else {
|
||
anc_user_train_timeout(NULL);
|
||
}
|
||
} else
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
{
|
||
anc_mode_switch_deal(mode);
|
||
}
|
||
/* anc_mode_switch_deal(mode); */
|
||
}
|
||
}
|
||
|
||
static void anc_ui_mode_sel_timer(void *priv)
|
||
{
|
||
if (anc_hdl->ui_mode_sel && (anc_hdl->ui_mode_sel != anc_hdl->param.mode)) {
|
||
/*
|
||
*提示音不打断
|
||
*tws提示音同步播放完成
|
||
*/
|
||
if ((tone_get_status() == 0) && (anc_hdl->sync_busy == 0)) {
|
||
user_anc_log("anc_ui_mode_sel_timer:%d,sync_busy:%d", anc_hdl->ui_mode_sel, anc_hdl->sync_busy);
|
||
anc_mode_switch(anc_hdl->ui_mode_sel, 1);
|
||
sys_timer_del(anc_hdl->ui_mode_sel_timer);
|
||
anc_hdl->ui_mode_sel_timer = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
/*ANC通过ui菜单选择anc模式,处理快速切换的情景*/
|
||
void anc_ui_mode_sel(u8 mode, u8 tone_play)
|
||
{
|
||
/*
|
||
*timer存在表示上个模式还没有完成切换
|
||
*提示音不打断
|
||
*tws提示音同步播放完成
|
||
*/
|
||
if ((anc_hdl->ui_mode_sel_timer == 0) && (tone_get_status() == 0) && (anc_hdl->sync_busy == 0)) {
|
||
user_anc_log("anc_ui_mode_sel[ok]:%d", mode);
|
||
anc_mode_switch(mode, tone_play);
|
||
} else {
|
||
user_anc_log("anc_ui_mode_sel[dly]:%d,timer:%d,sync_busy:%d", mode, anc_hdl->ui_mode_sel_timer, anc_hdl->sync_busy);
|
||
anc_hdl->ui_mode_sel = mode;
|
||
if (anc_hdl->ui_mode_sel_timer == 0) {
|
||
anc_hdl->ui_mode_sel_timer = sys_timer_add(NULL, anc_ui_mode_sel_timer, 50);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*tws同步播放模式提示音，并且同步进入anc模式*/
|
||
void anc_tone_sync_play(int tone_name)
|
||
{
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (anc_hdl) {
|
||
user_anc_log("anc_tone_sync_play:%d", tone_name);
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_TONE_SYNC, tone_name);
|
||
}
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
}
|
||
|
||
/*ANC模式同步(tws模式)*/
|
||
void anc_mode_sync(u8 *data)
|
||
{
|
||
//data[0] mode;
|
||
//data[1] adaptive_seq;
|
||
//data[2] scene_id;
|
||
if (anc_hdl) {
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
anc_hdl->ear_adaptive_seq = data[1];
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
anc_hdl->scene_id = data[2];
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_MODE_SYNC, data[0]);
|
||
}
|
||
}
|
||
|
||
/*在anc任务里面切换anc模式，避免上一次切换没有完成，这次切换被忽略的情况*/
|
||
void anc_mode_switch_in_anctask(u8 mode, u8 tone_play)
|
||
{
|
||
if (anc_hdl) {
|
||
os_taskq_post_msg("anc", 3, ANC_MSG_MODE_SWITCH_IN_ANCTASK, mode, tone_play);
|
||
}
|
||
}
|
||
|
||
/*ANC挂起*/
|
||
void anc_suspend(void)
|
||
{
|
||
if (anc_hdl) {
|
||
user_anc_log("anc_suspend\n");
|
||
anc_hdl->suspend = 1;
|
||
anc_hdl->param.tool_enablebit = 0; //使能设置为0
|
||
if (anc_hdl->param.anc_fade_en) { //挂起ANC增益淡出
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SUSPEND, AUDIO_ANC_FDAE_CH_ALL, 0);
|
||
}
|
||
audio_anc_en_set(0);
|
||
}
|
||
}
|
||
|
||
/*ANC恢复*/
|
||
void anc_resume(void)
|
||
{
|
||
if (anc_hdl) {
|
||
user_anc_log("anc_resume\n");
|
||
anc_hdl->suspend = 0;
|
||
anc_hdl->param.tool_enablebit = anc_hdl->param.enablebit; //使能恢复
|
||
audio_anc_en_set(1);
|
||
if (anc_hdl->param.anc_fade_en) { //恢复ANC增益淡入
|
||
//避免param.anc_fade_gain 被修改，这里使用固定值
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SUSPEND, AUDIO_ANC_FDAE_CH_ALL, ANC_FADE_GAIN_DEFAULT);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*ANC信息保存*/
|
||
void anc_info_save()
|
||
{
|
||
if (anc_hdl) {
|
||
anc_info_t anc_info;
|
||
int ret = syscfg_read(CFG_ANC_INFO, &anc_info, sizeof(anc_info));
|
||
if (ret == sizeof(anc_info)) {
|
||
#if INEAR_ANC_UI
|
||
if (anc_info.mode == anc_hdl->param.mode && anc_info.inear_tws_mode == inear_tws_ancmode) {
|
||
#else
|
||
if (anc_info.mode == anc_hdl->param.mode) {
|
||
#endif/*INEAR_ANC_UI*/
|
||
user_anc_log("anc info.mode == cur_anc_mode");
|
||
return;
|
||
}
|
||
} else {
|
||
user_anc_log("read anc_info err");
|
||
}
|
||
|
||
user_anc_log("save anc_info");
|
||
anc_info.mode = anc_hdl->param.mode;
|
||
#if INEAR_ANC_UI
|
||
anc_info.inear_tws_mode = inear_tws_ancmode;
|
||
#endif/*INEAR_ANC_UI*/
|
||
ret = syscfg_write(CFG_ANC_INFO, &anc_info, sizeof(anc_info));
|
||
if (ret != sizeof(anc_info)) {
|
||
user_anc_log("anc info save err!\n");
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
/*系统上电的时候，根据配置决定是否进入上次的模式*/
|
||
void anc_poweron(void)
|
||
{
|
||
if (anc_hdl) {
|
||
#if ANC_INFO_SAVE_ENABLE
|
||
anc_info_t anc_info;
|
||
int ret = syscfg_read(CFG_ANC_INFO, &anc_info, sizeof(anc_info));
|
||
if (ret == sizeof(anc_info)) {
|
||
user_anc_log("read anc_info succ,state:%s,mode:%s", anc_state_str[anc_hdl->state], anc_mode_str[anc_info.mode]);
|
||
#if INEAR_ANC_UI
|
||
inear_tws_ancmode = anc_info.inear_tws_mode;
|
||
#endif/*INEAR_ANC_UI*/
|
||
if ((anc_hdl->state == ANC_STA_INIT) && (anc_info.mode != ANC_OFF)) {
|
||
anc_mode_switch(anc_info.mode, 0);
|
||
}
|
||
} else {
|
||
user_anc_log("read anc_info err");
|
||
}
|
||
#endif/*ANC_INFO_SAVE_ENABLE*/
|
||
}
|
||
}
|
||
|
||
/*ANC poweroff*/
|
||
void anc_poweroff(void)
|
||
{
|
||
if (anc_hdl) {
|
||
#if ANC_POWEOFF_SAVE_ADAPTIVE_DATA && ANC_EAR_ADAPTIVE_EN && (!ANC_DEVELOPER_MODE_EN)
|
||
if (anc_hdl->ear_adaptive_data_from == ANC_ADAPTIVE_DATA_FROM_ALOGM) { //表示数据已经更新
|
||
audio_anc_adaptive_data_save(&anc_hdl->adaptive_iir);
|
||
}
|
||
#endif/*ANC_POWEOFF_SAVE_ADAPTIVE_DATA*/
|
||
user_anc_log("anc_cur_state:%s\n", anc_state_str[anc_hdl->state]);
|
||
#if ANC_INFO_SAVE_ENABLE
|
||
anc_info_save();
|
||
#endif/*ANC_INFO_SAVE_ENABLE*/
|
||
if (anc_hdl->state == ANC_STA_OPEN) {
|
||
user_anc_log("anc_poweroff\n");
|
||
/*close anc module when fade_out timeout*/
|
||
anc_hdl->param.mode = ANC_OFF;
|
||
anc_hdl->new_mode = anc_hdl->param.mode;
|
||
anc_fade(0);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*模式切换测试demo*/
|
||
#define ANC_MODE_NUM 3 /*ANC模式循环切换*/
|
||
static const u8 anc_mode_switch_tab[ANC_MODE_NUM] = {
|
||
ANC_OFF,
|
||
ANC_TRANSPARENCY,
|
||
ANC_ON,
|
||
};
|
||
void anc_mode_next(void)
|
||
{
|
||
if (anc_hdl) {
|
||
if (anc_train_open_query()) {
|
||
return;
|
||
}
|
||
u8 next_mode = 0;
|
||
local_irq_disable();
|
||
anc_hdl->param.anc_fade_en = ANC_FADE_EN; //防止被其他地方清0
|
||
for (u8 i = 0; i < ANC_MODE_NUM; i++) {
|
||
if (anc_mode_switch_tab[i] == anc_hdl->param.mode) {
|
||
next_mode = i + 1;
|
||
if (next_mode >= ANC_MODE_NUM) {
|
||
next_mode = 0;
|
||
}
|
||
if ((anc_hdl->mode_enable & BIT(anc_mode_switch_tab[next_mode])) == 0) {
|
||
user_anc_log("anc_mode_filt,next:%d,en:%d", next_mode, anc_hdl->mode_enable);
|
||
next_mode++;
|
||
if (next_mode >= ANC_MODE_NUM) {
|
||
next_mode = 0;
|
||
}
|
||
}
|
||
//g_printf("fine out anc mode:%d,next:%d,i:%d",anc_hdl->param.mode,next_mode,i);
|
||
break;
|
||
}
|
||
}
|
||
local_irq_enable();
|
||
//user_anc_log("anc_next_mode:%d old:%d,new:%d", next_mode, anc_hdl->param.mode, anc_mode_switch_tab[next_mode]);
|
||
u8 new_mode = anc_mode_switch_tab[next_mode];
|
||
user_anc_log("new_mode:%s", anc_mode_str[new_mode]);
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN && ANC_EAR_ADAPTIVE_EVERY_TIME //非通话状态下，每次切模式都自适应
|
||
if ((anc_mode_switch_tab[next_mode] == ANC_ON) && (bt_phone_dec_is_running() == 0)) {
|
||
anc_hdl->param.mode = ANC_ON;
|
||
anc_hdl->new_mode = anc_hdl->param.mode;
|
||
audio_anc_mode_ear_adaptive(1);
|
||
} else
|
||
#endif/*ANC_EAR_ADAPTIVE_EVERY_TIME*/
|
||
{
|
||
anc_mode_switch(anc_mode_switch_tab[next_mode], 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
/*设置ANC支持切换的模式*/
|
||
void anc_mode_enable_set(u8 mode_enable)
|
||
{
|
||
if (anc_hdl) {
|
||
anc_hdl->mode_enable = mode_enable;
|
||
u8 mode_cnt = 0;
|
||
for (u8 i = 1; i < 4; i++) {
|
||
if (mode_enable & BIT(i)) {
|
||
mode_cnt++;
|
||
user_anc_log("%s Select", anc_mode_str[i]);
|
||
}
|
||
}
|
||
user_anc_log("anc_mode_enable_set:%d", mode_cnt);
|
||
anc_hdl->mode_num = mode_cnt;
|
||
}
|
||
}
|
||
|
||
/*获取anc状态，0:空闲，l:忙*/
|
||
u8 anc_status_get(void)
|
||
{
|
||
u8 status = 0;
|
||
if (anc_hdl) {
|
||
if (anc_hdl->state == ANC_STA_OPEN) {
|
||
status = 1;
|
||
}
|
||
}
|
||
return status;
|
||
}
|
||
|
||
/*获取anc当前模式*/
|
||
u8 anc_mode_get(void)
|
||
{
|
||
if (anc_hdl) {
|
||
//user_anc_log("anc_mode_get:%s", anc_mode_str[anc_hdl->param.mode]);
|
||
return anc_hdl->param.mode;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/*获取anc记录的最新的目标ANC模式*/
|
||
u8 anc_new_target_mode_get(void)
|
||
{
|
||
if (anc_hdl) {
|
||
//user_anc_log("anc_mode_get:%s", anc_mode_str[anc_hdl->new_mode]);
|
||
return anc_hdl->new_mode;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/*获取anc模式，dac左右声道的增益*/
|
||
u8 anc_dac_gain_get(u8 ch)
|
||
{
|
||
u8 gain = 0;
|
||
if (anc_hdl) {
|
||
gain = anc_hdl->param.gains.dac_gain;
|
||
}
|
||
return gain;
|
||
}
|
||
|
||
/*获取anc模式，ff_mic的增益*/
|
||
u8 audio_anc_ffmic_gain_get(void)
|
||
{
|
||
u8 gain = 0;
|
||
if (anc_hdl) {
|
||
if (anc_hdl->param.ch & ANC_L_CH) {
|
||
gain = anc_hdl->param.gains.l_ffmic_gain;
|
||
} else {
|
||
gain = anc_hdl->param.gains.r_ffmic_gain;
|
||
}
|
||
}
|
||
return gain;
|
||
}
|
||
|
||
/*获取anc模式，fb_mic的增益*/
|
||
u8 audio_anc_fbmic_gain_get(void)
|
||
{
|
||
u8 gain = 0;
|
||
if (anc_hdl) {
|
||
if (anc_hdl->param.ch & ANC_L_CH) {
|
||
gain = anc_hdl->param.gains.l_fbmic_gain;
|
||
} else {
|
||
gain = anc_hdl->param.gains.r_fbmic_gain;
|
||
}
|
||
}
|
||
return gain;
|
||
}
|
||
|
||
/*获取anc模式，指定mic的增益, mic_sel:目标MIC通道*/
|
||
u8 audio_anc_mic_gain_get(u8 mic_sel)
|
||
{
|
||
return anc_hdl->param.mic_param[mic_sel].gain;
|
||
}
|
||
|
||
|
||
/*anc coeff读接口*/
|
||
int *anc_coeff_read(void)
|
||
{
|
||
#if ANC_BOX_READ_COEFF
|
||
int *coeff = anc_db_get(ANC_DB_COEFF, &anc_hdl->param.coeff_size);
|
||
if (coeff) {
|
||
coeff = (int *)((u8 *)coeff);
|
||
}
|
||
user_anc_log("anc_coeff_read:0x%x", (u32)coeff);
|
||
return coeff;
|
||
#else
|
||
return NULL;
|
||
#endif/*ANC_BOX_READ_COEFF*/
|
||
}
|
||
|
||
|
||
/*anc coeff写接口*/
|
||
int anc_coeff_write(int *coeff, u16 len)
|
||
{
|
||
int ret = 0;
|
||
u8 single_type = 0;
|
||
anc_coeff_t *db_coeff = (anc_coeff_t *)coeff;
|
||
anc_coeff_t *tmp_coeff = NULL;
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
return -1;
|
||
#endif/**/
|
||
|
||
user_anc_log("anc_coeff_write:0x%x, len:%d", (u32)coeff, len);
|
||
ret = anc_coeff_check(db_coeff, len);
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
if (db_coeff->cnt != 1) {
|
||
ret = anc_db_put(&anc_hdl->param, NULL, (anc_coeff_t *)coeff);
|
||
} else { //保存对应的单项滤波器
|
||
ret = anc_coeff_single_fill(&anc_hdl->param, (anc_coeff_t *)coeff);
|
||
}
|
||
if (ret) {
|
||
user_anc_log("anc_coeff_write err:%d", ret);
|
||
return -1;
|
||
}
|
||
db_coeff = (anc_coeff_t *)anc_db_get(ANC_DB_COEFF, &anc_hdl->param.coeff_size);
|
||
user_anc_log("anc_db coeff_size %d\n", anc_hdl->param.coeff_size);
|
||
anc_coeff_fill(db_coeff);
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
audio_anc_param_map(1, 0);
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
if (anc_hdl->param.mode != ANC_OFF) { //实时更新填入使用
|
||
audio_anc_reset(&anc_hdl->param, 0);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static u8 ANC_idle_query(void)
|
||
{
|
||
if (anc_hdl) {
|
||
/*ANC训练模式，不进入低功耗*/
|
||
if (anc_train_open_query()) {
|
||
return 0;
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
static enum LOW_POWER_LEVEL ANC_level_query(void)
|
||
{
|
||
if (anc_hdl == NULL) {
|
||
return LOW_POWER_MODE_SLEEP;
|
||
}
|
||
/*根据anc的状态选择sleep等级*/
|
||
if (anc_status_get() || anc_hdl->mode_switch_lock) {
|
||
/*anc打开，进入轻量级低功耗*/
|
||
return LOW_POWER_MODE_LIGHT_SLEEP;
|
||
}
|
||
/*anc关闭，进入最优低功耗*/
|
||
return LOW_POWER_MODE_DEEP_SLEEP;
|
||
}
|
||
|
||
/* AT_VOLATILE_RAM_CODE */
|
||
AT(.volatile_ram_code)
|
||
u8 is_lowpower_anc_active()
|
||
{
|
||
if (anc_hdl->state == ANC_STA_OPEN || anc_hdl->mode_switch_lock) {
|
||
/* 若anc 开启，则进入轻量级低功耗时，保持住ANC对应时钟 */
|
||
if ((anc_hdl->param.ch == (ANC_L_CH | ANC_R_CH)) && !anc_hdl->param.lr_lowpower_en) {
|
||
return ANC_CLOCK_USE_PLL;
|
||
} else {
|
||
return ANC_CLOCK_USE_BTOSC;
|
||
}
|
||
}
|
||
return ANC_CLOCK_USE_CLOSE;
|
||
}
|
||
|
||
REGISTER_LP_TARGET(ANC_lp_target) = {
|
||
.name = "ANC",
|
||
.level = ANC_level_query,
|
||
.is_idle = ANC_idle_query,
|
||
};
|
||
|
||
void chargestore_uart_data_deal(u8 *data, u8 len)
|
||
{
|
||
/* anc_uart_process(data, len); */
|
||
}
|
||
|
||
#if TCFG_ANC_TOOL_DEBUG_ONLINE
|
||
//回复包
|
||
void anc_ci_send_packet(u32 id, u8 *packet, int size)
|
||
{
|
||
if (DB_PKT_TYPE_ANC == id) {
|
||
app_online_db_ack(anc_hdl->anc_parse_seq, packet, size);
|
||
return;
|
||
}
|
||
/* y_printf("anc_app_spp_tx\n"); */
|
||
ci_send_packet(id, packet, size);
|
||
}
|
||
|
||
//接收函数
|
||
static int anc_app_online_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size)
|
||
{
|
||
/* y_printf("anc_app_spp_rx\n"); */
|
||
anc_hdl->anc_parse_seq = ext_data[1];
|
||
anc_spp_rx_packet(packet, size);
|
||
return 0;
|
||
}
|
||
//发送函数
|
||
void anc_btspp_packet_tx(u8 *packet, int size)
|
||
{
|
||
app_online_db_send(DB_PKT_TYPE_ANC, packet, size);
|
||
}
|
||
#endif/*TCFG_ANC_TOOL_DEBUG_ONLINE*/
|
||
|
||
u8 anc_btspp_train_again(u8 mode, u32 dat)
|
||
{
|
||
/* tws_api_detach(TWS_DETACH_BY_POWEROFF); */
|
||
//ANC模式下可直接获取REF+ERRMIC的数据
|
||
/* if((dat == 3) || (dat == 5)) { */
|
||
/* anc_hdl->param.debug_sel = dat; */
|
||
/* os_taskq_post_msg("anc", 1, ANC_MSG_MIC_DATA_GET); */
|
||
/* return 0; */
|
||
/* } */
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (anc_hdl->ear_adaptive_busy) { //ANC自适应切换时，不支持获取DMA
|
||
return 0;
|
||
}
|
||
#if TCFG_USER_TWS_ENABLE
|
||
switch (dat) {
|
||
case 2:
|
||
dat = 4;
|
||
break;
|
||
case 3:
|
||
dat = 5;
|
||
break;
|
||
case 6:
|
||
dat = 7;
|
||
break;
|
||
}
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
user_anc_log("anc_btspp_train_again\n");
|
||
audio_anc_close();
|
||
anc_hdl->state = ANC_STA_INIT;
|
||
anc_train_open(mode, (u8)dat);
|
||
return 1;
|
||
}
|
||
|
||
u8 audio_anc_develop_get(void)
|
||
{
|
||
return anc_hdl->param.developer_mode;
|
||
}
|
||
|
||
void audio_anc_develop_set(u8 mode)
|
||
{
|
||
#if (!ANC_DEVELOPER_MODE_EN) && ANC_EAR_ADAPTIVE_EN //非强制开发者模式跟随工具设置
|
||
if (mode != anc_hdl->param.developer_mode) {
|
||
anc_hdl->param.developer_mode = mode;
|
||
if (anc_hdl->param.mode != ANC_OFF) {
|
||
anc_mode_switch(ANC_OFF, 0); //避免右耳参数异常，让调试者感受不适
|
||
}
|
||
if (anc_hdl->param.anc_coeff_mode == ANC_COEFF_MODE_ADAPTIVE) {
|
||
return; //自适应模式不更新参数
|
||
}
|
||
if (mode) { //0 -> 1
|
||
audio_anc_param_map(1, 1); //映射ANC参数
|
||
audio_anc_adaptive_poweron_catch_data(&anc_hdl->adaptive_iir); //打包自适应数据,等待工具读取
|
||
} else { //1 -> 0
|
||
audio_anc_db_cfg_read(); //读取ANC配置区的数据
|
||
if (anc_adaptive_data) {
|
||
free_anc_data_packet(anc_adaptive_data);
|
||
anc_adaptive_data = NULL;
|
||
}
|
||
}
|
||
}
|
||
#endif/*ANC_DEVELOPER_MODE_EN*/
|
||
}
|
||
|
||
/*ANC配置在线读取接口*/
|
||
int anc_cfg_online_deal(u8 cmd, anc_gain_t *cfg)
|
||
{
|
||
/*同步在线更新配置*/
|
||
int ret = 0;
|
||
anc_gain_param_t *gains = &anc_hdl->param.gains;
|
||
anc_param_fill(cmd, cfg);
|
||
if (cmd == ANC_CFG_WRITE) {
|
||
/*实时更新ANC配置*/
|
||
audio_anc_dac_gain(gains->dac_gain, gains->dac_gain);
|
||
audio_anc_mic_management(&anc_hdl->param);
|
||
audio_anc_mic_gain(anc_hdl->param.mic_param, 0);
|
||
anc_mix_out_audio_drc_thr(gains->audio_drc_thr);
|
||
if (anc_hdl->param.mode != ANC_OFF) { //实时更新填入使用
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
anc_mult_scene_set(anc_hdl->scene_id); //覆盖增益以及增益符号
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
audio_anc_reset(&anc_hdl->param, 0); //不可异步，因为后面会更新ANCIF区域内容
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
audio_anc_mult_scene_coeff_free(); //释放空间
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
}
|
||
/*仅修改增益配置*/
|
||
ret = anc_db_put(&anc_hdl->param, cfg, NULL);
|
||
if (ret) {
|
||
user_anc_log("ret %d\n", ret);
|
||
anc_hdl->param.lff_coeff = NULL;
|
||
anc_hdl->param.rff_coeff = NULL;
|
||
anc_hdl->param.lfb_coeff = NULL;
|
||
anc_hdl->param.rfb_coeff = NULL;
|
||
};
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
#if 0
|
||
/*ANC数字MIC IO配置*/
|
||
static atomic_t dmic_mux_ref;
|
||
#define DMIC_SCLK_FROM_PLNK 0
|
||
#define DMIC_SCLK_FROM_ANC 1
|
||
void dmic_io_mux_ctl(u8 en, u8 sclk_sel)
|
||
{
|
||
user_anc_log("dmic_io_mux,en:%d,sclk:%d,ref:%d\n", en, sclk_sel, atomic_read(&dmic_mux_ref));
|
||
if (en) {
|
||
if (atomic_read(&dmic_mux_ref)) {
|
||
user_anc_log("DMIC_IO_MUX open now\n");
|
||
if (sclk_sel == DMIC_SCLK_FROM_ANC) {
|
||
user_anc_log("plink_sclk -> anc_sclk\n");
|
||
gpio_set_fun_output_port(TCFG_AUDIO_PLNK_SCLK_PIN, FO_ANC_MICCK, 0, 1, LOW_POWER_KEEP);
|
||
}
|
||
atomic_inc_return(&dmic_mux_ref);
|
||
return;
|
||
}
|
||
if (sclk_sel == DMIC_SCLK_FROM_ANC) {
|
||
gpio_set_fun_output_port(TCFG_AUDIO_PLNK_SCLK_PIN, FO_ANC_MICCK, 0, 1, LOW_POWER_KEEP);
|
||
} else {
|
||
gpio_set_fun_output_port(TCFG_AUDIO_PLNK_SCLK_PIN, FO_PLNK_SCLK, 0, 1, LOW_POWER_KEEP);
|
||
}
|
||
gpio_set_direction(TCFG_AUDIO_PLNK_SCLK_PIN, 0);
|
||
gpio_set_die(TCFG_AUDIO_PLNK_SCLK_PIN, 0);
|
||
gpio_direction_output(TCFG_AUDIO_PLNK_SCLK_PIN, 1);
|
||
#if TCFG_AUDIO_PLNK_DAT0_PIN != NO_CONFIG_PORT
|
||
//anc data0 port init
|
||
gpio_set_pull_down(TCFG_AUDIO_PLNK_DAT0_PIN, 0);
|
||
gpio_set_pull_up(TCFG_AUDIO_PLNK_DAT0_PIN, 1);
|
||
gpio_set_direction(TCFG_AUDIO_PLNK_DAT0_PIN, 1);
|
||
gpio_set_die(TCFG_AUDIO_PLNK_DAT0_PIN, 1);
|
||
gpio_set_fun_input_port(TCFG_AUDIO_PLNK_DAT0_PIN, PFI_PLNK_DAT0, LOW_POWER_KEEP);
|
||
#endif/*TCFG_AUDIO_PLNK_DAT0_PIN != NO_CONFIG_PORT*/
|
||
|
||
#if TCFG_AUDIO_PLNK_DAT1_PIN != NO_CONFIG_PORT
|
||
//anc data1 port init
|
||
gpio_set_pull_down(TCFG_AUDIO_PLNK_DAT1_PIN, 0);
|
||
gpio_set_pull_up(TCFG_AUDIO_PLNK_DAT1_PIN, 1);
|
||
gpio_set_direction(TCFG_AUDIO_PLNK_DAT1_PIN, 1);
|
||
gpio_set_die(TCFG_AUDIO_PLNK_DAT1_PIN, 1);
|
||
gpio_set_fun_input_port(TCFG_AUDIO_PLNK_DAT1_PIN, PFI_PLNK_DAT1, LOW_POWER_KEEP);
|
||
#endif/*TCFG_AUDIO_PLNK_DAT1_PIN != NO_CONFIG_PORT*/
|
||
atomic_inc_return(&dmic_mux_ref);
|
||
} else {
|
||
if (atomic_read(&dmic_mux_ref)) {
|
||
atomic_dec_return(&dmic_mux_ref);
|
||
if (atomic_read(&dmic_mux_ref)) {
|
||
if (sclk_sel == DMIC_SCLK_FROM_ANC) {
|
||
user_anc_log("anc close now,anc_sclk->plnk_sclk\n");
|
||
gpio_set_fun_output_port(TCFG_AUDIO_PLNK_SCLK_PIN, FO_PLNK_SCLK, 0, 1, LOW_POWER_KEEP);
|
||
} else {
|
||
user_anc_log("plnk close,anc_plnk open\n");
|
||
}
|
||
} else {
|
||
user_anc_log("dmic all close,disable plnk io_mapping output\n");
|
||
gpio_disable_fun_output_port(TCFG_AUDIO_PLNK_SCLK_PIN);
|
||
#if TCFG_AUDIO_PLNK_DAT0_PIN != NO_CONFIG_PORT
|
||
gpio_disable_fun_input_port(TCFG_AUDIO_PLNK_DAT0_PIN);
|
||
#endif/*TCFG_AUDIO_PLNK_DAT0_PIN != NO_CONFIG_PORT*/
|
||
#if TCFG_AUDIO_PLNK_DAT1_PIN != NO_CONFIG_PORT
|
||
gpio_disable_fun_input_port(TCFG_AUDIO_PLNK_DAT1_PIN);
|
||
#endif/*TCFG_AUDIO_PLNK_DAT1_PIN != NO_CONFIG_PORT*/
|
||
}
|
||
} else {
|
||
user_anc_log("dmic_mux_ref NULL\n");
|
||
}
|
||
}
|
||
}
|
||
void anc_dmic_io_init(audio_anc_t *param, u8 en)
|
||
{
|
||
if (en) {
|
||
int i;
|
||
for (i = 0; i < 4; i++) {
|
||
if ((param->mic_type[i] > A_MIC1) && (param->mic_type[i] != MIC_NULL)) {
|
||
user_anc_log("anc_dmic_io_init %d:%d\n", i, param->mic_type[i]);
|
||
dmic_io_mux_ctl(1, DMIC_SCLK_FROM_ANC);
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
dmic_io_mux_ctl(0, DMIC_SCLK_FROM_ANC);
|
||
}
|
||
}
|
||
#else
|
||
void anc_dmic_io_init(audio_anc_t *param, u8 en)
|
||
{
|
||
}
|
||
#endif
|
||
|
||
extern void mix_out_drc_threadhold_update(float threadhold);
|
||
static void anc_mix_out_audio_drc_thr(float thr)
|
||
{
|
||
if (thr > 0.0 || thr < -6.0 || anc_hdl->param.enablebit == ANC_FB_EN) {
|
||
thr = 0.0;
|
||
}
|
||
mix_out_drc_threadhold_update(thr);
|
||
}
|
||
|
||
#if TCFG_AUDIO_DYNAMIC_ADC_GAIN
|
||
void anc_dynamic_micgain_start(u8 audio_mic_gain)
|
||
{
|
||
int anc_mic_gain, i, diff_gain;
|
||
u8 flag = 0;
|
||
float ffgain;
|
||
float multiple = 1.259;
|
||
if (!anc_status_get()) {
|
||
anc_hdl->mic_dy_state = ANC_MIC_DY_STA_INIT;
|
||
return;
|
||
}
|
||
memcpy(anc_hdl->dy_mic_param, anc_hdl->param.mic_param, sizeof(audio_adc_mic_mana_t) * 4);
|
||
|
||
for (i = 0; i < 4; i++) { //动态MIC增益调整时，忽略FBmic
|
||
if ((anc_hdl->dy_mic_param[i].type % 2) == 1) {
|
||
anc_hdl->dy_mic_param[i].mult_flag = 0;
|
||
printf("clean anc_hdl->dy_mic_param[%d].mult_flag\n", i);
|
||
}
|
||
}
|
||
anc_hdl->drc_ratio = 1.0;
|
||
ffgain = (float)(anc_hdl->param.mode == ANC_TRANSPARENCY ? anc_hdl->param.gains.drctrans_norgain : anc_hdl->param.gains.drcff_norgain);
|
||
for (i = 0; i < 4; i++) {
|
||
if (anc_hdl->dy_mic_param[i].mult_flag) {
|
||
anc_mic_gain = anc_hdl->dy_mic_param[i].gain;
|
||
anc_hdl->dy_mic_param[i].gain = audio_mic_gain;
|
||
flag = 1;
|
||
user_anc_log("after mic%d en %d, gain %d, type %d, mult_flag %d\n", i, anc_hdl->dy_mic_param[i].en, \
|
||
anc_hdl->dy_mic_param[i].gain, anc_hdl->dy_mic_param[i].type, anc_hdl->dy_mic_param[i].mult_flag);
|
||
}
|
||
}
|
||
if ((!flag) || (!(audio_mic_gain - anc_mic_gain))) {
|
||
user_anc_log("There is no common MIC\n");
|
||
anc_hdl->mic_dy_state = ANC_MIC_DY_STA_STOP;
|
||
return;
|
||
}
|
||
anc_hdl->mic_dy_state = ANC_MIC_DY_STA_START;
|
||
if (anc_hdl->mic_resume_timer) {
|
||
sys_timer_del(anc_hdl->mic_resume_timer);
|
||
anc_hdl->mic_resume_timer = 0;
|
||
}
|
||
anc_hdl->mic_diff_gain = audio_mic_gain - anc_mic_gain;
|
||
multiple = (anc_hdl->mic_diff_gain < 0) ? (1.0f / multiple) : multiple;
|
||
diff_gain = (anc_hdl->mic_diff_gain < 0) ? 0 - anc_hdl->mic_diff_gain : anc_hdl->mic_diff_gain;
|
||
for (i = 0; i < diff_gain; i++) {
|
||
ffgain /= multiple;
|
||
anc_hdl->drc_ratio *= multiple;
|
||
}
|
||
audio_anc_drc_ctrl(&anc_hdl->param, anc_hdl->drc_ratio);
|
||
audio_anc_mic_gain(anc_hdl->dy_mic_param, 1);
|
||
g_printf("dynamic mic:audio_g %d,anc_g %d, diff_g %d, ff_gain %d, mult %d/100\n", audio_mic_gain, anc_mic_gain, anc_hdl->mic_diff_gain, (s16)ffgain, (int)(multiple * 100.0f));
|
||
}
|
||
|
||
void anc_dynamic_micgain_resume_timer(void *priv)
|
||
{
|
||
float multiple = 1.259;
|
||
audio_adc_mic_mana_t mic_param[4];
|
||
if (anc_hdl->mic_diff_gain > 0) {
|
||
anc_hdl->mic_diff_gain--;
|
||
anc_hdl->drc_ratio /= multiple;
|
||
if (!anc_hdl->mic_diff_gain) {
|
||
anc_hdl->drc_ratio = 1.0;
|
||
}
|
||
for (int i = 0; i < 4; i++) {
|
||
if (anc_hdl->dy_mic_param[i].mult_flag) {
|
||
anc_hdl->dy_mic_param[i].gain--;
|
||
}
|
||
}
|
||
} else if (anc_hdl->mic_diff_gain < 0) {
|
||
anc_hdl->mic_diff_gain++;
|
||
anc_hdl->drc_ratio *= multiple;
|
||
if (!anc_hdl->mic_diff_gain) {
|
||
anc_hdl->drc_ratio = 1.0;
|
||
}
|
||
for (int i = 0; i < 4; i++) {
|
||
if (anc_hdl->dy_mic_param[i].mult_flag) {
|
||
anc_hdl->dy_mic_param[i].gain++;
|
||
}
|
||
}
|
||
} else {
|
||
sys_timer_del(anc_hdl->mic_resume_timer);
|
||
anc_hdl->mic_resume_timer = 0;
|
||
}
|
||
audio_anc_drc_ctrl(&anc_hdl->param, anc_hdl->drc_ratio);
|
||
audio_anc_mic_gain(anc_hdl->dy_mic_param, 1);
|
||
}
|
||
|
||
void anc_dynamic_micgain_stop(void)
|
||
{
|
||
if ((anc_hdl->mic_dy_state == ANC_MIC_DY_STA_START) && anc_status_get()) {
|
||
anc_hdl->mic_dy_state = ANC_MIC_DY_STA_STOP;
|
||
anc_hdl->mic_resume_timer = sys_timer_add(NULL, anc_dynamic_micgain_resume_timer, 10);
|
||
}
|
||
}
|
||
#endif/*TCFG_AUDIO_DYNAMIC_ADC_GAIN*/
|
||
|
||
void audio_anc_post_msg_drc(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_DRC_TIMER);
|
||
}
|
||
|
||
void audio_anc_post_msg_debug(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_DEBUG_OUTPUT);
|
||
}
|
||
|
||
void audio_anc_post_msg_icsd_anc_cmd(u8 cmd)
|
||
{
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_ICSD_ANC_CMD, cmd);
|
||
}
|
||
|
||
void audio_anc_post_msg_user_train_init(u8 mode)
|
||
{
|
||
if (mode == ANC_ON) {
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_USER_TRAIN_INIT);
|
||
}
|
||
}
|
||
|
||
void audio_anc_post_msg_user_train_run(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_USER_TRAIN_RUN);
|
||
}
|
||
|
||
void audio_anc_post_msg_user_train_setparam(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_USER_TRAIN_SETPARAM);
|
||
}
|
||
|
||
void audio_anc_post_msg_user_train_timeout(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_USER_TRAIN_TIMEOUT);
|
||
}
|
||
|
||
void audio_anc_post_msg_user_train_end(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_USER_TRAIN_END);
|
||
}
|
||
|
||
#if TCFG_ANC_SELF_DUT_GET_SZ
|
||
void audio_anc_post_msg_sz_fft_open(u8 sel)
|
||
{
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_SZ_FFT_OPEN, sel);
|
||
}
|
||
|
||
void audio_anc_post_msg_sz_fft_run(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_SZ_FFT_RUN);
|
||
}
|
||
|
||
void audio_anc_post_msg_sz_fft_close(void)
|
||
{
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_SZ_FFT_CLOSE);
|
||
}
|
||
|
||
static void audio_anc_sz_fft_dac_check_slience_cb(void *buf, int len)
|
||
{
|
||
if (anc_hdl->param.sz_fft.check_flag) {
|
||
s16 *check_buf = (s16 *)buf;
|
||
for (int i = 0; i < len / 2; i++) {
|
||
if (check_buf[i]) {
|
||
anc_hdl->param.sz_fft.check_flag = 0;
|
||
audio_anc_sz_fft_trigger();
|
||
audio_dac_write_callback_del(&dac_hdl, audio_anc_sz_fft_dac_check_slience_cb);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//SZ_FFT测试函数
|
||
void audio_anc_sz_fft_test(void)
|
||
{
|
||
#if 0
|
||
static u8 cnt = 0;
|
||
g_printf("cnt %d\n", cnt);
|
||
switch (cnt) {
|
||
case 0:
|
||
audio_anc_post_msg_sz_fft_open(4);
|
||
break;
|
||
case 1:
|
||
audio_anc_sz_fft_trigger();
|
||
/* play_tone_file(get_tone_files()->normal); */
|
||
break;
|
||
case 2:
|
||
audio_anc_post_msg_sz_fft_close();
|
||
break;
|
||
case 3:
|
||
audio_anc_sz_fft_outbuf_release();
|
||
break;
|
||
}
|
||
if (++cnt > 3) {
|
||
cnt = 0;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#endif/* TCFG_ANC_SELF_DUT_GET_SZ*/
|
||
|
||
|
||
void audio_anc_dut_enable_set(u8 enablebit)
|
||
{
|
||
anc_hdl->param.dut_audio_enablebit = enablebit;
|
||
}
|
||
|
||
/*
|
||
ANC结构设置, 下一次切模式或复位ANC时生效
|
||
param: enablebit ANC结构配置，如(ANC_FF_EN/ANC_FB_EN/ANC_HYBRID_EN)
|
||
update_flag 非ANC_OFF时，即时更新效果: 0 不更新；1 更新
|
||
*/
|
||
void audio_anc_enable_set(u8 enablebit, u8 update_flag)
|
||
{
|
||
anc_hdl->param.tool_enablebit = enablebit;
|
||
if ((anc_hdl->param.mode != ANC_OFF) && update_flag) { //实时更新填入使用
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_RESET, 1);
|
||
}
|
||
}
|
||
|
||
void audio_anc_post_msg_adt(u8 cmd)
|
||
{
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_ADT, cmd);
|
||
}
|
||
|
||
void audio_anc_mic_mana_set_gain(audio_anc_t *param, u8 num, u8 type)
|
||
{
|
||
int i;
|
||
switch (type) {
|
||
case 0:
|
||
param->mic_param[num].gain = param->gains.l_ffmic_gain;
|
||
break;
|
||
case 1:
|
||
param->mic_param[num].gain = param->gains.l_fbmic_gain;
|
||
break;
|
||
case 2:
|
||
param->mic_param[num].gain = param->gains.r_ffmic_gain;
|
||
break;
|
||
case 3:
|
||
param->mic_param[num].gain = param->gains.r_fbmic_gain;
|
||
break;
|
||
}
|
||
if ((param->ch == (ANC_L_CH | ANC_R_CH)) && param->mic_param[num].mult_flag) {
|
||
for (i = 0; i < 4; i++) {
|
||
if ((param->mic_param[i].type + 1) % 2) {
|
||
param->mic_param[i].mult_flag = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/*设置fb mic为复用mic*/
|
||
void audio_anc_mic_mana_fb_mult_set(u8 mult_flag)
|
||
{
|
||
if (anc_hdl) {
|
||
audio_anc_t *param = &anc_hdl->param;
|
||
for (int i = 0; i < 4; i++) {
|
||
if ((param->mic_param[i].type == ANC_MIC_TYPE_LFB) || (param->mic_param[i].type == ANC_MIC_TYPE_RFB)) {
|
||
param->mic_param[i].mult_flag = mult_flag;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void audio_anc_mic_management(audio_anc_t *param)
|
||
{
|
||
int i;
|
||
u8 double_mult_flag = 0;
|
||
for (i = 0; i < 4; i++) {
|
||
if (param->mic_type[i] == A_MIC0) {
|
||
param->mic_param[0].en = 1;
|
||
param->mic_param[0].type = i;
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_0
|
||
param->mic_param[0].mult_flag = 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_0*/
|
||
audio_anc_mic_mana_set_gain(param, 0, i);
|
||
}
|
||
if (param->mic_type[i] == A_MIC1) {
|
||
param->mic_param[1].en = 1;
|
||
param->mic_param[1].type = i;
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1
|
||
param->mic_param[1].mult_flag = 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1*/
|
||
audio_anc_mic_mana_set_gain(param, 1, i);
|
||
}
|
||
if (param->mic_type[i] == A_MIC2) {
|
||
param->mic_param[2].en = 1;
|
||
param->mic_param[2].type = i;
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_2
|
||
param->mic_param[2].mult_flag = 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_2*/
|
||
audio_anc_mic_mana_set_gain(param, 2, i);
|
||
}
|
||
if (param->mic_type[i] == A_MIC3) {
|
||
param->mic_param[3].en = 1;
|
||
param->mic_param[3].type = i;
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_3
|
||
param->mic_param[3].mult_flag = 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_3*/
|
||
audio_anc_mic_mana_set_gain(param, 3, i);
|
||
}
|
||
}
|
||
for (i = 0; i < 4; i++) {
|
||
printf("mic%d en %d, gain %d, type %d, mult_flag %d\n", i, param->mic_param[i].en, \
|
||
param->mic_param[i].gain, param->mic_param[i].type, param->mic_param[i].mult_flag);
|
||
}
|
||
}
|
||
|
||
void audio_anc_adc_ch_set(void)
|
||
{
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_0
|
||
anc_hdl->param.adc_ch = (anc_hdl->param.adc_ch << 1) | 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_0*/
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1
|
||
anc_hdl->param.adc_ch = (anc_hdl->param.adc_ch << 1) | 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1*/
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_2
|
||
anc_hdl->param.adc_ch = (anc_hdl->param.adc_ch << 1) | 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_2*/
|
||
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_3
|
||
anc_hdl->param.adc_ch = (anc_hdl->param.adc_ch << 1) | 1;
|
||
#endif/*TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_3*/
|
||
if (!anc_hdl->param.adc_ch) { //通话没有使用模拟MIC，则adc_ch默认赋1
|
||
anc_hdl->param.adc_ch = 1;
|
||
}
|
||
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
/* 开免摘功能后，根据通话mic和免摘mic个数，取最大值来打开ADC的数字通道，保证免摘ADC取数正常 */
|
||
u8 esco_mic_num = audio_adc_file_get_esco_mic_num();
|
||
u8 adt_mic_num = get_icsd_adt_mic_num();
|
||
u8 mic_num = esco_mic_num > adt_mic_num ? esco_mic_num : adt_mic_num;
|
||
if (mic_num == 2) {
|
||
anc_hdl->param.adc_ch = BIT(1) | BIT(0);
|
||
} else {
|
||
anc_hdl->param.adc_ch = BIT(2) | BIT(1) | BIT(0);
|
||
}
|
||
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
|
||
}
|
||
#if ANC_ADAPTIVE_EN
|
||
static void audio_anc_adap_tone_play(int ref_lvl, int err_lvl)
|
||
{
|
||
#if ANC_ADAPTIVE_TONE_EN
|
||
if (ref_lvl == 1) {
|
||
tone_play(TONE_ANC_ADAPTIVE_LVL1, 1);
|
||
} else if (ref_lvl == 0) {
|
||
tone_play(TONE_ANC_ADAPTIVE_LVL2, 1);
|
||
}
|
||
#endif/*ANC_ADAPTIVE_TONE_EN*/
|
||
anc_pow_adap_fade_timer_add(ref_lvl, err_lvl);
|
||
}
|
||
|
||
void audio_anc_adap_sync(int ref_lvl, int err_lvl, int err)
|
||
{
|
||
os_taskq_post_msg("anc", 3, ANC_MSG_ADAPTIVE_SYNC, ref_lvl, err_lvl);
|
||
}
|
||
|
||
extern void bt_tws_anc_adap_sync_send(int ref_lvl, int err_lvl, int msec);
|
||
extern int bt_tws_anc_adap_compare_send(int ref_lvl, int err_lvl);
|
||
|
||
void audio_anc_adap_lvl_compare(int ref_lvl, int err_lvl)
|
||
{
|
||
#if TCFG_USER_TWS_ENABLE
|
||
int ref_lvl_temp, err_lvl_temp;
|
||
ref_lvl_temp = anc_pow_adap_lvl_get(ANC_FF_EN);
|
||
err_lvl_temp = anc_pow_adap_lvl_get(ANC_FB_EN);
|
||
g_printf("compare ref_lvl_temp %d, %d, lvl %d, %d\n", ref_lvl_temp, err_lvl_temp, ref_lvl, err_lvl);
|
||
if (ref_lvl_temp >= ref_lvl) {
|
||
bt_tws_anc_adap_sync_send(ref_lvl, err_lvl, 150);
|
||
}
|
||
if (err_lvl_temp >= ref_lvl) {
|
||
bt_tws_anc_adap_sync_send(ref_lvl, err_lvl, 150);
|
||
}
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
}
|
||
|
||
int audio_anc_pow_adap_deal(int ref_lvl, int err_lvl)
|
||
{
|
||
#if TCFG_USER_TWS_ENABLE
|
||
if (get_tws_sibling_connect_state()) {
|
||
if (tws_api_get_role() == TWS_ROLE_MASTER) {
|
||
user_anc_log("[master]anc_pow_adap send %d %d\n", ref_lvl, err_lvl);
|
||
} else {
|
||
user_anc_log("[slave]anc_pow_adap send %d %d\n", ref_lvl, err_lvl);
|
||
}
|
||
bt_tws_anc_adap_compare_send(ref_lvl, err_lvl);
|
||
} else {
|
||
user_anc_log("[no tws]anc_pow_adap send %d %d\n", ref_lvl, err_lvl);
|
||
audio_anc_adap_tone_play(ref_lvl, err_lvl);
|
||
}
|
||
#else
|
||
user_anc_log("[no tws]anc_pow_adap send %d %d\n", ref_lvl, err_lvl);
|
||
audio_anc_adap_tone_play(ref_lvl, err_lvl);
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
return 0;
|
||
}
|
||
|
||
/*切换增益模式*/
|
||
void audio_anc_adaptive_mode_set(u8 mode, u8 lvl)
|
||
{
|
||
if (anc_hdl) {
|
||
anc_hdl->param.adaptive_mode = mode;
|
||
audio_anc_pow_export_en((mode == ANC_ADAPTIVE_GAIN_MODE), 0);
|
||
if (anc_hdl->param.mode == ANC_ON) {
|
||
switch (mode) {
|
||
case ANC_ADAPTIVE_MANUAL_MODE:
|
||
user_anc_log("ANC_ADAPTIVE_MANUAL_MODE ,lvl%d\n", lvl);
|
||
audio_anc_pow_adap_stop();
|
||
anc_hdl->param.anc_lvl = lvl;
|
||
audio_anc_lvl_set(lvl, 1);
|
||
break;
|
||
case ANC_ADAPTIVE_GAIN_MODE:
|
||
user_anc_log("ANC_ADAPTIVE_GAIN_MODE\n");
|
||
anc_hdl->param.anc_fade_gain = 16384;
|
||
audio_anc_pow_adap_start();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void audio_anc_pow_adap_fade(u16 gain)
|
||
{
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_SCENE_ADAPTIVE, AUDIO_ANC_FDAE_CH_ALL, gain);
|
||
}
|
||
|
||
#endif/*ANC_ADAPTIVE_EN*/
|
||
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_EN
|
||
|
||
#define ANC_MUSIC_DYNAMIC_GAIN_NORGAIN 1024 /*正常默认增益*/
|
||
#define ANC_MUSIC_DYNAMIC_GAIN_TRIGGER_INTERVAL 6 /*音乐响度取样间隔*/
|
||
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_SINGLE_FB
|
||
void audio_anc_music_dyn_gain_resume_timer(void *priv)
|
||
{
|
||
if (anc_hdl->loud_nowgain < anc_hdl->loud_targetgain) {
|
||
anc_hdl->loud_nowgain += 5; ///+5耗时194 * 10ms
|
||
if (anc_hdl->loud_nowgain >= anc_hdl->loud_targetgain) {
|
||
anc_hdl->loud_nowgain = anc_hdl->loud_targetgain;
|
||
sys_timer_del(anc_hdl->loud_timeid);
|
||
anc_hdl->loud_timeid = 0;
|
||
}
|
||
} else if (anc_hdl->loud_nowgain > anc_hdl->loud_targetgain) {
|
||
anc_hdl->loud_nowgain -= 5; ///-5耗时194 * 10ms
|
||
if (anc_hdl->loud_nowgain <= anc_hdl->loud_targetgain) {
|
||
anc_hdl->loud_nowgain = anc_hdl->loud_targetgain;
|
||
sys_timer_del(anc_hdl->loud_timeid);
|
||
anc_hdl->loud_timeid = 0;
|
||
}
|
||
}
|
||
audio_anc_fbgain_set(anc_hdl->loud_nowgain, anc_hdl->loud_nowgain);
|
||
/* user_anc_log("fb resume anc_hdl->loud_nowgain %d\n", anc_hdl->loud_nowgain); */
|
||
}
|
||
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_SINGLE_FB*/
|
||
|
||
void audio_anc_music_dynamic_gain_process(void)
|
||
{
|
||
if (anc_hdl->loud_nowgain != anc_hdl->loud_targetgain) {
|
||
// user_anc_log("low_nowgain %d, targergain %d\n", anc_hdl->loud_nowgain, anc_hdl->loud_targetgain);
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_SINGLE_FB
|
||
if (!anc_hdl->loud_timeid) {
|
||
anc_hdl->loud_timeid = sys_timer_add(NULL, audio_anc_music_dyn_gain_resume_timer, 10);
|
||
}
|
||
#else
|
||
anc_hdl->loud_nowgain = anc_hdl->loud_targetgain;
|
||
audio_anc_fade_ctr_set(ANC_FADE_MODE_MUSIC_DYNAMIC, AUDIO_ANC_FDAE_CH_ALL, anc_hdl->loud_targetgain << 4);
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_SINGLE_FB*/
|
||
}
|
||
}
|
||
|
||
void audio_anc_music_dynamic_gain_reset(u8 effect_reset_en)
|
||
{
|
||
if (anc_hdl->loud_targetgain != ANC_MUSIC_DYNAMIC_GAIN_NORGAIN) {
|
||
/* user_anc_log("audio_anc_music_dynamic_gain_reset\n"); */
|
||
anc_hdl->loud_targetgain = ANC_MUSIC_DYNAMIC_GAIN_NORGAIN;
|
||
if (anc_hdl->loud_timeid) {
|
||
sys_timer_del(anc_hdl->loud_timeid);
|
||
anc_hdl->loud_timeid = 0;
|
||
}
|
||
if (effect_reset_en && anc_hdl->param.mode == ANC_ON) {
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_MUSIC_DYN_GAIN);
|
||
} else {
|
||
anc_hdl->loud_nowgain = ANC_MUSIC_DYNAMIC_GAIN_NORGAIN;
|
||
anc_hdl->loud_dB = 1; //清除上次保留的dB值, 避免切模式后不触发的情况
|
||
anc_hdl->loud_hdl.peak_val = ANC_MUSIC_DYNAMIC_GAIN_THR;
|
||
}
|
||
}
|
||
}
|
||
|
||
void audio_anc_music_dynamic_gain_dB_get(int dB)
|
||
{
|
||
float mult = 1.122f;
|
||
float target_mult = 1.0f;
|
||
int cnt, i, gain;
|
||
#if ANC_MUSIC_DYNAMIC_GAIN_TRIGGER_INTERVAL > 1 //区间变化，避免频繁操作
|
||
if (dB > ANC_MUSIC_DYNAMIC_GAIN_THR) {
|
||
int temp_dB = dB / ANC_MUSIC_DYNAMIC_GAIN_TRIGGER_INTERVAL;
|
||
dB = temp_dB * ANC_MUSIC_DYNAMIC_GAIN_TRIGGER_INTERVAL;
|
||
}
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_TRIGGER_INTERVAL*/
|
||
if (anc_hdl->loud_dB != dB) {
|
||
anc_hdl->loud_dB = dB;
|
||
if (dB > ANC_MUSIC_DYNAMIC_GAIN_THR) {
|
||
cnt = dB - ANC_MUSIC_DYNAMIC_GAIN_THR;
|
||
for (i = 0; i < cnt; i++) {
|
||
target_mult *= mult;
|
||
}
|
||
gain = (int)((float)ANC_MUSIC_DYNAMIC_GAIN_NORGAIN / target_mult);
|
||
// user_anc_log("cnt %d, dB %d, gain %d\n", cnt, dB, gain);
|
||
anc_hdl->loud_targetgain = gain;
|
||
os_taskq_post_msg("anc", 1, ANC_MSG_MUSIC_DYN_GAIN);
|
||
} else {
|
||
audio_anc_music_dynamic_gain_reset(1);
|
||
}
|
||
}
|
||
}
|
||
|
||
void audio_anc_music_dynamic_gain_det(s16 *data, int len)
|
||
{
|
||
/* putchar('l'); */
|
||
if (anc_hdl->param.mode == ANC_ON) {
|
||
loudness_meter_short(&anc_hdl->loud_hdl, data, len >> 1);
|
||
audio_anc_music_dynamic_gain_dB_get(anc_hdl->loud_hdl.peak_val);
|
||
}
|
||
}
|
||
|
||
|
||
void audio_anc_music_dynamic_gain_init(int sr)
|
||
{
|
||
/* user_anc_log("audio_anc_music_dynamic_gain_init %d\n", sr); */
|
||
anc_hdl->loud_nowgain = ANC_MUSIC_DYNAMIC_GAIN_NORGAIN;
|
||
anc_hdl->loud_targetgain = ANC_MUSIC_DYNAMIC_GAIN_NORGAIN;
|
||
anc_hdl->loud_dB = 1; //清除上次保留的dB值
|
||
loudness_meter_init(&anc_hdl->loud_hdl, sr, 50, 0);
|
||
anc_hdl->loud_hdl.peak_val = ANC_MUSIC_DYNAMIC_GAIN_THR;
|
||
}
|
||
#endif/*ANC_MUSIC_DYNAMIC_GAIN_EN*/
|
||
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
extern struct audio_decoder_task decode_task;
|
||
/* 解码任务回调,执行自适应切换 */
|
||
|
||
void audio_anc_dac_check_slience_cb(void *buf, int len)
|
||
{
|
||
if (anc_hdl->dac_check_slience_flag) {
|
||
s16 *check_buf = (s16 *)buf;
|
||
for (int i = 0; i < len / 2; i++) {
|
||
if (check_buf[i]) {
|
||
anc_hdl->dac_check_slience_flag = 0;
|
||
icsd_anctone_dacon(i, dac_hdl.sample_rate);
|
||
audio_dac_write_callback_del(&dac_hdl, audio_anc_dac_check_slience_cb);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void audio_anc_ear_adaptive_open(void)
|
||
{
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
//载入场景参数-提供自适应训练过程使用
|
||
u8 scene_id = ANC_MULT_ADPTIVE_TRAIN_USE_ID ? ANC_MULT_ADPTIVE_TRAIN_USE_ID : anc_hdl->scene_id;
|
||
anc_mult_scene_set(scene_id);
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
anc_hdl->ear_adaptive = 1;
|
||
anc_hdl->param.anc_coeff_mode = ANC_COEFF_MODE_ADAPTIVE; //切到自适应的参数
|
||
anc_hdl->ear_adaptive_busy = 1;
|
||
audio_anc_ear_adaptive_param_init(&anc_hdl->param);
|
||
#if ANC_USER_TRAIN_TONE_MODE
|
||
anc_hdl->dac_check_slience_flag = 1;
|
||
audio_dac_write_callback_add(&dac_hdl, audio_anc_dac_check_slience_cb);
|
||
#endif/*ANC_USER_TRAIN_TONE_MODE*/
|
||
/*自适应时需要挂起adt*/
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
audio_anc_mode_switch_in_adt(ANC_ON);
|
||
#endif
|
||
anc_mode_switch(ANC_ON, ANC_USER_TRAIN_TONE_MODE);
|
||
}
|
||
|
||
static int audio_anc_adaptive_wait_handler(struct audio_res_wait *wait, int event)
|
||
{
|
||
if (event == AUDIO_RES_GET) {
|
||
if (anc_hdl->ear_adaptive_dec_wait == ANC_ADAPTIVE_DEC_WAIT_START) {
|
||
//避免重复进入
|
||
anc_hdl->ear_adaptive_dec_wait = ANC_ADAPTIVE_DEC_WAIT_RUN;
|
||
audio_anc_ear_adaptive_open();
|
||
}
|
||
} else {
|
||
g_printf("audio_anc.c AUDIO_RES_PUT\n");
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* 自适应解码任务注册 */
|
||
static int audio_anc_decoder_task_add(int parm)
|
||
{
|
||
anc_hdl->adaptive_wait.priority = 2; //优先级
|
||
anc_hdl->adaptive_wait.preemption = 1; //打断方式
|
||
anc_hdl->adaptive_wait.handler = audio_anc_adaptive_wait_handler;//解码任务回调
|
||
anc_hdl->ear_adaptive_dec_wait = ANC_ADAPTIVE_DEC_WAIT_START;
|
||
audio_decoder_task_add_wait(&decode_task, &anc_hdl->adaptive_wait);
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
自适应模式-重新检测
|
||
param: tws_sync_en 1 TWS同步自适应，支持TWS降噪平衡，需左右耳一起调用此接口
|
||
0 单耳自适应, 不支持TWS降噪平衡，可TWS状态下单耳自适应
|
||
*/
|
||
int audio_anc_mode_ear_adaptive(u8 tws_sync_en)
|
||
{
|
||
//不支持重入自适应模式，仅在ANC模式，非通话下进入自适应模式
|
||
anc_hdl->ear_adaptive_tws_sync = tws_sync_en;
|
||
|
||
if (anc_hdl->param.mode == ANC_ON && !anc_hdl->ear_adaptive_busy \
|
||
&& (bt_phone_dec_is_running() == 0) && !anc_hdl->mode_switch_lock
|
||
) {
|
||
if (bt_media_is_running()) { //当前处于音乐播放状态, 注册解码任务打断，进入自适应
|
||
/* if (0) { //当前处于音乐播放状态, 注册解码任务打断，进入自适应 */
|
||
if (strcmp(os_current_task(), "app_core") != 0) {
|
||
int *ptr = malloc(2 * sizeof(int));
|
||
ptr[0] = 0;
|
||
ptr[1] = 0;
|
||
OS_SEM *sem = malloc(sizeof(OS_SEM) + 4);
|
||
int *err = (int *)(sem + 1);
|
||
ASSERT(sem);
|
||
int msg[8];
|
||
msg[0] = (int)audio_anc_decoder_task_add;
|
||
msg[1] = 1 | BIT(8) | BIT(9);
|
||
msg[2] = (int)ptr;
|
||
msg[3] = (int)err;
|
||
msg[4] = (int)sem;
|
||
|
||
os_sem_create(sem, 0);
|
||
int ret_err;
|
||
while (1) {
|
||
int ret_err = os_taskq_post_type("app_core", Q_CALLBACK, 5, msg);
|
||
if (ret_err == OS_ERR_NONE) {
|
||
os_sem_pend(sem, 0);
|
||
ret_err = *err;
|
||
break;
|
||
}
|
||
if (ret_err != OS_Q_FULL) {
|
||
break;
|
||
}
|
||
os_time_dly(2);
|
||
}
|
||
free(sem);
|
||
free(ptr);
|
||
g_printf("switch to app_core paly tone ok\n");
|
||
return 0;
|
||
} else {
|
||
audio_anc_decoder_task_add(0);
|
||
return 0;
|
||
}
|
||
}
|
||
audio_anc_ear_adaptive_open();
|
||
return 0;
|
||
}
|
||
#if (RCSP_ADV_EN && RCSP_ADV_ANC_VOICE && RCSP_ADV_ADAPTIVE_NOISE_REDUCTION)
|
||
set_adaptive_noise_reduction_reset_callback(0); // 无法进入自适应，返回失败结果
|
||
#endif
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*自适应结束回调函数*/
|
||
void anc_user_train_cb(u8 mode, u8 result, u8 forced_exit)
|
||
{
|
||
user_anc_log("anc_adaptive end result 0x%x , coeff_use 0x%x\n", result, anc_hdl->adaptive_iir.result);
|
||
audio_anc_t *param = &anc_hdl->param;
|
||
anc_hdl->ear_adaptive_busy = 0;
|
||
|
||
if (forced_exit == 1) {
|
||
//强制打断，自适应定义为失败，使用默认参数
|
||
anc_hdl->adaptive_iir.result = 0;
|
||
//删除自适应DAC回调接口
|
||
audio_dac_write_callback_del(&dac_hdl, audio_anc_dac_check_slience_cb);
|
||
}
|
||
|
||
if (anc_hdl->adaptive_iir.result) { //自适应成功或部分成功
|
||
if (anc_hdl->ear_adaptive_data_from == ANC_ADAPTIVE_DATA_FROM_VM) { //释放掉原来VM使用的资源
|
||
if (anc_hdl->param.adaptive->lff_coeff) {
|
||
free(anc_hdl->param.adaptive->lff_coeff);
|
||
};
|
||
if (anc_hdl->param.adaptive->lfb_coeff) {
|
||
free(anc_hdl->param.adaptive->lfb_coeff);
|
||
};
|
||
if (anc_hdl->param.adaptive->lcmp_coeff) {
|
||
free(anc_hdl->param.adaptive->lcmp_coeff);
|
||
};
|
||
if (anc_hdl->param.adaptive->rff_coeff) {
|
||
free(anc_hdl->param.adaptive->rff_coeff);
|
||
};
|
||
if (anc_hdl->param.adaptive->rfb_coeff) {
|
||
free(anc_hdl->param.adaptive->rfb_coeff);
|
||
};
|
||
if (anc_hdl->param.adaptive->rcmp_coeff) {
|
||
free(anc_hdl->param.adaptive->rcmp_coeff);
|
||
};
|
||
}
|
||
anc_hdl->ear_adaptive_data_from = ANC_ADAPTIVE_DATA_FROM_ALOGM; //自适应参数更新
|
||
#if (ANC_CH & ANC_L_CH)
|
||
param->adaptive->lff_coeff = param->lff_coeff;
|
||
param->adaptive->lfb_coeff = param->lfb_coeff;
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
param->adaptive->lcmp_coeff = param->lcmp_coeff;
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*(ANC_CH & ANC_L_CH)*/
|
||
#if (ANC_CH & ANC_R_CH)
|
||
param->adaptive->rff_coeff = param->rff_coeff;
|
||
param->adaptive->rfb_coeff = param->rfb_coeff;
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
param->adaptive->rcmp_coeff = param->rcmp_coeff;
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*(ANC_CH & ANC_R_CH)*/
|
||
if (result != ANC_SUCCESS) { //非FF+FB同时成功
|
||
g_printf("no all success");
|
||
audio_anc_coeff_adaptive_set(ANC_COEFF_MODE_NORMAL, 0, 0); //先覆盖默认参数
|
||
audio_anc_coeff_adaptive_set(ANC_COEFF_MODE_ADAPTIVE, 0, 0); //根据自适应结果选择覆盖参数
|
||
}
|
||
|
||
#if (!ANC_POWEOFF_SAVE_ADAPTIVE_DATA) || ANC_DEVELOPER_MODE_EN
|
||
audio_anc_adaptive_data_save(&anc_hdl->adaptive_iir);
|
||
#endif/*ANC_POWEOFF_SAVE_ADAPTIVE_DATA*/
|
||
} else { //自适应失败使用默认的参数
|
||
audio_anc_coeff_adaptive_set(ANC_COEFF_MODE_NORMAL, 0, 0);
|
||
}
|
||
if (anc_hdl->ear_adaptive_dec_wait) {
|
||
anc_hdl->ear_adaptive_dec_wait = ANC_ADAPTIVE_DEC_WAIT_STOP;
|
||
audio_decoder_task_del_wait(&decode_task, &anc_hdl->adaptive_wait);
|
||
}
|
||
anc_mode_switch_deal(mode);
|
||
}
|
||
|
||
/*ANC滤波器模式循环切换*/
|
||
int audio_anc_coeff_adaptive_switch()
|
||
{
|
||
if (anc_hdl->param.mode == ANC_ON && !anc_hdl->ear_adaptive_busy && !anc_hdl->mode_switch_lock) {
|
||
anc_hdl->param.anc_coeff_mode ^= 1;
|
||
audio_anc_coeff_adaptive_set(anc_hdl->param.anc_coeff_mode, 1, 1);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/*当前ANC滤波器模式获取 0:普通参数 1:自适应参数*/
|
||
int audio_anc_coeff_mode_get(void)
|
||
{
|
||
if (!anc_hdl) {
|
||
return 0;
|
||
}
|
||
return anc_hdl->param.anc_coeff_mode;
|
||
}
|
||
|
||
/*
|
||
自适应/普通参数切换
|
||
param: mode 0 使用普通参数; 1 使用自适应参数
|
||
tone_play 0 不播放提示音；1 播放提示音
|
||
update_flag 0 不更新效果； 1 即时更新效果
|
||
*/
|
||
int audio_anc_coeff_adaptive_set(u32 mode, u8 tone_play, u8 update_flag)
|
||
{
|
||
audio_anc_t *param = &anc_hdl->param;
|
||
u8 result = anc_hdl->adaptive_iir.result;
|
||
if (anc_hdl->ear_adaptive_busy) {
|
||
return 0;
|
||
}
|
||
anc_hdl->param.anc_coeff_mode = mode;
|
||
switch (mode) {
|
||
case 0:
|
||
if (tone_play) {
|
||
tone_play_index(IDEX_TONE_ANC_NORMAL_COEFF, ANC_TONE_PREEMPTION);
|
||
}
|
||
#if ANC_COEFF_SAVE_ENABLE
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
//自适应切默认参数，回到当前场景
|
||
anc_mult_scene_set(anc_hdl->scene_id);
|
||
#else
|
||
if (audio_anc_db_cfg_read()) {
|
||
return 1;
|
||
}
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
#endif/*ANC_COEFF_SAVE_ENABLE*/
|
||
break;
|
||
case 1:
|
||
if (((!anc_hdl->param.adaptive->lff_coeff) && anc_hdl->param.lff_en) || \
|
||
((!anc_hdl->param.adaptive->lfb_coeff) && anc_hdl->param.lfb_en) || \
|
||
((!anc_hdl->param.adaptive->rff_coeff) && anc_hdl->param.rff_en) || \
|
||
((!anc_hdl->param.adaptive->rfb_coeff) && anc_hdl->param.rfb_en)) {
|
||
g_printf("anc no adaptive data\n");
|
||
return 1;
|
||
}
|
||
if (tone_play) {
|
||
tone_play_index(IDEX_TONE_ANC_ADAPTIVE_COEFF, ANC_TONE_PREEMPTION);
|
||
}
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
//载入场景参数-提供自适应部分成功时，匹配使用。
|
||
u8 scene_id = ANC_MULT_ADPTIVE_MATCH_USE_ID ? ANC_MULT_ADPTIVE_MATCH_USE_ID : anc_hdl->scene_id;
|
||
anc_mult_scene_set(scene_id);
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
audio_anc_ear_adaptive_param_init(&anc_hdl->param); //初始化自适应固定配置参数
|
||
#if ANC_CH & ANC_L_CH
|
||
if (result & ANC_ADAPTIVE_RESULT_LFF) {
|
||
user_anc_log("adaptive coeff set lff\n");
|
||
anc_hdl->param.gains.l_ffgain = (anc_hdl->adaptive_iir.lff_gain < 0) ? (0 - anc_hdl->adaptive_iir.lff_gain) : anc_hdl->adaptive_iir.lff_gain;
|
||
anc_hdl->param.lff_yorder = ANC_ADAPTIVE_FF_ORDER;
|
||
anc_hdl->param.lff_coeff = anc_hdl->param.adaptive->lff_coeff;
|
||
}
|
||
if (result & ANC_ADAPTIVE_RESULT_LFB) {
|
||
user_anc_log("adaptive coeff set lfb\n");
|
||
anc_hdl->param.gains.l_fbgain = (anc_hdl->adaptive_iir.lfb_gain < 0) ? (0 - anc_hdl->adaptive_iir.lfb_gain) : anc_hdl->adaptive_iir.lfb_gain;
|
||
anc_hdl->param.lfb_yorder = ANC_ADAPTIVE_FB_ORDER;
|
||
anc_hdl->param.lfb_coeff = anc_hdl->param.adaptive->lfb_coeff;
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
if (result & ANC_ADAPTIVE_RESULT_LCMP) {
|
||
user_anc_log("adaptive coeff set lcmp\n");
|
||
anc_hdl->param.gains.l_cmpgain = (anc_hdl->adaptive_iir.lcmp_gain < 0) ? (0 - anc_hdl->adaptive_iir.lcmp_gain) : anc_hdl->adaptive_iir.lcmp_gain;
|
||
anc_hdl->param.lcmp_coeff = anc_hdl->param.adaptive->lcmp_coeff;
|
||
anc_hdl->param.lcmp_yorder = ANC_ADAPTIVE_CMP_ORDER;
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CH*/
|
||
|
||
#if ANC_CH & ANC_R_CH
|
||
if (result & ANC_ADAPTIVE_RESULT_RFF) {
|
||
user_anc_log("adaptive coeff set rff\n");
|
||
anc_hdl->param.gains.r_ffgain = (anc_hdl->adaptive_iir.rff_gain < 0) ? (0 - anc_hdl->adaptive_iir.rff_gain) : anc_hdl->adaptive_iir.rff_gain;
|
||
anc_hdl->param.rff_yorder = ANC_ADAPTIVE_FF_ORDER;
|
||
anc_hdl->param.rff_coeff = anc_hdl->param.adaptive->rff_coeff;
|
||
}
|
||
if (result & ANC_ADAPTIVE_RESULT_RFB) {
|
||
user_anc_log("adaptive coeff set rfb\n");
|
||
anc_hdl->param.gains.r_fbgain = (anc_hdl->adaptive_iir.rfb_gain < 0) ? (0 - anc_hdl->adaptive_iir.rfb_gain) : anc_hdl->adaptive_iir.rfb_gain;
|
||
anc_hdl->param.rfb_yorder = ANC_ADAPTIVE_FB_ORDER;
|
||
anc_hdl->param.rfb_coeff = anc_hdl->param.adaptive->rfb_coeff;
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
if (result & ANC_ADAPTIVE_RESULT_RCMP) {
|
||
user_anc_log("adaptive coeff set rcmp\n");
|
||
anc_hdl->param.gains.r_cmpgain = (anc_hdl->adaptive_iir.rcmp_gain < 0) ? (0 - anc_hdl->adaptive_iir.rcmp_gain) : anc_hdl->adaptive_iir.rcmp_gain;
|
||
anc_hdl->param.rcmp_coeff = anc_hdl->param.adaptive->rcmp_coeff;
|
||
anc_hdl->param.rcmp_yorder = ANC_ADAPTIVE_CMP_ORDER;
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CH*/
|
||
|
||
break;
|
||
default:
|
||
return 1;
|
||
}
|
||
if ((anc_hdl->param.mode == ANC_ON) && update_flag) { //实时更新填入使用
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_RESET, 1);
|
||
/* audio_anc_reset(&anc_hdl->param); */
|
||
}
|
||
|
||
//put_buf(param->lff_coeff, ANC_ADAPTIVE_FF_ORDER * 5 * 8);
|
||
//put_buf(param->lfb_coeff, ANC_ADAPTIVE_FB_ORDER * 5 * 8);
|
||
//put_buf(param->lcmp_coeff, ANC_ADAPTIVE_CMP_ORDER * 5 * 8);
|
||
return 0;
|
||
}
|
||
|
||
void audio_anc_adaptive_data_format(anc_adaptive_iir_t *iir)
|
||
{
|
||
if (anc_hdl->ear_adaptive_data_from == ANC_ADAPTIVE_DATA_EMPTY) {
|
||
anc_hdl->ear_adaptive_data_from = ANC_ADAPTIVE_DATA_FROM_VM;
|
||
if (anc_hdl->param.lff_en) {
|
||
anc_hdl->param.adaptive->lff_coeff = malloc(ANC_ADAPTIVE_FF_ORDER * sizeof(double) * 5);
|
||
}
|
||
if (anc_hdl->param.lfb_en) {
|
||
anc_hdl->param.adaptive->lfb_coeff = malloc(ANC_ADAPTIVE_FB_ORDER * sizeof(double) * 5);
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
anc_hdl->param.adaptive->lcmp_coeff = malloc(ANC_ADAPTIVE_CMP_ORDER * sizeof(double) * 5);
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
}
|
||
if (anc_hdl->param.rff_en) {
|
||
anc_hdl->param.adaptive->rff_coeff = malloc(ANC_ADAPTIVE_FF_ORDER * sizeof(double) * 5);
|
||
}
|
||
if (anc_hdl->param.rfb_en) {
|
||
anc_hdl->param.adaptive->rfb_coeff = malloc(ANC_ADAPTIVE_FB_ORDER * sizeof(double) * 5);
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
anc_hdl->param.adaptive->rcmp_coeff = malloc(ANC_ADAPTIVE_CMP_ORDER * sizeof(double) * 5);
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
}
|
||
|
||
anc_iir_t iir_lib; // 库与外部指针分离
|
||
#if ANC_CONFIG_LFF_EN
|
||
iir_lib.lff = anc_hdl->adaptive_iir.lff;
|
||
#endif/*ANC_CONFIG_LFF_EN*/
|
||
#if ANC_CONFIG_LFB_EN
|
||
iir_lib.lfb = anc_hdl->adaptive_iir.lfb;
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
iir_lib.lcmp = anc_hdl->adaptive_iir.lcmp;
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CONFIG_LFB_EN*/
|
||
#if ANC_CONFIG_RFF_EN
|
||
iir_lib.rff = anc_hdl->adaptive_iir.rff;
|
||
#endif/*ANC_CONFIG_RFF_EN*/
|
||
#if ANC_CONFIG_RFB_EN
|
||
iir_lib.rfb = anc_hdl->adaptive_iir.rfb;
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
iir_lib.rcmp = anc_hdl->adaptive_iir.rcmp;
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CONFIG_RFB_EN*/
|
||
audio_anc_adaptive_data_analsis(&iir_lib);
|
||
}
|
||
}
|
||
|
||
int audio_anc_adaptive_data_save(anc_adaptive_iir_t *iir)
|
||
{
|
||
printf("%s\n", __func__);
|
||
#if ANC_DEVELOPER_MODE_EN
|
||
//保存前做数据格式处理，避免数据异常导致上电转换数据死机
|
||
anc_hdl->ear_adaptive_data_from = ANC_ADAPTIVE_DATA_EMPTY;
|
||
audio_anc_adaptive_data_format(iir);
|
||
#endif/*ANC_DEVELOPER_MODE_EN*/
|
||
int ret = syscfg_write(CFG_ANC_ADAPTIVE_DATA_ID, (u8 *)iir, sizeof(anc_adaptive_iir_t));
|
||
/* printf("vmdata_num %d\n", *vmdata_num); */
|
||
/* put_buf((u8*)vmdata_FL, EAR_RECORD_MAX*25*4); */
|
||
/* put_buf((u8*)vmdata_FR, EAR_RECORD_MAX*25*4); */
|
||
g_printf("ret %d, %d\n", ret, sizeof(anc_adaptive_iir_t));
|
||
return ret;
|
||
}
|
||
|
||
|
||
int audio_anc_adaptive_data_read(anc_adaptive_iir_t *iir)
|
||
{
|
||
int ret = syscfg_read(CFG_ANC_ADAPTIVE_DATA_ID, (u8 *)iir, sizeof(anc_adaptive_iir_t));
|
||
if (ret == sizeof(anc_adaptive_iir_t)) { //能读取到参数, 则默认进入自适应
|
||
if (!CRC16((u8 *)iir, sizeof(anc_adaptive_iir_t))) { //读到的数全为0
|
||
r_printf("adaptive data is emtpy!!!\n");
|
||
return -1;
|
||
}
|
||
g_printf("do adaptive, ret %d\n", ret);
|
||
|
||
} else {
|
||
return -1;
|
||
//给予自适应默认参数
|
||
}
|
||
|
||
audio_anc_adaptive_poweron_catch_data(iir); //开机需确认左右耳
|
||
audio_anc_adaptive_data_format(iir);
|
||
audio_anc_coeff_adaptive_set(ANC_COEFF_MODE_ADAPTIVE, 0, 0);
|
||
return 0;
|
||
}
|
||
|
||
/*判断当前是否处于训练中*/
|
||
u8 audio_anc_adaptive_busy_get(void)
|
||
{
|
||
return anc_hdl->ear_adaptive_busy;
|
||
}
|
||
|
||
/* 自适应默认参数更新 */
|
||
void audio_anc_ear_adaptive_param_init(audio_anc_t *param)
|
||
{
|
||
param->gains.ff_1st_dcc = icsd_dcc[0];
|
||
param->gains.ff_2nd_dcc = icsd_dcc[1];
|
||
param->gains.fb_1st_dcc = icsd_dcc[2];
|
||
param->gains.fb_2nd_dcc = icsd_dcc[3];
|
||
}
|
||
|
||
void audio_anc_adaptive_fr_fail_fill(u8 *dat, u8 order, u8 result)
|
||
{
|
||
u8 fr_fail[13] = {0x2, 0x0, 0x0, 0xc8, 0x42, \
|
||
0x0, 0x0, 0x0, 0x0, \
|
||
0x0, 0x0, 0x80, 0x3f
|
||
};
|
||
if (!result) {
|
||
for (int i = 0; i < order; i++) {
|
||
memcpy(dat + 4 + i * 13, fr_fail, 13);
|
||
}
|
||
}
|
||
}
|
||
|
||
extern void anc_packet_show(anc_packet_data_t *packet);
|
||
void audio_anc_adaptive_data_packet(struct icsd_anc_tool_data *TOOL_DATA)
|
||
{
|
||
int len = TOOL_DATA->h_len;
|
||
int fb_yorder = TOOL_DATA->yorderb;
|
||
int ff_yorder = TOOL_DATA->yorderf;
|
||
int cmp_yorder = TOOL_DATA->yorderc;
|
||
|
||
int ff_dat_len = sizeof(anc_fr_t) * ff_yorder + 4;
|
||
int fb_dat_len = sizeof(anc_fr_t) * fb_yorder + 4;
|
||
int cmp_dat_len = sizeof(anc_fr_t) * cmp_yorder + 4;
|
||
anc_adaptive_iir_t *iir = &anc_hdl->adaptive_iir;
|
||
u8 *ff_dat, *fb_dat, *cmp_dat, *rff_dat, *rfb_dat, *rcmp_dat;
|
||
u8 result = icsd_anc_train_result_get(TOOL_DATA);
|
||
|
||
anc_hdl->adaptive_iir.result = result; //记录当前参数的保存结果;
|
||
|
||
#if ANC_CONFIG_LFF_EN
|
||
ff_dat = (u8 *)&iir->lff_gain;
|
||
audio_anc_fr_format(ff_dat, TOOL_DATA->data_out5, ff_yorder, ff_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(ff_dat, ff_yorder, (result & ANC_ADAPTIVE_RESULT_LFF));
|
||
#endif/*ANC_CONFIG_LFF_EN*/
|
||
#if ANC_CONFIG_LFB_EN
|
||
fb_dat = (u8 *)&iir->lfb_gain;
|
||
audio_anc_fr_format(fb_dat, TOOL_DATA->data_out4, fb_yorder, fb_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(fb_dat, fb_yorder, (result & ANC_ADAPTIVE_RESULT_LFB));
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
cmp_dat = (u8 *)&iir->lcmp_gain;
|
||
audio_anc_fr_format(cmp_dat, TOOL_DATA->data_out11, cmp_yorder, cmp_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(cmp_dat, cmp_yorder, (result & ANC_ADAPTIVE_RESULT_LCMP));
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CONFIG_LFB_EN*/
|
||
#if ANC_CONFIG_RFF_EN
|
||
rff_dat = (u8 *)&iir->rff_gain;
|
||
if (!ANC_CONFIG_LFF_EN) { //TWS 单R声道使用
|
||
ff_dat = rff_dat;
|
||
audio_anc_fr_format(ff_dat, TOOL_DATA->data_out5, ff_yorder, ff_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(ff_dat, ff_yorder, (result & ANC_ADAPTIVE_RESULT_LFF));
|
||
} else {
|
||
audio_anc_fr_format(rff_dat, TOOL_DATA->data_out10, ff_yorder, ff_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(rff_dat, ff_yorder, (result & ANC_ADAPTIVE_RESULT_RFF));
|
||
}
|
||
#endif/*ANC_CONFIG_RFF_EN*/
|
||
#if ANC_CONFIG_RFB_EN
|
||
rfb_dat = (u8 *)&iir->rfb_gain;
|
||
if (!ANC_CONFIG_LFB_EN) { //TWS 单R声道使用
|
||
fb_dat = rfb_dat;
|
||
audio_anc_fr_format(fb_dat, TOOL_DATA->data_out4, fb_yorder, fb_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(fb_dat, fb_yorder, (result & ANC_ADAPTIVE_RESULT_LFB));
|
||
} else {
|
||
audio_anc_fr_format(rfb_dat, TOOL_DATA->data_out9, fb_yorder, fb_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(rfb_dat, fb_yorder, (result & ANC_ADAPTIVE_RESULT_RFB));
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
rcmp_dat = (u8 *)&iir->rcmp_gain;
|
||
if (!ANC_CONFIG_LFB_EN) { //TWS 单R声道使用
|
||
cmp_dat = rcmp_dat;
|
||
audio_anc_fr_format(cmp_dat, TOOL_DATA->data_out11, cmp_yorder, cmp_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(cmp_dat, cmp_yorder, (result & ANC_ADAPTIVE_RESULT_LCMP));
|
||
} else {
|
||
audio_anc_fr_format(rcmp_dat, TOOL_DATA->data_out12, cmp_yorder, cmp_iir_type);
|
||
audio_anc_adaptive_fr_fail_fill(rcmp_dat, cmp_yorder, (result & ANC_ADAPTIVE_RESULT_RCMP));
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CONFIG_RFB_EN*/
|
||
|
||
if (anc_hdl->param.developer_mode) {
|
||
printf("-- len = %d\n", len);
|
||
printf("-- ff_yorder = %d\n", ff_yorder);
|
||
printf("-- fb_yorder = %d\n", fb_yorder);
|
||
printf("-- cmp_yorder = %d\n", cmp_yorder);
|
||
/* 先统一申请空间，因为下面不知道什么情况下调用函数 anc_data_catch 时令参数 init_flag 为1 */
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, NULL, 0, 0, 1);
|
||
|
||
#if (ANC_CH == (ANC_L_CH | ANC_R_CH)) //头戴式
|
||
r_printf("ANC ear-adaptive send data\n");
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->h_freq, len * 4, ANC_R_ADAP_FRE, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out6, len * 8, ANC_R_ADAP_SZPZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out7, len * 8, ANC_R_ADAP_PZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out8, len * 8, ANC_R_ADAP_TARGET, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out14, len * 8, ANC_R_ADAP_TARGET_CMP, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)rff_dat, ff_dat_len, ANC_R_FF_IIR, 0); //R_ff
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)rfb_dat, fb_dat_len, ANC_R_FB_IIR, 0); //R_fb
|
||
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->h_freq, len * 4, ANC_L_ADAP_FRE, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out1, len * 8, ANC_L_ADAP_SZPZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out2, len * 8, ANC_L_ADAP_PZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out3, len * 8, ANC_L_ADAP_TARGET, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out13, len * 8, ANC_L_ADAP_TARGET_CMP, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)ff_dat, ff_dat_len, ANC_L_FF_IIR, 0); //L_ff
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)fb_dat, fb_dat_len, ANC_L_FB_IIR, 0); //L_fb
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)cmp_dat, cmp_dat_len, ANC_L_CMP_IIR, 0); //L_cmp
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)rcmp_dat, cmp_dat_len, ANC_R_CMP_IIR, 0); //R_cmp
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#else //入耳式
|
||
#if TCFG_USER_TWS_ENABLE
|
||
extern char bt_tws_get_local_channel(void);
|
||
if (bt_tws_get_local_channel() == 'R') {
|
||
r_printf("ANC ear-adaptive send data, ch:R\n");
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->h_freq, len * 4, ANC_R_ADAP_FRE, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out1, len * 8, ANC_R_ADAP_SZPZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out2, len * 8, ANC_R_ADAP_PZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out3, len * 8, ANC_R_ADAP_TARGET, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out13, len * 8, ANC_R_ADAP_TARGET_CMP, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)ff_dat, ff_dat_len, ANC_R_FF_IIR, 0); //R_ff
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)fb_dat, fb_dat_len, ANC_R_FB_IIR, 0); //R_fb
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)cmp_dat, cmp_dat_len, ANC_R_CMP_IIR, 0); //R_cmp
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
} else
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
{
|
||
r_printf("ANC ear-adaptive send data, ch:L\n");
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->h_freq, len * 4, ANC_L_ADAP_FRE, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out1, len * 8, ANC_L_ADAP_SZPZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out2, len * 8, ANC_L_ADAP_PZ, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out3, len * 8, ANC_L_ADAP_TARGET, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)TOOL_DATA->data_out13, len * 8, ANC_L_ADAP_TARGET_CMP, 0);
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)ff_dat, ff_dat_len, ANC_L_FF_IIR, 0); //L_ff
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)fb_dat, fb_dat_len, ANC_L_FB_IIR, 0); //L_fb
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)cmp_dat, cmp_dat_len, ANC_L_CMP_IIR, 0); //L_cmp
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
}
|
||
#endif /* ANC_CH == (ANC_L_CH | ANC_R_CH) */
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//开机自适应数据拼包，预备工具读取
|
||
void audio_anc_adaptive_poweron_catch_data(anc_adaptive_iir_t *iir)
|
||
{
|
||
if (anc_hdl->param.developer_mode) {
|
||
int i;
|
||
int ff_dat_len = sizeof(anc_fr_t) * ANC_ADAPTIVE_FF_ORDER + 4;
|
||
int fb_dat_len = sizeof(anc_fr_t) * ANC_ADAPTIVE_FB_ORDER + 4;
|
||
int cmp_dat_len = sizeof(anc_fr_t) * ANC_ADAPTIVE_CMP_ORDER + 4;
|
||
u8 *ff_dat, *fb_dat, *cmp_dat, *rff_dat, *rfb_dat, *rcmp_dat;
|
||
audio_anc_t *param = &anc_hdl->param;
|
||
#if ANC_CONFIG_LFF_EN
|
||
ff_dat = (u8 *)&iir->lff_gain;
|
||
#endif/*ANC_CONFIG_LFF_EN*/
|
||
#if ANC_CONFIG_LFB_EN
|
||
fb_dat = (u8 *)&iir->lfb_gain;
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
cmp_dat = (u8 *)&iir->lcmp_gain;
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CONFIG_LFB_EN*/
|
||
#if ANC_CONFIG_RFF_EN
|
||
rff_dat = (u8 *)&iir->rff_gain;
|
||
if (ff_dat == NULL) { //TWS ANC_R_CH使用
|
||
ff_dat = rff_dat;
|
||
}
|
||
#endif/*ANC_CONFIG_RFF_EN*/
|
||
#if ANC_CONFIG_RFB_EN
|
||
rfb_dat = (u8 *)&iir->rfb_gain;
|
||
if (fb_dat == NULL) { //TWS ANC_R_CH使用
|
||
fb_dat = rfb_dat;
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
rcmp_dat = (u8 *)&iir->rcmp_gain;
|
||
if (cmp_dat == NULL) { //TWS ANC_R_CH使用
|
||
cmp_dat = rcmp_dat;
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#endif/*ANC_CONFIG_RFB_EN*/
|
||
|
||
/* 先统一申请空间，因为下面不知道什么情况下调用函数 anc_data_catch 时令参数 init_flag 为1 */
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, NULL, 0, 0, 1);
|
||
#if (ANC_CH == (ANC_L_CH | ANC_R_CH)) //头戴式的耳机
|
||
r_printf("ANC ear-adaptive send data\n");
|
||
if (param->lff_en && param->rff_en) {
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_LFF) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)ff_dat, ff_dat_len, ANC_L_FF_IIR, 0); //L_ff
|
||
}
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_RFF) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)rff_dat, ff_dat_len, ANC_R_FF_IIR, 0); //R_ff
|
||
}
|
||
}
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_LFB) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)fb_dat, fb_dat_len, ANC_L_FB_IIR, 0); //L_fb
|
||
}
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_RFB) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)rfb_dat, fb_dat_len, ANC_R_FB_IIR, 0); //R_fb
|
||
}
|
||
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_LCMP) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)cmp_dat, cmp_dat_len, ANC_L_CMP_IIR, 0); //L_cmp
|
||
}
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_RCMP) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)rcmp_dat, cmp_dat_len, ANC_R_CMP_IIR, 0); //R_cmp
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
#else //入耳式的
|
||
#if TCFG_USER_TWS_ENABLE
|
||
extern char bt_tws_get_local_channel(void);
|
||
if (bt_tws_get_local_channel() == 'R') {
|
||
r_printf("ANC ear-adaptive send data, ch:R\n");
|
||
if (param->lff_en || param->rff_en) {
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_RFF) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)ff_dat, ff_dat_len, ANC_R_FF_IIR, 0); //R_ff
|
||
}
|
||
}
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_RFB) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)fb_dat, fb_dat_len, ANC_R_FB_IIR, 0); //R_fb
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_RCMP) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)cmp_dat, cmp_dat_len, ANC_R_CMP_IIR, 0); //R_cmp
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
} else
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
{
|
||
r_printf("ANC ear-adaptive send data, ch:L\n");
|
||
if (param->lff_en || param->rff_en) {
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_LFF) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)ff_dat, ff_dat_len, ANC_L_FF_IIR, 0); //L_ff
|
||
}
|
||
}
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_LFB) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)fb_dat, fb_dat_len, ANC_L_FB_IIR, 0); //L_fb
|
||
}
|
||
#if ANC_EAR_ADAPTIVE_CMP_EN
|
||
if (iir->result & ANC_ADAPTIVE_RESULT_LCMP) {
|
||
anc_adaptive_data = anc_data_catch(anc_adaptive_data, (u8 *)cmp_dat, cmp_dat_len, ANC_L_CMP_IIR, 0); //L_cmp
|
||
}
|
||
#endif/*ANC_EAR_ADAPTIVE_CMP_EN*/
|
||
}
|
||
#endif /* ANC_CH == (ANC_L_CH | ANC_R_CH) */
|
||
}
|
||
}
|
||
|
||
//左右参数映射
|
||
void audio_anc_param_map(u8 coeff_en, u8 gain_en)
|
||
{
|
||
#if TCFG_USER_TWS_ENABLE && (ANC_CH != (ANC_L_CH | ANC_R_CH))
|
||
if (anc_hdl->param.developer_mode) { //开发者模式左右耳区分使用参数
|
||
if (coeff_en && (!anc_hdl->param.lff_coeff || !anc_hdl->param.rff_coeff || \
|
||
!anc_hdl->param.lfb_coeff || !anc_hdl->param.rfb_coeff)) {
|
||
#if ANC_DEVELOPER_MODE_EN
|
||
ASSERT(0, "(ERROR)ANC adaptive coeff map %x, %x, %x, %x, Maybe anc_coeff.bin is ERR!", \
|
||
anc_hdl->param.lff_coeff, anc_hdl->param.rff_coeff, \
|
||
anc_hdl->param.lfb_coeff, anc_hdl->param.rfb_coeff);
|
||
#else
|
||
user_anc_log("(ERROR)ANC adaptive coeff map %x, %x, %x, %x, Maybe anc_coeff.bin is ERR!", \
|
||
anc_hdl->param.lff_coeff, anc_hdl->param.rff_coeff, \
|
||
anc_hdl->param.lfb_coeff, anc_hdl->param.rfb_coeff);
|
||
#endif/*ANC_DEVELOPER_MODE_EN*/
|
||
}
|
||
if ((ANC_CH == ANC_L_CH) && (bt_tws_get_local_channel() == 'R')) {
|
||
user_anc_log("ANC MAP TWS_RIGHT_CHANNEL\n");
|
||
if (gain_en) {
|
||
anc_hdl->param.gains.l_ffgain = anc_hdl->param.gains.r_ffgain;
|
||
anc_hdl->param.gains.l_fbgain = anc_hdl->param.gains.r_fbgain;
|
||
anc_hdl->param.gains.l_transgain = anc_hdl->param.gains.r_transgain;
|
||
anc_hdl->param.gains.l_cmpgain = anc_hdl->param.gains.r_cmpgain;
|
||
anc_hdl->param.gains.l_ffmic_gain = anc_hdl->param.gains.r_ffmic_gain;
|
||
anc_hdl->param.gains.l_fbmic_gain = anc_hdl->param.gains.r_fbmic_gain;
|
||
anc_hdl->param.gains.gain_sign = (anc_hdl->param.gains.gain_sign >> 4);
|
||
}
|
||
if (coeff_en) {
|
||
anc_hdl->param.lff_coeff = anc_hdl->param.rff_coeff;
|
||
anc_hdl->param.lfb_coeff = anc_hdl->param.rfb_coeff;
|
||
anc_hdl->param.ltrans_coeff = anc_hdl->param.rtrans_coeff;
|
||
anc_hdl->param.lcmp_coeff = anc_hdl->param.rcmp_coeff;
|
||
|
||
anc_hdl->param.lff_yorder = anc_hdl->param.rff_yorder;
|
||
anc_hdl->param.lfb_yorder = anc_hdl->param.rfb_yorder;
|
||
anc_hdl->param.ltrans_yorder = anc_hdl->param.rtrans_yorder;
|
||
anc_hdl->param.lcmp_yorder = anc_hdl->param.rcmp_yorder;
|
||
}
|
||
} else if ((ANC_CH == ANC_R_CH) && (bt_tws_get_local_channel() == 'L')) {
|
||
user_anc_log("ANC MAP TWS_LEFT_CHANNEL\n");
|
||
if (gain_en) {
|
||
anc_hdl->param.gains.r_ffgain = anc_hdl->param.gains.l_ffgain;
|
||
anc_hdl->param.gains.r_fbgain = anc_hdl->param.gains.l_fbgain;
|
||
anc_hdl->param.gains.r_transgain = anc_hdl->param.gains.l_transgain;
|
||
anc_hdl->param.gains.r_cmpgain = anc_hdl->param.gains.l_cmpgain;
|
||
anc_hdl->param.gains.r_ffmic_gain = anc_hdl->param.gains.l_ffmic_gain;
|
||
anc_hdl->param.gains.r_fbmic_gain = anc_hdl->param.gains.l_fbmic_gain;
|
||
anc_hdl->param.gains.gain_sign = (anc_hdl->param.gains.gain_sign << 4);
|
||
}
|
||
if (coeff_en) {
|
||
anc_hdl->param.rff_coeff = anc_hdl->param.lff_coeff;
|
||
anc_hdl->param.rfb_coeff = anc_hdl->param.lfb_coeff;
|
||
anc_hdl->param.rtrans_coeff = anc_hdl->param.ltrans_coeff;
|
||
anc_hdl->param.rcmp_coeff = anc_hdl->param.lcmp_coeff;
|
||
|
||
anc_hdl->param.rff_yorder = anc_hdl->param.lff_yorder;
|
||
anc_hdl->param.rfb_yorder = anc_hdl->param.lfb_yorder;
|
||
anc_hdl->param.rtrans_yorder = anc_hdl->param.ltrans_yorder;
|
||
anc_hdl->param.rcmp_yorder = anc_hdl->param.lcmp_yorder;
|
||
}
|
||
}
|
||
}
|
||
#endif/*TCFG_USER_TWS_ENABLE*/
|
||
|
||
}
|
||
|
||
//临时接口
|
||
void icsd_audio_adc_mic_open(u8 mic_idx, u8 gain, u16 sr, u8 mic_2_dac)
|
||
{
|
||
|
||
}
|
||
|
||
u8 anc_ear_adaptive_seq_get(void)
|
||
{
|
||
if (anc_hdl) {
|
||
return anc_hdl->ear_adaptive_seq;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void anc_ear_adaptive_forced_exit(void)
|
||
{
|
||
if (anc_hdl) {
|
||
if (anc_hdl->ear_adaptive_busy) {
|
||
icsd_anc_forced_exit();
|
||
anc_tone_stop();
|
||
}
|
||
}
|
||
}
|
||
|
||
//ANC自适应训练失败处理回调函数
|
||
void audio_anc_adaptive_fail_callback(u8 anc_err)
|
||
{
|
||
#if (RCSP_ADV_EN && RCSP_ADV_ANC_VOICE && RCSP_ADV_ADAPTIVE_NOISE_REDUCTION)
|
||
extern void set_adaptive_noise_reduction_reset_callback(u8 result);
|
||
set_adaptive_noise_reduction_reset_callback(!anc_err);
|
||
#endif
|
||
if (anc_err == 0) {
|
||
/* user_anc_log("ANC_ADAPTIVE SUCCESS==========================\n"); */
|
||
}
|
||
if (anc_err & ANC_ERR_LR_BALANCE) {
|
||
user_anc_log("ANC_ERR_LR_BALANCE==========================\n");
|
||
}
|
||
if (anc_err & ANC_ERR_SOUND_PRESSURE) {
|
||
user_anc_log("ANC_ERR_SOUND_PRESSURE==========================\n");
|
||
}
|
||
if (anc_err & ANC_ERR_SHAKE) {
|
||
user_anc_log("ANC_ERR_SHAKE==========================\n");
|
||
}
|
||
}
|
||
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
|
||
#if ANC_MULT_ORDER_ENABLE
|
||
|
||
void audio_anc_mult_scene_set(u16 scene_id, u8 update_flag)
|
||
{
|
||
user_anc_log(" audio_anc_mult scene_id set %d\n", scene_id);
|
||
if (audio_anc_mult_scene_id_check(scene_id)) {
|
||
user_anc_log("anc_mult_scene id set err id = %d", scene_id);
|
||
return;
|
||
}
|
||
anc_hdl->scene_id = scene_id;
|
||
#if ANC_EAR_ADAPTIVE_EN
|
||
if (anc_hdl->ear_adaptive_busy) {
|
||
anc_ear_adaptive_forced_exit();
|
||
return;
|
||
}
|
||
//非自适应训练状态，切场景自动切回普通参数
|
||
anc_hdl->param.anc_coeff_mode = ANC_COEFF_MODE_NORMAL;
|
||
#endif/*ANC_EAR_ADAPTIVE_EN*/
|
||
if ((anc_hdl->param.mode != ANC_OFF) && update_flag && \
|
||
!anc_hdl->mode_switch_lock) { //实时更新填入使用
|
||
anc_mult_scene_set(scene_id);
|
||
os_taskq_post_msg("anc", 2, ANC_MSG_RESET, 1);
|
||
}
|
||
}
|
||
|
||
u8 audio_anc_mult_scene_get(void)
|
||
{
|
||
return anc_hdl->scene_id;
|
||
}
|
||
|
||
void audio_anc_mult_scene_max_set(u8 scene_cnt)
|
||
{
|
||
anc_hdl->scene_max = scene_cnt;
|
||
}
|
||
|
||
u8 audio_anc_mult_scene_max_get(void)
|
||
{
|
||
return anc_hdl->scene_max;
|
||
}
|
||
|
||
void audio_anc_mult_scene_switch(u8 tone_flag)
|
||
{
|
||
static u8 cnt = 1;
|
||
if (cnt < audio_anc_mult_scene_max_get()) {
|
||
cnt++;
|
||
} else {
|
||
cnt = 1;
|
||
}
|
||
if (tone_flag) {
|
||
tone_play_index(IDEX_TONE_NUM_0 + cnt, 0);
|
||
}
|
||
audio_anc_mult_scene_set(cnt, 1);
|
||
}
|
||
#endif/*ANC_MULT_ORDER_ENABLE*/
|
||
|
||
//ANC产测/调试模式
|
||
extern struct adc_platform_data adc_data;
|
||
void audio_anc_prodution_mode_set(u8 mode)
|
||
{
|
||
//产测 or 调试模式 关闭非必要的流程
|
||
if (mode && (!anc_hdl->param.production_mode)) { //0->1
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
/*关闭ACOUSTIC_DETECTOR所有模块*/
|
||
if (audio_icsd_adt_is_running()) {
|
||
audio_icsd_adt_close_all();
|
||
}
|
||
adc_data.anc_adt_en = 0; //关闭adc_ch绑定，否则产测使用ADC中断数据会异常
|
||
#endif/* TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
} else if (!mode && (anc_hdl->param.production_mode)) { //1->0
|
||
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
|
||
adc_data.anc_adt_en = 1; //恢复adc_ch绑定
|
||
#endif/* TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
|
||
}
|
||
anc_hdl->param.production_mode = mode;
|
||
}
|
||
|
||
#endif/*TCFG_AUDIO_ANC_ENABLE*/
|