/*
|
* ctrl.c
|
* Description: ¸÷¸öË㷨ģ¿éµÄ²ÎÊý¿ØÖÆ´úÂë
|
*
|
* Created on: 2014-10-28
|
* Author: Graydon
|
* Modify:
|
*/
|
#include <stdio.h>
|
#include <alg.h>
|
|
#include "drv/global.h"
|
#include "ctrl.h"
|
#include "drv/fft.h"
|
|
|
|
|
int empty_ctrl(void* handle,int cmd,int *val,int num)
|
{
|
return 0;
|
}
|
|
int input_ctrl(pinput_handle handle,int cmd,int *val,int num)
|
{
|
int setting =0;
|
int channel = val[0]&(MAX_INPUT_NUM-1);
|
ptag_input pInput = handle->param_ptr;
|
extern void* netvoice_handle[4];
|
|
switch(cmd){
|
case INPUT_GAIN:
|
if(val[1]>=pInput->input[channel].mingain && val[1]<=pInput->input[channel].maxgain){
|
handle->input[channel].gain = val[1]/100.0f;
|
pInput->input[channel].gain = val[1];
|
}
|
break;
|
case INPUT_LEVEL:
|
pInput->input[channel].level = val[1];
|
setting =1;
|
break;
|
case INPUT_MUTE:
|
handle->input[channel].mute = val[1]&0x1;
|
handle->input[channel].time = FADE_OUT_TIME;
|
if(val[1]&0x1){
|
handle->input[channel].step_gain = (FADE_OUT_GAIN - handle->input[channel].old_gain)/FADE_OUT_TIME;
|
}
|
else{
|
handle->input[channel].step_gain = (handle->input[channel].gain - handle->input[channel].old_gain)/FADE_OUT_TIME;
|
}
|
pInput->input[channel].mute = val[1]&0x1;;
|
break;
|
case INPUT_PHANT:
|
if(val[1]&0x1){
|
handle->input[channel].delay = RATE_SAMPLES*5;
|
}
|
break;
|
case INPUT_SENS:
|
handle->input[channel].delay = RATE_SAMPLES;
|
break;
|
case INPUT_TYPE:{
|
pInput->input[channel].type = val[1];
|
handle->input[channel].type = val[1];
|
setting =1;
|
}
|
break;
|
case INPUT_FREQ:
|
pInput->input[channel].freq = val[1];
|
setting =1;
|
break;
|
case INPUT_STEP:
|
pInput->input[channel].gain += val[1];
|
if(pInput->input[channel].gain>pInput->input[channel].maxgain){
|
pInput->input[channel].gain = pInput->input[channel].maxgain;
|
}
|
if(pInput->input[channel].gain< pInput->input[channel].mingain){
|
pInput->input[channel].gain = pInput->input[channel].mingain;
|
}
|
handle->input[channel].gain = pInput->input[channel].gain/100.0f;
|
break;
|
case INPUT_POL:
|
pInput->input[channel].phase = val[1]&0x1;
|
handle->input[channel].phase = val[1]&0x1;
|
break;
|
case INPUT_MIN:
|
if(val[1]>1200 || val[1]<-8000){
|
return -1;
|
}
|
pInput->input[channel].mingain = val[1];
|
if(pInput->input[channel].gain < pInput->input[channel].mingain){
|
pInput->input[channel].gain = pInput->input[channel].mingain;
|
handle->input[channel].gain = pInput->input[channel].gain*0.01;
|
}
|
break;
|
case INPUT_MAX:
|
if(val[1]>1200 || val[1]<-8000){
|
return -1;
|
}
|
pInput->input[channel].maxgain = val[1];
|
if(pInput->input[channel].gain > pInput->input[channel].maxgain){
|
pInput->input[channel].gain = pInput->input[channel].maxgain;
|
handle->input[channel].gain = pInput->input[channel].gain*0.01;
|
}
|
break;
|
default:
|
break;
|
}
|
if(setting){
|
alg_sg_set_param(handle->input[channel].hgen,pInput->input[channel].freq,pInput->input[channel].type,pInput->input[channel].level/100.f);
|
}
|
return 0;
|
}
|
|
int gain_ctrl(pgain_handle handle,int cmd,int *val,int num)
|
{
|
ptag_gain pgain = handle->param_ptr;
|
switch(cmd){
|
case GAIN_SET:
|
if(val[0]>=-7200 && val[0]<=1200){
|
handle->gain = val[0]*(1.0f/100);
|
pgain->gain = val[0];
|
}
|
break;
|
default:break;
|
}
|
return 0;
|
}
|
|
int meter_ctrl(pmeter_handle handle,int cmd,int *val,int num)
|
{
|
return 0;
|
}
|
|
int delay_ctrl(pdelay_handle handle,int cmd,int *val,int num)
|
{
|
ptag_delay pdealy = (ptag_delay)handle->param_ptr;
|
switch(cmd){
|
case DELAY_BYPASS:
|
handle->bypass = val[0]&0x1;
|
pdealy->bypass = handle->bypass;
|
alg_delay_set_msec(handle->halg,pdealy->ms+pdealy->us*0.001);
|
break;
|
case DELAY_MSEC:
|
if(val[0]<0 || val[0]>2000){
|
return -1;
|
}
|
pdealy->ms = val[0];
|
alg_delay_set_msec(handle->halg,pdealy->ms+pdealy->us*0.001);
|
break;
|
case DELAY_USEC:
|
if(val[0]<0 || val[0]>1000){
|
return -1;
|
}
|
pdealy->us = val[0];
|
alg_delay_set_msec(handle->halg,pdealy->ms+pdealy->us*0.001);
|
break;
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
int eq_ctrl(peq_handle handle,int cmd,int *val,int num)
|
{
|
ptag_eq peq = (ptag_eq)handle->param_ptr;
|
int setting =0;
|
|
val[0]&=0x1f;
|
|
switch(cmd){
|
case EQ_BYPASS_ALL:
|
handle->bypass = val[0]&0x1;
|
peq->bypass = handle->bypass;
|
break;
|
case EQ_BYPASS:
|
peq->eq_attr[val[0]].bypass = val[1]&0x1;
|
setting=1;
|
break;
|
case EQ_FREQ:
|
if(val[1]<0 || val[1]>32000){
|
return -1;
|
}
|
peq->eq_attr[val[0]].freq = val[1];
|
setting=1;
|
break;
|
case EQ_GAIN:
|
if(val[1]<-4800 || val[1]>2400){
|
return -1;
|
}
|
peq->eq_attr[val[0]].gain = val[1];
|
setting=1;
|
break;
|
case EQ_QVALUE:
|
if(val[1]<0 || val[1]>5000){
|
return -1;
|
}
|
peq->eq_attr[val[0]].q = val[1];
|
setting=1;
|
break;
|
case EQ_TYPE:
|
if(val[1]>eq_highshelf || val[1]< eq_lpf){
|
return -1;
|
}
|
peq->eq_attr[val[0]].type = val[1];
|
setting=1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_eq_set_param(handle->halg,val[0], (eq_type_t)peq->eq_attr[val[0]].type, peq->eq_attr[val[0]].bypass
|
,peq->eq_attr[val[0]].freq,peq->eq_attr[val[0]].gain/100.0f,peq->eq_attr[val[0]].q/100.0f);
|
}
|
return 0;
|
}
|
|
int expander_ctrl(pexpander_handle handle,int cmd,int *val,int num)
|
{
|
ptag_expander pexpander = (ptag_expander)handle->param_ptr;
|
int setting = 0;
|
|
switch(cmd){
|
case EXPANDER_BYPASS:
|
handle->bypass = val[0]&0x1;
|
pexpander->bypass = handle->bypass;
|
break;
|
case EXPANDER_THRESHOLD:
|
if(val[0]<-7200 || val[0]>0){
|
return -1;
|
}
|
pexpander->threshold = val[0];
|
setting=1;
|
break;
|
case EXPANDER_RADIO:
|
if(val[0]<100 || val[0]>10000){
|
return -1;
|
}
|
pexpander->ratio= val[0];
|
setting=1;
|
break;
|
case EXPANDER_RELEASE:
|
if(val[0]<1 || val[0]>10000){
|
return -1;
|
}
|
pexpander->release= val[0];
|
setting=1;
|
break;
|
case EXPANDER_ATTACK:
|
if(val[0]<1 || val[0]>10000){
|
return -1;
|
}
|
pexpander->attack= val[0];
|
setting=1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_expander_set_param(handle->halg,pexpander->threshold/100.0f
|
,pexpander->ratio/100.0f,pexpander->attack,pexpander->release);
|
}
|
return 0;
|
}
|
|
int compressor_ctrl(pcompressor_handle handle,int cmd,int *val,int num)
|
{
|
ptag_compress pcompressor = (ptag_compress)handle->param_ptr;
|
int setting = 0;
|
|
switch(cmd){
|
case COMPRESS_BYPASS:
|
handle->bypass = val[0]&0x1;
|
pcompressor->bypass = handle->bypass;
|
break;
|
case COMPRESS_THERSHOLD:
|
if(val[0]<-4800 || val[0]>0){
|
return -1;
|
}
|
pcompressor->threshold = val[0];
|
setting=1;
|
break;
|
case COMPRESS_RADIO:
|
if(val[0]<1 || val[0]>10000){
|
return -1;
|
}
|
pcompressor->ratio= val[0];
|
setting=1;
|
break;
|
case COMPRESS_RELEASE:
|
if(val[0]<1 || val[0]>10000){
|
return -1;
|
}
|
pcompressor->release= val[0];
|
setting=1;
|
break;
|
case COMPRESS_ATTACK:
|
if(val[0]<1 || val[0]>10000){
|
return -1;
|
}
|
pcompressor->attack= val[0];
|
setting=1;
|
break;
|
case COMPRESS_GAIN:
|
if(val[0]<-7200 || val[0]>1200){
|
return -1;
|
}
|
pcompressor->gain= val[0];
|
setting=1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_compress_set_param(handle->halg,pcompressor->threshold/100.0f
|
,pcompressor->ratio/100.0f, pcompressor->attack ,pcompressor->release,pcompressor->gain/100.0f ,0);
|
}
|
return 0;
|
}
|
|
int mixer_ctrl(pmixer_handle handle,int cmd,int *val,int num)
|
{
|
int ni,no;
|
ptag_mixer pmixer = (ptag_mixer)handle->param_ptr;
|
|
ni = val[0]&0xff;
|
no = (val[0]>>8)&0xff;
|
|
if(no>=MAX_MIXER_OUTPUT){
|
return -1;
|
}
|
|
if(ni>=MAX_MIXER_INPUT){
|
return -1;
|
}
|
|
switch(cmd){
|
case MIXER_SWITCH:
|
if(val[1]&0x1){
|
handle->mask[no][ni/16]|= 1<<(ni&15);
|
// handle->gain[no][ni/16] = pmixer->input_gain[no][ni]/100.0f;
|
handle->gain[no][ni] = pmixer->input_gain[no][ni]/100.0f;/////////////////////////////////////////////////
|
|
// handle->step[no*handle->input_num+ni] = (handle->input[channel].gain - handle->input[channel].old_gain)/FADE_OUT_TIME;
|
|
|
}
|
else{
|
handle->mask[no][ni/16]&= ~(1<<(ni&15));
|
}
|
break;
|
case MIXER_GAIN:
|
if(val[1]<-7200 || val[1]>1200){
|
return -1;
|
}
|
//handle->gain[no*handle->input_num+ni] = GF(val[1]/100.0f);
|
pmixer->input_gain[no][ni] = val[1];
|
if((handle->mask[no][ni/16] >> (ni&15))&0x1) {
|
handle->gain[no][ni] = (val[1]/100.0f);
|
}
|
break;
|
case MIXER_DELAY:
|
if(val[1]<0 || val[1]>100){
|
return -1;
|
}
|
// handle->delay[no*handle->input_num+ni] = val[1];
|
//alg_delay_set_msec(handle->delay_ptr[no*handle->input_num+ni] , val[1]);
|
break;
|
default:
|
break;
|
|
}
|
|
return 0;
|
}
|
|
int shelf_ctrl(pshelf_handle handle,int cmd,int *val,int num)
|
{
|
ptag_shelf pshelf = (ptag_shelf)handle->param_ptr;
|
bool high_setting =0 ,low_setting=0;
|
|
switch(cmd){
|
case HIGH_SHELF_BYPASS:
|
pshelf->highshelf.bypass = val[0]&0x1;
|
high_setting =1;
|
break;
|
case HIGH_SHELF_FREQ:
|
if(val[0]<20 || val[0]>20000){
|
return -1;
|
}
|
pshelf->highshelf.freq = val[0];
|
high_setting =1;
|
break;
|
case HIGH_SHELF_QVALUE:
|
if(val[0]>5000 || val[0]<2){
|
return -1;
|
}
|
pshelf->highshelf.q = val[0];
|
high_setting =1;
|
break;
|
|
case HIGH_SHELF_GAIN:
|
if(val[0]>1500 || val[0]<-4500){
|
return -1;
|
}
|
pshelf->highshelf.gain = val[0];
|
high_setting=1;
|
break;
|
|
|
case LOW_SHELF_BYPASS:
|
pshelf->lowshelf.bypass = val[0]&0x1;
|
low_setting=1;
|
break;
|
case LOW_SHELF_FREQ:
|
if(val[0]<20 || val[0]>20000){
|
return -1;
|
}
|
pshelf->lowshelf.freq = val[0];
|
low_setting =1;
|
break;
|
case LOW_SHELF_QVALUE:
|
if(val[0]>5000 || val[0]<2){
|
return -1;
|
}
|
pshelf->lowshelf.q = val[0];
|
low_setting =1;
|
break;
|
case LOW_SHELF_GAIN:
|
if(val[0]>1500 || val[0]<-4500){
|
return -1;
|
}
|
pshelf->lowshelf.gain = val[0];
|
low_setting=1;
|
break;
|
default:
|
break;
|
}
|
|
if(pshelf->lowshelf.bypass && pshelf->highshelf.bypass){
|
handle->bypass =1 ;
|
}
|
else{
|
handle->bypass =0 ;
|
}
|
|
|
|
if(high_setting){
|
alg_eq_set_param(handle->halg,0,eq_highshelf, pshelf->highshelf.bypass,pshelf->highshelf.freq,pshelf->highshelf.gain/100.0f
|
,pshelf->highshelf.q/100.0f);
|
}
|
if(low_setting){
|
alg_eq_set_param(handle->halg,1,eq_lowshelf, pshelf->lowshelf.bypass,pshelf->lowshelf.freq,pshelf->lowshelf.gain/100.0f
|
,pshelf->lowshelf.q/100.0f);
|
}
|
return 0;
|
}
|
|
|
int crossover_ctrl(pcrossover_handle handle,int cmd,int *val,int num)
|
{
|
ptag_crossover pCross = (ptag_crossover)handle->param_ptr;
|
bool high_setting=0,low_setting=0;
|
switch(cmd){
|
case XOVER_HIGHPASS_BYPASS:
|
pCross->highpass.bypass = val[0]&0x1;
|
handle->highbypass = pCross->highpass.bypass;
|
high_setting =1;
|
break;
|
case XOVER_HIGHPASS_TYPE:
|
pCross->highpass.type = val[0];
|
high_setting =1;
|
break;
|
case XOVER_HIGHPASS_FREQ:
|
if(val[0]<20 || val[0]>20000){
|
return -1;
|
}
|
pCross->highpass.freq = val[0];
|
high_setting =1;
|
break;
|
case XOVER_HIGHPASS_ORDER:
|
if(val[0]>48){
|
return -1;
|
}
|
pCross->highpass.taps = val[0];
|
high_setting =1;
|
break;
|
case XOVER_HIGHPASS_GAIN:
|
if(val[0]>1500 || val[0]<-1500){
|
return -1;
|
}
|
pCross->highpass.gain = val[0];
|
high_setting =1;
|
break;
|
|
case XOVER_LOWPASS_BYPASS:
|
pCross->lowpass.bypass = val[0]&0x1;
|
handle->lowbypass=pCross->lowpass.bypass;
|
low_setting=1;
|
break;
|
case XOVER_LOWPASS_TYPE:
|
pCross->lowpass.type = val[0];
|
low_setting=1;
|
break;
|
case XOVER_LOWPASS_FREQ:
|
if(val[0]<20 || val[0]>20000){
|
return -1;
|
}
|
pCross->lowpass.freq = val[0];
|
low_setting=1;
|
break;
|
case XOVER_LOWPASS_ORDER:
|
if(val[0]>48){
|
return -1;
|
}
|
pCross->lowpass.taps = val[0];
|
low_setting=1;
|
break;
|
case XOVER_LOWPASS_GAIN:
|
if(val[0]>1500 || val[0]<-1500){
|
return -1;
|
}
|
pCross->lowpass.gain = val[0];
|
low_setting =1;
|
break;
|
default:
|
break;
|
}
|
|
|
if(low_setting){
|
alg_filter_set_param(handle->hLowalg,pCross->lowpass.freq,pCross->lowpass.taps,(eFilterType)pCross->lowpass.type,pCross->lowpass.gain/100.0f);
|
}
|
if(high_setting){
|
alg_filter_set_param(handle->hHighalg,pCross->highpass.freq,pCross->highpass.taps,(eFilterType)pCross->highpass.type,pCross->highpass.gain/100.0f);
|
}
|
return 0;
|
}
|
|
int output_ctrl(poutput_handle handle,int cmd,int *val,int num)
|
{
|
int channel = val[0]&(MAX_OUTPUT_NUM-1);
|
ptag_output poutput = handle->param_ptr;
|
|
|
switch(cmd){
|
case OUTPUT_GAIN:
|
if(val[1]>=poutput->output[channel].mingain && val[1]<=poutput->output[channel].maxgain){
|
handle->output[channel].gain = val[1]/100.0f;
|
poutput->output[channel].gain = val[1];
|
}
|
break;
|
case OUTPUT_MUTE:
|
handle->output[channel].mute = val[1]&0x1;
|
handle->output[channel].time = FADE_OUT_TIME;
|
if(val[1]&0x1){
|
handle->output[channel].step_gain = (FADE_OUT_GAIN - handle->output[channel].old_gain)/FADE_OUT_TIME;
|
}
|
else{
|
handle->output[channel].step_gain = (handle->output[channel].gain - handle->output[channel].old_gain)/FADE_OUT_TIME;
|
}
|
poutput->output[channel].mute = handle->output[channel].mute;
|
break;
|
case OUTPUT_STEP:{
|
poutput->output[channel].gain += val[1];
|
if(poutput->output[channel].gain>poutput->output[channel].maxgain){
|
poutput->output[channel].gain = poutput->output[channel].maxgain;
|
}
|
if(poutput->output[channel].gain<poutput->output[channel].mingain){
|
poutput->output[channel].gain = poutput->output[channel].mingain;
|
}
|
handle->output[channel].gain = poutput->output[channel].gain/100.0f;
|
}
|
case OUTPUT_POL:
|
poutput->output[channel].phase = val[1]&0x1;
|
handle->output[channel].phase = val[1]&0x1;
|
break;
|
case OUTPUT_MIN:
|
if(val[1]>1200 || val[1]<-8000){
|
return -1;
|
}
|
poutput->output[channel].mingain = val[1];
|
if(poutput->output[channel].gain < poutput->output[channel].mingain){
|
poutput->output[channel].gain = poutput->output[channel].mingain;
|
handle->output[channel].gain = poutput->output[channel].gain*0.01;
|
}
|
break;
|
case OUTPUT_MAX:
|
if(val[1]>1200 || val[1]<-8000){
|
return -1;
|
}
|
|
poutput->output[channel].maxgain = val[1];
|
if(poutput->output[channel].gain > poutput->output[channel].maxgain){
|
poutput->output[channel].gain = poutput->output[channel].maxgain;
|
handle->output[channel].gain = poutput->output[channel].gain*0.01;
|
}
|
|
break;
|
|
default:
|
break;
|
}
|
|
return 0;
|
}
|
|
|
int feedback_ctrl(pfeedback_handle handle,int cmd,int *val, int num)
|
{
|
int setting =0, setting1 =0;
|
ptag_feedback p = handle->param_ptr;
|
|
|
switch(cmd){
|
case FB_BYPASS:
|
handle->bypass = val[0]&0x1;
|
p->bypass = handle->bypass;
|
break;
|
case FB_PANIC:
|
if(val[0]<-3600 || val[0]>0){
|
return -1;
|
}
|
p->panic_threshold = val[0];
|
alg_nhs_set_panic(handle->halg, val[0]*0.01);
|
break;
|
case FB_FLT_DEPTH:
|
if(val[0]<100 || val[0]>2400){
|
return -1;
|
}
|
p->flt_depth = val[0];
|
setting =1;
|
break;
|
|
case FB_STEP:
|
if(val[0]<50 || val[0]>300){
|
return -1;
|
}
|
p->step = val[0];
|
setting =1;
|
break;
|
case FB_CLEAR:
|
alg_nhs_filters_clear(handle->halg);
|
break;
|
|
case FB_FLT_FREQ:
|
p->flt_group[val[0]].fc = val[1];
|
setting1 =1;
|
break;
|
case FB_FLT_GAIN:
|
p->flt_group[val[0]].gain = val[1];
|
setting1 =1;
|
break;
|
case FB_FLT_TYPE:
|
p->flt_group[val[0]].type = val[1];
|
setting1 =1;
|
break;
|
case FB_THRS:
|
p->fb_threshold = val[0];
|
alg_nhs_set_threshold(handle->halg, val[0]*0.01);
|
break;
|
case FB_FLT_Q:
|
p->bw = val[0];
|
setting = 1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_nhs_set_parameters(handle->halg, p->step*0.01 , p->flt_depth*0.01, p->bw*0.01 );
|
}
|
|
if(setting1 ){
|
alg_nhs_filters_set_unit(handle->halg , val[0], p->flt_group[val[0]].type , p->flt_group[val[0]].fc, p->flt_group[val[0]].gain*0.01);
|
}
|
|
return 0;
|
}
|
|
|
int gainsharing_automixer_ctrl(pgainsharing_mixer_handle handle,int cmd,int *val, int num)
|
{
|
int setting=0 ;//
|
ptag_gainsharing_mixer p = handle->param_ptr;
|
|
switch(cmd){
|
case AM_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case AM_MUTE:
|
alg_automixer_set_mute(handle->halg,val[0]&0x1);
|
break;
|
case AM_GAIN:
|
if(val[0]<-7200 || val[0]>1200){
|
return -1;
|
}
|
alg_automixer_set_gain(handle->halg,val[0]/100.f);
|
break;
|
case AM_SLOPE:
|
if(val[0]<100 || val[0]>600){
|
return -1;
|
}
|
alg_automixer_set_slope(handle->halg,val[0]/100.f);
|
break;
|
case AM_RESPONSE:
|
if(val[0]<5 || val[0]>5000){
|
return -1;
|
}
|
alg_automixer_set_response(handle->halg,val[0]);
|
break;
|
case AM_CHANNEL_AUTO:
|
p->channels[val[0]].automatic = val[1]&0x1;
|
setting =1;
|
break;
|
case AM_CHANNEL_MUTE:
|
p->channels[val[0]].mute = val[1]&0x1;
|
setting =1;
|
break;
|
case AM_CHANNEL_GAIN:
|
if(val[1]<-7200 || val[1]>1200){
|
return -1;
|
}
|
p->channels[val[0]].gain = val[1];
|
setting =1;
|
break;
|
case AM_CHANNEL_PRIORITY:
|
if(val[1]<0 || val[1]>10){
|
return -1;
|
}
|
p->channels[val[0]].priority = val[1];
|
setting =1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_automixer_set_param(handle->halg, val[0], p->channels[val[0]].automatic, p->channels[val[0]].mute
|
, p->channels[val[0]].priority , p->channels[val[0]].gain/100.f);
|
}
|
return 0;
|
}
|
|
int fir_ctrl(pcommon_handle handle,int cmd,int *val, int num)
|
{
|
switch(cmd){
|
case FIR_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case FIR_COEFFS:
|
//alg_fir_set_coeffs(handle->halg, val, num);
|
break;
|
default:
|
break;
|
}
|
return 0;
|
}
|
|
int agc_ctrl(pagc_handle handle, int cmd,int *val,int num)
|
{
|
int setting=0 ;
|
ptag_agc pagc = handle->param_ptr;
|
|
switch(cmd){
|
case AGC_BYPASS:
|
handle->bypass = val[0]&0x1;
|
pagc->bypass = handle->bypass;
|
break;
|
case AGC_THRESHOLD:
|
if(val[0]<-9600 || val[0]>-2000){
|
return -1;
|
}
|
pagc->threshold = val[0];
|
setting = 1;
|
break;
|
case AGC_TARGET_THRES:
|
if(val[0]<-4000 || val[0]>0){
|
return -1;
|
}
|
pagc->tar_threshold = val[0];
|
setting = 1;
|
break;
|
case AGC_RATIO:
|
if(val[0]<100 || val[0]>2000){
|
return -1;
|
}
|
pagc->ratio= val[0];
|
setting = 1;
|
break;
|
case AGC_ATTACKTIME:
|
if(val[0] >10000 || val[0]<1){
|
return -1;
|
}
|
pagc->attacktime = val[0];
|
setting = 1;
|
break;
|
case AGC_RELEASETIME:
|
if(val[0] >10000 || val[0]<1){
|
return -1;
|
}
|
pagc->releasetime = val[0];
|
setting = 1;
|
break;
|
default:
|
break;
|
}
|
if(setting ){
|
alg_agc_set_param(handle->halg ,pagc->threshold/100.0f , pagc->tar_threshold/100.0f, pagc->ratio/100.0f
|
,pagc->attacktime , pagc->releasetime);
|
|
}
|
return 0;
|
}
|
|
int aec_ctrl(paec_handle p,int cmd,int *val, int num)
|
{
|
int i;
|
extern void* haec;
|
switch(cmd){
|
case AEC_BYPASS:
|
p->bypass = val[0]&0x1;
|
alg_aec_clr_ulitily(p->halg);
|
//////////////////////////////////////////////
|
if(p->bypass) {
|
haec = 0;
|
}
|
else{
|
haec = p->halg;
|
}
|
/////////////////////////////////////////////
|
break;
|
case AEC_MODE:{
|
aec_mode_t mode = (aec_mode_t)(val[0]&0x3);
|
alg_aec_set_param(p->halg, mode);
|
|
}
|
break;
|
}
|
return 0;
|
}
|
|
int ans_ctrl(pans_handle p,int cmd,int *val, int num)
|
{
|
extern void* hans;
|
switch(cmd){
|
case ANS_BYPASS:
|
p->bypass = val[0]&0x1;
|
//alg_ans_clr_ulitily(p->halg);
|
/////////////////////////////////////////////
|
if(p->bypass) {
|
hans = 0;
|
}
|
else{
|
hans = p->halg;
|
}
|
/////////////////////////////////////////////
|
break;
|
case ANS_MODE:{
|
ans_mode mode = (ans_mode)(val[0]&0x3);
|
alg_ans_set_policy(p->halg, mode);
|
}
|
break;
|
}
|
|
return 0;
|
}
|
|
int afc_ctrl(pafc_handle p,int cmd,int *val, int num)
|
{
|
switch(cmd){
|
case AFC_BYPASS:
|
p->bypass = val[0]&0x1;
|
// alg_afc_set_calibration(p->halg , !(val[0]&0x1));
|
break;
|
case AFC_MODE:{
|
|
}
|
case AFC_GAIN:
|
if(val[0]>1200 || val[0]<-7200){
|
return -1;
|
}
|
//p->gain = val[0]*0.01;
|
|
break;
|
}
|
|
return 0;
|
}
|
|
|
int sysctl_ctrl(psysctl_handle p, int cmd ,int *val ,int num)
|
{
|
int i;
|
|
switch(cmd){
|
case SYSCTL_GAIN:
|
if(val[0]>=-8000 && val[0]<=1200){
|
p->gain = val[0]*(1.0f/100);
|
}
|
break;
|
case SYSCTL_MUTE:
|
if(val[0]&0x1){
|
for(i=0;i< p->input_num ;i++){
|
p->step_gain[i] = (FADE_OUT_GAIN - p->old_gain[i])/FADE_OUT_TIME;
|
}
|
}
|
else{
|
for(i=0;i< p->input_num ;i++){
|
p->step_gain[i] = (p->gain - p->old_gain[i])/FADE_OUT_TIME;
|
}
|
}
|
p->mute = val[0]&0x1;
|
p->time = FADE_OUT_TIME*p->input_num;
|
break;
|
default:break;
|
}
|
return 0;
|
}
|
|
int selector_ctrl(pselector_handle handle, int cmd ,int *val ,int num)
|
{
|
int ni,no;
|
ni = val[0]&0xff;
|
no = (val[0]>>8)&0xff;
|
|
if(no>=MAX_MIXER_OUTPUT){
|
return -1;
|
}
|
|
if(ni>=MAX_MIXER_INPUT){
|
return -1;
|
}
|
|
switch(cmd){
|
case MIXER_SWITCH:
|
if(val[1]&0x1){
|
handle->mask[no][ni/16]|= 1<<(ni&15);
|
}
|
else{
|
handle->mask[no][ni/16]&= ~(1<<(ni&15));
|
}
|
break;
|
default:
|
break;
|
|
}
|
|
return 0;
|
}
|
|
|
|
int gating_automixer_ctrl(pgating_mixer_handle handle,int cmd,int *val, int num)
|
{
|
int master_setting =0;
|
int setting = 0;
|
ptag_gating_mixer p = handle->param_ptr;
|
int def_mic = 0;
|
|
switch(cmd){
|
case AM_GATE_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case AM_GATE_MUTE:
|
alg_gating_automixer_set_mute(handle->halg ,val[0]&0x1);
|
break;
|
case AM_GATE_GAIN:
|
if(val[0]<-7200 || val[0]>1200){
|
return -1;
|
}
|
alg_gating_automixer_set_gain(handle->halg ,val[0]*0.01);
|
break;
|
case AM_GATE_LAST_ON:
|
alg_gating_automixer_set_last_on(handle->halg ,val[0]&0x1);
|
break;
|
|
case AM_GATE_NOISE_THR:
|
if(val[0]<-9600 || val[0]>-2400){
|
return -1;
|
}
|
p->noise_thr = val[0];
|
master_setting = 1;
|
break;
|
case AM_GATE_HOLD_TIME:
|
if(val[0]<100 || val[0]>5000){
|
return -1;
|
}
|
p->holdtime = val[0];
|
master_setting = 1;
|
break;
|
case AM_GATE_OFF_GAIN:
|
if(val[0]<-9000 || val[0]>-1000){
|
return -1;
|
}
|
p->offgain = val[0];
|
master_setting = 1;
|
break;
|
case AM_GATE_SENSITIVITY:
|
if(val[0]<300 || val[0]>3000){
|
return -1;
|
}
|
p->sensitivity = val[0];
|
master_setting = 1;
|
break;
|
case AM_GATE_NOM_ATTEN:
|
if(val[0]<0 || val[0]>600){
|
return -1;
|
}
|
p->nom_atten = val[0];
|
master_setting = 1;
|
break;
|
case AM_GATE_NOM_NUM:
|
if(val[0]<0 || val[0]>=AUTOMIXER_CHANNEL_NUM){
|
return -1;
|
}
|
p->nom_num = val[0];
|
master_setting = 1;
|
break;
|
case AM_GATE_CHANNEL_AUTO:
|
p->channels[val[0]].automatic = val[1]&0x1;
|
setting = 1;
|
break;
|
case AM_GATE_CHANNEL_MUTE:
|
p->channels[val[0]].mute = val[1]&0x1;
|
setting = 1;
|
break;
|
case AM_GATE_CHANNEL_GAIN:
|
if(val[1]<-8000 || val[1]>1200){
|
return -1;
|
}
|
p->channels[val[0]].gain = val[1];
|
setting = 1;
|
break;
|
case AM_GATE_CHANNEL_PRIORITY:
|
if(val[1]<0 || val[1]>10){
|
return -1;
|
}
|
p->channels[val[0]].priority = val[1];
|
setting = 1;
|
break;
|
case AM_GATE_CHANNEL_DEF:
|
p->channels[val[0]].def = val[1]&0x1;
|
setting = 1;
|
break;
|
default:
|
break;
|
}
|
|
if(master_setting){
|
alg_gating_automixer_set_master_param(handle->halg ,p->holdtime, p->offgain*0.01,p->noise_thr*0.01, p->sensitivity*0.01, p->nom_atten*0.01, p->nom_num);
|
}
|
|
if(setting){
|
alg_gating_automixer_set_param(handle->halg, val[0] ,p->channels[val[0]].automatic,p->channels[val[0]].mute
|
,p->channels[val[0]].priority, p->channels[val[0]].gain*0.01, p->channels[val[0]].def);
|
}
|
|
return 0;
|
}
|
|
int spl_ctrl(pspl_handle handle,int cmd,int *val, int num)
|
{
|
int setting =0;
|
ptag_spl p = handle->param_ptr;
|
|
switch(cmd){
|
case SPL_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case SPL_MAX_GAIN:
|
if(val[0]>2000 || val[0]<0){
|
return -1;
|
}
|
p->maxgain = val[0];
|
setting = 1;
|
break;
|
case SPL_MIN_GAIN:
|
if(val[0]>0 || val[0]<-3000){
|
return -1;
|
}
|
p->mingain = val[0];
|
setting = 1;
|
break;
|
case SPL_SENSE_RATIO:
|
if(val[0]<50 || val[0]>150){
|
return -1;
|
}
|
p->sense_ratio = val[0];
|
|
setting = 1;
|
break;
|
case SPL_SPEED:
|
if(val[0]<500 || val[0]>60000){
|
return -1;
|
}
|
p->speed = val[0];
|
|
setting = 1;
|
break;
|
case SPL_TRIM:
|
if(val[0]<-1000 || val[0]>1000){
|
return -1;
|
}
|
p->trim = val[0];
|
setting = 1;
|
break;
|
case SPL_THR:
|
if(val[0]<-7200 || val[0]>-2400){
|
return -1;
|
}
|
p->noise_thr = val[0];
|
setting =1;
|
break;
|
case SPL_DISTANCE:
|
if(val[0]<0 || val[0]>1500){
|
return -1;
|
}
|
p->distance = val[0];
|
alg_spl_continuous_set_distance(handle->halg , p->distance * 0.01);
|
break;
|
case SPL_MIX:
|
val[0] &= MAX_INPUT_NUM -1;
|
if(val[1]&0x1){
|
handle->mask[val[0]/16] |= (1<<(val[0]&15));
|
}
|
else{
|
handle->mask[val[0]/16] &= ~(1<<(val[0]&15));
|
}
|
setting =1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_spl_continuous_set_parameters(handle->halg ,p->noise_thr*0.01, p->maxgain*0.01 ,p->mingain*0.01 , p->sense_ratio*0.01, p->speed, p->trim*0.01);
|
}
|
|
return 0;
|
|
}
|
|
int gate_ctrl(pgate_handle handle,int cmd,int *val, int num)
|
{
|
int setting =0;
|
ptag_gate p = handle->param_ptr;
|
|
switch(cmd){
|
case GATE_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case GATE_THRESHOLD:
|
if(val[0]<-4800 || val[0]>0){
|
return -1;
|
}
|
p->threshold = val[0];
|
setting =1;
|
break;
|
case GATE_DEPTH:
|
if(val[0]<-7200 || val[0]>0){
|
return -1;
|
}
|
p->depth = val[0];
|
setting =1;
|
break;
|
case GATE_HOLDTIME:
|
if(val[0]<5 || val[0]>10000){
|
return -1;
|
}
|
p->holdtime = val[0];
|
setting =1;
|
break;
|
case GATE_ATTACK:
|
if(val[0]<1 || val[0]>1000){
|
return -1;
|
}
|
p->attacktime = val[0];
|
setting =1;
|
break;
|
case GATE_RELEASE:
|
if(val[0]<5 || val[0]>10000){
|
return -1;
|
}
|
p->releasetime = val[0];
|
setting =1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_gate_set_param(handle->halg ,p->threshold*0.01 ,p->holdtime, p->depth*0.01, p->releasetime, p->attacktime );
|
}
|
return 0;
|
}
|
|
#if 1
|
int ducker_ctrl(pducker_handle handle,int cmd,int *val, int num)
|
{
|
int setting =0;
|
ptag_ducker p = handle->param_ptr;
|
|
switch(cmd){
|
case DUCKER_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case DUCKER_THRESHOLD:
|
if(val[0]<-6000 || val[0]>0){
|
return -1;
|
}
|
p->threshold = val[0];
|
alg_ducker_set_threshold(handle->halg, p->threshold*0.01);
|
// setting =1;
|
break;
|
case DUCKER_DEPTH:
|
if(val[0]<-7200 || val[0]>0){
|
return -1;
|
}
|
p->depth = val[0];
|
alg_ducker_set_depth(handle->halg, p->depth*0.01);
|
// setting =1;
|
break;
|
case DUCKER_ATTACK:
|
if(val[0]<10 || val[0]>500){
|
return -1;
|
}
|
p->attacktime = val[0];
|
alg_ducker_set_attack_time(handle->halg, p->attacktime);
|
// setting =1;
|
break;
|
case DUCKER_HOLD:
|
if(val[0]<10 || val[0]>10000){
|
return -1;
|
}
|
p->holdtime = val[0];
|
alg_ducker_set_hold_time(handle->halg, p->holdtime);
|
// setting =1;
|
break;
|
case DUCKER_RELEASE:
|
if(val[0]<10 || (unsigned short)val[1]>60000){
|
return -1;
|
}
|
p->releasetime = val[0];
|
alg_ducker_set_release_time(handle->halg, p->releasetime);
|
// setting =1;
|
break;
|
case DUCKER_SIDE_GAIN:
|
if(val[0]<-7200 || val[0]>1200){
|
return -1;
|
}
|
p->side_gain = val[0];
|
alg_ducker_set_side_gain(handle->halg, p->side_gain*0.01);
|
//setting =1;
|
break;
|
case DUCKER_SIDE_MUTE:
|
p->mute = val[0]&0x1;
|
alg_ducker_set_side_mute(handle->halg, p->mute);
|
//setting =1;
|
break;
|
case DUCKER_MIX:
|
val[0] &= MAX_INPUT_NUM -1;
|
if(val[1]&0x1){
|
handle->mask[val[0]/16] |= (1<<(val[0]&15));
|
}
|
else{
|
handle->mask[val[0]/16] &= ~(1<<(val[0]&15));
|
}
|
break;
|
default:
|
break;
|
}
|
|
// if(setting){
|
// alg_ducker_set_parameters(handle->halg ,p->threshold*0.01,p->depth*0.01,p->attacktime
|
// ,p->releasetime,p->holdtime,p->mute, p->side_gain*0.01);
|
// }
|
|
return 0;
|
}
|
#else
|
int ducker_ctrl(pducker_handle handle,int cmd,int *val, int num)
|
{
|
int setting =0;
|
ptag_ducker p = handle->param_ptr;
|
|
switch(cmd){
|
case DUCKER_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case DUCKER_THRESHOLD:
|
if(val[0]<-6000 || val[0]>0){
|
return -1;
|
}
|
p->threshold = val[0];
|
setting =1;
|
break;
|
case DUCKER_DEPTH:
|
if(val[0]<-7200 || val[0]>0){
|
return -1;
|
}
|
p->depth = val[0];
|
setting =1;
|
break;
|
case DUCKER_ATTACK:
|
if(val[0]<10 || val[0]>500){
|
return -1;
|
}
|
p->attacktime = val[0];
|
setting =1;
|
break;
|
case DUCKER_HOLD:
|
if(val[0]<10 || val[0]>10000){
|
return -1;
|
}
|
p->holdtime = val[0];
|
setting =1;
|
break;
|
case DUCKER_RELEASE:
|
if(val[0]<10 || (unsigned short)val[1]>60000){
|
return -1;
|
}
|
p->releasetime = val[0];
|
setting =1;
|
break;
|
case DUCKER_SIDE_GAIN:
|
if(val[0]<-7200 || val[0]>1200){
|
return -1;
|
}
|
p->side_gain = val[0];
|
setting =1;
|
break;
|
case DUCKER_SIDE_MUTE:
|
p->mute = val[0]&0x1;
|
setting =1;
|
break;
|
case DUCKER_MIX:
|
val[0] &= MAX_INPUT_NUM -1;
|
if(val[1]&0x1){
|
handle->mask[val[0]/16] |= (1<<(val[0]&15));
|
}
|
else{
|
handle->mask[val[0]/16] &= ~(1<<(val[0]&15));
|
}
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_ducker_set_parameters(handle->halg ,p->threshold*0.01,p->depth*0.01,p->attacktime
|
,p->releasetime,p->holdtime,p->mute, p->side_gain*0.01);
|
}
|
|
return 0;
|
}
|
#endif
|
|
int reverb_ctrl(preverb_handle handle, int cmd ,int *val ,int num)
|
{
|
return 0;
|
}
|
|
int echo_ctrl(pecho_handle handle, int cmd , int* val , int num)
|
{
|
return 0;
|
}
|
|
int geq_ctrl(pgeq_handle handle, int cmd ,int *val ,int num)
|
{
|
ptag_geq p = handle->param_ptr;
|
float q = alg_geq_get_q(handle->halg, p->nsections, p->q);
|
|
switch(cmd){
|
case GEQ_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case GEQ_Q:
|
if(val[0]<1 || val[1]>3){
|
return -1;
|
}
|
p->q = val[0];
|
break;
|
case GEQ_GAIN:
|
if(val[0] > 31){
|
return -1;
|
}
|
if(val[1]>2400 || val[1]<-2400){
|
return -1;
|
}
|
//p->eq_attr[val[0]].gain = val[1];
|
|
alg_eq_set_param(handle->halg ,val[0], eq_geq, 0, 0, val[1]*0.01 ,q);
|
break;
|
}
|
|
return 0;
|
}
|
