/*------------------------------------------------------------------------*
*                                                                         *
*   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 <itg.h>
#include <tg_miket.h>
#include <tg.h>

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

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

typedef struct TG_MIKET_Obj {
    IALG_Obj    alg;            /* MUST be first field of all XDAS algs */
    TG_tDb *pDb;
    TG_tSc *pSc;
} TG_MIKET_Obj;

/*--------------------- local vars ----------------------------------------*/
/* default parameters of creation */
static const ITG_Params Params = {
    sizeof(ITG_Params)    /* sizeof this structure */
};

/*--------------------- 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(TG_MIKET_init, ".text:init")
#pragma CODE_SECTION(TG_MIKET_exit, ".text:exit")
#pragma DATA_SECTION(TG_MIKET_ITG, ".const:tg_miket_itg")

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

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

    /* Request memory for FIR object */
    memTab[0].size = sizeof(TG_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 (TG_tDb);
    memTab[HISTORY].alignment = 0;
    memTab[HISTORY].space = IALG_EXTERNAL;
    memTab[HISTORY].attrs = IALG_PERSIST;

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

    alloc(NULL, NULL, memTab);

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

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

    return (NUMBUFS);
}

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

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

    TG_MIKET_init_db(pObj->pDb);

    return (IALG_EOK);
}

/*-------------------------------------------------------------------------*/
static Int 						control
/*-------------------------------------------------------------------------*/
(
IALG_Handle handle, 
IALG_Cmd Cmd, 
IALG_Status *pStatus
)
{
    TG_MIKET_Obj *pObj = (Void *)handle;
	TG_MIKET_control(pObj->pDb, Cmd, (ITG_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
)
{
    TG_MIKET_Obj *pObj = (Void *)handle;

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

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

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

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

extern Void TG_MIKET_exit() {}
extern Void TG_MIKET_init() {}

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

#if defined (_dsp)
	asm(" .global _TG_MIKET_IALG");
	asm("_TG_MIKET_IALG .set _TG_MIKET_ITG");
#endif

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

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