/*
 * 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;
}