blob: eddc1486091acac98b576aac6239dcdd2c9f4924 [file] [log] [blame]
/* ------------------------------------------------------------------
* Copyright (C) 1998-2009 PacketVideo
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied.
* See the License for the specific language governing permissions
* and limitations under the License.
* -------------------------------------------------------------------
*/
#include <stdint.h>
#include "mp4dec_lib.h"
#include "vlc_decode.h"
#include "bitstream.h"
#ifndef INT32_MAX
#define INT32_MAX 0x7fffffff
#endif
#ifndef SIZE_MAX
#define SIZE_MAX ((size_t) -1)
#endif
#define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT
#ifdef DEC_INTERNAL_MEMORY_OPT
#define QCIF_MBS 99
#define QCIF_BS (4*QCIF_MBS)
#define QCIF_MB_ROWS 11
extern uint8 IMEM_sliceNo[QCIF_MBS];
extern uint8 IMEM_acPredFlag[QCIF_MBS];
extern uint8 IMEM_headerInfo_Mode[QCIF_MBS];
extern uint8 IMEM_headerInfo_CBP[QCIF_MBS];
extern int IMEM_headerInfo_QPMB[QCIF_MBS];
extern MacroBlock IMEM_mblock;
extern MOT IMEM_motX[QCIF_BS];
extern MOT IMEM_motY[QCIF_BS];
extern BitstreamDecVideo IMEM_BitstreamDecVideo[4];
extern typeDCStore IMEM_predDC[QCIF_MBS];
extern typeDCACStore IMEM_predDCAC_col[QCIF_MB_ROWS+1];
extern VideoDecData IMEM_VideoDecData[1];
extern Vop IMEM_currVop[1];
extern Vop IMEM_prevVop[1];
extern PIXEL IMEM_currVop_yChan[QCIF_MBS*128*3];
extern PIXEL IMEM_prevVop_yChan[QCIF_MBS*128*3];
extern uint8 IMEM_pstprcTypCur[6*QCIF_MBS];
extern uint8 IMEM_pstprcTypPrv[6*QCIF_MBS];
extern Vop IMEM_vopHEADER[2];
extern Vol IMEM_VOL[2];
extern Vop IMEM_vopHeader[2][1];
extern Vol IMEM_vol[2][1];
#endif
/* ======================================================================== */
/* Function : PVInitVideoDecoder() */
/* Date : 04/11/2000, 08/29/2000 */
/* Purpose : Initialization of the MPEG-4 video decoder library. */
/* The return type is Bool instead of PV_STATUS because */
/* we don't want to expose PV_STATUS to (outside) programmers */
/* that use our decoder library SDK. */
/* In/out : */
/* Return : PV_TRUE if successed, PV_FALSE if failed. */
/* Modified : */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVInitVideoDecoder(VideoDecControls *decCtrl, uint8 *volbuf[],
int32 *volbuf_size, int nLayers, int width, int height, MP4DecodingMode mode)
{
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
Bool status = PV_TRUE;
int idx;
BitstreamDecVideo *stream;
oscl_memset(decCtrl, 0, sizeof(VideoDecControls)); /* fix a size bug. 03/28/2001 */
decCtrl->nLayers = nLayers;
for (idx = 0; idx < nLayers; idx++)
{
decCtrl->volbuf[idx] = volbuf[idx];
decCtrl->volbuf_size[idx] = volbuf_size[idx];
}
/* memory allocation & initialization */
#ifdef DEC_INTERNAL_MEMORY_OPT
video = IMEM_VideoDecData;
#else
video = (VideoDecData *) oscl_malloc(sizeof(VideoDecData));
#endif
if (video != NULL)
{
oscl_memset(video, 0, sizeof(VideoDecData));
video->memoryUsage = sizeof(VideoDecData);
video->numberOfLayers = nLayers;
#ifdef DEC_INTERNAL_MEMORY_OPT
video->vol = (Vol **) IMEM_VOL;
#else
if ((size_t)nLayers > SIZE_MAX / sizeof(Vol *)) {
status = PV_FALSE;
goto fail;
}
video->vol = (Vol **) oscl_malloc(nLayers * sizeof(Vol *));
#endif
if (video->vol == NULL) status = PV_FALSE;
video->memoryUsage += nLayers * sizeof(Vol *);
/* we need to setup this pointer for the application to */
/* pass it around. */
decCtrl->videoDecoderData = (void *) video;
video->videoDecControls = decCtrl; /* yes. we have a cyclic */
/* references here :) */
/* Allocating Vop space, this has to change when we add */
/* spatial scalability to the decoder */
#ifdef DEC_INTERNAL_MEMORY_OPT
video->currVop = IMEM_currVop;
if (video->currVop == NULL) status = PV_FALSE;
else oscl_memset(video->currVop, 0, sizeof(Vop));
video->prevVop = IMEM_prevVop;
if (video->prevVop == NULL) status = PV_FALSE;
else oscl_memset(video->prevVop, 0, sizeof(Vop));
video->memoryUsage += (sizeof(Vop) * 2);
video->vopHeader = (Vop **) IMEM_vopHEADER;
#else
video->currVop = (Vop *) oscl_malloc(sizeof(Vop));
if (video->currVop == NULL) status = PV_FALSE;
else oscl_memset(video->currVop, 0, sizeof(Vop));
video->prevVop = (Vop *) oscl_malloc(sizeof(Vop));
if (video->prevVop == NULL) status = PV_FALSE;
else oscl_memset(video->prevVop, 0, sizeof(Vop));
video->memoryUsage += (sizeof(Vop) * 2);
if ((size_t)nLayers > SIZE_MAX / sizeof(Vop *)) {
status = PV_FALSE;
goto fail;
}
video->vopHeader = (Vop **) oscl_malloc(sizeof(Vop *) * nLayers);
#endif
if (video->vopHeader == NULL) status = PV_FALSE;
else oscl_memset(video->vopHeader, 0, sizeof(Vop *)*nLayers);
video->memoryUsage += (sizeof(Vop *) * nLayers);
video->initialized = PV_FALSE;
/* Decode the header to get all information to allocate data */
if (status == PV_TRUE)
{
/* initialize decoded frame counter. 04/24/2001 */
video->frame_idx = -1;
for (idx = 0; idx < nLayers; idx++)
{
#ifdef DEC_INTERNAL_MEMORY_OPT
video->vopHeader[idx] = IMEM_vopHeader[idx];
#else
video->vopHeader[idx] = (Vop *) oscl_malloc(sizeof(Vop));
#endif
if (video->vopHeader[idx] == NULL)
{
status = PV_FALSE;
break;
}
else
{
oscl_memset(video->vopHeader[idx], 0, sizeof(Vop));
video->vopHeader[idx]->timeStamp = 0;
video->memoryUsage += (sizeof(Vop));
}
#ifdef DEC_INTERNAL_MEMORY_OPT
video->vol[idx] = IMEM_vol[idx];
video->memoryUsage += sizeof(Vol);
oscl_memset(video->vol[idx], 0, sizeof(Vol));
if (video->vol[idx] == NULL) status = PV_FALSE;
stream = IMEM_BitstreamDecVideo;
#else
video->vol[idx] = (Vol *) oscl_malloc(sizeof(Vol));
if (video->vol[idx] == NULL)
{
status = PV_FALSE;
break;
}
else
{
video->memoryUsage += sizeof(Vol);
oscl_memset(video->vol[idx], 0, sizeof(Vol));
}
stream = (BitstreamDecVideo *) oscl_malloc(sizeof(BitstreamDecVideo));
#endif
video->memoryUsage += sizeof(BitstreamDecVideo);
if (stream == NULL)
{
status = PV_FALSE;
break;
}
else
{
int32 buffer_size;
if ((buffer_size = BitstreamOpen(stream, idx)) < 0)
{
mp4dec_log("InitVideoDecoder(): Can't allocate bitstream buffer.\n");
status = PV_FALSE;
break;
}
video->memoryUsage += buffer_size;
video->vol[idx]->bitstream = stream;
video->vol[idx]->volID = idx;
video->vol[idx]->timeInc_offset = 0; /* 11/12/01 */
video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader;
video->vlcDecCoeffInter = &VlcDecTCOEFShortHeader;
if (mode == MPEG4_MODE)
{
/* Set up VOL header bitstream for frame-based decoding. 08/30/2000 */
BitstreamReset(stream, decCtrl->volbuf[idx], decCtrl->volbuf_size[idx]);
switch (DecodeVOLHeader(video, idx))
{
case PV_SUCCESS :
if (status == PV_TRUE)
status = PV_TRUE; /* we want to make sure that if first layer is bad, second layer is good return PV_FAIL */
else
status = PV_FALSE;
break;
#ifdef PV_TOLERATE_VOL_ERRORS
case PV_BAD_VOLHEADER:
status = PV_TRUE;
break;
#endif
default :
status = PV_FALSE;
break;
}
}
else
{
video->shortVideoHeader = PV_TRUE;
}
if (video->shortVideoHeader == PV_TRUE)
{
mode = H263_MODE;
/* Set max width and height. In H.263 mode, we use */
/* volbuf_size[0] to pass in width and volbuf_size[1] */
/* to pass in height. 04/23/2001 */
video->prevVop->temporalRef = 0; /* 11/12/01 */
/* Compute some convenience variables: 04/23/2001 */
video->vol[idx]->quantType = 0;
video->vol[idx]->quantPrecision = 5;
video->vol[idx]->errorResDisable = 1;
video->vol[idx]->dataPartitioning = 0;
video->vol[idx]->useReverseVLC = 0;
video->intra_acdcPredDisable = 1;
video->vol[idx]->scalability = 0;
video->displayWidth = width;
video->displayHeight = height;
video->width = (width + 15) & -16;
video->height = (height + 15) & -16;
video->size = (int32)video->width * video->height;
#ifdef PV_ANNEX_IJKT_SUPPORT
video->modified_quant = 0;
video->advanced_INTRA = 0;
video->deblocking = 0;
video->slice_structure = 0;
#endif
}
}
}
}
if (status != PV_FALSE)
{
status = PVAllocVideoData(decCtrl, width, height, nLayers);
video->initialized = PV_TRUE;
}
}
else
{
status = PV_FALSE;
}
fail:
if (status == PV_FALSE) PVCleanUpVideoDecoder(decCtrl);
return status;
}
Bool PVAllocVideoData(VideoDecControls *decCtrl, int width, int height, int nLayers)
{
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
Bool status = PV_TRUE;
int nTotalMB;
int nMBPerRow;
int32 size;
if (video->shortVideoHeader == PV_TRUE)
{
video->displayWidth = width;
video->displayHeight = height;
video->width = (width + 15) & -16;
video->height = (height + 15) & -16;
video->nMBPerRow =
video->nMBinGOB = video->width / MB_SIZE;
video->nMBPerCol =
video->nGOBinVop = video->height / MB_SIZE;
video->nTotalMB =
video->nMBPerRow * video->nMBPerCol;
}
if (((uint64_t)video->width * video->height) > (uint64_t)INT32_MAX / sizeof(PIXEL)) {
return PV_FALSE;
}
size = (int32)sizeof(PIXEL) * video->width * video->height;
#ifdef PV_MEMORY_POOL
decCtrl->size = size;
#else
#ifdef DEC_INTERNAL_MEMORY_OPT
video->currVop->yChan = IMEM_currVop_yChan; /* Allocate memory for all VOP OKA 3/2/1*/
if (video->currVop->yChan == NULL) status = PV_FALSE;
video->currVop->uChan = video->currVop->yChan + size;
video->currVop->vChan = video->currVop->uChan + (size >> 2);
video->prevVop->yChan = IMEM_prevVop_yChan; /* Allocate memory for all VOP OKA 3/2/1*/
if (video->prevVop->yChan == NULL) status = PV_FALSE;
video->prevVop->uChan = video->prevVop->yChan + size;
video->prevVop->vChan = video->prevVop->uChan + (size >> 2);
#else
if (size > INT32_MAX / 3 * 2) {
return PV_FALSE;
}
video->currVop->yChan = (PIXEL *) oscl_malloc(size * 3 / 2); /* Allocate memory for all VOP OKA 3/2/1*/
if (video->currVop->yChan == NULL) status = PV_FALSE;
video->currVop->uChan = video->currVop->yChan + size;
video->currVop->vChan = video->currVop->uChan + (size >> 2);
video->prevVop->yChan = (PIXEL *) oscl_malloc(size * 3 / 2); /* Allocate memory for all VOP OKA 3/2/1*/
if (video->prevVop->yChan == NULL) status = PV_FALSE;
video->prevVop->uChan = video->prevVop->yChan + size;
video->prevVop->vChan = video->prevVop->uChan + (size >> 2);
#endif
video->memoryUsage += (size * 3);
#endif // MEMORY_POOL
/* Note that baseVop, enhcVop is only used to hold enhancement */
/* layer header information. 05/04/2000 */
if (nLayers > 1)
{
video->prevEnhcVop = (Vop *) oscl_malloc(sizeof(Vop));
video->memoryUsage += (sizeof(Vop));
if (video->prevEnhcVop == NULL)
{
status = PV_FALSE;
}
else
{
oscl_memset(video->prevEnhcVop, 0, sizeof(Vop));
#ifndef PV_MEMORY_POOL
if (size > INT32_MAX / 3 * 2) {
return PV_FALSE;
}
video->prevEnhcVop->yChan = (PIXEL *) oscl_malloc(size * 3 / 2); /* Allocate memory for all VOP OKA 3/2/1*/
if (video->prevEnhcVop->yChan == NULL) status = PV_FALSE;
video->prevEnhcVop->uChan = video->prevEnhcVop->yChan + size;
video->prevEnhcVop->vChan = video->prevEnhcVop->uChan + (size >> 2);
video->memoryUsage += (3 * size / 2);
#endif
}
}
/* Allocating space for slices, AC prediction flag, and */
/* AC/DC prediction storage */
nTotalMB = video->nTotalMB;
nMBPerRow = video->nMBPerRow;
#ifdef DEC_INTERNAL_MEMORY_OPT
video->sliceNo = (uint8 *)(IMEM_sliceNo);
if (video->sliceNo == NULL) status = PV_FALSE;
video->memoryUsage += nTotalMB;
video->acPredFlag = (uint8 *)(IMEM_acPredFlag);
if (video->acPredFlag == NULL) status = PV_FALSE;
video->memoryUsage += (nTotalMB);
video->predDC = (typeDCStore *)(IMEM_predDC);
if (video->predDC == NULL) status = PV_FALSE;
video->memoryUsage += (nTotalMB * sizeof(typeDCStore));
video->predDCAC_col = (typeDCACStore *)(IMEM_predDCAC_col);
if (video->predDCAC_col == NULL) status = PV_FALSE;
video->memoryUsage += ((nMBPerRow + 1) * sizeof(typeDCACStore));
video->predDCAC_row = video->predDCAC_col + 1;
video->headerInfo.Mode = (uint8 *)(IMEM_headerInfo_Mode);
if (video->headerInfo.Mode == NULL) status = PV_FALSE;
video->memoryUsage += nTotalMB;
video->headerInfo.CBP = (uint8 *)(IMEM_headerInfo_CBP);
if (video->headerInfo.CBP == NULL) status = PV_FALSE;
video->memoryUsage += nTotalMB;
video->QPMB = (int *)(IMEM_headerInfo_QPMB);
if (video->QPMB == NULL) status = PV_FALSE;
video->memoryUsage += (nTotalMB * sizeof(int));
video->mblock = &IMEM_mblock;
if (video->mblock == NULL) status = PV_FALSE;
oscl_memset(video->mblock->block, 0, sizeof(int16)*6*NCOEFF_BLOCK); // Aug 23,2005
video->memoryUsage += sizeof(MacroBlock);
video->motX = (MOT *)(IMEM_motX);
if (video->motX == NULL) status = PV_FALSE;
video->motY = (MOT *)(IMEM_motY);
if (video->motY == NULL) status = PV_FALSE;
video->memoryUsage += (sizeof(MOT) * 8 * nTotalMB);
#else
video->sliceNo = (uint8 *) oscl_malloc(nTotalMB);
if (video->sliceNo == NULL) status = PV_FALSE;
video->memoryUsage += nTotalMB;
video->acPredFlag = (uint8 *) oscl_malloc(nTotalMB * sizeof(uint8));
if (video->acPredFlag == NULL) status = PV_FALSE;
video->memoryUsage += (nTotalMB);
if ((size_t)nTotalMB > SIZE_MAX / sizeof(typeDCStore)) {
return PV_FALSE;
}
video->predDC = (typeDCStore *) oscl_malloc(nTotalMB * sizeof(typeDCStore));
if (video->predDC == NULL) status = PV_FALSE;
video->memoryUsage += (nTotalMB * sizeof(typeDCStore));
if (nMBPerRow > INT32_MAX - 1
|| (size_t)(nMBPerRow + 1) > SIZE_MAX / sizeof(typeDCACStore)) {
return PV_FALSE;
}
video->predDCAC_col = (typeDCACStore *) oscl_malloc((nMBPerRow + 1) * sizeof(typeDCACStore));
if (video->predDCAC_col == NULL) status = PV_FALSE;
video->memoryUsage += ((nMBPerRow + 1) * sizeof(typeDCACStore));
/* element zero will be used for storing vertical (col) AC coefficients */
/* the rest will be used for storing horizontal (row) AC coefficients */
video->predDCAC_row = video->predDCAC_col + 1; /* ACDC */
/* Allocating HeaderInfo structure & Quantizer array */
video->headerInfo.Mode = (uint8 *) oscl_malloc(nTotalMB);
if (video->headerInfo.Mode == NULL) status = PV_FALSE;
video->memoryUsage += nTotalMB;
video->headerInfo.CBP = (uint8 *) oscl_malloc(nTotalMB);
if (video->headerInfo.CBP == NULL) status = PV_FALSE;
video->memoryUsage += nTotalMB;
if ((size_t)nTotalMB > SIZE_MAX / sizeof(int16)) {
return PV_FALSE;
}
video->QPMB = (int16 *) oscl_malloc(nTotalMB * sizeof(int16));
if (video->QPMB == NULL) status = PV_FALSE;
video->memoryUsage += (nTotalMB * sizeof(int));
/* Allocating macroblock space */
video->mblock = (MacroBlock *) oscl_malloc(sizeof(MacroBlock));
if (video->mblock == NULL)
{
status = PV_FALSE;
}
else
{
oscl_memset(video->mblock->block, 0, sizeof(int16)*6*NCOEFF_BLOCK); // Aug 23,2005
video->memoryUsage += sizeof(MacroBlock);
}
/* Allocating motion vector space */
if ((size_t)nTotalMB > SIZE_MAX / (sizeof(MOT) * 4)) {
return PV_FALSE;
}
video->motX = (MOT *) oscl_malloc(sizeof(MOT) * 4 * nTotalMB);
if (video->motX == NULL) status = PV_FALSE;
video->motY = (MOT *) oscl_malloc(sizeof(MOT) * 4 * nTotalMB);
if (video->motY == NULL) status = PV_FALSE;
video->memoryUsage += (sizeof(MOT) * 8 * nTotalMB);
#endif
#ifdef PV_POSTPROC_ON
/* Allocating space for post-processing Mode */
#ifdef DEC_INTERNAL_MEMORY_OPT
video->pstprcTypCur = IMEM_pstprcTypCur;
video->memoryUsage += (nTotalMB * 6);
if (video->pstprcTypCur == NULL)
{
status = PV_FALSE;
}
else
{
oscl_memset(video->pstprcTypCur, 0, 4*nTotalMB + 2*nTotalMB);
}
video->pstprcTypPrv = IMEM_pstprcTypPrv;
video->memoryUsage += (nTotalMB * 6);
if (video->pstprcTypPrv == NULL)
{
status = PV_FALSE;
}
else
{
oscl_memset(video->pstprcTypPrv, 0, nTotalMB*6);
}
#else
if (nTotalMB > INT32_MAX / 6) {
return PV_FALSE;
}
video->pstprcTypCur = (uint8 *) oscl_malloc(nTotalMB * 6);
video->memoryUsage += (nTotalMB * 6);
if (video->pstprcTypCur == NULL)
{
status = PV_FALSE;
}
else
{
oscl_memset(video->pstprcTypCur, 0, 4*nTotalMB + 2*nTotalMB);
}
video->pstprcTypPrv = (uint8 *) oscl_malloc(nTotalMB * 6);
video->memoryUsage += (nTotalMB * 6);
if (video->pstprcTypPrv == NULL)
{
status = PV_FALSE;
}
else
{
oscl_memset(video->pstprcTypPrv, 0, nTotalMB*6);
}
#endif
#endif
/* initialize the decoder library */
video->prevVop->predictionType = I_VOP;
video->prevVop->timeStamp = 0;
#ifndef PV_MEMORY_POOL
oscl_memset(video->prevVop->yChan, 16, sizeof(uint8)*size); /* 10/31/01 */
oscl_memset(video->prevVop->uChan, 128, sizeof(uint8)*size / 2);
oscl_memset(video->currVop->yChan, 0, sizeof(uint8)*size*3 / 2);
if (nLayers > 1)
{
oscl_memset(video->prevEnhcVop->yChan, 0, sizeof(uint8)*size*3 / 2);
video->prevEnhcVop->timeStamp = 0;
}
video->concealFrame = video->prevVop->yChan; /* 07/07/2001 */
decCtrl->outputFrame = video->prevVop->yChan; /* 06/19/2002 */
#endif
/* always start from base layer */
video->currLayer = 0;
return status;
}
/* ======================================================================== */
/* Function : PVResetVideoDecoder() */
/* Date : 01/14/2002 */
/* Purpose : Reset video timestamps */
/* In/out : */
/* Return : PV_TRUE if successed, PV_FALSE if failed. */
/* Modified : */
/* ======================================================================== */
Bool PVResetVideoDecoder(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
int idx;
for (idx = 0; idx < decCtrl->nLayers; idx++)
{
video->vopHeader[idx]->timeStamp = 0;
}
video->prevVop->timeStamp = 0;
if (decCtrl->nLayers > 1)
video->prevEnhcVop->timeStamp = 0;
oscl_memset(video->mblock->block, 0, sizeof(int16)*6*NCOEFF_BLOCK); // Aug 23,2005
return PV_TRUE;
}
/* ======================================================================== */
/* Function : PVCleanUpVideoDecoder() */
/* Date : 04/11/2000, 08/29/2000 */
/* Purpose : Cleanup of the MPEG-4 video decoder library. */
/* In/out : */
/* Return : PV_TRUE if successed, PV_FALSE if failed. */
/* Modified : */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVCleanUpVideoDecoder(VideoDecControls *decCtrl)
{
int idx;
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
#ifdef DEC_INTERNAL_MEMORY_OPT
if (video)
{
#ifdef PV_POSTPROC_ON
video->pstprcTypCur = NULL;
video->pstprcTypPrv = NULL;
#endif
video->acPredFlag = NULL;
video->sliceNo = NULL;
video->motX = NULL;
video->motY = NULL;
video->mblock = NULL;
video->QPMB = NULL;
video->predDC = NULL;
video->predDCAC_row = NULL;
video->predDCAC_col = NULL;
video->headerInfo.Mode = NULL;
video->headerInfo.CBP = NULL;
if (video->numberOfLayers > 1)
{
if (video->prevEnhcVop)
{
video->prevEnhcVop->uChan = NULL;
video->prevEnhcVop->vChan = NULL;
if (video->prevEnhcVop->yChan) oscl_free(video->prevEnhcVop->yChan);
oscl_free(video->prevEnhcVop);
}
}
if (video->currVop)
{
video->currVop->uChan = NULL;
video->currVop->vChan = NULL;
if (video->currVop->yChan)
video->currVop->yChan = NULL;
video->currVop = NULL;
}
if (video->prevVop)
{
video->prevVop->uChan = NULL;
video->prevVop->vChan = NULL;
if (video->prevVop->yChan)
video->prevVop->yChan = NULL;
video->prevVop = NULL;
}
if (video->vol)
{
for (idx = 0; idx < video->numberOfLayers; idx++)
{
if (video->vol[idx])
{
BitstreamClose(video->vol[idx]->bitstream);
video->vol[idx]->bitstream = NULL;
video->vol[idx] = NULL;
}
video->vopHeader[idx] = NULL;
}
video->vol = NULL;
video->vopHeader = NULL;
}
video = NULL;
decCtrl->videoDecoderData = NULL;
}
#else
if (video)
{
#ifdef PV_POSTPROC_ON
if (video->pstprcTypCur) oscl_free(video->pstprcTypCur);
if (video->pstprcTypPrv) oscl_free(video->pstprcTypPrv);
#endif
if (video->predDC) oscl_free(video->predDC);
video->predDCAC_row = NULL;
if (video->predDCAC_col) oscl_free(video->predDCAC_col);
if (video->motX) oscl_free(video->motX);
if (video->motY) oscl_free(video->motY);
if (video->mblock) oscl_free(video->mblock);
if (video->QPMB) oscl_free(video->QPMB);
if (video->headerInfo.Mode) oscl_free(video->headerInfo.Mode);
if (video->headerInfo.CBP) oscl_free(video->headerInfo.CBP);
if (video->sliceNo) oscl_free(video->sliceNo);
if (video->acPredFlag) oscl_free(video->acPredFlag);
if (video->numberOfLayers > 1)
{
if (video->prevEnhcVop)
{
video->prevEnhcVop->uChan = NULL;
video->prevEnhcVop->vChan = NULL;
if (video->prevEnhcVop->yChan) oscl_free(video->prevEnhcVop->yChan);
oscl_free(video->prevEnhcVop);
}
}
if (video->currVop)
{
#ifndef PV_MEMORY_POOL
video->currVop->uChan = NULL;
video->currVop->vChan = NULL;
if (video->currVop->yChan)
oscl_free(video->currVop->yChan);
#endif
oscl_free(video->currVop);
}
if (video->prevVop)
{
#ifndef PV_MEMORY_POOL
video->prevVop->uChan = NULL;
video->prevVop->vChan = NULL;
if (video->prevVop->yChan)
oscl_free(video->prevVop->yChan);
#endif
oscl_free(video->prevVop);
}
if (video->vol)
{
for (idx = 0; idx < video->numberOfLayers; idx++)
{
if (video->vol[idx])
{
if (video->vol[idx]->bitstream)
{
BitstreamClose(video->vol[idx]->bitstream);
oscl_free(video->vol[idx]->bitstream);
}
oscl_free(video->vol[idx]);
}
}
oscl_free(video->vol);
}
for (idx = 0; idx < video->numberOfLayers; idx++)
{
if (video->vopHeader[idx]) oscl_free(video->vopHeader[idx]);
}
if (video->vopHeader) oscl_free(video->vopHeader);
oscl_free(video);
decCtrl->videoDecoderData = NULL;
}
#endif
return PV_TRUE;
}
/* ======================================================================== */
/* Function : PVGetVideoDimensions() */
/* Date : 040505 */
/* Purpose : */
/* In/out : */
/* Return : the display_width and display_height of */
/* the frame in the current layer. */
/* Note : This is not a macro or inline function because we do */
/* not want to expose our internal data structure. */
/* Modified : */
/* ======================================================================== */
OSCL_EXPORT_REF void PVGetVideoDimensions(VideoDecControls *decCtrl, int32 *display_width, int32 *display_height)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
*display_width = video->displayWidth;
*display_height = video->displayHeight;
}
OSCL_EXPORT_REF void PVGetBufferDimensions(VideoDecControls *decCtrl, int32 *width, int32 *height) {
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
*width = video->width;
*height = video->height;
}
/* ======================================================================== */
/* Function : PVGetVideoTimeStamp() */
/* Date : 04/27/2000, 08/29/2000 */
/* Purpose : */
/* In/out : */
/* Return : current time stamp in millisecond. */
/* Note : */
/* Modified : */
/* ======================================================================== */
uint32 PVGetVideoTimeStamp(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
return video->currTimestamp;
}
/* ======================================================================== */
/* Function : PVSetPostProcType() */
/* Date : 07/07/2000 */
/* Purpose : */
/* In/out : */
/* Return : Set post-processing filter type. */
/* Note : */
/* Modified : . 08/29/2000 changes the name for consistency. */
/* ======================================================================== */
OSCL_EXPORT_REF void PVSetPostProcType(VideoDecControls *decCtrl, int mode)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
video->postFilterType = mode;
}
/* ======================================================================== */
/* Function : PVGetDecBitrate() */
/* Date : 08/23/2000 */
/* Purpose : */
/* In/out : */
/* Return : This function returns the average bits per second. */
/* Note : */
/* Modified : */
/* ======================================================================== */
int PVGetDecBitrate(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
int idx;
int32 sum = 0;
for (idx = 0; idx < BITRATE_AVERAGE_WINDOW; idx++)
{
sum += video->nBitsPerVop[idx];
}
sum = (sum * video->frameRate) / (10 * BITRATE_AVERAGE_WINDOW);
return (int) sum;
}
/* ======================================================================== */
/* Function : PVGetDecFramerate() */
/* Date : 08/23/2000 */
/* Purpose : */
/* In/out : */
/* Return : This function returns the average frame per 10 second. */
/* Note : The fps can be calculated by PVGetDecFramerate()/10 */
/* Modified : */
/* ======================================================================== */
int PVGetDecFramerate(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
return video->frameRate;
}
/* ======================================================================== */
/* Function : PVGetOutputFrame() */
/* Date : 05/07/2001 */
/* Purpose : */
/* In/out : */
/* Return : This function returns the pointer to the output frame */
/* Note : */
/* Modified : */
/* ======================================================================== */
uint8 *PVGetDecOutputFrame(VideoDecControls *decCtrl)
{
return decCtrl->outputFrame;
}
/* ======================================================================== */
/* Function : PVGetLayerID() */
/* Date : 07/09/2001 */
/* Purpose : */
/* In/out : */
/* Return : This function returns decoded frame layer id (BASE/ENHANCE) */
/* Note : */
/* Modified : */
/* ======================================================================== */
int PVGetLayerID(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
return video->currLayer;
}
/* ======================================================================== */
/* Function : PVGetDecMemoryUsage() */
/* Date : 08/23/2000 */
/* Purpose : */
/* In/out : */
/* Return : This function returns the amount of memory used. */
/* Note : */
/* Modified : */
/* ======================================================================== */
int32 PVGetDecMemoryUsage(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
return video->memoryUsage;
}
/* ======================================================================== */
/* Function : PVGetDecBitstreamMode() */
/* Date : 08/23/2000 */
/* Purpose : */
/* In/out : */
/* Return : This function returns the decoding mode of the baselayer */
/* bitstream. */
/* Note : */
/* Modified : */
/* ======================================================================== */
OSCL_EXPORT_REF MP4DecodingMode PVGetDecBitstreamMode(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
if (video->shortVideoHeader)
{
return H263_MODE;
}
else
{
return MPEG4_MODE;
}
}
/* ======================================================================== */
/* Function : PVExtractVolHeader() */
/* Date : 08/29/2000 */
/* Purpose : */
/* In/out : */
/* Return : Extract vol header of the bitstream from buffer[]. */
/* Note : */
/* Modified : */
/* ======================================================================== */
Bool PVExtractVolHeader(uint8 *video_buffer, uint8 *vol_header, int32 *vol_header_size)
{
int idx = -1;
uint8 start_code_prefix[] = { 0x00, 0x00, 0x01 };
uint8 h263_prefix[] = { 0x00, 0x00, 0x80 };
if (oscl_memcmp(h263_prefix, video_buffer, 3) == 0) /* we have short header stream */
{
oscl_memcpy(vol_header, video_buffer, 32);
*vol_header_size = 32;
return TRUE;
}
else
{
if (oscl_memcmp(start_code_prefix, video_buffer, 3) ||
(video_buffer[3] != 0xb0 && video_buffer[3] >= 0x20)) return FALSE;
do
{
idx++;
while (oscl_memcmp(start_code_prefix, video_buffer + idx, 3))
{
idx++;
if (idx + 3 >= *vol_header_size) goto quit;
}
}
while (video_buffer[idx+3] != 0xb3 && video_buffer[idx+3] != 0xb6);
oscl_memcpy(vol_header, video_buffer, idx);
*vol_header_size = idx;
return TRUE;
}
quit:
oscl_memcpy(vol_header, video_buffer, *vol_header_size);
return FALSE;
}
/* ======================================================================== */
/* Function : PVLocateFrameHeader() */
/* Date : 04/8/2005 */
/* Purpose : */
/* In/out : */
/* Return : Return the offset to the first SC in the buffer */
/* Note : */
/* Modified : */
/* ======================================================================== */
int32 PVLocateFrameHeader(uint8 *ptr, int32 size)
{
int count = 0;
int32 i = size;
if (size < 1)
{
return 0;
}
while (i--)
{
if ((count > 1) && (*ptr == 0x01))
{
i += 2;
break;
}
if (*ptr++)
count = 0;
else
count++;
}
return (size - (i + 1));
}
/* ======================================================================== */
/* Function : PVLocateH263FrameHeader() */
/* Date : 04/8/2005 */
/* Purpose : */
/* In/out : */
/* Return : Return the offset to the first SC in the buffer */
/* Note : */
/* Modified : */
/* ======================================================================== */
int32 PVLocateH263FrameHeader(uint8 *ptr, int32 size)
{
int count = 0;
int32 i = size;
if (size < 1)
{
return 0;
}
while (i--)
{
if ((count > 1) && ((*ptr & 0xFC) == 0x80))
{
i += 2;
break;
}
if (*ptr++)
count = 0;
else
count++;
}
return (size - (i + 1));
}
/* ======================================================================== */
/* Function : PVDecodeVideoFrame() */
/* Date : 08/29/2000 */
/* Purpose : Decode one video frame and return a YUV-12 image. */
/* In/out : */
/* Return : */
/* Note : */
/* Modified : 04/17/2001 removed PV_EOS, PV_END_OF_BUFFER */
/* : 08/22/2002 break up into 2 functions PVDecodeVopHeader and */
/* PVDecodeVopBody */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVDecodeVideoFrame(VideoDecControls *decCtrl, uint8 *buffer[],
uint32 timestamp[], int32 buffer_size[], uint use_ext_timestamp[], uint8 *currYUV)
{
PV_STATUS status = PV_FAIL;
VopHeaderInfo header_info;
status = (PV_STATUS)PVDecodeVopHeader(decCtrl, buffer, timestamp, buffer_size, &header_info, use_ext_timestamp, currYUV);
if (status != PV_TRUE)
return PV_FALSE;
if (PVDecodeVopBody(decCtrl, buffer_size) != PV_TRUE)
{
return PV_FALSE;
}
return PV_TRUE;
}
/* ======================================================================== */
/* Function : PVDecodeVopHeader() */
/* Date : 08/22/2002 */
/* Purpose : Determine target layer and decode vop header, modified from */
/* original PVDecodeVideoFrame. */
/* In/out : */
/* Return : */
/* Note : */
/* Modified : */
/* ======================================================================== */
Bool PVDecodeVopHeader(VideoDecControls *decCtrl, uint8 *buffer[],
uint32 timestamp[], int32 buffer_size[], VopHeaderInfo *header_info, uint use_ext_timestamp [], uint8 *currYUV)
{
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
Vol *currVol;
Vop *currVop = video->currVop;
Vop **vopHeader = video->vopHeader;
BitstreamDecVideo *stream;
int target_layer;
#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
PV_STATUS status = PV_FAIL;
int idx;
int32 display_time;
/* decide which frame to decode next */
if (decCtrl->nLayers > 1)
{
display_time = target_layer = -1;
for (idx = 0; idx < decCtrl->nLayers; idx++)
{
/* do we have data for this layer? */
if (buffer_size[idx] <= 0)
{
timestamp[idx] = -1;
continue;
}
/* did the application provide a timestamp for this vop? */
if (timestamp[idx] < 0)
{
if (vopHeader[idx]->timeStamp < 0)
{
/* decode the timestamp in the bitstream */
video->currLayer = idx;
stream = video->vol[idx]->bitstream;
BitstreamReset(stream, buffer[idx], buffer_size[idx]);
while ((status = DecodeVOPHeader(video, vopHeader[idx], FALSE)) != PV_SUCCESS)
{
/* Try to find a VOP header in the buffer. 08/30/2000. */
if (PVSearchNextM4VFrame(stream) != PV_SUCCESS)
{
/* if we don't have data for enhancement layer, */
/* don't just stop. 09/07/2000. */
buffer_size[idx] = 0;
break;
}
}
if (status == PV_SUCCESS)
{
vopHeader[idx]->timeStamp =
timestamp[idx] = CalcVopDisplayTime(video->vol[idx], vopHeader[idx], video->shortVideoHeader);
if (idx == 0) vopHeader[idx]->refSelectCode = 1;
}
}
else
{
/* We've decoded this vop header in the previous run already. */
timestamp[idx] = vopHeader[idx]->timeStamp;
}
}
/* Use timestamps to select the next VOP to be decoded */
if (timestamp[idx] >= 0 && (display_time < 0 || display_time > timestamp[idx]))
{
display_time = timestamp[idx];
target_layer = idx;
}
else if (display_time == timestamp[idx])
{
/* we have to handle either SNR or spatial scalability here. */
}
}
if (target_layer < 0) return PV_FALSE;
/* set up for decoding the target layer */
video->currLayer = target_layer;
currVol = video->vol[target_layer];
video->bitstream = stream = currVol->bitstream;
/* We need to decode the vop header if external timestamp */
/* is provided. 10/04/2000 */
if (vopHeader[target_layer]->timeStamp < 0)
{
stream = video->vol[target_layer]->bitstream;
BitstreamReset(stream, buffer[target_layer], buffer_size[target_layer]);
while (DecodeVOPHeader(video, vopHeader[target_layer], TRUE) != PV_SUCCESS)
{
/* Try to find a VOP header in the buffer. 08/30/2000. */
if (PVSearchNextM4VFrame(stream) != PV_SUCCESS)
{
/* if we don't have data for enhancement layer, */
/* don't just stop. 09/07/2000. */
buffer_size[target_layer] = 0;
break;
}
}
video->vol[target_layer]->timeInc_offset = vopHeader[target_layer]->timeInc;
video->vol[target_layer]->moduloTimeBase = timestamp[target_layer];
vopHeader[target_layer]->timeStamp = timestamp[target_layer];
if (target_layer == 0) vopHeader[target_layer]->refSelectCode = 1;
}
}
else /* base layer only decoding */
{
#endif
video->currLayer = target_layer = 0;
currVol = video->vol[0];
video->bitstream = stream = currVol->bitstream;
if (buffer_size[0] <= 0) return PV_FALSE;
BitstreamReset(stream, buffer[0], buffer_size[0]);
if (video->shortVideoHeader)
{
while (DecodeShortHeader(video, vopHeader[0]) != PV_SUCCESS)
{
if (PVSearchNextH263Frame(stream) != PV_SUCCESS)
{
/* There is no vop header in the buffer, */
/* clean bitstream buffer. 2/5/2001 */
buffer_size[0] = 0;
if (video->initialized == PV_FALSE)
{
video->displayWidth = video->width = 0;
video->displayHeight = video->height = 0;
}
return PV_FALSE;
}
}
if (use_ext_timestamp[0])
{
/* MTB for H263 is absolute TR */
/* following line is equivalent to round((timestamp[0]*30)/1001); 11/13/2001 */
video->vol[0]->moduloTimeBase = 30 * ((timestamp[0] + 17) / 1001) + (30 * ((timestamp[0] + 17) % 1001) / 1001);
vopHeader[0]->timeStamp = timestamp[0];
}
else
vopHeader[0]->timeStamp = CalcVopDisplayTime(currVol, vopHeader[0], video->shortVideoHeader);
}
else
{
while (DecodeVOPHeader(video, vopHeader[0], FALSE) != PV_SUCCESS)
{
/* Try to find a VOP header in the buffer. 08/30/2000. */
if (PVSearchNextM4VFrame(stream) != PV_SUCCESS)
{
/* There is no vop header in the buffer, */
/* clean bitstream buffer. 2/5/2001 */
buffer_size[0] = 0;
return PV_FALSE;
}
}
if (use_ext_timestamp[0])
{
video->vol[0]->timeInc_offset = vopHeader[0]->timeInc;
video->vol[0]->moduloTimeBase = timestamp[0]; /* 11/12/2001 */
vopHeader[0]->timeStamp = timestamp[0];
}
else
{
vopHeader[0]->timeStamp = CalcVopDisplayTime(currVol, vopHeader[0], video->shortVideoHeader);
}
}
/* set up some base-layer only parameters */
vopHeader[0]->refSelectCode = 1;
#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
}
#endif
timestamp[target_layer] = video->currTimestamp = vopHeader[target_layer]->timeStamp;
#ifdef PV_MEMORY_POOL
vopHeader[target_layer]->yChan = (PIXEL *)currYUV;
vopHeader[target_layer]->uChan = (PIXEL *)currYUV + decCtrl->size;
vopHeader[target_layer]->vChan = (PIXEL *)(vopHeader[target_layer]->uChan) + (decCtrl->size >> 2);
#else
vopHeader[target_layer]->yChan = currVop->yChan;
vopHeader[target_layer]->uChan = currVop->uChan;
vopHeader[target_layer]->vChan = currVop->vChan;
#endif
oscl_memcpy(currVop, vopHeader[target_layer], sizeof(Vop));
#ifdef PV_SUPPORT_TEMPORAL_SCALABILITY
vopHeader[target_layer]->timeStamp = -1;
#endif
/* put header info into the structure */
header_info->currLayer = target_layer;
header_info->timestamp = video->currTimestamp;
header_info->frameType = (MP4FrameType)currVop->predictionType;
header_info->refSelCode = vopHeader[target_layer]->refSelectCode;
header_info->quantizer = currVop->quantizer;
/***************************************/
return PV_TRUE;
}
/* ======================================================================== */
/* Function : PVDecodeVopBody() */
/* Date : 08/22/2002 */
/* Purpose : Decode vop body after the header is decoded, modified from */
/* original PVDecodeVideoFrame. */
/* In/out : */
/* Return : */
/* Note : */
/* Modified : */
/* ======================================================================== */
Bool PVDecodeVopBody(VideoDecControls *decCtrl, int32 buffer_size[])
{
PV_STATUS status = PV_FAIL;
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
int target_layer = video->currLayer;
Vol *currVol = video->vol[target_layer];
Vop *currVop = video->currVop;
Vop *prevVop = video->prevVop;
Vop *tempVopPtr;
int bytes_consumed = 0; /* Record how many bits we used in the buffer. 04/24/2001 */
int idx;
if (currVop->vopCoded == 0) /* 07/03/2001 */
{
PV_BitstreamByteAlign(currVol->bitstream);
/* We should always clear up bitstream buffer. 10/10/2000 */
bytes_consumed = (getPointer(currVol->bitstream) + 7) >> 3;
if (bytes_consumed > currVol->bitstream->data_end_pos)
{
bytes_consumed = currVol->bitstream->data_end_pos;
}
if (bytes_consumed < buffer_size[target_layer])
{
/* If we only consume part of the bits in the buffer, take those */
/* out. 04/24/2001 */
/* oscl_memcpy(buffer[target_layer], buffer[target_layer]+bytes_consumed,
(buffer_size[target_layer]-=bytes_consumed)); */
buffer_size[target_layer] -= bytes_consumed;
}
else
{
buffer_size[target_layer] = 0;
}
#ifdef PV_MEMORY_POOL
if (target_layer)
{
if (video->prevEnhcVop->timeStamp > video->prevVop->timeStamp)
{
video->prevVop = video->prevEnhcVop;
}
}
oscl_memcpy(currVop->yChan, video->prevVop->yChan, (decCtrl->size*3) / 2);
video->prevVop = prevVop;
video->concealFrame = currVop->yChan; /* 07/07/2001 */
video->vop_coding_type = currVop->predictionType; /* 07/09/01 */
decCtrl->outputFrame = currVop->yChan;
/* Swap VOP pointers. No enhc. frame oscl_memcpy() anymore! 04/24/2001 */
if (target_layer)
{
tempVopPtr = video->prevEnhcVop;
video->prevEnhcVop = video->currVop;
video->currVop = tempVopPtr;
}
else
{
tempVopPtr = video->prevVop;
video->prevVop = video->currVop;
video->currVop = tempVopPtr;
}
#else
if (target_layer) /* this is necessary to avoid flashback problems 06/21/2002*/
{
video->prevEnhcVop->timeStamp = currVop->timeStamp;
}
else
{
video->prevVop->timeStamp = currVop->timeStamp;
}
#endif
video->vop_coding_type = currVop->predictionType; /* 07/09/01 */
/* the following is necessary to avoid displaying an notCoded I-VOP at the beginning of a session
or after random positioning 07/03/02*/
if (currVop->predictionType == I_VOP)
{
video->vop_coding_type = P_VOP;
}
return PV_TRUE;
}
/* ======================================================= */
/* Decode vop body (if there is no error in the header!) */
/* ======================================================= */
/* first, we need to select a reference frame */
if (decCtrl->nLayers > 1)
{
if (currVop->predictionType == I_VOP)
{
/* do nothing here */
}
else if (currVop->predictionType == P_VOP)
{
switch (currVop->refSelectCode)
{
case 0 : /* most recently decoded enhancement vop */
/* Setup video->prevVop before we call PV_DecodeVop(). 04/24/2001 */
if (video->prevEnhcVop->timeStamp >= video->prevVop->timeStamp)
video->prevVop = video->prevEnhcVop;
break;
case 1 : /* most recently displayed base-layer vop */
if (target_layer)
{
if (video->prevEnhcVop->timeStamp > video->prevVop->timeStamp)
video->prevVop = video->prevEnhcVop;
}
break;
case 2 : /* next base-layer vop in display order */
break;
case 3 : /* temporally coincident base-layer vop (no MV's) */
break;
}
}
else /* we have a B-Vop */
{
mp4dec_log("DecodeVideoFrame(): B-VOP not supported.\n");
}
}
/* This is for the calculation of the frame rate and bitrate. */
idx = ++video->frame_idx % BITRATE_AVERAGE_WINDOW;
/* Calculate bitrate for this layer. 08/23/2000 */
status = PV_DecodeVop(video);
video->nBitsPerVop[idx] = getPointer(currVol->bitstream);
video->prevTimestamp[idx] = currVop->timeStamp;
/* restore video->prevVop after PV_DecodeVop(). 04/24/2001 */
// if (currVop->refSelectCode == 0) video->prevVop = prevVop;
video->prevVop = prevVop;
/* Estimate the frame rate. 08/23/2000 */
video->duration = video->prevTimestamp[idx];
video->duration -= video->prevTimestamp[(++idx)%BITRATE_AVERAGE_WINDOW];
if (video->duration > 0)
{ /* Only update framerate when the timestamp is right */
video->frameRate = (int)(FRAMERATE_SCALE) / video->duration;
}
/* We should always clear up bitstream buffer. 10/10/2000 */
bytes_consumed = (getPointer(currVol->bitstream) + 7) >> 3; /* 11/4/03 */
if (bytes_consumed > currVol->bitstream->data_end_pos)
{
bytes_consumed = currVol->bitstream->data_end_pos;
}
if (bytes_consumed < buffer_size[target_layer])
{
/* If we only consume part of the bits in the buffer, take those */
/* out. 04/24/2001 */
/* oscl_memcpy(buffer[target_layer], buffer[target_layer]+bytes_consumed,
(buffer_size[target_layer]-=bytes_consumed)); */
buffer_size[target_layer] -= bytes_consumed;
}
else
{
buffer_size[target_layer] = 0;
}
switch (status)
{
case PV_FAIL :
return PV_FALSE; /* this will take care of concealment if we lose whole frame */
case PV_END_OF_VOP :
/* we may want to differenciate PV_END_OF_VOP and PV_SUCCESS */
/* in the future. 05/10/2000 */
case PV_SUCCESS :
/* Nohting is wrong :). */
video->concealFrame = video->currVop->yChan; /* 07/07/2001 */
video->vop_coding_type = video->currVop->predictionType; /* 07/09/01 */
decCtrl->outputFrame = video->currVop->yChan;
/* Swap VOP pointers. No enhc. frame oscl_memcpy() anymore! 04/24/2001 */
if (target_layer)
{
tempVopPtr = video->prevEnhcVop;
video->prevEnhcVop = video->currVop;
video->currVop = tempVopPtr;
}
else
{
tempVopPtr = video->prevVop;
video->prevVop = video->currVop;
video->currVop = tempVopPtr;
}
break;
default :
/* This will never happen */
break;
}
return PV_TRUE;
}
#ifdef PV_MEMORY_POOL
OSCL_EXPORT_REF void PVSetReferenceYUV(VideoDecControls *decCtrl, uint8 *YUV)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
video->prevVop->yChan = (PIXEL *)YUV;
video->prevVop->uChan = (PIXEL *)YUV + video->size;
video->prevVop->vChan = (PIXEL *)video->prevVop->uChan + (decCtrl->size >> 2);
oscl_memset(video->prevVop->yChan, 16, sizeof(uint8)*decCtrl->size); /* 10/31/01 */
oscl_memset(video->prevVop->uChan, 128, sizeof(uint8)*decCtrl->size / 2);
video->concealFrame = video->prevVop->yChan; /* 07/07/2001 */
decCtrl->outputFrame = video->prevVop->yChan; /* 06/19/2002 */
}
#endif
/* ======================================================================== */
/* Function : VideoDecoderErrorDetected() */
/* Date : 06/20/2000 */
/* Purpose : */
/* In/out : */
/* Return : This function will be called everytime an error int the */
/* bitstream is detected. */
/* Note : */
/* Modified : */
/* ======================================================================== */
uint VideoDecoderErrorDetected(VideoDecData *)
{
/* This is only used for trapping bitstream error for debuging */
return 0;
}
#ifdef ENABLE_LOG
#include <stdio.h>
#include <stdarg.h>
/* ======================================================================== */
/* Function : m4vdec_dprintf() */
/* Date : 08/15/2000 */
/* Purpose : This is a function that logs messages in the mpeg4 video */
/* decoder. We can call the standard PacketVideo PVMessage */
/* from inside this function if necessary. */
/* In/out : */
/* Return : */
/* Note : To turn on the logging, LOG_MP4DEC_MESSAGE must be defined */
/* when compiling this file (only this file). */
/* Modified : */
/* ======================================================================== */
void m4vdec_dprintf(char *format, ...)
{
FILE *log_fp;
va_list args;
va_start(args, format);
/* open the log file */
log_fp = fopen("\\mp4dec_log.txt", "a+");
if (log_fp == NULL) return;
/* output the message */
vfprintf(log_fp, format, args);
fclose(log_fp);
va_end(args);
}
#endif
/* ======================================================================== */
/* Function : IsIntraFrame() */
/* Date : 05/29/2000 */
/* Purpose : */
/* In/out : */
/* Return : The most recently decoded frame is an Intra frame. */
/* Note : */
/* Modified : */
/* ======================================================================== */
Bool IsIntraFrame(VideoDecControls *decCtrl)
{
VideoDecData *video = (VideoDecData *)decCtrl->videoDecoderData;
return (video->vop_coding_type == I_VOP);
}
/* ======================================================================== */
/* Function : PVDecPostProcess() */
/* Date : 01/09/2002 */
/* Purpose : PostProcess one video frame and return a YUV-12 image. */
/* In/out : */
/* Return : */
/* Note : */
/* Modified : */
/* ======================================================================== */
void PVDecPostProcess(VideoDecControls *decCtrl, uint8 *outputYUV)
{
uint8 *outputBuffer;
#ifdef PV_POSTPROC_ON
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
int32 tmpvar;
if (outputYUV)
{
outputBuffer = outputYUV;
}
else
{
if (video->postFilterType)
{
outputBuffer = video->currVop->yChan;
}
else
{
outputBuffer = decCtrl->outputFrame;
}
}
if (video->postFilterType)
{
/* Post-processing, */
PostFilter(video, video->postFilterType, outputBuffer);
}
else
{
if (outputYUV)
{
/* Copy decoded frame to the output buffer. */
tmpvar = (int32)video->width * video->height;
oscl_memcpy(outputBuffer, decCtrl->outputFrame, tmpvar*3 / 2); /* 3/3/01 */
}
}
#else
outputBuffer = decCtrl->outputFrame;
outputYUV;
#endif
decCtrl->outputFrame = outputBuffer;
return;
}
/* ======================================================================== */
/* Function : PVDecSetReference(VideoDecControls *decCtrl, uint8 *refYUV, */
/* int32 timestamp) */
/* Date : 07/22/2003 */
/* Purpose : Get YUV reference frame from external source. */
/* In/out : YUV 4-2-0 frame containing new reference frame in the same */
/* : dimension as original, i.e., doesn't have to be multiple of 16 !!!. */
/* Return : */
/* Note : */
/* Modified : */
/* ======================================================================== */
Bool PVDecSetReference(VideoDecControls *decCtrl, uint8 *refYUV, uint32 timestamp)
{
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
Vop *prevVop = video->prevVop;
int width = video->width;
uint8 *dstPtr, *orgPtr, *dstPtr2, *orgPtr2;
int32 size = (int32)width * video->height;
/* set new parameters */
prevVop->timeStamp = timestamp;
prevVop->predictionType = I_VOP;
dstPtr = prevVop->yChan;
orgPtr = refYUV;
oscl_memcpy(dstPtr, orgPtr, size);
dstPtr = prevVop->uChan;
dstPtr2 = prevVop->vChan;
orgPtr = refYUV + size;
orgPtr2 = orgPtr + (size >> 2);
oscl_memcpy(dstPtr, orgPtr, (size >> 2));
oscl_memcpy(dstPtr2, orgPtr2, (size >> 2));
video->concealFrame = video->prevVop->yChan;
video->vop_coding_type = I_VOP;
decCtrl->outputFrame = video->prevVop->yChan;
return PV_TRUE;
}
/* ======================================================================== */
/* Function : PVDecSetEnhReference(VideoDecControls *decCtrl, uint8 *refYUV, */
/* int32 timestamp) */
/* Date : 07/23/2003 */
/* Purpose : Get YUV enhance reference frame from external source. */
/* In/out : YUV 4-2-0 frame containing new reference frame in the same */
/* : dimension as original, i.e., doesn't have to be multiple of 16 !!!. */
/* Return : */
/* Note : */
/* Modified : */
/* ======================================================================== */
Bool PVDecSetEnhReference(VideoDecControls *decCtrl, uint8 *refYUV, uint32 timestamp)
{
VideoDecData *video = (VideoDecData *) decCtrl->videoDecoderData;
Vop *prevEnhcVop = video->prevEnhcVop;
uint8 *dstPtr, *orgPtr, *dstPtr2, *orgPtr2;
int32 size = (int32) video->width * video->height;
if (video->numberOfLayers <= 1)
return PV_FALSE;
/* set new parameters */
prevEnhcVop->timeStamp = timestamp;
prevEnhcVop->predictionType = I_VOP;
dstPtr = prevEnhcVop->yChan;
orgPtr = refYUV;
oscl_memcpy(dstPtr, orgPtr, size);
dstPtr = prevEnhcVop->uChan;
dstPtr2 = prevEnhcVop->vChan;
orgPtr = refYUV + size;
orgPtr2 = orgPtr + (size >> 2);
oscl_memcpy(dstPtr, orgPtr, (size >> 2));
oscl_memcpy(dstPtr2, orgPtr2, (size >> 2));
video->concealFrame = video->prevEnhcVop->yChan;
video->vop_coding_type = I_VOP;
decCtrl->outputFrame = video->prevEnhcVop->yChan;
return PV_TRUE;
}
/* ======================================================================== */
/* Function : PVGetVolInfo() */
/* Date : 08/06/2003 */
/* Purpose : Get the vol info(only base-layer). */
/* In/out : */
/* Return : */
/* Note : */
/* Modified : 06/24/2004 */
/* ======================================================================== */
Bool PVGetVolInfo(VideoDecControls *decCtrl, VolInfo *pVolInfo)
{
Vol *currVol;
if (pVolInfo == NULL || decCtrl == NULL || decCtrl->videoDecoderData == NULL ||
((VideoDecData *)decCtrl->videoDecoderData)->vol[0] == NULL) return PV_FALSE;
currVol = ((VideoDecData *)(decCtrl->videoDecoderData))->vol[0];
// get the VOL info
pVolInfo->shortVideoHeader = (int32)((VideoDecData *)(decCtrl->videoDecoderData))->shortVideoHeader;
pVolInfo->dataPartitioning = (int32)currVol->dataPartitioning;
pVolInfo->errorResDisable = (int32)currVol->errorResDisable;
pVolInfo->useReverseVLC = (int32)currVol->useReverseVLC;
pVolInfo->scalability = (int32)currVol->scalability;
pVolInfo->nbitsTimeIncRes = (int32)currVol->nbitsTimeIncRes;
pVolInfo->profile_level_id = (int32)currVol->profile_level_id;
return PV_TRUE;
}