/*
 * 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"


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

	short val[4];
	int channel = 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_REQ, val, 2);
	}
	else if(pID == INPUT_LEVEL) {
		val[0] = channel;  val[1] = RESSIGNBIT(val_c[1]);
		m->Ctrl(SG_GAIN, val, 2);
	}

	return 0;
}

u32 tg_param_ctrl::Input_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	enum Input_ID{
		GAIN = 0x1,
		MUTE,
		SENSI,
		PHANTOM,

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

		INPUT_MIN,
		INPUT_MAX,
	};

	short val[4];
	int channel = val_c[0];//&(MAX_INPUT_NUM-1);

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

	return 0;
}

u32 tg_param_ctrl::Gain_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	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)
{
	enum GainID {
		GAIN = 0x1,
		MUTE,
		SENSI,
		PHANTOM,

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

	return 0;
}

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

	return 0;
}

u32 tg_param_ctrl::Feedback_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	enum NHSID{
		FB_BYPASS= 0x1,
		FB_FLT_FREQ,
		FB_FLT_GAIN,
		FB_FLT_Q,
		FB_FLT_TYPE,

		FB_STEP,

		FB_CLEAR,
		FB_PANIC,
		FB_FLT_DEPTH,
		FB_THRS,
	};

	short val[4];
//	short cmd[16] = {FB_BYPASS, FB_FLT_FREQ, FB_FLT_GAIN, FB_FLT_Q, FB_FLT_TYPE, FB_STEP,\
//			FB_CLEAR, FB_PANIC, FB_FLT_DEPTH, FB_THRS, 0, 0 ,0 ,0 ,0 ,0 };

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

	return 0;
}

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

u32 tg_param_ctrl::Reverb_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	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)
{
	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::General_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	short val[4];

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

	m->Ctrl(pID, val, 2);
//	printf("pID:%d v[0]:%d v[1]:%d\n", pID, val[0], val[1]);

	return 0;
}

u32 tg_param_ctrl::Fir_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	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);
	}

	return 0;
}

u32 tg_param_ctrl::Spl_Ctrl(IModule* m, u32 pID, s16* val_c, u32 num)
{
	enum ContinousSPLID {
		SPL_BYPASS = 0x1,
		SPL_MAX_GAIN,
		SPL_MIN_GAIN,
		SPL_SENSE_RATIO = 4,
		SPL_UPSPEED = 5,
		SPL_DOWNSPEED,
		SPL_TRIM,
		SPL_THR,
		SPL_DISTANCE,
	};
	enum ContSplWithMixID {
		SPLMIX_BYPASS = 0x1, //val[0]:0-È¡Ïûbypass,1-bypass
		SPLMIX_MAX_GAIN,
		SPLMIX_MIN_GAIN,
		SPLMIX_SENSE_RATIO,
		SPLMIX_SPEED = 5,
		SPLMIX_TRIM,
		SPLMIX_THR,
		SPLMIX_DISTANCE,
		SPLMIX_MIX,
	};

	s16 val[4];
	val[0] = RESSIGNBIT(val_c[0]), val[0] = RESSIGNBIT(val_c[1]);

	if (pID < 5) {
		General_Ctrl(m, pID, val_c, num);
	}
	else {
		switch (pID) {
			case ContSplWithMixID::SPLMIX_SPEED:
				m->Ctrl(ContinousSPLID::SPL_UPSPEED, val, 1);
				m->Ctrl(ContinousSPLID::SPL_DOWNSPEED, val, 1);
				break;
			case ContSplWithMixID::SPLMIX_TRIM:
				m->Ctrl(ContinousSPLID::SPL_TRIM, val, 1);
				break;
			case ContSplWithMixID::SPLMIX_THR:
				m->Ctrl(ContinousSPLID::SPL_THR, val, 1);
				break;
			case ContSplWithMixID::SPLMIX_DISTANCE:
				m->Ctrl(ContinousSPLID::SPL_DISTANCE, val, 1);
				break;
			default:
				break;
		}
	}
	return 0;
}