/*
|
* 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/16]>>(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/16]>>(j&15))&0x1; m->Ctrl(MIXER_SWITCH, val, 3);
|
// dbg_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 DuckerWithMixID {
|
DUCKER_BYPASS = 0x1, //val[0]:0-È¡Ïûbypass,1-ʹÄÜbypass
|
DUCKER_THRESHOLD,//val[0]:ãÐÖµ£¬³ËÒÔ100£¬·¶Î§£º-6000~0
|
DUCKER_DEPTH,//val[0]:Éî¶È£¬³ËÒÔ100£¬·¶Î§£º-7200~0
|
DUCKER_ATTACK,//val[0]:½¨Á¢Ê±¼ä£¬·¶Î§£º1~2000ms
|
DUCKER_HOLD,//val[0]:±£³Öʱ¼ä£¬·¶Î§£º1~10000ms
|
DUCKER_RELEASE,//val[0]:ÊÍ·Åʱ¼ä£¬·¶Î§£º1~60000ms
|
DUCKER_SIDE_GAIN,//val[0]:²àÁ´ÔöÒ棬³ËÒÔ100£¬·¶Î§£º-7200~1200
|
DUCKER_SIDE_MUTE,//val[0]:²àÁ´¾²Òô£¬0-È¡Ïû¾²Òô£¬1-¾²Òô
|
DUCKER_SIDE_MIX,//val[0]:²àÁ´»ìÒô,0-È¡Ïû»ìÒô,1-»ìÒô
|
};
|
|
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);
|
short val[4];
|
ptag_ducker pduck = (ptag_ducker)handle;
|
plen = sizeof(tag_ducker);
|
|
val[0] = RESSIGNBIT(pduck->bypass); m->Ctrl(DUCKER_BYPASS, val, 1);
|
val[0] = RESSIGNBIT(pduck->threshold); m->Ctrl(DUCKER_THRESHOLD, val, 1);
|
val[0] = RESSIGNBIT(pduck->depth); m->Ctrl(DUCKER_DEPTH, val, 1);
|
val[0] = RESSIGNBIT(pduck->attacktime); m->Ctrl(DUCKER_ATTACK, val, 1);
|
val[0] = RESSIGNBIT(pduck->holdtime); m->Ctrl(DUCKER_HOLD, val, 1);
|
val[0] = RESSIGNBIT(pduck->releasetime); m->Ctrl(DUCKER_RELEASE, val, 1);
|
val[0] = RESSIGNBIT(pduck->side_gain); m->Ctrl(DUCKER_SIDE_GAIN, val, 1);
|
val[0] = RESSIGNBIT(pduck->mute); m->Ctrl(DUCKER_SIDE_MUTE, val, 1);
|
|
for (s16 i =0 ;i < input_num_channels; i++) {
|
val[0] = i;
|
val[1] = (pduck->mask[i/16]>>(i&15))&0x1; m->Ctrl(DUCKER_SIDE_MIX, val, 2);
|
}
|
|
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 ContSplWithMixID {
|
SPLMIX_BYPASS = 0x1, //val[0]:0-È¡Ïûbypass,1-bypass
|
SPL_MAX_GAIN,
|
SPL_MIN_GAIN,
|
SPL_SENSE_RATIO,
|
SPL_SPEED,
|
SPL_TRIM,
|
SPL_THR,
|
SPL_DISTANCE,
|
SPL_MIX,
|
};
|
|
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_SPEED, 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] = (pspl->mask[i/16]>>(i&15))&0x1 ; m->Ctrl(SPL_MIX, val, 2);
|
}
|
|
return 0;
|
}
|
|
|
u32 tg_param_convert::GeqParamCtrl(IModule* m, void* handle, int &plen)
|
{
|
enum GEQID{
|
GEQ_BYPASS_ALL = 0x1,//val[0]: 0-È¡Ïûbypass, 1- ʹÄÜbypass
|
GEQ_QVALUE,//val[0]: 1-narrow, 2-normal, 3-wide
|
GEQ_GAIN,//val[0]: ¶ÎÐòºÅ,val[1] : ÔöÒæ,³ËÒÔ100£¬·¶Î§:-4800~2400
|
GEQ_CLEAR,//val[0]: ¸´Î»EQ²ÎÊý
|
};
|
|
if(handle == NULL) return 1;
|
|
int i;
|
short val[4];
|
ptag_geq geq = (ptag_geq)handle;
|
plen = sizeof(tag_geq);
|
|
val[0] = geq->bypass; m->Ctrl(EQ_BYPASS_ALL, val, 1);
|
val[0] = geq->q_index; m->Ctrl(GEQ_QVALUE, val, 1);
|
|
for(i=0 ;i < geq->nsections ;i++) {
|
val[0] = i; val[1] = RESSIGNBIT(geq->eq_attr[i].gain); m->Ctrl(GEQ_GAIN, 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;
|
}
|
