lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first

Browse Source
This commit is contained in:
lmx
2025-10-29 13:10:02 +08:00
commit 49a07fa419
2284 changed files with 642060 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

447
cpu/br28/audio_demo/audio_adc_demo.c Normal file
View File

@ -0,0 +1,447 @@
/*
****************************************************************************
* Audio ADC Demo
*
*Description : Audio ADC使用范例
*Notes : (1)本demo为开发测试范例，请不要修改该demo， 如有需求，请自行
* 复制再修改
* (2)mic工作模式说明
* A.单端隔直(cap_mode)
* 可以选择mic供电方式：外部供电还是内部供电(mic_bias_inside = 1)
* B.单端省电容(capless_mode)
* C.差分模式(cap_diff_mode)
****************************************************************************
*/
#include "asm/includes.h"
#include "media/includes.h"
#include "system/includes.h"
#include "app_main.h"
#include "audio_config.h"
#include "audio_demo.h"
#include "asm/audio_adc.h"
#if 1
#define ADC_DEMO_LOG printf
#else
#define ADC_DEMO_LOG(...)
#endif
extern struct audio_dac_hdl dac_hdl;
extern struct audio_adc_hdl adc_hdl;
#define ADC_DEMO_CH_NUM 4 /*支持的最大采样通道(max = 2)*/
#define ADC_DEMO_BUF_NUM 2 /*采样buf数*/
#define ADC_DEMO_IRQ_POINTS 256 /*采样中断点数*/
#define ADC_DEMO_BUFS_SIZE (ADC_DEMO_CH_NUM * ADC_DEMO_BUF_NUM * ADC_DEMO_IRQ_POINTS)
struct adc_demo {
u8 adc_2_dac;
u8 mic_idx;
u8 linein_idx;
struct audio_adc_output_hdl adc_output;
struct adc_mic_ch mic_ch;
struct adc_linein_ch linein_ch;
s16 adc_buf[ADC_DEMO_BUFS_SIZE];
u8 linein_ch_num;
u8 linein_ch_sel;
};
static struct adc_demo *mic_demo = NULL;
static struct adc_demo *linein_demo = NULL;
/* 选择输出哪路 linein采样的数据,可通过按键调用此函数实现每按一下按键切一下输出的linein通路 */
void linein_output_channel_sel()
{
if (linein_demo) {
linein_demo->linein_ch_sel += 1;
if (linein_demo->linein_ch_sel > linein_demo->linein_ch_num - 1) {
linein_demo->linein_ch_sel = 0;
}
}
}
/*
*********************************************************************
* AUDIO MIC OUTPUT
* Description: mic采样数据回调
* Arguments : pric 私有参数
* data mic数据
* len 数据长度
* Return : 0 成功 其他 失败
* Note(s) : 单声道数据格式
* L0 L1 L2 L3 L4 ...
* 双声道数据格式()
* L0 R0 L1 R1 L2 R2...
*********************************************************************
*/
#define ADC_DEBUG_BUF (0)
#define ADC_DEBUF_SIZE (32000)
#if ADC_DEBUG_BUF
u32 d_skip_cnt = 100;
s16 d_buf[ADC_DEBUF_SIZE / 2] = {0};
u8 *d_ptr = d_buf;
u32 d_buf_cnt = 0;
#endif
static void adc_mic_demo_output(void *priv, s16 *data, int len)
{
//printf("> %d %d %d %d\n", data[0], data[1], data[2], data[3]);
int wlen = 0;
if (mic_demo && mic_demo->adc_2_dac) {
if (mic_demo->mic_idx == (AUDIO_ADC_MIC_0 | AUDIO_ADC_MIC_1)) {
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
/*输出两个mic的数据到DAC两个通道*/
putchar('a');
wlen = audio_dac_write(&dac_hdl, data, len * 2);
#else
/*输出其中一个mic的数据到DAC一个通道*/
putchar('b');
s16 *mono_data = data;
for (int i = 0; i < (len / 2); i++) {
mono_data[i] = data[i * 2]; /*MIC_L*/
//mono_data[i] = data[i * 2 + 1]; /*MIC_R*/
}
wlen = audio_dac_write(&dac_hdl, mono_data, len);
#endif/*TCFG_AUDIO_DAC_CONNECT_MODE*/
} else {
/*输出一个mic的数据到DAC一个通道*/
putchar('c');
wlen = audio_dac_write(&dac_hdl, data, len);
}
}
#if ADC_DEBUG_BUF
wdt_close();
if (d_skip_cnt) {
d_skip_cnt--;
return;
}
d_buf_cnt += len * ADC_DEMO_CH_NUM;
if (d_buf_cnt >= ADC_DEBUF_SIZE) {
wdt_close();
local_irq_disable();
printf(">>> hex\n\n");
put_buf(d_buf, ADC_DEBUF_SIZE);
printf(">>> hex end\n\n");
u32 i;
for (i = 0; i < ADC_DEBUF_SIZE / 2; i++) {
/* printf("%d\n", d_buf[i]); */
}
printf(">>> printf end\n\n");
while (1);
}
memcpy(d_ptr, data, len * ADC_DEMO_CH_NUM);
d_ptr += len * ADC_DEMO_CH_NUM;
#endif
}
/*
*********************************************************************
* AUDIO Linein OUTPUT
* Description: linein采样数据回调
* Arguments : pric 私有参数
* data mic数据
* len 数据长度
* Return : 0 成功 其他 失败
* Note(s) : 单声道数据格式
* L0 L1 L2 L3 L4 ...
* 双声道数据格式()
* L0 R0 L1 R1 L2 R2...
*********************************************************************
*/
#define LINEIN_DEBUG_BUF (0)
#define LINEIN_DEBUF_SIZE (32000)
#if LINEIN_DEBUG_BUF
u32 l_skip_cnt = 100;
s16 l_buf[LINEIN_DEBUF_SIZE / 2] = {0};
u8 *l_ptr = l_buf;
u32 l_buf_cnt = 0;
#endif
static void adc_linein_demo_output(void *priv, s16 *data, int len)
{
/* printf("> %d %d %d %d\n", data[0], data[1], data[2], data[3]); */
int wlen = 0;
if (linein_demo && linein_demo->adc_2_dac) {
if (linein_demo->linein_ch_num >= 2) {
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR)
/*输出两个linein的数据到DAC两个通道,默认输出第一个和第二个采样通道的数据*/
putchar('a');
s16 temp[len * 2];
for (int i = 0; i < len / 2; i++) {
temp[2 * i] = data[linein_demo->linein_ch_num * i];
temp[2 * i + 1] = data[linein_demo->linein_ch_num * i + 1];
}
wlen = audio_dac_write(&dac_hdl, temp, len * 2);
#else
/*输出其中一个linein的数据到DAC一个通道*/
putchar('b');
s16 *mono_data = data;
for (int i = 0; i < (len / 2); i++) {
switch (linein_demo->linein_ch_sel) {
case 0:
mono_data[i] = data[i * linein_demo->linein_ch_num]; /*第一路 linein采样的数据*/
break;
case 1:
mono_data[i] = data[i * linein_demo->linein_ch_num + 1]; /*第一路 linein采样的数据*/
break;
case 2:
mono_data[i] = data[i * linein_demo->linein_ch_num + 2]; /*第三路 linein采样的数据*/
break;
case 3:
mono_data[i] = data[i * linein_demo->linein_ch_num + 3]; /*第四路 linein采样的数据*/
break;
default:
break;
}
}
wlen = audio_dac_write(&dac_hdl, mono_data, len);
#endif/*TCFG_AUDIO_DAC_CONNECT_MODE*/
} else {
/*输出一个linein的数据到DAC一个通道*/
putchar('c');
wlen = audio_dac_write(&dac_hdl, data, len);
}
}
#if LINEIN_DEBUG_BUF
wdt_close();
if (l_skip_cnt) {
l_skip_cnt--;
return;
}
l_buf_cnt += len * ADC_DEMO_CH_NUM;
if (l_buf_cnt >= LINEIN_DEBUF_SIZE) {
wdt_close();
local_irq_disable();
printf(">>> hex\n\n");
put_buf(l_buf, LINEIN_DEBUF_SIZE);
printf(">>> hex end\n\n");
u32 i;
for (i = 0; i < LINEIN_DEBUF_SIZE / 2; i++) {
/* printf("%d\n", l_buf[i]); */
}
printf(">>> printf end\n\n");
while (1);
}
memcpy(l_ptr, data, len * ADC_DEMO_CH_NUM);
l_ptr += len * ADC_DEMO_CH_NUM;
#endif
}
/*
*********************************************************************
* AUDIO ADC MIC OPEN
* Description: 打开mic通道
* Arguments : mic_idx mic通道
* gain mic增益
* sr mic采样率
* mic_2_dac mic数据（通过DAC）监听
* Return : None.
* Note(s) : (1)打开一个mic通道示例：
* audio_adc_mic_demo_open(AUDIO_ADC_MIC_0,10,16000,1);
* 或者
* audio_adc_mic_demo_open(AUDIO_ADC_MIC_1,10,16000,1);
* (2)打开两个mic通道示例：
* audio_adc_mic_demo_open(AUDIO_ADC_MIC_1|AUDIO_ADC_MIC_0,10,16000,1);
*********************************************************************
*/
void audio_adc_mic_demo_open(u8 mic_idx, u8 gain, u16 sr, u8 mic_2_dac)
{
ADC_DEMO_LOG("audio_adc_mic_demo open:%d,gain:%d,sr:%d,mic_2_dac:%d\n", mic_idx, gain, sr, mic_2_dac);
mic_demo = zalloc(sizeof(struct adc_demo));
if (mic_demo) {
//step0:打开mic通道，并设置增益
audio_adc_mic_open(&mic_demo->mic_ch, AUDIO_ADC_MIC_0, &adc_hdl);
audio_adc_mic_set_gain(&mic_demo->mic_ch, gain);
audio_adc_mic_0dB_en(1);
//step1:设置mic通道采样率
audio_adc_mic_set_sample_rate(&mic_demo->mic_ch, sr);
//step2:设置mic采样buf
audio_adc_mic_set_buffs(&mic_demo->mic_ch, mic_demo->adc_buf, ADC_DEMO_IRQ_POINTS * 2, ADC_DEMO_BUF_NUM);
//step3:设置mic采样输出回调函数
mic_demo->adc_output.handler = adc_mic_demo_output;
audio_adc_add_output_handler(&adc_hdl, &mic_demo->adc_output);
//step4:启动mic通道采样
audio_adc_mic_start(&mic_demo->mic_ch);
/*监听配置（可选）*/
mic_demo->adc_2_dac = mic_2_dac;
mic_demo->mic_idx = mic_idx;
if (mic_2_dac) {
ADC_DEMO_LOG("max_sys_vol:%d\n", get_max_sys_vol());
app_audio_state_switch(APP_AUDIO_STATE_MUSIC, get_max_sys_vol());
ADC_DEMO_LOG("cur_vol:%d\n", app_audio_get_volume(APP_AUDIO_STATE_MUSIC));
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);
}
}
ADC_DEMO_LOG("audio_adc_mic_demo start succ\n");
int res = 0;
int msg[16];
// 循环一直往dac写数据
#ifdef BT_DUT_ADC_INTERFERE
while (0) {
#else
while (1) {
#endif/*BT_DUT_ADC_INTERFERE*/
// 这句是为了防止线程太久没有响应系统而产生异常，实际使用不需要
res = os_taskq_accept(ARRAY_SIZE(msg), msg);
os_time_dly(500);
}
}
/*
*********************************************************************
* AUDIO ADC MIC CLOSE
* Description: 关闭mic采样模块
* Arguments : None.
* Return : None.
* Note(s) : None.
*********************************************************************
*/
void audio_adc_mic_demo_close(void)
{
ADC_DEMO_LOG("audio_adc_mic_demo_close\n");
if (mic_demo) {
audio_adc_del_output_handler(&adc_hdl, &mic_demo->adc_output);
audio_adc_mic_close(&mic_demo->mic_ch);
free(mic_demo);
mic_demo = NULL;
}
}
/*
*********************************************************************
* AUDIO ADC linein OPEN
* Description: 打开linein通道
* Arguments : linein_idx linein通道
* gain linein增益
* sr linein采样率
* linein_2_dac linein数据（通过DAC）监听
* Return : None.
* Note(s) : (1)打开一个linein通道示例：
* audio_adc_linein_demo_open(AUDIO_ADC_LINE0,10,16000,1);
* 或者
* audio_adc_linein_demo_open(AUDIO_ADC_LINE1,10,16000,1);
* (2)打开两个linein通道示例：
* audio_adc_linein_demo_open(AUDIO_ADC_LINE1|AUDIO_ADC_LINE0,10,16000,1);
* (3)打开四个linein通道示例：
* audio_adc_linein_demo_open(AUDIO_ADC_LINE3|AUDIO_ADC_LINE2|AUDIO_ADC_LINE1|AUDIO_ADC_LINE0,10,16000,1);
*********************************************************************
*/
void audio_adc_linein_demo_open(u8 linein_idx, u8 gain, u16 sr, u8 linein_2_dac)
{
ADC_DEMO_LOG("audio_adc_linein_demo open:%d,gain:%d,sr:%d,linein_2_dac:%d\n", linein_idx, gain, sr, linein_2_dac);
linein_demo = zalloc(sizeof(struct adc_demo));
if (linein_demo) {
//step0:打开linein通道，并设置增益
if (linein_idx & AUDIO_ADC_LINE0) {
audio_adc_linein_open(&linein_demo->linein_ch, AUDIO_ADC_LINE0, &adc_hdl);
audio_adc_linein_set_gain(&linein_demo->linein_ch, gain);
audio_adc_linein_0dB_en(1);
linein_demo->linein_ch_num += 1;
}
if (linein_idx & AUDIO_ADC_LINE1) {
audio_adc_linein1_open(&linein_demo->linein_ch, AUDIO_ADC_LINE1, &adc_hdl);
audio_adc_linein1_set_gain(&linein_demo->linein_ch, gain);
audio_adc_linein1_0dB_en(1);
linein_demo->linein_ch_num += 1;
}
if (linein_idx & AUDIO_ADC_LINE2) {
audio_adc_linein2_open(&linein_demo->linein_ch, AUDIO_ADC_LINE2, &adc_hdl);
audio_adc_linein2_set_gain(&linein_demo->linein_ch, gain);
audio_adc_linein2_0dB_en(1);
linein_demo->linein_ch_num += 1;
}
if (linein_idx & AUDIO_ADC_LINE3) {
audio_adc_linein3_open(&linein_demo->linein_ch, AUDIO_ADC_LINE3, &adc_hdl);
audio_adc_linein3_set_gain(&linein_demo->linein_ch, gain);
audio_adc_linein3_0dB_en(1);
linein_demo->linein_ch_num += 1;
}
//step1:设置linein通道采样率
audio_adc_linein_set_sample_rate(&linein_demo->linein_ch, sr);
//step2:设置linein采样buf
audio_adc_linein_set_buffs(&linein_demo->linein_ch, linein_demo->adc_buf, ADC_DEMO_IRQ_POINTS * 2, ADC_DEMO_BUF_NUM);
//step3:设置linein采样输出回调函数
linein_demo->adc_output.handler = adc_linein_demo_output;
audio_adc_add_output_handler(&adc_hdl, &linein_demo->adc_output);
//step4:启动linein通道采样
audio_adc_linein_start(&linein_demo->linein_ch);
/*监听配置（可选）*/
linein_demo->adc_2_dac = linein_2_dac;
linein_demo->linein_idx = linein_idx;
if (linein_2_dac) {
ADC_DEMO_LOG("max_sys_vol:%d\n", get_max_sys_vol());
app_audio_state_switch(APP_AUDIO_STATE_MUSIC, get_max_sys_vol());
ADC_DEMO_LOG("cur_vol:%d\n", app_audio_get_volume(APP_AUDIO_STATE_MUSIC));
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);
}
}
ADC_DEMO_LOG("audio_adc_linein_demo start succ\n");
int res = 0;
int msg[16];
// 循环一直往dac写数据
while (1) {
// 这句是为了防止线程太久没有响应系统而产生异常，实际使用不需要
res = os_taskq_accept(ARRAY_SIZE(msg), msg);
os_time_dly(500);
}
}
/*
*********************************************************************
* AUDIO ADC linein CLOSE
* Description: 关闭linein采样模块
* Arguments : None.
* Return : None.
* Note(s) : None.
*********************************************************************
*/
void audio_adc_linein_demo_close(void)
{
ADC_DEMO_LOG("audio_adc_linein_demo_close\n");
if (linein_demo) {
audio_adc_del_output_handler(&adc_hdl, &linein_demo->adc_output);
audio_adc_linein_close(&linein_demo->linein_ch);
free(linein_demo);
linein_demo = NULL;
}
}
//开启audio_adc接口 用于测试BT干扰
void audio_adc_mic_dut_open(void)
{
audio_adc_mic_demo_open(AUDIO_ADC_MIC_0, 10, 16000, 0);
}
#if AUDIO_DEMO_LP_REG_ENABLE
static u8 adc_demo_idle_query()
{
return mic_demo ? 0 : 1;
}
REGISTER_LP_TARGET(adc_demo_lp_target) = {
.name = "adc_demo",
.is_idle = adc_demo_idle_query,
};
#endif/*AUDIO_DEMO_LP_REG_ENABLE*/

203
cpu/br28/audio_demo/audio_dac_demo.c Normal file
View File

@ -0,0 +1,203 @@
/*
****************************************************************************
* Audio DAC Demo
*
*Description : Audio DAC使用范例
*Notes : 本demo为开发测试范例，请不要修改该demo， 如有需求，请自行
* 复制再修改
****************************************************************************
*/
#include "audio_demo.h"
#include "media/includes.h"
#include "audio_config.h"
#include "audio_demo.h"
#define KEY_TEST 0//(IO_PORTB_01)
#define KEY_TEST2 0//(IO_PORTB_02)
extern struct audio_dac_hdl dac_hdl;
static u8 dac_demo = 0;
// 用于 DAC 播放的正弦波数据
const s16 data_sin44100[441] = {
0x0000, 0x122d, 0x23fb, 0x350f, 0x450f, 0x53aa, 0x6092, 0x6b85, 0x744b, 0x7ab5, 0x7ea2, 0x7fff, 0x7ec3, 0x7af6, 0x74ab, 0x6c03,
0x612a, 0x545a, 0x45d4, 0x35e3, 0x24db, 0x1314, 0x00e9, 0xeeba, 0xdce5, 0xcbc6, 0xbbb6, 0xad08, 0xa008, 0x94fa, 0x8c18, 0x858f,
0x8181, 0x8003, 0x811d, 0x84ca, 0x8af5, 0x9380, 0x9e3e, 0xaaf7, 0xb969, 0xc94a, 0xda46, 0xec06, 0xfe2d, 0x105e, 0x223a, 0x3365,
0x4385, 0x5246, 0x5f5d, 0x6a85, 0x7384, 0x7a2d, 0x7e5b, 0x7ffa, 0x7f01, 0x7b75, 0x7568, 0x6cfb, 0x6258, 0x55b7, 0x4759, 0x3789,
0x2699, 0x14e1, 0x02bc, 0xf089, 0xdea7, 0xcd71, 0xbd42, 0xae6d, 0xa13f, 0x95fd, 0x8ce1, 0x861a, 0x81cb, 0x800b, 0x80e3, 0x844e,
0x8a3c, 0x928c, 0x9d13, 0xa99c, 0xb7e6, 0xc7a5, 0xd889, 0xea39, 0xfc5a, 0x0e8f, 0x2077, 0x31b8, 0x41f6, 0x50de, 0x5e23, 0x697f,
0x72b8, 0x799e, 0x7e0d, 0x7fee, 0x7f37, 0x7bed, 0x761f, 0x6ded, 0x6380, 0x570f, 0x48db, 0x392c, 0x2855, 0x16ad, 0x048f, 0xf259,
0xe06b, 0xcf20, 0xbed2, 0xafd7, 0xa27c, 0x9705, 0x8db0, 0x86ab, 0x821c, 0x801a, 0x80b0, 0x83da, 0x8988, 0x919c, 0x9bee, 0xa846,
0xb666, 0xc603, 0xd6ce, 0xe86e, 0xfa88, 0x0cbf, 0x1eb3, 0x3008, 0x4064, 0x4f73, 0x5ce4, 0x6874, 0x71e6, 0x790a, 0x7db9, 0x7fdc,
0x7f68, 0x7c5e, 0x76d0, 0x6ed9, 0x64a3, 0x5863, 0x4a59, 0x3acc, 0x2a0f, 0x1878, 0x0661, 0xf42a, 0xe230, 0xd0d0, 0xc066, 0xb145,
0xa3bd, 0x9813, 0x8e85, 0x8743, 0x8274, 0x8030, 0x8083, 0x836b, 0x88da, 0x90b3, 0x9acd, 0xa6f5, 0xb4ea, 0xc465, 0xd515, 0xe6a3,
0xf8b6, 0x0aee, 0x1ced, 0x2e56, 0x3ecf, 0x4e02, 0x5ba1, 0x6764, 0x710e, 0x786f, 0x7d5e, 0x7fc3, 0x7f91, 0x7cc9, 0x777a, 0x6fc0,
0x65c1, 0x59b3, 0x4bd3, 0x3c6a, 0x2bc7, 0x1a41, 0x0833, 0xf5fb, 0xe3f6, 0xd283, 0xc1fc, 0xb2b7, 0xa503, 0x9926, 0x8f60, 0x87e1,
0x82d2, 0x804c, 0x805d, 0x8303, 0x8833, 0x8fcf, 0x99b2, 0xa5a8, 0xb372, 0xc2c9, 0xd35e, 0xe4da, 0xf6e4, 0x091c, 0x1b26, 0x2ca2,
0x3d37, 0x4c8e, 0x5a58, 0x664e, 0x7031, 0x77cd, 0x7cfd, 0x7fa3, 0x7fb4, 0x7d2e, 0x781f, 0x70a0, 0x66da, 0x5afd, 0x4d49, 0x3e04,
0x2d7d, 0x1c0a, 0x0a05, 0xf7cd, 0xe5bf, 0xd439, 0xc396, 0xb42d, 0xa64d, 0x9a3f, 0x9040, 0x8886, 0x8337, 0x806f, 0x803d, 0x82a2,
0x8791, 0x8ef2, 0x989c, 0xa45f, 0xb1fe, 0xc131, 0xd1aa, 0xe313, 0xf512, 0x074a, 0x195d, 0x2aeb, 0x3b9b, 0x4b16, 0x590b, 0x6533,
0x6f4d, 0x7726, 0x7c95, 0x7f7d, 0x7fd0, 0x7d8c, 0x78bd, 0x717b, 0x67ed, 0x5c43, 0x4ebb, 0x3f9a, 0x2f30, 0x1dd0, 0x0bd6, 0xf99f,
0xe788, 0xd5f1, 0xc534, 0xb5a7, 0xa79d, 0x9b5d, 0x9127, 0x8930, 0x83a2, 0x8098, 0x8024, 0x8247, 0x86f6, 0x8e1a, 0x978c, 0xa31c,
0xb08d, 0xbf9c, 0xcff8, 0xe14d, 0xf341, 0x0578, 0x1792, 0x2932, 0x39fd, 0x499a, 0x57ba, 0x6412, 0x6e64, 0x7678, 0x7c26, 0x7f50,
0x7fe6, 0x7de4, 0x7955, 0x7250, 0x68fb, 0x5d84, 0x5029, 0x412e, 0x30e0, 0x1f95, 0x0da7, 0xfb71, 0xe953, 0xd7ab, 0xc6d4, 0xb725,
0xa8f1, 0x9c80, 0x9213, 0x89e1, 0x8413, 0x80c9, 0x8012, 0x81f3, 0x8662, 0x8d48, 0x9681, 0xa1dd, 0xaf22, 0xbe0a, 0xce48, 0xdf89,
0xf171, 0x03a6, 0x15c7, 0x2777, 0x385b, 0x481a, 0x5664, 0x62ed, 0x6d74, 0x75c4, 0x7bb2, 0x7f1d, 0x7ff5, 0x7e35, 0x79e6, 0x731f,
0x6a03, 0x5ec1, 0x5193, 0x42be, 0x328f, 0x2159, 0x0f77, 0xfd44, 0xeb1f, 0xd967, 0xc877, 0xb8a7, 0xaa49, 0x9da8, 0x9305, 0x8a98,
0x848b, 0x80ff, 0x8006, 0x81a5, 0x85d3, 0x8c7c, 0x957b, 0xa0a3, 0xadba, 0xbc7b, 0xcc9b, 0xddc6, 0xefa2, 0x01d3, 0x13fa, 0x25ba,
0x36b6, 0x4697, 0x5509, 0x61c2, 0x6c80, 0x750b, 0x7b36, 0x7ee3, 0x7ffd, 0x7e7f, 0x7a71, 0x73e8, 0x6b06, 0x5ff8, 0x52f8, 0x444a,
0x343a, 0x231b, 0x1146, 0xff17, 0xecec, 0xdb25, 0xca1d, 0xba2c, 0xaba6, 0x9ed6, 0x93fd, 0x8b55, 0x850a, 0x813d, 0x8001, 0x815e,
0x854b, 0x8bb5, 0x947b, 0x9f6e, 0xac56, 0xbaf1, 0xcaf1, 0xdc05, 0xedd3
};
/*
*********************************************************************
* AUDIO DAC OPEN
* Description: 打开 dac demo
* Arguments : None
* Return : None.
* Note(s) : dac 播放正弦波
* 将这个函数放audio_dec_init()后调用即可
*********************************************************************
*/
void audio_dac_demo_open(void)
{
int len = 0;
int wlen = 0;
s16 *ptr;
s16 *data_addr;
u32 data_len;
app_audio_state_switch(APP_AUDIO_STATE_MUSIC, get_max_sys_vol()); // 音量状态设置
audio_dac_set_volume(&dac_hdl, get_max_sys_vol()); // dac 音量设置
audio_dac_set_sample_rate(&dac_hdl, 44100); // 采样率设置
audio_dac_start(&dac_hdl); // dac 启动
// 判断声道数，双声道需要复制多一个声道的数据
if (dac_hdl.channel == 2) {
data_addr = zalloc(441 * 2 * 2);
if (!data_addr) {
printf("demo dac malloc err !!\n");
return;
}
for (int i = 0; i < 882; i++) {
data_addr[i] = data_sin44100[i / 2];
}
data_len = 441 * 2 * 2;
} else {
data_addr = data_sin44100;
data_len = 441 * 2;
}
dac_demo = 1;
int res = 0;
int msg[16];
u8 mode = 0;
#if KEY_TEST
gpio_direction_input(KEY_TEST);
gpio_set_pull_down(KEY_TEST, 0);
gpio_set_pull_up(KEY_TEST, 1);
gpio_set_die(KEY_TEST, 1);
#endif
#if KEY_TEST2
gpio_direction_input(KEY_TEST2);
gpio_set_pull_down(KEY_TEST2, 0);
gpio_set_pull_up(KEY_TEST2, 1);
gpio_set_die(KEY_TEST2, 1);
#endif
// 循环一直往dac写数据
while (1) {
// 这句是为了防止线程太久没有响应系统而产生异常，实际使用不需要
res = os_taskq_accept(ARRAY_SIZE(msg), msg);
ptr = data_addr;
len = data_len;
while (len) {
// 往 dac 写数据
wlen = audio_dac_write(&dac_hdl, ptr, len);
#if KEY_TEST
if (0 == gpio_read(KEY_TEST)) {
while (0 == gpio_read(KEY_TEST)) {
os_time_dly(1);
};
mode++;
if (mode >= 3) {
mode = 0;
}
printf(">> mode:%d\n", mode);
if (mode == 0) {
JL_AUDIO->DAC_VL0 = 0;
printf(">> silence\n");
} else if (mode == 1) {
JL_AUDIO->DAC_VL0 = 0x40004000;
printf(">> 0dB\n");
} else {
JL_AUDIO->DAC_VL0 = 0x000F000F;
printf(">> -60dB\n");
}
}
#endif
#if KEY_TEST2
if (0 == gpio_read(KEY_TEST2)) {
while (0 == gpio_read(KEY_TEST2)) {
os_time_dly(1);
};
static u8 analog_gain = 0;
u32 TMP_CON1;
TMP_CON1 = JL_ADDA->DAA_CON1;
TMP_CON1 &= ~(0xf << 0 | 0xf << 4);
TMP_CON1 |= ((u32)(analog_gain & 0xf) << 0) | ((u32)(analog_gain & 0xf) << 4);
JL_ADDA->DAA_CON1 = TMP_CON1;
printf(">>> analog_gain: %d\n", analog_gain);
analog_gain++;
if (analog_gain > 15) {
analog_gain = 0;
}
}
#endif
if (wlen != len) { // dac缓存满了，延时 10ms 后再继续写
os_time_dly(1);
}
ptr += wlen / 2;
len -= wlen;
}
}
}
/*
*********************************************************************
* AUDIO DAC CLOSE
* Description: 关闭 dac demo
* Arguments : None
* Return : None.
* Note(s) : dac 停止播放正弦波
*********************************************************************
*/
void audio_dac_demo_close(void)
{
// 停止并关闭 DAC
audio_dac_stop(&dac_hdl);
audio_dac_close(&dac_hdl);
dac_demo = 0;
}
#if AUDIO_DEMO_LP_REG_ENABLE
static u8 dac_demo_idle_query()
{
return dac_demo ? 0 : 1;
}
REGISTER_LP_TARGET(dac_demo_lp_target) = {
.name = "dac_demo",
.is_idle = dac_demo_idle_query,
};
#endif/*AUDIO_DEMO_LP_REG_ENABLE*/

158
cpu/br28/audio_demo/audio_demo.h Normal file
View File

@ -0,0 +1,158 @@
/*
****************************************************************************
* Audio Demo Declaration
*
*Description : Audio Demo函数声明集合
*Notes : None.
****************************************************************************
*/
#ifndef __AUDIO_DEMO_H_
#define __AUDIO_DEMO_H_
#include "generic/typedef.h"
/*audio demo低功耗注册查询，防止调用demo的时候，进入低功耗，影响测试*/
#define AUDIO_DEMO_LP_REG_ENABLE 0
/**********************************************************************
*
* Audio DAC Demo APIs
*
**********************************************************************/
/**********************************************************************
*
* Audio ADC Demo APIs
*
**********************************************************************/
/*
*********************************************************************
* AUDIO ADC MIC OPEN
* Description: 打开mic通道
* Arguments : mic_idx mic通道
* gain mic增益
* sr mic采样率
* mic_2_dac mic数据（通过DAC）监听
* Return : None.
* Note(s) : (1)打开一个mic通道示例：
* audio_adc_mic_demo_open(AUDIO_ADC_MIC_0,10,16000,1);
* 或者
* audio_adc_mic_demo_open(AUDIO_ADC_MIC_1,10,16000,1);
* (2)打开两个mic通道示例：
* audio_adc_mic_demo_open(AUDIO_ADC_MIC_1|AUDIO_ADC_MIC_0,10,16000,1);
*********************************************************************
*/
// void audio_adc_mic_demo_open(u8 mic_idx, u8 gain, u16 sr, u8 mic_2_dac);
/*
*********************************************************************
* AUDIO ADC MIC CLOSE
* Description: 关闭mic采样模块
* Arguments : None.
* Return : None.
* Note(s) : None.
*********************************************************************
*/
// void audio_adc_mic_demo_close(void);
/**********************************************************************
*
* Audio AudioLink(IIS) APIs
*
**********************************************************************/
/*
*********************************************************************
* AUDIO IIS OUTPUT/INPUT OPEN
* Description: 打开iis通道
* Arguments : iis_rx 是否打开iis输入
* iis_tx 是否打开iis输出
* sr iis采样率
* iis_rx_2_dac iis_rx数据（通过DAC）监听
* Return : None.
* Note(s) : (1)打开一个iis rx通道示例：
* audio_link_demo_open(1,0,44100,1);
* (2)打开一个iis tx通道示例：
* audio_link_demo_open(0,1,44100,0);
* (3)同时打开iis tx 和 rx 通道示例：
* audio_link_demo_open(1,1,44100,1);
*********************************************************************
*/
// void audio_link_demo_open(u8 iis_rx, u8 iis_tx, u16 sr, u8 iis_rx_2_dac);
/*
*********************************************************************
* AUDIO IIS OUTPUT/INPUT OPEN
* Description: 打开iis通道
* Arguments : iis_rx 是否关闭iis输入
* iis_tx 是否关闭iis输出
* Return : None.
* Note(s) : (1)关闭一个iis rx通道示例：
* audio_link_demo_open(1,0);
* (2)关闭一个iis tx通道示例：
* audio_link_demo_open(0,1);
* (3)同时关闭iis tx 和 rx 通道示例：
* audio_link_demo_open(1,1);
*********************************************************************
*/
// void audio_link_demo_close(u8 iis_rx, u8 iis_tx);
/**********************************************************************
*
* Audio PDM APIs
*
**********************************************************************/
/*
*********************************************************************
* AUDIO PDM MIC OPEN
* Description: 打开pdm mic模块
* Arguments : sample pdm mic采样率
* mic_2_dac mic数据（通过DAC）监听
* Return : None.
* Note(s) : (1)打开pdm mic通道示例：
* audio_plnk_demo_open(16000, 1);
*********************************************************************
*/
// void audio_plnk_demo_open(u16 sample, u8 mic_2_dac);
/*
*********************************************************************
* AUDIO PDM MIC CLOSE
* Description: 关闭pdm mic模块
* Arguments : None.
* Return : None.
* Note(s) : None.
*********************************************************************
*/
// void audio_plnk_demo_close(void);
/*
*********************************************************************
* hw_fft_demo_real
* Description: 实数数据 FFT 运算 demo
* Arguments : None.
* Return : None.
* Note(s) : None.
*********************************************************************
*/
// extern void hw_fft_demo_real();
/*
*********************************************************************
* hw_fft_demo_complex
* Description: 复数数据 FFT 运算 demo
* Arguments : None.
* Return : None.
* Note(s) : None.
*********************************************************************
*/
// extern void hw_fft_demo_complex();
#endif/*__AUDIO_DEMO_H_*/

101
cpu/br28/audio_demo/audio_fft_demo.c Normal file
View File

@ -0,0 +1,101 @@
/*
****************************************************************************
* Audio FFT Demo
*
*Description : Audio FFT使用范例
*Notes :
*(1)本demo为开发测试范例，请不要修改该demo， 如有需求，请自行复制再修改
*(2)FFT输入数据位宽
*----------------------------------------------------------------------
* FFT模式 FFT点数 最大输入位宽
*----------------------------------------------------------------------
* 复数 64 [21:0]
* 128 [20:0]
* 256 [19:0]
* 512 [18:0]
* 1024 [17:0]
*----------------------------------------------------------------------
* 实数 64 [20:0]
* 128 [18:0]
* 256 [17:0]
* 512 [18:0]
* 1024 [16:0]
*----------------------------------------------------------------------
*(3)IFFT输入位宽：[29:0]
****************************************************************************
*/
#include "audio_demo.h"
#include "hw_fft.h"
// For 128 point Real_FFT test
void hw_fft_demo_real()
{
int tmpbuf[130]; // 130 = (128/2+1)*2
unsigned int fft_config;
printf("********* test start **************\n");
for (int i = 0; i < 128; i++) {
tmpbuf[i] = i + 1;
printf("tmpbuf[%d]: %d \n", i, tmpbuf[i]);
}
// Do 128 point FFT
fft_config = hw_fft_config(128, 7, 1, 0, 1);
hw_fft_run(fft_config, tmpbuf, tmpbuf);
for (int i = 0; i < 130; i++) {
printf("tmpbuf_[%d]: %d \n", i, tmpbuf[i]);
}
// Do 128 point IFFT
fft_config = hw_fft_config(128, 7, 1, 1, 1);
hw_fft_run(fft_config, tmpbuf, tmpbuf);
for (int i = 0; i < 128; i++) {
printf("tmpbuf_[%d]: %d \n", i, tmpbuf[i]);
}
}
// For 128 point Complex_FFT test
void hw_fft_demo_complex()
{
int tmpbuf[280]; // 280 = (128/2+1)*2*2
unsigned int fft_config;
printf("********* test start **************\n");
for (int i = 0; i < 128; i++) {
tmpbuf[2 * i] = i + 1;
tmpbuf[2 * i + 1] = i + 1;
printf("tmpbuf[%d]: %d \n", 2 * i, tmpbuf[2 * i]);
printf("tmpbuf[%d]: %d \n", 2 * i + 1, tmpbuf[2 * i + 1]);
}
// Do 128 point FFT
fft_config = hw_fft_config(128, 7, 1, 0, 0);
hw_fft_run(fft_config, tmpbuf, tmpbuf);
for (int i = 0; i < 128; i++) {
printf("tmpbuf[%d]: %d \n", 2 * i, tmpbuf[2 * i]);
printf("tmpbuf[%d]: %d \n", 2 * i + 1, tmpbuf[2 * i + 1]);
}
// Do 128 point IFFT
fft_config = hw_fft_config(128, 7, 1, 1, 0);
hw_fft_run(fft_config, tmpbuf, tmpbuf);
for (int i = 0; i < 128; i++) {
printf("tmpbuf[%d]: %d \n", 2 * i, tmpbuf[2 * i]);
printf("tmpbuf[%d]: %d \n", 2 * i + 1, tmpbuf[2 * i + 1]);
}
}

558
cpu/br28/audio_demo/audio_matrix_demo.c Normal file
View File

@ -0,0 +1,558 @@
#include "asm/MatrixInteFunc.h"
char src_a_u8[16]__attribute__((aligned(4))) = {0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
char src_b_u8[16]__attribute__((aligned(4))) = {4, 5, 6, 7, 10, 11, 12, 13, 4, 5, 6, 7, 10, 11, 12, 13};
char dst_u8[16]__attribute__((aligned(4)));
short int src_a_16[16]__attribute__((aligned(4))) = {0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
short int src_b_16[16]__attribute__((aligned(4))) = {4, 5, 6, 7, 10, 11, 12, 13, 4, 5, 6, 7, 10, 11, 12, 13};
short int dst_16[16]__attribute__((aligned(4)));
int src_a_32[16]__attribute__((aligned(4))) = {0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7};
int src_b_32[16]__attribute__((aligned(4))) = {4, 5, 6, 7, 10, 11, 12, 13, 4, 5, 6, 7, 10, 11, 12, 13};
int dst_32[16]__attribute__((aligned(4)));
MC MC_t;
MXYZ MXYZ_a, MXYZ_b, MXYZ_c;
void test_MatrixInteFunc_add_sub()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 4 - 1;
MC_t.MatQ = 0;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_16;
MXYZ_a.Dw = DW_16;
MXYZ_a.RowStep = MXYZ_a.Dw ;
MXYZ_a.ColStep = MXYZ_a.Dw * (MC_t.MatCol + 1);
MXYZ_a.Conj = 0;
MXYZ_b.Dw = DW_16;
MXYZ_b.MatAdr = (unsigned int)&src_b_16;
MXYZ_b.RowStep = MXYZ_b.Dw ;
MXYZ_b.ColStep = MXYZ_b.Dw * (MC_t.MatCol + 1);
MXYZ_b.Conj = 0;
MXYZ_c.Dw = DW_16;
MXYZ_c.MatAdr = (unsigned int)&dst_16;
MXYZ_c.RowStep = MXYZ_c.Dw ;
MXYZ_c.ColStep = MXYZ_c.Dw * (MC_t.MatCol + 1);
MXYZ_c.Conj = 0;
MatrixADD_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_16[k]);
}
//sub
//MXYZ_a.MatAdr = &src_a_16;
MXYZ_a.Dw = DW_16;
MXYZ_a.RowStep = MXYZ_a.Dw ;
MXYZ_a.ColStep = MXYZ_a.Dw * (MC_t.MatCol + 1);
MXYZ_a.Conj = 0;
MXYZ_b.Dw = DW_16;
MXYZ_b.MatAdr = (unsigned int)&src_b_16;
MXYZ_b.RowStep = MXYZ_b.Dw ;
MXYZ_b.ColStep = MXYZ_b.Dw * (MC_t.MatCol + 1);
MXYZ_b.Conj = 0;
MXYZ_c.Dw = DW_16;
MXYZ_c.MatAdr = (unsigned int)&dst_16;
MXYZ_c.RowStep = MXYZ_c.Dw ;
MXYZ_c.ColStep = MXYZ_c.Dw * (MC_t.MatCol + 1);
MXYZ_c.Conj = 0;
MatrixSUB_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_16[k]);
}
}
void test_MatrixInteFunc_scale_add_sub()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 4 - 1;
MC_t.MatQ = 1;
MC_t.RS = 4;
MXYZ_a.MatAdr = (unsigned int)&src_a_u8;
MXYZ_a.RowStep = 1;
MXYZ_a.ColStep = 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_8;
MXYZ_b.MatAdr = (unsigned int)&src_b_u8;
MXYZ_b.RowStep = 1;
MXYZ_b.ColStep = 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_8;
MXYZ_c.MatAdr = (unsigned int)&dst_u8;
MXYZ_c.RowStep = 1;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_8;
MatrixScaleADD_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_u8[k]);
}
//sub
MXYZ_a.MatAdr = (unsigned int)&src_a_16;
MXYZ_b.MatAdr = (unsigned int)&src_b_16;
MXYZ_c.MatAdr = (unsigned int)&dst_16;
MXYZ_a.Dw = DW_16;
MXYZ_b.Dw = DW_16;
MXYZ_c.Dw = DW_16;
MXYZ_a.RowStep = 1 * 2;
MXYZ_a.ColStep = 4 * 2;
MXYZ_b.RowStep = 1 * 2;
MXYZ_b.ColStep = 4 * 2;
MXYZ_c.RowStep = 1 * 2;
MXYZ_c.ColStep = 4 * 2;
MatrixScaleSUB_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_16[k]);
}
}
void test_MatrixInteFunc_scale_mul_mla_mls()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 4 - 1;
MC_t.MatQ = 1;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_u8;
MXYZ_a.RowStep = 1;
MXYZ_a.ColStep = 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_8;
MXYZ_b.MatAdr = (unsigned int)&src_b_u8;
MXYZ_b.RowStep = 1;
MXYZ_b.ColStep = 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_8;
MXYZ_c.MatAdr = (unsigned int)&dst_u8;
MXYZ_c.RowStep = 1;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_8;
MatrixScaleMUL_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
//
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_u8[k]);
}
for (int k = 0; k < 8; k++) {
dst_32[k] = k;
}
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_a.Dw = DW_32;
MXYZ_b.Dw = DW_32;
MXYZ_c.Dw = DW_32;
MXYZ_a.RowStep = 1 * 4;
MXYZ_a.ColStep = 4 * 4;
MXYZ_b.RowStep = 1 * 4;
MXYZ_b.ColStep = 4 * 4;
MXYZ_c.RowStep = 1 * 4;
MXYZ_c.ColStep = 4 * 4;
MatrixScaleMLA_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_32[k]);
}
//
for (int k = 0; k < 8; k++) {
dst_32[k] = -1;
}
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_a.Dw = DW_32;
MXYZ_b.Dw = DW_32;
MXYZ_c.Dw = DW_32;
MatrixScaleMLS_Real(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_32[k]);
}
}
void test_Matvec_mul()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 4 - 1;
MC_t.MatQ = 0;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_a.RowStep = 1 * 4;
MXYZ_a.ColStep = 4 * 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_b.RowStep = 1 * 4;
MXYZ_b.ColStep = 4 * 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_32;
/*MXYZ_c.MatAdr = &dst_32;
MXYZ_c.RowStep = 1;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_32;*/
int sum;
MatVecMUL_Real(&MXYZ_a, &MXYZ_b, &sum, &MC_t, 1);
//
/*for(int k = 0;k<8;k++)
{
printf("dst_u8=%d\n",dst_32[k]);
}*/
printf("sum=%d\n", sum);
}
//complex
void test_MatrixInteFunc_add_sub_complex()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 2 - 1;
MC_t.MatQ = 0;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_u8;
MXYZ_a.RowStep = 1 * 2;
MXYZ_a.ColStep = 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_8;
MXYZ_b.MatAdr = (unsigned int)&src_b_u8;
MXYZ_b.RowStep = 1 * 2;
MXYZ_b.ColStep = 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_8;
MXYZ_c.MatAdr = (unsigned int)&dst_u8;
MXYZ_c.RowStep = 1 * 2;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_8;
MatrixADD_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_u8[k]);
}
//sub
MXYZ_a.MatAdr = (unsigned int)&src_a_16;
MXYZ_b.MatAdr = (unsigned int)&src_b_16;
MXYZ_c.MatAdr = (unsigned int)&dst_16;
MXYZ_a.Dw = DW_16;
MXYZ_b.Dw = DW_16;
MXYZ_c.Dw = DW_16;
MXYZ_a.RowStep = 1 * 2 * 2;
MXYZ_a.ColStep = 4 * 2;
MXYZ_b.RowStep = 1 * 2 * 2;
MXYZ_b.ColStep = 4 * 2;
MXYZ_c.RowStep = 1 * 2 * 2;
MXYZ_c.ColStep = 4 * 2;
MatrixSUB_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_16[k]);
}
}
void test_MatrixInteFunc_scale_add_sub_complex()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 2 - 1;
MC_t.MatQ = 1;
MC_t.RS = 4;
MXYZ_a.MatAdr = (unsigned int)&src_a_u8;
MXYZ_a.RowStep = 1 * 2;
MXYZ_a.ColStep = 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_8;
MXYZ_b.MatAdr = (unsigned int)&src_b_u8;
MXYZ_b.RowStep = 1 * 2;
MXYZ_b.ColStep = 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_8;
MXYZ_c.MatAdr = (unsigned int)&dst_u8;
MXYZ_c.RowStep = 1 * 2;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_8;
MatrixScaleADD_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_u8[k]);
}
//sub
MXYZ_a.MatAdr = (unsigned int)&src_a_16;
MXYZ_b.MatAdr = (unsigned int)&src_b_16;
MXYZ_c.MatAdr = (unsigned int)&dst_16;
MXYZ_a.Dw = DW_16;
MXYZ_b.Dw = DW_16;
MXYZ_c.Dw = DW_16;
MXYZ_a.RowStep = 1 * 2 * 2;
MXYZ_a.ColStep = 4 * 2;
MXYZ_b.RowStep = 1 * 2 * 2;
MXYZ_b.ColStep = 4 * 2;
MXYZ_c.RowStep = 1 * 2 * 2;
MXYZ_c.ColStep = 4 * 2;
MatrixScaleSUB_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_16[k]);
}
}
void test_MatrixInteFunc_scale_mul_mla_mls_complex()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 2 - 1;
MC_t.MatQ = 1;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_u8;
MXYZ_a.RowStep = 1 * 2;
MXYZ_a.ColStep = 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_8;
MXYZ_b.MatAdr = (unsigned int)&src_b_u8;
MXYZ_b.RowStep = 1 * 2;
MXYZ_b.ColStep = 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_8;
MXYZ_c.MatAdr = (unsigned int)&dst_u8;
MXYZ_c.RowStep = 1 * 2;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_8;
MatrixScaleMUL_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
//
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_u8[k]);
}
for (int k = 0; k < 8; k++) {
dst_32[k] = k;
}
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_a.Dw = DW_32;
MXYZ_b.Dw = DW_32;
MXYZ_c.Dw = DW_32;
MXYZ_a.RowStep = 1 * 4 * 2;
MXYZ_a.ColStep = 4 * 4;
MXYZ_b.RowStep = 1 * 4 * 2;
MXYZ_b.ColStep = 4 * 4;
MXYZ_c.RowStep = 1 * 4 * 2;
MXYZ_c.ColStep = 4 * 4;
MatrixScaleMLA_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_32[k]);
}
//
for (int k = 0; k < 8; k++) {
dst_32[k] = -1;
}
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_a.Dw = DW_32;
MXYZ_b.Dw = DW_32;
MXYZ_c.Dw = DW_32;
MatrixScaleMLS_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_16=%d\n", dst_32[k]);
}
}
void test_Matvec_mul_complex()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 2 - 1;
MC_t.MatQ = 0;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_a.RowStep = 1 * 4 * 2;
MXYZ_a.ColStep = 4 * 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_b.RowStep = 1 * 4 * 2;
MXYZ_b.ColStep = 4 * 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_32;
/*MXYZ_c.MatAdr = &dst_32;
MXYZ_c.RowStep = 1;
MXYZ_c.ColStep = 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_32;*/
int sum[2];
MatVecMUL_Complex(&MXYZ_a, &MXYZ_b, (int *)&sum, &MC_t, -1);
//
/*for(int k = 0;k<8;k++)
{
printf("dst_u8=%d\n",dst_32[k]);
}*/
printf("sum1=%d\n", sum[0]);
printf("sum2=%d\n", sum[1]);
}
void test_MatrixComplexScaleMul_Complex()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 2 - 1;
MC_t.MatQ = 1;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_a.RowStep = 1 * 4;
MXYZ_a.ColStep = 4 * 2;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_32;
MXYZ_b.MatAdr = (unsigned int)&src_b_32;
MXYZ_b.RowStep = 1 * 4 * 2;
MXYZ_b.ColStep = 4 * 2 * 2;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_c.RowStep = 1 * 4 * 2;
MXYZ_c.ColStep = 4 * 2 * 2;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_32;
MatrixComplexScaleMUL_Complex(&MXYZ_a, &MXYZ_b, &MXYZ_c, &MC_t);
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_32[k]);
}
}
void test_MatrixMUL_Real()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 4 - 1;
MC_t.MatQ = 0;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_a.RowStep = 4;
MXYZ_a.ColStep = 4 * 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_32;
int src_b_32_T[8]__attribute__((aligned(4))) = {4, 6, 10, 12, 5, 7, 11, 13};
MXYZ_b.MatAdr = (unsigned int)&src_b_32_T;
MXYZ_b.RowStep = 4;
MXYZ_b.ColStep = 4 * 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_c.RowStep = 4;
MXYZ_c.ColStep = 4 * 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_32;
MatrixMUL_Real(&MXYZ_b, &MXYZ_a, &MXYZ_c, &MC_t, -1);
//
for (int k = 0; k < 4; k++) {
printf("dst_u8=%d\n", dst_32[k]);
}
}
void test_MatrixMUL_Complex()
{
printf(__func__);
printf("ssssssnnn\n");
MC_t.MatRow = 2 - 1;
MC_t.MatCol = 2 - 1;
MC_t.MatQ = 0;
MC_t.RS = 0;
MXYZ_a.MatAdr = (unsigned int)&src_a_32;
MXYZ_a.RowStep = 4;
MXYZ_a.ColStep = 4 * 4;
MXYZ_a.Conj = 0;
MXYZ_a.Dw = DW_32;
int src_b_32_T1[8]__attribute__((aligned(4))) = {4, 5, 10, 11, 6, 7, 12, 13};
MXYZ_b.MatAdr = (unsigned int)&src_b_32_T1;
MXYZ_b.RowStep = 4;
MXYZ_b.ColStep = 4 * 4;
MXYZ_b.Conj = 0;
MXYZ_b.Dw = DW_32;
MXYZ_c.MatAdr = (unsigned int)&dst_32;
MXYZ_c.RowStep = 4;
MXYZ_c.ColStep = 4 * 4;
MXYZ_c.Conj = 0;
MXYZ_c.Dw = DW_32;
MatrixMUL_Complex(&MXYZ_b, &MXYZ_a, &MXYZ_c, &MC_t, -1);
//
for (int k = 0; k < 8; k++) {
printf("dst_u8=%d\n", dst_32[k]);
}
}

340
cpu/br28/audio_demo/audio_wind_detect_demo.c Normal file
View File

@ -0,0 +1,340 @@
/*
****************************************************************
* AUDIO_WIND_DETECT_DEMO
* File : audio_wind_detect_demo.c
* By :
* Notes :风噪检测使用，请不要修改本demo，如有需求，请拷贝副
* 本，自行修改!
* Usage :
*(1)需要打开双麦的宏 TCFG_AUDIO_DUAL_MIC_ENABLE
*(2)需要使用第二版双麦算法 CONST_DMS_GLOBAL_VERSION = DMS_GLOBAL_V200
*(3)调用audio_wind_detect_demo_open();使用
****************************************************************
*/
#include "audio_wind_detect_demo.h"
#include "system/includes.h"
#include "app_config.h"
#include "audio_adc.h"
#include "audio_enc.h"
#include "aec_user.h"
#include "task.h"
#include "cvp/cvp_common.h"
#include "lib_h/jlsp_ns.h"
#include "online_db_deal.h"
#include "spp_user.h"
#include "overlay_code.h"
#include "app_main.h"
#define WIND_DETECT_TASK_NAME "WindDetect"
/* 通过蓝牙spp发送风噪信息
* 需要同时打开USER_SUPPORT_PROFILE_SPP和APP_ONLINE_DEBUG*/
#define WIND_DETECT_INFO_SPP_DEBUG_ENABLE 0
#define AUDIO_ADC_BUF_NUM 3 //mic_adc采样buf个数
#define AUDIO_ADC_IRQ_POINTS 256 //mic_adc采样长度（单位：点数）
#if TCFG_AUDIO_TRIPLE_MIC_ENABLE
#define AUDIO_ADC_CH 3 //3mic通话
#elif TCFG_AUDIO_DUAL_MIC_ENABLE
#define AUDIO_ADC_CH 2 //双mic通话
#else
#define AUDIO_ADC_CH 1 //单mic通话
#endif/*TCFG_AUDIO_DUAL_MIC_ENABLE*/
#define AUDIO_ADC_BUFS_SIZE (AUDIO_ADC_BUF_NUM * AUDIO_ADC_IRQ_POINTS * AUDIO_ADC_CH)
struct audio_mic_hdl {
struct audio_adc_output_hdl adc_output;
struct adc_mic_ch mic_ch;
int adc_dump_cnt;
s16 adc_buf[AUDIO_ADC_BUFS_SIZE]; //align 2Bytes
#if (AUDIO_ADC_CH > 1)
s16 tmp_buf[AUDIO_ADC_IRQ_POINTS];
#endif/*AUDIO_ADC_CH*/
#if (AUDIO_ADC_CH > 2)
s16 tmp_buf_1[AUDIO_ADC_IRQ_POINTS];
#endif/*AUDIO_ADC_CH*/
};
static struct audio_mic_hdl *audio_mic = NULL;
extern struct audio_adc_hdl adc_hdl;
struct audio_wind_detect_hdl {
int wd_flag;
int wd_val;
int wd_lev;
#if WIND_DETECT_INFO_SPP_DEBUG_ENABLE
struct spp_operation_t *spp_opt;
#endif
};
static struct audio_wind_detect_hdl *audio_wd = NULL;
void audio_mic_dump_set(u16 dump_cnt)
{
printf("adc_dump_cnt:%d\n", dump_cnt);
if (audio_mic) {
audio_mic->adc_dump_cnt = dump_cnt;
}
}
/*adc_mic采样输出接口*/
static void adc_mic_output_handler(void *priv, s16 *data, int len)
{
if (audio_mic) {
if (audio_mic->adc_dump_cnt) {
audio_mic->adc_dump_cnt--;
//printf("[%d]",audio_mic->adc_dump_cnt);
memset(data, 0, len);
return;
}
#if (AUDIO_ADC_CH == 3)/*3 Mic*/
s16 *mic0_data = data;
s16 *mic1_data = data + (len / 2);
s16 *mic2_data = data + (len / 2) * 2;
int offset = 0;
s16 *mic1_data_pos = audio_mic->tmp_buf;
s16 *mic2_data_pos = audio_mic->tmp_buf_1;
//printf("mic_data:%x,%x,%d\n",data,mic1_data_pos,len);
for (u16 i = 0; i < (len >> 1); i++) {
mic0_data[i] = data[i * 3];
mic1_data[i] = data[i * 3 + 1];
mic2_data[i] = data[i * 3 + 2];
}
memcpy(mic1_data, mic1_data_pos, len);
memcpy(mic2_data, mic2_data_pos, len);
offset = (len / 2) * app_var.talk_ref_mic_ch;
audio_aec_inbuf_ref(data + offset, len);
offset = (len / 2) * app_var.talk_fb_mic_ch;
audio_aec_inbuf_ref_1(data + offset, len);
offset = (len / 2) * app_var.talk_mic_ch;
audio_aec_inbuf(data + offset, len);
return;
#elif (AUDIO_ADC_CH == 2)/*DualMic*/
s16 *mic0_data = data;
s16 *mic1_data = audio_mic->tmp_buf;
s16 *mic1_data_pos = data + (len / 2);
//printf("mic_data:%x,%x,%d\n",data,mic1_data_pos,len);
for (u16 i = 0; i < (len >> 1); i++) {
mic0_data[i] = data[i * 2];
mic1_data[i] = data[i * 2 + 1];
}
memcpy(mic1_data_pos, mic1_data, len);
#if (TCFG_AUDIO_DMS_MIC_MANAGE == DMS_MASTER_MIC0)
audio_aec_inbuf_ref(mic1_data_pos, len);
audio_aec_inbuf(data, len);
#else
audio_aec_inbuf_ref(data, len);
audio_aec_inbuf(mic1_data_pos, len);
#endif/*TCFG_AUDIO_DMS_MIC_MANAGE*/
#else/*SingleMic*/
audio_aec_inbuf(data, len);
#endif/*ESCO_ADC_CH*/
}
}
/*mic初始化*/
static int audio_mic_en(u8 en, u16 sr, u16 mic0_gain, u16 mic1_gain, u16 mic2_gain, u16 mic3_gain)
{
printf("audio_mic_en:%d\n", en);
u8 mic_ch = en;
if (en) {
if (audio_mic) {
printf("audio_mic re-malloc error\n");
return -1;
}
audio_mic = zalloc(sizeof(struct audio_mic_hdl));
if (audio_mic == NULL) {
printf("audio mic zalloc failed\n");
return -1;
}
audio_mic_pwr_ctl(MIC_PWR_ON);
audio_mic_dump_set(3);/*处理开mic后在短时间起3次中断影响aec的问题*/
if (en & AUDIO_ADC_MIC_0) {
printf("adc_mic0 open,gain:%d\n", mic0_gain);
audio_adc_mic_open(&audio_mic->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic_set_gain(&audio_mic->mic_ch, mic0_gain);
}
if (en & AUDIO_ADC_MIC_1) {
printf("adc_mic1 open,gain:%d\n", mic1_gain);
audio_adc_mic1_open(&audio_mic->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic1_set_gain(&audio_mic->mic_ch, mic1_gain);
}
if (en & AUDIO_ADC_MIC_2) {
printf("adc_mic2 open,gain:%d\n", mic2_gain);
audio_adc_mic2_open(&audio_mic->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic2_set_gain(&audio_mic->mic_ch, mic2_gain);
}
if (en & AUDIO_ADC_MIC_3) {
printf("adc_mic3 open,gain:%d\n", mic3_gain);
audio_adc_mic3_open(&audio_mic->mic_ch, mic_ch, &adc_hdl);
audio_adc_mic3_set_gain(&audio_mic->mic_ch, mic3_gain);
}
audio_adc_mic_set_sample_rate(&audio_mic->mic_ch, sr);
audio_adc_mic_set_buffs(&audio_mic->mic_ch, audio_mic->adc_buf,
AUDIO_ADC_IRQ_POINTS * 2, AUDIO_ADC_BUF_NUM);
audio_mic->adc_output.handler = adc_mic_output_handler;
audio_adc_add_output_handler(&adc_hdl, &audio_mic->adc_output);
audio_adc_mic_start(&audio_mic->mic_ch);
} else {
if (audio_mic) {
audio_adc_mic_close(&audio_mic->mic_ch);
audio_adc_del_output_handler(&adc_hdl, &audio_mic->adc_output);
audio_mic_pwr_ctl(MIC_PWR_OFF);
free(audio_mic);
audio_mic = NULL;
}
}
return 0;
}
static int audio_wind_detect_output_hdl(s16 *data, int len)
{
return len;
}
/*打开风噪检测*/
int audio_wind_detect_open(u32 sr, u16 mic0_gain, u16 mic1_gain, u16 mic2_gain, u16 mic3_gain)
{
int err = 0;
overlay_load_code(OVERLAY_AEC);
audio_aec_open(sr, -1, audio_wind_detect_output_hdl);
/* audio_aec_open(sr, WNC_EN | ENC_EN | AEC_EN, audio_wind_detect_output_hdl); */
audio_mic_en(TCFG_AUDIO_ADC_MIC_CHA, sr, mic0_gain, mic1_gain, mic2_gain, mic3_gain);
return 0;
}
/*关闭风噪检测*/
int audio_wind_detect_close()
{
audio_aec_close();
audio_mic_en(0, 0, 0, 0, 0, 0);
return 0;
}
/*风噪检测信息获取任务*/
static void audio_wind_detect_task(void *p)
{
while (1) {
os_time_dly(10);
audio_get_wind_detect_info();
}
}
/*打开获取风噪信息的任务*/
int audio_wind_info_task_open()
{
int err = 0;
if (audio_wd) {
printf("[err] audio_wd re-malloc !!!");
return -1;
}
audio_wd = zalloc(sizeof(struct audio_wind_detect_hdl));
if (audio_wd == NULL) {
printf("[err] audio_wd malloc fail !!!");
return 0;
}
#if WIND_DETECT_INFO_SPP_DEBUG_ENABLE
spp_get_operation_table(&audio_wd->spp_opt);
#endif
overlay_load_code(OVERLAY_AEC);
err = os_task_create(audio_wind_detect_task, NULL, 2, 256, 128, WIND_DETECT_TASK_NAME);
/* err = task_create(audio_wind_detect_task, NULL, WIND_DETECT_TASK_NAME); */
if (err != OS_NO_ERR) {
printf("task create error!");
return -1;
}
return 0;
}
/*关闭获取风噪信息的任务*/
int audio_wind_info_task_close(void)
{
if (audio_wd) {
/* task_kill(WIND_DETECT_TASK_NAME); */
os_task_del(WIND_DETECT_TASK_NAME);
free(audio_wd);
audio_wd = NULL;
}
return 0;
}
/*打开风噪检测的demo*/
int audio_wind_detect_demo_open(void)
{
/*打开风噪检测*/
audio_wind_detect_open(16000, 4, 4, 1, 1);
/*获取风噪的信息*/
audio_wind_info_task_open();
return 0;
}
/*关闭风噪检测的demo*/
int audio_wind_detect_demo_close(void)
{
audio_wind_detect_close();
audio_wind_info_task_close();
return 0;
}
/*获取风噪信息*/
int audio_get_wind_detect_info(void)
{
if (audio_wd) {
#if TCFG_AUDIO_TRIPLE_MIC_ENABLE
jlsp_tms_get_wind_detect_info(&audio_wd->wd_flag, &audio_wd->wd_val, &audio_wd->wd_lev);
#elif TCFG_AUDIO_DUAL_MIC_ENABLE
jlsp_get_wind_detect_info(&audio_wd->wd_flag, &audio_wd->wd_val, &audio_wd->wd_lev);
#endif
printf("wd_flag:%d, wd_val:%d, wd_lev:%d", audio_wd->wd_flag, audio_wd->wd_val, audio_wd->wd_lev);
#if WIND_DETECT_INFO_SPP_DEBUG_ENABLE
if (audio_wd->spp_opt && audio_wd->spp_opt->send_data) {
char tmpbuf[25];
memset(tmpbuf, 0x20, sizeof(tmpbuf));
sprintf(tmpbuf, "falg:%d, val:%d, lev:%d", audio_wd->wd_flag, audio_wd->wd_val, audio_wd->wd_lev);
audio_wd->spp_opt->send_data(NULL, tmpbuf, sizeof(tmpbuf));
}
#endif
}
return 0;
}
/*获取是否有风，0：无风，1：有风*/
int audio_get_wd_flag(void)
{
if (audio_wd) {
return audio_wd->wd_flag;
}
return -1;
}
/*获取风强*/
int audio_get_wd_val(void)
{
if (audio_wd) {
return audio_wd->wd_val;
}
return -1;
}
/*获取预设的风噪等级, 0：弱风，1：中风：2：强风*/
int audio_get_wd_lev(void)
{
if (audio_wd) {
return audio_wd->wd_lev;
}
return -1;
}
static u8 audio_wind_detect_idle_query()
{
return (audio_wd == NULL) ? 1 : 0;
}
REGISTER_LP_TARGET(audio_wind_detect_lp_target) = {
.name = "audio_wind_detect",
.is_idle = audio_wind_detect_idle_query,
};

35
cpu/br28/audio_demo/audio_wind_detect_demo.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef __AUDIO_WIND_DETECT_DEMO_H_
#define __AUDIO_WIND_DETECT_DEMO_H_
#include "generic/typedef.h"
/*打开风噪检测的demo*/
int audio_wind_detect_demo_open(void);
/*关闭风噪检测的demo*/
int audio_wind_detect_demo_close(void);
/*打开风噪检测*/
int audio_wind_detect_open(u32 sr, u16 mic0_gain, u16 mic1_gain, u16 mic2_gain, u16 mic3_gain);
/*关闭风噪检测*/
int audio_wind_detect_close();
/*打开获取风噪信息的任务*/
int audio_wind_info_task_open();
/*获取风噪信息*/
int audio_get_wind_detect_info(void);
/*关闭获取风噪信息的任务*/
int audio_wind_info_task_close(void);
/*获取是否有风，0：无风，1：有风*/
int audio_get_wd_flag(void);
/*获取风强*/
int audio_get_wd_val(void);
/*获取预设的风噪等级, 0：弱风，1：中风：2：强风*/
int audio_get_wd_lev(void);
#endif /* __AUDIO_WIND_DETECT_DEMO_H_*/