/*
|
* 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 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;
|
|
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]<-7200){
|
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]<-7200){
|
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*1.0f);
|
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[1]>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;
|
// if(handle->bypass){
|
// alg_compress_clr_buf(handle->halg);
|
// }
|
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;
|
}
|
|
#if 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*handle->input_num+ni] = fgain_get_factor(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));
|
handle->gain[no*handle->input_num+ni] = 0;
|
}
|
break;
|
case MIXER_GAIN:
|
handle->gain[no*handle->input_num+ni] = fgain_get_factor(val[1]/100.0f);
|
pmixer->input_gain[no][ni] = val[1];
|
break;
|
default:
|
break;
|
|
}
|
|
return 0;
|
}
|
#else
|
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;
|
default:
|
break;
|
|
}
|
|
return 0;
|
}
|
#endif
|
|
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]<-7200){
|
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]<-7200){
|
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;
|
//alg_afc_set_calibration(handle->halg , !(val[0]&0x1));
|
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);
|
//alg_afc_enhanced_mode_enable(handle->halg ,1);
|
break;
|
case FB_FLT_DEPTH:
|
if(val[0]<100 || val[0]>2400){
|
return -1;
|
}
|
p->flt_depth = val[0];
|
//alg_afc_set_highpass_freq(handle->halg , val[0]);
|
setting =1;
|
break;
|
|
case FB_MODE:
|
p->mode = val[0]&0x3;
|
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_afc_set_highpass_gain(handle->halg , val[0]*0.01/6);
|
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, 2.5 , 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;
|
}
|
|
#if 1
|
int automixer_ctrl(pautomixer_handle handle,int cmd,int *val, int num)
|
{
|
int setting=0 ;//
|
ptag_automixer 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]].master = 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]].threshold = 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]].master
|
, p->channels[val[0]].threshold, p->channels[val[0]].gain/100.f);
|
}
|
return 0;
|
}
|
#else
|
int automixer_ctrl(pautomixer_handle handle,int cmd,int *val, int num)
|
{
|
int setting=0 ;//
|
ptag_automixer p = handle->param_ptr;
|
|
switch(cmd){
|
case AM_BYPASS:
|
handle->bypass = val[0]&0x1;
|
break;
|
case AM_MUTE:
|
alg_pri_automixer_set_mute(handle->halg,val[0]&0x1);
|
break;
|
case AM_GAIN:
|
if(val[0]<-7200 || val[0]>1200){
|
return -1;
|
}
|
alg_pri_automixer_set_gain(handle->halg,val[0]/100.f);
|
break;
|
case AM_SLOPE:
|
if(val[0]<100 || val[0]>600){
|
return -1;
|
}
|
alg_pri_automixer_set_slope(handle->halg,val[0]/100.f);
|
break;
|
case AM_RESPONSE:
|
if(val[0]<5 || val[0]>5000){
|
return -1;
|
}
|
alg_pri_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]].master = 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]<-6000 || val[1]>0){
|
return -1;
|
}
|
p->channels[val[0]].threshold = val[1];
|
setting =1;
|
break;
|
default:
|
break;
|
}
|
|
if(setting){
|
alg_pri_automixer_set_param(handle->halg, val[0], p->channels[val[0]].automatic, p->channels[val[0]].master
|
, p->channels[val[0]].threshold*0.01 , p->channels[val[0]].gain/100.f);
|
}
|
return 0;
|
}
|
#endif
|
|
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)
|
{
|
if(p == NULL) return -1;
|
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)
|
{
|
if(p == NULL) return -1;
|
|
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]&7);
|
alg_ans_set_policy(p->halg, mode);
|
}
|
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]>=-7200 && 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;
|
}
|
|
