lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7567ddc0883a6fb596606ff9e0c818cf5300ca3b
99_7018_lmx/apps/earphone/audio_enc_mpt_cvp_ctr.c

599 lines
18 KiB
C
Raw Normal View History

first
2025-10-29 13:10:02 +08:00
/*
****************************************************************
* 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 "aec_user.h"
#include "app_main.h"
#include "audio_config.h"
#include "audio_enc.h"
#include "audio_enc_mpt_self.h"
#include "audio_anc.h"
#include "overlay_code.h"
#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;
#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
typedef struct {
u8 dump_cnt;
u8 monitor;
u8 mic_num; //当前MIC个数
u16 mic_id[4];
u16 dut_mic_ch;
struct audio_adc_output_hdl adc_output;
struct adc_mic_ch mic_ch;
s16 *tmp_buf[3];
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, get_max_sys_vol());
dut_cvp_log("cur_vol:%d,max_sys_vol:%d\n", app_audio_get_volume(APP_AUDIO_STATE_MUSIC), get_max_sys_vol());
audio_dac_set_volume(&dac_hdl, app_audio_get_volume(APP_AUDIO_STATE_MUSIC));
audio_dac_set_sample_rate(&dac_hdl, sr);
audio_dac_start(&dac_hdl);
} else {
audio_dac_stop(&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;
u8 talk_id_cnt = 0xff;
//ADC启动不稳定，实测开头大约有50ms 杂音数据, 这里丢弃掉16*8 = 128ms
if (cvp_hdl->dump_cnt < 8) {
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 == 2) {
mic_data[1] = cvp_hdl->tmp_buf[0];
for (u16 i = 0; i < (len >> 1); i++) {
mic_data[0][i] = data[i * 2];
mic_data[1][i] = data[i * 2 + 1];
}
mic_data[1] = data + (len / 2);
memcpy(mic_data[1], cvp_hdl->tmp_buf[0], len);
} else if (cvp_hdl->mic_num == 3) {
mic_data[1] = cvp_hdl->tmp_buf[0];
mic_data[2] = cvp_hdl->tmp_buf[1];
for (u16 i = 0; i < (len >> 1); i++) {
mic_data[0][i] = data[i * 3];
mic_data[1][i] = data[i * 3 + 1];
mic_data[2][i] = data[i * 3 + 2];
}
} else if (cvp_hdl->mic_num == 4) {
mic_data[1] = cvp_hdl->tmp_buf[0];
mic_data[2] = cvp_hdl->tmp_buf[1];
mic_data[3] = cvp_hdl->tmp_buf[2];
for (u16 i = 0; i < (len >> 1); i++) {
mic_data[0][i] = data[i * 4];
mic_data[1][i] = data[i * 4 + 1];
mic_data[2][i] = data[i * 4 + 2];
mic_data[3][i] = data[i * 4 + 3];
}
}
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) { //表示有算法主麦输入
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;
u8 mic_max = A_MIC3 + 1;
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%d: anc_id 0x%x, group_id 0x%x, en %x", mic_type, mic_id, mic_id_tmp[i], mic_en[i]);
return 0;
}
}
#endif/*TCFG_AUDIO_ANC_ENABLE*/
return 1;
}
/*根据mic通道值获取使用的第几个mic*/
static u8 get_mic_num(u8 bit)
{
u8 i = 0;
for (i = 0; i < 4; i++) {
if (bit & 0x1) {
return i;
}
bit >>= 1;
}
return 0;
}
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;
u8 mic_en[4] = {0};
u16 mic_id_tmp[4] = {0};
dut_cvp_log("mic open sr: %d,mic_gain:%d %d %d %d\n", sr, mic_gain[0], mic_gain[1], mic_gain[2], mic_gain[3]);
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)) {
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_0
mic_en[0] = 1;
mic_id_tmp[0] = 1;
#endif
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_1
mic_en[1] = 1;
mic_id_tmp[1] = 1;
#endif
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_2
mic_en[2] = 1;
mic_id_tmp[2] = 1;
#endif
#if TCFG_AUDIO_ADC_MIC_CHA & AUDIO_ADC_MIC_3
mic_en[3] = 1;
mic_id_tmp[3] = 1;
#endif
#if TCFG_AUDIO_DUAL_MIC_ENABLE
//1.1 确定主副MIC-仅支持双麦定位，三麦目前还不支持
#if (TCFG_AUDIO_DMS_MIC_MANAGE == DMS_MASTER_MIC0)
u8 call_cnt = 0;
for (i = 0; i < 4; i++) {
if (mic_id_tmp[i]) {
mic_id_tmp[i] = call_mic_id[call_cnt++];
}
}
#else
u8 call_cnt = 1;
for (i = 0; i < 4; i++) {
if (mic_id_tmp[i]) {
mic_id_tmp[i] = call_mic_id[call_cnt--];
}
}
#endif
#elif TCFG_AUDIO_TRIPLE_MIC_ENABLE //三麦通话
//三麦通话目前需手动指定mic类型
mic_id_tmp[get_mic_num(app_var.talk_mic_ch)] = AUDIO_ENC_MPT_TALK_MIC;
mic_id_tmp[get_mic_num(app_var.talk_ref_mic_ch)] = AUDIO_ENC_MPT_SLAVE_MIC;
mic_id_tmp[get_mic_num(app_var.talk_fb_mic_ch)] = AUDIO_ENC_MPT_TALK_FB_MIC;
/* mic_id_tmp[3] = ; */
#else /*单麦通话*/
for (i = 0; i < 4; i++) {
if (mic_id_tmp[i]) {
mic_id_tmp[i] = AUDIO_ENC_MPT_TALK_MIC;
break;
}
}
#endif/*TCFG_AUDIO_DUAL_MIC_ENABLE*/
}
//2.只测通话MIC，不测试算法输出
if (!(cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT)) {
for (i = 0; i < 4; 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 && (ANC_CH == ANC_R_CH)
audio_enc_mpt_anc_mic_query(ANCR_FF_MIC, AUDIO_ENC_MPT_FF_MIC, mic_en, mic_id_tmp, mic_gain);
#else
audio_enc_mpt_anc_mic_query(ANCL_FF_MIC, AUDIO_ENC_MPT_FF_MIC, mic_en, mic_id_tmp, mic_gain);
#endif/*TCFG_USER_TWS_ENABLE && (ANC_CH == ANC_R_CH)*/
}
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_FB_MIC) {
#if TCFG_USER_TWS_ENABLE && (ANC_CH == ANC_R_CH)
audio_enc_mpt_anc_mic_query(ANCR_FB_MIC, AUDIO_ENC_MPT_FB_MIC, mic_en, mic_id_tmp, mic_gain);
#else
audio_enc_mpt_anc_mic_query(ANCL_FB_MIC, AUDIO_ENC_MPT_FB_MIC, mic_en, mic_id_tmp, mic_gain);
#endif/*TCFG_USER_TWS_ENABLE && (ANC_CH == ANC_R_CH)*/
}
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_RFF_MIC) {
audio_enc_mpt_anc_mic_query(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(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 < 4; 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) {
if (mic_en[0]) {
cvp_hdl->mic_num++;
audio_adc_mic_open(&cvp_hdl->mic_ch, AUDIO_ADC_MIC_0, &adc_hdl);
audio_adc_mic_set_gain(&cvp_hdl->mic_ch, mic_gain[0]);
}
if (mic_en[1]) {
cvp_hdl->mic_num++;
audio_adc_mic1_open(&cvp_hdl->mic_ch, AUDIO_ADC_MIC_1, &adc_hdl);
audio_adc_mic1_set_gain(&cvp_hdl->mic_ch, mic_gain[1]);
}
if (mic_en[2]) {
cvp_hdl->mic_num++;
audio_adc_mic2_open(&cvp_hdl->mic_ch, AUDIO_ADC_MIC_2, &adc_hdl);
audio_adc_mic2_set_gain(&cvp_hdl->mic_ch, mic_gain[2]);
}
if (mic_en[3]) {
cvp_hdl->mic_num++;
audio_adc_mic3_open(&cvp_hdl->mic_ch, AUDIO_ADC_MIC_3, &adc_hdl);
audio_adc_mic3_set_gain(&cvp_hdl->mic_ch, mic_gain[3]);
}
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 < 4; 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]);
}
free(cvp_hdl->mic_buf);
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[4];
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;
mic_gain[0] = app_var.aec_mic_gain;
mic_gain[1] = app_var.aec_mic1_gain;
mic_gain[2] = app_var.aec_mic2_gain;
mic_gain[3] = app_var.aec_mic3_gain;
if (cvp_hdl->dut_mic_ch & AUDIO_ENC_MPT_CVP_OUT) {
overlay_load_code(OVERLAY_AEC);
audio_aec_open(CVP_MIC_SR, -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);
//由于产测对时钟设置不敏感，因此暂定128M
if (clk_get("sys") < 128 * 1000000L) {
clk_set("sys", 128 * 1000000L);
}
return ret;
}
void audio_enc_mpt_fre_response_open(u16 mic_ch)
{
#if TCFG_AUDIO_ANC_ENABLE
//设置为ANC产测模式
audio_anc_prodution_mode_set(1);
#endif/*TCFG_AUDIO_ANC_ENABLE*/
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_cvp_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:
app_var.aec_mic_gain = 15;
app_var.aec_mic1_gain = 15;
app_var.aec_mic2_gain = 15;
app_var.aec_mic3_gain = 15;
mic_ch |= AUDIO_ENC_MPT_CVP_OUT;
mic_ch |= AUDIO_ENC_MPT_TALK_MIC;
/* mic_ch |= AUDIO_ENC_MPT_SLAVE_MIC; */
/* mic_ch |= AUDIO_ENC_MPT_TALK_FB_MIC; */
/* 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*/
Reference in New Issue Copy Permalink