huxi
562 lines
17 KiB
C
562 lines
17 KiB
C
#ifdef SUPPORT_MS_EXTENSIONS
|
|
#pragma bss_seg(".audio_enc_mpt_cvp_ctr.data.bss")
|
|
#pragma data_seg(".audio_enc_mpt_cvp_ctr.data")
|
|
#pragma const_seg(".audio_enc_mpt_cvp_ctr.text.const")
|
|
#pragma code_seg(".audio_enc_mpt_cvp_ctr.text")
|
|
#endif
|
|
/*
|
|
****************************************************************
|
|
* Audio Enc Mass production test self CVP control
|
|
* File : audio_enc_mpt_cvp_crl.c
|
|
* note : 自研ENC产测 CVP通话算法/MIC 控制层
|
|
****************************************************************
|
|
*/
|
|
#include "asm/includes.h"
|
|
#include "media/includes.h"
|
|
#include "system/includes.h"
|
|
#include "app_config.h"
|
|
#include "cvp_user.h"
|
|
#include "app_main.h"
|
|
#include "audio_config.h"
|
|
#include "audio_enc_mpt_self.h"
|
|
#include "overlay_code.h"
|
|
#include "adc_file.h"
|
|
#include "cvp_node.h"
|
|
#if TCFG_AUDIO_ANC_ENABLE
|
|
#include "audio_anc.h"
|
|
#endif
|
|
|
|
#if AUDIO_ENC_MPT_SELF_ENABLE
|
|
|
|
#define DUT_CVP_LOG_ENABLE
|
|
#ifdef DUT_CVP_LOG_ENABLE
|
|
#define dut_cvp_log(x, ...) printf("[enc_mpt_cvp]" x " ", ## __VA_ARGS__)
|
|
#else
|
|
#define dut_cvp_log(...)
|
|
#endif/*DUT_CVP_LOG_ENABLE*/
|
|
|
|
/*
|
|
暂不支持开ANC模式测试
|
|
1没有与ANC复用ADC BUFF
|
|
2没有开动态MIC增益
|
|
*/
|
|
|
|
|
|
extern struct adc_platform_data adc_data;
|
|
extern struct audio_dac_hdl dac_hdl;
|
|
extern struct audio_adc_hdl adc_hdl;
|
|
extern void clock_refurbish(void);
|
|
|
|
#define MIC_BUF_NUM 3
|
|
#define MIC_IRQ_POINTS 256
|
|
|
|
#define CVP_MIC_SR 16000 //采样率
|
|
|
|
#define CVP_MONITOR_DIS 0 //监听关闭
|
|
#define CVP_MONITOR_PROBE 1 //监听处理前数据
|
|
#define CVP_MONITOR_POST 2 //监听处理后数据
|
|
//默认监听选择
|
|
#define CVP_MONITOR_SEL CVP_MONITOR_DIS
|
|
|
|
#define AUDIO_ENC_MPT_MIC_NUM AUDIO_ADC_MAX_NUM //最大ADC个数
|
|
|
|
|
|
typedef struct {
|
|
u8 dump_cnt;
|
|
u8 monitor;
|
|
u8 mic_num; //当前MIC个数
|
|
u16 mic_id[AUDIO_ENC_MPT_MIC_NUM];
|
|
u16 dut_mic_ch;
|
|
struct audio_adc_output_hdl adc_output;
|
|
struct adc_mic_ch mic_ch;
|
|
s16 *tmp_buf[AUDIO_ENC_MPT_MIC_NUM - 1];
|
|
s16 *mic_buf;
|
|
} audio_cvp_t;
|
|
static audio_cvp_t *cvp_hdl = NULL;
|
|
|
|
/* 写卡使能控制, 需注意一下几点
|
|
1、需打开 AUDIO_PCM_DEBUG
|
|
2、AEC原本的写卡流程需关闭
|
|
3、测试流程需包含CVP_OUT测试, 因为写卡只能在线程写
|
|
*/
|
|
#define AUDIO_ENC_MPT_UART_DEBUG_EN 0
|
|
#define AUDIO_ENC_MPT_UART_DEBUG_CH 3 //写卡通道数
|
|
#define AUDIO_ENC_MPT_UART_DEBUG_LEN MIC_IRQ_POINTS * 2 //写卡长度
|
|
|
|
#ifdef AUDIO_PCM_DEBUG
|
|
extern int aec_uart_init();
|
|
extern int aec_uart_open(u8 nch, u16 single_size);
|
|
extern int aec_uart_fill(u8 ch, void *buf, u16 size);
|
|
extern void aec_uart_write(void);
|
|
extern int aec_uart_close(void);
|
|
#endif/*AUDIO_PCM_DEBUG*/
|
|
|
|
/*监听输出：默认输出到dac*/
|
|
static int cvp_monitor_output(s16 *data, int len)
|
|
{
|
|
int wlen = audio_dac_write(&dac_hdl, data, len);
|
|
if (wlen != len) {
|
|
dut_cvp_log("monitor output full\n");
|
|
}
|
|
return wlen;
|
|
}
|
|
|
|
/*监听使能*/
|
|
static int cvp_monitor_en(u8 en, int sr)
|
|
{
|
|
dut_cvp_log("cvp_monitor_en:%d,sr:%d\n", en, sr);
|
|
if (en) {
|
|
app_audio_state_switch(APP_AUDIO_STATE_MUSIC, app_audio_volume_max_query(AppVol_BT_MUSIC), NULL); // 音量状态设置
|
|
audio_dac_set_volume(&dac_hdl, app_audio_volume_max_query(AppVol_BT_MUSIC)); // dac 音量设置
|
|
audio_dac_set_sample_rate(&dac_hdl, sr);
|
|
audio_dac_start(&dac_hdl);
|
|
audio_dac_channel_start(NULL);
|
|
} else {
|
|
audio_dac_stop(&dac_hdl);
|
|
audio_dac_close(&dac_hdl);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
测试前的预处理,
|
|
如方案使用模拟开关复用ADC通道，可以在此切换模拟开关
|
|
*/
|
|
static void audio_enc_mpt_fre_pre(u16 mic_ch)
|
|
{
|
|
#if 0
|
|
//测试算法或者TALK 主MIC
|
|
if (mic_ch & (AUDIO_ENC_MPT_CVP_OUT | AUDIO_ENC_MPT_TALK_MIC)) {
|
|
}
|
|
//测试算法或者TALK 副MIC
|
|
if (mic_ch & (AUDIO_ENC_MPT_CVP_OUT | AUDIO_ENC_MPT_SLAVE_MIC)) {
|
|
}
|
|
//测试算法或者TALK FBMIC
|
|
if (mic_ch & (AUDIO_ENC_MPT_CVP_OUT | AUDIO_ENC_MPT_TALK_FB_MIC)) {
|
|
}
|
|
//测试TWS FFMIC or 头戴式LFF MIC
|
|
if (mic_ch & AUDIO_ENC_MPT_FF_MIC) {
|
|
}
|
|
//测试TWS FBMIC or 头戴式LFB MIC
|
|
if (mic_ch & AUDIO_ENC_MPT_FB_MIC) {
|
|
}
|
|
//测试头戴式RFF MIC
|
|
if (mic_ch & AUDIO_ENC_MPT_RFF_MIC) {
|
|
}
|
|
//测试头戴式RFB MIC
|
|
if (mic_ch & AUDIO_ENC_MPT_RFB_MIC) {
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*mic adc原始数据输出*/
|
|
static void mic_output(void *priv, s16 *data, int len)
|
|
{
|
|
/* putchar('.'); */
|
|
s16 *mic_data[cvp_hdl->mic_num];
|
|
int i, index;
|
|
u8 talk_id_cnt = 0xff;
|
|
//ADC启动不稳定，实测开头大约有50ms 杂音数据, 这里丢弃掉16*8 = 128ms
|
|
#if (defined CONFIG_CPU_BR50)
|
|
if (cvp_hdl->dump_cnt < 8 + 20) { //BR50 ADC稳定需要28*16 = 448ms 后续可以优化
|
|
#else
|
|
if (cvp_hdl->dump_cnt < 8) {
|
|
#endif
|
|
cvp_hdl->dump_cnt++;
|
|
return;
|
|
}
|
|
|
|
mic_data[0] = data;
|
|
//printf("mic_data:%x,%x,%d\n",data,mic1_data_pos,len);
|
|
if (cvp_hdl->mic_num > 1) {
|
|
for (index = 1; index < cvp_hdl->mic_num; index++) {
|
|
mic_data[index] = cvp_hdl->tmp_buf[index - 1];
|
|
}
|
|
for (i = 0; i < (len >> 1); i++) {
|
|
for (index = 0; index < cvp_hdl->mic_num; index++) {
|
|
mic_data[index][i] = data[i * cvp_hdl->mic_num + index];
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < cvp_hdl->mic_num; i++) {
|
|
#if AUDIO_ENC_MPT_UART_DEBUG_EN && (defined AUDIO_PCM_DEBUG)
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
aec_uart_fill(i, mic_data[i], 512);
|
|
}
|
|
#endif/*AUDIO_ENC_MPT_UART_DEBUG_EN*/
|
|
audio_enc_mpt_fre_response_inbuf(cvp_hdl->mic_id[i], mic_data[i], len);
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
#if TCFG_AUDIO_TRIPLE_MIC_ENABLE
|
|
if (cvp_hdl->mic_id[i] & AUDIO_ENC_MPT_TALK_FB_MIC) {
|
|
audio_aec_inbuf_ref_1(mic_data[i], len);
|
|
continue;
|
|
}
|
|
#endif/*TCFG_AUDIO_TRIPLE_MIC_ENABLE*/
|
|
#if TCFG_AUDIO_DUAL_MIC_ENABLE || TCFG_AUDIO_TRIPLE_MIC_ENABLE
|
|
if (cvp_hdl->mic_id[i] & AUDIO_ENC_MPT_SLAVE_MIC) {
|
|
audio_aec_inbuf_ref(mic_data[i], len);
|
|
continue;
|
|
}
|
|
#endif/*TCFG_AUDIO_DUAL_MIC_ENABLE || TCFG_AUDIO_TRIPLE_MIC_ENABLE*/
|
|
if (cvp_hdl->mic_id[i] & AUDIO_ENC_MPT_TALK_MIC) {
|
|
talk_id_cnt = i;
|
|
/* audio_aec_inbuf(mic_data[i], len); */
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
//主麦数据输入触发AEC线程，最后处理
|
|
if (talk_id_cnt != 0xff) { //表示有算法主麦输入
|
|
//cvp 参考数据
|
|
audio_cvp_phase_align();
|
|
|
|
audio_aec_inbuf(mic_data[talk_id_cnt], len);
|
|
}
|
|
|
|
#if CVP_MONITOR_SEL != CVP_MONITOR_DIS
|
|
if (cvp_hdl->monitor == CVP_MONITOR_PROBE) {
|
|
static u8 num = 0;
|
|
static int cnt = 0;
|
|
if (++cnt > 300) {
|
|
cnt = 0;
|
|
if (++num == cvp_hdl->mic_num) {
|
|
num = 0;
|
|
}
|
|
r_printf("num %d", num);
|
|
}
|
|
cvp_monitor_output(mic_data[num], len);
|
|
}
|
|
#endif/*CVP_MONITOR_SEL != CVP_MONITOR_DIS*/
|
|
}
|
|
|
|
static u16 audio_enc_mpt_anc_mic_query(u8 mic_type, u16 mic_id, u8 *mic_en, u16 *mic_id_tmp, u8 *gain)
|
|
{
|
|
#if TCFG_AUDIO_ANC_ENABLE
|
|
u8 i;
|
|
#if (defined CONFIG_CPU_BR28)
|
|
u8 mic_max = A_MIC3 + 1;
|
|
#elif (defined CONFIG_CPU_BR50)
|
|
u8 mic_max = A_MIC4 + 1;
|
|
#else
|
|
/*br36*/
|
|
u8 mic_max = A_MIC1 + 1;
|
|
#endif
|
|
for (i = A_MIC0; i < mic_max; i++) {
|
|
if (mic_type == i) {
|
|
if (!mic_en[i]) {
|
|
//此MIC没有开过，则使用ANC的MIC增益
|
|
gain[i] = audio_anc_mic_gain_get(i);
|
|
}
|
|
mic_en[i] = 1;
|
|
mic_id_tmp[i] |= mic_id;
|
|
dut_cvp_log("ANC mic type %d, id %x, en %x", mic_type, mic_id, mic_en[i]);
|
|
return 0;
|
|
}
|
|
}
|
|
#endif/*TCFG_AUDIO_ANC_ENABLE*/
|
|
return 1;
|
|
}
|
|
|
|
static const u16 call_mic_id[2] = {AUDIO_ENC_MPT_TALK_MIC, AUDIO_ENC_MPT_SLAVE_MIC};
|
|
static int mic_open(u8 *mic_gain, int sr)
|
|
{
|
|
int i, j, index;
|
|
u8 mic_en[AUDIO_ENC_MPT_MIC_NUM] = {0};
|
|
u16 mic_id_tmp[AUDIO_ENC_MPT_MIC_NUM] = {0};
|
|
|
|
/*读取adc配置*/
|
|
audio_adc_file_init();
|
|
/*获取通话adc通道*/
|
|
u8 mic_ch = audio_adc_file_get_mic_en_map();
|
|
/*获取通话mic增益*/
|
|
dut_cvp_log("mic ch %x, mic open sr: %d\n", mic_ch, sr);
|
|
for (index = 0; index < AUDIO_ENC_MPT_MIC_NUM; index++) {
|
|
mic_gain[index] = audio_adc_file_get_gain(index);
|
|
dut_cvp_log("mic%d_gain:%d \n", index, mic_gain[index]);
|
|
}
|
|
|
|
cvp_hdl->dump_cnt = 0;
|
|
//1.测试CVP的输出 or 通话MIC相关 MIC输出
|
|
if (cvp_hdl->dut_mic_ch & (AUDIO_ENC_MPT_CVP_OUT | AUDIO_ENC_MPT_TALK_MIC | \
|
|
AUDIO_ENC_MPT_SLAVE_MIC | AUDIO_ENC_MPT_TALK_FB_MIC)) {
|
|
|
|
for (index = 0; index < AUDIO_ENC_MPT_MIC_NUM; index++) {
|
|
if (mic_ch & BIT(index)) {
|
|
mic_en[index] = 1;
|
|
mic_id_tmp[index] = 1;
|
|
}
|
|
}
|
|
|
|
#if TCFG_AUDIO_DUAL_MIC_ENABLE
|
|
//1.1 确定主副MIC-仅支持双麦定位，三麦目前还不支持
|
|
cvp_param_cfg_read();
|
|
u8 talk_mic = cvp_get_talk_mic_ch();
|
|
u8 talk_ref_mic = cvp_get_talk_ref_mic_ch();
|
|
dut_cvp_log("talk_mic %d, talk_ref_mic %d", talk_mic, talk_ref_mic);
|
|
mic_id_tmp[talk_mic - 1] = AUDIO_ENC_MPT_TALK_MIC;
|
|
mic_id_tmp[talk_ref_mic - 1] = AUDIO_ENC_MPT_SLAVE_MIC;
|
|
#elif TCFG_AUDIO_TRIPLE_MIC_ENABLE
|
|
//三麦通话目前需手动指定mic类型
|
|
mic_id_tmp[0] = AUDIO_ENC_MPT_TALK_MIC;
|
|
mic_id_tmp[1] = AUDIO_ENC_MPT_SLAVE_MIC;
|
|
mic_id_tmp[2] = AUDIO_ENC_MPT_TALK_FB_MIC;
|
|
/* mic_id_tmp[3] = ; */
|
|
#elif (defined TCFG_AUDIO_CVP_DEVELOP_ENABLE) //第三方算法通道映射
|
|
#else
|
|
for (i = 0; i < AUDIO_ENC_MPT_MIC_NUM; i++) {
|
|
if ((mic_ch >> i) & 0x01) {
|
|
mic_id_tmp[i] = AUDIO_ENC_MPT_TALK_MIC;
|
|
}
|
|
}
|
|
#endif/*TCFG_AUDIO_DUAL_MIC_ENABLE*/
|
|
|
|
|
|
}
|
|
//2.只测通话MIC，不测试算法输出
|
|
if (!(cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT)) {
|
|
for (i = 0; i < AUDIO_ENC_MPT_MIC_NUM; i++) {
|
|
//清除非目标MIC的使能
|
|
if (!(cvp_hdl->dut_mic_ch & mic_id_tmp[i])) {
|
|
mic_id_tmp[i] = 0;
|
|
mic_en[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//3.ANC MIC映射
|
|
#if TCFG_AUDIO_ANC_ENABLE
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_FF_MIC) {
|
|
#if TCFG_USER_TWS_ENABLE && (TCFG_AUDIO_ANC_CH == ANC_R_CH)
|
|
audio_enc_mpt_anc_mic_query(TCFG_AUDIO_ANCR_FF_MIC, AUDIO_ENC_MPT_FF_MIC, mic_en, mic_id_tmp, mic_gain);
|
|
#else
|
|
audio_enc_mpt_anc_mic_query(TCFG_AUDIO_ANCL_FF_MIC, AUDIO_ENC_MPT_FF_MIC, mic_en, mic_id_tmp, mic_gain);
|
|
#endif/*TCFG_USER_TWS_ENABLE && (TCFG_AUDIO_ANC_CH == ANC_R_CH)*/
|
|
}
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_FB_MIC) {
|
|
#if TCFG_USER_TWS_ENABLE && (TCFG_AUDIO_ANC_CH == ANC_R_CH)
|
|
audio_enc_mpt_anc_mic_query(TCFG_AUDIO_ANCR_FB_MIC, AUDIO_ENC_MPT_FB_MIC, mic_en, mic_id_tmp, mic_gain);
|
|
#else
|
|
audio_enc_mpt_anc_mic_query(TCFG_AUDIO_ANCL_FB_MIC, AUDIO_ENC_MPT_FB_MIC, mic_en, mic_id_tmp, mic_gain);
|
|
#endif/*TCFG_USER_TWS_ENABLE && (TCFG_AUDIO_ANC_CH == ANC_R_CH)*/
|
|
}
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_RFF_MIC) {
|
|
audio_enc_mpt_anc_mic_query(TCFG_AUDIO_ANCR_FF_MIC, AUDIO_ENC_MPT_RFF_MIC, mic_en, mic_id_tmp, mic_gain);
|
|
}
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_RFB_MIC) {
|
|
audio_enc_mpt_anc_mic_query(TCFG_AUDIO_ANCR_FB_MIC, AUDIO_ENC_MPT_RFB_MIC, mic_en, mic_id_tmp, mic_gain);
|
|
}
|
|
#endif/*TCFG_AUDIO_ANC_ENABLE*/
|
|
|
|
//4.重新排列数组, 兼容ADC_BUFF的缓存结构
|
|
j = 0;
|
|
for (i = 0; i < AUDIO_ENC_MPT_MIC_NUM; i++) {
|
|
if (mic_id_tmp[i]) {
|
|
cvp_hdl->mic_id[j++] = mic_id_tmp[i];
|
|
}
|
|
}
|
|
|
|
//5.ADC初始化
|
|
audio_mic_pwr_ctl(MIC_PWR_ON);
|
|
if (cvp_hdl) {
|
|
for (index = 0; index < AUDIO_ENC_MPT_MIC_NUM; index++) {
|
|
if (mic_en[index]) {
|
|
cvp_hdl->mic_num++;
|
|
adc_file_mic_open(&cvp_hdl->mic_ch, BIT(index));
|
|
audio_adc_mic_set_gain(&cvp_hdl->mic_ch, BIT(index), mic_gain[index]);
|
|
}
|
|
}
|
|
if (!cvp_hdl->mic_num) {
|
|
dut_cvp_log("Error valid mic_num is zero!\n");
|
|
return 1;
|
|
}
|
|
|
|
//5.1 ADC临时BUFF、ISR BUFF申请
|
|
for (i = 1; i < cvp_hdl->mic_num; i++) {
|
|
cvp_hdl->tmp_buf[i - 1] = malloc(MIC_IRQ_POINTS * sizeof(short));
|
|
}
|
|
cvp_hdl->mic_buf = malloc(cvp_hdl->mic_num * MIC_BUF_NUM * MIC_IRQ_POINTS * sizeof(short));
|
|
|
|
audio_adc_mic_set_sample_rate(&cvp_hdl->mic_ch, sr);
|
|
audio_adc_mic_set_buffs(&cvp_hdl->mic_ch, cvp_hdl->mic_buf, MIC_IRQ_POINTS * 2, MIC_BUF_NUM);
|
|
|
|
cvp_hdl->adc_output.handler = mic_output;
|
|
audio_adc_add_output_handler(&adc_hdl, &cvp_hdl->adc_output);
|
|
audio_adc_mic_start(&cvp_hdl->mic_ch);
|
|
}
|
|
dut_cvp_log("mic_open succ mic_num %d\n", cvp_hdl->mic_num);
|
|
for (i = 0; i < AUDIO_ENC_MPT_MIC_NUM; i++) {
|
|
dut_cvp_log("mic%d_id 0x%x, en %d, gain %d\n", i, cvp_hdl->mic_id[i], mic_en[i], mic_gain[i]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void mic_close(void)
|
|
{
|
|
if (cvp_hdl) {
|
|
audio_adc_mic_close(&cvp_hdl->mic_ch);
|
|
audio_adc_del_output_handler(&adc_hdl, &cvp_hdl->adc_output);
|
|
for (int i = 1; i < cvp_hdl->mic_num; i++) {
|
|
free(cvp_hdl->tmp_buf[i - 1]);
|
|
}
|
|
if (cvp_hdl->mic_buf) {
|
|
//在adc 驱动中释放了这个buffer
|
|
/* free(cvp_hdl->mic_buf); */
|
|
cvp_hdl->mic_buf = NULL;
|
|
}
|
|
audio_mic_pwr_ctl(MIC_PWR_OFF);
|
|
}
|
|
}
|
|
|
|
/*清晰语音数据输出*/
|
|
static int cvp_output_hdl(s16 *data, u16 len)
|
|
{
|
|
/* putchar('o'); */
|
|
|
|
audio_enc_mpt_fre_response_inbuf(AUDIO_ENC_MPT_CVP_OUT, data, len);
|
|
#if AUDIO_ENC_MPT_UART_DEBUG_EN && (defined AUDIO_PCM_DEBUG)
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
aec_uart_fill(2, data, 512);
|
|
aec_uart_write();
|
|
}
|
|
#endif/*AUDIO_ENC_MPT_UART_DEBUG_EN*/
|
|
#if !AUDIO_ENC_MPT_FRERES_ASYNC
|
|
audio_enc_mpt_fre_response_post_run(0);
|
|
#endif/*AUDIO_ENC_MPT_FRERES_ASYNC*/
|
|
|
|
#if CVP_MONITOR_SEL != CVP_MONITOR_DIS
|
|
if (cvp_hdl->monitor == CVP_MONITOR_POST) {
|
|
cvp_monitor_output(data, len);
|
|
}
|
|
#endif/*CVP_MONITOR_SEL != CVP_MONITOR_DIS*/
|
|
return len;
|
|
}
|
|
|
|
int audio_enc_mpt_cvp_close(void)
|
|
{
|
|
if (cvp_hdl != NULL) {
|
|
#if AUDIO_ENC_MPT_UART_DEBUG_EN && (defined AUDIO_PCM_DEBUG)
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
aec_uart_close();
|
|
}
|
|
#endif/*AUDIO_ENC_MPT_UART_DEBUG_EN*/
|
|
#if CVP_MONITOR_SEL != CVP_MONITOR_DIS
|
|
if (cvp_hdl->monitor) {
|
|
cvp_monitor_en(0, CVP_MIC_SR);
|
|
}
|
|
#endif/* CVP_MONITOR_SEL != CVP_MONITOR_DIS*/
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
audio_aec_close();
|
|
}
|
|
//先关AEC再关MIC
|
|
mic_close();
|
|
free(cvp_hdl);
|
|
cvp_hdl = NULL;
|
|
dut_cvp_log("cvp_hdl close\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int audio_enc_mpt_cvp_open(u16 mic_ch)
|
|
{
|
|
int ret = 0;
|
|
u8 mic_gain[AUDIO_ENC_MPT_MIC_NUM];
|
|
if (cvp_hdl) {
|
|
//支持重入
|
|
audio_enc_mpt_cvp_close();
|
|
dut_cvp_log("dut_cvp start again\n");
|
|
}
|
|
#if AUDIO_ENC_MPT_UART_DEBUG_EN && (defined AUDIO_PCM_DEBUG)
|
|
if (mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
aec_uart_open(AUDIO_ENC_MPT_UART_DEBUG_CH, AUDIO_ENC_MPT_UART_DEBUG_LEN);
|
|
}
|
|
#endif/*AUDIO_ENC_MPT_UART_DEBUG_EN*/
|
|
dut_cvp_log("cvp_hdl open, mic_ch %x\n", mic_ch);
|
|
cvp_hdl = zalloc(sizeof(audio_cvp_t));
|
|
ASSERT(cvp_hdl);
|
|
audio_enc_mpt_fre_pre(mic_ch);
|
|
#if CVP_MONITOR_SEL != CVP_MONITOR_DIS
|
|
cvp_hdl->monitor = CVP_MONITOR_SEL;
|
|
if (cvp_hdl->monitor) {
|
|
cvp_monitor_en(1, CVP_MIC_SR);
|
|
}
|
|
#endif/* CVP_MONITOR_SEL != CVP_MONITOR_DIS*/
|
|
cvp_hdl->dut_mic_ch = mic_ch;
|
|
|
|
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
|
|
struct audio_aec_init_param_t init_param;
|
|
init_param.sample_rate = CVP_MIC_SR;
|
|
init_param.ref_sr = 0;
|
|
audio_aec_open(&init_param, -1, cvp_output_hdl);
|
|
#if 1//TCFG_AUDIO_CVP_NS_MODE == CVP_DNS_MODE
|
|
//默认关闭DNS
|
|
audio_cvp_ioctl(CVP_NS_SWITCH, 0, NULL); //降噪关
|
|
#endif/*TCFG_AUDIO_CVP_NS_MODE*/
|
|
}
|
|
ret = mic_open(mic_gain, CVP_MIC_SR);
|
|
return ret;
|
|
}
|
|
|
|
void audio_enc_mpt_fre_response_open(u16 mic_ch)
|
|
{
|
|
clock_refurbish();
|
|
audio_enc_mpt_fre_response_start(mic_ch);
|
|
if (audio_enc_mpt_cvp_open(mic_ch)) {
|
|
audio_enc_mpt_fre_response_release();
|
|
}
|
|
}
|
|
|
|
void audio_enc_mpt_fre_response_close(void)
|
|
{
|
|
audio_enc_mpt_fre_response_stop();
|
|
audio_enc_mpt_cvp_close();
|
|
}
|
|
|
|
|
|
static u8 audio_cvp_idle_query()
|
|
{
|
|
return (cvp_hdl == NULL) ? 1 : 0;
|
|
}
|
|
|
|
REGISTER_LP_TARGET(audio_enc_mpt_lp_target) = {
|
|
.name = "audio_cvp",
|
|
.is_idle = audio_cvp_idle_query,
|
|
};
|
|
|
|
//测试func
|
|
void audio_enc_mpt_cvp_key_test()
|
|
{
|
|
static u8 cnt = 0;
|
|
u16 mic_ch = 0;
|
|
dut_cvp_log("cnt %d\n", cnt);
|
|
|
|
mem_stats();
|
|
switch (cnt) {
|
|
case 0:
|
|
mic_ch |= AUDIO_ENC_MPT_CH_TWS_CVP_ENC;
|
|
/* mic_ch |= AUDIO_ENC_MPT_FF_MIC; */
|
|
/* mic_ch |= AUDIO_ENC_MPT_FB_MIC; */
|
|
/* mic_ch |= AUDIO_ENC_MPT_RFF_MIC; */
|
|
/* mic_ch |= AUDIO_ENC_MPT_RFB_MIC; */
|
|
audio_enc_mpt_fre_response_open(mic_ch);
|
|
break;
|
|
case 1:
|
|
audio_enc_mpt_fre_response_close();
|
|
break;
|
|
case 2:
|
|
u8 *buf;
|
|
audio_enc_mpt_fre_response_file_get(&buf);
|
|
break;
|
|
case 3:
|
|
audio_enc_mpt_fre_response_release();
|
|
break;
|
|
}
|
|
cnt++;
|
|
if (cnt > 3) {
|
|
cnt = 0;
|
|
}
|
|
}
|
|
|
|
#endif/*AUDIO_ENC_MPT_SELF_ENABLE*/
|