/*
|
* scene.c
|
* Description:
|
*
|
* Created on: 2014-10-28
|
* Author: Graydon
|
* Modify:
|
*/
|
#include <stdio.h>
|
#include <assert.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <alg.h>
|
#include "drv/global.h"
|
#include "drv/hmem.h"
|
#include "scene.h"
|
#include "drv/fft.h"
|
|
static short level_buf[1024];
|
static int nlevels=0;
|
#define LEVEL_MALLOC(n) level_buf+nlevels;nlevels+=n
|
|
#define AEC_MEM1 (void*)0x000c3000
|
#define AEC_MEM2 (void*)0x000c5000
|
#define AEC_SMALES 32000
|
#define AEC_TAIL 256
|
|
void* hafc=0;
|
void* haec=0;
|
void* hans=0;
|
|
//alg_asy_handle alg= {0};
|
|
int GetLevelPtr(short** ptr)
|
{
|
|
*ptr = level_buf;
|
|
return nlevels;
|
}
|
|
void LevelEmpty()
|
{
|
int i;
|
int n = sizeof(level_buf)/sizeof(short);
|
//Meter* m = (Meter*)level_buf;
|
|
hafc =0;
|
hans =0;
|
haec =0;
|
|
nlevels = 0;
|
|
//for(i=0;i<n;i++){
|
// level_buf[i] = -12000;
|
//}
|
|
// for(i=0;i<sizeof(m->feedback_meter);i+=2){
|
// m->feedback_meter[i] = 20;
|
// m->feedback_meter[i+1] = 0;
|
// }
|
}
|
|
int str_delim(const char* str, unsigned int number[])
|
{
|
char pstr[32];
|
char * ptr;
|
|
int i = 0;
|
|
strcpy(pstr, str);
|
ptr = strtok(pstr, "|");
|
|
if (strcmp(ptr, str) == 0) {
|
int start, end;
|
ptr = strtok(pstr, "-");
|
start = atoi(ptr);
|
|
ptr = strtok(NULL, "-");
|
end = atoi(ptr);
|
while (start<=end)
|
{
|
number[i++] = start++;
|
}
|
return i;
|
}
|
else
|
{
|
while (ptr)
|
{
|
number[i++] = atoi(ptr);
|
ptr = strtok(NULL, "|");
|
}
|
return i;
|
}
|
}
|
|
void normalize(short* ptr,int size)
|
{
|
int i;
|
for(i=0;i<size;i++){
|
ptr[i]=NORMALIZE(ptr[i]);
|
}
|
}
|
|
void* input_create(ptag_input pInput,char* inport_str,char* outport_str)
|
{
|
int i;
|
pinput_handle handle = mymalloc(SRAM_AUTO , sizeof(input_handle));
|
assert(handle!=0);
|
|
normalize((short*)pInput,sizeof(tag_input));
|
memset(handle,0,sizeof(input_handle));
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
for(i=0;i<handle->input_num;i++){
|
if(pInput->input[i].gain>1200 || pInput->input[i].gain<-7200){
|
pInput->input[i].gain = 0;
|
}
|
handle->input[i].gain= pInput->input[i].gain/100.0f;
|
handle->input[i].old_gain = -48 ;
|
|
handle->input[i].time = FADE_OUT_TIME;
|
handle->input[i].step_gain = (handle->input[i].gain - handle->input[i].old_gain)/FADE_OUT_TIME;
|
|
handle->input[i].mute = pInput->input[i].mute&0x1;
|
handle->input[i].type = pInput->input[i].type&0x3;
|
handle->input[i].phase = pInput->input[i].phase&0x1;
|
|
if(pInput->input[i].phant){
|
handle->input[i].delay = RATE_SAMPLES*5;
|
}
|
|
// handle->input[i].hExpander = alg_expander_create(RATE_SAMPLES,NUM_SAMPLES);
|
// alg_expander_set_param(handle->input[i].hExpander, -72.0, 1.2, 1,1);
|
|
handle->input[i].hgen = alg_sg_create(RATE_SAMPLES,NUM_SAMPLES);
|
alg_sg_set_param(handle->input[i].hgen,pInput->input[i].freq,handle->input[i].type,pInput->input[i].level/100.0f);
|
}
|
|
|
handle->param_ptr = pInput;
|
return handle;
|
}
|
|
void* output_create(ptag_output pOutput, char* inport_str, char* outport_str)
|
{
|
|
int i;
|
poutput_handle handle = mymalloc(SRAM_AUTO ,sizeof(output_handle));
|
assert(handle!=0);
|
|
|
normalize((short*)pOutput,sizeof(tag_output));
|
memset(handle,0,sizeof(output_handle));
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
for (i=0;i<handle->output_num;i++){
|
if(pOutput->output[i].gain>1200 || pOutput->output[i].gain<-7200){
|
pOutput->output[i].gain = 0;
|
}
|
handle->output[i].mute = pOutput->output[i].mute;
|
handle->output[i].gain = pOutput->output[i].gain/100.0f;
|
handle->output[i].old_gain = -48 ;
|
handle->output[i].time = FADE_OUT_TIME;
|
handle->output[i].step_gain = (handle->output[i].gain - handle->output[i].old_gain)/FADE_OUT_TIME;
|
handle->output[i].phase = pOutput->output[i].phase&0x1;
|
}
|
|
|
handle->param_ptr = pOutput;
|
|
return handle;
|
}
|
|
void* delay_create( ptag_delay pDelay, char* inport_str, char* outport_str)
|
{
|
pdelay_handle handle = mymalloc(SRAM_AUTO ,sizeof(delay_handle));
|
assert(handle!=0);
|
|
normalize((short*)pDelay,sizeof(tag_delay));
|
|
pDelay->bypass&=0x1;
|
if(pDelay->ms>MAX_DELAY_MSEC){
|
pDelay->ms=1;
|
}
|
if(pDelay->us > 999) {
|
pDelay->us= 0;
|
}
|
|
handle->bypass = pDelay->bypass&0x1;
|
handle->halg = alg_delay_create(MAX_DELAY_MSEC,RATE_SAMPLES,NUM_SAMPLES);
|
alg_delay_set_msec(handle->halg,pDelay->ms+pDelay->us*0.001);
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pDelay;
|
|
|
return handle;
|
}
|
|
void* shelf_create(ptag_shelf pshelf,char* inport_str, char* outport_str)
|
{
|
pshelf_handle handle = mymalloc(SRAM_AUTO ,sizeof(eq_handle));
|
assert(handle!=NULL);
|
|
normalize((short*)pshelf,sizeof(tag_shelf));
|
|
if(pshelf->lowshelf.freq>20000 || pshelf->lowshelf.freq<20){
|
pshelf->lowshelf.freq = 20;
|
}
|
if(pshelf->lowshelf.gain>1500 || pshelf->lowshelf.gain<-4500){
|
pshelf->lowshelf.gain = 0;
|
}
|
if(pshelf->lowshelf.q>5000 || pshelf->lowshelf.q<2){
|
pshelf->lowshelf.q = 71;
|
}
|
if(pshelf->highshelf.freq>20000 || pshelf->highshelf.freq<20){
|
pshelf->highshelf.freq = 20;
|
}
|
if(pshelf->highshelf.gain>1500 || pshelf->highshelf.gain<-4500){
|
pshelf->highshelf.gain = 0;
|
}
|
if(pshelf->highshelf.q>5000 || pshelf->highshelf.q<2){
|
pshelf->highshelf.q = 71;
|
}
|
|
pshelf->lowshelf.bypass &= 0x1;
|
pshelf->highshelf.bypass &= 0x1;
|
|
if(pshelf->lowshelf.bypass && pshelf->highshelf.bypass){
|
handle->bypass =1 ;
|
}
|
else{
|
handle->bypass =0 ;
|
}
|
|
handle->halg = alg_eq_create(RATE_SAMPLES,NUM_SAMPLES,2);
|
|
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);
|
|
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);
|
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pshelf;
|
|
|
return handle;
|
}
|
|
void* eq_create(ptag_eq pEQ, char* inport_str, char* outport_str)
|
{
|
int i;
|
|
peq_handle handle = mymalloc(SRAM_AUTO ,sizeof(eq_handle));
|
assert(handle!=NULL);
|
|
normalize((short*)pEQ,sizeof(tag_eq));
|
|
if(pEQ->nsection>MAX_EQ_SECTION){
|
pEQ->nsection = MAX_EQ_SECTION;
|
}
|
for(i=0;i<pEQ->nsection;i++){
|
pEQ->eq_attr[i].bypass&=0x1;
|
if(pEQ->eq_attr[i].freq>20000 || pEQ->eq_attr[i].freq<20){
|
pEQ->eq_attr[i].freq = 200;
|
}
|
if(pEQ->eq_attr[i].gain<-4800 || pEQ->eq_attr[i].gain>2400){
|
pEQ->eq_attr[i].gain = 0;
|
}
|
if(pEQ->eq_attr[i].q<=0 || pEQ->eq_attr[i].q>5000){
|
pEQ->eq_attr[i].q = 100;
|
}
|
if(pEQ->eq_attr[i].type> (int)eq_highshelf ){
|
pEQ->eq_attr[i].type = (int)eq_peaking_eq;
|
}
|
}
|
|
handle->bypass = pEQ->bypass&0x1;
|
|
handle->halg = alg_eq_create(RATE_SAMPLES,NUM_SAMPLES,pEQ->nsection);
|
for(i=0;i<pEQ->nsection;i++){
|
alg_eq_set_param(handle->halg,i,(eq_type_t)pEQ->eq_attr[i].type, pEQ->eq_attr[i].bypass,pEQ->eq_attr[i].freq,pEQ->eq_attr[i].gain/100.0f
|
,pEQ->eq_attr[i].q/100.0f);
|
}
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pEQ;
|
|
|
return handle;
|
}
|
|
void* expander_create(ptag_expander pExpander, char* inport_str, char* outport_str)
|
{
|
pexpander_handle handle = mymalloc(SRAM_AUTO ,sizeof(expander_handle));
|
assert(handle!=0);
|
|
normalize((short*)pExpander,sizeof(tag_expander));
|
|
if(pExpander->threshold>0 || pExpander->threshold<-7200){
|
pExpander->threshold = -4800;
|
}
|
if(pExpander->ratio>10000|| pExpander->ratio<100){
|
pExpander->ratio = 100;
|
}
|
if(pExpander->attack>10000){
|
pExpander->attack = 1;
|
}
|
if(pExpander->release>10000){
|
pExpander->release = 1;
|
}
|
|
handle->bypass = pExpander->bypass;
|
handle->halg = alg_expander_create(RATE_SAMPLES,NUM_SAMPLES);
|
alg_expander_set_param(handle->halg, pExpander->threshold/100.0f, pExpander->ratio/100.0f, pExpander->attack,pExpander->release);
|
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pExpander;
|
handle->level = LEVEL_MALLOC(1);
|
|
return handle;
|
}
|
|
void* compressor_create(ptag_compress pcompress, char* inport_str, char* outport_str)
|
{
|
|
pcompressor_handle handle = mymalloc(SRAM_AUTO ,sizeof(compressor_handle));
|
assert(handle!=0);
|
|
|
normalize((short*)pcompress,sizeof(tag_compress));
|
if(pcompress->threshold>0 || pcompress->threshold<-4800){
|
pcompress->threshold = -4800;
|
}
|
if(pcompress->ratio>10000 || pcompress->ratio<100){
|
pcompress->ratio = 100;
|
}
|
if(pcompress->attack>10000){
|
pcompress->attack = 1;
|
}
|
if(pcompress->release>10000){
|
pcompress->release = 1;
|
}
|
if(pcompress->gain>1200 || pcompress->gain<-7200){
|
pcompress->gain = 0;
|
}
|
handle->bypass = pcompress->bypass;
|
handle->halg = alg_compress_create(RATE_SAMPLES,NUM_SAMPLES,compresser_peak);
|
alg_compress_set_param(handle->halg, pcompress->threshold/100.0f, pcompress->ratio/100.0f,pcompress->attack,pcompress->release,pcompress->gain/100.0f,0 );
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pcompress;
|
handle->level = LEVEL_MALLOC(2);
|
|
return handle;
|
}
|
|
#if 0
|
void* mixer_create(ptag_mixer pMixer, char* inport_str, char* outport_str)
|
{
|
int i,j;
|
|
pmixer_handle handle = mymalloc(SRAM_AUTO ,sizeof(mixer_handle));
|
assert(handle!=0);
|
|
normalize((short*)pMixer,sizeof(tag_mixer));
|
memset(handle,0,sizeof(mixer_handle));
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->gain= mymalloc(SRAM_AUTO ,handle->output_num*handle->input_num);
|
handle->step = mymalloc(SRAM_AUTO ,handle->output_num*handle->input_num);
|
|
for (i=0;i<handle->output_num ;i ++){
|
for(j=0;j<handle->input_num;j++){
|
if((pMixer->input_mask[i][j/16]>>(j&15))&0x1){
|
handle->gain[i*handle->input_num+j] = fgain_get_factor(pMixer->input_gain[i][j]/100.0f);
|
handle->step[i*handle->input_num+j] = handle->gain[i*handle->input_num+j] ;
|
}
|
else{
|
handle->gain[i*handle->input_num+j] = 0;
|
handle->step[i*handle->input_num+j] = 0;
|
}
|
|
}
|
handle->weight[i] = 1.0f;
|
}
|
//memcpy(handle->mask,pMixer->input_mask,sizeof(pMixer->input_mask));
|
|
handle->param_ptr = pMixer;
|
|
|
return handle;
|
}
|
#else
|
void* mixer_create(ptag_mixer pMixer, char* inport_str, char* outport_str)
|
{
|
int i,j;
|
|
pmixer_handle handle = mymalloc(SRAM_AUTO ,sizeof(mixer_handle));
|
assert(handle!=0);
|
|
normalize((short*)pMixer,sizeof(tag_mixer));
|
memset(handle,0,sizeof(mixer_handle));
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
for (i=0;i<handle->output_num ;i ++){
|
for(j=0;j<handle->input_num;j++){
|
handle->gain[i][j] = pMixer->input_gain[i][j]*0.01f;
|
}
|
}
|
memcpy(handle->mask,pMixer->input_mask,sizeof(pMixer->input_mask));
|
|
handle->param_ptr = pMixer;
|
|
|
return handle;
|
}
|
#endif
|
|
void* crossover_create(ptag_crossover pCross, char* inport_str, char* outport_str)
|
{
|
pcrossover_handle handle = mymalloc(SRAM_AUTO ,sizeof(crossover_handle));
|
assert(handle!=0);
|
|
|
normalize((short*)pCross,sizeof(tag_crossover));
|
|
if(pCross->highpass.freq>20000 || pCross->highpass.freq<20){
|
pCross->highpass.freq = 20;
|
}
|
if(pCross->highpass.taps>48 || pCross->highpass.taps<6){
|
pCross->highpass.taps = 6;
|
}
|
if(pCross->lowpass.freq>20000 || pCross->lowpass.freq<20){
|
pCross->highpass.freq = 20;
|
}
|
if(pCross->lowpass.taps>48 || pCross->lowpass.taps<6){
|
pCross->highpass.taps = 6;
|
}
|
if(pCross->lowpass.gain>1500 || pCross->lowpass.gain<-1500){
|
pCross->lowpass.gain = 0;
|
}
|
if(pCross->highpass.gain>1500 || pCross->highpass.gain<-1500){
|
pCross->highpass.gain = 0;
|
}
|
handle->lowbypass = pCross->lowpass.bypass&0x1;
|
handle->highbypass = pCross->highpass.bypass&0x1;
|
|
handle->hLowalg = alg_filter_create(RATE_SAMPLES,NUM_SAMPLES,bqLowPass);
|
handle->hHighalg = alg_filter_create(RATE_SAMPLES,NUM_SAMPLES,bqHighPass);
|
|
alg_filter_set_param(handle->hLowalg,pCross->lowpass.freq,pCross->lowpass.taps,(eFilterType)pCross->lowpass.type, pCross->lowpass.gain/100.0f);
|
alg_filter_set_param(handle->hHighalg,pCross->highpass.freq,pCross->highpass.taps,(eFilterType)pCross->highpass.type,pCross->highpass.gain/100.0f);
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pCross;
|
|
|
return handle;
|
}
|
|
void* meter_create(ptag_Meter pMeter, char* inport_str, char* outport_str)
|
{
|
|
pmeter_handle handle = mymalloc(SRAM_AUTO ,sizeof(meter_handle));
|
assert(handle!=0);
|
|
//normalize((short*)pMeter,sizeof(tag_Meter));
|
|
|
handle->input_num= str_delim(inport_str,handle->il_id);
|
|
handle->meter_num = handle->input_num;
|
|
handle->param_ptr = pMeter;
|
|
handle->level = LEVEL_MALLOC(handle->meter_num);
|
|
memset(handle->maxLevel,0 , handle->meter_num);
|
memset(handle->period,0 , handle->meter_num);
|
|
|
|
//memset(handle->old_level,0,handle->meter_num);
|
return handle;
|
}
|
|
|
void* gain_create(ptag_gain pgain,char* inport_str, char* outport_str)
|
{
|
pgain_handle handle = mymalloc(SRAM_AUTO ,sizeof(gain_handle));
|
assert(handle!=0);
|
|
normalize((short*)pgain,sizeof(tag_gain));
|
|
if(pgain->gain>1200 || pgain->gain<-7200){
|
pgain->gain = 0;
|
}
|
handle->gain = pgain->gain/100.0f;
|
handle->old_gain=-100.0f;
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->param_ptr = pgain;
|
|
return handle;
|
}
|
|
|
void* feedback_create(ptag_feedback pfeedback, char* inport_str,char* outport_str)
|
{
|
int i;
|
|
pfeedback_handle handle = mymalloc(SRAM_AUTO ,sizeof(feedback_handle));
|
assert(handle!=0);
|
#if 1
|
normalize((short*)pfeedback,sizeof(tag_feedback));
|
|
handle->bypass = pfeedback->bypass&0x1;
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->param_ptr = pfeedback;
|
|
if(pfeedback->panic_threshold<-3600 || pfeedback->panic_threshold>0){
|
pfeedback->panic_threshold = -1800;
|
}
|
|
if(pfeedback->flt_depth<100 || pfeedback->flt_depth>2400){
|
pfeedback->flt_depth = 1800;
|
}
|
|
|
handle->bypass = pfeedback->bypass;
|
|
#if 1
|
handle->halg=alg_nhs_create(RATE_SAMPLES,NUM_SAMPLES, 8, pfeedback->fb_threshold*0.01, pfeedback->panic_threshold*0.01);
|
|
alg_nhs_set_parameters(handle->halg, 2.5 ,pfeedback->flt_depth*0.01, pfeedback->bw*0.01);
|
|
for(i=0;i<FEEDBACK_FILTERS_NUM;i++){
|
if(pfeedback->flt_group[i].fc<20 || pfeedback->flt_group[i].fc>20000){
|
pfeedback->flt_group[i].fc =20;
|
}
|
if( pfeedback->flt_group[i].type>2){
|
pfeedback->flt_group[i].type = 0;
|
}
|
if(pfeedback->flt_group[i].gain<-2400 || pfeedback->flt_group[i].gain>0){
|
pfeedback->flt_group[i].gain = 0;
|
}
|
alg_nhs_filters_set_unit(handle->halg , i ,pfeedback->flt_group[i].type
|
, pfeedback->flt_group[i].fc,pfeedback->flt_group[i].gain/100.0);
|
|
}
|
#else
|
{
|
static int init=0;
|
if(inport_str[0]=='1' && init ==0){
|
handle->halg = alg_afc_create(RATE_SAMPLES,NUM_SAMPLES);
|
alg.hafc = handle->halg;
|
init =1;
|
}
|
else{
|
handle->halg = 0;
|
}
|
}
|
#endif
|
|
handle->level = LEVEL_MALLOC(FEEDBACK_FILTERS_NUM*2);
|
#endif
|
return handle;
|
}
|
|
#if 1
|
void* automixer_create(ptag_automixer pautomixer, char* inport_str,char* outport_str)
|
{
|
int i;
|
pautomixer_handle handle = mymalloc(SRAM_AUTO ,sizeof(automixer_handle));
|
assert(handle!=0);
|
|
normalize((short*)pautomixer,sizeof(tag_automixer));
|
|
handle->bypass = pautomixer->bypass ;
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->param_ptr = pautomixer;
|
|
//²ÎÊý¼ì²é
|
if(pautomixer->master_gain<-7200 || pautomixer->master_gain>1200){
|
pautomixer->master_gain =0;
|
}
|
if(pautomixer->response<5 || pautomixer->response>5000){
|
pautomixer->response =100;
|
}
|
if(pautomixer->slope<100 || pautomixer->slope>600){
|
pautomixer->slope =200;
|
}
|
|
for(i=0;i<handle->input_num;i++){
|
if(pautomixer->channels[i].gain<-7200 || pautomixer->channels[i].gain>1200){
|
pautomixer->channels[i].gain = 0;
|
}
|
if(pautomixer->channels[i].threshold< 0 || pautomixer->channels[i].threshold>10){
|
pautomixer->channels[i].threshold =5;
|
}
|
}
|
|
handle->halg = alg_automixer_create(handle->input_num,NUM_SAMPLES, RATE_SAMPLES
|
,pautomixer->master_gain/100.0f, pautomixer->response,pautomixer->slope/100.f);
|
|
for(i=0;i<handle->input_num;i++){
|
alg_automixer_set_param(handle->halg, i, pautomixer->channels[i].automatic&0x1,pautomixer->channels[i].master&0x1
|
, pautomixer->channels[i].threshold, pautomixer->channels[i].gain/100.0f);
|
}
|
|
|
handle->level = LEVEL_MALLOC(handle->input_num*2);
|
return handle;
|
}
|
#else
|
void* automixer_create(ptag_automixer pautomixer, char* inport_str,char* outport_str)
|
{
|
int i;
|
pautomixer_handle handle = mymalloc(SRAM_AUTO ,sizeof(automixer_handle));
|
assert(handle!=0);
|
|
normalize((short*)pautomixer,sizeof(tag_automixer));
|
|
handle->bypass = pautomixer->bypass ;
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->param_ptr = pautomixer;
|
|
//2?¨ºy?¨¬2¨¦
|
if(pautomixer->master_gain<-7200 || pautomixer->master_gain>1200){
|
pautomixer->master_gain =0;
|
}
|
if(pautomixer->response<5 || pautomixer->response>5000){
|
pautomixer->response =100;
|
}
|
if(pautomixer->slope<100 || pautomixer->slope>600){
|
pautomixer->slope =200;
|
}
|
|
for(i=0;i<handle->input_num;i++){
|
if(pautomixer->channels[i].gain<-7200 || pautomixer->channels[i].gain>1200){
|
pautomixer->channels[i].gain = 0;
|
}
|
if(pautomixer->channels[i].threshold<-6000 || pautomixer->channels[i].threshold>0){
|
pautomixer->channels[i].threshold =-4800;
|
}
|
}
|
|
handle->halg = alg_pri_automixer_create(handle->input_num,NUM_SAMPLES, RATE_SAMPLES
|
,pautomixer->master_gain/100.0f, pautomixer->response,pautomixer->slope/100.f);
|
|
for(i=0;i<handle->input_num;i++){
|
alg_pri_automixer_set_param(handle->halg, i, pautomixer->channels[i].automatic&0x1,pautomixer->channels[i].master&0x1
|
, pautomixer->channels[i].threshold*0.01 , pautomixer->channels[i].gain/100.0f);
|
}
|
|
|
handle->level = LEVEL_MALLOC(handle->input_num*2);
|
return handle;
|
}
|
#endif
|
|
|
void* fir_create(ptag_fir pfir, char* inport_str,char* outport_str)
|
{
|
pcommon_handle handle = mymalloc(SRAM_AUTO ,sizeof(common_handle));
|
assert(handle!=0);
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->bypass =1 ;
|
|
//handle->halg = alg_fir_create(NUM_SAMPLES, RATE_SAMPLES);
|
|
return handle;
|
}
|
|
|
|
void* agc_create(ptag_agc pagc, char* inport_str,char* outport_str)
|
{
|
pagc_handle handle = mymalloc(SRAM_AUTO ,sizeof(agc_handle));
|
assert(handle != 0);
|
|
normalize((short*)pagc,sizeof(tag_agc));
|
|
pagc->bypass &= 0x1;
|
if(pagc->threshold<-9600 || pagc->threshold>-2000){
|
pagc->threshold = -9600;
|
}
|
//pagc->threshold = -7200;
|
if(pagc->tar_threshold<-4000 || pagc->tar_threshold>0){
|
pagc->tar_threshold = 0;
|
}
|
if(pagc->ratio<100 || pagc->ratio>2000){
|
pagc->ratio = 100;
|
}
|
if(pagc->attacktime >10000){
|
pagc->attacktime = 1;
|
}
|
if(pagc->releasetime >10000){
|
pagc->releasetime = 1;
|
}
|
|
handle->bypass = pagc->bypass;
|
handle->halg = alg_agc_create(RATE_SAMPLES,NUM_SAMPLES);
|
|
alg_agc_set_param(handle->halg ,pagc->threshold/100.0f , pagc->tar_threshold/100.0f, pagc->ratio/100.0f
|
,pagc->attacktime , pagc->releasetime);
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
handle->level = LEVEL_MALLOC(2);
|
|
handle->param_ptr = pagc;
|
|
return handle;
|
}
|
|
void *aec_create(ptag_aec paec, char* inport_str,char* outport_str)
|
{
|
|
paec_handle handle = mymalloc(SRAM_AUTO ,sizeof(aec_handle));
|
assert(handle!=0);
|
|
normalize((short*)paec,sizeof(tag_aec));
|
|
//void *aec_mem1 = mymalloc(SRAM_AUTO ,6*1024);
|
//void *aec_mem2 = mymalloc(SRAM_AUTO ,6*1024);
|
|
handle->bypass = paec->bypass&0x1;
|
handle->halg = alg_aec_create(RATE_SAMPLES,AEC_SMALES ,NUM_SAMPLES,AEC_MEM1 ,AEC_MEM2, AEC_TAIL);
|
alg_aec_set_param(handle->halg, (aec_mode_t)paec->mode);
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = paec;
|
|
haec = handle->halg;
|
return handle;
|
|
}
|
|
void *ans_create(ptag_ans pans, char* inport_str,char* outport_str)
|
{
|
pans_handle handle = mymalloc(SRAM_AUTO ,sizeof(ans_handle));
|
assert(handle!=0);
|
|
handle->bypass = pans->bypass&0x1;
|
|
if(pans->mode >= ns_off) pans->mode = ns_18dB;
|
|
handle->halg = alg_ans_create(RATE_SAMPLES, RATE_SAMPLES , NUM_SAMPLES);
|
alg_ans_set_policy(handle->halg, (ans_mode)pans->mode);
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pans;
|
|
hans = handle->halg;
|
return handle;
|
}
|
|
void* sysctl_create(ptag_sysctl psysctl , char* inport_str,char* outport_str)
|
{
|
|
int i;
|
psysctl_handle handle = mymalloc(SRAM_AUTO ,sizeof(sysctl_handle));
|
assert(handle!=0);
|
|
if(psysctl->gain>1200 || psysctl->gain<-8000){
|
psysctl->gain = 0;
|
}
|
|
handle->gain = psysctl->gain *0.01;
|
handle->mute = psysctl->mute&0x1;
|
handle->time = 0 ;
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
|
for(i=0 ;i<handle->input_num; i++){
|
handle->old_gain[i] = -120;
|
}
|
|
handle->param_ptr = psysctl;
|
|
|
return handle;
|
|
}
|
|
|
void* selector_create(ptag_selector pselector , char* inport_str,char* outport_str)
|
{
|
int i,j;
|
|
pselector_handle handle = mymalloc(SRAM_AUTO ,sizeof(selector_handle));
|
assert(handle!=0);
|
|
normalize((short*)pselector,sizeof(tag_selector));
|
memset(handle,0,sizeof(selector_handle));
|
|
|
memcpy(handle->mask,pselector->input_mask,sizeof(pselector->input_mask));
|
|
handle->input_num=str_delim(inport_str,handle->il_id);
|
handle->output_num=str_delim(outport_str,handle->ol_id);
|
handle->param_ptr = pselector;
|
|
|
return handle;
|
|
}
|
