/*
 * scene.c
 * Description:
 *
 *  Created on: 2014-10-28
 *      Author: Graydon
 *  Modify:
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <alg.h>

#include "drv/global.h"
#include "drv/hmem.h"
#include "scene.h"
#include "create.h"
#include "ctrl.h"
#include "execute.h"
#include "protocol.h"
#include "drv/fft.h"

//#define PROC_NUM 152

#pragma section("scene_mem")
static tag_parameters parameters;

#pragma section("scene_mem")
static  struct proc_field{
	int proc_id;
	eproc_type proc_type;
	void* proc_handle;

	char inportstr[MAX_DELIM_LEN];
	char outportstr[MAX_DELIM_LEN];
	void * const parameters;
} proc_list[]={
		 {255,PROC_METER,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|","",0} //0
		,{150,PROC_INPUT,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|","0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|",&parameters.input} 
		
		,{1,PROC_DELAY,0,"0|","0|",&parameters.indelay[0]},{2,PROC_DELAY,0,"1|","1|",&parameters.indelay[1]} 
		,{3,PROC_DELAY,0,"2|","2|",&parameters.indelay[2]},{4,PROC_DELAY,0,"3|","3|",&parameters.indelay[3]}
		,{5,PROC_DELAY,0,"4|","4|",&parameters.indelay[4]},{6,PROC_DELAY,0,"5|","5|",&parameters.indelay[5]}
		,{7,PROC_DELAY,0,"6|","6|",&parameters.indelay[6]},{8,PROC_DELAY,0,"7|","7|",&parameters.indelay[7]}
		,{9,PROC_DELAY,0,"8|","8|",&parameters.indelay[8]},{10,PROC_DELAY,0,"9|","9|",&parameters.indelay[9]}
		,{11,PROC_DELAY,0,"10|","10|",&parameters.indelay[10]},{12,PROC_DELAY,0,"11|","11|",&parameters.indelay[11]}
		,{13,PROC_DELAY,0,"12|","12|",&parameters.indelay[12]},{14,PROC_DELAY,0,"13|","13|",&parameters.indelay[13]}
		,{15,PROC_DELAY,0,"14|","14|",&parameters.indelay[14]},{16,PROC_DELAY,0,"15|","15|",&parameters.indelay[15]}  
		
		,{17,PROC_SHELF,0,"0|","0|",&parameters.shelf[0]},{18,PROC_SHELF,0,"1|","1|",&parameters.shelf[1]} 
		,{19,PROC_SHELF,0,"2|","2|",&parameters.shelf[2]},{20,PROC_SHELF,0,"3|","3|",&parameters.shelf[3]}
		,{21,PROC_SHELF,0,"4|","4|",&parameters.shelf[4]},{22,PROC_SHELF,0,"5|","5|",&parameters.shelf[5]}
		,{23,PROC_SHELF,0,"6|","6|",&parameters.shelf[6]},{24,PROC_SHELF,0,"7|","7|",&parameters.shelf[7]}
		,{25,PROC_SHELF,0,"8|","8|",&parameters.shelf[8]},{26,PROC_SHELF,0,"9|","9|",&parameters.shelf[9]}
		,{27,PROC_SHELF,0,"10|","10|",&parameters.shelf[10]},{28,PROC_SHELF,0,"11|","11|",&parameters.shelf[11]}
		,{29,PROC_SHELF,0,"12|","12|",&parameters.shelf[12]},{30,PROC_SHELF,0,"13|","13|",&parameters.shelf[13]}
		,{31,PROC_SHELF,0,"14|","14|",&parameters.shelf[14]},{32,PROC_SHELF,0,"15|","15|",&parameters.shelf[15]} 
		

		,{65,PROC_EXPANDER,0,"0|","0|",&parameters.expander[0]},{66,PROC_EXPANDER,0,"1|","1|",&parameters.expander[1]} 
		,{67,PROC_EXPANDER,0,"2|","2|",&parameters.expander[2]},{68,PROC_EXPANDER,0,"3|","3|",&parameters.expander[3]}
		,{69,PROC_EXPANDER,0,"4|","4|",&parameters.expander[4]},{70,PROC_EXPANDER,0,"5|","5|",&parameters.expander[5]}
		,{71,PROC_EXPANDER,0,"6|","6|",&parameters.expander[6]},{72,PROC_EXPANDER,0,"7|","7|",&parameters.expander[7]}
		,{73,PROC_EXPANDER,0,"8|","8|",&parameters.expander[8]},{74,PROC_EXPANDER,0,"9|","9|",&parameters.expander[9]}
		,{75,PROC_EXPANDER,0,"10|","10|",&parameters.expander[10]},{76,PROC_EXPANDER,0,"11|","11|",&parameters.expander[11]}
		,{77,PROC_EXPANDER,0,"12|","12|",&parameters.expander[12]},{78,PROC_EXPANDER,0,"13|","13|",&parameters.expander[13]}
		,{79,PROC_EXPANDER,0,"14|","14|",&parameters.expander[14]},{80,PROC_EXPANDER,0,"15|","15|",&parameters.expander[15]}  
		
		,{49,PROC_PEQ,0,"0|","0|",&parameters.inpeq[0]},{50,PROC_PEQ,0,"1|","1|",&parameters.inpeq[1]} 
		,{51,PROC_PEQ,0,"2|","2|",&parameters.inpeq[2]},{52,PROC_PEQ,0,"3|","3|",&parameters.inpeq[3]}
		,{53,PROC_PEQ,0,"4|","4|",&parameters.inpeq[4]},{54,PROC_PEQ,0,"5|","5|",&parameters.inpeq[5]}
		,{55,PROC_PEQ,0,"6|","6|",&parameters.inpeq[6]},{56,PROC_PEQ,0,"7|","7|",&parameters.inpeq[7]}
		,{57,PROC_PEQ,0,"8|","8|",&parameters.inpeq[8]},{58,PROC_PEQ,0,"9|","9|",&parameters.inpeq[9]}
		,{59,PROC_PEQ,0,"10|","10|",&parameters.inpeq[10]},{60,PROC_PEQ,0,"11|","11|",&parameters.inpeq[11]}
		,{61,PROC_PEQ,0,"12|","12|",&parameters.inpeq[12]},{62,PROC_PEQ,0,"13|","13|",&parameters.inpeq[13]}
		,{63,PROC_PEQ,0,"14|","14|",&parameters.inpeq[14]},{64,PROC_PEQ,0,"15|","15|",&parameters.inpeq[15]}  
			
		,{33,PROC_COMPRESSER,0,"0|","0|",&parameters.incompress[0]},{34,PROC_COMPRESSER,0,"1|","1|",&parameters.incompress[1]} 
		,{35,PROC_COMPRESSER,0,"2|","2|",&parameters.incompress[2]},{36,PROC_COMPRESSER,0,"3|","3|",&parameters.incompress[3]}
		,{37,PROC_COMPRESSER,0,"4|","4|",&parameters.incompress[4]},{38,PROC_COMPRESSER,0,"5|","5|",&parameters.incompress[5]}
		,{39,PROC_COMPRESSER,0,"6|","6|",&parameters.incompress[6]},{40,PROC_COMPRESSER,0,"7|","7|",&parameters.incompress[7]}
		,{41,PROC_COMPRESSER,0,"8|","8|",&parameters.incompress[8]},{42,PROC_COMPRESSER,0,"9|","9|",&parameters.incompress[9]}
		,{43,PROC_COMPRESSER,0,"10|","10|",&parameters.incompress[10]},{44,PROC_COMPRESSER,0,"11|","11|",&parameters.incompress[11]}
		,{45,PROC_COMPRESSER,0,"12|","12|",&parameters.incompress[12]},{46,PROC_COMPRESSER,0,"13|","13|",&parameters.incompress[13]}
		,{47,PROC_COMPRESSER,0,"14|","14|",&parameters.incompress[14]},{48,PROC_COMPRESSER,0,"15|","15|",&parameters.incompress[15]}  
		
		,{151,PROC_FEEDBACK,0,"0|","0|",&parameters.feedback[0]},{152,PROC_FEEDBACK,0,"1|","1|",&parameters.feedback[1]}
		,{153,PROC_FEEDBACK,0,"2|","2|",&parameters.feedback[2]},{154,PROC_FEEDBACK,0,"3|","3|",&parameters.feedback[3]}
		,{155,PROC_FEEDBACK,0,"4|","4|",&parameters.feedback[4]},{156,PROC_FEEDBACK,0,"5|","5|",&parameters.feedback[5]}
		,{157,PROC_FEEDBACK,0,"6|","6|",&parameters.feedback[6]},{158,PROC_FEEDBACK,0,"7|","7|",&parameters.feedback[7]}
		,{159,PROC_FEEDBACK,0,"8|","8|",&parameters.feedback[8]},{160,PROC_FEEDBACK,0,"9|","9|",&parameters.feedback[9]}
		,{161,PROC_FEEDBACK,0,"10|","10|",&parameters.feedback[10]},{162,PROC_FEEDBACK,0,"11|","11|",&parameters.feedback[11]}
		,{163,PROC_FEEDBACK,0,"12|","12|",&parameters.feedback[12]},{164,PROC_FEEDBACK,0,"13|","13|",&parameters.feedback[13]}
		,{165,PROC_FEEDBACK,0,"14|","14|",&parameters.feedback[14]},{166,PROC_FEEDBACK,0,"15|","15|",&parameters.feedback[15]}
		
		,{149,PROC_AUTOMIXER,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15","0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16",&parameters.automixer}  
		
		,{167,PROC_SELECTOR,0, "0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|","17|18|", &parameters.aec_selector}  
		,{168,PROC_AEC,0, "17|18|","17|",&parameters.aec}
		,{169,PROC_SELECTOR,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|","18|", &parameters.ans_selector}
		,{170,PROC_ANS,0,"18|","|18", &parameters.ans}
		
		,{82,PROC_MIXER,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|","0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15",&parameters.mixer}  
		
		,{83,PROC_CROSSOVER,0,"0|","0|",&parameters.outxover[0]},{84,PROC_CROSSOVER,0,"1|","1|",&parameters.outxover[1]} 
		,{85,PROC_CROSSOVER,0,"2|","2|",&parameters.outxover[2]},{86,PROC_CROSSOVER,0,"3|","3|",&parameters.outxover[3]}
		,{87,PROC_CROSSOVER,0,"4|","4|",&parameters.outxover[4]},{88,PROC_CROSSOVER,0,"5|","5|",&parameters.outxover[5]}
		,{89,PROC_CROSSOVER,0,"6|","6|",&parameters.outxover[6]},{90,PROC_CROSSOVER,0,"7|","7|",&parameters.outxover[7]}
		,{91,PROC_CROSSOVER,0,"8|","8|",&parameters.outxover[8]},{92,PROC_CROSSOVER,0,"9|","9|",&parameters.outxover[9]}
		,{93,PROC_CROSSOVER,0,"10|","10|",&parameters.outxover[10]},{94,PROC_CROSSOVER,0,"11|","11|",&parameters.outxover[11]}
		,{95,PROC_CROSSOVER,0,"12|","12|",&parameters.outxover[12]},{96,PROC_CROSSOVER,0,"13|","13|",&parameters.outxover[13]}
		,{97,PROC_CROSSOVER,0,"14|","14|",&parameters.outxover[14]},{98,PROC_CROSSOVER,0,"15|","15|",&parameters.outxover[15]} 
				
		,{99,PROC_PEQ,0,"0|","0|",&parameters.outpeq[0]},{100,PROC_PEQ,0,"1|","1|",&parameters.outpeq[1]} 
		,{101,PROC_PEQ,0,"2|","2|",&parameters.outpeq[2]},{102,PROC_PEQ,0,"3|","3|",&parameters.outpeq[3]}
		,{103,PROC_PEQ,0,"4|","4|",&parameters.outpeq[4]},{104,PROC_PEQ,0,"5|","5|",&parameters.outpeq[5]}
		,{105,PROC_PEQ,0,"6|","6|",&parameters.outpeq[6]},{106,PROC_PEQ,0,"7|","7|",&parameters.outpeq[7]}
		,{107,PROC_PEQ,0,"8|","8|",&parameters.outpeq[8]},{108,PROC_PEQ,0,"9|","9|",&parameters.outpeq[9]}
		,{109,PROC_PEQ,0,"10|","10|",&parameters.outpeq[10]},{110,PROC_PEQ,0,"11|","11|",&parameters.outpeq[11]}
		,{111,PROC_PEQ,0,"12|","12|",&parameters.outpeq[12]},{112,PROC_PEQ,0,"13|","13|",&parameters.outpeq[13]}
		,{113,PROC_PEQ,0,"14|","14|",&parameters.outpeq[14]},{114,PROC_PEQ,0,"15|","15|",&parameters.outpeq[15]} 
	
		,{115,PROC_DELAY,0,"0|","0|",&parameters.outdelay[0]},{116,PROC_DELAY,0,"1|","1|",&parameters.outdelay[1]} 
		,{117,PROC_DELAY,0,"2|","2|",&parameters.outdelay[2]},{118,PROC_DELAY,0,"3|","3|",&parameters.outdelay[3]}
		,{119,PROC_DELAY,0,"4|","4|",&parameters.outdelay[4]},{120,PROC_DELAY,0,"5|","5|",&parameters.outdelay[5]}
		,{121,PROC_DELAY,0,"6|","6|",&parameters.outdelay[6]},{122,PROC_DELAY,0,"7|","7|",&parameters.outdelay[7]}
		,{123,PROC_DELAY,0,"8|","8|",&parameters.outdelay[8]},{124,PROC_DELAY,0,"9|","9|",&parameters.outdelay[9]}
		,{125,PROC_DELAY,0,"10|","10|",&parameters.outdelay[10]},{126,PROC_DELAY,0,"11|","11|",&parameters.outdelay[11]}
		,{127,PROC_DELAY,0,"12|","12|",&parameters.outdelay[12]},{128,PROC_DELAY,0,"13|","13|",&parameters.outdelay[13]}
		,{129,PROC_DELAY,0,"14|","14|",&parameters.outdelay[14]},{130,PROC_DELAY,0,"15|","15|",&parameters.outdelay[15]}  
		
		,{131,PROC_LIMIT,0,"0|","0|",&parameters.limit[0]},{132,PROC_LIMIT,0,"1|","1|",&parameters.limit[1]} 
		,{133,PROC_LIMIT,0,"2|","2|",&parameters.limit[2]},{134,PROC_LIMIT,0,"3|","3|",&parameters.limit[3]}
		,{135,PROC_LIMIT,0,"4|","4|",&parameters.limit[4]},{136,PROC_LIMIT,0,"5|","5|",&parameters.limit[5]}
		,{137,PROC_LIMIT,0,"6|","6|",&parameters.limit[6]},{138,PROC_LIMIT,0,"7|","7|",&parameters.limit[7]}
		,{139,PROC_LIMIT,0,"8|","8|",&parameters.limit[8]},{140,PROC_LIMIT,0,"9|","9|",&parameters.limit[9]}
		,{141,PROC_LIMIT,0,"10|","10|",&parameters.limit[10]},{142,PROC_LIMIT,0,"11|","11|",&parameters.limit[11]}
		,{143,PROC_LIMIT,0,"12|","12|",&parameters.limit[12]},{144,PROC_LIMIT,0,"13|","13|",&parameters.limit[13]}
		,{145,PROC_LIMIT,0,"14|","14|",&parameters.limit[14]},{146,PROC_LIMIT,0,"15|","15|",&parameters.limit[15]}  

	/*	
		,{167,PROC_FIR,0,"0|","0|",0},{168,PROC_FIR,0,"1|","1|",0} 
		,{169,PROC_FIR,0,"2|","2|",0},{154,PROC_FIR,0,"3|","3|",0}
		,{167,PROC_FIR,0,"4|","4|",0},{167,PROC_FIR,0,"5|","5|",0}
		,{167,PROC_FIR,0,"6|","6|",0},{167,PROC_FIR,0,"7|","7|",0}
		,{167,PROC_FIR,0,"8|","8|",0},{167,PROC_FIR,0,"9|","9|",0} 
		,{167,PROC_FIR,0,"10|","10|",0},{167,PROC_FIR,0,"11|","11|",0}
		,{167,PROC_FIR,0,"12|","12|",0},{167,PROC_FIR,0,"13|","13|",0}
		,{167,PROC_FIR,0,"14|","14|",0},{167,PROC_FIR,0,"15|","15|",0}*/
		
		,{147,PROC_OUTPUT,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15","0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15",&parameters.output} 

		,{171,PROC_SYSCTL,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15","0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15",&parameters.sysctl} 
		
		,{254,PROC_METER,0,"0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15","",0} //151
};

static int g_procID_table[256];

typedef void* create_fn(void*, char*, char*);
typedef int execute_fn(void* proc);
typedef int ctrl_fn(void* proc,int cmd,int* val,int num);


static const struct{
	create_fn  *create;
	ctrl_fn	* ctrl;
	execute_fn *execute;
}g_opt_ptr[PROC_COUNT]={
		{(create_fn*)input_create,           (ctrl_fn*)input_ctrl,        (execute_fn*)input_execute             }
		,{(create_fn*)meter_create,          (ctrl_fn*)meter_ctrl,        (execute_fn*)meter_execute 			 }
		,{(create_fn*)eq_create,             (ctrl_fn*)eq_ctrl,           (execute_fn*)eq_execute                }
		,{(create_fn*)expander_create,       (ctrl_fn*)expander_ctrl,     (execute_fn*)expander_execute		     }
		,{(create_fn*)compressor_create,     (ctrl_fn*)compressor_ctrl,	  (execute_fn*)compressor_execute		 }
		,{(create_fn*)compressor_create,     (ctrl_fn*)compressor_ctrl,   (execute_fn*)compressor_execute		 }
		,{(create_fn*)mixer_create,          (ctrl_fn*)mixer_ctrl,        (execute_fn*)mixer_execute			 }
		,{(create_fn*)delay_create,          (ctrl_fn*)delay_ctrl,        (execute_fn*)delay_execute			 }
		,{(create_fn*)crossover_create,      (ctrl_fn*)crossover_ctrl,    (execute_fn*)crossover_execute		 }
		,{(create_fn*)output_create,         (ctrl_fn*)output_ctrl,       (execute_fn*)output_execute		 	 }
		,{(create_fn*)gain_create,           (ctrl_fn*)gain_ctrl,         (execute_fn*)gain_execute			     }
		,{(create_fn*)feedback_create,       (ctrl_fn*)feedback_ctrl,     (execute_fn*)feedback_execute		     }
		,{(create_fn*)automixer_create,      (ctrl_fn*)automixer_ctrl,    (execute_fn*)automixer_execute		 }
		,{(create_fn*)agc_create,            (ctrl_fn*)agc_ctrl      ,    (execute_fn*)agc_execute			     }
		,{(create_fn*)aec_create,            (ctrl_fn*)aec_ctrl       ,    (execute_fn*)aec_execute			     }
		,{(create_fn*)ans_create,            (ctrl_fn*)ans_ctrl        ,    (execute_fn*)ans_execute			     }
		,{(create_fn*)sysctl_create,         (ctrl_fn*)sysctl_ctrl      ,    (execute_fn*)sysctl_execute			     }
		,{(create_fn*)shelf_create,          (ctrl_fn*)shelf_ctrl        ,    (execute_fn*)eq_execute			     }
	    ,{(create_fn*)selector_create,          (ctrl_fn*)selector_ctrl        ,    (execute_fn*)selector_execute			     }
};


void proc_delete(void* proc,eproc_type proc_type)
{
	int i;
		
	switch(proc_type){
		case PROC_LIMIT:
		case PROC_COMPRESSER:{
			pcompressor_handle p = proc;
			alg_compress_destroy(p->halg);
		}
		break;
		case PROC_EXPANDER:{
			pexpander_handle p = proc;
			alg_expander_destroy(p->halg);
		}
		break;
		case PROC_DELAY:{
			pdelay_handle p = proc;
			alg_delay_destroy(p->halg);
		}
		break;
		case PROC_INPUT:{
			pinput_handle handle = proc;
			for(i=0;i<handle->input_num;i++){
				if(handle->input[i].hgen){
					alg_sg_destroy(handle->input[i].hgen);
				}
			}
		}
		break;
		case PROC_SHELF:
		case PROC_PEQ:{
			peq_handle p = proc;
			alg_eq_destroy(p->halg);
		}
		break;
		case PROC_CROSSOVER:
		{
			pcrossover_handle p = proc;
			alg_filter_destroy(p->hHighalg);
			alg_filter_destroy(p->hLowalg);
		}
		break;
		case PROC_AUTOMIXER:{
			pautomixer_handle p = proc;
			alg_automixer_destroy(p->halg);
		}
		case PROC_FEEDBACK:{
			pfeedback_handle p = proc;
		//	alg_fb_destroy(p->halg);
		}
		break;
		default:
		break;
	}
	free(proc);
}

	

//ÉèÖÃĬÈϲÎÊý
void scene_default()
{
	int i,j,module_cnt=0;
	int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);
	int allbypass = 1;
	
	for(i=0;i<proc_cnt;i++){
		switch(proc_list[i].proc_type){
			case PROC_INPUT:{			
				ptag_input pInput = (ptag_input)proc_list[i].parameters;
				pInput->input_num = MAX_INPUT_NUM;	
				for(j=0;j<MAX_INPUT_NUM;j++){
					pInput->input[j].level = -3000;
					pInput->input[j].freq = 2000;
					pInput->input[j].type =0;
				}
			}
			break;
			case PROC_METER:{
			//	ptag_Meter pMeter = (ptag_Meter)proc_list[i].parameters;
			//	pMeter->input_num = 8;
			}
			break;
			case PROC_PEQ:{
				int j;
				ptag_eq pEQ = (ptag_eq)proc_list[i].parameters;
				
				pEQ->bypass = allbypass;
				pEQ->nsection = MAX_EQ_SECTION;
				for(j=0;j<pEQ->nsection;j++){
					pEQ->eq_attr[j].bypass = allbypass;
					pEQ->eq_attr[j].freq = 20+j*20000/16;
					pEQ->eq_attr[j].gain = 0;
					pEQ->eq_attr[j].q = 250;
				}

			}
			break;
			case PROC_EXPANDER:{
				ptag_expander pExpander = (ptag_expander)proc_list[i].parameters;
				pExpander->bypass = allbypass;
				pExpander->threshold = -4800;
				pExpander->ratio = 200;
				pExpander->attack = 1;
				pExpander->release = 1;
				
			}
			break;
			case PROC_COMPRESSER:{
				ptag_compress pcompress = (ptag_compress)proc_list[i].parameters;
				pcompress->bypass = allbypass;
				pcompress->threshold = -2000;
				pcompress->ratio = 200;
				pcompress->attack = 1;
				pcompress->release = 1;
				pcompress->gain = 0;
			}
			break;
			case PROC_LIMIT:{
				ptag_compress pcompress = (ptag_compress)proc_list[i].parameters;
				pcompress->bypass = allbypass;
				pcompress->threshold = -2000;
				pcompress->ratio = 10000;
				pcompress->attack = 1;
				pcompress->release = 1;
				pcompress->gain = 0;
				
			}
			break;
			case PROC_MIXER:{
				int j,m;
				
				ptag_mixer pMixer = (ptag_mixer)proc_list[i].parameters;
				pMixer->input_num = MAX_MIXER_INPUT;
				pMixer->output_num = MAX_MIXER_OUTPUT;
				for (m=0;m<pMixer->output_num ;m ++){
					for(j=0;j<pMixer->input_num;j++){
						 pMixer->input_gain[m][j]=0;
					}
					pMixer->input_mask[m][m/16]=1<<(m&15);
				}
				#if 0
				{
					//test
					static int mixer =0 ;
					mixer++;
					if(mixer==1){
						pMixer->input_mask[7][1]=1;//(1<<2)|(1<<0);
						pMixer->input_mask[17][0] = 1;
					}
					if(mixer==2){
						pMixer->input_mask[6][1]=1<<1;
					}
				}
				#endif
			}
			break;
			case PROC_DELAY:{
				ptag_delay pDelay = (ptag_delay)proc_list[i].parameters;
				pDelay->bypass = allbypass;
				pDelay->ms  = 100;
			}
			break;
			case PROC_CROSSOVER:{
				ptag_crossover pCross = (ptag_crossover)proc_list[i].parameters;
				pCross->highpass.bypass = allbypass;
				pCross->highpass.freq = 20;//454;
				pCross->highpass.taps = 18;//48;
				pCross->highpass.type = butterworth;


				pCross->lowpass.bypass = allbypass;
				pCross->lowpass.freq = 20000;
				pCross->lowpass.taps = 18;
				pCross->lowpass.type = butterworth;
				
			}
			break;
			case PROC_OUTPUT:{
				ptag_output pOutput= (ptag_output)proc_list[i].parameters;
				pOutput->output_num  = MAX_OUTPUT_NUM;
			}
			break;
			case PROC_GAIN:{
			}
			break;
			case PROC_AUTOMIXER:{
				int j;
				
				ptag_automixer pautomixer = (ptag_automixer)proc_list[i].parameters;
				
				pautomixer->bypass = allbypass;
				pautomixer->master_mute =0;
				pautomixer->master_gain =0;
				pautomixer->response = 5;
				pautomixer->slope = 200;
				
				for(j=0;j<AUTOMIXER_CHANNEL_NUM;j++){
					pautomixer->channels[j].automatic = 1;
					pautomixer->channels[j].mute = 0;
					pautomixer->channels[j].gain = 0;
					pautomixer->channels[j].priority = 5;
				}
			}
			break;
			case PROC_FEEDBACK:{
				ptag_feedback pfb = (ptag_feedback)proc_list[i].parameters;
				pfb->bypass = allbypass;
				pfb->lock = 0;
				pfb->panic_threshold = 0;
				pfb->fb_threshold = -4800;
				pfb->flt_bw = 10;
				pfb->flt_step = 100;
				pfb->flt_depth = 1800;
				pfb->flt_nfixed = 8;
			}
			break;
			case PROC_SHELF:{
				ptag_shelf pshelf = (ptag_shelf)proc_list[i].parameters;
				
				pshelf->highshelf.bypass = allbypass;
				pshelf->highshelf.freq = 500;
				pshelf->highshelf.q = 71;
				pshelf->highshelf.gain = -4500;
				
				
				pshelf->lowshelf.bypass = allbypass;
				pshelf->lowshelf.freq = 500;
				pshelf->lowshelf.q = 71;
				pshelf->lowshelf.gain = -4500;
			}
			break;
			case PROC_AEC:{
				ptag_aec paec = (ptag_aec)proc_list[i].parameters;
				
				paec->bypass = 1;
				paec->mode = 0;
			}
			break;
			case PROC_ANS:{
				ptag_ans pans = (ptag_ans)proc_list[i].parameters;
				
				pans->bypass = 1;
				pans->mode = 0;
			}
			break;
			case PROC_SELECTOR:{
				int m;
				ptag_selector pselector = (ptag_selector)proc_list[i].parameters;
				
				pselector->input_num = MAX_MIXER_INPUT;
				pselector->output_num = MAX_MIXER_OUTPUT;
				
				memset(pselector->input_mask,0,sizeof(pselector->input_mask));
			}
			break;
			default:
			break;
		}
	}
}


void scene_analyze()
{
	int i;
	int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);

	
	//ÖØмÓÔس¡¾°Ö®Ç°Çå¿ÕµçƽBUF
	LevelEmpty();
	

	for(i=0;i<proc_cnt;i++){
		proc_list[i].proc_handle = g_opt_ptr[proc_list[i].proc_type].create(
					proc_list[i].parameters
					,proc_list[i].inportstr
					,proc_list[i].outportstr);

		g_procID_table[proc_list[i].proc_id-1] = i;
	}

	


	fft_reset();
}

void scene_destroy()
{
	int i;
	int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);
	
	for(i=0;i<proc_cnt;i++){
		if(proc_list[i].proc_handle!=NULL){
			proc_delete(proc_list[i].proc_handle,proc_list[i].proc_type);	
		}
	}
	pm_entrie_free();
	dm_entrie_free();
	sdram_entrie_free();
}

void scene_running()
{
	int i;
	int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);
	
	for(i=0;i<proc_cnt;i++){
		g_opt_ptr[proc_list[i].proc_type].execute(proc_list[i].proc_handle);
	}
}



int scene_ctrl(int proc_id,int cmd,int* val,int num)
{
	unsigned int id = g_procID_table[proc_id-1];

	if(id>256){
		return -1;
	}
	return g_opt_ptr[proc_list[id].proc_type].ctrl(proc_list[id].proc_handle,cmd,val,num);
}


int scene_cpy(int npkt,const void* param,int size)
{
	int max_len = SPI_DATA_LEN;
	int max_pkts = (sizeof(parameters)+SPI_DATA_LEN-1)/SPI_DATA_LEN;
	int i;

	if(size>max_len){
		return -1;
	}
	if(npkt>=max_pkts){
		return -1;	
	}
	if(npkt==max_pkts-1){
		size = sizeof(parameters)-npkt*SPI_DATA_LEN;
	}
	memcpy((short*)&parameters+npkt*max_len,param,size);
		
	return 0;
}
/*
void topo_analize(short* bin, int file_size)
{
	int i,memory_size;
	void* ptopo;
	int min_buffer;
	error_code_t result;
	
	//¼ÆËã¿ò¼ÜÔËÐбØÐëµÄÄÚ´æ´óС¡£
	memory_size = fw_try_calc_memory_size(bin);
	//Èç¹ûÄÚ´æÂú×ãÔòopen_document
	ptopo = open_document(bin, file_size);
	
	
	min_buffer = fw_topo_min_num_buffer(ptopo);
	result = fw_topo_analize(ptopo, 0xff);
	if (result != RESULT_SUCCESS) {
		printf("Topo file has some error!\n");
	}

	if (ptopo != NULL) {
		fw_processor_destroy();
		close_document(ptopo);
		ptopo = NULL;
	}
}*/