/*
|
* tg_user_ctrl.cpp
|
*
|
* Created on: 2025Äê7ÔÂ24ÈÕ
|
* Author: 86189
|
*/
|
#include <stdio.h>
|
#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, void* param)
|
{
|
enum SGItemType{
|
SG_MUTE = 0x1,
|
SG_TYPE ,
|
SG_FREQ ,
|
SG_GAIN,
|
};
|
|
short val[4];
|
int channel = RESSIGNBIT(val_c[0]); //&(MAX_INPUT_NUM-1);
|
|
if(pID == INPUT_TYPE) {//signal gen
|
if(val_c[1] > 3) {
|
val[0] = channel;
|
val[1] = 0 ;
|
}
|
else if(val_c[1] > 0) {
|
val[0] = channel;
|
val[1] = RESSIGNBIT(val_c[1]);
|
m->Ctrl(SG_TYPE, val, 2);
|
}
|
else {
|
val[0] = channel;
|
val[1] = 0;
|
m->Ctrl(SG_TYPE, val, 2);
|
}
|
}
|
else if(pID == INPUT_FREQ) {
|
val[0] = channel; val[1] = RESSIGNBIT(val_c[1]);
|
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, void* param)
|
{
|
enum SigSrcID {
|
GAIN = 0x1, //val[0]: ͨµÀºÅ,val[1] : ÔöÒæ £¬³ËÒÔ100 £¬ ·¶Î§: -7200 ~ 1200
|
MUTE, //val[0]: ͨµÀºÅ,val[1] : ¾²Òô , 0-È¡Ïû¾²Òô,1-¾²Òô
|
SENSI,
|
PHANTO,
|
SIGNAL_TYPE = 5,
|
|
GENERATE_FREQ,
|
GENERATE_LEVEL,
|
PHASE = 9, //val[0]: ͨµÀºÅ,val[1] : ·´Ïà , 0-È¡Ïû·´Ïà, 1-·´Ïà
|
STEP,
|
};
|
|
short val[4];
|
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, void* param)
|
{
|
enum GainID {
|
GAIN = 0x1,
|
MUTE,
|
SENSI,
|
PHANTOM,
|
|
PHASE = 9,
|
STEP,//-500~+500
|
};
|
|
short val[4];
|
int channel = val_c[0];//&(MAX_INPUT_NUM-1);
|
|
if(pID == 0x20) {
|
val[0] = channel; val[1] = RESSIGNBIT(val_c[1]);
|
m->Ctrl(GAIN, val, 2);
|
}
|
|
return 0;
|
}
|
|
u32 tg_param_ctrl::Output_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
enum GainID {
|
GAIN = 0x1,
|
MUTE,
|
SENSI,
|
PHANTO,
|
|
PHASE = 9,
|
STEP,
|
};
|
|
short val[4];
|
int channel = val_c[0];//&(MAX_OUTPUT_NUM-1);
|
|
short cmd[16] = {GAIN, MUTE, 0, PHASE, SENSI, STEP, 0, 0, 0, 0, 0, 0 ,0 ,0 ,0 ,0 };
|
val[0] = channel;
|
val[1] = RESSIGNBIT(val_c[1]);
|
|
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, void* param)
|
{
|
short val[4];
|
|
if(m->GetModuleID() >= 320){
|
val[0] = RESSIGNBIT(val_c[0]);
|
val[1] = 0;
|
val[2] = RESSIGNBIT(val_c[1]);
|
|
m->Ctrl(MIXER_SWITCH, val, 3);
|
}
|
else{
|
val[0] = val_c[0]&0xff ;
|
val[1] = (val_c[0]>>8)&0xff;
|
val[2] = RESSIGNBIT(val_c[1]);
|
|
m->Ctrl(pID, val, 3);
|
}
|
|
return 0;
|
}
|
|
u32 tg_param_ctrl::Crossover_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
enum CFilterID {
|
_BYPASS = 0x1,
|
_TYPE,
|
_TAPS,
|
_FREQ,
|
_GAIN,
|
};
|
|
short val[4];
|
|
if(pID >= XOVER_LOWPASS_BYPASS){
|
val[0] = 0;
|
val[1] = RESSIGNBIT(val_c[0]);
|
pID = pID - XOVER_LOWPASS_BYPASS +1;
|
}
|
else{
|
val[0] = 1;
|
val[1] = RESSIGNBIT(val_c[0]);
|
}
|
|
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::Automixer_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
enum GainSharingAMID {
|
AM_BYPASS =0x1,
|
AM_MUTE ,
|
AM_GAIN,
|
AM_SLOPE,
|
AM_RESPONSE,
|
AM_CHANNEL_AUTO ,
|
AM_CHANNEL_MUTE,
|
AM_CHANNEL_GAIN,
|
AM_CHANNEL_PRIORITY,
|
};
|
|
short val[4];
|
short cmd[16] = {AM_MUTE, AM_GAIN,AM_SLOPE,AM_RESPONSE,AM_CHANNEL_AUTO,AM_CHANNEL_MUTE,\
|
AM_CHANNEL_GAIN,AM_CHANNEL_PRIORITY,AM_BYPASS};
|
|
val[0] = RESSIGNBIT(val_c[0]); val[1] = RESSIGNBIT(val_c[1]);
|
m->Ctrl(cmd[pID-1], val, 2);
|
|
return 0;
|
}
|
|
u32 tg_param_ctrl::Aec_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
enum AECID{
|
BYPASS = 0X1,
|
MUTE,
|
NLPLEVEL,
|
NSMODE,
|
HPFFREQ,
|
CHANNAME,
|
AGC_BYPASS,
|
AGC_THRESHOLD,
|
AGC_TARTHRESHOLD,
|
AGC_RATIO,
|
AGC_ATTACK,
|
AGC_RELEASE,
|
AGC_GAIN,
|
};
|
|
short val[4] = {0,0,0,0};
|
short cmd[3] = {0, BYPASS, NLPLEVEL};
|
|
val[1] = RESSIGNBIT(val_c[0]);
|
m->Ctrl(cmd[pID], val, 2);
|
|
return 0;
|
}
|
|
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
|
SYSCTL_GAIN, //
|
};
|
|
short val[4];
|
short cmd[4] = {0, SYSCTL_GAIN, SYSCTL_MUTE, 0};
|
|
val[0] = RESSIGNBIT(val_c[0]);
|
m->Ctrl(cmd[pID], val, 1);
|
|
return 0;
|
}
|
|
u32 tg_param_ctrl::Reverb_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
short val[4];
|
|
val[0] = RESSIGNBIT(val_c[0]);
|
val[1] = RESSIGNBIT(val_c[1]);
|
|
m->Ctrl(pID, val, 2);
|
|
return 0;
|
}
|
|
u32 tg_param_ctrl::Echo_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
enum EchoID{
|
ECHO_BYPASS = 1,
|
ECHO_HPF,
|
ECHO_LPF,
|
ECHO_DELAY,
|
ECHO_GAIN,
|
};
|
|
short val[4];
|
|
val[0] = RESSIGNBIT(val_c[0]);
|
val[1] = RESSIGNBIT(val_c[1]);
|
|
m->Ctrl(pID, val, 2);
|
|
return 0;
|
}
|
|
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(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, void* param)
|
{
|
enum FIRID {
|
FIR_BYPASS = 0x1, ////val[0]: 0-È¡Ïûbypass, 1- ʹÄÜbypass
|
FIR_NAME, //ÎÞÓÃ
|
FIR_TAPS, //ÎÞÓÃ
|
FIR_COEFFS, //val: ·Ö°ü£¬×î´ó³¤¶È1024 float. ÎÞת»»Ö±½Ó¿½±´float.
|
};
|
s16 val[4];
|
val[0] = RESSIGNBIT(val_c[0]);
|
|
if(FIR_BYPASS == pID){
|
m->Ctrl(pID, val, 1); // val[0] is bypass or nobypass
|
}
|
else if (FIR_COEFFS == pID){
|
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::General_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num, void* param)
|
{
|
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,
|
SPL_SPEED,
|
SPL_TRIM,
|
SPL_THR,
|
SPL_DISTANCE,
|
SPL_MIX,
|
};
|
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;
|
}
|
