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