i_gaec.c

TI公司DSP/tms320c55x/tms320c54x系列的声学回声消除代码

/*------------------------------------------------------------------------*
*                                                                         *
*   THIS IS AN UNPUBLISHED WORK CONTAINING CONFIDENTIAL AND PROPRIETARY   *
*   INFORMATION.  IF PUBLICATION OCCURS, THE FOLLOWING NOTICE APPLIES:    *
*      "COPYRIGHT 2001 MIKET DSP SOLUTIONS, ALL RIGHTS RESERVED"          *
*                                                                         *
*-------------------------------------------------------------------------*/
/*
 *  This file contains an implementation of the IALG interface
 *  required by XDAS.
 */
 
#include <gaeci.h>

#include <string.h>         /* memcpy() declaration */

/*--------------------- local defs ----------------------------------------*/

#define DATABASE    1
#define HISTORY     2
#define ADFBUFF     3
#define ADFMBUF     4
#define WORKBUF     5
#define NUMBUFS     6

typedef struct GAEC_MIKET_Obj {
    IALG_Obj    alg;            /* MUST be first field of all XDAS algs */
    GAEC_tDb *pDb;
    GAEC_tSc *pSc;
} GAEC_MIKET_Obj;

/*--------------------- local vars ----------------------------------------*/

/*--------------------- local functions -----------------------------------*/

static Void activate
(IALG_Handle handle);

static Void deactivate
(IALG_Handle handle);

static Int alloc
(const IALG_Params *algParams, IALG_Fxns **pf, IALG_MemRec memTab[]);

static Int free
(IALG_Handle handle, IALG_MemRec memTab[]);                     

static Int control
(IALG_Handle, IALG_Cmd, IALG_Status *);

static Int initObj
(IALG_Handle handle, const IALG_MemRec memTab[], 
IALG_Handle parent,const IALG_Params *algParams);

#if 0                
static Void moved
(IALG_Handle handle, const IALG_MemRec memTab[], 
IALG_Handle parent,const IALG_Params *algParams);
#endif
                
static Int numAlloc(Void);                
static Int process
(IALG_Handle handle,Int *pRcv, Int *pSnd);

#if defined (_dsp)

#pragma CODE_SECTION(activate, ".text:algActivate")
#pragma CODE_SECTION(alloc, ".text:algAlloc")
#pragma CODE_SECTION(numAlloc, ".text:algNumAlloc")
#pragma CODE_SECTION(deactivate, ".text:algDeactivate")
#pragma CODE_SECTION(control, ".text:algControl")
#pragma CODE_SECTION(free, ".text:algFree")
#pragma CODE_SECTION(initObj, ".text:algInit")

#if 0
#pragma CODE_SECTION(moved, ".text:algMoved")
#endif

#pragma CODE_SECTION(process, ".text:algProcess")
#pragma CODE_SECTION(GAEC_MIKET_init, ".text:init")
#pragma CODE_SECTION(GAEC_MIKET_exit, ".text:exit")
#pragma DATA_SECTION(GAEC_MIKET_IGAEC, ".const:GAEC_miket_IGAEC")
#endif

/*-------------------------------------------------------------------------*/
static Int 					alloc
/*-------------------------------------------------------------------------*/
(
const IALG_Params *algParams,
IALG_Fxns **pf, 
IALG_MemRec memTab[]
)
{
#if 0
    const IGAEC_Params *params = (IGAEC_Params *)algParams;

    if (params == NULL) {
        params = &Params;  /* set default parameters */
    }
#endif

    /* Request memory for FIR object */
    memTab[0].size = sizeof(GAEC_MIKET_Obj);
    memTab[0].alignment = 4; /* pointers are long */
    memTab[0].space = IALG_EXTERNAL;
    memTab[0].attrs = IALG_PERSIST;

    memTab[DATABASE].size = sizeof (GAEC_tDb);
    memTab[DATABASE].alignment = 4;
    memTab[DATABASE].space = IALG_SARAM;
    memTab[DATABASE].attrs = IALG_PERSIST;

    memTab[HISTORY].size = sizeof(S16)*GAEC_RCV_SZ*2*GAEC_BANDS;
    memTab[HISTORY].alignment = 2;
    memTab[HISTORY].space = IALG_SARAM1;
    memTab[HISTORY].attrs = IALG_PERSIST;

    memTab[ADFBUFF].size = sizeof(S16)*GAEC_ADF_SZ*2*GAEC_BANDS;
    memTab[ADFBUFF].alignment = 2;
    memTab[ADFBUFF].space = IALG_SARAM1;
    memTab[ADFBUFF].attrs = IALG_PERSIST;

    memTab[ADFMBUF].size = sizeof(S16)*GAEC_ADF_SZ*2*GAEC_BANDS;
    memTab[ADFMBUF].alignment = 2;
    memTab[ADFMBUF].space = IALG_SARAM1;
    memTab[ADFMBUF].attrs = IALG_PERSIST;
    /*
     *  Request memory for shared working buffer
     */
    memTab[WORKBUF].size = sizeof (GAEC_tSc);
    memTab[WORKBUF].alignment = 4;
    memTab[WORKBUF].space = IALG_DARAM0;
    memTab[WORKBUF].attrs = IALG_SCRATCH;
    
    return (NUMBUFS);
}
/*-------------------------------------------------------------------------*/
static Int 						free
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_MemRec memTab[]
)
{
    GAEC_MIKET_Obj *pObj = (GAEC_MIKET_Obj *)handle;

    alloc(NULL, NULL, memTab);

    memTab[DATABASE].base = pObj->pDb;
    memTab[DATABASE].size = sizeof(GAEC_tDb);

    memTab[WORKBUF].base = pObj->pSc;
    memTab[WORKBUF].size = sizeof(GAEC_tSc);

    memTab[HISTORY].base = pObj->pDb->psRcv;
    memTab[HISTORY].size = GAEC_RCV_SZ*2*GAEC_BANDS;

    memTab[ADFBUFF].base = pObj->pDb->psAdf;
    memTab[ADFBUFF].size = GAEC_ADF_SZ*2*GAEC_BANDS;

    memTab[ADFMBUF].base = pObj->pDb->psAdfM;
    memTab[ADFMBUF].size = GAEC_ADF_SZ*2*GAEC_BANDS;

    return (NUMBUFS);
}

/*-------------------------------------------------------------------------*/
static Int 						initObj
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle,
const IALG_MemRec memTab[], 
IALG_Handle p,
const IALG_Params *algParams
)
{
    GAEC_MIKET_Obj *pObj = (GAEC_MIKET_Obj *)handle;

    pObj->pSc = (GAEC_tSc *)memTab[WORKBUF].base;
    pObj->pDb = (GAEC_tDb *)memTab[HISTORY].base;

	if (algParams == NULL)
	{
		extern const IGAEC_tCfg IGAEC_MIKET_DefaultCfg;
    	GAEC_MIKET_init_db(
    		pObj->pDb, 
    		(IGAEC_tCfg *)&IGAEC_MIKET_DefaultCfg, 
    		(S16 *)memTab[HISTORY].base,
    		(S16 *)memTab[ADFBUFF].base,
    		(S16 *)memTab[ADFMBUF].base
            );
    }
    else
    {
    	IGAEC_tCfg *pCfg = ((IGAEC_Params *)algParams)->pCfg;
    	GAEC_MIKET_init_db(
    		pObj->pDb, 
    		pCfg, 
    		(S16 *)memTab[HISTORY].base,
    		(S16 *)memTab[ADFBUFF].base,
    		(S16 *)memTab[ADFMBUF].base
            );
    }

    return (IALG_EOK);
}

/*-------------------------------------------------------------------------*/
static Int 						control
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_Cmd Cmd, 
IALG_Status *pStatus
)
{
    GAEC_MIKET_Obj *pObj = (GAEC_MIKET_Obj *)handle;
	GAEC_MIKET_control(pObj->pDb, Cmd, (IGAEC_Status *)pStatus);
    return (IALG_EOK);
}
/*-------------------------------------------------------------------------*/
static Void 					activate
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle
)
{
/*   GAEC_MIKET_Obj *pObj = (Void *)handle; */
}

/*-------------------------------------------------------------------------*/
static Void 					deactivate
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle
)
{                 
}
/*-------------------------------------------------------------------------*/
static Int 						numAlloc
/*-------------------------------------------------------------------------*/
(
)
{                 
	return NUMBUFS;
}

#if 0
/*-------------------------------------------------------------------------*/
static Void 					moved
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle,
const IALG_MemRec memTab[], 
IALG_Handle p,
const IALG_Params *algParams
)
{
    GAEC_MIKET_Obj *pObj = (GAEC_MIKET_Obj *)handle;

    pObj->pSc = (GAEC_tSc *)memTab[WORKBUF].base;
    pObj->pDb = (GAEC_tDb *)memTab[HISTORY].base;
}              
#endif

/*-------------------------------------------------------------------------*/
static Int 						process
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle,
Int *pRcv,
Int *pSnd
)
{
    GAEC_MIKET_Obj *pObj = (GAEC_MIKET_Obj *)handle;

	GAEC_MIKET_process(pObj->pDb, pObj->pSc, pRcv, pSnd);
    return 0;
}

/*--------------------- public  functions ---------------------------------*/

/*-------------------------------------------------------------------------*/
Void 				GAEC_MIKET_exit
/*-------------------------------------------------------------------------*/
(
) 
{
}
/*-------------------------------------------------------------------------*/
Void 				GAEC_MIKET_init
/*-------------------------------------------------------------------------*/
(
)
{
}

/*--------------------- public vars ---------------------------------------*/

#if defined (_dsp)
	asm(" .global _GAEC_MIKET_IALG");
	asm("_GAEC_MIKET_IALG .set _GAEC_MIKET_IGAEC");
#endif

const IGAEC_Fxns GAEC_MIKET_IGAEC = {       /* module_vendor_interface */
    (void *)&GAEC_MIKET_IGAEC,       /* module ID */ 
    activate,    /* activate */  
    alloc,       /* alloc */     
    control,     /* control */   
    deactivate,  /* deactivate */
    free,        /* free */      
    initObj,     /* init */      
    NULL,        /* moved */     
    numAlloc,	 /* numAlloc */
    process      /*  */
};

const char	GAEC_MIKET_Version[] = __DATE__;//0x0102;

/*-------------------------------------------------------------------------*/