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

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

#if ! defined(_dsp)
#include "icpd.cpp"
#endif

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

typedef struct CPD_MIKET_Obj {
    IALG_Obj    alg;            /* MUST be first field of all XDAS algs */
    CPD_tDb *pDb;
    CPD_tSc *pSc;
} CPD_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);

#if defined (_dsp)

#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(process, ".text:algProcess")
#pragma CODE_SECTION(CPD_MIKET_init, ".text:init")
#pragma CODE_SECTION(CPD_MIKET_exit, ".text:exit")
#pragma DATA_SECTION(CPD_MIKET_ICPD, ".const:cpd_miket_icpd")
#endif

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

    if (params == NULL) {
        params = &Params;  /* set default parameters */
    }
#endif
    /* Request memory for FIR object */
    memTab[0].size = sizeof(CPD_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 (CPD_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 (CPD_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[]
)
{
    CPD_MIKET_Obj *pObj = (CPD_MIKET_Obj *)handle;

    alloc(NULL, NULL, memTab);

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

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

    return (NUMBUFS);
}

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

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

	if (algParams == NULL)
	{
	    CPD_MIKET_init_db(pObj->pDb, ICPD_MIKET_DefaultParams.pCfg);
	}
	else
	{
	    CPD_MIKET_init_db(pObj->pDb, ((ICPD_Params *)algParams)->pCfg);
	}
    return (IALG_EOK);
}

/*-------------------------------------------------------------------------*/
static Int 						control
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_Cmd Cmd, 
IALG_Status *pStatus
)
{
    CPD_MIKET_Obj *pObj = (CPD_MIKET_Obj *)handle;
	CPD_MIKET_control(pObj->pDb, Cmd, (ICPD_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
)
{
    CPD_MIKET_Obj *pObj = (CPD_MIKET_Obj *)handle;

    pObj->pSc = (CPD_tSc*)memTab[WORKBUF].base;
    pObj->pDb = (CPD_tDb*)memTab[HISTORY].base;
}              

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

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

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

/*-------------------------------------------------------------------------*/
Void 				CPD_MIKET_exit
/*-------------------------------------------------------------------------*/
(
) 
{
}
/*-------------------------------------------------------------------------*/
Void 				CPD_MIKET_init
/*-------------------------------------------------------------------------*/
(
)
{
}

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

#if defined (_dsp)
	asm(" .global _CPD_MIKET_IALG");
	asm("_CPD_MIKET_IALG .set _CPD_MIKET_ICPD");
#endif

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

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