/*
 * scene.c
 * Description:
 *
 *  Created on: 2014-10-28
 *      Author: Graydon
 *  Modify:
 */
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "IModule.h"
#include "module_def.h"
#include "tg_param_convert.h"
#include "../var_state.h"


u32 tg_param_convert::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;
}

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

		TYPE,
		FREQ,
		LEVEL,
		NAME,
		PHASE,
		STEP,
		LINK,
		CHANNEL_LEVEL,

		INPUT_MIN,
		INPUT_MAX,
	};

	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].level);  m->Ctrl(LEVEL, 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);

		val[1] = RESSIGNBIT(pInput->input[i].type);  m->Ctrl(TYPE, val, 2);
		val[1] = RESSIGNBIT(pInput->input[i].freq);  m->Ctrl(FREQ, val, 2);
		val[1] = RESSIGNBIT(pInput->input[i].level);  m->Ctrl(LEVEL, val, 2);
	}

	return 0;
}

u32 tg_param_convert::GainParamCtrl(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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::MixerParamCtrl(IModule* m, void* handle, int &plen)
{
	u16 input_num_channels, output_num_channels ;
	VarState var = VarState::GetInstance();
	hw_adapter_t* adpater = var.get_hw_adapter();

	adpater->get_channel_num(&input_num_channels, &output_num_channels);

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

	if(handle == NULL) return 1;

	if(m->GetModuleID() >= 320){
		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);
//				printf("oich %d %d= %x %x %x\n", i,j, val[0],val[1],val[2]);
				val[0] = j;  val[1] = i; val[2] = RESSIGNBIT(pmixer->input_gain[i][j]);  m->Ctrl(MIXER_GAIN, val, 3);
			}
		}
	}

	return 0;
}

u32 tg_param_convert::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 + pdelay->us;  m->Ctrl(DELAY_MSEC, val, 1);

	return 0;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::FeedbackParamCtrl(IModule* m, void* handle, int &plen)
{
	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);

	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(pfbc->step);   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;
}

u32 tg_param_convert::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_CHANNEL_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].mute);  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].priority);  m->Ctrl(AM_CHANNEL_PRIORITY, val, 2);
	}

	return 0;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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] = {0,0,0,0};
	ptag_aec paec = (ptag_aec)handle;
	plen = sizeof(tag_aec);

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

	return 0;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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_CHANNEL_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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;
}

u32 tg_param_convert::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;

	u16 input_num_channels, output_num_channels ;
	VarState var = VarState::GetInstance();
	hw_adapter_t* adpater = var.get_hw_adapter();

	adpater->get_channel_num(&input_num_channels, &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;
}


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

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

u32 tg_param_convert::ReverbParamCtrl(IModule* m, void* handle, int &plen)
{
	enum ReverbID{
		REV_BYPASS = 1,
		REV_HPF,
		REV_LPF, //µÍͨϵÊý,0-1, ĬÈÏ0.9
		REV_DRYWET_RATIO,//(¸Éʪ±È): 0-1, ĬÈÏ0.6
		REV_DIFFUSE, //(À©É¢Öµ): 0-1,ĬÈÏ0.75
		REV_OUTGAIN,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_reverb preverb = (ptag_reverb)handle;
	plen = sizeof(tag_reverb);

//	val[0] = RESSIGNBIT(preverb->bypass);  m->Ctrl(REV_BYPASS, val, 1);
//	val[0] = RESSIGNBIT(preverb->hfreq);  m->Ctrl(REV_HPF, val, 1);
//	val[0] = RESSIGNBIT(preverb->lfreq);  m->Ctrl(REV_LPF, val, 1);
//	val[0] = RESSIGNBIT(preverb->drywet_ratio);  m->Ctrl(REV_DRYWET_RATIO, val, 1);
//	val[0] = RESSIGNBIT(preverb->diffuse);  m->Ctrl(REV_DIFFUSE, val, 1);
//	val[0] = RESSIGNBIT(preverb->out_gain);  m->Ctrl(REV_OUTGAIN, val, 1);

	return 0;
}

u32 tg_param_convert::EchoParamCtrl(IModule* m, void* handle, int &plen)
{
	enum EchoID{
		ECHO_BYPASS = 1,
		ECHO_HPF,
		ECHO_LPF,
		ECHO_DELAY,
		ECHO_GAIN,
		ECHO_REDELAY,
		ECHO_OUTGAIN,
	};

	if(handle == NULL) return 1;

	short val[4];
	ptag_echo pecho = (ptag_echo)handle;
	plen = sizeof(tag_echo);

//	val[0] = RESSIGNBIT(pecho->bypass);  m->Ctrl(ECHO_BYPASS, val, 1);
//	val[0] = RESSIGNBIT(pecho->hfreq);  m->Ctrl(ECHO_HPF, val, 1);
//	val[0] = RESSIGNBIT(pecho->lfreq);  m->Ctrl(ECHO_LPF, val, 1);
//	val[0] = RESSIGNBIT(pecho->delay);  m->Ctrl(ECHO_DELAY, val, 1);
//	val[0] = RESSIGNBIT(pecho->gain);  m->Ctrl(ECHO_GAIN, val, 1);
//	val[0] = RESSIGNBIT(pecho->re_delay);  m->Ctrl(ECHO_REDELAY, val, 1);
//	val[0] = RESSIGNBIT(pecho->out_gain);  m->Ctrl(ECHO_OUTGAIN, val, 1);

	return 0;
}

u32 tg_param_convert::FirParamCtrl(IModule* m, void* handle, int &plen)
{
	enum FIRID {
		FIR_BYPASS = 0x1,  ////val[0]: 0-È¡Ïûbypass, 1- ʹÄÜbypass
		FIR_NAME, //ÎÞÓÃ
		FIR_TAPS, //ÎÞÓÃ
		FIR_COEFFS, //val: ·Ö°ü£¬×î´ó³¤¶È1024 float. ÎÞת»»Ö±½Ó¿½±´float.
	};
	if(NULL == handle)	return 1;

	ptag_fir pfir = (ptag_fir)handle;

	plen = sizeof(tag_fir);
	short val[4] = {0};
	val[0] = pfir->bypass;
	int taps = pfir->taps;
	const short *pcoeffs = (const short *)pfir->coeffs;

	m->Ctrl(FIR_BYPASS, val, 1);
	m->Ctrl(FIR_COEFFS, pcoeffs, taps * 2);

	return 0;
}

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

	plen = sizeof(tag_dummy);

	return 0;
}