From 8758151dcdb0f89e362dd297405a384d3a034380 Mon Sep 17 00:00:00 2001
From: chenlh <2008get@163.com>
Date: 星期三, 28 一月 2026 20:21:37 +0800
Subject: [PATCH] 天宫输入源模块设置时爆音及参数拷贝更新
---
src/tg/tg_user_ctrl.cpp | 694 +++++++++++++++++++++++++++++++++++++++++++++++----------
1 files changed, 568 insertions(+), 126 deletions(-)
diff --git a/src/tg/tg_user_ctrl.cpp b/src/tg/tg_user_ctrl.cpp
index f9bc97d..fa0808a 100644
--- a/src/tg/tg_user_ctrl.cpp
+++ b/src/tg/tg_user_ctrl.cpp
@@ -8,19 +8,22 @@
#include "IModule.h"
#include "module_def.h"
#include "tg_user_ctrl.h"
+#include "tg_scene.h"
+#include "../var_state.h"
+#include "../ModuleExport.h"
-u32 tg_param_ctrl::Signalgen_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Signalgen_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum SGItemType{
SG_MUTE = 0x1,
SG_TYPE ,
- SG_REQ ,
+ SG_FREQ ,
SG_GAIN,
};
short val[4];
- int channel = val_c[0]&(MAX_INPUT_NUM-1);
+ int channel = RESSIGNBIT(val_c[0]); //&(MAX_INPUT_NUM-1);
if(pID == INPUT_TYPE) {//signal gen
if(val_c[1] > 3) {
@@ -40,47 +43,91 @@
}
else if(pID == INPUT_FREQ) {
val[0] = channel; val[1] = RESSIGNBIT(val_c[1]);
- m->Ctrl(SG_REQ, val, 2);
+ m->Ctrl(SG_FREQ, val, 2);
}
else if(pID == INPUT_LEVEL) {
val[0] = channel; val[1] = RESSIGNBIT(val_c[1]);
m->Ctrl(SG_GAIN, val, 2);
}
+ // copy the channel params.
+ ptag_input psg = (ptag_input)param;
+ switch(pID) {
+ case SG_MUTE:
+ psg->input[channel].mute = val[1];
+ break;
+ case SG_TYPE:
+ psg->input[channel].type = val[1];
+ break;
+ case SG_FREQ:
+ psg->input[channel].freq = val[1];
+ break;
+ case SG_GAIN:
+ psg->input[channel].level = val[1];
+ break;
+ default:
+ break;
+ }
return 0;
}
-u32 tg_param_ctrl::Input_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Input_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
- enum Input_ID{
- GAIN = 0x1,
- MUTE,
- SENSI,
- PHANTOM,
- TYPE,
+ enum SigSrcID {
+ GAIN = 0x1, //val[0]: 通道号,val[1] : 增益 ，乘以100 ， 范围: -7200 ~ 1200
+ MUTE, //val[0]: 通道号,val[1] : 静音 , 0-取消静音,1-静音
+ SENSI,
+ PHANTO,
+ SIGNAL_TYPE = 5,
- FREQ,
- LEVEL,
- NAME,
- PHASE,
- STEP,
-
- LINK,
- CHANNEL_LEVEL,
- INPUT_MIN,
- INPUT_MAX,
- };
+ GENERATE_FREQ,
+ GENERATE_LEVEL,
+ PHASE = 9, //val[0]: 通道号,val[1] : 反相 , 0-取消反相, 1-反相
+ STEP,
+ };
short val[4];
- int channel = val_c[0];//&(MAX_INPUT_NUM-1);
+ int channel = RESSIGNBIT(val_c[0]);//&(MAX_INPUT_NUM-1);
val[0] = channel; val[1] = RESSIGNBIT(val_c[1]);
m->Ctrl(pID, val, 2);
+ ptag_input pin = (ptag_input)param;
+ switch(pID) {
+ case GAIN:
+ pin->input[channel].gain = val[1];
+ break;
+ case MUTE:
+ pin->input[channel].mute = val[1];
+ break;
+ case SENSI:
+ pin->input[channel].sensitivity = val[1];
+ break;
+ case PHANTO:
+ pin->input[channel].phant = val[1];
+ break;
+ case SIGNAL_TYPE:
+ pin->input[channel].type = val[1];
+ break;
+ case GENERATE_FREQ:
+ pin->input[channel].freq = val[1];
+ break;
+ case GENERATE_LEVEL:
+ pin->input[channel].level = val[1];
+ break;
+ case PHASE:
+ pin->input[channel].phase = val[1];
+ break;
+ case STEP:
+ pin->input[channel].gain += val[1];
+ break;
+ default:
+ break;
+ }
return 0;
}
-u32 tg_param_ctrl::Gain_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Gain_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum GainID {
GAIN = 0x1,
@@ -103,13 +150,13 @@
return 0;
}
-u32 tg_param_ctrl::Output_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Output_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum GainID {
GAIN = 0x1,
MUTE,
SENSI,
- PHANTOM,
+ PHANTO,
PHASE = 9,
STEP,
@@ -124,10 +171,30 @@
m->Ctrl(cmd[pID-1], val, 2);
+ ptag_output pin = (ptag_output)param;
+ switch(pID) {
+ case GAIN:
+ pin->output[channel].gain = val[1];
+ break;
+ case MUTE:
+ pin->output[channel].mute = val[1];
+ break;
+ case SENSI:
+ pin->output[channel].sensitivity = val[1];
+ break;
+ case PHASE:
+ pin->output[channel].phase = val[1];
+ break;
+ case STEP:
+ pin->output[channel].gain += val[1];
+ break;
+ default:
+ break;
+ }
return 0;
}
-u32 tg_param_ctrl::Mixer_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Mixer_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
short val[4];
@@ -149,7 +216,7 @@
return 0;
}
-u32 tg_param_ctrl::Crossover_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Crossover_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum CFilterID {
_BYPASS = 0x1,
@@ -173,37 +240,32 @@
m->Ctrl(pID, val, 2);
+ // copy the ctrl params
+ ptag_module pmodu = (ptag_module)param;
+ ptag_crossover pxov = (ptag_crossover)pmodu->proc_ins;
+ switch(pID) {
+ case _BYPASS:
+ (0==val[0]) ? (pxov->lowpass.bypass = val[1]) : (pxov->highpass.bypass = val[1]);
+ break;
+ case _TYPE:
+ (0==val[0]) ? (pxov->lowpass.type = val[1]) : (pxov->highpass.type = val[1]);
+ break;
+ case _TAPS:
+ (0==val[0]) ? (pxov->lowpass.taps = val[1]) : (pxov->highpass.taps = val[1]);
+ break;
+ case _FREQ:
+ (0==val[0]) ? (pxov->lowpass.freq = val[1]) : (pxov->highpass.freq = val[1]);
+ break;
+ case _GAIN:
+ (0==val[0]) ? (pxov->lowpass.gain = val[1]) : (pxov->highpass.gain = val[1]);
+ break;
+ default:
+ break;
+ }
return 0;
}
-u32 tg_param_ctrl::Feedback_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
-{
- enum NHSID{
- FB_BYPASS= 0x1,
- FB_FLT_FREQ,
- FB_FLT_GAIN,
- FB_FLT_Q,
- FB_FLT_TYPE,
-
- FB_STEP,
-
- FB_CLEAR,
- FB_PANIC,
- FB_FLT_DEPTH,
- FB_THRS,
- };
-
- short val[4];
-// short cmd[16] = {FB_BYPASS, FB_FLT_FREQ, FB_FLT_GAIN, FB_FLT_Q, FB_FLT_TYPE, FB_STEP,\
-// FB_CLEAR, FB_PANIC, FB_FLT_DEPTH, FB_THRS, 0, 0 ,0 ,0 ,0 ,0 };
-
- val[0] = RESSIGNBIT(val_c[0]); val[1] = RESSIGNBIT(val_c[1]);
- m->Ctrl(pID, val, 2);
-
- return 0;
-}
-
-u32 tg_param_ctrl::Automixer_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Automixer_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum GainSharingAMID {
AM_BYPASS =0x1,
@@ -227,7 +289,7 @@
return 0;
}
-u32 tg_param_ctrl::Aec_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Aec_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum AECID{
BYPASS = 0X1,
@@ -254,7 +316,7 @@
return 0;
}
-u32 tg_param_ctrl::Sysctl_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Sysctl_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum SYSCTRLID{
SYSCTL_MUTE = 0x1, //val[0]:0-unmute,1-mute
@@ -270,27 +332,7 @@
return 0;
}
-u32 tg_param_ctrl::Geq_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
-{
- enum GEQID{
- GEQ_BYPASS_ALL = 0x1,//val[0]: 0-取消bypass, 1- 使能bypass
- GEQ_QVALUE,//val[0]: 1-narrow, 2-normal, 3-wide
- GEQ_GAIN,//val[0]: 段序号,val[1] : 增益,乘以100，范围:-4800~2400
- GEQ_CLEAR,//val[0]: 复位EQ参数
- };
-
- short val[4];
- short cmd[8] = {0, GEQ_BYPASS_ALL, GEQ_QVALUE, GEQ_GAIN, GEQ_CLEAR};
-
- val[0] = RESSIGNBIT(val_c[0]);
- val[1] = RESSIGNBIT(val_c[1]);
-
- m->Ctrl(cmd[pID], val, 2);
-
- return 0;
-}
-
-u32 tg_param_ctrl::Reverb_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Reverb_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
short val[4];
@@ -302,7 +344,7 @@
return 0;
}
-u32 tg_param_ctrl::Echo_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Echo_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum EchoID{
ECHO_BYPASS = 1,
@@ -322,20 +364,46 @@
return 0;
}
-u32 tg_param_ctrl::General_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Geq_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
+ enum GEQID{
+ GEQ_BYPASS_ALL = 0x1,//val[0]: 0-取消bypass, 1- 使能bypass
+ GEQ_QVALUE,//val[0]: 1-narrow, 2-normal, 3-wide
+ GEQ_GAIN,//val[0]: 段序号,val[1] : 增益,乘以100，范围:-4800~2400
+ GEQ_CLEAR,//val[0]: 复位EQ参数
+ };
+
short val[4];
+ short cmd[8] = {0, GEQ_BYPASS_ALL, GEQ_QVALUE, GEQ_GAIN, GEQ_CLEAR};
val[0] = RESSIGNBIT(val_c[0]);
val[1] = RESSIGNBIT(val_c[1]);
- m->Ctrl(pID, val, 2);
-// dbg_printf("pID:%d v[0]:%d v[1]:%d\n", pID, val[0], val[1]);
+ m->Ctrl(cmd[pID], val, 2);
+
+
+ // save the modul param
+ ptag_module pmodu = (ptag_module)param;
+ ptag_geq pgeq = (ptag_geq)pmodu->proc_ins;
+ switch(pID) {
+ case GEQ_BYPASS_ALL:
+ pgeq->bypass = val[0];
+ break;
+ case GEQ_QVALUE:
+ pgeq->q_index = val[0];
+ break;
+ case GEQ_GAIN:
+ if (val[0] < 31)
+ pgeq->eq_attr[val[0]].gain = val[1];
+ break;
+ default:
+ break;
+ }
return 0;
}
-u32 tg_param_ctrl::Fir_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::Fir_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
enum FIRID {
FIR_BYPASS = 0x1, ////val[0]: 0-取消bypass, 1- 使能bypass
@@ -353,58 +421,432 @@
m->Ctrl(pID, val_c, num);
}
+ ptag_module pmodu = (ptag_module)param;
+ ptag_fir pfir = (ptag_fir)pmodu->proc_ins;
+ switch(pID) {
+ case FIR_BYPASS:
+ pfir->bypass = val[0];
+ break;
+ case FIR_COEFFS:
+ memcpy((void*)&pfir->coeffs, val_c, num * sizeof(*val_c));
+ break;
+ default:
+ break;
+ }
return 0;
}
-u32 tg_param_ctrl::Spl_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
+u32 tg_param_ctrl::General_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
{
- enum ContinousSPLID {
- SPL_BYPASS = 0x1,
+ short val[4];
+
+ val[0] = RESSIGNBIT(val_c[0]);
+ val[1] = RESSIGNBIT(val_c[1]);
+
+ m->Ctrl(pID, val, 2);
+// dbg_printf("pID:%d v[0]:%d v[1]:%d\n", pID, val[0], val[1]);
+ return 0;
+}
+
+u32 tg_param_ctrl::Agc_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum AGCID {
+ AGC_BYPASS = 0x1, //val[0]:0-取消bypass，1-bypass
+ AGC_NOISE_THR, //val[0]: 阈值,乘以100，范围：-9600~-2000
+ AGC_TARGET_LEVEL, //val[0]:目标阈值，乘以100，范围-4000~0
+ AGC_RATIO, //val[0]:比率，乘以100，范围1-10000.
+ AGC_ATTACKTIME, //val[0]:建立时间,范围1~2000
+ AGC_RELEASETIME, //val[0]:释放时间,范围1~2000
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ // save the modul param
+ ptag_module pmodu = (ptag_module)param;
+ ptag_agc pagc = (ptag_agc)pmodu->proc_ins;
+ switch(pID) {
+ case AGC_BYPASS:
+ pagc->bypass = val[0];
+ break;
+ case AGC_NOISE_THR:
+ pagc->threshold = val[0];
+ break;
+ case AGC_TARGET_LEVEL:
+ pagc->tar_threshold = val[0];
+ break;
+ case AGC_RATIO:
+ pagc->ratio = val[0];
+ break;
+ case AGC_ATTACKTIME:
+ pagc->attacktime = val[0];
+ break;
+ case AGC_RELEASETIME:
+ pagc->releasetime = val[0];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Peq_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum PEQID{
+ EQ_BYPASS_ALL = 0x1,//val[0]: 0-取消bypass, 1- 使能bypass
+ EQ_BYPASS,//val[0]: 段序号,val[1] : 0-取消bypass, 1- 使能bypass
+ EQ_FREQ,//val[0]: 段序号,val[1] : 频率， 范围:20-20K
+ EQ_GAIN,//val[0]: 段序号,val[1] : 增益,乘以100，范围:-4800~2400
+ EQ_QVALUE,//val[0]: 段序号,val[1] :Q值，乘以100，范围1~5000
+ EQ_TYPE,//val[0]: 段序号,val[1] : EQ类型 范围参考枚举类型EQType定义
+ EQ_CLEAR,//val[0]: 复位EQ参数
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ val[1] = RESSIGNBIT(val_c[1]);
+ // save the modul param
+ ptag_module pmodu = (ptag_module)param;
+ ptag_eq pexp = (ptag_eq)pmodu->proc_ins;
+ switch(pID) {
+ case EQ_BYPASS_ALL:
+ pexp->bypass = val[0];
+ break;
+ case EQ_BYPASS:
+ pexp->eq_attr[val[0]].bypass = val[1];
+ break;
+ case EQ_FREQ:
+ pexp->eq_attr[val[0]].freq = val[1];
+ break;
+ case EQ_GAIN:
+ pexp->eq_attr[val[0]].gain = val[1];
+ break;
+ case EQ_QVALUE:
+ pexp->eq_attr[val[0]].q = val[1];
+ break;
+ case EQ_TYPE:
+ pexp->eq_attr[val[0]].type = val[1];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Expander_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum ExpanderID{
+ EXPANDER_BYPASS = 0x1,
+ EXPANDER_THRESHOLD,
+ EXPANDER_RADIO,
+ EXPANDER_ATTACK,
+ EXPANDER_RELEASE,
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ // save the modul param
+ ptag_module pmodu = (ptag_module)param;
+ ptag_expander pexp = (ptag_expander)pmodu->proc_ins;
+ switch(pID) {
+ case EXPANDER_BYPASS:
+ pexp->bypass = val[0];
+ break;
+ case EXPANDER_THRESHOLD:
+ pexp->threshold = val[0];
+ break;
+ case EXPANDER_RADIO:
+ pexp->ratio = val[0];
+ break;
+ case EXPANDER_ATTACK:
+ pexp->attack = val[0];
+ break;
+ case EXPANDER_RELEASE:
+ pexp->release = val[0];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::CompAndLimt_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum CompressorID {
+ COMPRESS_BYPASS = 0x1,
+ COMPRESS_THERSHOLD,
+ COMPRESS_RADIO,
+ COMPRESS_ATTACK,
+ COMPRESS_RELEASE,
+ COMPRESS_GAIN,
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ // save the modul param
+ ptag_module pmodu = (ptag_module)param;
+ ptag_compress pco2li = (ptag_compress)pmodu->proc_ins;
+ switch(pID) {
+ case COMPRESS_BYPASS:
+ pco2li->bypass = val[0];
+ break;
+ case COMPRESS_THERSHOLD:
+ pco2li->threshold = val[0];
+ break;
+ case COMPRESS_RADIO:
+ pco2li->ratio = val[0];
+ break;
+ case COMPRESS_ATTACK:
+ pco2li->attack = val[0];
+ break;
+ case COMPRESS_RELEASE:
+ pco2li->release = val[0];
+ break;
+ case COMPRESS_GAIN:
+ pco2li->gain = val[0];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Delay_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum DelayID {
+ DELAY_BYPASS = 0x1,
+ DELAY_MSEC,
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ ptag_module pmodu = (ptag_module)param;
+ ptag_delay pdelay = (ptag_delay)pmodu->proc_ins;
+ switch(pID) {
+ case DELAY_BYPASS:
+ pdelay->bypass = val[0];
+ break;
+ case DELAY_MSEC:
+ pdelay->ms = val[0];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Gating_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum NoiseGateID {
+ GATE_BYPASS = 0x1, //val[0]:0-取消bypass, 1-使能bypass
+ GATE_THRESHOLD,//val[0]:阈值，乘以100，范围-9600~0
+ GATE_DEPTH, //val[0]:深度，乘以100，范围-7200~0
+ GATE_HOLDTIME, //val[0]: 保持时间,范围1~10000ms
+ GATE_ATTACK, //val[0]:建立时间，范围1~2000ms
+ GATE_RELEASE,//val[0]:释放时间，范围1~2000ms
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ ptag_module pmodu = (ptag_module)param;
+ ptag_gate pgate = (ptag_gate)pmodu->proc_ins;
+ switch(pID) {
+ case GATE_BYPASS:
+ pgate->bypass = val[0];
+ break;
+ case GATE_THRESHOLD:
+ pgate->threshold = val[0];
+ break;
+ case GATE_DEPTH:
+ pgate->depth = val[0];
+ break;
+ case GATE_HOLDTIME:
+ pgate->holdtime = val[0];
+ break;
+ case GATE_ATTACK:
+ pgate->attacktime = val[0];
+ break;
+ case GATE_RELEASE:
+ pgate->releasetime = val[0];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Feedback_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum NHSID{
+ FB_BYPASS= 0x1,
+ FB_FLT_FREQ,
+ FB_FLT_GAIN,
+ FB_FLT_Q,
+ FB_FLT_TYPE,
+
+ FB_STEP,
+ FB_CLEAR,
+ FB_PANIC,
+ FB_FLT_DEPTH,
+ FB_THRS,
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ val[1] = RESSIGNBIT(val_c[1]);
+ // save the modul param
+ ptag_module pmodu = (ptag_module)param;
+ ptag_feedback pfb = (ptag_feedback)pmodu->proc_ins;
+ switch(pID) {
+ case FB_BYPASS:
+ pfb->bypass = val[0];
+ break;
+ case FB_FLT_FREQ:
+ pfb->flt_group[val[0]].fc = val[1];
+ break;
+ case FB_FLT_GAIN:
+ pfb->flt_group[val[0]].gain = val[1];
+ break;
+ case FB_FLT_Q:
+ pfb->bw = val[0];
+ break;
+ case FB_FLT_TYPE:
+ pfb->flt_group[val[0]].type = val[1];
+ break;
+ case FB_STEP:
+ pfb->step = val[0];
+ break;
+ case FB_PANIC:
+ pfb->panic_threshold = val[0];
+ break;
+ case FB_FLT_DEPTH:
+ pfb->flt_depth = val[0];
+ break;
+ case FB_THRS:
+ pfb->fb_threshold = val[0];
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Ducker_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum DuckerWithMixID {
+ DUCKER_BYPASS = 0x1, //val[0]:0-取消bypass,1-使能bypass
+ DUCKER_THRESHOLD,//val[0]:阈值，乘以100，范围：-6000~0
+ DUCKER_DEPTH,//val[0]:深度，乘以100，范围：-7200~0
+ DUCKER_ATTACK,//val[0]:建立时间，范围：1~2000ms
+ DUCKER_HOLD,//val[0]:保持时间，范围：1~10000ms
+ DUCKER_RELEASE,//val[0]:释放时间，范围：1~60000ms
+ DUCKER_SIDE_GAIN,//val[0]:侧链增益，乘以100，范围：-7200~1200
+ DUCKER_SIDE_MUTE,//val[0]:侧链静音，0-取消静音，1-静音
+ DUCKER_SIDE_MIX,//val[0]:侧链混音,0-取消混音,1-混音
+ };
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ val[1] = RESSIGNBIT(val_c[1]);
+ ptag_module pmodu = (ptag_module)param;
+ ptag_ducker pduck = (ptag_ducker)pmodu->proc_ins;
+ switch(pID) {
+ case DUCKER_BYPASS:
+ pduck->bypass = val[0];
+ break;
+ case DUCKER_THRESHOLD:
+ pduck->threshold = val[0];
+ break;
+ case DUCKER_DEPTH:
+ pduck->depth = val[0];
+ break;
+ case DUCKER_ATTACK:
+ pduck->attacktime = val[0];
+ break;
+ case DUCKER_HOLD:
+ pduck->holdtime = val[0];
+ break;
+ case DUCKER_RELEASE:
+ pduck->releasetime = val[0];
+ break;
+ case DUCKER_SIDE_GAIN:
+ pduck->side_gain = val[0];
+ break;
+ case DUCKER_SIDE_MUTE:
+ pduck->mute = val[0];
+ break;
+ case DUCKER_SIDE_MIX:
+ if (val[1])
+ pduck->mask[val[0]/16] |= (1>>(val[0]&15));
+ else
+ pduck->mask[val[0]/16] &= (0>>(val[0]&15));
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+u32 tg_param_ctrl::Spler_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
+{
+ General_Ctrl(m, pID, val_c, num, param);
+
+ enum ContSplWithMixID {
+ SPLMIX_BYPASS = 0x1, //val[0]:0-取消bypass,1-bypass
SPL_MAX_GAIN,
SPL_MIN_GAIN,
- SPL_SENSE_RATIO = 4,
- SPL_UPSPEED = 5,
- SPL_DOWNSPEED,
+ SPL_SENSE_RATIO,
+ SPL_SPEED,
SPL_TRIM,
SPL_THR,
SPL_DISTANCE,
+ SPL_MIX,
};
- enum ContSplWithMixID {
- SPLMIX_BYPASS = 0x1, //val[0]:0-取消bypass,1-bypass
- SPLMIX_MAX_GAIN,
- SPLMIX_MIN_GAIN,
- SPLMIX_SENSE_RATIO,
- SPLMIX_SPEED = 5,
- SPLMIX_TRIM,
- SPLMIX_THR,
- SPLMIX_DISTANCE,
- SPLMIX_MIX,
- };
-
- s16 val[4];
- val[0] = RESSIGNBIT(val_c[0]), val[0] = RESSIGNBIT(val_c[1]);
-
- if (pID < 5) {
- General_Ctrl(m, pID, val_c, num);
- }
- else {
- switch (pID) {
- case ContSplWithMixID::SPLMIX_SPEED:
- m->Ctrl(ContinousSPLID::SPL_UPSPEED, val, 1);
- m->Ctrl(ContinousSPLID::SPL_DOWNSPEED, val, 1);
- break;
- case ContSplWithMixID::SPLMIX_TRIM:
- m->Ctrl(ContinousSPLID::SPL_TRIM, val, 1);
- break;
- case ContSplWithMixID::SPLMIX_THR:
- m->Ctrl(ContinousSPLID::SPL_THR, val, 1);
- break;
- case ContSplWithMixID::SPLMIX_DISTANCE:
- m->Ctrl(ContinousSPLID::SPL_DISTANCE, val, 1);
- break;
- default:
- break;
- }
+ short val[4];
+ val[0] = RESSIGNBIT(val_c[0]);
+ val[1] = RESSIGNBIT(val_c[1]);
+ ptag_module pmodu = (ptag_module)param;
+ ptag_spl pspl = (ptag_spl)pmodu->proc_ins;
+ switch(pID) {
+ case SPLMIX_BYPASS:
+ pspl->bypass = val[0];
+ break;
+ case SPL_MAX_GAIN:
+ pspl->maxgain = val[0];
+ break;
+ case SPL_MIN_GAIN:
+ pspl->mingain = val[0];
+ break;
+ case SPL_SENSE_RATIO:
+ pspl->sense_ratio = val[0];
+ break;
+ case SPL_SPEED:
+ pspl->speed = val[0];
+ break;
+ case SPL_TRIM:
+ pspl->trim = val[0];
+ break;
+ case SPL_THR:
+ pspl->noise_thr = val[0];
+ break;
+ case SPL_DISTANCE:
+ pspl->distance = val[0];
+ break;
+ case SPL_MIX:
+ if (val[1])
+ pspl->mask[val[0]/16] |= (1>>(val[0]&15));
+ else
+ pspl->mask[val[0]/16] &= (0>>(val[0]&15));
+ break;
+ default:
+ break;
}
return 0;
}
--
Gitblit v1.9.3