#include "ParamCtrl.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "ModuleExport.h"
#include "config.h"
#include "scene.h"
#include "tob.h"

#define RESSIGNBIT(X) (((X)&0x8000)?(-((~(X))&0xffff)-1):(X)) //»¹Ô­·ûºÅλ

//static ToB* MTob = ToB::GetInstance();

static u32 SignalgenParamCtrl(IModule* m, void* handle, int &plen)
{
	enum SGItemType{
		SG_MUTE = 0x1,
		SG_TYPE ,
		SG_REQ ,
		SG_GAIN,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_input pInput = (ptag_input)handle;
	plen = sizeof(tag_input);

	for(i=0; i<pInput->input_num; i++){
		val[0] = i ;

		if(pInput->input[i].type > 3) {

		}
		else if(pInput->input[i].type) {
			//control signalgen
			val[1] = RESSIGNBIT(pInput->input[i].type);  m->Ctrl(SG_TYPE, val, 2);
			val[1] = RESSIGNBIT(pInput->input[i].freq);  m->Ctrl(SG_REQ, val, 2);
			val[1] = RESSIGNBIT(pInput->input[i].level);  m->Ctrl(SG_GAIN, val, 2);
		}
		else {
			//control signalgen
			val[1] = 0;  m->Ctrl(SG_TYPE, val, 2);
			val[1] = RESSIGNBIT(pInput->input[i].freq);  m->Ctrl(SG_REQ, val, 2);
			val[1] = RESSIGNBIT(pInput->input[i].level);  m->Ctrl(SG_GAIN, val, 2);
		}
	}

	return 0;
}

static u32 InputParamCtrl(IModule* m, void* handle, int &plen)
{
	enum GainID {
		GAIN = 0x1,
		MUTE,
		SENSI,
		PHANTOM,

		PHASE = 9,
		STEP,//-500~+500
	};

	enum PitchID {
		PITCH_BYPASS = 0x1,//
		PITCH_SEMITONES,//
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_input pInput = (ptag_input)handle;
	plen = sizeof(tag_input);

	for(i=0; i<pInput->input_num; i++){
		val[0] = i ;

		val[1] = RESSIGNBIT(pInput->input[i].gain);  m->Ctrl(GAIN, val, 2);
		val[1] = RESSIGNBIT(pInput->input[i].mute);  m->Ctrl(MUTE, val, 2);
		val[1] = RESSIGNBIT(pInput->input[i].sensitivity);  m->Ctrl(SENSI, val, 2);
		val[1] = RESSIGNBIT(pInput->input[i].phant);  m->Ctrl(PHANTOM, val, 2);
		val[1] = RESSIGNBIT(pInput->input[i].phase);  m->Ctrl(PHASE, val, 2);
	}

	return 0;
}

static u32 OutputParamCtrl(IModule* m, void* handle, int &plen)
{
	enum GainID {
		GAIN = 0x1,
		MUTE,
		SENSI,
		PHANTOM,

		PHASE = 9,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_output pOutput = (ptag_output)handle;
	plen = sizeof(tag_output);

	for(i=0; i< pOutput->output_num; i++){
		val[0] = i; val[1] = RESSIGNBIT(pOutput->output[i].gain);  m->Ctrl(GAIN, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pOutput->output[i].mute);  m->Ctrl(MUTE, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pOutput->output[i].sensitivity);  m->Ctrl(SENSI, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pOutput->output[i].phase);  m->Ctrl(PHASE, val, 2);
	}

	return 0;
}

static u32 EqParamCtrl(IModule* m, void* handle, int &plen)
{
	enum EQID{
		EQ_BYPASS_ALL = 0x1,
		EQ_BYPASS,
		EQ_FREQ,
		EQ_GAIN,
		EQ_QVALUE,
		EQ_TYPE,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_eq peq = (ptag_eq)handle;
	plen = sizeof(tag_eq);

	val[0] = peq->bypass;   m->Ctrl(EQ_BYPASS_ALL, val, 2);
	for(i=0 ;i < peq->nsection ;i++) {
		val[0] = i; val[1] = RESSIGNBIT(peq->eq_attr[i].gain);  m->Ctrl(EQ_GAIN, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(peq->eq_attr[i].bypass);  m->Ctrl(EQ_BYPASS, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(peq->eq_attr[i].freq);  m->Ctrl(EQ_FREQ, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(peq->eq_attr[i].q);  m->Ctrl(EQ_QVALUE, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(peq->eq_attr[i].type);  m->Ctrl(EQ_TYPE, val, 2);

	}

	return 0;
}

static u32 ExpanderParamCtrl(IModule* m, void* handle, int &plen)
{
	enum ExpanderID{
		EXPANDER_BYPASS = 0x1,
		EXPANDER_THRESHOLD,
		EXPANDER_RADIO,
		EXPANDER_ATTACK,
		EXPANDER_RELEASE,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_expander pexpander = (ptag_expander)handle ;
	plen = sizeof(tag_expander);

	val[0] = RESSIGNBIT(pexpander->bypass);  m->Ctrl(EXPANDER_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pexpander->threshold);  m->Ctrl(EXPANDER_THRESHOLD, val, 1);
	val[0] = RESSIGNBIT(pexpander->ratio);  m->Ctrl(EXPANDER_RADIO, val, 1);
	val[0] = RESSIGNBIT(pexpander->attack);  m->Ctrl(EXPANDER_ATTACK, val, 1);
	val[0] = RESSIGNBIT(pexpander->release);  m->Ctrl(EXPANDER_RELEASE, val, 1);

	return 0;
}

static u32 CompressParamCtrl(IModule* m, void* handle, int &plen)
{
	enum CompressorID {
		COMPRESS_BYPASS = 0x1,
		COMPRESS_THERSHOLD,
		COMPRESS_RADIO,
		COMPRESS_ATTACK,
		COMPRESS_RELEASE,
		COMPRESS_GAIN,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_compress pcompress = (ptag_compress)handle;
	plen = sizeof(tag_compress);

	val[0] = RESSIGNBIT(pcompress->bypass);  m->Ctrl(COMPRESS_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pcompress->threshold);  m->Ctrl(COMPRESS_THERSHOLD, val, 1);
	val[0] = RESSIGNBIT(pcompress->ratio);  m->Ctrl(COMPRESS_RADIO, val, 1);
	val[0] = RESSIGNBIT(pcompress->attack);  m->Ctrl(COMPRESS_ATTACK, val, 1);
	val[0] = RESSIGNBIT(pcompress->release);  m->Ctrl(COMPRESS_RELEASE, val, 1);
	val[0] = RESSIGNBIT(pcompress->gain);  m->Ctrl(COMPRESS_GAIN, val, 1);

	return 0;
}

static u32 LimitParamCtrl(IModule* m, void* handle, int &plen)
{
	enum CompressorID {
		COMPRESS_BYPASS = 0x1,
		COMPRESS_THERSHOLD,
		COMPRESS_RADIO,
		COMPRESS_ATTACK,
		COMPRESS_RELEASE,
		COMPRESS_GAIN,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_compress pcompress = (ptag_compress)handle;
	plen = sizeof(tag_compress);

	val[0] = RESSIGNBIT(pcompress->bypass);  m->Ctrl(COMPRESS_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pcompress->threshold);  m->Ctrl(COMPRESS_THERSHOLD, val, 1);
	val[0] = RESSIGNBIT(pcompress->attack);  m->Ctrl(COMPRESS_ATTACK, val, 1);
	val[0] = RESSIGNBIT(pcompress->release);  m->Ctrl(COMPRESS_RELEASE, val, 1);

	return 0;
}

static u32 MixerParamCtrl(IModule* m, void* handle, int &plen)
{
	enum MixerID {
		MIXER_SWITCH = 0x1,
		MIXER_GAIN,
		MIXER_DELAY,
		MIXER_INPUT_MUTE,
		MIXER_OUTPUT_MUTE,
	};

	if(handle == NULL) return 1;

	if(m->GetModuleID() >= 320){
		extern int input_num_channels;
		extern int output_num_channels;

		int i;
		short val[4];
		ptag_ducker pducker = (ptag_ducker)handle;
		plen = sizeof(tag_ducker);

		for (i =0 ;i < input_num_channels; i++) {
			val[0] = i; val[1] = 0;
			val[2] = (pducker->mask[i/15]>>(i&15))&0x1;  m->Ctrl(MIXER_SWITCH, val, 3);

		}
	}
	else{
		int i ,j;
		short val[4];
		ptag_mixer pmixer = (ptag_mixer)handle;
		plen = sizeof(tag_mixer);

		for(i=0 ;i < pmixer->output_num ;i ++) {
			for(j =0 ;j < pmixer->input_num ;j++) {
				val[0] = j;  val[1] = i ; val[2] = (pmixer->input_mask[i][j/15]>>(j&15))&0x1;  m->Ctrl(MIXER_SWITCH, val, 3);
				val[0] = j;  val[1] = i ; val[2] = RESSIGNBIT(pmixer->input_gain[i][j]);  m->Ctrl(MIXER_GAIN, val, 3);
			}
		}
	}

	return 0;
}

static u32 DelayParamCtrl(IModule* m, void* handle, int &plen)
{
	enum DelayID {
		DELAY_BYPASS = 0x1,
		DELAY_MSEC,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_delay pdelay = (ptag_delay)handle;
	plen = sizeof(tag_delay);

	val[0] = pdelay->bypass;  m->Ctrl(DELAY_BYPASS, val, 1);
	val[0] = pdelay->ms;  m->Ctrl(DELAY_MSEC, val, 1);
	//val[0] = pdelay->ms + pdelay->us;  m->Ctrl(DELAY_MSEC, val, 1);

	return 0;
}

static u32 CrossoverParamCtrl(IModule* m, void* handle, int &plen)
{
	enum CFilterID {
		_BYPASS = 0x1,
		_TYPE,
		_TAPS,
		_FREQ,
		_GAIN,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_crossover pcrossover = (ptag_crossover)handle;
	plen = sizeof(tag_crossover);

	val[0] = 0; val[1] = RESSIGNBIT(pcrossover->lowpass.bypass);  m->Ctrl(_BYPASS, val, 2);
	val[0] = 0; val[1] = RESSIGNBIT(pcrossover->lowpass.type);  m->Ctrl(_TYPE, val, 2);
	val[0] = 0; val[1] = RESSIGNBIT(pcrossover->lowpass.taps);  m->Ctrl(_TAPS, val, 2);
	val[0] = 0; val[1] = RESSIGNBIT(pcrossover->lowpass.freq);  m->Ctrl(_FREQ, val, 0);
	val[0] = 0; val[1] = RESSIGNBIT(pcrossover->lowpass.gain);  m->Ctrl(_GAIN, val, 0);

	val[0] = 1; val[1] = RESSIGNBIT(pcrossover->highpass.bypass);  m->Ctrl(_BYPASS, val, 2);
	val[0] = 1; val[1] = RESSIGNBIT(pcrossover->highpass.type);  m->Ctrl(_TYPE, val, 2);
	val[0] = 1; val[1] = RESSIGNBIT(pcrossover->highpass.taps);  m->Ctrl(_TAPS, val, 2);
	val[0] = 1; val[1] = RESSIGNBIT(pcrossover->highpass.freq);  m->Ctrl(_FREQ, val, 2);
	val[0] = 1; val[1] = RESSIGNBIT(pcrossover->highpass.gain);  m->Ctrl(_GAIN, val, 2);

	return 0;
}

static u32 FeedbackParamCtrl(IModule* m, void* handle, int &plen)
{
//	enum NHSID{
//		FB_BYPASS = 0x1,
//		FB_PANIC,
//		FB_THRS,
//		FB_FLT_DEPTH,
//		FB_STEP,
//		FB_FLT_Q,
//		FB_RECYCLETIME,
//
//		FB_FLT_FREQ,
//		FB_FLT_GAIN,
//		FB_FLT_TYPE,
//
//		FB_CLEAR, //
//		FB_CLEAR_DYNAMIC,//
//	};
	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,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_feedback pfbc = (ptag_feedback)handle;
	plen = sizeof(tag_feedback);
	//short step[4] = {150, 300, 450, 600};

	val[0] = RESSIGNBIT(pfbc->bypass);   m->Ctrl(FB_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pfbc->panic_threshold);   m->Ctrl(FB_PANIC, val, 1);
	val[0] = RESSIGNBIT(pfbc->fb_threshold);   m->Ctrl(FB_THRS, val, 1);
	val[0] = RESSIGNBIT(pfbc->flt_depth);   m->Ctrl(FB_FLT_DEPTH, val, 1);
	//val[0] = RESSIGNBIT(step[pfbc->flt_step]);   m->Ctrl(FB_STEP, val, 1);
	val[0] = RESSIGNBIT(150);   m->Ctrl(FB_STEP, val, 1);
	val[0] = RESSIGNBIT(pfbc->bw);   m->Ctrl(FB_FLT_Q, val, 1);
	for(i=0;i < FEEDBACK_FILTERS_NUM;i++) {
		val[0] = i; val[1] = RESSIGNBIT(pfbc->flt_group[i].type);  m->Ctrl(FB_FLT_TYPE, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pfbc->flt_group[i].gain);  m->Ctrl(FB_FLT_GAIN, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pfbc->flt_group[i].fc);  m->Ctrl(FB_FLT_FREQ, val, 2);
	}

	return 0;
}

static u32 AutomixerParamCtrl(IModule* m, void* handle, int &plen)
{
	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,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_gainsharing_mixer pautomixer = (ptag_gainsharing_mixer)handle;
	plen = sizeof(tag_gainsharing_mixer);

	val[0] = RESSIGNBIT(pautomixer->bypass);  m->Ctrl(AM_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pautomixer->master_mute);  m->Ctrl(AM_MUTE, val, 1);
	val[0] = RESSIGNBIT(pautomixer->master_gain);  m->Ctrl(AM_GAIN, val, 1);
	val[0] = RESSIGNBIT(pautomixer->slope);  m->Ctrl(AM_SLOPE, val, 1);
	val[0] = RESSIGNBIT(pautomixer->response);  m->Ctrl(AM_RESPONSE, val, 1);

	for(i=0; i < AUTOMIXER_CHANNELS_NUM; i++) {
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].automatic);  m->Ctrl(AM_CHANNEL_AUTO, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].master);  m->Ctrl(AM_CHANNEL_MUTE, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].gain);  m->Ctrl(AM_CHANNEL_GAIN, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].threshold);  m->Ctrl(AM_CHANNEL_PRIORITY, val, 2);
	}

	return 0;
}

static u32 AgcParamCtrl(IModule* m, void* handle, int &plen)
{
	enum AGCID {
		AGC_BYPASS = 0x1,
		AGC_NOISE_THR,
		AGC_TARGET_LEVEL,
		AGC_RATIO,
		AGC_ATTACKTIME,
		AGC_RELEASETIME,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_agc pagc = (ptag_agc)handle;
	plen = sizeof(tag_agc);

	val[0] = RESSIGNBIT(pagc->bypass);  m->Ctrl(AGC_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pagc->threshold);  m->Ctrl(AGC_NOISE_THR, val, 1);
	val[0] = RESSIGNBIT(pagc->tar_threshold);  m->Ctrl(AGC_TARGET_LEVEL, val, 1);
	val[0] = RESSIGNBIT(pagc->ratio);  m->Ctrl(AGC_RATIO, val, 1);
	val[0] = RESSIGNBIT(pagc->attacktime);  m->Ctrl(AGC_ATTACKTIME, val, 1);
	val[0] = RESSIGNBIT(pagc->releasetime);  m->Ctrl(AGC_RELEASETIME, val, 1);

	return 0;
}

static u32 AecParamCtrl(IModule* m, void* handle, int &plen)
{
	enum AECID{
		BYPASS = 0X1,
		MUTE,
		NLPLEVEL,
		NSMODE,
		HPFFREQ,
		CHANNAME,
		AGC_BYPASS,
		AGC_THRESHOLD,
		AGC_TARTHRESHOLD,
		AGC_RATIO,
		AGC_ATTACK,
		AGC_RELEASE,
		AGC_GAIN,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_aec paec = (ptag_aec)handle;
	plen = sizeof(tag_aec);

	val[0] = paec->bypass;  m->Ctrl(BYPASS, val, 1);
	val[0] = paec->mode;  m->Ctrl(NLPLEVEL, val, 1);

	return 0;
}

static u32 AnsParamCtrl(IModule* m, void* handle, int &plen)
{
	enum AECID{
		Bypass = 0x1,
		NSMode,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_ans pans = (ptag_ans)handle;
	plen = sizeof(tag_ans);

	val[0] = pans->bypass;  m->Ctrl(Bypass, val, 1);
	val[0] = pans->mode;  m->Ctrl(NSMode, val, 1);

	return 0;
}

static u32 SysctlParamCtrl(IModule* m, void* handle, int &plen)
{
	enum SYSCTRLID{
		SYSCTL_MUTE = 0x1, //
		SYSCTL_GAIN, //
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_sysctl sys = (ptag_sysctl)handle;
	plen = sizeof(tag_sysctl);

	val[0] = RESSIGNBIT(sys->mute);  m->Ctrl(SYSCTL_MUTE, val, 1);
	val[0] = RESSIGNBIT(sys->gain);  m->Ctrl(SYSCTL_GAIN, val, 1);

	return 0;
}

static u32 SelectorParamCtrl(IModule* m, void* handle, int &plen)
{
	enum MixerID {
		MIXER_SWITCH = 0x1,
		MIXER_GAIN,
		MIXER_DELAY,
		MIXER_INPUT_MUTE,
		MIXER_OUTPUT_MUTE,
	};

	if(handle == NULL) return 1;

	int i ,j;
	short val[4];
	ptag_selector pselector = (ptag_selector)handle;
	plen = sizeof(tag_selector);

	for(i=0 ;i < pselector->output_num ;i ++) {
		for(j =0 ;j < pselector->input_num ;j++) {
			val[0] = j;  val[1] = i; val[2] = ((pselector->input_mask[i][j/15]>>(j&15))&0x1) ;
			m->Ctrl(MIXER_SWITCH, val, 3);
		}
	}

	return 0;
}

static u32 Gating_automixerParamCtrl(IModule* m, void* handle, int &plen)
{
	enum  GatingAMID{
		AM_GATE_BYPASS = 0x1,
		AM_GATE_MUTE,
		AM_GATE_GAIN,
		AM_GATE_LAST_ON,
		AM_GATE_HOLD_TIME,
		AM_GATE_OFF_GAIN,
		AM_GATE_SENSITIVITY,
		AM_GATE_NOM_ATTEN,
		AM_GATE_NOM_NUM,
		AM_GATE_CHANNEL_AUTO,
		AM_GATE_CHANNEL_MUTE,
		AM_GATE_CHANNEL_GAIN,
		AM_GATE_CHANNEL_PRIORITY,
		AM_GATE_CHANNEL_DEF,
		AM_GATE_NOISE_THR,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_gating_mixer pautomixer = (ptag_gating_mixer)handle;
	plen = sizeof(tag_gating_mixer);

	val[0] = RESSIGNBIT(pautomixer->bypass);  m->Ctrl(AM_GATE_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pautomixer->master_mute);   m->Ctrl(AM_GATE_MUTE, val, 1);
	val[0] = RESSIGNBIT(pautomixer->master_gain);   m->Ctrl(AM_GATE_GAIN, val, 1);
	val[0] = RESSIGNBIT(pautomixer->last_on);   m->Ctrl(AM_GATE_LAST_ON, val, 1);
	val[0] = RESSIGNBIT(pautomixer->holdtime);   m->Ctrl(AM_GATE_HOLD_TIME, val, 1);
	val[0] = RESSIGNBIT(pautomixer->offgain);   m->Ctrl(AM_GATE_OFF_GAIN, val, 1);
	val[0] = RESSIGNBIT(pautomixer->sensitivity);   m->Ctrl(AM_GATE_SENSITIVITY, val, 1);
	val[0] = RESSIGNBIT(pautomixer->nom_atten);   m->Ctrl(AM_GATE_NOM_ATTEN, val, 1);
	val[0] = RESSIGNBIT(pautomixer->nom_num);   m->Ctrl(AM_GATE_NOM_NUM, val, 1);

	for(i=0 ;i < AUTOMIXER_CHANNELS_NUM ;i++) {
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].automatic);  m->Ctrl(AM_GATE_CHANNEL_AUTO, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].mute);  m->Ctrl(AM_GATE_CHANNEL_MUTE, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].gain);  m->Ctrl(AM_GATE_CHANNEL_GAIN, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].priority);  m->Ctrl(AM_GATE_CHANNEL_PRIORITY, val, 2);
		val[0] = i; val[1] = RESSIGNBIT(pautomixer->channels[i].def);  m->Ctrl(AM_GATE_CHANNEL_DEF, val, 2);
	}

	return 0;
}

static u32 DuckerParamCtrl(IModule* m, void* handle, int &plen)
{
	enum DuckerID {
		DUCKER_BYPASS = 0x1,
		DUCKER_THRESHOLD,
		DUCKER_DEPTH,
		DUCKER_ATTACK,
		DUCKER_HOLD,
		DUCKER_RELEASE,
		DUCKER_SIDE_GAIN,
		DUCKER_SIDE_MUTE,
	};

	enum MixerID {
		MIXER_SWITCH = 0x1,
		MIXER_GAIN,
		MIXER_DELAY,
		MIXER_INPUT_MUTE,
		MIXER_OUTPUT_MUTE,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_ducker pducker = (ptag_ducker)handle;
	plen = sizeof(tag_ducker);

	val[0] = RESSIGNBIT(pducker->bypass);  m->Ctrl(DUCKER_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pducker->threshold);  m->Ctrl(DUCKER_THRESHOLD, val, 1);
	val[0] = RESSIGNBIT(pducker->depth);  m->Ctrl(DUCKER_DEPTH, val, 1);
	val[0] = RESSIGNBIT(pducker->attacktime);  m->Ctrl(DUCKER_ATTACK, val, 1);
	val[0] = RESSIGNBIT(pducker->holdtime);  m->Ctrl(DUCKER_HOLD, val, 1);
	val[0] = RESSIGNBIT(pducker->releasetime);  m->Ctrl(DUCKER_RELEASE, val, 1);
	val[0] = RESSIGNBIT(pducker->side_gain);  m->Ctrl(DUCKER_SIDE_GAIN, val, 1);
	val[0] = RESSIGNBIT(pducker->mute);  m->Ctrl(DUCKER_SIDE_MUTE, val, 1);

	return 0;
}

static u32 GatingParamCtrl(IModule* m, void* handle, int &plen)
{
	enum NoiseGateID {
		GATE_BYPASS = 0x1,
		GATE_THRESHOLD,
		GATE_DEPTH,
		GATE_HOLDTIME,
		GATE_ATTACK,
		GATE_RELEASE,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_gate pgate = (ptag_gate)handle;
	plen = sizeof(tag_gate);

	val[0] = RESSIGNBIT(pgate->bypass);  m->Ctrl(GATE_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pgate->threshold);  m->Ctrl(GATE_THRESHOLD, val, 1);
	val[0] = RESSIGNBIT(pgate->depth);  m->Ctrl(GATE_DEPTH, val, 1);
	val[0] = RESSIGNBIT(pgate->attacktime);  m->Ctrl(GATE_ATTACK, val, 1);
	val[0] = RESSIGNBIT(pgate->holdtime);  m->Ctrl(GATE_HOLDTIME, val, 1);
	val[0] = RESSIGNBIT(pgate->releasetime);  m->Ctrl(GATE_RELEASE, val, 1);

	return 0;
}

static u32 SplParamCtrl(IModule* m, void* handle, int &plen)
{
	enum ContinousSPLID {
		SPL_BYPASS = 0x1,
		SPL_MAX_GAIN,
		SPL_MIN_GAIN,
		SPL_SENSE_RATIO,
		SPL_UPSPEED,
		SPL_DOWNSPEED,
		SPL_TRIM,
		SPL_THR,
		SPL_DISTANCE,
	};

	enum MixerID {
		MIXER_SWITCH = 0x1,
		MIXER_GAIN,
		MIXER_DELAY,
		MIXER_INPUT_MUTE,
		MIXER_OUTPUT_MUTE,
	};

	if(handle == NULL) return 1;

	extern int input_num_channels;
	extern int output_num_channels;

	int i ,j;
	short val[4];
	ptag_spl pspl = (ptag_spl)handle;
	plen = sizeof(tag_spl);

	val[0] = RESSIGNBIT(pspl->bypass);  m->Ctrl(SPL_BYPASS, val, 1);
	val[0] = RESSIGNBIT(pspl->maxgain);  m->Ctrl(SPL_MAX_GAIN, val, 1);
	val[0] = RESSIGNBIT(pspl->mingain);  m->Ctrl(SPL_MIN_GAIN, val, 1);
	val[0] = RESSIGNBIT(pspl->sense_ratio);  m->Ctrl(SPL_SENSE_RATIO, val, 1);
	val[0] = RESSIGNBIT(pspl->speed);  m->Ctrl(SPL_UPSPEED, val, 1);
	val[0] = RESSIGNBIT(pspl->speed);  m->Ctrl(SPL_DOWNSPEED, val, 1);
	val[0] = RESSIGNBIT(pspl->trim);  m->Ctrl(SPL_TRIM, val, 1);
	val[0] = RESSIGNBIT(pspl->noise_thr);  m->Ctrl(SPL_THR, val, 1);
	val[0] = RESSIGNBIT(pspl->distance);  m->Ctrl(SPL_DISTANCE, val, 1);

	for (i =0 ;i < input_num_channels; i++) {
		val[0] = i; val[1] = 0;
		val[2] = (pspl->mask[i/15]>>(i&15))&0x1 ;  m->Ctrl(MIXER_SWITCH, val, 3);
	}

	return 0;
}

const s16 fc_10[]={31, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000 };
const s16 fc_15[]={25, 40, 63, 100, 160, 250, 400, 630, 1000, 1600, 2500, 4000, 6300, 10000, 16000};
const s16 fc_31[]={20, 25,31, 40, 50, 63, 80, 100, 125, 160, 200,250, 315, 400, 500, 630, 800, 1000, 1250, 1600,2000,2500, 3150, 4000, 5000, 6300, 8000, 10000,12500, 16000,20000};
static u32 GeqParamCtrl(IModule* m, void* handle, int &plen)
{
	enum EQID{
		EQ_BYPASS_ALL = 0x1,
		EQ_BYPASS,
		EQ_FREQ,
		EQ_GAIN,
		EQ_QVALUE,
		EQ_TYPE,
	};

	if(handle == NULL) return 1;

	int i;
	short val[4];
	ptag_geq pgeq = (ptag_geq)handle ;
	plen = sizeof(tag_geq);
	const s16 *pfc = fc_31;

	switch(pgeq->nsections){
	case 10:
	  pfc = fc_10;
	  break;
	case 15:
	  pfc = fc_15;
	  break;
	default:
	  pfc = fc_31;
	  break;
	}

	val[0] = pgeq->bypass;  m->Ctrl(EQ_BYPASS_ALL, val, 1);
	val[0] = pgeq->q;  m->Ctrl(EQ_QVALUE, val, 1);

	for(i=0 ;i < pgeq->nsections ;i++) {
		val[0] = i; val[1] = RESSIGNBIT(pgeq->eq_attr[i].gain);  m->Ctrl(EQ_GAIN, val, 2);
		val[0] = i; val[1] = pfc[i];  m->Ctrl(EQ_FREQ, val, 2);
	}

	return 0;
}

static u32 EmptyParamCtrl(IModule* m, void* handle, int &plen)
{
	if(handle == NULL) return 1;

	plen = sizeof(tag_dummy);

	return 0;
}


static u32 Signalgen_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	enum SGItemType{
		SG_MUTE = 0x1,
		SG_TYPE ,
		SG_REQ ,
		SG_GAIN,
	};

	short val[4];
	int channel = val_c[0]&(MAX_INPUT_NUM-1);
	ptag_input pInput = (ptag_input)m->GetModuleParam();

	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);
		}
		pInput->input[channel].type = val[1];
	}
	else if(pID == INPUT_FREQ) {
		val[0] = channel;  val[1] = RESSIGNBIT(val_c[1]);
		m->Ctrl(SG_REQ, val, 2);
		pInput->input[channel].freq = val[1];
	}
	else if(pID == INPUT_LEVEL) {
		val[0] = channel;  val[1] = RESSIGNBIT(val_c[1]);
		m->Ctrl(SG_GAIN, val, 2);
		pInput->input[channel].level = val[1];
	}

	return 0;
}

static u32 Input_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	enum GainID {
		GAIN = 0x1,
		MUTE,
		SENSI,
		PHANTOM,

		PHASE = 9,
		STEP,//-500~+500
	};


	enum PitchID {
		PITCH_BYPASS = 0x1,//
		PITCH_SEMITONES,//
	};


	short val[4];
	int channel = val_c[0]&(MAX_INPUT_NUM-1);
	ptag_input pInput = (ptag_input)m->GetModuleParam();

	if(pID == INPUT_STEP) {
		val[0] = channel;  val[1] = RESSIGNBIT(val_c[1]);
		m->Ctrl(STEP, val, 2);
	}
	else {
		val[0] = channel;  val[1] = RESSIGNBIT(val_c[1]);
		m->Ctrl(pID, val, 2);
	}

	switch(pID){
		case INPUT_GAIN:
			pInput->input[channel].gain = val[1];
		break;
		case INPUT_MUTE:
			pInput->input[channel].mute = val[1]&0x1;;
		break;
		case INPUT_STEP:
			pInput->input[channel].gain += val[1];
		break;
		case INPUT_POL:
			pInput->input[channel].phase = val[1]&0x1;
		break;
		case INPUT_MIN:
			pInput->input[channel].mingain = val[1];
		break;
		case INPUT_MAX:
			pInput->input[channel].maxgain = val[1];
		break;
		default:
		break;
	}

	return 0;
}

static u32 Output_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	enum GainID {
		GAIN = 0x1,
		MUTE,
		SENSI,
		PHANTOM,

		PHASE = 9,
		STEP,
	};

	short val[4];
	int channel = val_c[0]&(MAX_OUTPUT_NUM-1);
	ptag_output poutput = (ptag_output)m->GetModuleParam();

	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);

	switch(pID){
		case OUTPUT_GAIN:
			poutput->output[channel].gain = val[1];
		break;
		case OUTPUT_MUTE:
			poutput->output[channel].mute = val[1]&0x1;
		break;
		case OUTPUT_STEP:
			poutput->output[channel].gain += val[1];
		break;
		case OUTPUT_POL:
			poutput->output[channel].phase = val[1]&0x1;
		break;
		case OUTPUT_MIN:
			poutput->output[channel].mingain = val[1];
		break;
		case OUTPUT_MAX:
			poutput->output[channel].maxgain = val[1];
		break;
		default:
		break;
	}

	return 0;
}

static u32 Mixer_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	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;
}

static u32 Crossover_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	enum CFilterID {
		_BYPASS = 0x1,
		_TYPE,
		_TAPS,
		_FREQ,
		_GAIN,
	};

	short val[4];
	u32 cmd = pID;
	ptag_crossover pCross = (ptag_crossover)m->GetModuleParam();

	if(pID >= XOVER_LOWPASS_BYPASS){
		val[0] = 0;
		val[1] = RESSIGNBIT(val_c[0]);
		cmd = pID - XOVER_LOWPASS_BYPASS +1;
	}
	else{
		val[0] = 1;
		val[1] = RESSIGNBIT(val_c[0]);
	}

	m->Ctrl(cmd, val, 2);

	switch(pID){
		case XOVER_HIGHPASS_BYPASS:
			pCross->highpass.bypass = val[1]&0x1;
			break;
		case XOVER_HIGHPASS_TYPE:
			pCross->highpass.type = val[1];
			break;
		case XOVER_HIGHPASS_FREQ:
			pCross->highpass.freq = val[1];
			break;
		case XOVER_HIGHPASS_SLOPE:
			pCross->highpass.taps = val[1];
			break;
		case XOVER_HIGHPASS_GAIN:
			pCross->highpass.gain = val[1];
			break;
		case XOVER_LOWPASS_BYPASS:
			pCross->lowpass.bypass = val[1]&0x1;
			break;
		case XOVER_LOWPASS_TYPE:
			pCross->lowpass.type = val[1];
			break;
		case XOVER_LOWPASS_FREQ:
			pCross->lowpass.freq = val[1];
			break;
		case XOVER_LOWPASS_SLOPE:
			pCross->lowpass.taps = val[1];
			break;
		case XOVER_LOWPASS_GAIN:
			pCross->lowpass.gain = val[1];
			break;
		default:
			break;
	}

	return 0;
}

static u32 Feedback_Ctrl(IModule* m, u32 pID, s16* val_c)
{
//	enum NHSID{
//		FB_BYPASS = 0x1,
//		FB_PANIC,
//		FB_THRS,
//		FB_FLT_DEPTH,
//		FB_STEP,
//		FB_FLT_Q,
//		FB_RECYCLETIME,
//
//		FB_FLT_FREQ,
//		FB_FLT_GAIN,
//		FB_FLT_TYPE,
//
//		FB_CLEAR,
//		FB_CLEAR_DYNAMIC,
//	};
	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 };
//	short step[4] = {150, 300, 450, 600};
	ptag_feedback p = (ptag_feedback)m->GetModuleParam();

#if 0
	if(pID == FB_STEP){
		val[0] = RESSIGNBIT(step[val_c[0]]);
	}
	else{
		val[0] = RESSIGNBIT(val_c[0]);
	}

	val[1] = RESSIGNBIT(val_c[1]);
#else
	val[0] = RESSIGNBIT(val_c[0]); val[1] = RESSIGNBIT(val_c[1]);
#endif
	m->Ctrl(pID, val, 2);

	switch(pID){
		case FB_BYPASS:
			p->bypass = val[0]&0x1;
		break;
		case FB_PANIC:
			p->panic_threshold = val[0];
		break;
		case FB_FLT_DEPTH:
			p->flt_depth = val[0];
		break;
		case FB_STEP:
			p->flt_step = val[0]&0x3;
		break;
		case FB_FLT_FREQ:
			p->flt_group[val[0]].fc = val[1];
		break;
		case FB_FLT_GAIN:
			p->flt_group[val[0]].gain = val[1];
		break;
		case FB_FLT_TYPE:
			p->flt_group[val[0]].type = val[1];
		break;
		case FB_THRS:
			p->fb_threshold = val[0];
		break;
		case FB_FLT_Q:
			p->bw = val[0];
		break;
		default:
		break;
	}

	return 0;
}

static u32 Automixer_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	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;
}

static u32 Aec_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	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];
	short cmd[12] = {0, BYPASS, NLPLEVEL, 0, 0,0};

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);
	m->Ctrl(cmd[pID], val, 1);

	return 0;
}

static u32 Sysctl_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	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;
}


static u32 Geq_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	enum EQID{
	  EQ_BYPASS_ALL = 0x1,
	  EQ_BYPASS,
	  EQ_FREQ,
	  EQ_GAIN,
	  EQ_QVALUE,
	  EQ_TYPE,
	};

	short val[4];
	short cmd[8] = {0,EQ_BYPASS_ALL, EQ_QVALUE, EQ_GAIN};

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(cmd[pID], val, 2);

	return 0;
}

static u32 Peq_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	short val[4];
	ptag_eq peq = (ptag_eq)m->GetModuleParam();

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(pID, val, 2);

	val[0]&=0x1f;

	switch(pID){
		case EQ_BYPASS_ALL:
			peq->bypass = val[0]&0x1;
			break;
		case EQ_BYPASS:
			peq->eq_attr[val[0]].bypass = val[1]&0x1;
			break;
		case EQ_FREQ:
			peq->eq_attr[val[0]].freq = val[1];
			break;
		case EQ_GAIN:
			peq->eq_attr[val[0]].gain = val[1];
			break;
		case EQ_QVALUE:
			peq->eq_attr[val[0]].q = val[1];
			break;
		case EQ_TYPE:
			peq->eq_attr[val[0]].type = val[1];
			break;
		default:
			break;
	}

	return 0;
}

static u32 Expander_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	short val[4];
	ptag_expander pexpander = (ptag_expander)m->GetModuleParam();

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(pID, val, 2);

	switch(pID){
		case EXPANDER_BYPASS:
			pexpander->bypass = val[0]&0x1;
			break;
		case EXPANDER_THRESHOLD:
			pexpander->threshold = val[0];
			break;
		case EXPANDER_RADIO:
			pexpander->ratio= val[0];
			break;
		case EXPANDER_RELEASE:
			pexpander->release= val[0];
			break;
		case EXPANDER_ATTACK:
			pexpander->attack= val[0];
			break;
		default:
			break;
	}

	return 0;
}

static u32 Compress_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	short val[4];
	ptag_compress pcompressor = (ptag_compress)m->GetModuleParam();

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(pID, val, 2);

	switch(pID){
		case COMPRESS_BYPASS:
			pcompressor->bypass = val[0]&0x1;
			break;
		case COMPRESS_THERSHOLD:
			pcompressor->threshold = val[0];
			break;
		case COMPRESS_RADIO:
			pcompressor->ratio= val[0];
			break;
		case COMPRESS_RELEASE:
			pcompressor->release= val[0];
			break;
		case COMPRESS_ATTACK:
			pcompressor->attack= val[0];
			break;
		case COMPRESS_GAIN:
			pcompressor->gain= val[0];
			break;
		default:
			break;
	}

	return 0;
}

static u32 Agc_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	short val[4];
	ptag_agc pagc = (ptag_agc)m->GetModuleParam();

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(pID, val, 2);

	switch(pID){
		case AGC_BYPASS:
			pagc->bypass = val[0]&0x1;
			break;
		case AGC_THRESHOLD:
			pagc->threshold = val[0];
			break;
		case AGC_TARGET_THRES:
			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;
}

static u32 Delay_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	short val[4];
	ptag_delay pdealy = (ptag_delay)m->GetModuleParam();

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(pID, val, 2);

	switch(pID){
	case DELAY_BYPASS:
		pdealy->bypass = val[0]&0x1;
		break;
	case DELAY_MSEC:
		pdealy->ms  = val[0];
		break;
	case DELAY_USEC:
		pdealy->us = val[0];
		break;
	default:
		break;
	}

	return 0;
}

static u32 General_Ctrl(IModule* m, u32 pID, s16* val_c)
{
	short val[4];

	val[0] = RESSIGNBIT(val_c[0]);
	val[1] = RESSIGNBIT(val_c[1]);

	m->Ctrl(pID, val, 2);

	return 0;
}

ParamCtrl_fn ParamEntry::GetParamEntry()
{
	return param;
}

Ctrl_fn ParamEntry::GetCtrlEntry()
{
	return ctrl;
}

ParamEntry::ParamEntry(ParamCtrl_fn fparam, Ctrl_fn fctrl)
{
	//module_type = type;
	param = fparam;
	ctrl = fctrl;
}

std::map<u32, ParamEntry*> CreateParamCtrl(void)
{
	std::map<u32, ParamEntry*> m;

	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_INPUT, new ParamEntry(InputParamCtrl, Input_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_OUTPUT, new ParamEntry(OutputParamCtrl, Output_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_EQ, new ParamEntry(EqParamCtrl, Peq_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_EXPANDER, new ParamEntry(ExpanderParamCtrl, Expander_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_COMPRESS, new ParamEntry(CompressParamCtrl, Compress_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_LIMIT, new ParamEntry(LimitParamCtrl, Compress_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_MIXER, new ParamEntry(MixerParamCtrl, Mixer_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_DELAY, new ParamEntry(DelayParamCtrl, Delay_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_CROSSOVER, new ParamEntry(CrossoverParamCtrl, Crossover_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_FEEDBACK, new ParamEntry(FeedbackParamCtrl, Feedback_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_AUTOMIXER, new ParamEntry(AutomixerParamCtrl, Automixer_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_AGC, new ParamEntry(AgcParamCtrl, Agc_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_AEC, new ParamEntry(AecParamCtrl, Aec_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_ANS, new ParamEntry(AnsParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_SYSCTL, new ParamEntry(SysctlParamCtrl, Sysctl_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_SHELF, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_ROUTE, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_SELECTOR, new ParamEntry(SelectorParamCtrl, Mixer_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_GATING_AUTOMIXER, new ParamEntry(Gating_automixerParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_DUCKER, new ParamEntry(DuckerParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_SIGNALGEN, new ParamEntry(SignalgenParamCtrl, Signalgen_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_GATING, new ParamEntry(GatingParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_CONTINUNOUS_SPL, new ParamEntry(SplParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_GEQ, new ParamEntry(GeqParamCtrl, Geq_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_GAIN, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_METER, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_PITCH, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_REVERB, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_ECHO, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)PROC_AFC, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)DUMMY_INPUT, new ParamEntry(EmptyParamCtrl, General_Ctrl)));
	m.insert(std::pair<u32, ParamEntry*>((u32)DUMMY_OUTPUT, new ParamEntry(EmptyParamCtrl, General_Ctrl)));


	return m;
}