/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - Initial contribution
*
* Contributors:
* Ixonos Plc
*
* Description:  
* Video decoder engine main module.
*
*/




/*
 * Includes
 */

#include "h263dConfig.h"

#include "vdemain.h"
#include "renapi.h"
#include "rendri.h"
#include "h263dext.h"
#include "vde.h"

#include "biblin.h"


/*
 * Global functions
 */
  
/* {{-output"vdeFree.txt"}} */
/*
 * vdeFree
 *    
 *
 * Parameters:
 *    Nothing
 *
 * Function:
 *    This function deinitializes this module.
 *
 * Returns:
 *    VDE_OK                     if the function was successful
 *    VDE_ERROR                  indicating a general error
 *
 *    
 */

int vdeFree(void)
/* {{-output"vdeFree.txt"}} */
{
   if (vdcFree() < 0)
      return VDE_ERROR;

   return VDE_OK;
}


/* {{-output"vdeGetLatestFrame.txt"}} */
/*
 * vdeGetLatestFrame
 *    
 *
 * Parameters:
 *    hInstance                  instance data
 *    
 *    ppy, ppu, ppv              used to return Y, U and V frame pointers
 *
 *    pLumWidth, pLumHeight      used to return luminance image width and height
 *                               Note these values can be counted on even if
 *                               the function returns an error.
 *
 *    pFrameNum                  used to return frame number
 *
 * Function:
 *    This function returns the latest correctly decoded frame
 *    (and some side-information).
 *
 *    Note that no thread synchronization is used since the function
 *    is used only from the mobidntc.c and it is very likely that
 *    the same decoder instance is used only from a single calling
 *    thread at the same time.
 *
 * Returns:
 *    VDE_OK                     if the function was successful
 *    VDE_ERROR                  indicating a general error
 */


int vdeGetLatestFrame(
   vdeHInstance_t hInstance,
   u_char **ppy, u_char **ppu, u_char **ppv,
   int *pLumWidth, int *pLumHeight,
   int *pFrameNum)
/* {{-output"vdeGetLatestFrame.txt"}} */
{
   int
      retValue;

   vdeImb_t
      *pImb;

   vdeImsItem_t 
      *pImsItem;

   vdeInstance_t 
      *instance = (vdeInstance_t *) hInstance;


   vdeAssert(instance != NULL);

   /* Ensure that image width and height are returned anyway */
   *pLumWidth = instance->lumWidth;
   *pLumHeight = instance->lumHeight;

   retValue = vdeImsGetReference(
      &instance->imageStore, 
      VDEIMS_REF_LATEST, 0, 
      &pImsItem);
   if (retValue < 0)
      return retValue;

   if (!pImsItem)
      return VDE_ERROR;

   pImb = pImsItem->imb;

   if (vdeImbYUV(pImb, ppy, ppu, ppv, pLumWidth, pLumHeight) < 0)
      return VDE_ERROR;

   *pFrameNum = renDriFrameNumber(pImb->drawItem);

   return VDE_OK;
}



/* {{-output"vdeInit.txt"}} */
/*
 * vdeInit
 *    
 *
 * Parameters:
 *    param                      a h263dOpen_t structure containing
 *                               the initialization parameters
 *
 * Function:
 *    This function allocates and initializes an H.263 video decoder engine
 *    (VDE) instance.
 *
 * Returns:
 *    a handle to the new instance or
 *    NULL if the initialization fails
 *
 *    
 */

vdeHInstance_t vdeInit(h263dOpen_t *param)
/* {{-output"vdeInit.txt"}} */
{
   vdeInstance_t *instance;

   vdeAssert(param);
   vdeAssert(!param->fRPS || (param->fRPS && param->numReferenceFrames > 1));

   instance = (vdeInstance_t *) 
      vdeMalloc(sizeof(vdeInstance_t) + param->freeSpace);
   if (instance == NULL)
      goto errInstanceAllocation;
   memset(instance, 0, sizeof(vdeInstance_t));

   if (param->lumWidth % 16)
      param->lumWidth = (param->lumWidth / 16 + 1) * 16;
   
   if (param->lumHeight % 16)
      param->lumHeight = (param->lumHeight / 16 + 1) * 16;

   if (vdeImsOpen(&instance->imageStore, param->numPreallocatedFrames, 
      param->lumWidth, param->lumHeight) < 0)
      goto errVdeImsOpen;

   instance->vdcHInstance = vdcOpen(&instance->imageStore, 
      param->fRPS ? param->numReferenceFrames : 1,
      (void *) instance);
   if (!instance->vdcHInstance)
      goto errVdcOpen;

   if (vdeFrtOpen(&instance->renStore) < 0)
      goto errRenStore;

   if (vdeFrtOpen(&instance->startCallbackStore) < 0)
      goto errStartCallbackStore;

   if (vdeFrtOpen(&instance->endCallbackStore) < 0)
      goto errEndCallbackStore;


   instance->lumWidth = param->lumWidth;
   instance->lumHeight = param->lumHeight;

   return (vdeHInstance_t) instance;

   /* Error cases (release resources in reverse order) */

errEndCallbackStore:
    
   vdeFrtClose(&instance->startCallbackStore);
errStartCallbackStore:

   vdeFrtClose(&instance->renStore);
errRenStore:

   vdcClose(instance->vdcHInstance);
errVdcOpen:

   vdeImsClose(&instance->imageStore);
errVdeImsOpen:

   vdeDealloc(instance);
errInstanceAllocation:

   return NULL;
}


/* {{-output"vdeIsINTRA.txt"}} */
/*
 * vdeIsINTRA
 *    
 *
 * Parameters:
 *    hInstance                  handle of instance data
 *    frameStart                 pointer to memory chunk containing a frame
 *    frameLength                number of bytes in frame
 *
 * Function:
 *    This function returns 1 if the passed frame is an INTRA frame.
 *    Otherwise the function returns 0.
 *
 * Note:
 *    This function does not use vdeque services since it is intended to be
 *    used in non-thread version of the codec only.
 *
 * Returns:
 *    See above.
 */

int vdeIsINTRA(
   vdeHInstance_t hInstance,
   void *frameStart,
   unsigned frameLength)
/* {{-output"vdeIsINTRA.txt"}} */
{
   vdeInstance_t *instance = (vdeInstance_t *) hInstance;

   vdeAssert(instance != NULL);

   /* Note: We assume that vdeDetermineStreamType has been called to
      decide whether the stream is MPEG-4 or H.263 */
      
   if (instance->fMPEG4)
      return vdcIsMPEGINTRA(instance->vdcHInstance, frameStart, frameLength);
   else
      return vdcIsINTRA(instance->vdcHInstance, frameStart, frameLength);
}


/* {{-output"vdeLoad.txt"}} */
/*
 * vdeLoad
 *    
 *
 * Parameters:
 *    rendererFileName           file from which to get renderer functions
 *
 * Function:
 *    This function initializes this module.
 *
 *    Renderer functions are dynamically loaded from the given file.
 *    If rendererFileName is NULL, renderer functions are expected to be
 *    statically linked.
 *
 * Returns:
 *    VDE_OK                     if the function was successful
 *    VDE_ERROR                  indicating a general error
 *
 *    
 */

int vdeLoad(const char * /*rendererFileName*/)
/* {{-output"vdeLoad.txt"}} */
{

   if (vdcLoad() < 0)
      return VDE_ERROR;

   return VDE_OK;
}




/* {{-output"vdeSetInputBuffer.txt"}} */
/*
 * vdeSetInputBuffer
 *    
 *
 * Parameters:
 *    hInstance                  handle of instance data
 *    buffer                     a new bit buffer to use
 *
 * Function:
 *    This function sets the bit buffer to use for decoding.
 *    It is intended that this function is used mainly in applications
 *    where frames are provided one by one from applications.
 *    Some upper level function must create a bit buffer for each frame,
 *    pass a pointer to the created bit buffer to the decoder using this
 *    function and then decode the frame.
 *
 * Returns:
 *    VDE_OK                     if the function was successful
 *    VDE_ERROR                  indicating a general error
 *
 *    
 */

int vdeSetInputBuffer(vdeHInstance_t hInstance, bibBuffer_t *buffer)
/* {{-output"vdeSetInputBuffer.txt"}} */
{
   vdeInstance_t *instance = (vdeInstance_t *) hInstance;

   if (instance == NULL)
      return VDE_ERROR;

   instance->inBuffer = buffer;

   return VDE_OK;
}



int vdeSetOutputBuffer(vdeHInstance_t hInstance, bibBuffer_t *buffer)
/* {{-output"vdeSetOutputBuffer.txt"}} */
{
   vdeInstance_t *instance = (vdeInstance_t *) hInstance;

   if (instance == NULL)
      return VDE_ERROR;

   instance->outBuffer = buffer;

   return VDE_OK;
}

int vdeSetBufferEdit(vdeHInstance_t hInstance, bibBufferEdit_t *bufEdit)
/* {{-output"vdeSetOutputBuffer.txt"}} */
{
   vdeInstance_t *instance = (vdeInstance_t *) hInstance;

   if (instance == NULL)
      return VDE_ERROR;

   instance->bufEdit = bufEdit;

   return VDE_OK;
}

int vdeSetVideoEditParams(vdeHInstance_t hInstance, int aColorEffect, TBool aGetDecodedFrame, 
                          TInt aColorToneU, TInt aColorToneV)
{
   vdeInstance_t *instance = (vdeInstance_t *) hInstance;

   if (instance == NULL)
      return VDE_ERROR;

   instance->iColorEffect = aColorEffect;
   instance->iGetDecodedFrame = aGetDecodedFrame;
   instance->iColorToneU = aColorToneU;
   instance->iColorToneV = aColorToneV;

   return VDE_OK;
}









/* {{-output"vdeShutDown.txt"}} */
/*
 * vdeShutDown
 *    
 *
 * Parameters:
 *    hInstance                  handle of instance data
 *
 * Function:
 *    This function has to be called in the end of each video sequence.
 *    It frees the resources (the VDE instance) allocated by vdeInit.
 *
 * Returns:
 *    VDE_OK                     if the closing was successful
 *    VDE_ERROR                  indicating a general error
 *
 *    
 */

int vdeShutDown(vdeHInstance_t hInstance)
/* {{-output"vdeShutDown.txt"}} */
{
   int retValue = VDE_OK;
   vdeInstance_t *instance = (vdeInstance_t *) hInstance;

   if (vdcClose(instance->vdcHInstance) < 0)
      retValue = VDE_ERROR;

   if (vdeFrtClose(&instance->endCallbackStore) < 0)
      retValue = VDE_ERROR;

   if (vdeFrtClose(&instance->startCallbackStore) < 0)
      retValue = VDE_ERROR;

   if (vdeFrtClose(&instance->renStore) < 0)
      retValue = VDE_ERROR;

   if (vdeImsClose(&instance->imageStore) < 0)
      retValue = VDE_ERROR;

   vdeDealloc(instance);

   return retValue;
}

// End of File