1849 lines
58 KiB
C
1849 lines
58 KiB
C
#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
|