1984 lines
82 KiB
C
1984 lines
82 KiB
C
/* ///////////////////////////////////////////////////////////////////////
|
|
//
|
|
// INTEL CORPORATION PROPRIETARY INFORMATION
|
|
// This software is supplied under the terms of a license agreement or
|
|
// nondisclosure agreement with Intel Corporation and may not be copied
|
|
// or disclosed except in accordance with the terms of that agreement.
|
|
// Copyright (c) 2001-2008 Intel Corporation. All Rights Reserved.
|
|
//
|
|
// Description: Decodes MPEG-4 bitstream.
|
|
//
|
|
*/
|
|
|
|
#include "mp4def.h"
|
|
#include "mp4dec.h"
|
|
|
|
#pragma warning(disable : 188) // enumerated type mixed with another type ICL
|
|
|
|
void mp4_ResetVOL(mp4_Info *pInfo)
|
|
{
|
|
pInfo->VisualObject.VideoObject.VOPindex = 0;
|
|
pInfo->VisualObject.VideoObject.prevPlaneIsB = 0;
|
|
pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.time_code = 0;
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame=0;
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame=0;
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.nFrame);
|
|
pInfo->VisualObject.nFrame=0;
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.sFrame);
|
|
pInfo->VisualObject.sFrame=0;
|
|
}
|
|
|
|
static int AllocateInitFrame(mp4_Frame* pFrame)
|
|
{
|
|
int32_t w, h;
|
|
|
|
w = (pFrame->mbPerRow + 2 * MP4_NUM_EXT_MB) << 4;
|
|
h = (pFrame->mbPerCol + 2 * MP4_NUM_EXT_MB) << 4;
|
|
pFrame->mid = malloc(w * h + (w * h >> 1));
|
|
if (!pFrame->mid)
|
|
return 1; // out of memory
|
|
|
|
ippsSet_8u(0, pFrame->mid, w * h);
|
|
ippsSet_8u(128, pFrame->mid + w * h, w * h >> 1);
|
|
|
|
pFrame->stepY = w;
|
|
pFrame->stepCb = w >> 1;
|
|
pFrame->stepCr = w >> 1;
|
|
|
|
/* benski> stuff from LockFrame... */
|
|
pFrame->apY = pFrame->mid;
|
|
pFrame->pY = pFrame->apY + w * 16 + 16;
|
|
pFrame->apCb = pFrame->apY + w * h;
|
|
w >>= 1;
|
|
h >>= 1;
|
|
pFrame->pCb = pFrame->apCb + w * 8 + 8;
|
|
pFrame->apCr = pFrame->apCb + w * h;
|
|
pFrame->pCr = pFrame->apCr + w * 8 + 8;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static mp4_Status mp4_AllocInitFrame(mp4_Frame* pFrame, int32_t mbPerRow, int32_t mbPerCol)
|
|
{
|
|
int32_t w, h;
|
|
|
|
w = (mbPerRow + 2 * MP4_NUM_EXT_MB) << 4;
|
|
h = (mbPerCol + 2 * MP4_NUM_EXT_MB) << 4;
|
|
pFrame->stepY = w;
|
|
pFrame->apY = ippsMalloc_8u(w * h);
|
|
if (!pFrame->apY)
|
|
return MP4_STATUS_NO_MEM;
|
|
ippsSet_8u(0, pFrame->apY, w * h);
|
|
pFrame->pY = pFrame->apY + w * 16 + 16;
|
|
w >>= 1;
|
|
h >>= 1;
|
|
pFrame->stepCb = w;
|
|
pFrame->apCb = ippsMalloc_8u(w * h);
|
|
if (!pFrame->apCb)
|
|
return MP4_STATUS_NO_MEM;
|
|
ippsSet_8u(128, pFrame->apCb, w * h);
|
|
pFrame->pCb = pFrame->apCb + w * 8 + 8;
|
|
pFrame->stepCr = w;
|
|
pFrame->apCr = ippsMalloc_8u(w * h);
|
|
if (!pFrame->apCr)
|
|
return MP4_STATUS_NO_MEM;
|
|
pFrame->pCr = pFrame->apCr + w * 8 + 8;
|
|
ippsSet_8u(128, pFrame->apCr, w * h);
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
// mp4_Info for decoding of Video Object Layer
|
|
*/
|
|
mp4_Status mp4_InitVOL(mp4_Info* pInfo)
|
|
{
|
|
int32_t mbPerRow, mbPerCol, specSize;
|
|
|
|
if (pInfo->VisualObject.VideoObject.short_video_header) {
|
|
pInfo->noBVOPs = 1;
|
|
} else {
|
|
if (pInfo->strictSyntaxCheck) {
|
|
if (pInfo->VisualObject.VideoObject.random_accessible_vol)
|
|
pInfo->noPVOPs = pInfo->noBVOPs = 1;
|
|
if (pInfo->VisualObject.VideoObject.type_indication == MP4_VIDEO_OBJECT_TYPE_SIMPLE ||
|
|
pInfo->VisualObject.VideoObject.type_indication == MP4_VIDEO_OBJECT_TYPE_ADVANCED_REAL_TIME_SIMPLE ||
|
|
pInfo->VisualObject.VideoObject.VOLControlParameters.low_delay) {
|
|
pInfo->noBVOPs = 1;
|
|
}
|
|
}
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.shape == MP4_SHAPE_TYPE_RECTANGULAR)
|
|
{
|
|
mbPerRow = (pInfo->VisualObject.VideoObject.width + 15) >> 4;
|
|
mbPerCol = (pInfo->VisualObject.VideoObject.height + 15) >> 4;
|
|
// current frame
|
|
// if (mp4_AllocInitFrame(&pInfo->VisualObject.cFrame, mbPerRow, mbPerCol) != MP4_STATUS_OK)
|
|
// return MP4_STATUS_NO_MEM;
|
|
if (pInfo->VisualObject.VideoObject.sprite_enable != MP4_SPRITE_STATIC)
|
|
{
|
|
// ref in past frame
|
|
// if (mp4_AllocInitFrame(&pInfo->VisualObject.rFrame, mbPerRow, mbPerCol) != MP4_STATUS_OK)
|
|
// return MP4_STATUS_NO_MEM;
|
|
// ref in future frame
|
|
// if (mp4_AllocInitFrame(&pInfo->VisualObject.nFrame, mbPerRow, mbPerCol) != MP4_STATUS_OK)
|
|
// return MP4_STATUS_NO_MEM;
|
|
// motion info (not needed for Sprites)
|
|
pInfo->VisualObject.VideoObject.MBinfo = (mp4_MacroBlock*)ippsMalloc_8u(mbPerRow*mbPerCol*sizeof(mp4_MacroBlock));
|
|
if (!pInfo->VisualObject.VideoObject.MBinfo) return MP4_STATUS_NO_MEM;
|
|
#ifdef USE_NOTCODED_STATE
|
|
// not_coded MB state
|
|
pInfo->VisualObject.VideoObject.ncState = ippsMalloc_8u(mbPerCol * mbPerRow);
|
|
if (!pInfo->VisualObject.VideoObject.ncState) return MP4_STATUS_NO_MEM;
|
|
pInfo->VisualObject.VideoObject.ncStateCleared = 0;
|
|
#endif
|
|
}
|
|
else
|
|
{ // data for static sprite
|
|
mbPerRow = pInfo->VisualObject.sFrame->mbPerRow = (pInfo->VisualObject.VideoObject.sprite_width + 15) >> 4;
|
|
mbPerCol = pInfo->VisualObject.sFrame->mbPerCol = (pInfo->VisualObject.VideoObject.sprite_height + 15) >> 4;
|
|
// if (mp4_AllocInitFrame(&pInfo->VisualObject.sFrame, mbPerRow, mbPerCol) != MP4_STATUS_OK)
|
|
// return MP4_STATUS_NO_MEM;
|
|
}
|
|
pInfo->VisualObject.VideoObject.MacroBlockPerRow = mbPerRow;
|
|
pInfo->VisualObject.VideoObject.MacroBlockPerCol = mbPerCol;
|
|
pInfo->VisualObject.VideoObject.MacroBlockPerVOP = mbPerRow * mbPerCol;
|
|
pInfo->VisualObject.VideoObject.mbns = mp4_GetMacroBlockNumberSize(pInfo->VisualObject.VideoObject.MacroBlockPerVOP);
|
|
|
|
if (!pInfo->VisualObject.VideoObject.short_video_header)
|
|
{
|
|
// Intra Prediction info (not needed for SVH)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.quant = ippsMalloc_8u(mbPerRow + 1);
|
|
if (!pInfo->VisualObject.VideoObject.IntraPredBuff.quant) return MP4_STATUS_NO_MEM;
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.block = (mp4_IntraPredBlock*)ippsMalloc_8u((mbPerRow + 1)*6*sizeof(mp4_IntraPredBlock));
|
|
if (!pInfo->VisualObject.VideoObject.IntraPredBuff.block) return MP4_STATUS_NO_MEM;
|
|
{
|
|
mp4_IntraPredBlock *mbCurr = pInfo->VisualObject.VideoObject.IntraPredBuff.block;
|
|
mp4_IntraPredBlock *mbA = mbCurr, *mbB = pInfo->VisualObject.VideoObject.IntraPredBuff.dcB, *mbC = mbCurr + 6;
|
|
int32_t j;
|
|
|
|
for (j = 0; j < mbPerRow; j ++) {
|
|
mbCurr[0].predA = &mbA[1]; mbCurr[0].predB = &mbB[3]; mbCurr[0].predC = &mbC[2];
|
|
mbCurr[1].predA = &mbC[0]; mbCurr[1].predB = &mbC[2]; mbCurr[1].predC = &mbC[3];
|
|
mbCurr[2].predA = &mbA[3]; mbCurr[2].predB = &mbA[1]; mbCurr[2].predC = &mbC[0];
|
|
mbCurr[3].predA = &mbC[2]; mbCurr[3].predB = &mbC[0]; mbCurr[3].predC = &mbC[1];
|
|
mbCurr[4].predA = &mbA[4]; mbCurr[4].predB = &mbB[4]; mbCurr[4].predC = &mbC[4];
|
|
mbCurr[5].predA = &mbA[5]; mbCurr[5].predB = &mbB[5]; mbCurr[5].predC = &mbC[5];
|
|
mbCurr += 6; mbA += 6; mbC += 6;
|
|
}
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.data_partitioned) {
|
|
// DataPart info
|
|
pInfo->VisualObject.VideoObject.DataPartBuff = (mp4_DataPartMacroBlock*)ippsMalloc_8u(mbPerRow*mbPerCol*sizeof(mp4_DataPartMacroBlock));
|
|
if (!pInfo->VisualObject.VideoObject.DataPartBuff) return MP4_STATUS_NO_MEM;
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.interlaced) {
|
|
// Field MV for B-VOP
|
|
pInfo->VisualObject.VideoObject.FieldMV = (IppMotionVector*)ippsMalloc_8u(mbPerRow*mbPerCol*sizeof(IppMotionVector)*2);
|
|
if (!pInfo->VisualObject.VideoObject.FieldMV) return MP4_STATUS_NO_MEM;
|
|
}
|
|
ippiQuantInvIntraGetSize_MPEG4(&specSize);
|
|
pInfo->VisualObject.VideoObject.QuantInvIntraSpec = (IppiQuantInvIntraSpec_MPEG4*)ippsMalloc_8u(specSize);
|
|
ippiQuantInvIntraInit_MPEG4(pInfo->VisualObject.VideoObject.quant_type ? pInfo->VisualObject.VideoObject.intra_quant_mat : NULL, pInfo->VisualObject.VideoObject.QuantInvIntraSpec, 8);
|
|
ippiQuantInvInterGetSize_MPEG4(&specSize);
|
|
pInfo->VisualObject.VideoObject.QuantInvInterSpec = (IppiQuantInvInterSpec_MPEG4*)ippsMalloc_8u(specSize);
|
|
ippiQuantInvInterInit_MPEG4(pInfo->VisualObject.VideoObject.quant_type ? pInfo->VisualObject.VideoObject.nonintra_quant_mat : NULL, pInfo->VisualObject.VideoObject.QuantInvInterSpec, 8);
|
|
ippiWarpGetSize_MPEG4(&specSize);
|
|
pInfo->VisualObject.VideoObject.WarpSpec = (IppiWarpSpec_MPEG4*)ippsMalloc_8u(specSize);
|
|
}
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
// Free memory allocated for mp4_Info
|
|
*/
|
|
mp4_Status mp4_FreeVOL(mp4_Info* pInfo)
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.shape == MP4_SHAPE_TYPE_RECTANGULAR) {
|
|
if (pInfo->VisualObject.VideoObject.sprite_enable != MP4_SPRITE_STATIC) {
|
|
ippsFree(pInfo->VisualObject.VideoObject.MBinfo); pInfo->VisualObject.VideoObject.MBinfo = NULL;
|
|
#ifdef USE_NOTCODED_STATE
|
|
ippsFree(pInfo->VisualObject.VideoObject.ncState);
|
|
#endif
|
|
} else {
|
|
}
|
|
if (!pInfo->VisualObject.VideoObject.short_video_header) {
|
|
ippsFree(pInfo->VisualObject.VideoObject.IntraPredBuff.quant); pInfo->VisualObject.VideoObject.IntraPredBuff.quant = NULL;
|
|
ippsFree(pInfo->VisualObject.VideoObject.IntraPredBuff.block); pInfo->VisualObject.VideoObject.IntraPredBuff.block = NULL;
|
|
if (pInfo->VisualObject.VideoObject.data_partitioned) {
|
|
ippsFree(pInfo->VisualObject.VideoObject.DataPartBuff); pInfo->VisualObject.VideoObject.DataPartBuff = NULL;
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.interlaced) {
|
|
ippsFree(pInfo->VisualObject.VideoObject.FieldMV); pInfo->VisualObject.VideoObject.FieldMV = NULL;
|
|
}
|
|
ippsFree(pInfo->VisualObject.VideoObject.QuantInvIntraSpec); pInfo->VisualObject.VideoObject.QuantInvIntraSpec = NULL;
|
|
ippsFree(pInfo->VisualObject.VideoObject.QuantInvInterSpec); pInfo->VisualObject.VideoObject.QuantInvInterSpec = NULL;
|
|
ippsFree(pInfo->VisualObject.VideoObject.WarpSpec); pInfo->VisualObject.VideoObject.WarpSpec = NULL;
|
|
}
|
|
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
|
|
mp4_Status mp4_DecodeMVD(mp4_Info *pInfo, int32_t *mvdx, int32_t *mvdy, int32_t fcode)
|
|
{
|
|
const mp4_VLC1 *pTab;
|
|
int32_t mvd, sign;
|
|
uint32_t code;
|
|
int32_t factor = fcode - 1;
|
|
|
|
/* decode MVDx */
|
|
code = mp4_ShowBits(pInfo, 12);
|
|
if (code >= 128)
|
|
pTab = mp4_MVD_B12_2 + ((code - 128) >> 5);
|
|
else if (code >= 2)
|
|
pTab = mp4_MVD_B12_1 + (code - 2);
|
|
else {
|
|
mp4_Error("Error: decoding MVD");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
mvd = pTab->code;
|
|
mp4_FlushBits(pInfo, pTab->len);
|
|
if (mvd) {
|
|
sign = mp4_GetBit(pInfo);
|
|
if (factor) {
|
|
code = mp4_GetBits9(pInfo, factor);
|
|
mvd = ((mvd - 1) << factor) + code + 1;
|
|
}
|
|
if (sign)
|
|
mvd = -mvd;
|
|
}
|
|
*mvdx = mvd;
|
|
/* decode MVDy */
|
|
code = mp4_ShowBits(pInfo, 12);
|
|
if (code >= 128)
|
|
pTab = mp4_MVD_B12_2 + ((code - 128) >> 5);
|
|
else if (code >= 2)
|
|
pTab = mp4_MVD_B12_1 + (code - 2);
|
|
else {
|
|
mp4_Error("Error: decoding MVD");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
mvd = pTab->code;
|
|
mp4_FlushBits(pInfo, pTab->len);
|
|
if (mvd) {
|
|
sign = mp4_GetBit(pInfo);
|
|
if (factor) {
|
|
code = mp4_GetBits9(pInfo, factor);
|
|
mvd = ((mvd - 1) << factor) + code + 1;
|
|
}
|
|
if (sign)
|
|
mvd = -mvd;
|
|
}
|
|
*mvdy = mvd;
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_DecodeMV(mp4_Info *pInfo, IppMotionVector *mv, int32_t fcode)
|
|
{
|
|
int32_t mvdx, mvdy, range, range2, dx, dy;
|
|
|
|
if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
range = 16 << fcode;
|
|
range2 = range + range;
|
|
dx = mv->dx + mvdx;
|
|
if (dx < -range)
|
|
dx += range2;
|
|
else if (dx >= range)
|
|
dx -= range2;
|
|
mv->dx = (int16_t)dx;
|
|
dy = mv->dy + mvdy;
|
|
if (dy < -range)
|
|
dy += range2;
|
|
else if (dy >= range)
|
|
dy -= range2;
|
|
mv->dy = (int16_t)dy;
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_Decode4MV(mp4_Info *pInfo, IppMotionVector *mv, int32_t fcode)
|
|
{
|
|
int32_t i, mvdx, mvdy, range, range2, dx, dy;
|
|
|
|
range = 16 << fcode;
|
|
range2 = range + range;
|
|
for (i = 0; i < 4; i ++) {
|
|
if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
dx = mv[i].dx + mvdx;
|
|
if (dx < -range)
|
|
dx += range2;
|
|
else if (dx >= range)
|
|
dx -= range2;
|
|
mv[i].dx = (int16_t)dx;
|
|
dy = mv[i].dy + mvdy;
|
|
if (dy < -range)
|
|
dy += range2;
|
|
else if (dy >= range)
|
|
dy -= range2;
|
|
mv[i].dy = (int16_t)dy;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_DecodeMV_Direct(mp4_Info *pInfo, IppMotionVector mvC[4], IppMotionVector mvForw[4], IppMotionVector mvBack[4], int32_t TRB, int32_t TRD, int32_t modb, int32_t comb_type)
|
|
{
|
|
int32_t mvdx, mvdy, i;
|
|
|
|
if (modb == 2) {
|
|
if (comb_type != IPPVC_MBTYPE_INTER4V) {
|
|
mvForw[0].dx = mvForw[1].dx = mvForw[2].dx = mvForw[3].dx = (int16_t)((TRB * mvC[0].dx) / TRD);
|
|
mvForw[0].dy = mvForw[1].dy = mvForw[2].dy = mvForw[3].dy = (int16_t)((TRB * mvC[0].dy) / TRD);
|
|
mvBack[0].dx = mvBack[1].dx = mvBack[2].dx = mvBack[3].dx = (int16_t)(((TRB - TRD) * mvC[0].dx) / TRD);
|
|
mvBack[0].dy = mvBack[1].dy = mvBack[2].dy = mvBack[3].dy = (int16_t)(((TRB - TRD) * mvC[0].dy) / TRD);
|
|
} else
|
|
for (i = 0; i < 4; i ++) {
|
|
mvForw[i].dx = (int16_t)((TRB * mvC[i].dx) / TRD);
|
|
mvForw[i].dy = (int16_t)((TRB * mvC[i].dy) / TRD);
|
|
mvBack[i].dx = (int16_t)(((TRB - TRD) * mvC[i].dx) / TRD);
|
|
mvBack[i].dy = (int16_t)(((TRB - TRD) * mvC[i].dy) / TRD);
|
|
}
|
|
} else {
|
|
if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, 1) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
if (comb_type != IPPVC_MBTYPE_INTER4V) {
|
|
mvForw[0].dx = mvForw[1].dx = mvForw[2].dx = mvForw[3].dx = (int16_t)((TRB * mvC[0].dx) / TRD + mvdx);
|
|
mvForw[0].dy = mvForw[1].dy = mvForw[2].dy = mvForw[3].dy = (int16_t)((TRB * mvC[0].dy) / TRD + mvdy);
|
|
if (mvdx == 0)
|
|
mvBack[0].dx = mvBack[1].dx = mvBack[2].dx = mvBack[3].dx = (int16_t)(((TRB - TRD) * mvC[0].dx) / TRD);
|
|
else
|
|
mvBack[0].dx = mvBack[1].dx = mvBack[2].dx = mvBack[3].dx = (int16_t)(mvForw[0].dx - mvC[0].dx);
|
|
if (mvdy == 0)
|
|
mvBack[0].dy = mvBack[1].dy = mvBack[2].dy = mvBack[3].dy = (int16_t)(((TRB - TRD) * mvC[0].dy) / TRD);
|
|
else
|
|
mvBack[0].dy = mvBack[1].dy = mvBack[2].dy = mvBack[3].dy = (int16_t)(mvForw[0].dy - mvC[0].dy);
|
|
} else
|
|
for (i = 0; i < 4; i++) {
|
|
mvForw[i].dx = (int16_t)((TRB * mvC[i].dx) / TRD + mvdx);
|
|
mvForw[i].dy = (int16_t)((TRB * mvC[i].dy) / TRD + mvdy);
|
|
if (mvdx == 0)
|
|
mvBack[i].dx = (int16_t)(((TRB - TRD) * mvC[i].dx) / TRD);
|
|
else
|
|
mvBack[i].dx = (int16_t)(mvForw[i].dx - mvC[i].dx);
|
|
if (mvdy == 0)
|
|
mvBack[i].dy = (int16_t)(((TRB - TRD) * mvC[i].dy) / TRD);
|
|
else
|
|
mvBack[i].dy = (int16_t)(mvForw[i].dy - mvC[i].dy);
|
|
}
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_DecodeMV_DirectField(mp4_Info *pInfo, int32_t mb_ftfr, int32_t mb_fbfr, IppMotionVector *mvTop, IppMotionVector *mvBottom, IppMotionVector *mvForwTop, IppMotionVector *mvForwBottom, IppMotionVector *mvBackTop, IppMotionVector *mvBackBottom, int32_t TRB, int32_t TRD, int32_t modb)
|
|
{
|
|
// field direct mode
|
|
int32_t TRDt, TRDb, TRBt, TRBb, deltaTop, deltaBottom, mvdx, mvdy;
|
|
|
|
deltaTop = mb_ftfr;
|
|
deltaBottom = mb_fbfr - 1;
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.top_field_first) {
|
|
deltaTop = -deltaTop;
|
|
deltaBottom = -deltaBottom;
|
|
}
|
|
TRDt = mp4_DivRoundInf(TRD, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaTop;
|
|
TRDb = mp4_DivRoundInf(TRD, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaBottom;
|
|
TRBt = mp4_DivRoundInf(TRB, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaTop;
|
|
TRBb = mp4_DivRoundInf(TRB, pInfo->VisualObject.VideoObject.Tframe) * 2 + deltaBottom;
|
|
if (modb == 2) {
|
|
// delta == 0
|
|
mvdx = mvdy = 0;
|
|
} else {
|
|
if (mp4_DecodeMVD(pInfo, &mvdx, &mvdy, 1) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
mvForwTop->dx = (int16_t)((TRBt * mvTop->dx) / TRDt + mvdx);
|
|
if (mvdx == 0)
|
|
mvBackTop->dx = (int16_t)(((TRBt - TRDt) * mvTop->dx) / TRDt);
|
|
else
|
|
mvBackTop->dx = (int16_t)(mvForwTop->dx - mvTop->dx);
|
|
mvForwTop->dy = (int16_t)((TRBt * mvTop->dy * 2) / TRDt + mvdy);
|
|
if (mvdy == 0)
|
|
mvBackTop->dy = (int16_t)(((TRBt - TRDt) * mvTop->dy * 2) / TRDt);
|
|
else
|
|
mvBackTop->dy = (int16_t)(mvForwTop->dy - mvTop->dy * 2);
|
|
mvForwBottom->dx = (int16_t)((TRBb * mvBottom->dx) / TRDb + mvdx);
|
|
if (mvdx == 0)
|
|
mvBackBottom->dx = (int16_t)(((TRBb - TRDb) * mvBottom->dx) / TRDb);
|
|
else
|
|
mvBackBottom->dx = (int16_t)(mvForwBottom->dx - mvBottom->dx);
|
|
mvForwBottom->dy = (int16_t)((TRBb * mvBottom->dy * 2) / TRDb + mvdy);
|
|
if (mvdy == 0)
|
|
mvBackBottom->dy = (int16_t)(((TRBb - TRDb) * mvBottom->dy * 2) / TRDb);
|
|
else
|
|
mvBackBottom->dy = (int16_t)(mvForwBottom->dy - mvBottom->dy * 2);
|
|
mvForwTop->dy >>= 1;
|
|
mvBackTop->dy >>= 1;
|
|
mvForwBottom->dy >>= 1;
|
|
mvBackBottom->dy >>= 1;
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
/*static*/ void mp4_ExpandFrameReplicate(uint8_t *pSrcDstPlane, int32_t frameWidth, int32_t frameHeight, int32_t expandPels, int32_t step)
|
|
{
|
|
uint8_t *pDst1, *pDst2, *pSrc1, *pSrc2;
|
|
int32_t i, j;
|
|
uint32_t t1, t2;
|
|
|
|
pDst1 = pSrcDstPlane + step * expandPels;
|
|
pDst2 = pDst1 + frameWidth + expandPels;
|
|
if (expandPels == 8) {
|
|
for (i = 0; i < frameHeight; i ++) {
|
|
t1 = pDst1[8] + (pDst1[8] << 8);
|
|
t2 = pDst2[-1] + (pDst2[-1] << 8);
|
|
t1 = (t1 << 16) + t1;
|
|
t2 = (t2 << 16) + t2;
|
|
((uint32_t*)pDst1)[0] = t1;
|
|
((uint32_t*)pDst1)[1] = t1;
|
|
((uint32_t*)pDst2)[0] = t2;
|
|
((uint32_t*)pDst2)[1] = t2;
|
|
pDst1 += step;
|
|
pDst2 += step;
|
|
}
|
|
} else if (expandPels == 16) {
|
|
for (i = 0; i < frameHeight; i ++) {
|
|
t1 = pDst1[16] + (pDst1[16] << 8);
|
|
t2 = pDst2[-1] + (pDst2[-1] << 8);
|
|
t1 = (t1 << 16) + t1;
|
|
t2 = (t2 << 16) + t2;
|
|
((uint32_t*)pDst1)[0] = t1;
|
|
((uint32_t*)pDst1)[1] = t1;
|
|
((uint32_t*)pDst1)[2] = t1;
|
|
((uint32_t*)pDst1)[3] = t1;
|
|
((uint32_t*)pDst2)[0] = t2;
|
|
((uint32_t*)pDst2)[1] = t2;
|
|
((uint32_t*)pDst2)[2] = t2;
|
|
((uint32_t*)pDst2)[3] = t2;
|
|
pDst1 += step;
|
|
pDst2 += step;
|
|
}
|
|
} else {
|
|
for (i = 0; i < frameHeight; i ++) {
|
|
ippsSet_8u(pDst1[expandPels], pDst1, expandPels);
|
|
ippsSet_8u(pDst2[-1], pDst2, expandPels);
|
|
pDst1 += step;
|
|
pDst2 += step;
|
|
}
|
|
}
|
|
pDst1 = pSrcDstPlane;
|
|
pSrc1 = pSrcDstPlane + expandPels * step;
|
|
pDst2 = pSrc1 + frameHeight * step;
|
|
pSrc2 = pDst2 - step;
|
|
j = frameWidth + 2 * expandPels;
|
|
for (i = 0; i < expandPels; i ++) {
|
|
ippsCopy_8u(pSrc1, pDst1, j);
|
|
ippsCopy_8u(pSrc2, pDst2, j);
|
|
pDst1 += step;
|
|
pDst2 += step;
|
|
}
|
|
}
|
|
|
|
void mp4_PadFrame(mp4_Info* pInfo)
|
|
{
|
|
#if 0
|
|
/*
|
|
// padding VOP (for not complete blocks padd by
|
|
// 0 for DivX(tm) 5.0 AVI streams
|
|
// 128 for QuickTime(tm) MP4 streams
|
|
// replication for other
|
|
*/
|
|
int32_t wL, hL, wC, hC, i;
|
|
|
|
//if (pInfo->VisualObject.VideoObject.short_video_header)
|
|
// return;
|
|
wL = pInfo->VisualObject.VideoObject.width;
|
|
hL = pInfo->VisualObject.VideoObject.height;
|
|
wC = pInfo->VisualObject.VideoObject.width >> 1;
|
|
hC = pInfo->VisualObject.VideoObject.height >> 1;
|
|
if ((pInfo->VisualObject.VideoObject.width & 15 || pInfo->VisualObject.VideoObject.height & 15) &&
|
|
((pInfo->ftype == 1 && pInfo->ftype_f == 0) || (pInfo->ftype == 2 && pInfo->ftype_f == 1))) {
|
|
uint8_t pad = (uint8_t)(pInfo->ftype == 1 ? 128 : 0);
|
|
|
|
if (pInfo->VisualObject.VideoObject.width & 15) {
|
|
uint8_t *p;
|
|
// pad one col
|
|
p = pInfo->VisualObject.cFrame.pY + pInfo->VisualObject.VideoObject.width;
|
|
for (i = 0; i < pInfo->VisualObject.VideoObject.height; i ++) {
|
|
*p = pad;
|
|
p += pInfo->VisualObject.cFrame.stepY;
|
|
}
|
|
p = pInfo->VisualObject.cFrame.pCb + (pInfo->VisualObject.VideoObject.width >> 1);
|
|
for (i = 0; i < pInfo->VisualObject.VideoObject.height >> 1; i ++) {
|
|
*p = pad;
|
|
p += pInfo->VisualObject.cFrame.stepCb;
|
|
}
|
|
p = pInfo->VisualObject.cFrame.pCr + (pInfo->VisualObject.VideoObject.width >> 1);
|
|
for (i = 0; i < pInfo->VisualObject.VideoObject.height >> 1; i ++) {
|
|
*p = pad;
|
|
p += pInfo->VisualObject.cFrame.stepCr;
|
|
}
|
|
wL ++;
|
|
wC ++;
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.height & 15) {
|
|
// pad one row
|
|
ippsSet_8u(pad, pInfo->VisualObject.cFrame.pY + pInfo->VisualObject.cFrame.stepY * pInfo->VisualObject.VideoObject.height, pInfo->VisualObject.VideoObject.width);
|
|
ippsSet_8u(pad, pInfo->VisualObject.cFrame.pCb + pInfo->VisualObject.cFrame.stepCb * (pInfo->VisualObject.VideoObject.height >> 1), pInfo->VisualObject.VideoObject.width >> 1);
|
|
ippsSet_8u(pad, pInfo->VisualObject.cFrame.pCr + pInfo->VisualObject.cFrame.stepCr * (pInfo->VisualObject.VideoObject.height >> 1), pInfo->VisualObject.VideoObject.width >> 1);
|
|
hL ++;
|
|
hC ++;
|
|
}
|
|
}
|
|
#else
|
|
/*
|
|
// padding VOP for not complete blocks
|
|
// replication from macroblock boundary for DIVX and MP4 and from frame boundary for other
|
|
*/
|
|
int32_t wL, hL, wC, hC;
|
|
|
|
if ((pInfo->ftype == 1 && pInfo->ftype_f == 0) || (pInfo->ftype == 2 && pInfo->ftype_f == 1)) {
|
|
wL = pInfo->VisualObject.VideoObject.MacroBlockPerRow * 16;
|
|
hL = pInfo->VisualObject.VideoObject.MacroBlockPerCol * 16;
|
|
} else {
|
|
wL = pInfo->VisualObject.VideoObject.width;
|
|
hL = pInfo->VisualObject.VideoObject.height;
|
|
}
|
|
wC = wL >> 1;
|
|
hC = hL >> 1;
|
|
#endif
|
|
mp4_ExpandFrameReplicate(pInfo->VisualObject.cFrame->apY, wL, hL, 16 * MP4_NUM_EXT_MB, pInfo->VisualObject.cFrame->stepY);
|
|
mp4_ExpandFrameReplicate(pInfo->VisualObject.cFrame->apCb, wC, hC, 8 * MP4_NUM_EXT_MB, pInfo->VisualObject.cFrame->stepCb);
|
|
mp4_ExpandFrameReplicate(pInfo->VisualObject.cFrame->apCr, wC, hC, 8 * MP4_NUM_EXT_MB, pInfo->VisualObject.cFrame->stepCr);
|
|
|
|
}
|
|
|
|
mp4_Status mp4_DecodeVideoObjectPlane(mp4_Info* pInfo)
|
|
{
|
|
mp4_Status status = MP4_STATUS_OK;
|
|
Ipp64s vop_time;
|
|
|
|
// set VOP time
|
|
if (pInfo->VisualObject.VideoObject.short_video_header)
|
|
{
|
|
vop_time = pInfo->VisualObject.VideoObject.vop_sync_time + pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.temporal_reference * 1001;
|
|
if (pInfo->VisualObject.cFrame && pInfo->VisualObject.cFrame->time > vop_time)
|
|
{
|
|
pInfo->VisualObject.VideoObject.vop_sync_time += 256 * 1001;
|
|
vop_time += 256 * 1001;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coding_type == MP4_VOP_TYPE_B)
|
|
{
|
|
vop_time = pInfo->VisualObject.VideoObject.vop_sync_time_b + pInfo->VisualObject.VideoObject.VideoObjectPlane.modulo_time_base * pInfo->VisualObject.VideoObject.vop_time_increment_resolution + pInfo->VisualObject.VideoObject.VideoObjectPlane.time_increment;
|
|
}
|
|
else
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.time_code > pInfo->VisualObject.VideoObject.vop_sync_time)
|
|
pInfo->VisualObject.VideoObject.vop_sync_time = pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.time_code;
|
|
vop_time = pInfo->VisualObject.VideoObject.vop_sync_time + pInfo->VisualObject.VideoObject.VideoObjectPlane.modulo_time_base * pInfo->VisualObject.VideoObject.vop_time_increment_resolution + pInfo->VisualObject.VideoObject.VideoObjectPlane.time_increment;
|
|
if (pInfo->VisualObject.VideoObject.vop_sync_time_b < pInfo->VisualObject.VideoObject.vop_sync_time)
|
|
pInfo->VisualObject.VideoObject.vop_sync_time_b = pInfo->VisualObject.VideoObject.vop_sync_time;
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.modulo_time_base != 0) {
|
|
pInfo->VisualObject.VideoObject.vop_sync_time = vop_time - pInfo->VisualObject.VideoObject.VideoObjectPlane.time_increment;
|
|
}
|
|
}
|
|
}
|
|
// if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coded || vop_time != pInfo->VisualObject.rFrame.time) {
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coded ||
|
|
( (!pInfo->VisualObject.cFrame || vop_time != pInfo->VisualObject.cFrame->time) &&
|
|
(!pInfo->VisualObject.rFrame || vop_time != pInfo->VisualObject.rFrame->time) &&
|
|
(!pInfo->VisualObject.nFrame || vop_time != pInfo->VisualObject.nFrame->time)
|
|
))
|
|
{
|
|
switch (pInfo->VisualObject.VideoObject.VideoObjectPlane.coding_type)
|
|
{
|
|
case MP4_VOP_TYPE_I :
|
|
// set new video frame
|
|
if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_STATIC)
|
|
{
|
|
// TODO: verify
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.sFrame);
|
|
pInfo->VisualObject.sFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
}
|
|
else
|
|
{
|
|
if (pInfo->noPVOPs)
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame=0;
|
|
}
|
|
else if (pInfo->noBVOPs)
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
}
|
|
else
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.VOPindex > 0)
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.prevPlaneIsB)
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame = 0;
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.nFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.nFrame;
|
|
pInfo->VisualObject.nFrame = 0;
|
|
pInfo->VisualObject.VideoObject.prevPlaneIsB=0;
|
|
}
|
|
else
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coded)
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.shape == MP4_SHAPE_TYPE_RECTANGULAR)
|
|
{
|
|
status = mp4_DecodeVOP_I(pInfo);
|
|
} //f else
|
|
//f status = mp4_DecodeVOP_I_Shape(pInfo);
|
|
if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_STATIC && pInfo->VisualObject.VideoObject.VOPindex == 0)
|
|
{
|
|
// TODO: verify (was: mp4_SWAP(mp4_Frame, pInfo->VisualObject.sFrame, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.sFrame);
|
|
pInfo->VisualObject.sFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
mp4_ExpandFrameReplicate(pInfo->VisualObject.sFrame->apY, pInfo->VisualObject.VideoObject.sprite_width, pInfo->VisualObject.VideoObject.sprite_height, 16, pInfo->VisualObject.sFrame->stepY);
|
|
mp4_ExpandFrameReplicate(pInfo->VisualObject.sFrame->apCb, pInfo->VisualObject.VideoObject.sprite_width >> 1, pInfo->VisualObject.VideoObject.sprite_height >> 1, 8, pInfo->VisualObject.sFrame->stepCb);
|
|
mp4_ExpandFrameReplicate(pInfo->VisualObject.sFrame->apCr, pInfo->VisualObject.VideoObject.sprite_width >> 1, pInfo->VisualObject.VideoObject.sprite_height >> 1, 8, pInfo->VisualObject.sFrame->stepCr);
|
|
} else {
|
|
mp4_PadFrame(pInfo);
|
|
}
|
|
// set past and future time for B-VOP
|
|
pInfo->VisualObject.VideoObject.rTime = pInfo->VisualObject.VideoObject.nTime;
|
|
pInfo->VisualObject.VideoObject.nTime = vop_time;
|
|
#ifdef USE_NOTCODED_STATE
|
|
// Clear not_coded MB state
|
|
if ((pInfo->VisualObject.VideoObject.sprite_enable != MP4_SPRITE_STATIC) && pInfo->VisualObject.VideoObject.obmc_disable && !pInfo->VisualObject.VideoObject.ncStateCleared) {
|
|
ippsZero_8u(pInfo->VisualObject.VideoObject.ncState, pInfo->VisualObject.VideoObject.MacroBlockPerVOP);
|
|
pInfo->VisualObject.VideoObject.ncStateCleared = 1;
|
|
}
|
|
#endif
|
|
}
|
|
mp4_StatisticInc(&pInfo->VisualObject.Statistic.nVOP_I);
|
|
break;
|
|
case MP4_VOP_TYPE_P :
|
|
// set new video frame
|
|
if (pInfo->noBVOPs)
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
}
|
|
else
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.VOPindex > 0)
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.prevPlaneIsB)
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame=0;
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.nFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.nFrame;
|
|
pInfo->VisualObject.nFrame = 0;
|
|
pInfo->VisualObject.VideoObject.prevPlaneIsB = 0;
|
|
}
|
|
else
|
|
{
|
|
if (pInfo->VisualObject.cFrame)
|
|
{
|
|
int w, h;
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame=0;
|
|
|
|
pInfo->VisualObject.cFrame = CreateFrame(&pInfo->VisualObject);
|
|
w = (pInfo->VisualObject.cFrame->mbPerRow + 2 * MP4_NUM_EXT_MB) << 4;
|
|
h = (pInfo->VisualObject.cFrame->mbPerCol + 2 * MP4_NUM_EXT_MB) << 4;
|
|
memcpy(pInfo->VisualObject.cFrame->mid, pInfo->VisualObject.rFrame->mid, w * h + (w * h >> 1));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coded)
|
|
{
|
|
status = mp4_DecodeVOP_P(pInfo);
|
|
mp4_PadFrame(pInfo);
|
|
// set past and future time for B-VOP
|
|
pInfo->VisualObject.VideoObject.rTime = pInfo->VisualObject.VideoObject.nTime;
|
|
pInfo->VisualObject.VideoObject.nTime = vop_time;
|
|
}
|
|
mp4_StatisticInc(&pInfo->VisualObject.Statistic.nVOP_P);
|
|
#ifdef USE_NOTCODED_STATE
|
|
pInfo->VisualObject.VideoObject.ncStateCleared = 0;
|
|
#endif
|
|
break;
|
|
case MP4_VOP_TYPE_B :
|
|
status = MP4_STATUS_OK;
|
|
// after reset it is need to skip first B-frames
|
|
//if (pInfo->VisualObject.VideoObject.VOPindex >= 2)
|
|
//DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
|
|
if (!pInfo->VisualObject.VideoObject.prevPlaneIsB)
|
|
{
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.nFrame);
|
|
pInfo->VisualObject.nFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
pInfo->VisualObject.VideoObject.prevPlaneIsB = 1;
|
|
}
|
|
else
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame=0;
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.VOPindex < 2)
|
|
{
|
|
// if we don't have both reference frames
|
|
if (pInfo->ftype == 2)
|
|
{
|
|
//repeat last frame for AVI timing reasons
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.nFrame);
|
|
if (pInfo->VisualObject.nFrame)
|
|
pInfo->VisualObject.nFrame->outputted = 0;
|
|
}
|
|
mp4_StatisticInc(&pInfo->VisualObject.Statistic.nVOP_B);
|
|
break;
|
|
}
|
|
|
|
// set Tframe for direct interlaced mode
|
|
if (!pInfo->VisualObject.VideoObject.Tframe)
|
|
pInfo->VisualObject.VideoObject.Tframe = (int32_t)(vop_time - pInfo->VisualObject.rFrame->time);
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coded)
|
|
{
|
|
pInfo->VisualObject.VideoObject.TRB = (int32_t)(vop_time - pInfo->VisualObject.VideoObject.rTime);
|
|
pInfo->VisualObject.VideoObject.TRD = (int32_t)(pInfo->VisualObject.VideoObject.nTime - pInfo->VisualObject.VideoObject.rTime);
|
|
// defense from bad streams when B-VOPs are before Past and/or Future
|
|
if (pInfo->VisualObject.VideoObject.TRB <= 0)
|
|
pInfo->VisualObject.VideoObject.TRB = 1;
|
|
if (pInfo->VisualObject.VideoObject.TRD <= 0)
|
|
pInfo->VisualObject.VideoObject.TRD = 2;
|
|
if (pInfo->VisualObject.VideoObject.TRD <= pInfo->VisualObject.VideoObject.TRB)
|
|
{
|
|
pInfo->VisualObject.VideoObject.TRB = 1;
|
|
pInfo->VisualObject.VideoObject.TRD = 2;
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.Tframe >= pInfo->VisualObject.VideoObject.TRD)
|
|
pInfo->VisualObject.VideoObject.Tframe = pInfo->VisualObject.VideoObject.TRB;
|
|
status = mp4_DecodeVOP_B(pInfo);
|
|
}
|
|
mp4_StatisticInc(&pInfo->VisualObject.Statistic.nVOP_B);
|
|
break;
|
|
case MP4_VOP_TYPE_S :
|
|
// set new video frame
|
|
if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_GMC)
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.VOPindex > 0)
|
|
{
|
|
if (pInfo->VisualObject.VideoObject.prevPlaneIsB)
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame=0;
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.nFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.nFrame;
|
|
pInfo->VisualObject.nFrame = 0;
|
|
pInfo->VisualObject.VideoObject.prevPlaneIsB = 0;
|
|
}
|
|
else
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
pInfo->VisualObject.rFrame = pInfo->VisualObject.cFrame;
|
|
pInfo->VisualObject.cFrame = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
ReleaseFrame(&pInfo->VisualObject, pInfo->VisualObject.cFrame);
|
|
pInfo->VisualObject.cFrame=0;
|
|
}
|
|
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.coded)
|
|
{
|
|
status = mp4_DecodeVOP_S(pInfo);
|
|
if (pInfo->VisualObject.VideoObject.sprite_enable == MP4_SPRITE_GMC)
|
|
{
|
|
mp4_PadFrame(pInfo);
|
|
// set past and future time for B-VOP
|
|
pInfo->VisualObject.VideoObject.rTime = pInfo->VisualObject.VideoObject.nTime;
|
|
pInfo->VisualObject.VideoObject.nTime = vop_time;
|
|
}
|
|
#ifdef USE_NOTCODED_STATE
|
|
// Clear not_coded MB state
|
|
if ((pInfo->VisualObject.VideoObject.sprite_enable != MP4_SPRITE_STATIC) && pInfo->VisualObject.VideoObject.obmc_disable && !pInfo->VisualObject.VideoObject.ncStateCleared)
|
|
{
|
|
ippsZero_8u(pInfo->VisualObject.VideoObject.ncState, pInfo->VisualObject.VideoObject.MacroBlockPerVOP);
|
|
pInfo->VisualObject.VideoObject.ncStateCleared = 1;
|
|
}
|
|
#endif
|
|
}
|
|
mp4_StatisticInc(&pInfo->VisualObject.Statistic.nVOP_S);
|
|
break;
|
|
}
|
|
if (!pInfo->VisualObject.VideoObject.VideoObjectPlane.coded)
|
|
{
|
|
//pInfo->VisualObject.rFrame->outputted = 0;
|
|
//pInfo->VisualObject.cFrame = pInfo->VisualObject.rFrame;
|
|
//pInfo->VisualObject.rFrame=0;
|
|
//DisplayFrame(&pInfo->VisualObject, pInfo->VisualObject.rFrame);
|
|
//ippsCopy_8u(pInfo->VisualObject.rFrame->apY, pInfo->VisualObject.cFrame->apY, pInfo->VisualObject.cFrame->stepY * ((pInfo->VisualObject.VideoObject.MacroBlockPerCol + 2) << 4));
|
|
//ippsCopy_8u(pInfo->VisualObject.rFrame->apCb, pInfo->VisualObject.cFrame->apCb, pInfo->VisualObject.cFrame->stepCb * ((pInfo->VisualObject.VideoObject.MacroBlockPerCol + 2) << 3));
|
|
//ippsCopy_8u(pInfo->VisualObject.rFrame->apCr, pInfo->VisualObject.cFrame->apCr, pInfo->VisualObject.cFrame->stepCr * ((pInfo->VisualObject.VideoObject.MacroBlockPerCol + 2) << 3));
|
|
#ifdef USE_NOTCODED_STATE
|
|
ippsSet_8u(1, pInfo->VisualObject.VideoObject.ncState, pInfo->VisualObject.VideoObject.MacroBlockPerVOP);
|
|
pInfo->VisualObject.VideoObject.ncStateCleared = 0;
|
|
#endif
|
|
}
|
|
mp4_StatisticInc(&pInfo->VisualObject.Statistic.nVOP);
|
|
}
|
|
if (pInfo->VisualObject.cFrame)
|
|
{
|
|
// save current VOP type
|
|
pInfo->VisualObject.cFrame->type = pInfo->VisualObject.VideoObject.VideoObjectPlane.coding_type;
|
|
// save current VOP time
|
|
pInfo->VisualObject.cFrame->time = vop_time;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
// Intra DC and AC reconstruction for SVH macroblock
|
|
*/
|
|
mp4_Status mp4_DecodeIntraMB_SVH(mp4_Info *pInfo, int32_t pat, int32_t quant, uint8_t *pR[], int32_t stepR[])
|
|
{
|
|
__ALIGN16(int16_t, coeff, 64);
|
|
int32_t blockNum, pm = 32, lnz;
|
|
|
|
for (blockNum = 0; blockNum < 6; blockNum ++) {
|
|
if (ippiReconstructCoeffsIntra_H263_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, &lnz, pat & pm, quant, 0, IPPVC_SCAN_ZIGZAG, 0) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding coefficients of Inter block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
if (lnz > 0) {
|
|
ippiDCT8x8Inv_16s8u_C1R(coeff, pR[blockNum], stepR[blockNum]);
|
|
} else {
|
|
mp4_Set8x8_8u(pR[blockNum], stepR[blockNum], (uint8_t)((coeff[0] + 4) >> 3));
|
|
}
|
|
if (pat & pm) {
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_AC);
|
|
} else {
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_DC);
|
|
}
|
|
pm >>= 1;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
|
|
mp4_Status mp4_DecodeInterMB_SVH(mp4_Info *pInfo, int16_t *coeffMB, int32_t quant, int32_t pat)
|
|
{
|
|
int32_t i, lnz, pm = 32;
|
|
int16_t *coeff = coeffMB;
|
|
|
|
for (i = 0; i < 6; i ++) {
|
|
if ((pat) & pm) {
|
|
if (ippiReconstructCoeffsInter_H263_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, &lnz, quant, 0) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding coefficients of Inter block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
if (lnz != 0) {
|
|
if ((lnz <= 4) && (coeff[16] == 0))
|
|
ippiDCT8x8Inv_2x2_16s_C1I(coeff);
|
|
else if ((lnz <= 13) && (coeff[32] == 0))
|
|
ippiDCT8x8Inv_4x4_16s_C1I(coeff);
|
|
else
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
} else {
|
|
mp4_Set64_16s((int16_t)((coeff[0] + 4) >> 3), coeff);
|
|
}
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C);
|
|
} else {
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC);
|
|
}
|
|
pm >>= 1;
|
|
coeff += 64;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
// Intra DC and AC reconstruction for macroblock
|
|
*/
|
|
mp4_Status mp4_DecodeIntraMB(mp4_Info *pInfo, int32_t x, int32_t pat, int32_t quant, int32_t dcVLC, int32_t ac_pred_flag, uint8_t *pR[], int32_t stepR[])
|
|
{
|
|
__ALIGN16(int16_t, coeff, 64);
|
|
int32_t blockNum, lnz, predDir, scan, dc, dcA, dcB, dcC, dcP, k, nz, predQuantA, predQuantC, dcScaler, pm = 32;
|
|
int16_t *predAcA, *predAcC, sDC = 0;
|
|
mp4_IntraPredBlock *bCurr;
|
|
|
|
for (blockNum = 0; blockNum < 6; blockNum ++) {
|
|
// find prediction direction
|
|
bCurr = &pInfo->VisualObject.VideoObject.IntraPredBuff.block[6*x+blockNum];
|
|
dcA = bCurr->predA->dct_dc >= 0 ? bCurr->predA->dct_dc : 1024;
|
|
dcB = bCurr->predB->dct_dc >= 0 ? bCurr->predB->dct_dc : 1024;
|
|
dcC = bCurr->predC->dct_dc >= 0 ? bCurr->predC->dct_dc : 1024;
|
|
if (mp4_ABS(dcA - dcB) < mp4_ABS(dcB - dcC)) {
|
|
predDir = IPPVC_SCAN_HORIZONTAL;
|
|
dcP = dcC;
|
|
} else {
|
|
predDir = IPPVC_SCAN_VERTICAL;
|
|
dcP = dcA;
|
|
}
|
|
scan = IPPVC_SCAN_ZIGZAG;
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.alternate_vertical_scan_flag)
|
|
scan = IPPVC_SCAN_VERTICAL;
|
|
else if (ac_pred_flag)
|
|
scan = predDir;
|
|
// decode coeffs
|
|
if (dcVLC) {
|
|
if (ippiDecodeDCIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, (blockNum < 4) ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding DC coefficient of Intra block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
}
|
|
if (pat & pm) {
|
|
if (ippiDecodeCoeffsIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, &lnz, 0, dcVLC, scan) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding coefficients of Intra block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_AC);
|
|
} else {
|
|
if (dcVLC)
|
|
sDC = coeff[0];
|
|
mp4_Zero64_16s(coeff);
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_DC);
|
|
lnz = 0;
|
|
if (dcVLC)
|
|
coeff[0] = sDC;
|
|
}
|
|
// predict DC
|
|
dcScaler = (blockNum < 4) ? mp4_DCScalerLuma[quant] : mp4_DCScalerChroma[quant];
|
|
dc = coeff[0] + mp4_DivIntraDC(dcP, dcScaler);
|
|
mp4_CLIP(dc, -2048, 2047);
|
|
coeff[0] = (int16_t)dc;
|
|
// predict AC
|
|
nz = 0;
|
|
if (ac_pred_flag) {
|
|
if (predDir == IPPVC_SCAN_HORIZONTAL && (bCurr->predC->dct_dc >= 0)) {
|
|
predAcC = bCurr->predC->dct_acC;
|
|
predQuantC = (blockNum == 2 || blockNum == 3) ? quant : pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x+1];
|
|
if (predQuantC == quant)
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k] = (int16_t)(coeff[k] + predAcC[k]);
|
|
if (coeff[k]) {
|
|
mp4_CLIP(coeff[k], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
else
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k] = (int16_t)(coeff[k] + mp4_DivIntraAC(predAcC[k] * predQuantC, quant));
|
|
if (coeff[k]) {
|
|
mp4_CLIP(coeff[k], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
} else if (predDir == IPPVC_SCAN_VERTICAL && (bCurr->predA->dct_dc >= 0)) {
|
|
predAcA = bCurr->predA->dct_acA;
|
|
predQuantA = (blockNum == 1 || blockNum == 3) ? quant : pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x];
|
|
if (predQuantA == quant)
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k*8] = (int16_t)(coeff[k*8] + predAcA[k]);
|
|
if (coeff[k*8]) {
|
|
mp4_CLIP(coeff[k*8], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
else
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k*8] = (int16_t)(coeff[k*8] + mp4_DivIntraAC(predAcA[k] * predQuantA, quant));
|
|
if (coeff[k*8]) {
|
|
mp4_CLIP(coeff[k*8], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// copy predicted AC for future Prediction
|
|
for (k = 1; k < 8; k ++) {
|
|
bCurr[6].dct_acC[k] = coeff[k];
|
|
bCurr[6].dct_acA[k] = coeff[k*8];
|
|
}
|
|
if ((nz | lnz) || (pInfo->VisualObject.VideoObject.quant_type == 1)) {
|
|
ippiQuantInvIntra_MPEG4_16s_C1I(coeff, 63, pInfo->VisualObject.VideoObject.QuantInvIntraSpec, quant, (blockNum < 4) ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA);
|
|
ippiDCT8x8Inv_16s8u_C1R(coeff, pR[blockNum], stepR[blockNum]);
|
|
} else {
|
|
k = coeff[0] * dcScaler;
|
|
mp4_CLIP(k, -2048, 2047);
|
|
coeff[0] = (int16_t)k;
|
|
k = (k + 4) >> 3;
|
|
mp4_CLIP(k, 0, 255);
|
|
mp4_Set8x8_8u(pR[blockNum], stepR[blockNum], (uint8_t)k);
|
|
}
|
|
// copy DC for future Prediction
|
|
if (blockNum >= 3)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[blockNum].dct_dc = bCurr[6].dct_dc;
|
|
bCurr[6].dct_dc = coeff[0];
|
|
// copy quant
|
|
if (blockNum == 5)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x+1] = (uint8_t)quant;
|
|
pm >>= 1;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
// Intra DC and AC reconstruction for DP macroblock
|
|
*/
|
|
mp4_Status mp4_DecodeIntraMB_DP(mp4_Info *pInfo, int16_t dct_dc[], int32_t x, int32_t pat, int32_t quant, int32_t dcVLC, int32_t ac_pred_flag, uint8_t *pR[], int32_t stepR[])
|
|
{
|
|
__ALIGN16(int16_t, coeff, 64);
|
|
int32_t blockNum, lnz, predDir, scan, dc, dcA, dcB, dcC, dcP, k, nz, predQuantA, predQuantC, dcScaler, pm = 32;
|
|
int16_t *predAcA, *predAcC;
|
|
mp4_IntraPredBlock *bCurr;
|
|
|
|
for (blockNum = 0; blockNum < 6; blockNum ++) {
|
|
// find prediction direction
|
|
bCurr = &pInfo->VisualObject.VideoObject.IntraPredBuff.block[6*x+blockNum];
|
|
dcA = bCurr->predA->dct_dc >= 0 ? bCurr->predA->dct_dc : 1024;
|
|
dcB = bCurr->predB->dct_dc >= 0 ? bCurr->predB->dct_dc : 1024;
|
|
dcC = bCurr->predC->dct_dc >= 0 ? bCurr->predC->dct_dc : 1024;
|
|
if (mp4_ABS(dcA - dcB) < mp4_ABS(dcB - dcC)) {
|
|
predDir = IPPVC_SCAN_HORIZONTAL;
|
|
dcP = dcC;
|
|
} else {
|
|
predDir = IPPVC_SCAN_VERTICAL;
|
|
dcP = dcA;
|
|
}
|
|
scan = (ac_pred_flag) ? predDir : IPPVC_SCAN_ZIGZAG;
|
|
// decode coeffs
|
|
if (pat & pm) {
|
|
if (ippiDecodeCoeffsIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, &lnz, pInfo->VisualObject.VideoObject.reversible_vlc, dcVLC, scan) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding coefficients of Intra block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_AC);
|
|
} else {
|
|
mp4_Zero64_16s(coeff);
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_DC);
|
|
lnz = 0;
|
|
}
|
|
if (dcVLC)
|
|
coeff[0] = dct_dc[blockNum];
|
|
// predict DC
|
|
dcScaler = (blockNum < 4) ? mp4_DCScalerLuma[quant] : mp4_DCScalerChroma[quant];
|
|
dc = coeff[0] + mp4_DivIntraDC(dcP, dcScaler);
|
|
mp4_CLIP(dc, -2048, 2047);
|
|
coeff[0] = (int16_t)dc;
|
|
// predict AC
|
|
nz = 0;
|
|
if (ac_pred_flag) {
|
|
if (predDir == IPPVC_SCAN_HORIZONTAL && (bCurr->predC->dct_dc >= 0)) {
|
|
predAcC = bCurr->predC->dct_acC;
|
|
predQuantC = (blockNum == 2 || blockNum == 3) ? quant : pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x+1];
|
|
if (predQuantC == quant)
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k] = (int16_t)(coeff[k] + predAcC[k]); // clip ??
|
|
if (coeff[k]) {
|
|
mp4_CLIP(coeff[k], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
else
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k] = (int16_t)(coeff[k] + mp4_DivIntraAC(predAcC[k] * predQuantC, quant));
|
|
if (coeff[k]) {
|
|
mp4_CLIP(coeff[k], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
} else if (predDir == IPPVC_SCAN_VERTICAL && (bCurr->predA->dct_dc >= 0)) {
|
|
predAcA = bCurr->predA->dct_acA;
|
|
predQuantA = (blockNum == 1 || blockNum == 3) ? quant : pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x];
|
|
if (predQuantA == quant)
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k*8] = (int16_t)(coeff[k*8] + predAcA[k]);
|
|
if (coeff[k*8]) {
|
|
mp4_CLIP(coeff[k*8], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
else
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k*8] = (int16_t)(coeff[k*8] + mp4_DivIntraAC(predAcA[k] * predQuantA, quant));
|
|
if (coeff[k*8]) {
|
|
mp4_CLIP(coeff[k*8], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// copy predicted AC for future Prediction
|
|
for (k = 1; k < 8; k ++) {
|
|
bCurr[6].dct_acC[k] = coeff[k];
|
|
bCurr[6].dct_acA[k] = coeff[k*8];
|
|
}
|
|
if ((nz | lnz) || (pInfo->VisualObject.VideoObject.quant_type == 1)) {
|
|
ippiQuantInvIntra_MPEG4_16s_C1I(coeff, 63, pInfo->VisualObject.VideoObject.QuantInvIntraSpec, quant, (blockNum < 4) ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA);
|
|
ippiDCT8x8Inv_16s8u_C1R(coeff, pR[blockNum], stepR[blockNum]);
|
|
} else {
|
|
k = coeff[0] * dcScaler;
|
|
mp4_CLIP(k, -2048, 2047);
|
|
coeff[0] = (int16_t)k;
|
|
k = (k + 4) >> 3;
|
|
mp4_CLIP(k, 0, 255);
|
|
mp4_Set8x8_8u(pR[blockNum], stepR[blockNum], (uint8_t)k);
|
|
}
|
|
// copy DC for future Prediction
|
|
if (blockNum >= 3)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[blockNum].dct_dc = bCurr[6].dct_dc;
|
|
bCurr[6].dct_dc = coeff[0];
|
|
// copy quant
|
|
if (blockNum == 5)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x+1] = (uint8_t)quant;
|
|
pm >>= 1;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
/*
|
|
// Intra DC and AC reconstruction for macroblock (w/o iDCT)
|
|
*/
|
|
mp4_Status mp4_ReconstructCoeffsIntraMB(mp4_Info *pInfo, int32_t x, int32_t pat, int32_t quant, int32_t dcVLC, int32_t ac_pred_flag, int16_t *coeffMB, int32_t lastNZ[])
|
|
{
|
|
int32_t blockNum, lnz, predDir, scan, dc, dcA, dcB, dcC, dcP, k, nz, predQuantA, predQuantC, dcScaler, pm = 32;
|
|
int16_t *predAcA, *predAcC, sDC = 0, *coeff = coeffMB;
|
|
mp4_IntraPredBlock *bCurr;
|
|
|
|
for (blockNum = 0; blockNum < 6; blockNum ++) {
|
|
// find prediction direction
|
|
bCurr = &pInfo->VisualObject.VideoObject.IntraPredBuff.block[6*x+blockNum];
|
|
dcA = bCurr->predA->dct_dc >= 0 ? bCurr->predA->dct_dc : 1024;
|
|
dcB = bCurr->predB->dct_dc >= 0 ? bCurr->predB->dct_dc : 1024;
|
|
dcC = bCurr->predC->dct_dc >= 0 ? bCurr->predC->dct_dc : 1024;
|
|
if (mp4_ABS(dcA - dcB) < mp4_ABS(dcB - dcC)) {
|
|
predDir = IPPVC_SCAN_HORIZONTAL;
|
|
dcP = dcC;
|
|
} else {
|
|
predDir = IPPVC_SCAN_VERTICAL;
|
|
dcP = dcA;
|
|
}
|
|
scan = IPPVC_SCAN_ZIGZAG;
|
|
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.alternate_vertical_scan_flag)
|
|
scan = IPPVC_SCAN_VERTICAL;
|
|
else if (ac_pred_flag)
|
|
scan = predDir;
|
|
// decode coeffs
|
|
if (dcVLC) {
|
|
if (ippiDecodeDCIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, (blockNum < 4) ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding DC coefficient of Intra block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
}
|
|
if (pat & pm) {
|
|
if (ippiDecodeCoeffsIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, &lnz, 0, dcVLC, scan) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding coefficients of Intra block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_AC);
|
|
} else {
|
|
if (dcVLC)
|
|
sDC = coeff[0];
|
|
mp4_Zero64_16s(coeff);
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTRA_DC);
|
|
lnz = 0;
|
|
if (dcVLC)
|
|
coeff[0] = sDC;
|
|
}
|
|
// predict DC
|
|
dcScaler = (blockNum < 4) ? mp4_DCScalerLuma[quant] : mp4_DCScalerChroma[quant];
|
|
dc = coeff[0] + mp4_DivIntraDC(dcP, dcScaler);
|
|
mp4_CLIP(dc, -2048, 2047);
|
|
coeff[0] = (int16_t)dc;
|
|
// predict AC
|
|
nz = 0;
|
|
if (ac_pred_flag) {
|
|
if (predDir == IPPVC_SCAN_HORIZONTAL && (bCurr->predC->dct_dc >= 0)) {
|
|
predAcC = bCurr->predC->dct_acC;
|
|
predQuantC = (blockNum == 2 || blockNum == 3) ? quant : pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x+1];
|
|
if (predQuantC == quant)
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k] = (int16_t)(coeff[k] + predAcC[k]);
|
|
if (coeff[k]) {
|
|
mp4_CLIP(coeff[k], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
else
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k] = (int16_t)(coeff[k] + mp4_DivIntraAC(predAcC[k] * predQuantC, quant));
|
|
if (coeff[k]) {
|
|
mp4_CLIP(coeff[k], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
} else if (predDir == IPPVC_SCAN_VERTICAL && (bCurr->predA->dct_dc >= 0)) {
|
|
predAcA = bCurr->predA->dct_acA;
|
|
predQuantA = (blockNum == 1 || blockNum == 3) ? quant : pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x];
|
|
if (predQuantA == quant)
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k*8] = (int16_t)(coeff[k*8] + predAcA[k]);
|
|
if (coeff[k*8]) {
|
|
mp4_CLIP(coeff[k*8], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
else
|
|
for (k = 1; k < 8; k ++) {
|
|
coeff[k*8] = (int16_t)(coeff[k*8] + mp4_DivIntraAC(predAcA[k] * predQuantA, quant));
|
|
if (coeff[k*8]) {
|
|
mp4_CLIP(coeff[k*8], -2048, 2047);
|
|
nz = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// copy predicted AC for future Prediction
|
|
for (k = 1; k < 8; k ++) {
|
|
bCurr[6].dct_acC[k] = coeff[k];
|
|
bCurr[6].dct_acA[k] = coeff[k*8];
|
|
}
|
|
if ((nz | lnz) || (pInfo->VisualObject.VideoObject.quant_type == 1)) {
|
|
ippiQuantInvIntra_MPEG4_16s_C1I(coeff, 63, pInfo->VisualObject.VideoObject.QuantInvIntraSpec, quant, (blockNum < 4) ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA);
|
|
lnz = 63;
|
|
} else {
|
|
k = coeff[0] * dcScaler;
|
|
mp4_CLIP(k, -2048, 2047);
|
|
coeff[0] = (int16_t)k;
|
|
}
|
|
// copy DC for future Prediction
|
|
if (blockNum >= 3)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.dcB[blockNum].dct_dc = bCurr[6].dct_dc;
|
|
bCurr[6].dct_dc = coeff[0];
|
|
// copy quant
|
|
if (blockNum == 5)
|
|
pInfo->VisualObject.VideoObject.IntraPredBuff.quant[x+1] = (uint8_t)quant;
|
|
lastNZ[blockNum] = lnz;
|
|
pm >>= 1;
|
|
coeff += 64;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_DecodeInterMB(mp4_Info *pInfo, int16_t *coeffMB, int32_t quant, int32_t pat, int32_t scan)
|
|
{
|
|
int32_t i, lnz, pm = 32;
|
|
int16_t *coeff = coeffMB;
|
|
|
|
for (i = 0; i < 6; i ++) {
|
|
if ((pat) & pm) {
|
|
if (ippiReconstructCoeffsInter_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, coeff, &lnz, pInfo->VisualObject.VideoObject.reversible_vlc, scan, pInfo->VisualObject.VideoObject.QuantInvInterSpec, quant) != ippStsNoErr) {
|
|
mp4_Error("Error: decoding coefficients of Inter block");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
if (pInfo->VisualObject.VideoObject.quant_type == 0 || (coeff[63] == 0)) {
|
|
if (lnz != 0) {
|
|
if (scan == IPPVC_SCAN_ZIGZAG) {
|
|
if ((lnz <= 4) && (coeff[16] == 0))
|
|
ippiDCT8x8Inv_2x2_16s_C1I(coeff);
|
|
else if ((lnz <= 13) && (coeff[32] == 0))
|
|
ippiDCT8x8Inv_4x4_16s_C1I(coeff);
|
|
else
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
} else { // IPPVC_SCAN_VERTICAL
|
|
if ((lnz <= 5) && (coeff[16] == 0) && (coeff[24] == 0))
|
|
ippiDCT8x8Inv_2x2_16s_C1I(coeff);
|
|
else if (lnz <= 9)
|
|
ippiDCT8x8Inv_4x4_16s_C1I(coeff);
|
|
else
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
}
|
|
} else {
|
|
mp4_Set64_16s((int16_t)((coeff[0] + 4) >> 3), coeff);
|
|
}
|
|
} else {
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
}
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_C);
|
|
} else {
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC);
|
|
}
|
|
pm >>= 1;
|
|
coeff += 64;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
void mp4_DCTInvCoeffsInterMB(mp4_Info *pInfo, int16_t *coeffMB, int32_t lastNZ[], int32_t pat, int32_t scan)
|
|
{
|
|
int32_t i, lnz, pm = 32;
|
|
int16_t *coeff = coeffMB;
|
|
|
|
for (i = 0; i < 6; i ++) {
|
|
if ((pat) & pm) {
|
|
if (pInfo->VisualObject.VideoObject.quant_type == 0 || (coeff[63] == 0)) {
|
|
lnz = lastNZ[i];
|
|
if (lnz != 0) {
|
|
if (scan == IPPVC_SCAN_ZIGZAG) {
|
|
if ((lnz <= 4) && (coeff[16] == 0))
|
|
ippiDCT8x8Inv_2x2_16s_C1I(coeff);
|
|
else if ((lnz <= 13) && (coeff[32] == 0))
|
|
ippiDCT8x8Inv_4x4_16s_C1I(coeff);
|
|
else
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
} else { // IPPVC_SCAN_VERTICAL
|
|
if ((lnz <= 5) && (coeff[16] == 0) && (coeff[24] == 0))
|
|
ippiDCT8x8Inv_2x2_16s_C1I(coeff);
|
|
else if (lnz <= 9)
|
|
ippiDCT8x8Inv_4x4_16s_C1I(coeff);
|
|
else
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
}
|
|
} else {
|
|
mp4_Set64_16s((int16_t)((coeff[0] + 4) >> 3), coeff);
|
|
}
|
|
} else {
|
|
ippiDCT8x8Inv_16s_C1I(coeff);
|
|
}
|
|
}
|
|
pm >>= 1;
|
|
coeff += 64;
|
|
}
|
|
}
|
|
|
|
/*
|
|
// decode mcbpc and set MBtype and ChromaPattern
|
|
*/
|
|
mp4_Status mp4_DecodeMCBPC_P(mp4_Info* pInfo, int32_t *mbType, int32_t *mbPattern, int32_t stat)
|
|
{
|
|
uint32_t code;
|
|
int32_t type, pattern;
|
|
|
|
code = mp4_ShowBits9(pInfo, 9);
|
|
if (code >= 256) {
|
|
type = IPPVC_MBTYPE_INTER;
|
|
pattern = 0;
|
|
mp4_FlushBits(pInfo, 1);
|
|
} else {
|
|
type = mp4_PVOPmb_type[code];
|
|
pattern = mp4_PVOPmb_cbpc[code];
|
|
mp4_FlushBits(pInfo, mp4_PVOPmb_bits[code]);
|
|
}
|
|
if (code == 0) {
|
|
mp4_Error("Error: decoding MCBPC");
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
*mbType = type;
|
|
*mbPattern = pattern;
|
|
if (stat) {
|
|
if (type == IPPVC_MBTYPE_INTER)
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTER);
|
|
else if (type == IPPVC_MBTYPE_INTER_Q)
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTER_Q);
|
|
else if (type == IPPVC_MBTYPE_INTRA)
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTRA);
|
|
else if (type == IPPVC_MBTYPE_INTRA_Q)
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTRA_Q);
|
|
else if (type == IPPVC_MBTYPE_INTER4V)
|
|
mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_INTER4V);
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_PredictDecode1MV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int32_t y, int32_t x)
|
|
{
|
|
IppMotionVector *mvLeft, *mvTop, *mvRight, *mvCurr;
|
|
int32_t mbInRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
|
|
int32_t fcode = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_forward;
|
|
int32_t resync_marker_disable = pInfo->VisualObject.VideoObject.resync_marker_disable;
|
|
|
|
// block 0
|
|
mvCurr = MBcurr[0].mv;
|
|
mvLeft = MBcurr[-1].mv;
|
|
mvTop = MBcurr[-mbInRow].mv;
|
|
mvRight = MBcurr[-mbInRow+1].mv;
|
|
if (resync_marker_disable) {
|
|
if ((y | x) == 0) {
|
|
mvCurr[0].dx = mvCurr[0].dy = 0;
|
|
} else if (x == 0) {
|
|
mvCurr[0].dx = mp4_Median(0, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(0, mvTop[2].dy, mvRight[2].dy);
|
|
} else if (y == 0) {
|
|
mvCurr[0] = mvLeft[1];
|
|
} else if (x == mbInRow - 1) {
|
|
mvCurr[0].dx = mp4_Median(0, mvLeft[1].dx, mvTop[2].dx);
|
|
mvCurr[0].dy = mp4_Median(0, mvLeft[1].dy, mvTop[2].dy);
|
|
} else {
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, mvRight[2].dy);
|
|
}
|
|
} else {
|
|
int32_t validLeft, validTop, validRight;
|
|
|
|
if (x > 0)
|
|
validLeft = MBcurr[-1].validPred;
|
|
else
|
|
validLeft = 0;
|
|
if (y > 0)
|
|
validTop = MBcurr[-mbInRow].validPred;
|
|
else
|
|
validTop = 0;
|
|
if ((y > 0) && (x < mbInRow - 1))
|
|
validRight = MBcurr[-mbInRow+1].validPred;
|
|
else
|
|
validRight = 0;
|
|
switch ((validLeft << 2) | (validTop << 1) | validRight) {
|
|
case 7:
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, mvRight[2].dy);
|
|
break;
|
|
case 6:
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, 0);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, 0);
|
|
break;
|
|
case 5:
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, 0, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, 0, mvRight[2].dy);
|
|
break;
|
|
case 4:
|
|
mvCurr[0] = mvLeft[1];
|
|
break;
|
|
case 3:
|
|
mvCurr[0].dx = mp4_Median(0, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(0, mvTop[2].dy, mvRight[2].dy);
|
|
break;
|
|
case 2:
|
|
mvCurr[0] = mvTop[2];
|
|
break;
|
|
case 1:
|
|
mvCurr[0] = mvRight[2];
|
|
break;
|
|
default:
|
|
mvCurr[0].dx = mvCurr[0].dy = 0;
|
|
break;
|
|
}
|
|
}
|
|
return mp4_DecodeMV(pInfo, mvCurr, fcode);
|
|
}
|
|
|
|
mp4_Status mp4_PredictDecode4MV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int32_t y, int32_t x)
|
|
{
|
|
IppMotionVector *mvLeft, *mvTop, *mvRight, *mvCurr;
|
|
int32_t mbInRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
|
|
int32_t fcode = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_forward;
|
|
int32_t resync_marker_disable = pInfo->VisualObject.VideoObject.resync_marker_disable;
|
|
|
|
mvCurr = MBcurr[0].mv;
|
|
mvLeft = MBcurr[-1].mv;
|
|
mvTop = MBcurr[-mbInRow].mv;
|
|
mvRight = MBcurr[-mbInRow+1].mv;
|
|
if (resync_marker_disable) {
|
|
// block 0
|
|
if ((y | x) == 0) {
|
|
mvCurr[0].dx = mvCurr[0].dy = 0;
|
|
} else if (x == 0) {
|
|
mvCurr[0].dx = mp4_Median(0, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(0, mvTop[2].dy, mvRight[2].dy);
|
|
} else if (y == 0) {
|
|
mvCurr[0] = mvLeft[1];
|
|
} else if (x == mbInRow - 1) {
|
|
mvCurr[0].dx = mp4_Median(0, mvLeft[1].dx, mvTop[2].dx);
|
|
mvCurr[0].dy = mp4_Median(0, mvLeft[1].dy, mvTop[2].dy);
|
|
} else {
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, mvRight[2].dy);
|
|
}
|
|
if (mp4_DecodeMV(pInfo, mvCurr, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// block 1
|
|
if (y == 0) {
|
|
mvCurr[1] = mvCurr[0];
|
|
} else if (x == mbInRow - 1) {
|
|
mvCurr[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, 0);
|
|
mvCurr[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, 0);
|
|
} else {
|
|
mvCurr[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, mvRight[2].dx);
|
|
mvCurr[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, mvRight[2].dy);
|
|
}
|
|
if (mp4_DecodeMV(pInfo, mvCurr+1, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// block 2
|
|
if (x == 0) {
|
|
mvCurr[2].dx = mp4_Median(0, mvCurr[0].dx, mvCurr[1].dx);
|
|
mvCurr[2].dy = mp4_Median(0, mvCurr[0].dy, mvCurr[1].dy);
|
|
} else {
|
|
mvCurr[2].dx = mp4_Median(mvLeft[3].dx, mvCurr[0].dx, mvCurr[1].dx);
|
|
mvCurr[2].dy = mp4_Median(mvLeft[3].dy, mvCurr[0].dy, mvCurr[1].dy);
|
|
}
|
|
if (mp4_DecodeMV(pInfo, mvCurr+2, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// block 3
|
|
mvCurr[3].dx = mp4_Median(mvCurr[2].dx, mvCurr[0].dx, mvCurr[1].dx);
|
|
mvCurr[3].dy = mp4_Median(mvCurr[2].dy, mvCurr[0].dy, mvCurr[1].dy);
|
|
if (mp4_DecodeMV(pInfo, mvCurr+3, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
} else {
|
|
int32_t validLeft, validTop, validRight;
|
|
|
|
if (x > 0)
|
|
validLeft = MBcurr[-1].validPred;
|
|
else
|
|
validLeft = 0;
|
|
if (y > 0)
|
|
validTop = MBcurr[-mbInRow].validPred;
|
|
else
|
|
validTop = 0;
|
|
if ((y > 0) && (x < mbInRow - 1))
|
|
validRight = MBcurr[-mbInRow+1].validPred;
|
|
else
|
|
validRight = 0;
|
|
// block 0
|
|
switch ((validLeft << 2) | (validTop << 1) | validRight) {
|
|
case 7:
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, mvRight[2].dy);
|
|
break;
|
|
case 6:
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, 0);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, 0);
|
|
break;
|
|
case 5:
|
|
mvCurr[0].dx = mp4_Median(mvLeft[1].dx, 0, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(mvLeft[1].dy, 0, mvRight[2].dy);
|
|
break;
|
|
case 4:
|
|
mvCurr[0] = mvLeft[1];
|
|
break;
|
|
case 3:
|
|
mvCurr[0].dx = mp4_Median(0, mvTop[2].dx, mvRight[2].dx);
|
|
mvCurr[0].dy = mp4_Median(0, mvTop[2].dy, mvRight[2].dy);
|
|
break;
|
|
case 2:
|
|
mvCurr[0] = mvTop[2];
|
|
break;
|
|
case 1:
|
|
mvCurr[0] = mvRight[2];
|
|
break;
|
|
default:
|
|
mvCurr[0].dx = mvCurr[0].dy = 0;
|
|
break;
|
|
}
|
|
if (mp4_DecodeMV(pInfo, mvCurr, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// block 1
|
|
switch ((validTop << 1) | validRight) {
|
|
case 3:
|
|
mvCurr[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, mvRight[2].dx);
|
|
mvCurr[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, mvRight[2].dy);
|
|
break;
|
|
case 2:
|
|
mvCurr[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, 0);
|
|
mvCurr[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, 0);
|
|
break;
|
|
case 1:
|
|
mvCurr[1].dx = mp4_Median(mvCurr[0].dx, 0, mvRight[2].dx);
|
|
mvCurr[1].dy = mp4_Median(mvCurr[0].dy, 0, mvRight[2].dy);
|
|
break;
|
|
default:
|
|
mvCurr[1] = mvCurr[0];
|
|
break;
|
|
}
|
|
if (mp4_DecodeMV(pInfo, mvCurr+1, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// block 2
|
|
if (validLeft) {
|
|
mvCurr[2].dx = mp4_Median(mvLeft[3].dx, mvCurr[0].dx, mvCurr[1].dx);
|
|
mvCurr[2].dy = mp4_Median(mvLeft[3].dy, mvCurr[0].dy, mvCurr[1].dy);
|
|
} else {
|
|
mvCurr[2].dx = mp4_Median(0, mvCurr[0].dx, mvCurr[1].dx);
|
|
mvCurr[2].dy = mp4_Median(0, mvCurr[0].dy, mvCurr[1].dy);
|
|
}
|
|
if (mp4_DecodeMV(pInfo, mvCurr+2, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// block 3
|
|
mvCurr[3].dx = mp4_Median(mvCurr[2].dx, mvCurr[0].dx, mvCurr[1].dx);
|
|
mvCurr[3].dy = mp4_Median(mvCurr[2].dy, mvCurr[0].dy, mvCurr[1].dy);
|
|
if (mp4_DecodeMV(pInfo, mvCurr+3, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
}
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
mp4_Status mp4_PredictDecodeFMV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int32_t y, int32_t x, IppMotionVector *mvT, IppMotionVector *mvB)
|
|
{
|
|
IppMotionVector mvLeft = {0, 0}, mvTop = {0, 0}, mvRight = {0, 0}, mvPred;
|
|
int32_t mbInRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow;
|
|
int32_t fcode = pInfo->VisualObject.VideoObject.VideoObjectPlane.fcode_forward;
|
|
int32_t resync_marker_disable = pInfo->VisualObject.VideoObject.resync_marker_disable;
|
|
|
|
if (x > 0) {
|
|
mvLeft = MBcurr[-1].mv[1];
|
|
mvLeft.dy = (int16_t)mp4_Div2(mvLeft.dy);
|
|
}
|
|
if (y > 0) {
|
|
mvTop = MBcurr[-mbInRow].mv[2];
|
|
mvTop.dy = (int16_t)mp4_Div2(mvTop.dy);
|
|
if (x < (mbInRow - 1)) {
|
|
mvRight = MBcurr[-mbInRow+1].mv[2];
|
|
mvRight.dy = (int16_t)mp4_Div2(mvRight.dy);
|
|
}
|
|
}
|
|
if (resync_marker_disable) {
|
|
if ((y | x) == 0) {
|
|
mvPred.dx = mvPred.dy = 0;
|
|
} else if (x == 0) {
|
|
mvPred.dx = mp4_Median(0, mvTop.dx, mvRight.dx);
|
|
mvPred.dy = mp4_Median(0, mvTop.dy, mvRight.dy);
|
|
} else if (y == 0) {
|
|
mvPred = mvLeft;
|
|
} else if (x == mbInRow - 1) {
|
|
mvPred.dx = mp4_Median(0, mvLeft.dx, mvTop.dx);
|
|
mvPred.dy = mp4_Median(0, mvLeft.dy, mvTop.dy);
|
|
} else {
|
|
mvPred.dx = mp4_Median(mvLeft.dx, mvTop.dx, mvRight.dx);
|
|
mvPred.dy = mp4_Median(mvLeft.dy, mvTop.dy, mvRight.dy);
|
|
}
|
|
} else {
|
|
int32_t validLeft, validTop, validRight;
|
|
|
|
if (x > 0)
|
|
validLeft = MBcurr[-1].validPred;
|
|
else
|
|
validLeft = 0;
|
|
if (y > 0)
|
|
validTop = MBcurr[-mbInRow].validPred;
|
|
else
|
|
validTop = 0;
|
|
if ((y > 0) && (x < mbInRow - 1))
|
|
validRight = MBcurr[-mbInRow+1].validPred;
|
|
else
|
|
validRight = 0;
|
|
switch ((validLeft << 2) | (validTop << 1) | validRight) {
|
|
case 7:
|
|
mvPred.dx = mp4_Median(mvLeft.dx, mvTop.dx, mvRight.dx);
|
|
mvPred.dy = mp4_Median(mvLeft.dy, mvTop.dy, mvRight.dy);
|
|
break;
|
|
case 6:
|
|
mvPred.dx = mp4_Median(mvLeft.dx, mvTop.dx, 0);
|
|
mvPred.dy = mp4_Median(mvLeft.dy, mvTop.dy, 0);
|
|
break;
|
|
case 5:
|
|
mvPred.dx = mp4_Median(mvLeft.dx, 0, mvRight.dx);
|
|
mvPred.dy = mp4_Median(mvLeft.dy, 0, mvRight.dy);
|
|
break;
|
|
case 4:
|
|
mvPred = mvLeft;
|
|
break;
|
|
case 3:
|
|
mvPred.dx = mp4_Median(0, mvTop.dx, mvRight.dx);
|
|
mvPred.dy = mp4_Median(0, mvTop.dy, mvRight.dy);
|
|
break;
|
|
case 2:
|
|
mvPred = mvTop;
|
|
break;
|
|
case 1:
|
|
mvPred = mvRight;
|
|
break;
|
|
default:
|
|
mvPred.dx = mvPred.dy = 0;
|
|
break;
|
|
}
|
|
}
|
|
*mvT = mvPred;
|
|
if (mp4_DecodeMV(pInfo, mvT, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
*mvB = mvPred;
|
|
if (mp4_DecodeMV(pInfo, mvB, fcode) != MP4_STATUS_OK)
|
|
return MP4_STATUS_ERROR;
|
|
// update MV buffer for future prediction
|
|
MBcurr->mv[0].dx = MBcurr->mv[1].dx = MBcurr->mv[2].dx = MBcurr->mv[3].dx = (int16_t)mp4_Div2Round(mvT->dx + mvB->dx);
|
|
MBcurr->mv[0].dy = MBcurr->mv[1].dy = MBcurr->mv[2].dy = MBcurr->mv[3].dy = (int16_t)(mvT->dy + mvB->dy);
|
|
return MP4_STATUS_OK;
|
|
}
|
|
|
|
void mp4_OBMC(mp4_Info *pInfo, mp4_MacroBlock *pMBinfo, IppMotionVector *mvCur, int32_t colNum, int32_t rowNum, IppiRect limitRectL, uint8_t *pYc, int32_t stepYc, uint8_t *pYr, int32_t stepYr, int32_t cbpy, int16_t *coeffMB, int32_t dct_type)
|
|
{
|
|
IppMotionVector mvOBMCL, mvOBMCU, mvOBMCR, mvOBMCB, *mvLeft, *mvUpper, *mvRight;
|
|
int32_t mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow, dx, dy, rt;
|
|
|
|
// get Right MV
|
|
if (colNum == mbPerRow - 1)
|
|
mvRight = &mvCur[1];
|
|
else if (pMBinfo[1].type >= IPPVC_MBTYPE_INTRA)
|
|
mvRight = &mvCur[1];
|
|
else
|
|
mvRight = pMBinfo[1].mv;
|
|
// get Left MV
|
|
if (colNum == 0)
|
|
mvLeft = mvCur - 1;
|
|
else if (pMBinfo[-1].type >= IPPVC_MBTYPE_INTRA)
|
|
mvLeft = mvCur - 1;
|
|
else
|
|
mvLeft = pMBinfo[-1].mv;
|
|
// get Upper MV
|
|
if (rowNum == 0)
|
|
mvUpper = mvCur - 2;
|
|
else if (pMBinfo[-mbPerRow].type >= IPPVC_MBTYPE_INTRA)
|
|
mvUpper = mvCur - 2;
|
|
else
|
|
mvUpper = pMBinfo[-mbPerRow].mv;
|
|
dx = colNum * 16;
|
|
dy = rowNum * 16;
|
|
rt = pInfo->VisualObject.VideoObject.VideoObjectPlane.rounding_type;
|
|
if (pInfo->VisualObject.VideoObject.quarter_sample) {
|
|
mp4_LimitMVQ(&mvLeft[1], &mvOBMCL, &limitRectL, dx, dy, 8);
|
|
mp4_LimitMVQ(&mvUpper[2], &mvOBMCU, &limitRectL, dx, dy, 8);
|
|
mp4_LimitMVQ(&mvCur[1], &mvOBMCR, &limitRectL, dx, dy, 8);
|
|
mp4_LimitMVQ(&mvCur[2], &mvOBMCB, &limitRectL, dx, dy, 8);
|
|
ippiOBMC8x8QP_MPEG4_8u_C1R(pYr, stepYr, pYc, stepYc, &mvCur[0], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvOBMCB, rt);
|
|
mp4_LimitMVQ(&mvCur[0], &mvOBMCL, &limitRectL, dx+8, dy, 8);
|
|
mp4_LimitMVQ(&mvUpper[3], &mvOBMCU, &limitRectL, dx+8, dy, 8);
|
|
mp4_LimitMVQ(&mvRight[0], &mvOBMCR, &limitRectL, dx+8, dy, 8);
|
|
mp4_LimitMVQ(&mvCur[3], &mvOBMCB, &limitRectL, dx+8, dy, 8);
|
|
ippiOBMC8x8QP_MPEG4_8u_C1R(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvOBMCB, rt);
|
|
mp4_LimitMVQ(&mvLeft[3], &mvOBMCL, &limitRectL, dx, dy+8, 8);
|
|
mp4_LimitMVQ(&mvCur[0], &mvOBMCU, &limitRectL, dx, dy+8, 8);
|
|
mp4_LimitMVQ(&mvCur[3], &mvOBMCR, &limitRectL, dx, dy+8, 8);
|
|
ippiOBMC8x8QP_MPEG4_8u_C1R(pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, &mvCur[2], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvCur[2], rt);
|
|
mp4_LimitMVQ(&mvCur[2], &mvOBMCL, &limitRectL, dx+8, dy+8, 8);
|
|
mp4_LimitMVQ(&mvCur[1], &mvOBMCU, &limitRectL, dx+8, dy+8, 8);
|
|
mp4_LimitMVQ(&mvRight[2], &mvOBMCR, &limitRectL, dx+8, dy+8, 8);
|
|
ippiOBMC8x8QP_MPEG4_8u_C1R(pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, &mvCur[3], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvCur[3], rt);
|
|
} else {
|
|
mp4_LimitMV(&mvLeft[1], &mvOBMCL, &limitRectL, dx, dy, 8);
|
|
mp4_LimitMV(&mvUpper[2], &mvOBMCU, &limitRectL, dx, dy, 8);
|
|
mp4_LimitMV(&mvCur[1], &mvOBMCR, &limitRectL, dx, dy, 8);
|
|
mp4_LimitMV(&mvCur[2], &mvOBMCB, &limitRectL, dx, dy, 8);
|
|
ippiOBMC8x8HP_MPEG4_8u_C1R(pYr, stepYr, pYc, stepYc, &mvCur[0], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvOBMCB, rt);
|
|
mp4_LimitMV(&mvCur[0], &mvOBMCL, &limitRectL, dx+8, dy, 8);
|
|
mp4_LimitMV(&mvUpper[3], &mvOBMCU, &limitRectL, dx+8, dy, 8);
|
|
mp4_LimitMV(&mvRight[0], &mvOBMCR, &limitRectL, dx+8, dy, 8);
|
|
mp4_LimitMV(&mvCur[3], &mvOBMCB, &limitRectL, dx+8, dy, 8);
|
|
ippiOBMC8x8HP_MPEG4_8u_C1R(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvOBMCB, rt);
|
|
mp4_LimitMV(&mvLeft[3], &mvOBMCL, &limitRectL, dx, dy+8, 8);
|
|
mp4_LimitMV(&mvCur[0], &mvOBMCU, &limitRectL, dx, dy+8, 8);
|
|
mp4_LimitMV(&mvCur[3], &mvOBMCR, &limitRectL, dx, dy+8, 8);
|
|
ippiOBMC8x8HP_MPEG4_8u_C1R(pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, &mvCur[2], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvCur[2], rt);
|
|
mp4_LimitMV(&mvCur[2], &mvOBMCL, &limitRectL, dx+8, dy+8, 8);
|
|
mp4_LimitMV(&mvCur[1], &mvOBMCU, &limitRectL, dx+8, dy+8, 8);
|
|
mp4_LimitMV(&mvRight[2], &mvOBMCR, &limitRectL, dx+8, dy+8, 8);
|
|
ippiOBMC8x8HP_MPEG4_8u_C1R(pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, &mvCur[3], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvCur[3], rt);
|
|
}
|
|
if (!dct_type) {
|
|
mp4_AddResidual(cbpy & 8, pYc, stepYc, coeffMB);
|
|
mp4_AddResidual(cbpy & 4, pYc+8, stepYc, coeffMB+64);
|
|
mp4_AddResidual(cbpy & 2, pYc+stepYc*8, stepYc, coeffMB+128);
|
|
mp4_AddResidual(cbpy & 1, pYc+stepYc*8+8, stepYc, coeffMB+192);
|
|
} else {
|
|
mp4_AddResidual(cbpy & 8, pYc, stepYc*2, coeffMB);
|
|
mp4_AddResidual(cbpy & 4, pYc+8, stepYc*2, coeffMB+64);
|
|
mp4_AddResidual(cbpy & 2, pYc+stepYc, stepYc*2, coeffMB+128);
|
|
mp4_AddResidual(cbpy & 1, pYc+stepYc+8, stepYc*2, coeffMB+192);
|
|
}
|
|
}
|
|
|
|
|
|
void mp4_CopyMacroBlocks(const mp4_Frame *rFrame, mp4_Frame *cFrame, int32_t mbPerRow, int32_t rowNum, int32_t colNum, int32_t n)
|
|
{
|
|
int32_t i, stepYr, stepYc, stepCbr, stepCbc, stepCrr, stepCrc;
|
|
uint8_t *pYc, *pCbc, *pCrc, *pYr, *pCbr, *pCrr;
|
|
|
|
if (n <= 0)
|
|
return;
|
|
stepYc = cFrame->stepY;
|
|
stepCbc = cFrame->stepCb;
|
|
stepCrc = cFrame->stepCr;
|
|
stepYr = rFrame->stepY;
|
|
stepCbr = rFrame->stepCb;
|
|
stepCrr = rFrame->stepCr;
|
|
pYc = cFrame->pY + (rowNum * stepYc + colNum) * 16;
|
|
pCbc = cFrame->pCb + (rowNum * stepCbc + colNum) * 8;
|
|
pCrc = cFrame->pCr + (rowNum * stepCrc + colNum) * 8;
|
|
pYr = rFrame->pY + (rowNum * stepYr + colNum) * 16;
|
|
pCbr = rFrame->pCb + (rowNum * stepCbr + colNum) * 8;
|
|
pCrr = rFrame->pCr + (rowNum * stepCrr + colNum) * 8;
|
|
for (i = rowNum * mbPerRow + colNum; i < rowNum * mbPerRow + colNum + n; i ++) {
|
|
ippiCopy16x16_8u_C1R(pYr, stepYr, pYc, stepYc);
|
|
ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc);
|
|
ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc);
|
|
if ((i + 1) % mbPerRow == 0) {
|
|
pYc += (2 * MP4_NUM_EXT_MB + 1) * 16 + (stepYc << 4) - stepYc;
|
|
pCbc += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCbc << 3) - stepCbc;
|
|
pCrc += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCrc << 3) - stepCrc;
|
|
pYr += (2 * MP4_NUM_EXT_MB + 1) * 16 + (stepYr << 4) - stepYr;
|
|
pCbr += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCbr << 3) - stepCbr;
|
|
pCrr += (2 * MP4_NUM_EXT_MB + 1) * 8 + (stepCrr << 3) - stepCrr;
|
|
} else {
|
|
pYc += 16; pCrc += 8; pCbc += 8;
|
|
pYr += 16; pCrr += 8; pCbr += 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// added by benski
|
|
mp4_Frame *CreateFrame(mp4_VisualObject *object)
|
|
{
|
|
if (object->frame_cache)
|
|
{
|
|
mp4_Frame *ret = object->frame_cache;
|
|
object->frame_cache = ret->next;
|
|
ret->next = 0;
|
|
ret->reference_count = 1;
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
mp4_Frame *ret = (mp4_Frame *)calloc(1, sizeof(mp4_Frame));
|
|
ret->reference_count = 1;
|
|
ret->sprite = 0;
|
|
ret->mbPerRow = (object->VideoObject.width + 15) >> 4;
|
|
ret->mbPerCol = (object->VideoObject.height + 15) >> 4;
|
|
AllocateInitFrame(ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
mp4_Frame *CreateSpriteFrame(mp4_VisualObject *object)
|
|
{
|
|
if (object->sprite_cache)
|
|
{
|
|
mp4_Frame *ret = object->sprite_cache;
|
|
object->sprite_cache = ret->next;
|
|
ret->next = 0;
|
|
ret->reference_count = 1;
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
mp4_Frame *ret = (mp4_Frame *)calloc(1, sizeof(mp4_Frame));
|
|
ret->reference_count = 1;
|
|
ret->sprite = 1;
|
|
ret->mbPerRow = (object->VideoObject.sprite_width + 15) >> 4;
|
|
ret->mbPerCol = (object->VideoObject.sprite_height + 15) >> 4;
|
|
AllocateInitFrame(ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* to delete
|
|
free(decoder->dec.VisualObject.cFrame.mid);
|
|
decoder->dec.VisualObject.cFrame.mid = 0;
|
|
*/
|
|
void ReleaseFrame(mp4_VisualObject *object, mp4_Frame *frame)
|
|
{
|
|
if (frame && --frame->reference_count == 0)
|
|
{
|
|
if (frame->outputted == 0)
|
|
{
|
|
// DebugBreak();
|
|
}
|
|
frame->outputted = 0;
|
|
if (frame->sprite)
|
|
{
|
|
frame->next = object->sprite_cache;
|
|
object->sprite_cache = frame;
|
|
}
|
|
else
|
|
{
|
|
frame->next = object->frame_cache;
|
|
object->frame_cache = frame;
|
|
}
|
|
}
|
|
}
|
|
|
|
mp4_Frame *GetDisplayFrame(mp4_VisualObject *object)
|
|
{
|
|
mp4_Frame *ret = object->display_frames;
|
|
if (ret)
|
|
{
|
|
object->display_frames = ret->next;
|
|
ret->next = 0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void DisplayFrame(mp4_VisualObject *object, mp4_Frame *frame)
|
|
{
|
|
if (frame)
|
|
{
|
|
mp4_Frame *tail = object->display_frames;
|
|
if (frame->outputted)
|
|
{
|
|
DebugBreak();
|
|
}
|
|
frame->outputted = 1;
|
|
frame->reference_count++;
|
|
if (tail)
|
|
{
|
|
while (tail->next)
|
|
{
|
|
tail = tail->next;
|
|
}
|
|
tail->next = frame;
|
|
frame->next = 0;
|
|
}
|
|
else
|
|
{
|
|
object->display_frames = frame;
|
|
frame->next = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void FreeCache(mp4_VisualObject *object)
|
|
{
|
|
while (object->display_frames)
|
|
{
|
|
mp4_Frame *frame = object->display_frames;
|
|
object->display_frames = frame->next;
|
|
free(frame->mid);
|
|
free(frame);
|
|
}
|
|
|
|
while (object->frame_cache)
|
|
{
|
|
mp4_Frame *frame = object->frame_cache;
|
|
object->frame_cache = frame->next;
|
|
free(frame->mid);
|
|
free(frame);
|
|
}
|
|
|
|
while (object->sprite_cache)
|
|
{
|
|
mp4_Frame *frame = object->frame_cache;
|
|
object->frame_cache = frame->next;
|
|
free(frame->mid);
|
|
free(frame);
|
|
}
|
|
}
|