DSP/AD1802/BDpro.git

#include "scene.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "ModuleExport.h"
#include "config.h"
#include "../drv/spi.h"
#include "tob.h"
//#include "memory.h"
#include "crc.h"
#include "../drv/memory.h"
 
#define OFFSET(TYPE_PTR,VALUE) ((int)&((TYPE_PTR)0)->VALUE)
 
static short g_procID_table[MAX_MODULE_NUM] = {0};
 
int input_num_channels = 16;
int output_num_channels = 16;
 
int local_input_channels_num =8;
int local_output_channels_num =8;
int dante_input_channels_num =0;
int dante_output_channels_num =0;
 
#pragma section("scene_mem")
static tag_parameters parameters;
 
#pragma section("scene_mem")
static struct proc_field{
    short proc_id;
    u8 proc_type;
 
    char ninports[8];
    char noutports[8];
 
    const u8 dsp_index ; ///DSP index.
    const u8 fixed ; /// ¹Ì¶¨or¶¯Ì¬Ä£¿é
    u8 filter; //ÊÇ·ñ¹ýÂË´ËÄ£¿é
    u8 phymodule;
 
    void * const parameters;
 
    u16 level_index;
    u16  tagID;
} proc_list[]={
        {300,PROC_SIGNALGEN,"1-32","1-32",0,1,0,0, &parameters.input}
        ,{299,PROC_INPUT,"1-32","1-32",0,1,0,1 ,&parameters.input}
        ,{298,PROC_METER,"1-32","",0,1,0,0,0}
 
 
        ,{1,PROC_EXPANDER,"1|32","1",0,0,1,0,&parameters.in1[0]},{2,PROC_EXPANDER,"2|32","2",0,0,1,0,&parameters.in1[1]}
        ,{3,PROC_EXPANDER,"3|32","3",0,0,1,0,&parameters.in1[2]},{4,PROC_EXPANDER,"4|32","4",0,0,1,0,&parameters.in1[3]}
        ,{5,PROC_EXPANDER,"5|32","5",0,0,1,0,&parameters.in1[4]},{6,PROC_EXPANDER,"6|32","6",0,0,1,0,&parameters.in1[5]}
        ,{7,PROC_EXPANDER,"7|32","7",0,0,1,0,&parameters.in1[6]},{8,PROC_EXPANDER,"8|32","8",0,0,1,0,&parameters.in1[7]}
//        ,{9,PROC_EXPANDER,"9|32","9",0,0,1,0,&parameters.in1[8]},{10,PROC_EXPANDER,"10|32","10",0,0,1,0,&parameters.in1[9]}
//        ,{11,PROC_EXPANDER,"11|32","11",0,0,1,0,&parameters.in1[10]},{12,PROC_EXPANDER,"12|32","12",0,0,1,0,&parameters.in1[11]}
//        ,{13,PROC_EXPANDER,"13|32","13",0,0,1,0,&parameters.in1[12]},{14,PROC_EXPANDER,"14|32","14",0,0,1,0,&parameters.in1[13]}
//        ,{15,PROC_EXPANDER,"15|32","15",0,0,1,0,&parameters.in1[14]},{16,PROC_EXPANDER,"16|32","16",0,0,1,0,&parameters.in1[15]}
 
 
        ,{33,PROC_COMPRESS,"1|32","1",0,0,1,0,&parameters.in2[0]},{34,PROC_COMPRESS,"2|32","2",0,0,1,0,&parameters.in2[1]}
        ,{35,PROC_COMPRESS,"3|32","3",0,0,1,0,&parameters.in2[2]},{36,PROC_COMPRESS,"4|32","4",0,0,1,0,&parameters.in2[3]}
        ,{37,PROC_COMPRESS,"5|32","5",0,0,1,0,&parameters.in2[4]},{38,PROC_COMPRESS,"6|32","6",0,0,1,0,&parameters.in2[5]}
        ,{39,PROC_COMPRESS,"7|32","7",0,0,1,0,&parameters.in2[6]},{40,PROC_COMPRESS,"8|32","8",0,0,1,0,&parameters.in2[7]}
//        ,{41,PROC_COMPRESS,"9|32","9",0,0,1,0,&parameters.in2[8]},{42,PROC_COMPRESS,"10|32","10",0,0,1,0,&parameters.in2[9]}
//        ,{43,PROC_COMPRESS,"11|32","11",0,0,1,0,&parameters.in2[10]},{44,PROC_COMPRESS,"12|32","12",0,0,1,0,&parameters.in2[11]}
//        ,{45,PROC_COMPRESS,"13|32","13",0,0,1,0,&parameters.in2[12]},{46,PROC_COMPRESS,"14|32","14",0,0,1,0,&parameters.in2[13]}
//        ,{47,PROC_COMPRESS,"15|32","15",0,0,1,0,&parameters.in2[14]},{48,PROC_COMPRESS,"16|32","16",0,0,1,0,&parameters.in2[15]}
 
 
        ,{65,PROC_AGC,"1|32","1",0,0,1,0,&parameters.in3[0]},{66,PROC_AGC,"2|32","2",0,0,1,0,&parameters.in3[1]}
        ,{67,PROC_AGC,"3|32","3",0,0,1,0,&parameters.in3[2]},{68,PROC_AGC,"4|32","4",0,0,1,0,&parameters.in3[3]}
        ,{69,PROC_AGC,"5|32","5",0,0,1,0,&parameters.in3[4]},{70,PROC_AGC,"6|32","6",0,0,1,0,&parameters.in3[5]}
        ,{71,PROC_AGC,"7|32","7",0,0,1,0,&parameters.in3[6]},{72,PROC_AGC,"8|32","8",0,0,1,0,&parameters.in3[7]}
//        ,{73,PROC_AGC,"9|32","9",0,0,1,0,&parameters.in3[8]},{74,PROC_AGC,"10|32","10",0,0,1,0,&parameters.in3[9]}
//        ,{75,PROC_AGC,"11|32","11",0,0,1,0,&parameters.in3[10]},{76,PROC_AGC,"12|32","12",0,0,1,0,&parameters.in3[11]}
//        ,{77,PROC_AGC,"13|32","13",0,0,1,0,&parameters.in3[12]},{78,PROC_AGC,"14|32","14",0,0,1,0,&parameters.in3[13]}
//        ,{79,PROC_AGC,"15|32","15",0,0,1,0,&parameters.in3[14]},{80,PROC_AGC,"16|32","16",0,0,1,0,&parameters.in3[15]}
 
 
        ,{97,PROC_EQ,"1|32","1",0,0,1,0,&parameters.in4[0]},{98,PROC_EQ,"2|32","2",0,0,1,0,&parameters.in4[1]}
        ,{99,PROC_EQ,"3|32","3",0,0,1,0,&parameters.in4[2]},{100,PROC_EQ,"4|32","4",0,0,1,0,&parameters.in4[3]}
        ,{101,PROC_EQ,"5|32","5",0,0,1,0,&parameters.in4[4]},{102,PROC_EQ,"6|32","6",0,0,1,0,&parameters.in4[5]}
        ,{103,PROC_EQ,"7|32","7",0,0,1,0,&parameters.in4[6]},{104,PROC_EQ,"8|32","8",0,0,1,0,&parameters.in4[7]}
//        ,{105,PROC_EQ,"9|32","9",0,0,1,0,&parameters.in4[8]},{106,PROC_EQ,"10|32","10",0,0,1,0,&parameters.in4[9]}
//        ,{107,PROC_EQ,"11|32","11",0,0,1,0,&parameters.in4[10]},{108,PROC_EQ,"12|32","12",0,0,1,0,&parameters.in4[11]}
//        ,{109,PROC_EQ,"13|32","13",0,0,1,0,&parameters.in4[12]},{110,PROC_EQ,"14|32","14",0,0,1,0,&parameters.in4[13]}
//        ,{111,PROC_EQ,"15|32","15",0,0,1,0,&parameters.in4[14]},{112,PROC_EQ,"16|32","16",0,0,1,0,&parameters.in4[15]}
 
 
        ,{129,PROC_FEEDBACK,"1|32","1",0,0,1,0,&parameters.in5[0]},{130,PROC_FEEDBACK,"2|32","2",0,0,1,0,&parameters.in5[1]}
        ,{131,PROC_FEEDBACK,"3|32","3",0,0,1,0,&parameters.in5[2]},{132,PROC_FEEDBACK,"4|32","4",0,0,1,0,&parameters.in5[3]}
        ,{133,PROC_FEEDBACK,"5|32","5",0,0,1,0,&parameters.in5[4]},{134,PROC_FEEDBACK,"6|32","6",0,0,1,0,&parameters.in5[5]}
        ,{135,PROC_FEEDBACK,"7|32","7",0,0,1,0,&parameters.in5[6]},{136,PROC_FEEDBACK,"8|32","8",0,0,1,0,&parameters.in5[7]}
//        ,{137,PROC_FEEDBACK,"9|32","9",0,0,1,0,&parameters.in5[8]},{138,PROC_FEEDBACK,"10|32","10",0,0,1,0,&parameters.in5[9]}
//        ,{139,PROC_FEEDBACK,"11|32","11",0,0,1,0,&parameters.in5[10]},{140,PROC_FEEDBACK,"12|32","12",0,0,1,0,&parameters.in5[11]}
//        ,{141,PROC_FEEDBACK,"13|32","13",0,0,1,0,&parameters.in5[12]},{142,PROC_FEEDBACK,"14|32","14",0,0,1,0,&parameters.in5[13]}
//        ,{143,PROC_FEEDBACK,"15|32","15",0,0,1,0,&parameters.in5[14]},{144,PROC_FEEDBACK,"16|32","16",0,0,1,0,&parameters.in5[15]}
 
 
        ,{161,PROC_AUTOMIXER,"1-32","1-33",0,1,1,0,&parameters.automixer}
        ,{162,PROC_SELECTOR,"1-34","35-36",0,1,1,0,&parameters.aec_selector}  //usb
        ,{163,PROC_AEC,"35-36","35",0,1,1,0,&parameters.aec}
 
        ,{164,PROC_SELECTOR,"1-35","36",1,1,1,0,&parameters.ans_selector}
        ,{165,PROC_ANS,"36","36",1,1,1,0,&parameters.ans}
        ,{166,PROC_MIXER,"1-36","1-32",1,1,1,0,&parameters.mixer}
 
        ,{167,PROC_CROSSOVER,"1","1",1,0,0,0,&parameters.out1[0]},{168,PROC_CROSSOVER,"2","2",1,0,0,0,&parameters.out1[1]}
        ,{169,PROC_CROSSOVER,"3","3",1,0,0,0,&parameters.out1[2]},{170,PROC_CROSSOVER,"4","4",1,0,0,0,&parameters.out1[3]}
        ,{171,PROC_CROSSOVER,"5","5",1,0,0,0,&parameters.out1[4]},{172,PROC_CROSSOVER,"6","6",1,0,0,0,&parameters.out1[5]}
        ,{173,PROC_CROSSOVER,"7","7",1,0,0,0,&parameters.out1[6]},{174,PROC_CROSSOVER,"8","8",1,0,0,0,&parameters.out1[7]}
//        ,{175,PROC_CROSSOVER,"9","9",1,0,0,0,&parameters.out1[8]},{176,PROC_CROSSOVER,"10","10",1,0,0,0,&parameters.out1[9]}
//        ,{177,PROC_CROSSOVER,"11","11",1,0,0,0,&parameters.out1[10]},{178,PROC_CROSSOVER,"12","12",1,0,0,0,&parameters.out1[11]}
//        ,{179,PROC_CROSSOVER,"13","13",1,0,0,0,&parameters.out1[12]},{180,PROC_CROSSOVER,"14","14",1,0,0,0,&parameters.out1[13]}
//        ,{181,PROC_CROSSOVER,"15","15",1,0,0,0,&parameters.out1[14]},{182,PROC_CROSSOVER,"16","16",1,0,0,0,&parameters.out1[15]}
 
        ////
        ,{199,PROC_EQ,"1","1",1,0,0,0,&parameters.out2[0]},{200,PROC_EQ,"2","2",1,0,0,0,&parameters.out2[1]}
        ,{201,PROC_EQ,"3","3",1,0,0,0,&parameters.out2[2]},{202,PROC_EQ,"4","4",1,0,0,0,&parameters.out2[3]}
        ,{203,PROC_EQ,"5","5",1,0,0,0,&parameters.out2[4]},{204,PROC_EQ,"6","6",1,0,0,0,&parameters.out2[5]}
        ,{205,PROC_EQ,"7","7",1,0,0,0,&parameters.out2[6]},{206,PROC_EQ,"8","8",1,0,0,0,&parameters.out2[7]}
//        ,{207,PROC_EQ,"9","9",1,0,0,0,&parameters.out2[8]},{208,PROC_EQ,"10","10",1,0,0,0,&parameters.out2[9]}
//        ,{209,PROC_EQ,"11","11",1,0,0,0,&parameters.out2[10]},{210,PROC_EQ,"12","12",1,0,0,0,&parameters.out2[11]}
//        ,{211,PROC_EQ,"13","13",1,0,0,0,&parameters.out2[12]},{212,PROC_EQ,"14","14",1,0,0,0,&parameters.out2[13]}
//        ,{213,PROC_EQ,"15","15",1,0,0,0,&parameters.out2[14]},{214,PROC_EQ,"16","16",1,0,0,0,&parameters.out2[15]}
 
 
        ,{231,PROC_DELAY,"1","1",1,0,0,0,&parameters.out3[0]},{232,PROC_DELAY,"2","2",1,0,0,0,&parameters.out3[1]}
        ,{233,PROC_DELAY,"3","3",1,0,0,0,&parameters.out3[2]},{234,PROC_DELAY,"4","4",1,0,0,0,&parameters.out3[3]}
        ,{235,PROC_DELAY,"5","5",1,0,0,0,&parameters.out3[4]},{236,PROC_DELAY,"6","6",1,0,0,0,&parameters.out3[5]}
        ,{237,PROC_DELAY,"7","7",1,0,0,0,&parameters.out3[6]},{238,PROC_DELAY,"8","8",1,0,0,0,&parameters.out3[7]}
//        ,{239,PROC_DELAY,"9","9",1,0,0,0,&parameters.out3[8]},{240,PROC_DELAY,"10","10",1,0,0,0,&parameters.out3[9]}
//        ,{241,PROC_DELAY,"11","11",1,0,0,0,&parameters.out3[10]},{242,PROC_DELAY,"12","12",1,0,0,0,&parameters.out3[11]}
//        ,{243,PROC_DELAY,"13","13",1,0,0,0,&parameters.out3[12]},{244,PROC_DELAY,"14","14",1,0,0,0,&parameters.out3[13]}
//        ,{245,PROC_DELAY,"15","15",1,0,0,0,&parameters.out3[14]},{246,PROC_DELAY,"16","16",1,0,0,0,&parameters.out3[15]}
 
 
        ,{263,PROC_LIMIT,"1","1",1,0,0,0,&parameters.out4[0]},{264,PROC_LIMIT,"2","2",1,0,0,0,&parameters.out4[1]}
        ,{265,PROC_LIMIT,"3","3",1,0,0,0,&parameters.out4[2]},{266,PROC_LIMIT,"4","4",1,0,0,0,&parameters.out4[3]}
        ,{267,PROC_LIMIT,"5","5",1,0,0,0,&parameters.out4[4]},{268,PROC_LIMIT,"6","6",1,0,0,0,&parameters.out4[5]}
        ,{269,PROC_LIMIT,"7","7",1,0,0,0,&parameters.out4[6]},{270,PROC_LIMIT,"8","8",1,0,0,0,&parameters.out4[7]}
//        ,{271,PROC_LIMIT,"9","9",1,0,0,0,&parameters.out4[8]},{272,PROC_LIMIT,"10","10",1,0,0,0,&parameters.out4[9]}
//        ,{273,PROC_LIMIT,"11","11",1,0,0,0,&parameters.out4[10]},{274,PROC_LIMIT,"12","12",1,0,0,0,&parameters.out4[11]}
//        ,{275,PROC_LIMIT,"13","13",1,0,0,0,&parameters.out4[12]},{276,PROC_LIMIT,"14","14",1,0,0,0,&parameters.out4[13]}
//        ,{277,PROC_LIMIT,"15","15",1,0,0,0,&parameters.out4[14]},{278,PROC_LIMIT,"16","16",1,0,0,0,&parameters.out4[15]}
 
 
        ,{295,PROC_OUTPUT,"1-32","1-32",1,1,1,2,&parameters.output}
 
 
        ,{296,PROC_SYSCTL,"1-32","1-32",1,1,1,0,&parameters.sysctl}
        ,{297,PROC_METER,"1-32","1-32",1,1,1,0,0} //151
};
 
int str_delim(const char* str, unsigned short* bufID)
{
    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, "-");
        if(ptr)
            end = atoi(ptr);
        else
            end = start;
 
        while (start<=end)
        {
            if(bufID) bufID[i] = start++;
            i++;
        }
        return i;
    }
    else
    {
        while (ptr)
        {
            if(bufID) bufID[i] = atoi(ptr);
            i++;
            ptr = strtok(NULL, "|");
        }
        return i;
    }
}
 
int scene_get_proc_type(short proc_id)
{
    unsigned int id ;
 
    if(proc_id > 320)  return -1;
    id = g_procID_table[proc_id-1];
 
    return proc_list[id].proc_type;
}
 
void scene_type_update()
{
    int i ;
    int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);
    ptag_module pmodule ;
    unsigned char ch;
    unsigned char update_en = 0;
 
    for(i=0;i< proc_cnt;i++){
        if(proc_list[i].fixed == 0 && proc_list[i].parameters != NULL){
            pmodule = (ptag_module)proc_list[i].parameters;
 
            pmodule->proc_type = proc_list[i].proc_type;
        }
 
 
        if(proc_list[i].proc_id == 300 || proc_list[i].proc_id == 299 || proc_list[i].proc_id == 298){
                 //signal gen
            sprintf(proc_list[i].ninports, "1-%d", input_num_channels );
            sprintf(proc_list[i].noutports, "1-%d", input_num_channels );
            proc_list[i].filter =0 ;
        }
        else if( (proc_list[i].proc_id >= 1 && proc_list[i].proc_id <= 160)) {//in1-in5
            u16 bufID[2];
            str_delim(proc_list[i].noutports, bufID);
            sprintf(proc_list[i].ninports, "%d|%d", bufID[0], input_num_channels);
            if(bufID[0] > input_num_channels) {
                proc_list[i].filter = 1 ;
            }
            else {
                proc_list[i].filter = 0 ;
            }
        }
        else if(proc_list[i].proc_id == 161){
            //automixer
            sprintf(proc_list[i].ninports, "1-%d", input_num_channels);
            sprintf(proc_list[i].noutports, "1-%d", input_num_channels+1);
            proc_list[i].filter = 0 ;
        }
        else if(proc_list[i].proc_id == 162){
            //aec_selector
            sprintf(proc_list[i].ninports, "1-%d", input_num_channels+ 2);//input_channels+automixer
            sprintf(proc_list[i].noutports, "%d|%d", input_num_channels+ 3, input_num_channels+ 4);//aec+ans
            proc_list[i].filter = 0 ;
            //proc_list[i].fixed = 36
        }
        else if(proc_list[i].proc_id == 163){
             //aec
            sprintf(proc_list[i].ninports, "%d|%d", input_num_channels+ 3, input_num_channels+ 4);//aec+ans
            sprintf(proc_list[i].noutports, "%d", input_num_channels+ 3);//input_channels+aec+ans
            proc_list[i].filter = 0 ;
        }
        else if(proc_list[i].proc_id == 164 ){
             //ans_selector
            sprintf(proc_list[i].ninports, "1-%d", input_num_channels+ 3);
            sprintf(proc_list[i].noutports, "%d", input_num_channels+ 4);
            proc_list[i].filter = 0 ;
            //proc_list[i].fixed = 37;
        }
        else if(proc_list[i].proc_id == 165 ){
             //ans
            sprintf(proc_list[i].ninports, "%d", input_num_channels+ 4);
            sprintf(proc_list[i].noutports, "%d", input_num_channels+ 4);
            proc_list[i].filter = 0 ;
        }
        else if(proc_list[i].proc_id == 166 ){
             //matrix
            sprintf(proc_list[i].ninports, "1-%d", input_num_channels+ 4);//automixer+aec+ans
            sprintf(proc_list[i].noutports, "1-%d", output_num_channels+ 1);
            proc_list[i].filter = 0 ;
        }
        else if( (proc_list[i].proc_id >= 167 && proc_list[i].proc_id <= 294)) {//out1-out4
            u16 bufID[2];
            str_delim(proc_list[i].noutports, bufID);
            if(bufID[0] > output_num_channels) {
                proc_list[i].filter = 1 ;
            }
            else {
                proc_list[i].filter = 0 ;
            }
        }
        else if(proc_list[i].proc_id == 295 || proc_list[i].proc_id == 296 || proc_list[i].proc_id == 297){
             //output & sysctl &mter
            sprintf(proc_list[i].ninports, "1-%d", output_num_channels);
            sprintf(proc_list[i].noutports, "1-%d", output_num_channels);
            proc_list[i].filter = 0 ;
        }
        else {
            proc_list[i].filter = 0;
        }
 
        if(proc_list[i].proc_type == PROC_EQ){
            ptag_eq peq = (ptag_eq)pmodule->proc_ins;
            proc_list[i].tagID = peq->nsection;
        }
        else if(proc_list[i].proc_type == PROC_DELAY){
            proc_list[i].tagID = MAX_DELAY_MSEC;
        }
        else if(proc_list[i].proc_type == PROC_CROSSOVER){
            proc_list[i].tagID = 1;
        }
        else if(proc_list[i].proc_type == PROC_FEEDBACK){
            ptag_feedback pfbc = (ptag_feedback)pmodule->proc_ins;
            proc_list[i].tagID = FEEDBACK_FILTERS_NUM;//pfbc->fbc_num;
        }
        else if(proc_list[i].proc_type == PROC_AEC){
            proc_list[i].tagID = 32000;
        }
        else if(proc_list[i].proc_type == PROC_ANS){
            proc_list[i].tagID = 16000;
        }
        else if(proc_list[i].proc_type == PROC_GEQ){
            ptag_geq pgeq = (ptag_geq)pmodule->proc_ins;
            proc_list[i].tagID = pgeq->nsections;
        }
        else{
            proc_list[i].tagID = 0;
        }
 
        g_procID_table[proc_list[i].proc_id-1] = i;
    }
}
 
 
 
static void* ToDSPScene(int mtype, void *param, int fixed)
{
    void *ptr = NULL;
 
    if(fixed == 0){
        ptag_module pmod = (ptag_module)param;
        ptr = (void*)pmod->proc_ins;
    }
    else{
        ptr = param;
    }
 
    return ptr;
}
 
 
void SceneToDSPFlowchart(char *bin, int *ret_size)
{
    int i ,j;
    int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);
 
    struct FlowChartHead* flowchart = (struct FlowChartHead*)bin;
    u32 size =  sizeof(struct FlowChartHead);
    int ninports,noutports;
    u16 rxBufID[64],txBufID[64];
    u16 dsp_input_num[2] ={0,0};
    u16 dsp_output_num[2] ={0,0};
 
    u32 pmoud_id;
 
    int wpos;
    int tmp = 2048;
    int crc = 0xFFFFFFFF;
 
    if (!bin) return;
 
 
    for (i=0; i<proc_cnt; i++) {
        struct ModuleParam *m  = (struct ModuleParam *)(bin + size);
        struct proc_field * p = &proc_list[i];
 
        ninports = str_delim(proc_list[i].ninports, rxBufID) ;
        noutports = str_delim(proc_list[i].noutports , txBufID) ;
 
        if(proc_list[i].filter){
            continue;
        }
 
        //ducker & spl.
        if(proc_list[i].proc_type == PROC_DUCKER || proc_list[i].proc_type == PROC_CONTINUNOUS_SPL) {
            //insert a mixer.
            struct ModuleParam *mixer  = (struct ModuleParam *)(bin + size);
            //ptag_module pmod = (ptag_module)p->parameters;
            u16 channelID[64];
 
            mixer->mDsp = 0;
            mixer->mID = p->proc_id + 320;
            mixer->mType = PROC_MIXER;
            mixer->mTag = 0;
            mixer->mPhyModule =0;
            mixer->handle = ToDSPScene(p->proc_type,p->parameters,p->fixed);
 
            size += sizeof(struct ModuleParam);
 
            mixer->mRxNum = str_delim(proc_list[1].ninports, channelID) ;
            memcpy(bin + size , channelID, mixer->mRxNum*sizeof(u16)); size += mixer->mRxNum*sizeof(u16);
            mixer->mTxNum = 1;
            memcpy(bin + size , &rxBufID[1], mixer->mTxNum*sizeof(u16)); size += mixer->mTxNum*sizeof(u16);
 
            //scene_size += ToDSPScene(bin_scene,p->proc_type,p->parameters,p->fixed,scene_size);
        }
 
        m  = (struct ModuleParam *)(bin + size);
        for(j = 0 ; j< ninports ;j ++) {
            if(rxBufID[j] > dsp_input_num[p->dsp_index]) {
                dsp_input_num[p->dsp_index] = rxBufID[j];
            }
        }
        for(j = 0 ; j< noutports ;j ++) {
            if(txBufID[j] > dsp_output_num[p->dsp_index]) {
                dsp_output_num[p->dsp_index] = txBufID[j];
            }
        }
 
        m->mDsp = 0;
        m->mID = p->proc_id;
        m->mType = p->proc_type;
        m->mTag = p->tagID;
        m->mPhyModule =p->phymodule;
 
        m->handle = ToDSPScene(p->proc_type,p->parameters,p->fixed);
 
        size += sizeof(struct ModuleParam);
        m->mRxNum = ninports;
        memcpy(bin + size , rxBufID, m->mRxNum*sizeof(u16)); size += m->mRxNum*sizeof(u16);
        m->mTxNum = noutports;
        memcpy(bin + size , txBufID, m->mTxNum*sizeof(u16)); size += m->mTxNum*sizeof(u16);
 
        //scene_size += ToDSPScene(bin_scene,p->proc_type,p->parameters,p->fixed,scene_size);
    }
 
    ninports = dsp_input_num[0]>dsp_output_num[0]?dsp_input_num[0]:dsp_output_num[0];
    noutports = dsp_input_num[1]>dsp_output_num[1]?dsp_input_num[1]:dsp_output_num[1];
 
    if(0) {
        flowchart->dsp_buffer_num[0] = ninports;
        flowchart->dsp_buffer_num[1] = noutports;
    }
    else {
        flowchart->dsp_buffer_num[0] = ninports>noutports?ninports:noutports;
    }
 
    flowchart->module_num = proc_cnt;
    flowchart->crcLsb = 0;
    flowchart->crcMsb = 0;
    flowchart->compress = 0;
 
    crc = CRC::crc32((const u8*)bin, size);
 
    flowchart->crcLsb = crc & 0xffff;
    flowchart->crcMsb = crc >> 16;
 
 
    *ret_size = size;
}
 
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;
}
 
static int scene_can_copy(ptag_module  psrc, ptag_module pdst, int input)
{
    int i;
    int number = input?5:4;
    int channels_delim = input?MAX_INPUT_NUM:MAX_OUTPUT_NUM;
 
    for(i=0;i<number;i++){
        if(psrc->proc_type != pdst->proc_type){
            return 0;
        }
        psrc+=channels_delim;
        pdst+=channels_delim;
    }
    return 1;
}
 
static void scene_copy(ptag_module  psrc, ptag_module pdst, int input)
{
    int i;
    int number = input?5:4;
    int channels_delim = input?MAX_INPUT_NUM:MAX_OUTPUT_NUM;
 
    for(i=0;i<number;i++){
        memcpy(pdst , psrc , sizeof(tag_module));
        psrc += channels_delim;
        pdst += channels_delim;
    }
}
 
static int find_proc_by_paramaddr(int addr)
{
    int i;
    int paramaddr;
    int proc_cnt = sizeof(proc_list)/sizeof(struct proc_field);
 
    for(i=0;i<proc_cnt;i++){
        paramaddr = (int)(proc_list[i].parameters);
        if(paramaddr == addr){
            return i;
        }
    }
    return -1;
}
 
static void update_copy(int output , int channel)
{
    ToB* tob = ToB::GetInstance();
    short proc_id, index;
    ptag_module pmodule;
 
    if(output){
        tob->SetModuleParam(PROC_OUTPUT, 295, &parameters.output);
 
        pmodule = &parameters.out1[channel];
        for(u32 i = 0; i < 4; i++){
            index = find_proc_by_paramaddr((int)pmodule);
            proc_id = proc_list[index].proc_id;
            tob->SetModuleParam(pmodule->proc_type, proc_id, pmodule->proc_ins);
            pmodule += MAX_OUTPUT_NUM;
        }
    }
    else{
        tob->SetModuleParam(PROC_SIGNALGEN, 300, &parameters.input);
        tob->SetModuleParam(PROC_INPUT, 299, &parameters.input);
 
        pmodule = &parameters.in1[channel];
        for(u32 i = 0; i < 5; i++){
            index = find_proc_by_paramaddr((int)pmodule);
            proc_id = proc_list[index].proc_id;
            tob->SetModuleParam(pmodule->proc_type, proc_id, pmodule->proc_ins);
            pmodule += MAX_INPUT_NUM;
        }
    }
}
 
int scene_channel_copy(ptag_channel_copy pchannels)
{
    ptag_module psrc;
    ptag_module pdst ;
 
    if(pchannels->output == 0){
        if(pchannels->source_channel_index>= MAX_INPUT_NUM
            || pchannels->dest_channel_index>= MAX_INPUT_NUM ){
                return 0;
        }
 
        psrc = &parameters.in1[pchannels->source_channel_index];
        pdst = &parameters.in1[pchannels->dest_channel_index];
 
        if(scene_can_copy(psrc ,pdst , 1)){
            scene_copy(psrc ,pdst , 1);
 
            memcpy(&parameters.input.input[pchannels->dest_channel_index]
                        , &parameters.input.input[pchannels->source_channel_index]
                        , sizeof(parameters.input.input[0]));
 
            update_copy(0 , pchannels->dest_channel_index);
        }
        else{
            return 0;
        }
    }
    else{
        if(pchannels->source_channel_index>= MAX_OUTPUT_NUM
            || pchannels->dest_channel_index>= MAX_OUTPUT_NUM ){
                return 0;
        }
 
        psrc = &parameters.out1[pchannels->source_channel_index];
        pdst = &parameters.out1[pchannels->dest_channel_index];
 
        if(scene_can_copy(psrc ,pdst , 0)){
            scene_copy(psrc ,pdst , 0);
 
            memcpy(&parameters.output.output[pchannels->dest_channel_index]
                        , &parameters.output.output[pchannels->source_channel_index]
                        , sizeof(parameters.output.output[0]));
 
            update_copy(1 , pchannels->dest_channel_index);
        }
        else{
            return 0;
        }
    }
    return 1;
}