Uahpet/AC707N
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
36e62db3a4021223d74c8a4df5ff2e97b6a2921a
AC707N/SDK/audio/smart_voice/voice_mic_data.c
T
huxi bc195654bf 初版
2025-12-03 11:12:34 +08:00

679 lines
20 KiB
C
Raw Blame History

#ifdef SUPPORT_MS_EXTENSIONS
#pragma bss_seg(".voice_mic_data.data.bss")
#pragma data_seg(".voice_mic_data.data")
#pragma const_seg(".voice_mic_data.text.const")
#pragma code_seg(".voice_mic_data.text")
#endif
/*****************************************************************
>file name : voice_mic_data.c
>author : lichao
>create time : Mon 01 Nov 2021 11:33:32 AM CST
*****************************************************************/
#include "app_config.h"
#include "voice_mic_data.h"
#include "smart_voice.h"
#include "app_main.h"
#include "adc_file.h"
#include "aec_uart_debug.h"
#include "effects/convert_data.h"
#include "circular_buf.h"
#include "media/audio_general.h"
#include "audio_splicing.h"
#if TCFG_AUDIO_ANC_ENABLE
#include "audio_anc.h"
#endif /*TCFG_AUDIO_ANC_ENABLE*/
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
#include "vad_mic.h"
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
#if TCFG_SMART_VOICE_USE_AEC
#include "audio_cvp.h"
#include "overlay_code.h"
#endif
#if ((defined TCFG_SMART_VOICE_ENABLE) && TCFG_SMART_VOICE_ENABLE)
extern struct audio_adc_hdl adc_hdl;
#define CONFIG_VOICE_MIC_DATA_DUMP 0
#define CONFIG_VOICE_MIC_DATA_EXPORT 0
#define MAIN_ADC_GAIN 8
#define MAIN_ADC_BUF_NUM 3
struct main_adc_context {
struct audio_adc_output_hdl dma_output;
struct adc_mic_ch mic_ch;
s16 *dma_buf;
s16 *mic_sample_data;
u8 adc_ch_num; //打开的adc ch数量
u8 adc_seq; //记录当前用的那个mic
u8 bit_width;
};
/*
* Mic 数据接收buffer(循环buffer，动态大小)
*/
struct voice_mic_data {
u8 open;
u8 source;
struct main_adc_context *main_adc;
void *vad_mic;
struct list_head head;
cbuffer_t cbuf;
u8 buf[0];
};
struct voice_mic_capture_channel {
void *priv;
void (*output)(void *priv, s16 *data, int len);
struct list_head entry;
};
static struct voice_mic_data *voice_handle = NULL;
extern const u8 const_adc_async_en;
#define __this (voice_handle)
#if CONFIG_VOICE_MIC_DATA_DUMP
static u8 mic_data_dump = 0;
#endif
int audio_smart_voice_aec_run(void *priv, s16 *data, int len);
#if TCFG_SMART_VOICE_USE_AEC
struct voice_aec_hdl_t {
cbuffer_t aec_cbuf;
u8 aec_data_buf[640 * 3];
u8 in_tmpbuf[3][512];
u8 *ref_tmpbuf;
int ref_tmpbuf_len;
int last_data_len;
u8 bit_width;
u8 ref_channel;
};
static struct voice_aec_hdl_t *voice_aec_hdl = NULL;
extern int audio_dac_read_reset(void);
extern int audio_dac_read(s16 points_offset, void *data, int len, u8 read_channel);
extern int a2dp_player_runing();
void audio_smart_voice_aec_cbuf_data_clear()
{
if (voice_aec_hdl) {
cbuf_clear(&voice_aec_hdl->aec_cbuf);
audio_dac_read_reset();
}
}
static int audio_smart_voice_aec_run(void *priv, s16 *data, int len)
{
if (a2dp_player_runing() && voice_aec_hdl) {
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
/*vad 刚起来时，会把缓存的4包数据一起推出来，需要等数据稳定320byte后再做回音消除*/
if (len != voice_aec_hdl->last_data_len) {
audio_dac_read_reset();
voice_aec_hdl->last_data_len = len;
return 0;
}
voice_aec_hdl->last_data_len = len;
#endif
int wlen = 0;
wlen = cbuf_write(&voice_aec_hdl->aec_cbuf, data, len);
if (wlen != len) {
putchar('a');
}
int dac_read_len;
if (voice_aec_hdl->bit_width == ADC_BIT_WIDTH_16) {
dac_read_len = len * 1 * voice_aec_hdl->ref_channel * 3;
audio_dac_read(0, voice_aec_hdl->ref_tmpbuf, dac_read_len / voice_aec_hdl->ref_channel, voice_aec_hdl->ref_channel);
if (voice_aec_hdl->ref_channel == 2) {
pcm_dual_to_single(voice_aec_hdl->ref_tmpbuf, voice_aec_hdl->ref_tmpbuf, dac_read_len);
dac_read_len >>= 1;
}
audio_aec_refbuf((s16 *)voice_aec_hdl->ref_tmpbuf, NULL, dac_read_len);
} else {
dac_read_len = len * 2 * voice_aec_hdl->ref_channel * 3;
audio_dac_read(0, voice_aec_hdl->ref_tmpbuf, dac_read_len / voice_aec_hdl->ref_channel, voice_aec_hdl->ref_channel);
audio_convert_data_32bit_to_16bit_round((s32 *)voice_aec_hdl->ref_tmpbuf, (s16 *)voice_aec_hdl->ref_tmpbuf, dac_read_len / 4);
dac_read_len >>= 1;
if (voice_aec_hdl->ref_channel == 2) {
pcm_dual_to_single(voice_aec_hdl->ref_tmpbuf, voice_aec_hdl->ref_tmpbuf, dac_read_len);
dac_read_len >>= 1;
}
audio_aec_refbuf((s16 *)voice_aec_hdl->ref_tmpbuf, NULL, dac_read_len);
}
static u8 burk = 0;
if (cbuf_get_data_len(&voice_aec_hdl->aec_cbuf) >= 512) {
wlen = cbuf_read(&voice_aec_hdl->aec_cbuf, &(voice_aec_hdl->in_tmpbuf[burk][0]), 512);
audio_aec_inbuf((s16 *) & (voice_aec_hdl->in_tmpbuf[burk][0]), wlen);
burk++;
if (burk > 2) {
burk = 0;
}
/* printf("wlen : %d", wlen); */
} else {
//printf("data_len : %d", cbuf_get_data_len(&__this->aec_cbuf));
}
return len;
} else {
return 0;
}
}
/*清晰语音数据输出*/
static int cvp_output_hdl(s16 *data, u16 len)
{
struct voice_mic_data *voice = (struct voice_mic_data *)__this;
struct voice_mic_capture_channel *ch;
list_for_each_entry(ch, &voice->head, entry) {
if (ch->output) {
ch->output(ch->priv, data, len);
}
}
int wlen = cbuf_write(&voice->cbuf, data, len);
if (wlen < len) {
putchar('D');
}
return wlen;
}
int audio_smart_voice_aec_open(void)
{
if (voice_aec_hdl) {
printf("voice_aec_hdl is alreadly open !!!");
return -1;
}
struct voice_aec_hdl_t *hdl = zalloc(sizeof(struct voice_aec_hdl_t));
if (hdl == NULL) {
printf("hdl malloc fail !!!");
return -1;
}
#if (TCFG_DAC_NODE_ENABLE && (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR))
hdl->ref_channel = 2;
#else
hdl->ref_channel = 1;
#endif
hdl->bit_width = audio_general_out_dev_bit_width();
printf("hdl->bit_width %d", hdl->bit_width);
if (hdl->bit_width == DATA_BIT_WIDE_16BIT) {
hdl->ref_tmpbuf_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(short) * hdl->ref_channel * 3;
} else {
hdl->ref_tmpbuf_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(int) * hdl->ref_channel * 3;
}
hdl->ref_tmpbuf = zalloc(hdl->ref_tmpbuf_len);
cbuf_init(&hdl->aec_cbuf, hdl->aec_data_buf, sizeof(hdl->aec_data_buf));
struct audio_aec_init_param_t init_param = {
.sample_rate = VOICE_ADC_SAMPLE_RATE,
.ref_sr = TCFG_AUDIO_GLOBAL_SAMPLE_RATE,
};
audio_aec_open(&init_param, AEC_EN, cvp_output_hdl);
audio_dac_read_reset();
voice_aec_hdl = hdl;
return 0;
}
void audio_smart_voice_aec_close(void)
{
if (voice_aec_hdl) {
audio_aec_close();
free(voice_aec_hdl->ref_tmpbuf);
free(voice_aec_hdl);
voice_aec_hdl = NULL;
}
}
#endif // TCFG_SMART_VOICE_USE_AEC
static int voice_mic_data_output(void *priv, s16 *data, int len)
{
struct voice_mic_data *voice = (struct voice_mic_data *)priv;
int wlen = 0;
#if TCFG_SMART_VOICE_USE_AEC
wlen = audio_smart_voice_aec_run(priv, data, len);
if (wlen) {
return wlen;
} else
#endif // TCFG_SMART_VOICE_USE_AEC
{
struct voice_mic_capture_channel *ch;
list_for_each_entry(ch, &voice->head, entry) {
if (ch->output) {
ch->output(ch->priv, data, len);
}
}
wlen = cbuf_write(&voice->cbuf, data, len);
if (wlen < len) {
putchar('D');
}
}
return wlen;
}
static void audio_main_adc_dma_data_handler(void *priv, s16 *data, int len)
{
struct voice_mic_data *voice = (struct voice_mic_data *)priv;
if (!voice || voice->source != VOICE_MCU_MIC) {
return;
}
s16 *pcm_data = NULL;
if (voice->main_adc->bit_width != ADC_BIT_WIDTH_16) {
s32 *s32_src = (s32 *)data;
s32 *s32_dst = (s32 *)voice->main_adc->mic_sample_data;
if (voice->main_adc->adc_ch_num > 1) {
for (int i = 0; i < len / 4; i++) {
s32_dst[i] = s32_src[i * voice->main_adc->adc_ch_num + voice->main_adc->adc_seq];
}
audio_convert_data_32bit_to_16bit_round(s32_dst, (s16 *)s32_dst, len / 4);
} else {
audio_convert_data_32bit_to_16bit_round(s32_src, (s16 *)s32_dst, len / 4);
}
pcm_data = (s16 *)s32_dst;
len >>= 1;
} else {
s16 *s16_src = (s16 *)data;
s16 *s16_dst = (s16 *)voice->main_adc->mic_sample_data;
if (voice->main_adc->adc_ch_num > 1) {
for (int i = 0; i < len / 2; i++) {
s16_dst[i] = s16_src[i * voice->main_adc->adc_ch_num + voice->main_adc->adc_seq];
}
pcm_data = (s16 *)s16_dst;
} else {
pcm_data = (s16 *)data;
}
}
/* putchar('M'); */
voice_mic_data_output(voice, pcm_data, len);
smart_voice_core_post_msg(1, SMART_VOICE_MSG_DMA);
}
#if TCFG_CALL_KWS_SWITCH_ENABLE
static void audio_main_adc_mic_close(struct voice_mic_data *voice, u8 all_channel);
static void audio_main_adc_suspend_handler(int all_channel, int arg)
{
OS_SEM *sem = (OS_SEM *)arg;
if (__this) {
audio_main_adc_mic_close(__this, all_channel);
}
os_sem_post(sem);
}
void audio_main_adc_suspend_in_core_task(u8 all_channel)
{
if (!__this || !__this->main_adc) {
return;
}
int argv[5];
OS_SEM *sem = malloc(sizeof(OS_SEM));
os_sem_create(sem, 0);
argv[0] = (int)audio_main_adc_suspend_handler;
argv[1] = 2;
argv[2] = all_channel;
argv[3] = (int)sem;
do {
int err = os_taskq_post_type(ASR_CORE, Q_CALLBACK, 4, argv);
if (err == OS_ERR_NONE) {
break;
}
if (err != OS_Q_FULL) {
audio_main_adc_suspend_handler(all_channel, (int)sem);
goto exit;
}
os_time_dly(2);
} while (1);
os_sem_pend(sem, 100);
exit:
free(sem);
}
void kws_aec_data_output(void *priv, s16 *data, int len)
{
if (!__this || __this->source != VOICE_MCU_MIC) {
return;
}
audio_main_adc_suspend_in_core_task(0);
voice_mic_data_output(__this, data, len);
smart_voice_core_post_msg(1, SMART_VOICE_MSG_DMA);
}
u8 kws_get_state(void)
{
if (!__this || __this->source != VOICE_MCU_MIC) {
return 0;
}
return 1;
}
void smart_voice_mcu_mic_suspend(void)
{
if (!__this || __this->source != VOICE_MCU_MIC) {
return;
}
//打开adc前, 如果kws本身打开了mic，需要close
audio_main_adc_suspend_in_core_task(1);
}
#endif
#define audio_main_adc_mic_ch_setup(ch, mic_ch, ch_map, adc_handle) \
if (ch_map & BIT(ch)) { \
audio_adc_mic##ch##_open(mic_ch, ch_map, adc_handle); \
}
static int audio_main_adc_mic_open(struct voice_mic_data *voice)
{
int ret = 0;
if (voice->main_adc) {
printf("audio main adc mic already open !!!");
return 0;
}
voice->main_adc = zalloc(sizeof(struct main_adc_context));
if (!voice->main_adc) {
return -ENOMEM;
}
#if TCFG_AUDIO_ANC_ENABLE && (!TCFG_AUDIO_DYNAMIC_ADC_GAIN)
/* MAIN_ADC_GAIN = anc_mic_gain_get(); */
#elif TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_DYNAMIC_ADC_GAIN
anc_dynamic_micgain_start(MAIN_ADC_GAIN);
#endif/*TCFG_AUDIO_ANC_ENABLE && (!TCFG_AUDIO_DYNAMIC_ADC_GAIN)*/
if (const_adc_async_en) {
/*是否4个adc通道都打开，音箱使用*/
voice->main_adc->adc_ch_num = 4;
} else {
/*默认打开一个adc通道做语音识别，耳机使用*/
voice->main_adc->adc_ch_num = 1;
}
voice->main_adc->bit_width = adc_hdl.bit_width;
/*设置adc buf大小*/
int dma_len = 0;
if (voice->main_adc->bit_width == ADC_BIT_WIDTH_16) {
dma_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(short) * MAIN_ADC_BUF_NUM * voice->main_adc->adc_ch_num;
} else {
dma_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(int) * MAIN_ADC_BUF_NUM * voice->main_adc->adc_ch_num;
}
voice->main_adc->dma_buf = zalloc(dma_len);
printf("adc dma_len %d ", dma_len);
/*设置缓存buf大小*/
int buf_len = 0;
if (voice->main_adc->bit_width == ADC_BIT_WIDTH_16) {
if (voice->main_adc->adc_ch_num > 1) {
buf_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(short);
}
} else {
if (voice->main_adc->adc_ch_num > 1) {
buf_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(int);
} else {
buf_len = VOICE_MIC_DATA_PERIOD_FRAMES * sizeof(short);
}
}
printf("mic sample data len %d", buf_len);
if (buf_len) {
voice->main_adc->mic_sample_data = zalloc(buf_len);
}
/*配置使用哪个mic做语音识别*/
#ifdef TCFG_SMART_VOICE_MIC_CH_SEL
u8 ch = TCFG_SMART_VOICE_MIC_CH_SEL;
#else
u8 ch = AUDIO_ADC_MIC_0;
#endif
printf("%s:%d", __func__, ch);
audio_adc_file_init();
if (ch & AUDIO_ADC_MIC_0) {
adc_file_mic_open(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_0);
audio_adc_mic_set_gain(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_0, MAIN_ADC_GAIN);
}
if (ch & AUDIO_ADC_MIC_1) {
adc_file_mic_open(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_1);
audio_adc_mic_set_gain(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_1, MAIN_ADC_GAIN);
}
if (ch & AUDIO_ADC_MIC_2) {
adc_file_mic_open(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_2);
audio_adc_mic_set_gain(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_2, MAIN_ADC_GAIN);
}
if (ch & AUDIO_ADC_MIC_3) {
adc_file_mic_open(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_3);
audio_adc_mic_set_gain(&voice->main_adc->mic_ch, AUDIO_ADC_MIC_3, MAIN_ADC_GAIN);
}
audio_adc_mic_set_sample_rate(&voice->main_adc->mic_ch, VOICE_ADC_SAMPLE_RATE);
ret = audio_adc_mic_set_buffs(&voice->main_adc->mic_ch, voice->main_adc->dma_buf,
VOICE_MIC_DATA_PERIOD_FRAMES * 2, MAIN_ADC_BUF_NUM);
if (ret && voice->main_adc->dma_buf) {
/*已经设置过buf了，并不需要在set buf*/
free(voice->main_adc->dma_buf);
voice->main_adc->dma_buf = NULL;
}
voice->main_adc->dma_output.priv = voice;
voice->main_adc->dma_output.handler = audio_main_adc_dma_data_handler;
audio_adc_add_output_handler(&adc_hdl, &voice->main_adc->dma_output);
audio_adc_mic_start(&voice->main_adc->mic_ch);
voice->main_adc->adc_seq = get_adc_seq(&adc_hdl, ch); //查询模拟mic对应的ADC通道,打开4个adc通道时使用
printf("adc_seq %d", voice->main_adc->adc_seq);
return 0;
}
static void audio_main_adc_mic_close(struct voice_mic_data *voice, u8 all_channel)
{
if (voice->main_adc) {
#if TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_DYNAMIC_ADC_GAIN
anc_dynamic_micgain_stop();
#endif/*TCFG_AUDIO_ANC_ENABLE && TCFG_AUDIO_DYNAMIC_ADC_GAIN*/
if (all_channel) {
audio_adc_mic_close(&voice->main_adc->mic_ch);
}
audio_adc_del_output_handler(&adc_hdl, &voice->main_adc->dma_output);
if (voice->main_adc->dma_buf) {
/*mic close时会自动释放内存*/
/* free(voice->main_adc->dma_buf); */
voice->main_adc->dma_buf = NULL;
}
if (voice->main_adc->mic_sample_data) {
free(voice->main_adc->mic_sample_data);
voice->main_adc->mic_sample_data = NULL;
}
free(voice->main_adc);
voice->main_adc = NULL;
}
}
void *voice_mic_data_open(u8 source, int buffer_size, int sample_rate)
{
if (!__this) {
__this = zalloc(sizeof(struct voice_mic_data) + buffer_size);
}
if (!__this) {
return NULL;
}
if (__this->open) {
return __this;
}
cbuf_init(&__this->cbuf, __this->buf, buffer_size);
__this->source = source;
INIT_LIST_HEAD(&__this->head);
#if CONFIG_VOICE_MIC_DATA_EXPORT
aec_uart_open(1, VOICE_MIC_DATA_PERIOD_FRAMES * 2);
#endif
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
if (source == VOICE_VAD_MIC) {
__this->vad_mic = lp_vad_mic_open((void *)__this, voice_mic_data_output);
} else if (source == VOICE_MCU_MIC)
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
{
audio_main_adc_mic_open(__this);
smart_voice_core_post_msg(1, SMART_VOICE_MSG_WAKE);
}
__this->open = 1;
return __this;
}
void voice_mic_data_close(void *mic)
{
struct voice_mic_data *voice = (struct voice_mic_data *)mic;
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
if (voice->source == VOICE_VAD_MIC) {
lp_vad_mic_close(voice->vad_mic);
voice->vad_mic = NULL;
} else if (voice->source == VOICE_MCU_MIC)
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
{
audio_main_adc_mic_close(voice, 1);
smart_voice_core_post_msg(1, SMART_VOICE_MSG_STANDBY);
}
#if CONFIG_VOICE_MIC_DATA_EXPORT
aec_uart_close();
#endif
if (voice) {
free(voice);
}
__this = NULL;
}
void voice_mic_data_switch_source(void *mic, u8 source, int buffer_size, int sample_rate)
{
struct voice_mic_data *voice = (struct voice_mic_data *)mic;
voice->source = source;
if (voice->source == VOICE_VAD_MIC) {
audio_main_adc_mic_close(voice, 1);
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
if (!voice->vad_mic) {
voice->vad_mic = lp_vad_mic_open(voice, voice_mic_data_output);
}
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
} else if (voice->source == VOICE_MCU_MIC) {
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
if (voice->vad_mic) {
lp_vad_mic_close(voice->vad_mic);
voice->vad_mic = NULL;
}
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
audio_main_adc_mic_open(voice);
smart_voice_core_post_msg(1, SMART_VOICE_MSG_WAKE);
}
}
void *voice_mic_data_capture(int sample_rate, void *priv, void (*output)(void *priv, s16 *data, int len))
{
struct voice_mic_capture_channel *ch = (struct voice_mic_capture_channel *)zalloc(sizeof(struct voice_mic_capture_channel));
if (!ch) {
return NULL;
}
voice_mic_data_open(VOICE_VAD_MIC, 2048, sample_rate);
if (!__this) {
free(ch);
return NULL;
}
ch->priv = priv;
ch->output = output;
list_add(&ch->entry, &__this->head);
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
lp_vad_mic_test();
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
return ch;
}
void voice_mic_data_stop_capture(void *mic)
{
struct voice_mic_capture_channel *ch = (struct voice_mic_capture_channel *)mic;
if (ch) {
list_del(&ch->entry);
free(ch);
}
if (list_empty(&__this->head)) {
#if CONFIG_VAD_PLATFORM_SUPPORT_EN
lp_vad_mic_test();
#endif /*CONFIG_VAD_PLATFORM_SUPPORT_EN*/
}
}
int voice_mic_data_read(void *mic, void *data, int len)
{
struct voice_mic_data *fb = (struct voice_mic_data *)mic;
/* printf("%s. %d, %d", __func__, len, cbuf_get_data_len(&fb->cbuf)); */
if (cbuf_get_data_len(&fb->cbuf) < len) {
return 0;
} else {
int wlen = cbuf_read(&fb->cbuf, data, len);
#if CONFIG_VOICE_MIC_DATA_EXPORT
aec_uart_fill(0, data, len);
aec_uart_write();
#endif
return wlen;
}
}
int voice_mic_data_buffered_samples(void *mic)
{
struct voice_mic_data *fb = (struct voice_mic_data *)mic;
return cbuf_get_data_len(&fb->cbuf) >> 1;
}
void voice_mic_data_clear(void *mic)
{
struct voice_mic_data *fb = (struct voice_mic_data *)mic;
cbuf_clear(&fb->cbuf);
}
void voice_mic_data_dump(void *mic)
{
struct voice_mic_data *fb = (struct voice_mic_data *)mic;
if (fb == NULL) {
return;
}
#if CONFIG_VOICE_MIC_DATA_DUMP
mic_data_dump = 1;
int len = 0;
int i = 0;
s16 *data = (s16 *)cbuf_read_alloc(&fb->cbuf, &len);
len >>= 1;
if (data) {
#if 0
for (i = 0; i < len; i++) {
if ((i % 3000) == 0) {
wdt_clear();
}
printf("%d\n", data[i]);
}
#else
put_buf(data, len << 1);
#endif
}
cbuf_read_updata(&fb->cbuf, len << 1);
mic_data_dump = 0;
#endif
}
#endif
Reference in New Issue View Git Blame Copy Permalink