codec memory error

Can you give an example to illustrate how to use  algAlloc() and algInit() to request and store memory? I try to use it ,but it does not  works,

/*
 *  Copyright 2010
 *  Hailing ,Xidian University
 *
 */
/*
 *  =========== vidrnc_track.c ============
 *  Video Encoder "track" algorithm.
 *
 *  This file contains an implementation of the deprecated IVIDENC interface
 *  as defined by xDM.
 */
#include <xdc/std.h>
#include <string.h>
#include<stdio.h>
#include <stdlib.h>
 
#include <ti/xdais/dm/ividenc.h>
#include <ti/xdais/dm/xdm.h>
#include <ti/sdo/ce/trace/gt.h>
 
#include "videnc_track_ti.h"
#include "videnc_track_ti_priv.h"
 

# define SIZE 352*288*sizeof(unsigned char)
 
 
/* buffer definitions */
#define MININBUFS       1
#define MINOUTBUFS      1
#define MININBUFSIZE    1
#define MINOUTBUFSIZE   1
 
extern IALG_Fxns VIDENCTRACK_TI_IALG;
#define IALGFXNS  \
    &VIDENCTRACK_TI_IALG,         /* module ID */                         \
    VIDENCTRACK_TI_activate,     /* activate */                          \
    VIDENCTRACK_TI_alloc,        /* alloc */                             \
    NULL,                       /* control (NULL => no control ops) */   \
    VIDENCTRACK_TI_deactivate,   /* deactivate */                        \
    VIDENCTRACK_TI_free,         /* free */                              \
    VIDENCTRACK_TI_initObj,      /* init */                              \
    NULL,                       /* moved */                              \
    NULL                        /* numAlloc (NULL => IALG_MAXMEMRECS) */
 
/*
 *  ======== VIDENCTRACK_TI_IVIDENC ========
 *  This structure defines TI's implementation of the IVIDENC interface
 *  for the VIDENCTRACK_TI module.
 */
IVIDENC_Fxns VIDENCTRACK_TI_VIDENCTRACK = {      /* module_vendor_interface */
     {IALGFXNS},
     VIDENCTRACK_TI_process,
     VIDENCTRACK_TI_control,
};
 
/*
 *  ======== VIDENCTRACK_TI_IALG ========
 *  This structure defines TI's implementation of the IALG interface
 *  for the VIDENCTRACK_TI module.
 */
#ifdef _TI_
/* satisfy xDAIS symbol requirement without any overhead */
asm("_VIDENCTRACK_TI_IALG .set _VIDENCTRACK_TI_VIDENCTRACK");
 
#else
/*
 *  We duplicate the structure here to allow this code to be compiled and
 *  run non-DSP platforms at the expense of unnecessary data space
 *  consumed by the definition below.
 */
 IALG_Fxns VIDENCTRACK_TI_IALG = {      /* module_vendor_interface int *pFlagFG;*/ 
     IALGFXNS
};
 
#endif
 
/* tracing information */
#define GTNAME "ti.sdo.ce.examples.codecs.videnc_track"
static GT_Mask curTrace = {NULL,NULL};
 
 
/*
 *  ======== VIDENCTRACK_TI_activate ========
 */
Void VIDENCTRACK_TI_activate(IALG_Handle handle)
{
    GT_1trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_activate(0x%x)\n", handle);
}
 
 
/*
 *  ======== VIDENCTRACK_TI_deactivate ========
 */
Void VIDENCTRACK_TI_deactivate(IALG_Handle handle)
{
    GT_1trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_deactivate(0x%x)\n", handle);
}
 
 
/*
 *  ======== VIDENCTRACK_TI_alloc ========
 */
Int VIDENCTRACK_TI_alloc(const IALG_Params *algParams,
    IALG_Fxns **pf, IALG_MemRec memTab[])
{
    if (curTrace.modName == NULL) {   /* initialize GT (tracing) */
        GT_create(&curTrace, GTNAME);
    }
 
    GT_3trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_alloc(0x%x, 0x%x, 0x%x)\n",
        algParams, pf, memTab);

         
     /* Request memory for my object */
     memTab[0].size = sizeof(VIDENCTRACK_TI_Obj);
     memTab[0].alignment = 0;
     memTab[0].space = IALG_EXTERNAL;
     memTab[0].attrs = IALG_PERSIST;

     memTab[1].size = 352*288*sizeof(unsigned char);
     memTab[1].alignment = 0;
     memTab[1].space = IALG_EXTERNAL;
     memTab[1].attrs = IALG_PERSIST;
memTab[0].base=(void*)MEM_alloc(memTab[0].space,memTab[0].size,memTab[0].alignment);
memTab[1].base=(unsigned char*)MEM_alloc(memTab[1].space,memTab[1].size,memTab[1].alignment);
     return (1);
}
 
 
/*
 *  ======== VIDENCTRACK_TI_free ========
 */
Int VIDENCTRACK_TI_free(IALG_Handle handle, IALG_MemRec memTab[])
{
    GT_2trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_free(0x%lx, 0x%lx)\n",
        handle, memTab);

//        VIDENCTRACK_TI_Obj *inst = (VIDENCTRACK_TI_Obj *)handle;
    VIDENCTRACK_TI_alloc(NULL, NULL, memTab);
   
return (1);
}
 
 
/*
 *  ======== VIDENCTRACK_TI_initObj ========
 */
Int VIDENCTRACK_TI_initObj(IALG_Handle handle,
    const IALG_MemRec memTab[], IALG_Handle p,
    const IALG_Params *algParams) 
{   int i;
    VIDENCTRACK_TI_Obj *inst = (VIDENCTRACK_TI_Obj *)handle;
   
   

    inst->p=memTab[1].base;
  if(inst->p==NULL){
        return (IALG_EFAIL); }
   
GT_4trace(curTrace, GT_ENTER,
        "VIDENCTRACK_TI_initObj(0x%x, 0x%x, 0x%x, 0x%x)\n", handle, memTab,
        p, algParams);
 
    return (IALG_EOK);
}
 
 
/* 
 *  ======== VIDENCTRACK_TI_process ========
 */
XDAS_Int32 VIDENCTRACK_TI_process(IVIDENC_Handle h, XDM_BufDesc *inBufs,
    XDM_BufDesc *outBufs, IVIDENC_InArgs *inArgs, IVIDENC_OutArgs *outArgs)
{ 
  XDAS_Int32 curBuf;
  XDAS_Int32 minSamples;
  int i,j;

    VIDENCTRACK_TI_Obj *inst = (VIDENCTRACK_TI_Obj *)h;
    q=inst->p;
    
  
 GT_5trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_process(0x%lx, 0x%lx, 0x%lx, "
       "0x%lx, 0x%lx)\n", h, inBufs, outBufs, inArgs, outArgs);

    /* validate arguments - this codec only supports "base" xDM. */
    if ((inArgs->size != sizeof(*inArgs)) ||
        (outArgs->size != sizeof(*outArgs))) {

        GT_2trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_process, unsupported size "
            "(0x%lx, 0x%lx)\n", inArgs->size, outArgs->size);

        return (IVIDENC_EFAIL);
    }



  outArgs->bytesGenerated=0;
 
 
     minSamples = inBufs->bufSizes[0] < outBufs->bufSizes[0] ?
     inBufs->bufSizes[0] : outBufs->bufSizes[0];       
            
         memcpy(inst->p,inBufs->bufs[curBuf],inBufs->bufSizes[0]);
         for(i=0;i<288;i++)
            for(j=0;j<352;j+=2)
            {
              inst->p[i*352+j]=0x80;
            inst->p[i*352+j+1]=0x10; 
            }
 
     memcpy(outBufs->bufs[0], inst->p, outBufs->bufSizes[0]);
 
     GT_1trace( curTrace, GT_2CLASS, "VIDENCTRACK_TI_process> "
               "Processed %d bytes.\n", minSamples );
       outArgs->bytesGenerated += minSamples;
 
 
     /* Fill out the rest of the outArgs struct */
    outArgs->extendedError = 0;
    outArgs->encodedFrameType = 0;     /* TODO */
    outArgs->inputFrameSkip = IVIDEO_FRAME_ENCODED;
    outArgs->reconBufs.numBufs = 0;   /* important: indicate no reconBufs */

 
  return (IVIDENC_EOK);
}
 
 
/*
 *  ======== VIDENCTRACK_TI_control ========
 */
XDAS_Int32 VIDENCTRACK_TI_control(IVIDENC_Handle handle, IVIDENC_Cmd id,
    IVIDENC_DynamicParams *params, IVIDENC_Status *status)
{
     XDAS_Int32 retVal;
 
     GT_4trace(curTrace, GT_ENTER, "VIDENCTRACK_TI_control(0x%x, 0x%x, 0x%x, "
         "0x%x)\n", handle, id, params, status);
     
     /* validate arguments - this codec only supports "base" xDM. */
     if ((params->size != sizeof(*params)) ||
         (status->size != sizeof(*status))) {
 
        GT_2trace(curTrace, GT_ENTER,
            "VIDENCTRACK_TI_control, unsupported size "
            "(0x%x, 0x%x)\n", params->size, status->size);
 
        return (IVIDENC_EFAIL);
      }
 
     switch (id) {
         case XDM_GETSTATUS:
        case XDM_GETBUFINFO:
            status->extendedError = 0;
            status->bufInfo.minNumInBufs = MININBUFS;
            status->bufInfo.minNumOutBufs = MINOUTBUFS;
            status->bufInfo.minInBufSize[0] = MININBUFSIZE;
            status->bufInfo.minOutBufSize[0] = MINOUTBUFSIZE;
 
            retVal = IVIDENC_EOK;
 
            break;
        case XDM_SETPARAMS:
        case XDM_SETDEFAULT:
        case XDM_RESET:
        case XDM_FLUSH:
            /* TODO - for now just return success. */
            retVal = IVIDENC_EOK;
            break;
        default:
            /* unsupported cmd */
            retVal = IVIDENC_EFAIL;
            break;
        }
     return (retVal);
} 
 
  

Can anyone explan the function and use of the API GT_4trace,and its 7parameters?