i_lec.c

The line echo canceller (LEC) is designed to provide the maximum attainable transparent voice qualit

/*------------------------------------------------------------------------*
*                                                                         *
*   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 <leci.h>

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

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

#define DATABASE 1
#define HISTORY 2
#define AFILTER 3
#define STTS    4
#define WORKBUF 5
#define NUMBUFS 6

typedef struct LEC_MIKET_Obj {
    IALG_Obj    alg;            /* MUST be first field of all XDAS algs */
    LEC_tDb *pDb;
    LEC_tSc *pSc;
} LEC_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(LEC_MIKET_init, ".text:init")
#pragma CODE_SECTION(LEC_MIKET_exit, ".text:exit")
#pragma DATA_SECTION(LEC_MIKET_ILEC, ".const:LEC_miket_ILEC")
#endif

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

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

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

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

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

    memTab[AFILTER].size = sizeof (S16)*LEC_FLT2_SZ*2;
    memTab[AFILTER].alignment = 2;
    memTab[AFILTER].space = IALG_DARAM1;
    memTab[AFILTER].attrs = IALG_PERSIST;

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

    /*
     *  Request memory for shared working buffer
     */
    memTab[WORKBUF].size = sizeof (LEC_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[]
)
{
    LEC_MIKET_Obj *pObj = (LEC_MIKET_Obj *)handle;

    alloc(NULL, NULL, memTab);

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

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

    memTab[HISTORY].base = pObj->pDb->psHst;
    memTab[HISTORY].size = LEC_HST_SZ*2;

    memTab[AFILTER].base = pObj->pDb->psFlt1;
    memTab[AFILTER].size = LEC_FLT2_SZ*2;

    memTab[STTS].base = pObj->pDb->pStts;
    memTab[STTS].size = sizeof(LEC_MIKET_tStts);

    return (NUMBUFS);
}

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

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

	if (algParams == NULL)
	{
//		extern const ILEC_tCfg ILEC_MIKET_DefaultCfg;
    	LEC_MIKET_init_db(
    		pObj->pDb, 
    		(ILEC_tCfg *)&ILEC_MIKET_DefaultCfg, 
    		(LEC_MIKET_tStts *)memTab[STTS].base,
    		(S16 *)memTab[HISTORY].base,
    		(S16 *)memTab[AFILTER].base);
    }
    else
    {
    	ILEC_tCfg *pCfg = ((ILEC_Params *)algParams)->pCfg;
    	LEC_MIKET_init_db(
    		pObj->pDb, 
    		pCfg, 
    		(LEC_MIKET_tStts *)memTab[STTS].base,
    		(S16 *)memTab[HISTORY].base,
    		(S16 *)memTab[AFILTER].base);
    }

    return (IALG_EOK);
}

/*-------------------------------------------------------------------------*/
static Int 						control
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_Cmd Cmd, 
IALG_Status *pStatus
)
{
    LEC_MIKET_Obj *pObj = (LEC_MIKET_Obj *)handle;
	LEC_MIKET_control(pObj->pDb, Cmd, (ILEC_Status *)pStatus);
    return (IALG_EOK);
}
/*-------------------------------------------------------------------------*/
static Void 					activate
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle
)
{
/*   LEC_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
)
{
    LEC_MIKET_Obj *pObj = (LEC_MIKET_Obj *)handle;

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

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

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

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

/*-------------------------------------------------------------------------*/
Void 				LEC_MIKET_exit
/*-------------------------------------------------------------------------*/
(
) 
{
}
/*-------------------------------------------------------------------------*/
Void 				LEC_MIKET_init
/*-------------------------------------------------------------------------*/
(
)
{
}

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

#if defined (_dsp)
	asm(" .global _LEC_MIKET_IALG");
	asm("_LEC_MIKET_IALG .set _LEC_MIKET_ILEC");
#endif

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

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