/*
* 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