/*
 * 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[1536];
static int nlevels=0;
#define LEVEL_MALLOC(n) level_buf+nlevels;nlevels+=n

void* hafc=0;
void* haec=0;
void* hans=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;
	}
}


#define BEIGN_DECLINE(exp) if(exp) {  
#define END_DECLINE(n) }else { \
	LEVEL_MALLOC(n) ; \
	return NULL;  \
}	

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* empty_create(void* handle,char* inport_str,char* outport_str)
{
	return NULL;
}

void* input_create(ptag_input pInput,char* inport_str,char* outport_str)
{
	BEIGN_DECLINE(inport_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&0x7;
		handle->input[i].phase  = pInput->input[i].phase&0x1;
		
		if(pInput->input[i].phant){
			handle->input[i].delay = RATE_SAMPLES*5;
		}
		
		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;
	END_DECLINE(0)
}

void* output_create(ptag_output pOutput, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_str)
	int i, pitch_alloc =0;
	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;
	END_DECLINE(0)
}



void* delay_create(	ptag_delay pDelay, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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;
	}
	
	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*1.0f);
	
	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;
	END_DECLINE(0)
}

void* shelf_create(ptag_shelf pshelf,char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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;
	END_DECLINE(0)
}

void* eq_create(ptag_eq pEQ, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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;
	END_DECLINE(0)
}

void* expander_create(ptag_expander pExpander, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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;
	END_DECLINE(1)
}

void* compressor_create(ptag_compress pcompress, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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;
	END_DECLINE(2)
}

void* mixer_create(ptag_mixer pMixer, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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);
//	handle->delay_ptr = mymalloc(SRAM_AUTO ,handle->output_num*handle->input_num);
//	handle->delay = 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++){
			handle->gain[i][j] = pMixer->input_gain[i][j]*0.01f;
			
			//handle->delay_ptr[i*handle->input_num+j] = alg_delay_create(100 , RATE_SAMPLES,NUM_SAMPLES);
			//if(pMixer->delay[i][j]>100 ){
			//	pMixer->delay[i][j] =0;
			//}
			//handle->delay[i*handle->input_num+j] = pMixer->delay[i][j];
			//alg_delay_set_msec(handle->delay_ptr[i*handle->input_num+j] , handle->delay[i*handle->input_num+j]);
		}
//		handle->weight[i] = 1.0f;
	}
	memcpy(handle->mask,pMixer->input_mask,sizeof(pMixer->input_mask));

	handle->param_ptr = pMixer;


	return handle;
	END_DECLINE(0)
}

void* crossover_create(ptag_crossover pCross, char* inport_str, char* outport_str)
{
	BEIGN_DECLINE(inport_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;
	END_DECLINE(0)
}

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)
{
	BEIGN_DECLINE(inport_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;
	END_DECLINE(0)
}


void* feedback_create(ptag_feedback pfeedback, char* inport_str,char* outport_str)
{
	BEIGN_DECLINE(inport_str)
	int i;
	pfeedback_handle handle = mymalloc(SRAM_AUTO ,sizeof(feedback_handle));
	ASSERT(handle!=0);
	
	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;
	}	
	
	if(pfeedback->step<50 || pfeedback->step>300){
		pfeedback->step	= 250;
	}
	
	if(pfeedback->fbc_num<8 || pfeedback->fbc_num>16){
		pfeedback->fbc_num	= 8;
	}
	
	handle->bypass = pfeedback->bypass;
	
	handle->halg = alg_nhs_create(RATE_SAMPLES,NUM_SAMPLES, pfeedback->fbc_num, pfeedback->fb_threshold*0.01, pfeedback->panic_threshold*0.01);
	
	alg_nhs_set_parameters(handle->halg, pfeedback->step*0.01 ,pfeedback->flt_depth*0.01, pfeedback->bw*0.01);
	
	for(i=0;i<pfeedback->fbc_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);
		
	}

	handle->level = LEVEL_MALLOC(pfeedback->fbc_num*2);
	handle->nsection = pfeedback->fbc_num;
	return handle;
	END_DECLINE(pfeedback->fbc_num*2)
}


void* gainsharing_automixer_create(ptag_gainsharing_mixer pautomixer, char* inport_str,char* outport_str)
{
	
	int i;
	
	pgainsharing_mixer_handle handle = mymalloc(SRAM_AUTO ,sizeof(gainsharing_mixer_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].priority<0 || pautomixer->channels[i].priority>10){
			pautomixer->channels[i].priority =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].mute&0x1
				, pautomixer->channels[i].priority , pautomixer->channels[i].gain/100.0f);
	}
	

	handle->level = LEVEL_MALLOC(handle->input_num*2);
	return handle;
}


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)
{	
	BEIGN_DECLINE(inport_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;
	}
	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->input_num=str_delim(inport_str,handle->il_id);
	handle->output_num=str_delim(outport_str,handle->ol_id);
	

	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->level = LEVEL_MALLOC(2);
	
	handle->param_ptr = pagc;
		
	return handle;
	END_DECLINE(2)
}

#define AEC_SAMPLE_RATE 32000
#define mem1_ptr (void*)0x000C3000
#define mem2_ptr (void*)0x000C5000
#define TAIL_MS 256
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));
		
	handle->bypass = paec->bypass&0x1;
	handle->halg = alg_aec_create(RATE_SAMPLES , AEC_SAMPLE_RATE, NUM_SAMPLES, mem1_ptr , mem2_ptr, TAIL_MS);
	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;
	
	handle->halg = alg_ans_create(RATE_SAMPLES,RATE_SAMPLES,NUM_SAMPLES);
	alg_ans_set_policy(handle->halg, (ans_mode)pans->mode);
	
	if(pans->mode >= ns_off) pans->mode = ns_18dB;
	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 *afc_create(ptag_afc pafc,  char* inport_str,char* outport_str)
{
	pafc_handle handle = mymalloc(SRAM_AUTO ,sizeof(afc_handle));
	ASSERT(handle!=0);
	
	if(pafc->gain >1200 || pafc->gain <-7200){
		pafc->gain =0;	
	}
	handle->bypass = pafc->bypass&0x1;
	handle->gain = pafc->gain;
	
	handle->halg = 0;//alg_afc_create(RATE_SAMPLES,NUM_SAMPLES);

	handle->input_num=str_delim(inport_str,handle->il_id);
	handle->output_num=str_delim(outport_str,handle->ol_id);
	handle->param_ptr = pafc;
	
	hafc = 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->sample_count =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;
	//handle->mask[0][34/16]|= 1<<(34&15);

	return handle;
	
}


void* spl_create(ptag_spl pspl ,char* inport_str,char* outport_str)
{
	BEIGN_DECLINE(inport_str)
	pspl_handle handle = mymalloc(SRAM_AUTO ,sizeof(spl_handle));
	ASSERT(handle!=0);
	
	normalize((short*)pspl,sizeof(tag_spl));
	memset(handle,0,sizeof(spl_handle));
	
	pspl->bypass &= 0x1;
	if(pspl->maxgain<0 || pspl->maxgain>2000){
		pspl->maxgain = 2000;
	}
	if(pspl->mingain<-3000 || pspl->mingain>0){
		pspl->mingain = -3000;
	}
	if(pspl->sense_ratio <50 || pspl->sense_ratio>150){
		pspl->sense_ratio = 75;
	}
	if(pspl->speed < 500 || pspl->speed>60000){
		pspl->speed = 500;
	}
	if(pspl->trim < -1000 || pspl->trim > 1000){
		pspl->trim = 0;
	}
	
	memcpy (handle->mask ,pspl->mask , sizeof(handle->mask));
	
	handle->halg = alg_spl_continuous_create(RATE_SAMPLES,NUM_SAMPLES);
	
	alg_spl_continuous_set_distance(handle->halg ,pspl->distance*0.01);
	alg_spl_continuous_set_parameters(handle->halg,pspl->noise_thr*0.01, pspl->maxgain*0.01 ,pspl->mingain*0.01 ,pspl->sense_ratio*0.01, pspl->speed,pspl->trim*0.01);
	
	handle->input_num=str_delim(inport_str,handle->il_id);
	handle->output_num=str_delim(outport_str,handle->ol_id);
	handle->param_ptr = pspl;
	handle->level = LEVEL_MALLOC(2);
	handle->bypass = pspl->bypass;
	
	return handle;
	END_DECLINE(2)
}

void* gate_create(ptag_gate pgate ,char* inport_str,char* outport_str)
{
	BEIGN_DECLINE(inport_str)
	pgate_handle handle = mymalloc(SRAM_AUTO ,sizeof(gate_handle));
	ASSERT(handle!=0);
	
	normalize((short*)pgate, sizeof(tag_gate));
	memset(handle, 0, sizeof(gate_handle));
	
	if(pgate->attacktime<1 || pgate->attacktime>1000){
		pgate->attacktime = 2;
	}
	if(pgate->releasetime<5 || pgate->releasetime >10000){
		pgate->releasetime = 1000;
	}
	if(pgate->holdtime<5 || pgate->holdtime >10000){
		pgate->holdtime = 5;
	}
	
	if(pgate->threshold < -4800 || pgate->threshold>0){
		pgate->threshold = -3000;
	}
	
	pgate->bypass &= 0x1;
	if(pgate->depth <-7200 || pgate->depth>0){
		pgate->depth = -6000;
	}
	
	
	handle->halg = alg_gate_create(RATE_SAMPLES,NUM_SAMPLES);
	alg_gate_set_param(handle->halg, pgate->threshold*0.01, pgate->holdtime, pgate->depth*0.01, pgate->releasetime ,pgate->attacktime);
	
	handle->input_num=str_delim(inport_str,handle->il_id);
	handle->output_num=str_delim(outport_str,handle->ol_id);
	handle->param_ptr = pgate;
	handle->level = LEVEL_MALLOC(1);
	handle->bypass = pgate->bypass;
	
	return handle;
	END_DECLINE(1)
}

void* ducker_create(ptag_ducker pducker ,char* inport_str,char* outport_str)
{
	BEIGN_DECLINE(inport_str)
	pducker_handle handle = mymalloc(SRAM_AUTO ,sizeof(ducker_handle));
	ASSERT(handle!=0);
	
	normalize((short*)pducker, sizeof(tag_ducker));
	memset(handle, 0, sizeof(ducker_handle));
	
	if(pducker->attacktime<10 || pducker->attacktime>500){
		pducker->attacktime = 20;
	}
	if(pducker->holdtime <10 || pducker->holdtime >10000){
		pducker->holdtime = 1000;
	}
	if(pducker->releasetime <10 || pducker->releasetime >60000){
		pducker->releasetime = 1000;
	}
	if(pducker->depth <-7200 || pducker->depth>0){
		pducker->depth = -6000;
	}
	if(pducker->side_gain<-7200 || pducker->side_gain>1200){
		pducker->side_gain =0 ;
	}
	if(pducker->threshold < -6000 || pducker->threshold>0){
		pducker->threshold = -4500;
	}
	pducker->bypass &= 0x1;
	pducker->mute &= 0x1;
	
	memcpy (handle->mask ,pducker->mask , sizeof(handle->mask));
	handle->bypass = pducker->bypass;
	handle->halg = alg_ducker_create(RATE_SAMPLES,NUM_SAMPLES);
	alg_ducker_set_parameters(handle->halg ,pducker->threshold*0.01 ,pducker->depth*0.01, pducker->attacktime
		, pducker->releasetime ,pducker->holdtime ,pducker->mute , pducker->side_gain*0.01);
	
	handle->input_num=str_delim(inport_str,handle->il_id);
	handle->output_num=str_delim(outport_str,handle->ol_id);
	handle->param_ptr = pducker;
	
	handle->level = LEVEL_MALLOC(1);
	
	return handle;
	END_DECLINE(1)
}

void* reverb_create(ptag_reverb preverb ,char* inport_str,char* outport_str)
{
	return 0;
}

void* echo_create(ptag_echo pecho ,char* inport_str,char* outport_str)
{
	return 0;
}

void* geq_create(ptag_geq pgeq ,char* inport_str,char* outport_str)
{
	BEIGN_DECLINE(inport_str)
	int i;
	float q;
	pgeq_handle handle = mymalloc(SRAM_AUTO ,sizeof(geq_handle));
	ASSERT(handle!=0);
	
	normalize((short*)pgeq, sizeof(tag_geq));
	memset(handle, 0, sizeof(geq_handle));
	
	pgeq->bypass&=0x1;
	
	if(pgeq->nsections > 31) pgeq->nsections =31;
	
	if(pgeq->q <1 || pgeq->q>3){
		pgeq->q = 2;	
	}
	
	for(i=0;i<pgeq->nsections;i++){
		if(pgeq->eq_attr[i].gain<-7200 || pgeq->eq_attr[i].gain > 1200){
			pgeq->eq_attr[i].gain =0;
		}
	}
	
	handle->bypass = pgeq->bypass;
	handle->halg = alg_eq_create(RATE_SAMPLES,NUM_SAMPLES, pgeq->nsections);
	q = alg_geq_get_q(handle->halg, pgeq->nsections, pgeq->q);
	
	for(i=0;i<pgeq->nsections;i++){
		alg_eq_set_param(handle->halg , i ,eq_geq, 0 ,0, pgeq->eq_attr[i].gain*0.01 , q);
	}
	
	handle->input_num=str_delim(inport_str,handle->il_id);
	handle->output_num=str_delim(outport_str,handle->ol_id);
	handle->param_ptr = pgeq;
	
	return handle;
	END_DECLINE(0)
}

void* gating_automixer_create(ptag_gating_mixer pautomixer,char* inport_str,char* outport_str)
{
	int i;
	pgating_mixer_handle handle = mymalloc(SRAM_AUTO ,sizeof(gating_mixer_handle));
	ASSERT(handle!=0);
	
	normalize((short*)pautomixer,sizeof(tag_gating_mixer));
	
	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->holdtime < 100 || pautomixer->holdtime>5000){
		pautomixer->holdtime = 500;
	}
	if(pautomixer->last_on > AUTOMIXER_CHANNEL_NUM){
		pautomixer->last_on = 0;
	}
	if(pautomixer->offgain<-9000 || pautomixer->offgain>-1000){
		pautomixer->offgain = -4000;
	}
	if(pautomixer->noise_thr <-9600 || pautomixer->noise_thr >-2400){
		pautomixer->noise_thr = -4800;	
	}
	if(pautomixer->nom_atten > 600){
		pautomixer->nom_atten = 300;
	}
	if(pautomixer->nom_num > handle->input_num){
		pautomixer->nom_num = 4;
	}
	if(pautomixer->sensitivity < 300 || pautomixer->sensitivity>3000){
		pautomixer->sensitivity = 600;
	}
	pautomixer->master_mute &= 0x1;
	
	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].priority>10){
			pautomixer->channels[i].priority =5;
		}
		pautomixer->channels[i].automatic &= 0x1;
		pautomixer->channels[i].mute &= 0x1;
	}
	
	handle->halg = alg_gating_automixer_create(handle->input_num,NUM_SAMPLES, RATE_SAMPLES
			,pautomixer->master_gain/100.0f,  pautomixer->master_mute, pautomixer->last_on);
	alg_gating_automixer_set_master_param(handle->halg , pautomixer->holdtime, pautomixer->offgain*0.01
			 ,pautomixer->noise_thr*0.01, pautomixer->sensitivity*0.01, pautomixer->nom_atten*0.01, pautomixer->nom_num);
		
	for(i=0;i<handle->input_num;i++){
		alg_gating_automixer_set_param(handle->halg, i, pautomixer->channels[i].automatic,pautomixer->channels[i].mute
				, pautomixer->channels[i].priority , pautomixer->channels[i].gain/100.0f, pautomixer->channels[i].def);
	}
	

	handle->level = LEVEL_MALLOC(handle->input_num*2);
	return handle;
}