i_dtmf.c

Express DSP compliant C55x DTMF detector software is proposed in two versions: one with a 5 ms frame

/*------------------------------------------------------------------------*
*                                                                         *
*   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 <idtmf.h>
#include <dtmf_miket.h>
#include <dtmfi.h>

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

/*--------------------- local defs ----------------------------------------*/
#define HISTORY 1
#define WORKBUF 2
#define NUMBUFS 3

typedef struct DTMF_MIKET_Obj {
    IALG_Obj    alg;            /* MUST be first field of all XDAS algs */
    DTMF_tDb *pDb;
    DTMF_tSc *pSc;
} DTMF_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);
                
static Void moved
(IALG_Handle handle, const IALG_MemRec memTab[], 
IALG_Handle parent,const IALG_Params *algParams);
                
static Int process
(IALG_Handle handle,Int *pIn);



#pragma CODE_SECTION(activate, ".text:algActivate")
#pragma CODE_SECTION(alloc, ".text:algAlloc")
#pragma CODE_SECTION(deactivate, ".text:algDeactivate")
#pragma CODE_SECTION(control, ".text:algControl")
#pragma CODE_SECTION(free, ".text:algFree")
#pragma CODE_SECTION(initObj, ".text:algInit")
#pragma CODE_SECTION(moved, ".text:algMoved")
#pragma CODE_SECTION(DTMF_MIKET_init, ".text:init")
#pragma CODE_SECTION(DTMF_MIKET_exit, ".text:exit")
#pragma DATA_SECTION(DTMF_MIKET_IDTMF, ".const:dtmf_miket_idtmf")

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

    if (params == NULL) {
        params = &Params;  /* set default parameters */
    }
#endif
    /* Request memory for FIR object */
    memTab[0].size = sizeof(DTMF_MIKET_Obj);
    memTab[0].alignment = 4; /* pointers are long */
    memTab[0].space = IALG_EXTERNAL;
    memTab[0].attrs = IALG_PERSIST;

    /*
     *  Request memory filter's "inter-frame" state (i.e., the
     *  delay history)
     *
     *  Note we could have simply added the delay buffer size to the
     *  end of the FIR object by combining this request with the one
     *  above, thereby saving some code.  We separate it here for
     *  clarity.
     */
    memTab[HISTORY].size = sizeof (DTMF_tDb);
    memTab[HISTORY].alignment = 0;
    memTab[HISTORY].space = IALG_SARAM;
    memTab[HISTORY].attrs = IALG_PERSIST;

    /*
     *  Request memory for shared working buffer
     */
    memTab[WORKBUF].size = sizeof (DTMF_tSc);
    memTab[WORKBUF].alignment = 0;
    memTab[WORKBUF].space = IALG_DARAM0;
    memTab[WORKBUF].attrs = IALG_SCRATCH;
    
    return (NUMBUFS);
}
/*-------------------------------------------------------------------------*/
static Int 						free
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_MemRec memTab[]
)
{
    DTMF_MIKET_Obj *pObj = (Void *)handle;

    alloc(NULL, NULL, memTab);

    memTab[HISTORY].base = pObj->pDb;
    memTab[HISTORY].size = sizeof(DTMF_tDb);

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

    return (NUMBUFS);
}

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

    pObj->pSc = memTab[WORKBUF].base;
    pObj->pDb = memTab[HISTORY].base;

	if (algParams == NULL)
	{
    	DTMF_MIKET_init_db(pObj->pDb, (IDTMF_tCfg *)&IDTMF_MIKET_DefaultCfg);
    }
    else
    {
    	IDTMF_tCfg *pCfg = ((IDTMF_Params *)algParams)->pCfg;
    	DTMF_MIKET_init_db(pObj->pDb, pCfg);
    }

    return (IALG_EOK);
}

/*-------------------------------------------------------------------------*/
static Int 						control
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_Cmd Cmd, 
IALG_Status *pStatus
)
{
    DTMF_MIKET_Obj *pObj = (Void *)handle;
	DTMF_MIKET_control(pObj->pDb, Cmd, (IDTMF_Status *)pStatus);
    return (IALG_EOK);
}
/*-------------------------------------------------------------------------*/
static Void 					activate
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle
)
{
/*   TG_MIKET_Obj *pObj = (Void *)handle; */
}

/*-------------------------------------------------------------------------*/
static Void 					deactivate
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle
)
{                 
}
/*-------------------------------------------------------------------------*/
static Void 					moved
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle,
const IALG_MemRec memTab[], 
IALG_Handle p,
const IALG_Params *algParams
)
{
    DTMF_MIKET_Obj *pObj = (Void *)handle;

    pObj->pSc = memTab[WORKBUF].base;
    pObj->pDb = memTab[HISTORY].base;
}              

/*-------------------------------------------------------------------------*/
static Int 						process
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle,
Int *pOut
)
{
    DTMF_MIKET_Obj *pObj = (Void *)handle;

	return DTMF_MIKET_process(pObj->pDb, pObj->pSc, pOut);
}

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

extern Void DTMF_MIKET_exit() {}
extern Void DTMF_MIKET_init() {}

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

#if defined (_dsp)
	asm(" .global _DTMF_MIKET_IALG");
	asm("_DTMF_MIKET_IALG .set _DTMF_MIKET_IDTMF");
#endif

const IDTMF_Fxns DTMF_MIKET_IDTMF = {       /* module_vendor_interface */
    (void *)&DTMF_MIKET_IDTMF,       /* module ID */ 
    activate,    /* activate */  
    alloc,       /* alloc */     
    control,     /* control */   
    deactivate,  /* deactivate */
    free,        /* free */      
    initObj,     /* init */      
    moved,       /* moved */     
    NULL,                 /* numAlloc (NULL => IALG_MAXMEMRECS) */\
    process      /*  */
};

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