Kaotings/KT24-1110_65E-HA-651B
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
50d8f1f7c1
KT24-1110_65E-HA-651B/cpu/br25/audio_mic/mic_effect.c

1849 lines
58 KiB
C
Raw Normal View History

inited
2024-11-10 10:44:17 +00:00
#include "audio_splicing.h"
#include "application/audio_bfilt.h"
#include "media/audio_eq_drc_apply.h"
#include "application/audio_echo_src.h"
#include "application/audio_energy_detect.h"
#include "clock_cfg.h"
#include "media/audio_stream.h"
#include "media/includes.h"
#include "mic_effect.h"
#include "asm/dac.h"
#include "audio_enc/audio_enc.h"
#include "audio_dec.h"
#include "stream_entry.h"
#include "effect_linein.h"
#include "audio_recorder_mix.h"
#include "app_task.h"
#include "vollevel_detect.h"
#include "media/effects_adj.h"
#include "audio_effect/audio_eff_default_parm.h"
#include "audio_effect/audio_autotune_demo.h"
#include "media/convert_data.h"
#include "simpleAGC.h"
#define LOG_TAG "[APP-REVERB]"
#define LOG_ERROR_ENABLE
#define LOG_INFO_ENABLE
#define LOG_DUMP_ENABLE
#define LOG_DEBUG_ENABLE
#include "debug.h"
#ifdef SUPPORT_MS_EXTENSIONS
//#pragma bss_seg(".audio_mic_stream_bss")
//#pragma data_seg(".audio_mic_stream_data")
#pragma const_seg(".audio_mic_effect_const")
#pragma code_seg(".audio_mic_effect_code")
#endif
#if defined(TCFG_MIC_EFFECT_ENABLE) && TCFG_MIC_EFFECT_ENABLE
#define LOUDNESS_DEBUG_ENABLE 0//分贝指示器
// 混响不叠加播U/SD的情况下可以使能，否则可能会出现某些高码率歌曲会卡顿的问题
#ifdef CONFIG_BOARD_AC696X_MEGAPHONE
#define ENABLE_BYPASS_CH_AND_EQ2 1//使能bypass ch and EQ2
#else
#define ENABLE_BYPASS_CH_AND_EQ2 0//使能bypass ch and EQ2
#endif
extern struct audio_dac_hdl dac_hdl;
struct aud_reverb_process {
struct audio_stream_entry entry; // 音频流入口
s16 *tmpbuf[3];
void *eff;//struct __mic_effect
s16 *out_buf;
u8 bit_wide;//eq是否输出32bit位宽
u8 in_ch;
u8 divide;//左右声道是否需要独立的gain
};
struct __mic_effect {
OS_MUTEX mutex;
struct __mic_effect_parm parm;
mic_stream *mic;
struct audio_eq *mic_eq0; //eq 句柄
struct audio_drc *mic_drc0; //eq 句柄
struct convert_data *convert0;//32-》16
#if TCFG_EQ_ENABLE && TCFG_MIC_TUNNING_EQ_ENABLE
struct audio_eq *mic_tunning_eq; //eq 句柄
#endif
struct audio_eq *mic_eq4; //eq drc句柄
struct audio_drc *mic_drc4; //eq drc句柄
struct convert_data *convert4;//32-》16
/* struct aud_gain_process *gain;//最后一级 的增益调节 */
struct audio_stream *stream; // 音频流
struct audio_stream_entry entry; // effect 音频入口
int out_len;
int process_len;
u8 input_ch_num; //mic输入给混响数据流的源声道数
NOISEGATE_API_STRUCT *noisegate;
void *d_vol;
HOWLING_API_STRUCT *howling_ps;
HOWLING_API_STRUCT *notch_howling;
voice_changer_hdl *voice_changer;
#if defined(TCFG_MIC_AUTOTUNE_ENABLE) && TCFG_MIC_AUTOTUNE_ENABLE
autotune_hdl *autotune;
#endif
struct channel_switch *channel_zoom;
struct audio_dac_channel *dac;
#if (RECORDER_MIX_EN)
struct __stream_entry *rec_hdl;
#endif
#if (TCFG_USB_MIC_DATA_FROM_MICEFFECT||TCFG_USB_MIC_DATA_FROM_DAC)
struct __stream_entry *usbmic_hdl;
u8 usbmic_start;
#endif
void *energy_hdl; //能量检测的hdl
u8 dodge_en; //能量检测运行过程闪避是否使能
struct __effect_linein *linein;
struct audio_drc *drc;
u8 pause_mark;
LOUDNESS_M_STRUCT loudness_adc;
LOUDNESS_M_STRUCT loudness_drc_out;
struct __stream_entry *loudness_debug_hdl;
struct audio_src_handle *src_hdl;
struct audio_eq *mic_eq3; //eq drc句柄
struct audio_drc *mic_drc3; //eq drc句柄
u8 main_pause;
//分支0节点
PLATE_REVERB_API_STRUCT *sub_0_plate_reverb_hdl;
struct audio_eq *mic_eq1; //eq drc句柄
struct audio_drc *mic_drc1; //eq drc句柄
//分支1节点
ECHO_API_STRUCT *sub_1_echo_hdl;
struct audio_eq *mic_eq2; //eq drc句柄
struct audio_drc *mic_drc2; //eq drc句柄
//分支1 2 3的总处理
struct aud_reverb_process *aud_reverb;
};
struct __mic_stream_parm *g_mic_parm = NULL;
static struct __mic_effect *p_effect = NULL;
#define __this p_effect
#define R_ALIN(var,al) ((((var)+(al)-1)/(al))*(al))
void *mic_tunning_eq_open(u32 sample_rate, u8 ch_num);
void mic_tunning_eq_close(void *eq);
void *mic_eq_open(u32 sample_rate, u8 ch_num, u8 eq_name);
void *mic_drc_open(u32 sample_rate, u8 ch_num, u8 drc_name, u8 _32bit);
void mic_eq_close(void *eq);
void mic_drc_close(void *drc);
void mic_effect_echo_parm_parintf(ECHO_PARM_SET *parm);
void *mic_energy_detect_open(u32 sr, u8 ch_num);
void mic_energy_detect_close(void *hdl);
void mic_voicechange_switch(u8 eff_mode);
s16 *aud_reverb_process_run(struct aud_reverb_process *hdl, s16 *data, int len);
static void audio_reverb_process_output_data_process_len(struct audio_stream_entry *entry, int len)
{
struct aud_reverb_process *hdl = container_of(entry, struct aud_reverb_process, entry);
}
static int audio_reverb_process_data_handler(struct audio_stream_entry *entry,
struct audio_data_frame *in,
struct audio_data_frame *out)
{
struct aud_reverb_process *hdl = container_of(entry, struct aud_reverb_process, entry);
/* if (in->data_len != 304) { */
/* printf("in->data_len %d\n", in->data_len); */
/* } */
out->data_sync = in->data_sync;
struct __mic_effect *eff = hdl->eff;
if (eff->sub_0_plate_reverb_hdl) {
out->channel = 2;//in->channel;
} else {
out->channel = in->channel;
}
out->data_len = out->channel * in->data_len;
hdl->in_ch = in->channel;
out->data = aud_reverb_process_run(hdl, (short *)((int)in->data + in->offset), (in->data_len - in->offset)); //默认输出2ch
if (out->channel == 1) {
pcm_dual_to_single(out->data, out->data, in->data_len * 2);
}
return in->data_len;
}
struct aud_reverb_process *aud_reverb_open(struct __mic_effect *eff, u8 bit_wide)
{
struct aud_reverb_process *hdl = zalloc(sizeof(struct aud_reverb_process));
hdl->eff = eff;
hdl->bit_wide = bit_wide;
hdl->entry.data_process_len = audio_reverb_process_output_data_process_len;
hdl->entry.data_handler = audio_reverb_process_data_handler;
return hdl;
}
void aud_reverb_close(struct aud_reverb_process *hdl)
{
if (!hdl) {
return;
}
local_irq_disable();
audio_stream_del_entry(&hdl->entry);
local_irq_enable();
for (int i = 0; i < 3; i++) {
if (hdl->tmpbuf[i]) {
free(hdl->tmpbuf[i]);
hdl->tmpbuf[i] = NULL;
}
}
free(hdl);
hdl = NULL;
}
void pcm_single_to_dual_32bit(void *out, void *in, u16 len)
{
s32 *outbuf = out;
s32 *inbuf = in;
len >>= 2;
while (len--) {
*outbuf++ = *inbuf;
*outbuf++ = *inbuf;
inbuf++;
}
}
s16 *aud_reverb_process_run(struct aud_reverb_process *hdl, s16 *data, int len)
{
struct __mic_effect *eff = hdl->eff;
u8 ch_num = eff->input_ch_num;
if (eff->sub_0_plate_reverb_hdl) {
//ch0
if (hdl->in_ch == 2) {
if (!hdl->tmpbuf[0]) {
hdl->tmpbuf[0] = malloc(len);//2ch 16 bit buf
}
u8 *tmp = hdl->tmpbuf[0];
pcm_dual_to_single(&tmp[len / 2], data, len);
run_plate_reverb(eff->sub_0_plate_reverb_hdl, &tmp[len / 2], hdl->tmpbuf[0], len / 2); //内部单变双
} else {
if (!hdl->bit_wide) { //16 bit
if (!hdl->tmpbuf[0]) {
hdl->tmpbuf[0] = malloc(len * 2);//2ch 16 bit buf
}
run_plate_reverb(eff->sub_0_plate_reverb_hdl, data, hdl->tmpbuf[0], len); //16bit 内部单变双
audio_dec_eq_run(eff->mic_eq1, hdl->tmpbuf[0], hdl->tmpbuf[0], len * 2);// 16bit 2ch
audio_dec_drc_run(eff->mic_drc1, hdl->tmpbuf[0], len * 2); //16bit 2ch
} else {
if (!hdl->tmpbuf[0]) {
hdl->tmpbuf[0] = malloc(len * 2 * 2);//2ch 32 bit buf
}
u8 *tmp = hdl->tmpbuf[0];
u8 *tar = &tmp[len * 2 * 2 - 2 * len]; //放在最后 16bit 2ch
run_plate_reverb(eff->sub_0_plate_reverb_hdl, data, tar, len); //16 bit 内部单变双
audio_dec_eq_run(eff->mic_eq1, tar, hdl->tmpbuf[0], len * 2);// 32bit 2ch out
audio_dec_drc_run(eff->mic_drc1, hdl->tmpbuf[0], len * 2 * 2); //32bit 2ch
}
}
}
//ch1
u32 points = 0;
if (hdl->in_ch == 1) {
if (!hdl->bit_wide) { //16 bit
u8 *tmp = NULL;
u8 *tar = NULL;
if (eff->sub_1_echo_hdl) {
if (!hdl->tmpbuf[1]) {
hdl->tmpbuf[1] = malloc(len * 2);//2ch 16 bit buf
}
//ch1
tmp = hdl->tmpbuf[1];
tar = &tmp[len];
if ((TCFG_MIC_EFFECT_SEL & MIC_EFFECT_MEGAPHONE)) {
memcpy(tar, data, len);
} else {
run_echo(eff->sub_1_echo_hdl, data, tar, len);
}
audio_dec_eq_run(eff->mic_eq2, tar, NULL, len); //1ch
audio_dec_drc_run(eff->mic_drc2, tar, len); //16bit 1ch
pcm_single_to_dual(hdl->tmpbuf[1], tar, len);//16bit 2ch
}
#if ENABLE_BYPASS_CH_AND_EQ2
if (!hdl->tmpbuf[2]) {
hdl->tmpbuf[2] = malloc(len * 2);//2ch 16 bit buf
}
//ch2
audio_dec_eq_run(eff->mic_eq3, data, NULL, len);//1ch
audio_dec_drc_run(eff->mic_drc3, data, len); //16bit 1ch
pcm_single_to_dual(hdl->tmpbuf[2], data, len);//16bit 2ch
#endif
points = (len * 2) / 2;
} else {
u8 *tmp = NULL;
u8 *tar = NULL;
if (eff->sub_1_echo_hdl) {
if (!hdl->tmpbuf[1]) {
hdl->tmpbuf[1] = malloc(len * 2 * 2); //2ch 32 bit buf
}
//ch1
tmp = hdl->tmpbuf[1];
tar = &tmp[len * 2 * 2 - len]; //放在最后 16bit 1ch
u8 *tar2 = &tmp[len * 2]; //buf中间位置
run_echo(eff->sub_1_echo_hdl, data, tar, len);
audio_dec_eq_run(eff->mic_eq2, tar, tar2, len); //16 ->32 1ch
audio_dec_drc_run(eff->mic_drc2, tar2, len * 2); //32bit 1ch
pcm_single_to_dual_32bit(hdl->tmpbuf[1], tar2, len * 2); //32bit 2ch out
}
//ch2
if (!hdl->tmpbuf[2]) {
hdl->tmpbuf[2] = malloc(len * 2 * 2); //2ch 32 bit buf
}
tmp = hdl->tmpbuf[2];
tar = &tmp[len * 2]; //buf中间位置
audio_dec_eq_run(eff->mic_eq3, data, tar, len);//16->32bit 1ch
audio_dec_drc_run(eff->mic_drc3, tar, len * 2); //32bit 1ch
pcm_single_to_dual_32bit(hdl->tmpbuf[2], tar, len * 2); //32bit 2ch
points = (len * 2 * 2) / 4;
}
} else {
if (!hdl->bit_wide) { //16 bit
u8 *tmp = NULL;
u8 *tar = NULL;
if (eff->sub_1_echo_hdl) {
if (!hdl->tmpbuf[1]) {
hdl->tmpbuf[1] = malloc(len);//2ch 16 bit buf
}
tmp = hdl->tmpbuf[1];
tar = &tmp[len / 2];
pcm_dual_to_single(tar, data, len);
run_echo(eff->sub_1_echo_hdl, tar, tar, len / 2);
pcm_single_to_dual(tmp, tar, len / 2);
audio_dec_eq_run(eff->mic_eq2, tmp, hdl->tmpbuf[1], len); //立体声处理2ch
audio_dec_drc_run(eff->mic_drc2, hdl->tmpbuf[1], len); //16bit 2ch
}
//ch2
if (!hdl->tmpbuf[2]) {
hdl->tmpbuf[2] = malloc(len);//2ch 16bit buf
}
audio_dec_eq_run(eff->mic_eq3, data, hdl->tmpbuf[2], len);
audio_dec_drc_run(eff->mic_drc3, hdl->tmpbuf[2], len); //16bit 2ch
points = len / 2;
} else {
u8 *tmp = NULL;
u8 *tar = NULL;
if (eff->sub_1_echo_hdl) {
if (!hdl->tmpbuf[1]) {
hdl->tmpbuf[1] = malloc(len * 2); //2ch 32 bit buf
}
//ch1
tmp = hdl->tmpbuf[1];
tar = &tmp[len * 2 - len / 2];
pcm_dual_to_single(tar, data, len);
run_echo(eff->sub_1_echo_hdl, tar, tar, len / 2);
pcm_single_to_dual(tmp, tar, len / 2);
audio_dec_eq_run(eff->mic_eq2, tmp, hdl->tmpbuf[1], len); //立体声处理2ch
audio_dec_drc_run(eff->mic_drc2, hdl->tmpbuf[1], len * 2); //32bit 2ch
}
//ch2
if (!hdl->tmpbuf[2]) {
hdl->tmpbuf[2] = malloc(len * 2 * 2); //2ch 32 bit buf
}
audio_dec_eq_run(eff->mic_eq3, data, hdl->tmpbuf[2], len);
audio_dec_drc_run(eff->mic_drc3, hdl->tmpbuf[2], len * 2); //32bit 2ch
points = (len * 2) / 4;
}
}
MixParam mix0 = {0};
MixParam mix1 = {0};
MixParam mix2 = {0};
u8 mode = get_mic_eff_mode();
Mix_TOOL_SET *mix_gain = &eff_mode[mode].mix_gain;
mix0.data = hdl->tmpbuf[0];
mix0.gain = mix_gain->gain1;
mix1.data = hdl->tmpbuf[1];
mix1.gain = mix_gain->gain2;
mix2.data = hdl->tmpbuf[2];
mix2.gain = mix_gain->gain3;
u8 out_ch_num = 2;
if (!hdl->bit_wide) { //16 bit
if (eff->sub_1_echo_hdl && eff->sub_0_plate_reverb_hdl) {
Mix16to16(&mix0, &mix1, &mix2, hdl->tmpbuf[0], out_ch_num, 3, points / out_ch_num);
} else if (eff->sub_0_plate_reverb_hdl) {
Mix16to16(&mix0, &mix2, NULL, hdl->tmpbuf[0], out_ch_num, 2, points / out_ch_num);
} else {
#if ENABLE_BYPASS_CH_AND_EQ2
Mix16to16(&mix1, &mix2, NULL, hdl->tmpbuf[1], out_ch_num, 2, points / out_ch_num);
#endif
return hdl->tmpbuf[1];
}
return hdl->tmpbuf[0];
} else {
if (eff->sub_1_echo_hdl && eff->sub_0_plate_reverb_hdl) {
Mix32to16(&mix0, &mix1, &mix2, hdl->tmpbuf[0], out_ch_num, 3, points / out_ch_num);
} else if (eff->sub_0_plate_reverb_hdl) {
Mix32to16(&mix0, &mix2, NULL, hdl->tmpbuf[0], out_ch_num, 2, points / out_ch_num);
} else {
Mix32to16(&mix1, &mix2, NULL, hdl->tmpbuf[1], out_ch_num, 2, points / out_ch_num);
return hdl->tmpbuf[1];
}
}
return hdl->tmpbuf[0];
}
/*----------------------------------------------------------------------------*/
/**@brief mic数据流串接入口
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
static u32 mic_effect_effect_run(void *priv, void *in, void *out, u32 inlen, u32 outlen)
{
struct __mic_effect *effect = (struct __mic_effect *)priv;
if (effect == NULL) {
return 0;
}
struct audio_data_frame frame = {0};
frame.channel = effect->input_ch_num;
frame.sample_rate = effect->parm.sample_rate;
frame.data_len = inlen;
frame.data = in;
effect->out_len = 0;
effect->process_len = inlen;
if (effect->pause_mark) {
memset(in, 0, inlen);
return inlen;
} else {
}
#if LOUDNESS_DEBUG_ENABLE
loudness_meter_short(&effect->loudness_adc, in, inlen / 2);
#endif
while (1) {
audio_stream_run(&effect->entry, &frame);
if (effect->out_len >= effect->process_len) {
break;
}
frame.data = (s16 *)((u8 *)in + effect->out_len);
frame.data_len = inlen - effect->out_len;
}
return outlen;
}
/*----------------------------------------------------------------------------*/
/**@brief 释放mic数据流资源
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
static void mic_effect_destroy(struct __mic_effect **hdl)
{
if (hdl == NULL || *hdl == NULL) {
return ;
}
struct __mic_effect *effect = *hdl;
if (effect->mic) {
log_i("mic_stream_destroy\n\n\n");
mic_stream_destroy(&effect->mic);
}
#if TCFG_MIC_DODGE_EN
if (effect->energy_hdl) {
mic_energy_detect_close(effect->energy_hdl);
}
#endif
if (effect->noisegate) {
log_i("close_noisegate\n\n\n");
audio_noisegate_close(effect->noisegate);
}
if (effect->howling_ps) {
log_i("close_howling\n\n\n");
close_howling(effect->howling_ps);
}
if (effect->notch_howling) {
log_i("close_howling\n\n\n");
close_howling(effect->notch_howling);
}
#if defined(TCFG_MIC_VOICE_CHANGER_ENABLE) && TCFG_MIC_VOICE_CHANGER_ENABLE
if (effect->voice_changer) {
audio_voice_changer_close_demo(effect->voice_changer);
}
#endif
#if defined(TCFG_MIC_AUTOTUNE_ENABLE) && TCFG_MIC_AUTOTUNE_ENABLE
if (effect->autotune) {
audio_autotune_close_demo(effect->autotune);
}
#endif
#if TCFG_EQ_ENABLE && TCFG_MIC_TUNNING_EQ_ENABLE
if (effect->mic_tunning_eq) {
mic_tunning_eq_close(effect->mic_tunning_eq);
}
#endif
if (effect->mic_eq0) {
log_i("mic_eq0_close\n\n\n");
mic_eq_close(effect->mic_eq0);
}
if (effect->mic_drc0) {
log_i("mic_drc0_close\n\n\n");
mic_drc_close(effect->mic_drc0);
}
if (effect->convert0) {
log_i("convet0_data_close\n\n\n");
convet_data_close(effect->convert0);
}
if (effect->mic_eq1) {
log_i("mic_eq1_close\n\n\n");
mic_eq_close(effect->mic_eq1);
}
if (effect->mic_drc1) {
log_i("mic_drc1_close\n\n\n");
mic_drc_close(effect->mic_drc1);
}
if (effect->mic_eq2) {
log_i("mic_eq2_close\n\n\n");
mic_eq_close(effect->mic_eq2);
}
if (effect->mic_drc2) {
log_i("mic_drc2_close\n\n\n");
mic_drc_close(effect->mic_drc2);
}
if (effect->mic_eq3) {
log_i("mic_eq3_close\n\n\n");
mic_eq_close(effect->mic_eq3);
}
if (effect->mic_drc3) {
log_i("mic_drc3_close\n\n\n");
mic_drc_close(effect->mic_drc3);
}
if (effect->mic_eq4) {
log_i("mic_eq4_close\n\n\n");
mic_eq_close(effect->mic_eq4);
}
if (effect->mic_drc4) {
log_i("mic_drc4_close\n\n\n");
mic_drc_close(effect->mic_drc4);
}
if (effect->convert4) {
log_i("convet4_data_close\n\n\n");
convet_data_close(effect->convert4);
}
/* if (effect->gain) { */
/* log_i("audio_gain_close_demo\n\n\n"); */
/* audio_gain_close_demo(effect->gain); */
/* effect->gain = NULL; */
/* } */
if (effect->sub_1_echo_hdl) {
close_echo(effect->sub_1_echo_hdl);
}
if (effect->sub_0_plate_reverb_hdl) {
close_plate_reverb(effect->sub_0_plate_reverb_hdl);
}
if (effect->d_vol) {
audio_stream_del_entry(audio_dig_vol_entry_get(effect->d_vol));
#if SYS_DIGVOL_GROUP_EN
sys_digvol_group_ch_close("mic_mic");
#else
audio_dig_vol_close(effect->d_vol);
#endif/*SYS_DIGVOL_GROUP_EN*/
}
/* if (effect->linein) { */
/* effect_linein_close(&effect->linein); */
/* } */
if (effect->src_hdl) {
audio_stream_del_entry(&effect->src_hdl->entry);
audio_hw_src_stop(effect->src_hdl);
audio_hw_src_close(effect->src_hdl);
free(effect->src_hdl);
effect->src_hdl = NULL;
}
if (effect->channel_zoom) {
channel_switch_close(&effect->channel_zoom);
/*effect->channel_zoom = NULL;*/
}
if (effect->loudness_debug_hdl) {
stream_entry_close(&effect->loudness_debug_hdl);
}
if (effect->dac) {
audio_stream_del_entry(&effect->dac->entry);
audio_dac_free_channel(effect->dac);
free(effect->dac);
effect->dac = NULL;
}
#if (RECORDER_MIX_EN)
if (effect->rec_hdl) {
stream_entry_close(&effect->rec_hdl);
}
#endif
#if (TCFG_USB_MIC_DATA_FROM_MICEFFECT||TCFG_USB_MIC_DATA_FROM_DAC)
if (effect->usbmic_hdl) {
stream_entry_close(&effect->usbmic_hdl);
}
#endif
if (effect->aud_reverb) {
aud_reverb_close(effect->aud_reverb);
}
if (effect->stream) {
audio_stream_close(effect->stream);
}
local_irq_disable();
free(effect);
*hdl = NULL;
local_irq_enable();
mem_stats();
clock_remove_set(REVERB_CLK);
}
/*----------------------------------------------------------------------------*/
/**@brief 串流唤醒
@param
@return
@note 暂未使用
*/
/*----------------------------------------------------------------------------*/
static void mic_stream_resume(void *p)
{
struct __mic_effect *effect = (struct __mic_effect *)p;
/* audio_decoder_resume_all(&decode_task); */
}
/*----------------------------------------------------------------------------*/
/**@brief 串流数据处理长度回调
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
static void mic_effect_data_process_len(struct audio_stream_entry *entry, int len)
{
struct __mic_effect *effect = container_of(entry, struct __mic_effect, entry);
effect->out_len += len;
/* printf("out len[%d]",effect->out_len); */
}
static int mic_effect_record_stream_callback(void *priv, struct audio_data_frame *in)
{
struct __mic_effect *effect = (struct __mic_effect *)priv;
s16 *data = in->data;
u32 len = in->data_len;
return recorder_mix_pcm_write((u8 *)data, len);
}
extern int usb_audio_mic_write_do(void *data, u16 len);
static int mic_effect_otherout_stream_callback(void *priv, struct audio_data_frame *in)
{
struct __mic_effect *effect = (struct __mic_effect *)priv;
s16 *data = in->data;
u32 len = in->data_len;
#if ((TCFG_USB_MIC_DATA_FROM_MICEFFECT||TCFG_USB_MIC_DATA_FROM_DAC))
if (effect->usbmic_start) {
if (len) {
usb_audio_mic_write_do(data, len);
}
} else {
}
#endif
return len;
}
void mic_effect_to_usbmic_onoff(u8 mark)
{
#if (TCFG_USB_MIC_DATA_FROM_MICEFFECT||TCFG_USB_MIC_DATA_FROM_DAC)
if (__this) {
__this->usbmic_start = mark ? 1 : 0;
}
#endif
}
static void inline rl_rr_mix_to_rl_rr(short *data, int len)
{
s32 tmp32_1;
s32 tmp32_2;
s16 *inbuf = data;
inbuf = inbuf + 2; //定位到第三通道
len >>= 3;
__asm__ volatile(
"1: \n\t"
"rep %0 { \n\t"
" %2 = h[%1 ++= 2](s) \n\t" //取第三通道值，并地址偏移两个字节指向第四通道数据
" %3 = h[%1 ++= -2](s) \n\t" //取第四通道值，并地址偏移两个字节指向第三通道数据
" %2 = %2 + %3 \n\t"
" %2 = sat16(%2)(s) \n\t" //饱和处理
" h[%1 ++= 2] = %2 \n\t" //存取第三通道数据，并地址偏移两个字节指向第四通道数据
" h[%1 ++= 6] = %2 \n\t" //存取第四通道数据，并地址偏移六个字节指向第三通道相邻的数据
"} \n\t"
"if(%0 != 0) goto 1b \n\t"
:
"=&r"(len),
"=&r"(inbuf),
"=&r"(tmp32_1),
"=&r"(tmp32_2)
:
"0"(len),
"1"(inbuf),
"2"(tmp32_1),
"3"(tmp32_2)
:
);
}
static int effect_to_dac_data_pro_handle(struct audio_stream_entry *entry, struct audio_data_frame *in)
{
#if (SOUNDCARD_ENABLE)
if (in->data_len == 0) {
return 0;
}
#if 1
rl_rr_mix_to_rl_rr(in->data, in->data_len);//汇编加速
#else
s16 *outbuf = in->data;
s16 *inbuf = in->data;
s32 tmp32;
u16 len = in->data_len;
len >>= 3;
while (len--) {
*outbuf++ = inbuf[0];
*outbuf++ = inbuf[1];
tmp32 = (inbuf[2] + inbuf[3]);
if (tmp32 < -32768) {
tmp32 = -32768;
} else if (tmp32 > 32767) {
tmp32 = 32767;
}
*outbuf++ = tmp32;
*outbuf++ = tmp32;
inbuf += 4;
}
#endif
#endif
return 0;
}
#if TCFG_APP_RECORD_EN
static int prob_handler_to_record(struct audio_stream_entry *entry, struct audio_data_frame *in)
{
if (app_get_curr_task() != APP_RECORD_TASK) {
return 0;
}
if (in->data_len == 0) {
return 0;
}
if (recorder_is_encoding() == 0) {
return 0;
}
int wlen = recorder_userdata_to_enc(in->data, in->data_len);
if (wlen != in->data_len) {
putchar('N');
}
return 0;
}
#endif
int audio_data_check_cb(struct audio_stream_entry *entry, struct audio_data_frame *data_buf)
{
if (__this) {
loudness_meter_short(&__this->loudness_drc_out, data_buf->data, data_buf->data_len / 2);
}
return data_buf->data_len;
}
#if (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_LR || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_DUAL_LR_DIFF)
#define DAC_OUTPUT_CHANNELS 2
#elif (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_R || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_R || TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_MONO_LR_DIFF)
#define DAC_OUTPUT_CHANNELS 1
#elif (TCFG_AUDIO_DAC_CONNECT_MODE == DAC_OUTPUT_FRONT_LR_REAR_LR)
#define DAC_OUTPUT_CHANNELS 4
#else
#define DAC_OUTPUT_CHANNELS 3
#endif
static u8 reverb_mode = 0;
static u8 voicechange_mode = 0;
void switch_mic_effect_mode(void)
{
reverb_mode++;
if (reverb_mode > 2) {
reverb_mode = 0;
}
printf("\n--func=%s [%d] \n", __FUNCTION__, reverb_mode);
set_mic_reverb_mode_by_id(reverb_mode);
}
/*----------------------------------------------------------------------------*/
/**@brief (mic数据流)混响打开接口
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
bool mic_effect_start(void)
{
bool ret = false;
mem_stats();
printf("\n--func=%s\n", __FUNCTION__);
if (__this) {
log_e("reverb is already start \n");
return ret;
}
struct __mic_effect *effect = (struct __mic_effect *)zalloc(sizeof(struct __mic_effect));
if (effect == NULL) {
return false;
}
u8 mode = get_mic_eff_mode();
struct eff_parm *mic_eff = &eff_mode[mode];
clock_add_set(REVERB_CLK);
os_mutex_create(&effect->mutex);
memcpy(&effect->parm, &effect_parm_default, sizeof(struct __mic_effect_parm));
struct __mic_stream_parm *mic_parm = (struct __mic_stream_parm *)&effect_mic_stream_parm_default;
if (g_mic_parm) {
mic_parm = g_mic_parm;
}
#if LOUDNESS_DEBUG_ENABLE
loudness_meter_init(&effect->loudness_adc, effect_mic_stream_parm_default.sample_rate, 50, 1);
loudness_meter_init(&effect->loudness_drc_out, effect_mic_stream_parm_default.sample_rate, 50, 2);
effect->loudness_debug_hdl = stream_entry_open(effect, audio_data_check_cb, 0);// 能量计算及打印节点
#endif
if ((TCFG_MIC_EFFECT_SEL & MIC_EFFECT_ECHO)
&& (TCFG_MIC_EFFECT_SEL & MIC_EFFECT_REVERB)) {
log_e("effect config err ?? !!!, cann't support echo && reverb at the same time\n");
mic_effect_destroy(&effect);
return false;
}
u16 irq_points = mic_parm->point_unit;
u8 ch_num = 1; //??
effect->input_ch_num = ch_num;
#if TCFG_MIC_DODGE_EN
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_ENERGY_DETECT)) {
effect->energy_hdl = mic_energy_detect_open(effect->parm.sample_rate, ch_num);
effect->dodge_en = 0;//默认关闭， 需要通过按键触发打开
}
#endif
///声音门限初始化
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_NOISEGATE)) {
effect->noisegate = audio_noisegate_open_demo(AEID_MIC_NS_GATE, MIC_EFFECT_SAMPLERATE, ch_num);
}
///啸叫抑制初始化
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_HOWLING)) {
log_i("open_howling\n\n\n");
effect->howling_ps = open_howling(NULL, effect->parm.sample_rate, 0, 1);//以频
}
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_HOWLING_TRAP)) {
log_i("open_howling\n\n\n");
HOWLING_PARM_SET howling_param = {
.threshold = mic_eff->notchhowling_parm.parm.threshold,
.fade_time = mic_eff->notchhowling_parm.parm.fade_n,
.notch_Q = mic_eff->notchhowling_parm.parm.Q,
.notch_gain = mic_eff->notchhowling_parm.parm.gain,
.sample_rate = MIC_EFFECT_SAMPLERATE,
.channel = 1,
};
#if (TCFG_USER_TWS_ENABLE == 0)
effect->notch_howling = open_howling(&howling_param, effect->parm.sample_rate, 0, 0);//陷波
#endif
}
#if defined(TCFG_MIC_VOICE_CHANGER_ENABLE) && TCFG_MIC_VOICE_CHANGER_ENABLE
effect->voice_changer = audio_voice_changer_open_demo(AEID_MIC_VOICE_CHANGER, effect->parm.sample_rate);
#endif
#if defined(TCFG_MIC_AUTOTUNE_ENABLE) && TCFG_MIC_AUTOTUNE_ENABLE
effect->autotune = audio_autotune_open_demo(AEID_MIC_AUTOTUNE, effect->parm.sample_rate);
#endif
log_i("effect->parm.sample_rate %d\n", effect->parm.sample_rate);
#if TCFG_EQ_ENABLE && TCFG_MIC_TUNNING_EQ_ENABLE
effect->mic_tunning_eq = mic_tunning_eq_open(effect->parm.sample_rate, ch_num);
#endif
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_EQ0)) {
effect->mic_eq0 = mic_eq_open(effect->parm.sample_rate, ch_num, AEID_MIC_EQ0);
if (effect->mic_eq0 && effect->mic_eq0->out_32bit) {
effect->mic_drc0 = mic_drc_open(effect->parm.sample_rate, ch_num, AEID_MIC_DRC0, 1);
effect->convert0 = convet_data_open(0, (irq_points << 1) * ch_num);
} else {
#if ENABLE_BYPASS_CH_AND_EQ2
effect->mic_drc0 = mic_drc_open(effect->parm.sample_rate, ch_num, AEID_MIC_DRC0, 0);
#endif
}
}
#if ENABLE_BYPASS_CH_AND_EQ2
effect->mic_eq3 = mic_eq_open(effect->parm.sample_rate, ch_num, AEID_MIC_EQ3);
#endif
if (effect->mic_eq3 && effect->mic_eq3->out_32bit) {
effect->mic_drc3 = mic_drc_open(effect->parm.sample_rate, ch_num, AEID_MIC_DRC3, 1);
}
// sub 0 分流节点
if ((TCFG_MIC_EFFECT_SEL & MIC_EFFECT_ECHO) || (TCFG_MIC_EFFECT_SEL & MIC_EFFECT_MEGAPHONE)) {
effect->sub_1_echo_hdl = open_echo((ECHO_PARM_SET *)&mic_eff->echo_parm.parm, (EF_REVERB_FIX_PARM *)&effect_echo_fix_parm_default);
if (effect->sub_1_echo_hdl) {
#if ENABLE_BYPASS_CH_AND_EQ2
effect->mic_eq2 = mic_eq_open(effect->parm.sample_rate, ch_num, AEID_MIC_EQ2);
#endif
if (effect->mic_eq2 && effect->mic_eq2->out_32bit) {
effect->mic_drc2 = mic_drc_open(effect->parm.sample_rate, ch_num, AEID_MIC_DRC2, 1);
}
}
}
if (TCFG_MIC_EFFECT_SEL & MIC_EFFECT_REVERB) {
effect->sub_0_plate_reverb_hdl = open_plate_reverb((Plate_reverb_parm *)&mic_eff->plate_reverb_parm.parm, effect->parm.sample_rate);
if (effect->sub_0_plate_reverb_hdl) {
ch_num = 2;
}
effect->mic_eq1 = mic_eq_open(effect->parm.sample_rate, ch_num, AEID_MIC_EQ1);
if (effect->mic_eq1 && effect->mic_eq1->out_32bit) {
effect->mic_drc1 = mic_drc_open(effect->parm.sample_rate, ch_num, AEID_MIC_DRC1, 1);
}
}
//多路混合后 EQ drc
#if TCFG_AUDIO_MIC_EFFECT_POST_EQ_ENABLE
effect->mic_eq4 = mic_eq_open(effect->parm.sample_rate, ch_num, AEID_MIC_EQ4);
if (effect->mic_eq4 && effect->mic_eq4->out_32bit) {
effect->mic_drc4 = mic_drc_open(effect->parm.sample_rate, ch_num, AEID_MIC_DRC4, 1);
effect->convert4 = convet_data_open(0, (irq_points << 1) * ch_num);
}
#endif/*TCFG_AUDIO_MIC_EFFECT_POST_EQ_ENABLE*/
/* effect->gain = audio_gain_open_demo(AEID_MIC_GAIN, ch_num); */
///初始化数字音量
struct audio_stream_entry *dvol_entry;
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_DVOL)) {
effect_dvol_default_parm.ch_total = ch_num;
#if SYS_DIGVOL_GROUP_EN
dvol_entry = sys_digvol_group_ch_open("mic_mic", -1, &effect_dvol_default_parm);
effect->d_vol = audio_dig_vol_group_hdl_get(sys_digvol_group, "mic_mic");
#else
effect->d_vol = audio_dig_vol_open((audio_dig_vol_param *)&effect_dvol_default_parm);
dvol_entry = audio_dig_vol_entry_get(effect->d_vol);
#endif /*SYS_DIGVOL_GROUP_EN*/
}
//打开混响变采样
if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_SOFT_SRC)) {
u32 out_sr = audio_output_nor_rate();
effect->src_hdl = zalloc(sizeof(struct audio_src_handle));
audio_hw_src_open(effect->src_hdl, ch_num, SRC_TYPE_RESAMPLE);
audio_hw_src_set_rate(effect->src_hdl, effect->parm.sample_rate, out_sr);
}
//混响通路混合linein
/* if (effect->parm.effect_config & BIT(MIC_EFFECT_CONFIG_LINEIN)) { */
/* effect->linein = effect_linein_open(); */
/* } */
u8 output_channels = DAC_OUTPUT_CHANNELS;
if (output_channels != ch_num) {
u32 points_num = REVERB_LADC_IRQ_POINTS * 4;
effect->channel_zoom = channel_switch_open(output_channels == 2 ? AUDIO_CH_LR : (output_channels == 4 ? AUDIO_CH_QUAD : AUDIO_CH_DIFF), output_channels == 4 ? (points_num * 2 + 128) : 1024);
//effect->channel_zoom = channel_switch_open(AUDIO_CH_LR, 1024);
}
effect->dac = (struct audio_dac_channel *)zalloc(sizeof(struct audio_dac_channel));
if (effect->dac) {
audio_dac_new_channel(&dac_hdl, effect->dac);
struct audio_dac_channel_attr attr;
audio_dac_channel_get_attr(effect->dac, &attr);
attr.delay_time = mic_parm->dac_delay;
attr.write_mode = WRITE_MODE_FORCE;
audio_dac_channel_set_attr(effect->dac, &attr);
effect->dac->entry.prob_handler = effect_to_dac_data_pro_handle;
/* audio_dac_channel_set_pause(effect->dac,1); */
}
effect->entry.data_process_len = mic_effect_data_process_len;
#if (RECORDER_MIX_EN)
///送录音数据流
effect->rec_hdl = stream_entry_open(effect, mic_effect_record_stream_callback, 1);
#endif
#if (TCFG_USB_MIC_DATA_FROM_MICEFFECT||TCFG_USB_MIC_DATA_FROM_DAC)
effect->usbmic_hdl = stream_entry_open(effect, mic_effect_otherout_stream_callback, 1);
#endif
u8 bit_wide = 0;
if (effect->mic_eq1 && effect->mic_eq1->out_32bit) {
bit_wide = 1;
}
effect->aud_reverb = aud_reverb_open(effect, bit_wide);
// 数据流串联
struct audio_stream_entry *entries[25] = {NULL};
u8 entry_cnt = 0;
entries[entry_cnt++] = &effect->entry;
#if TCFG_MIC_DODGE_EN
if (effect->energy_hdl) {
entries[entry_cnt++] = audio_energy_detect_entry_get(effect->energy_hdl);
}
#endif
if (effect->noisegate) {
entries[entry_cnt++] = &effect->noisegate->entry;
}
#if TCFG_EQ_ENABLE && TCFG_MIC_TUNNING_EQ_ENABLE
if (effect->mic_tunning_eq) {
entries[entry_cnt++] = &effect->mic_tunning_eq->entry;
}
#endif
if (effect->mic_eq0) {
entries[entry_cnt++] = &effect->mic_eq0->entry;
}
if (effect->mic_drc0) {
entries[entry_cnt++] = &effect->mic_drc0->entry;
}
if (effect->mic_eq0 && effect->mic_eq0->out_32bit) {
if (effect->convert0) {
entries[entry_cnt++] = &effect->convert0->entry;
}
}
if (effect->howling_ps) {
entries[entry_cnt++] = &effect->howling_ps->entry;
}
if (effect->notch_howling) {
entries[entry_cnt++] = &effect->notch_howling->entry;
}
if (effect->voice_changer) {
entries[entry_cnt++] = &effect->voice_changer->entry;
}
#if defined(TCFG_MIC_AUTOTUNE_ENABLE) && TCFG_MIC_AUTOTUNE_ENABLE
if (effect->autotune) {
entries[entry_cnt++] = &effect->autotune->entry;
}
#endif
if (effect->aud_reverb) {
entries[entry_cnt++] = &effect->aud_reverb->entry;
}
if (effect->d_vol) {
entries[entry_cnt++] = dvol_entry;
}
if (effect->mic_eq4) {
entries[entry_cnt++] = &effect->mic_eq4->entry;
if (effect->mic_eq4->out_32bit) {
if (effect->mic_drc4) {
entries[entry_cnt++] = &effect->mic_drc4->entry;
}
if (effect->convert4) {
entries[entry_cnt++] = &effect->convert4->entry;
}
}
}
/* if (effect->gain) { */
/* entries[entry_cnt++] = &effect->gain->entry; */
/* } */
if (effect->loudness_debug_hdl) {
entries[entry_cnt++] = &effect->loudness_debug_hdl->entry;
}
if (effect->channel_zoom) {
entries[entry_cnt++] = &effect->channel_zoom->entry;
}
if (effect->dac) {
entries[entry_cnt++] = &effect->dac->entry;
#if (TCFG_USB_MIC_DATA_FROM_DAC)
if (effect->usbmic_hdl) {
entries[entry_cnt++] = &effect->usbmic_hdl->entry;
}
#endif
}
effect->stream = audio_stream_open(effect, mic_stream_resume);
audio_stream_add_list(effect->stream, entries, entry_cnt);
/* effect->main_pause = 2; */
///mic 数据流初始化
effect->mic = mic_stream_creat(mic_parm);
if (effect->mic == NULL) {
mic_effect_destroy(&effect);
return false;
}
mic_stream_set_output(effect->mic, (void *)effect, mic_effect_effect_run);
mic_stream_start(effect->mic);
#if (RECORDER_MIX_EN)
recorder_mix_pcm_stream_open(effect->parm.sample_rate, ch_num);
#endif
clock_set_cur();
__this = effect;
log_info("--------------------------effect start ok\n");
mem_stats();
mic_effect_change_mode(mode);
return true;
}
/*----------------------------------------------------------------------------*/
/**@brief mic增益调节
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
/* void mic_effect_mic_gain_parm_fill(EFFECTS_MIC_GAIN_PARM *parm, u8 fade, u8 online) */
/* { */
/* if (__this == NULL || parm == NULL) { */
/* return ; */
/* } */
/* audio_mic_set_gain(parm->gain); */
/* } */
/*----------------------------------------------------------------------------*/
/**@brief mic效果模式切换（数据流音效组合切换）
@param
@return
@note 使用效果配置文件时生效
*/
/*----------------------------------------------------------------------------*/
void mic_effect_change_mode(u16 mode)
{
set_mic_reverb_mode_by_id(mode);
}
/*----------------------------------------------------------------------------*/
/**@brief 获取mic效果模式（数据流音效组合）
@param
@return
@note 使用效果配置文件时生效
*/
/*----------------------------------------------------------------------------*/
u16 mic_effect_get_cur_mode(void)
{
return get_mic_eff_mode();
}
void *mic_eq_open(u32 sample_rate, u8 ch_num, u8 eq_name)
{
#if TCFG_EQ_ENABLE
#if(TCFG_MIC_EFFECT_SEL == MIC_EFFECT_MEGAPHONE)
if ((eq_name == AEID_MIC_EQ1)) {
return NULL;
}
#endif
u8 mode = get_mic_eff_mode();
struct audio_eq_param parm = {0};
parm.channels = ch_num;
if ((eq_name == AEID_MIC_EQ0) || (eq_name == AEID_MIC_EQ4)) {
/* parm.out_32bit = 1;//32bit位宽输出 */ //696默认使用16bitEQ
}
parm.no_wait = 0;//同步方式
parm.cb = eq_get_filter_info;
parm.sr = sample_rate;
parm.eq_name = eq_name;
u8 index = get_eq_module_index(eq_name);
log_d("index %d\n", index);
parm.max_nsection = eff_mode[mode].eq_parm[index].seg_num;
parm.nsection = eff_mode[mode].eq_parm[index].seg_num;
parm.seg = eff_mode[mode].eq_parm[index].seg;
parm.global_gain = eff_mode[mode].eq_parm[index].global_gain;
log_d("=====mic eq_name %d\n", eq_name);
struct audio_eq *eq = audio_dec_eq_open(&parm);
return eq;
#else
return NULL;
#endif//TCFG_EQ_ENABLE
}
void *mic_drc_open(u32 sample_rate, u8 ch_num, u8 drc_name, u8 _32bit)
{
#if TCFG_DRC_ENABLE
u8 mode = get_mic_eff_mode();
log_i("sample_rate %d %d\n", sample_rate, ch_num);
struct audio_drc_param parm = {0};
parm.channels = ch_num;
parm.sr = sample_rate;
parm.out_32bit = _32bit;
parm.cb = drc_get_filter_info;
parm.drc_name = drc_name;
u8 index = get_drc_module_index(drc_name);
parm.wdrc = &eff_mode[mode].drc_parm[index];
log_d("=====drc_name %d\n", drc_name);
struct audio_drc *drc = audio_dec_drc_open(&parm);
clock_add(EQ_CLK);
return drc;
#else
return NULL;
#endif//TCFG_DRC_ENABLE
}
void mic_eq_close(void *eq)
{
#if TCFG_EQ_ENABLE
if (eq) {
audio_dec_eq_close(eq);
clock_remove(EQ_CLK);
}
#endif
return;
}
void mic_drc_close(void *drc)
{
#if TCFG_DRC_ENABLE
if (drc) {
audio_dec_drc_close(drc);
drc = NULL;
clock_remove(EQ_CLK);
}
#endif
return;
}
#if TCFG_EQ_ENABLE && TCFG_MIC_TUNNING_EQ_ENABLE
struct eq_seg_info mic_high_bass_eq_seg[] = {
{0, EQ_IIR_TYPE_BAND_PASS, 100, 0, 0.7f},
{1, EQ_IIR_TYPE_BAND_PASS, 1000, 0, 0.7f},
};
struct eq_tool mic_tunning_eq_parm = {0};
/*
*混响mic tunning_eq 打开
* */
void *mic_tunning_eq_open(u32 sample_rate, u8 ch_num)
{
u8 seg_num = ARRAY_SIZE(mic_high_bass_eq_seg);
mic_tunning_eq_parm.seg_num = seg_num;
mic_tunning_eq_parm.global_gain = 0;
memcpy(&mic_tunning_eq_parm.seg, mic_high_bass_eq_seg, sizeof(mic_high_bass_eq_seg));
struct audio_eq_param parm = {0};
parm.channels = ch_num;
parm.cb = eq_get_filter_info;
parm.sr = sample_rate;
parm.eq_name = AEID_MIC_TUNNING_EQ;
parm.max_nsection = mic_tunning_eq_parm.seg_num;
parm.nsection = mic_tunning_eq_parm.seg_num;
parm.seg = mic_tunning_eq_parm.seg;
parm.global_gain = mic_tunning_eq_parm.global_gain;
parm.fade = 1;//高低音增益更新差异大，会引入哒哒音，此处使能系数淡入
parm.fade_step = 0.4f;//淡入步进（0.1f~1.0f）
log_d("=====mic tunning eq_name %d\n", parm.eq_name);
struct audio_eq *eq = audio_dec_eq_open(&parm);
return eq;
}
/*
*混响mic tunning_eq 关闭
* */
void mic_tunning_eq_close(void *eq)
{
if (eq) {
audio_dec_eq_close(eq);
}
}
/*
*index:0 low, 1 high
*gain:增益（-12~0）dB
* */
void mic_tunning_eq_update(u8 index, float gain)
{
if (gain > 0) {
gain = 0;
} else if (gain < -12) {
gain = -12;
}
mic_tunning_eq_parm.seg[index].gain = gain;
/* log_d("mic tunning eq index %d, %d\n", index, (int)gain); */
struct audio_eq *hdl = get_cur_eq_hdl_by_name(AEID_MIC_TUNNING_EQ);
if (hdl) {
cur_eq_set_update(AEID_MIC_TUNNING_EQ, &mic_tunning_eq_parm.seg[index], mic_tunning_eq_parm.seg_num, 1);
}
}
/*
*混响切换模式时更新高低音参数
*/
void mic_tunning_eq_update_parm(u8 mode)
{
#if 0
u8 seg_num = ARRAY_SIZE(mic_high_bass_eq_seg);
struct audio_eq *hdl = get_cur_eq_hdl_by_name(AEID_MIC_TUNNING_EQ);
for (int i = 0; i < seg_num; i++) {
if (hdl) {
cur_eq_set_update(AEID_MIC_TUNNING_EQ, &mic_tunning_eq_parm.seg[i], mic_tunning_eq_parm.seg_num, 1);
}
}
#endif
}
#endif/*TCFG_EQ_ENABLE && TCFG_MIC_TUNNING_EQ_ENABLE*/
#if TCFG_MIC_DODGE_EN
void mic_e_det_handler(u8 event, u8 ch)
{
//printf(">>>> ch:%d %s\n", ch, event ? ("MUTE") : ("UNMUTE"));
struct __mic_effect *effect = (struct __mic_effect *)__this;
#if SYS_DIGVOL_GROUP_EN
//printf("effect_dvol_default_parm.ch_total %d effect->dodge_en %d\n", effect_dvol_default_parm.ch_total, effect->dodge_en);
if (ch == effect_dvol_default_parm.ch_total) {
if (effect->dodge_en) {
if (effect && effect->d_vol) {
if (event) { //推出闪避
audio_dig_vol_group_dodge(sys_digvol_group, "mic_mic", 100, 100);
} else { //启动闪避
audio_dig_vol_group_dodge(sys_digvol_group, "mic_mic", 100, 0);
}
}
}
}
#endif
}
/*----------------------------------------------------------------------------*/
/**@brief 打开mic 能量检测
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void *mic_energy_detect_open(u32 sr, u8 ch_num)
{
audio_energy_detect_param e_det_param = {0};
e_det_param.mute_energy = dodge_parm.dodge_out_thread;//人声能量小于mute_energy 退出闪避
e_det_param.unmute_energy = dodge_parm.dodge_in_thread;//人声能量大于 100触发闪避
e_det_param.mute_time_ms = dodge_parm.dodge_out_time_ms;
e_det_param.unmute_time_ms = dodge_parm.dodge_in_time_ms;
e_det_param.count_cycle_ms = 2;
e_det_param.sample_rate = sr;
e_det_param.event_handler = mic_e_det_handler;
e_det_param.ch_total = ch_num;
e_det_param.dcc = 1;
void *audio_e_det_hdl = audio_energy_detect_open(&e_det_param);
return audio_e_det_hdl;
}
/*----------------------------------------------------------------------------*/
/**@brief 关闭mic 能量检测
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_energy_detect_close(void *hdl)
{
if (hdl) {
audio_stream_del_entry(audio_energy_detect_entry_get(hdl));
#if SYS_DIGVOL_GROUP_EN
struct __mic_effect *effect = (struct __mic_effect *)__this;
if (effect->d_vol) {
audio_dig_vol_group_dodge(sys_digvol_group, "mic_mic", 100, 100); // undodge
}
#endif
audio_energy_detect_close(hdl);
}
}
/*----------------------------------------------------------------------------*/
/**@brief 能量检测运行过程，是否触发闪避
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_dodge_ctr(void)
{
struct __mic_effect *effect = (struct __mic_effect *)__this;
if (effect) {
effect->dodge_en = !effect->dodge_en;
}
}
u8 mic_dodge_get_status(void)
{
struct __mic_effect *effect = (struct __mic_effect *)__this;
if (effect) {
return effect->dodge_en;
}
return 0;
}
#endif
/*----------------------------------------------------------------------------*/
/**@brief (mic数据流)混响关闭接口
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_stop(void)
{
mic_effect_destroy(&__this);
}
/*----------------------------------------------------------------------------*/
/**@brief (mic数据流)混响暂停接口(整个数据流不运行)
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_pause(u8 mark)
{
if (__this) {
__this->pause_mark = mark ? 1 : 0;
}
}
/*----------------------------------------------------------------------------*/
/**@brief (mic数据流)混响暂停输出到DAC(数据流后级不写入DAC)
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_dac_pause(u8 mark)
{
if (__this && __this->dac) {
audio_dac_channel_set_pause(__this->dac, mark);
}
}
/*----------------------------------------------------------------------------*/
/**@brief (mic数据流)混响状态获取接口
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
u8 mic_effect_get_status(void)
{
return ((__this) ? 1 : 0);
}
/*----------------------------------------------------------------------------*/
/**@brief 数字音量调节接口
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_set_dvol(u8 vol)
{
if (__this && __this->d_vol) {
audio_dig_vol_set(__this->d_vol, 3, vol);
}
}
u8 mic_effect_get_dvol(void)
{
if (__this && __this->d_vol) {
return audio_dig_vol_get(__this->d_vol, 1);
}
return 0;
}
/*----------------------------------------------------------------------------*/
/**@brief 获取mic增益接口
@param
@return
@note
*/
/*----------------------------------------------------------------------------*/
u8 mic_effect_get_micgain(void)
{
//动态调的需实时记录
return effect_mic_stream_parm_default.mic_gain;
}
/*----------------------------------------------------------------------------*/
/**@brief reverb 效果声增益调节接口
@param wet增益系数%[0,300];dry增益系数%[0,200]
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_set_reverb_wet(int wet)
{
if (__this == NULL || __this->sub_0_plate_reverb_hdl == NULL) {
return ;
}
os_mutex_pend(&__this->mutex, 0);
Plate_reverb_parm parm;
memcpy(&parm, & __this->sub_0_plate_reverb_hdl->reverb_parm_obj, sizeof(Plate_reverb_parm));
parm.wet = wet;
update_plate_reverb_parm(__this->sub_0_plate_reverb_hdl, &parm);
os_mutex_post(&__this->mutex);
}
int mic_effect_get_reverb_wet(void)
{
if (__this && __this->sub_0_plate_reverb_hdl) {
return __this->sub_0_plate_reverb_hdl->reverb_parm_obj.wet;
}
return 0;
}
void mic_effect_set_reverb_dry(int dry)
{
if (__this == NULL || __this->sub_0_plate_reverb_hdl == NULL) {
return ;
}
os_mutex_pend(&__this->mutex, 0);
Plate_reverb_parm parm;
memcpy(&parm, & __this->sub_0_plate_reverb_hdl->reverb_parm_obj, sizeof(Plate_reverb_parm));
parm.dry = dry;
update_plate_reverb_parm(__this->sub_0_plate_reverb_hdl, &parm);
os_mutex_post(&__this->mutex);
}
int mic_effect_get_reverb_dry(void)
{
if (__this && __this->sub_0_plate_reverb_hdl) {
return __this->sub_0_plate_reverb_hdl->reverb_parm_obj.dry;
}
return 0;
}
/*----------------------------------------------------------------------------*/
/**@brief echo 回声延时调节接口
@param delay 回声延时[0,max_ms]
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_set_echo_delay(u32 delay)
{
if (__this == NULL || __this->sub_1_echo_hdl == NULL) {
return ;
}
os_mutex_pend(&__this->mutex, 0);
ECHO_PARM_SET parm;
memcpy(&parm, &__this->sub_1_echo_hdl->echo_parm_obj, sizeof(ECHO_PARM_SET));
parm.delay = delay;
update_echo_parm(__this->sub_1_echo_hdl, &parm);
os_mutex_post(&__this->mutex);
}
u32 mic_effect_get_echo_delay(void)
{
if (__this && __this->sub_1_echo_hdl) {
return __this->sub_1_echo_hdl->echo_parm_obj.delay;
}
return 0;
}
/*----------------------------------------------------------------------------*/
/**@brief echo 回声衰减系数调节接口
@param decay 衰减系数值%[0,90]
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_set_echo_decay(u32 decay)
{
if (__this == NULL || __this->sub_1_echo_hdl == NULL) {
return ;
}
os_mutex_pend(&__this->mutex, 0);
ECHO_PARM_SET parm;
memcpy(&parm, &__this->sub_1_echo_hdl->echo_parm_obj, sizeof(ECHO_PARM_SET));
parm.decayval = decay;
update_echo_parm(__this->sub_1_echo_hdl, &parm);
os_mutex_post(&__this->mutex);
}
u32 mic_effect_get_echo_decay(void)
{
if (__this && __this->sub_1_echo_hdl) {
return __this->sub_1_echo_hdl->echo_parm_obj.decayval;
}
return 0;
}
/*----------------------------------------------------------------------------*/
/**@brief echo 回声wetgain调节接口
@param wetgain 湿声增益系数%[0,200]
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_set_echo_wetgain(u32 wetgain)
{
if (__this == NULL || __this->sub_1_echo_hdl == NULL) {
return ;
}
os_mutex_pend(&__this->mutex, 0);
ECHO_PARM_SET parm;
memcpy(&parm, &__this->sub_1_echo_hdl->echo_parm_obj, sizeof(ECHO_PARM_SET));
parm.wetgain = wetgain;
update_echo_parm(__this->sub_1_echo_hdl, &parm);
os_mutex_post(&__this->mutex);
}
u32 mic_effect_get_echo_wetgain(void)
{
if (__this && __this->sub_1_echo_hdl) {
return __this->sub_1_echo_hdl->echo_parm_obj.wetgain;
}
return 0;
}
/*----------------------------------------------------------------------------*/
/**@brief echo 回声drygain调节接口
@param 干声增益系数%[0,100]
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_effect_set_echo_drygain(u32 drygain)
{
if (__this == NULL || __this->sub_1_echo_hdl == NULL) {
return ;
}
os_mutex_pend(&__this->mutex, 0);
ECHO_PARM_SET parm;
memcpy(&parm, &__this->sub_1_echo_hdl->echo_parm_obj, sizeof(ECHO_PARM_SET));
parm.drygain = drygain;
update_echo_parm(__this->sub_1_echo_hdl, &parm);
os_mutex_post(&__this->mutex);
}
u32 mic_effect_get_echo_drygain(void)
{
if (__this && __this->sub_1_echo_hdl) {
return __this->sub_1_echo_hdl->echo_parm_obj.drygain;
}
return 0;
}
//*********************变声音效切换例程**********************************//
/* VOICE_CHANGER_NONE,//原声 */
/* VOICE_CHANGER_UNCLE,//大叔 */
/* VOICE_CHANGER_GODDESS,//女神 */
/* VOICE_CHANGER_BABY,//娃娃音 */
/* VOICE_CHANGER_MAGIC,//魔音女声 */
/* VOICE_CHANGER_MONSTER,//怪兽音 */
/* VOICE_CHANGER_DONALD_DUCK,//唐老鸭 */
/* VOICE_CHANGER_MINIONS,//小黄人 */
/* VOICE_CHANGER_ROBOT,//机器音 */
/* VOICE_CHANGER_WHISPER,//气音 */
/* VOICE_CHANGER_MELODY,//固定旋律音 */
/* VOICE_CHANGER_FEEDBACK,//调制音 */
VOICECHANGER_PARM parm = {
.shiftv = 100,//[50-200];越尖锐,越大声音越沉;100就是原声
.formant_shift = 100,
.effect_v = EFFECT_VOICECHANGE_PITCHSHIFT,
};
/*----------------------------------------------------------------------------*/
/**@brief 变声音调重置为原声音调
@param NULL
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_pitchv_reset_parm(void)
{
#if defined(TCFG_MIC_VOICE_CHANGER_ENABLE) && TCFG_MIC_VOICE_CHANGER_ENABLE
parm.shiftv = 100;
audio_voice_changer_update_parm(AEID_MIC_VOICE_CHANGER, &parm);
#endif
}
/*----------------------------------------------------------------------------*/
/**@brief 变声音调递增
@param NULL
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_pitchv_up(void)
{
#if defined(TCFG_MIC_VOICE_CHANGER_ENABLE) && TCFG_MIC_VOICE_CHANGER_ENABLE
if (parm.shiftv < 190) {
parm.shiftv += 10;
audio_voice_changer_update_parm(AEID_MIC_VOICE_CHANGER, &parm);
}
#endif
}
/*----------------------------------------------------------------------------*/
/**@brief 变声音调递减
@param NULL
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_pitchv_down(void)
{
#if defined(TCFG_MIC_VOICE_CHANGER_ENABLE) && TCFG_MIC_VOICE_CHANGER_ENABLE
if (parm.shiftv > 60) {
parm.shiftv -= 10;
audio_voice_changer_update_parm(AEID_MIC_VOICE_CHANGER, &parm);
}
#endif
}
/*----------------------------------------------------------------------------*/
/**@brief 变声音效循环切换
@param NULL
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_voicechange_loop(void)
{
voicechange_mode++;
if (voicechange_mode >= VOICE_CHANGER_MAX) {
voicechange_mode = VOICE_CHANGER_NONE;
}
mic_voicechange_switch(voicechange_mode);
}
/*----------------------------------------------------------------------------*/
/**@brief 变声音效指定模式切换
@param eff_mode 模式索引
@return
@note
*/
/*----------------------------------------------------------------------------*/
void mic_voicechange_switch(u8 eff_mode)
{
#if defined(TCFG_MIC_VOICE_CHANGER_ENABLE) && TCFG_MIC_VOICE_CHANGER_ENABLE
if (!mic_effect_get_status()) {
mic_effect_start();
/* return; */
}
switch (eff_mode) {
case VOICE_CHANGER_NONE://原声,录音棚
/* tone_play_index(IDEX_TONE_MIC_OST, 1); */
break;
case VOICE_CHANGER_UNCLE://大叔
/* tone_play_index(IDEX_TONE_UNCLE, 1); */
break;
case VOICE_CHANGER_GODDESS://女神
/* tone_play_index(IDEX_TONE_GODNESS, 1); */
break;
case VOICE_CHANGER_BABY://娃娃音
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_MAGIC://魔音女声
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_MONSTER://怪兽音
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_DONALD_DUCK://唐老鸭
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_MINIONS://小黄人
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_ROBOT://机器音
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_WHISPER://气音
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_MELODY://固定旋律音
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
case VOICE_CHANGER_FEEDBACK://调制音
/* tone_play_index(IDEX_TONE_BABY, 1); */
break;
default:
puts("mic_ERROR\n");
/* mic_effect_stop(); */
break;
}
audio_voice_changer_mode_switch(AEID_MIC_VOICE_CHANGER, eff_mode);
#endif//TCFG_MIC_VOICE_CHANGER_ENABLE
}
/**************************各个音效模块参数设置接口(调试工具/模式切换会使用勿修改)************************************/
void plate_reverb_update_parm(void *parm, int bypass)
{
if (__this && __this->sub_0_plate_reverb_hdl) {
update_plate_reverb_parm(__this->sub_0_plate_reverb_hdl, parm);
plate_reverb_update_bypass(__this->sub_0_plate_reverb_hdl, bypass);
}
}
void echo_updata_parm(void *parm, int bypass)
{
if (__this && __this->sub_1_echo_hdl) {
update_echo_parm(__this->sub_1_echo_hdl, parm);
echo_update_bypass(__this->sub_1_echo_hdl, bypass);
}
}
void noisegate_update_parm(void *parm, int bypass)
{
audio_noisegate_update(AEID_MIC_NS_GATE, parm);
audio_noisegate_bypass(AEID_MIC_NS_GATE, bypass);
}
void howling_pitch_shift_update_parm(void *parm, int bypass)
{
if (__this && __this->howling_ps) {
update_howling_parm(__this->howling_ps, parm);
howling_update_bypass(__this->howling_ps, bypass);
}
}
void notchhowline_update_parm(void *parm, int bypass)
{
if (__this && __this->notch_howling) {
update_howling_parm(__this->notch_howling, parm);
howling_update_bypass(__this->notch_howling, bypass);
}
}
/**************************各个音效模块参数设置接口 END************************************/
#endif
Reference in New Issue Copy Permalink