diff options
Diffstat (limited to 'Src/mpeg4dec/mp4decvopp.c')
| -rw-r--r-- | Src/mpeg4dec/mp4decvopp.c | 1079 |
1 files changed, 1079 insertions, 0 deletions
diff --git a/Src/mpeg4dec/mp4decvopp.c b/Src/mpeg4dec/mp4decvopp.c new file mode 100644 index 00000000..10ec2c1d --- /dev/null +++ b/Src/mpeg4dec/mp4decvopp.c @@ -0,0 +1,1079 @@ +/* /////////////////////////////////////////////////////////////////////// +// +// 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 P-VOPs +// +*/ + +#include "mp4def.h" +#include "mp4dec.h" + +/* +// used for short_viseo_header +*/ +/*static*/ mp4_Status mp4_PredictDecodeMV(mp4_Info *pInfo, mp4_MacroBlock *MBcurr, int32_t frGOB, int32_t y, int32_t x) +{ + IppMotionVector *mvLeft, *mvTop, *mvRight, *mvCurr; + int32_t mbInRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow; + + mvCurr = MBcurr[0].mv; + mvLeft = MBcurr[-1].mv; + mvTop = MBcurr[-mbInRow].mv; + mvRight = MBcurr[-mbInRow+1].mv; + if (y == frGOB && x == 0) { + mvCurr->dx = mvCurr->dy = 0; + } else if (x == 0) { + mvCurr->dx = mp4_Median(0, mvTop[0].dx, mvRight[0].dx); + mvCurr->dy = mp4_Median(0, mvTop[0].dy, mvRight[0].dy); + } else if (y == frGOB) { + MBcurr->mv[0] = mvLeft[0]; + } else if (x == mbInRow - 1) { + mvCurr->dx = mp4_Median(0, mvLeft[0].dx, mvTop[0].dx); + mvCurr->dy = mp4_Median(0, mvLeft[0].dy, mvTop[0].dy); + } else { + mvCurr->dx = mp4_Median(mvLeft[0].dx, mvTop[0].dx, mvRight[0].dx); + mvCurr->dy = mp4_Median(mvLeft[0].dy, mvTop[0].dy, mvRight[0].dy); + } + return mp4_DecodeMV(pInfo, mvCurr, 1); +} + +/* +// decode MPEG-4 PVOP +*/ +mp4_Status mp4_DecodeVOP_P(mp4_Info* pInfo) +{ + __ALIGN16(int16_t, coeffMB, 64*6); + int32_t stepYr, stepYc, stepCbr, stepCbc, stepCrr, stepCrc, stepFc[6]; + int32_t i, j, nmb, nmbgob, dx, dy, mbCurr, mbInVideoPacket, colNum, rowNum, mbPerRow, mbPerCol; + uint8_t *pYr, *pCbr, *pCrr; + uint8_t *pYc, *pCbc, *pCrc, *pFc[6]; + int32_t mb_not_coded, mb_type, cbpc, cbpy, ac_pred_flag, cbpyPrev; + int32_t dcVLC, quant, quantPred, rvlc, scan, obmc_disable, rt, quarter_sample; + IppiRect limitRectL, limitRectC; + IppMotionVector mvCur[4], mvPrev[4], mvTmp[4], mvCbCr; + mp4_MacroBlock *pMBinfo; + mp4_Status sts; +#ifdef USE_NOTCODED_STATE + uint8_t *ncState = pInfo->VisualObject.VideoObject.ncState; +#endif + if (!pInfo->VisualObject.cFrame) + pInfo->VisualObject.cFrame = CreateFrame(&pInfo->VisualObject); + mbPerRow = pInfo->VisualObject.VideoObject.MacroBlockPerRow; + mbPerCol = pInfo->VisualObject.VideoObject.MacroBlockPerCol; + + stepYc = pInfo->VisualObject.cFrame->stepY; + stepYr = pInfo->VisualObject.rFrame->stepY; + stepCbc = pInfo->VisualObject.cFrame->stepCb; + stepCbr = pInfo->VisualObject.rFrame->stepCb; + stepCrc = pInfo->VisualObject.cFrame->stepCr; + stepCrr = pInfo->VisualObject.rFrame->stepCr; + pYc = pInfo->VisualObject.cFrame->pY; + pCbc = pInfo->VisualObject.cFrame->pCb; + pCrc = pInfo->VisualObject.cFrame->pCr; + pYr = pInfo->VisualObject.rFrame->pY; + pCbr = pInfo->VisualObject.rFrame->pCb; + pCrr = pInfo->VisualObject.rFrame->pCr; + stepFc[0] = stepFc[1] = stepFc[2] = stepFc[3] = stepYc; stepFc[4] = stepCbc; stepFc[5] = stepCrc; + // Bounding rectangle for MV limitation + limitRectL.x = - 16 * MP4_NUM_EXT_MB; + limitRectL.y = - 16 * MP4_NUM_EXT_MB; + limitRectL.width = pInfo->VisualObject.VideoObject.width + 16 * 2 * MP4_NUM_EXT_MB; + limitRectL.height = pInfo->VisualObject.VideoObject.height + 16 * 2 * MP4_NUM_EXT_MB; + pMBinfo = pInfo->VisualObject.VideoObject.MBinfo; + // warning "variable may be used without having been initialized" + cbpc = cbpy = mb_type = 0; + nmb = pInfo->VisualObject.VideoObject.MacroBlockPerVOP; + mbCurr = colNum = rowNum = 0; + sts = MP4_STATUS_OK; + // decode short_video_header P-VOP + if (pInfo->VisualObject.VideoObject.short_video_header) + { + int32_t frGOB; + IppMotionVector mvCur; + + quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.vop_quant; + nmbgob = 0; + pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number = 0; + frGOB = 0; + for (;;) + { + do + { + mb_not_coded = mp4_GetBit(pInfo); + if (mb_not_coded) + break; + if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK) + goto Err_1; + } while (mb_type == IPPVC_MB_STUFFING); + if (mb_not_coded) + { +#ifdef USE_NOTCODED_STATE + if (!(*ncState)) + { + *ncState = 1; +#endif + ippiCopy16x16_8u_C1R(pYr, stepYr, pYc, stepYc); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); +#ifdef USE_NOTCODED_STATE + } +#endif + pMBinfo->mv[0].dx = pMBinfo->mv[0].dy = 0; + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED); + } + else + { +#ifdef USE_NOTCODED_STATE + // clear not_coded MB state + *ncState = 0; +#endif + if (mb_type == IPPVC_MBTYPE_INTER4V || mb_type == IPPVC_MBTYPE_INTER4V_Q) + { + mp4_Error("Error: 4MV shall not be used for short_video_header"); + goto Err_1; + } + if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK) + goto Err_1; + if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q) + mp4_UpdateQuant(pInfo, quant); + if (mb_type >= IPPVC_MBTYPE_INTRA) + { + pFc[0] = pYc; pFc[1] = pYc + 8; pFc[2] = pYc + 8 * stepYc; pFc[3] = pYc + 8 * stepYc + 8; pFc[4] = pCbc; pFc[5] = pCrc; + if (mp4_DecodeIntraMB_SVH(pInfo, (cbpy << 2) + cbpc, quant, pFc, stepFc) != MP4_STATUS_OK) + goto Err_1; + pMBinfo->mv[0].dx = pMBinfo->mv[0].dy = 0; + } + else + { + if (mp4_PredictDecodeMV(pInfo, pMBinfo, frGOB, rowNum, colNum) != MP4_STATUS_OK) + goto Err_1; + mp4_LimitMV(&pMBinfo->mv[0], &mvCur, &limitRectL, colNum * 16, rowNum * 16, 16); + mp4_ComputeChromaMV(&mvCur, &mvCbCr); + + // decode and MC blocks + if (cbpy) + { + mp4_DecodeMCInterBlock_SVH(pInfo, quant, cbpy & 8, pYr, pYc, stepYr, coeffMB, &mvCur, Err_1); + mp4_DecodeMCInterBlock_SVH(pInfo, quant, cbpy & 4, pYr+8, pYc+8, stepYr, coeffMB, &mvCur, Err_1); + mp4_DecodeMCInterBlock_SVH(pInfo, quant, cbpy & 2, pYr+stepYr*8, pYc+stepYc*8, stepYr, coeffMB, &mvCur, Err_1); + mp4_DecodeMCInterBlock_SVH(pInfo, quant, cbpy & 1, pYr+8+stepYr*8, pYc+8+stepYc*8, stepYr, coeffMB, &mvCur, Err_1); + } + else + { + mp4_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur, 0); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + } + mp4_DecodeMCInterBlock_SVH(pInfo, quant, cbpc & 2, pCbr, pCbc, stepCbr, coeffMB, &mvCbCr, Err_1); + mp4_DecodeMCInterBlock_SVH(pInfo, quant, cbpc & 1, pCrr, pCrc, stepCrr, coeffMB, &mvCbCr, Err_1); + } + } + pMBinfo ++; +#ifdef USE_NOTCODED_STATE + ncState ++; +#endif + colNum ++; + if (colNum == mbPerRow) + { + colNum = 0; + rowNum ++; + if (rowNum == mbPerCol) + break; + 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; + } + nmbgob ++; + if (nmbgob == pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_macroblocks_in_gob && pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number < (pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_gobs_in_vop - 1)) + { +ErrRet_1: + if (mp4_CheckDecodeGOB_SVH(pInfo) != MP4_STATUS_OK) + goto Err_1; + if (!pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_header_empty) + { + quant = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.quant_scale; + i = pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number * pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_rows_in_gob; + frGOB = i; + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, (i - rowNum) * mbPerRow - colNum); + rowNum = i; + colNum = 0; + pYc = pInfo->VisualObject.cFrame->pY + i * stepYc * 16; pCbc = pInfo->VisualObject.cFrame->pCb + i * stepCbc * 8; pCrc = pInfo->VisualObject.cFrame->pCr + i * stepCrc * 8; + pYr = pInfo->VisualObject.rFrame->pY + i * stepYr * 16; pCbr = pInfo->VisualObject.rFrame->pCb + i * stepCbr * 8; pCrr = pInfo->VisualObject.rFrame->pCr + i * stepCrr * 8; + pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + i * mbPerRow; +#ifdef USE_NOTCODED_STATE + ncState = pInfo->VisualObject.VideoObject.ncState + i * mbPerRow; +#endif + } + nmbgob = 0; + } + } + mp4_AlignBits(pInfo); + return sts; +Err_1: + sts = MP4_STATUS_ERROR; + if (pInfo->stopOnErr) + return sts; + if (!mp4_SeekGOBMarker(pInfo)) + { + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, pInfo->VisualObject.VideoObject.MacroBlockPerVOP - rowNum * mbPerRow - colNum); + return sts; + } + goto ErrRet_1; + } + rt = pInfo->VisualObject.VideoObject.VideoObjectPlane.rounding_type; + quarter_sample = pInfo->VisualObject.VideoObject.quarter_sample; + obmc_disable = pInfo->VisualObject.VideoObject.obmc_disable; + rvlc = pInfo->VisualObject.VideoObject.reversible_vlc; + scan = pInfo->VisualObject.VideoObject.VideoObjectPlane.alternate_vertical_scan_flag ? IPPVC_SCAN_VERTICAL : IPPVC_SCAN_ZIGZAG; + // Bounding rectangles for MV limitation + limitRectC.x = -8 * MP4_NUM_EXT_MB; + limitRectC.y = -8 * MP4_NUM_EXT_MB; + limitRectC.width = (pInfo->VisualObject.VideoObject.width >> 1) + 8 * 2 * MP4_NUM_EXT_MB; + limitRectC.height = (pInfo->VisualObject.VideoObject.height >> 1) + 8 * 2 * MP4_NUM_EXT_MB; + quant = quantPred = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant; + // warning "variable may be used without having been initialized" + ac_pred_flag = cbpyPrev = 0; + mvCbCr.dx = mvCbCr.dy = 0; + //ippsZero_8u((uint8_t*)pInfo->VisualObject.VideoObject.MBinfo, nmb * sizeof(mp4_MacroBlock)); + // decode data_partitioned P-VOP + if (pInfo->VisualObject.VideoObject.data_partitioned) { + for (;;) { + mp4_DataPartMacroBlock *pMBdp; + int32_t x, y; + + x = colNum; + y = rowNum; + // reset Intra prediction buffer on new Video_packet + mp4_ResetIntraPredBuffer(pInfo); + pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr]; + pMBinfo = &pInfo->VisualObject.VideoObject.MBinfo[mbCurr]; + mbInVideoPacket = 0; + // decode not_coded/mb_type/cbpc/MV part + for (;;) { + mb_not_coded = mp4_GetBit(pInfo); + if (mb_not_coded) { + mb_type = IPPVC_MBTYPE_INTER; + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED); + } else { + if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK) + goto Err_2; + } + if (mb_type != IPPVC_MB_STUFFING) { + if (mbInVideoPacket == nmb - mbCurr) { + mp4_Error("DC Marker missed"); + goto Err_2; + } + pMBinfo->validPred = 1; + if (!mb_not_coded && (mb_type <= IPPVC_MBTYPE_INTER4V)) { + if (mb_type != IPPVC_MBTYPE_INTER4V) { + if (mp4_PredictDecode1MV(pInfo, pMBinfo, y, x) != MP4_STATUS_OK) + goto Err_2; + pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0]; + } else { + if (mp4_PredictDecode4MV(pInfo, pMBinfo, y, x) != MP4_STATUS_OK) + goto Err_2; + } + } else { + mp4_Zero4MV(pMBinfo->mv); + } + pMBinfo->not_coded = (uint8_t)mb_not_coded; + pMBinfo->type = (uint8_t)mb_type; + pMBinfo ++; + pMBdp->pat = (uint8_t)cbpc; + pMBdp ++; + mbInVideoPacket ++; + x ++; + if (x == mbPerRow) { + x = 0; + y ++; + } + } + if (mp4_ShowBits(pInfo, 17) == MP4_MV_MARKER) { + mp4_GetBits(pInfo, 17); + break; + } + } + pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr]; + pMBinfo = &pInfo->VisualObject.VideoObject.MBinfo[mbCurr]; + // decode ac_pred_flag/cbpy/dquant/IntraDC part + for (i = 0; i < mbInVideoPacket; i ++) { + if (!pMBinfo->not_coded) { + mb_type = pMBinfo->type; + if (mb_type >= IPPVC_MBTYPE_INTRA) + pMBdp->ac_pred_flag = (uint8_t)mp4_GetBit(pInfo); + if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK) + goto Err_2; + pMBdp->pat = (uint8_t)((cbpy << 2) + pMBdp->pat); + quantPred = quant; + if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q) + mp4_UpdateQuant(pInfo, quant); + pMBdp->quant = (uint8_t)quant; + if (i == 0) + quantPred = quant; + // decode DC coefficient of Intra blocks + dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0; + if ((mb_type >= IPPVC_MBTYPE_INTRA) && dcVLC) { + for (j = 0; j < 6; j ++) { + if (ippiDecodeDCIntra_MPEG4_1u16s(&pInfo->bufptr, &pInfo->bitoff, &pMBdp->dct_dc[j], j < 4 ? IPPVC_BLOCK_LUMA : IPPVC_BLOCK_CHROMA) != ippStsNoErr) + goto Err_2; + } + } + } + pMBdp ++; + pMBinfo ++; + } + if (mbCurr + mbInVideoPacket < nmb) + pMBinfo->type = IPPVC_MBTYPE_INTRA; // for OBMC set first MB of the next videopacket as invalid for right MV + pMBdp = &pInfo->VisualObject.VideoObject.DataPartBuff[mbCurr]; + pMBinfo = &pInfo->VisualObject.VideoObject.MBinfo[mbCurr]; + // decode coeffs and reconstruct macroblocks + for (i = 0; i < mbInVideoPacket; i ++) { + if (colNum == 0) { + // reset B-prediction blocks on new row + mp4_ResetIntraPredBblock(pInfo); + } + quant = pMBdp->quant; + mb_type = pMBinfo->type; + if (mb_type >= IPPVC_MBTYPE_INTRA) { + quantPred = (i == 0) ? quant : pMBdp[-1].quant; + dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0; + pFc[0] = pYc; pFc[1] = pYc + 8; pFc[2] = pYc + 8 * stepYc; pFc[3] = pYc + 8 * stepYc + 8; pFc[4] = pCbc; pFc[5] = pCrc; + if (mp4_DecodeIntraMB_DP(pInfo, pMBdp->dct_dc, colNum, pMBdp->pat, quant, dcVLC, pMBdp->ac_pred_flag, pFc, stepFc) != MP4_STATUS_OK) + goto Err_2; + } else { + mp4_UpdateIntraPredBuffInvalid(pInfo, colNum); + mb_not_coded = pMBinfo->not_coded; + if (!mb_not_coded) { + dx = colNum * 16; + dy = rowNum * 16; + cbpy = pMBdp->pat >> 2; + cbpc = pMBdp->pat & 3; + if (mb_type == IPPVC_MBTYPE_INTER4V) { + if (quarter_sample) { + mp4_Limit4MVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8); + mp4_ComputeChroma4MVQ(pMBinfo->mv, &mvCbCr); + } else { + mp4_Limit4MV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8); + mp4_ComputeChroma4MV(pMBinfo->mv, &mvCbCr); + } + mp4_LimitMV(&mvCbCr, &mvCbCr, &limitRectC, dx >> 1, dy >> 1, 8); + } else { + if (quarter_sample) { + mp4_LimitMVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16); + mp4_ComputeChromaMVQ(mvCur, &mvCbCr); + } else { + mp4_LimitMV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16); + mp4_ComputeChromaMV(mvCur, &mvCbCr); + } + mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0]; + } + } + if (obmc_disable) { + if (mb_not_coded) { + ippiCopy16x16_8u_C1R(pYr, stepYr, pYc, stepYc); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); + } else { + if (quarter_sample) { + if (mb_type == IPPVC_MBTYPE_INTER4V) { + mp4_Copy8x8QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_Copy8x8QP_8u(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], rt); + mp4_Copy8x8QP_8u(pYr+8*stepYr, stepYr, pYc+8*stepYc, stepYc, &mvCur[2], rt); + mp4_Copy8x8QP_8u(pYr+8*stepYr+8, stepYr, pYc+8*stepYc+8, stepYc, &mvCur[3], rt); + } else + mp4_Copy16x16QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 8, pYc, stepYc, Err_2); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 4, pYc+8, stepYc, Err_2); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 2, pYc+8*stepYc, stepYc, Err_2); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 1, pYc+8*stepYc+8, stepYc, Err_2); + } else { + if (cbpy || mb_type == IPPVC_MBTYPE_INTER4V) { + mp4_DecodeMCBlockInter_MPEG4(cbpy & 8, pYr, stepYr, pYc, stepYc, mvCur[0], rt, Err_2); + mp4_DecodeMCBlockInter_MPEG4(cbpy & 4, pYr+8, stepYr, pYc+8, stepYc, mvCur[1], rt, Err_2); + mp4_DecodeMCBlockInter_MPEG4(cbpy & 2, pYr+8*stepYr, stepYr, pYc+8*stepYc, stepYc, mvCur[2], rt, Err_2); + mp4_DecodeMCBlockInter_MPEG4(cbpy & 1, pYr+8*stepYr+8, stepYr, pYc+8*stepYc+8, stepYc, mvCur[3], rt, Err_2); + } else { + mp4_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + } + } + mp4_DecodeMCBlockInter_MPEG4(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, mvCbCr, rt, Err_2); + mp4_DecodeMCBlockInter_MPEG4(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, mvCbCr, rt, Err_2); + } + } else { + if (mb_not_coded) { + cbpy = 0; + mp4_Zero4MV(mvCur); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); + } else { + if (mp4_DecodeInterMB(pInfo, coeffMB, quant, (cbpy << 2) + cbpc, scan) != MP4_STATUS_OK) + goto Err_2; + mp4_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt); + mp4_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt); + } + mp4_OBMC(pInfo, pMBinfo, mvCur, colNum, rowNum, limitRectL, pYc, stepYc, pYr, stepYr, cbpy, coeffMB, 0); + } + } + pMBinfo ++; + pMBdp ++; + colNum ++; + if (colNum == mbPerRow) { + colNum = 0; + rowNum ++; + if (rowNum == mbPerCol) + return sts; + 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; + } + } + //mbCurr += mbInVideoPacket; + if (!pInfo->VisualObject.VideoObject.resync_marker_disable) + { + int32_t found; +ErrRet_2: + if (mp4_CheckDecodeVideoPacket(pInfo, &found) == MP4_STATUS_OK) + { + if (found) + { + quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant_scale; + mbInVideoPacket = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num - mbCurr; + mbCurr = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num; + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, mbCurr - rowNum * mbPerRow - colNum); + rowNum = mbCurr / mbPerRow; + colNum = mbCurr % mbPerRow; + pYc = pInfo->VisualObject.cFrame->pY + (rowNum * stepYc + colNum) * 16; pCbc = pInfo->VisualObject.cFrame->pCb + (rowNum * stepCbc + colNum) * 8; pCrc = pInfo->VisualObject.cFrame->pCr + (rowNum * stepCrc + colNum) * 8; + pYr = pInfo->VisualObject.rFrame->pY + (rowNum * stepYr + colNum) * 16; pCbr = pInfo->VisualObject.rFrame->pCb + (rowNum * stepCbr + colNum) * 8; pCrr = pInfo->VisualObject.rFrame->pCr + (rowNum * stepCrr + colNum) * 8; + pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + mbCurr; + } + else + goto Err_2; + } + else + goto Err_2; + } + // mark MBs the previous videopacket as invalid for prediction + for (i = 1; i <= IPP_MIN(mbInVideoPacket, mbPerRow + 1); i ++) + pMBinfo[-i].validPred = 0; + } +Err_2: + sts = MP4_STATUS_ERROR; + if (pInfo->stopOnErr) + return sts; + if (pInfo->VisualObject.VideoObject.resync_marker_disable || !mp4_SeekResyncMarker(pInfo)) + { + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, pInfo->VisualObject.VideoObject.MacroBlockPerVOP - rowNum * mbPerRow - colNum); + return sts; + } + goto ErrRet_2; + } + // decode interlaced P-VOP + if (pInfo->VisualObject.VideoObject.interlaced) + { + int32_t stepY, pYoff23, field_prediction, dct_type, dct_typePrev, mb_ftfr, mb_fbfr; + IppMotionVector mvCbCrT, mvCbCrB, *mvField = pInfo->VisualObject.VideoObject.FieldMV; + + // warning "variable may be used without having been initialized" + dct_type = dct_typePrev = mb_ftfr = mb_fbfr = 0; + mvCbCrT.dx = mvCbCrT.dy = mvCbCrB.dx = mvCbCrB.dy = 0; + for (;;) { + // reset Intra prediction buffer on new Video_packet + mp4_ResetIntraPredBuffer(pInfo); + mbInVideoPacket = 0; + // decode blocks + for (;;) + { + if (colNum == 0) + { + // reset B-prediction blocks on new row + mp4_ResetIntraPredBblock(pInfo); + } + mb_not_coded = mp4_GetBit(pInfo); + mb_type = IPPVC_MBTYPE_INTER; + if (!mb_not_coded) + { + if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK) + goto Err_3; + } + if (mb_type != IPPVC_MB_STUFFING) + { + if (!mb_not_coded) + { + if (mb_type >= IPPVC_MBTYPE_INTRA) + ac_pred_flag = mp4_GetBit(pInfo); + if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK) + goto Err_3; + quantPred = quant; + if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q) + mp4_UpdateQuant(pInfo, quant); + dct_type = 0; + field_prediction = 0; + if (mb_type >= IPPVC_MBTYPE_INTRA || (cbpy + cbpc) != 0) + dct_type = mp4_GetBit(pInfo); + if (mb_type == IPPVC_MBTYPE_INTER || mb_type == IPPVC_MBTYPE_INTER_Q) { + field_prediction = mp4_GetBit(pInfo); + if (field_prediction) { + mb_ftfr = mp4_GetBit(pInfo); + mb_fbfr = mp4_GetBit(pInfo); + } + } + } + else + { + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED); + mp4_Zero4MV(pMBinfo->mv); + field_prediction = 0; + } + pMBinfo->validPred = 1; + pMBinfo->not_coded = (uint8_t)mb_not_coded; + pMBinfo->type = (uint8_t)mb_type; + pMBinfo->field_info = (uint8_t)(field_prediction + (mb_ftfr << 1) + (mb_fbfr << 2)); + if (mb_type >= IPPVC_MBTYPE_INTRA) + { + if (mbInVideoPacket == 0) + quantPred = quant; + dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0; + if (dct_type) + { + stepY = stepYc * 2; + pYoff23 = stepYc; + } + else + { + stepY = stepYc; + pYoff23 = 8 * stepYc; + } + stepFc[0] = stepFc[1] = stepFc[2] = stepFc[3] = stepY; + pFc[0] = pYc; pFc[1] = pYc + 8; pFc[2] = pYc + pYoff23; pFc[3] = pYc + pYoff23 + 8; pFc[4] = pCbc; pFc[5] = pCrc; + if (mp4_DecodeIntraMB(pInfo, colNum, (cbpy << 2) + cbpc, quant, dcVLC, ac_pred_flag, pFc, stepFc) != MP4_STATUS_OK) + goto Err_3; + mp4_Zero4MV(pMBinfo->mv); +#ifdef USE_NOTCODED_STATE + // clear not_coded MB state + *ncState = 0; +#endif + } + else + { + mp4_UpdateIntraPredBuffInvalid(pInfo, colNum); + if (!mb_not_coded) + { + dx = colNum * 16; + dy = rowNum * 16; + if (!field_prediction) + { + if (mb_type != IPPVC_MBTYPE_INTER4V) + { + if (mp4_PredictDecode1MV(pInfo, pMBinfo, rowNum, colNum) != MP4_STATUS_OK) + goto Err_3; + pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0]; + if (quarter_sample) + { + mp4_LimitMVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16); + mp4_ComputeChromaMVQ(mvCur, &mvCbCr); + } + else + { + mp4_LimitMV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16); + mp4_ComputeChromaMV(mvCur, &mvCbCr); + } + mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0]; + } + else + { + if (mp4_PredictDecode4MV(pInfo, pMBinfo, rowNum, colNum) != MP4_STATUS_OK) + goto Err_3; + if (quarter_sample) + { + mp4_Limit4MVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8); + mp4_ComputeChroma4MVQ(pMBinfo->mv, &mvCbCr); + } + else + { + mp4_Limit4MV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8); + mp4_ComputeChroma4MV(pMBinfo->mv, &mvCbCr); + } + mp4_LimitMV(&mvCbCr, &mvCbCr, &limitRectC, dx >> 1, dy >> 1, 8); + } + } + else + { + IppMotionVector mvFT, mvFB; + if (mp4_PredictDecodeFMV(pInfo, pMBinfo, rowNum, colNum, &mvFT, &mvFB) != MP4_STATUS_OK) + goto Err_3; + mvField[0] = mvFT; mvField[1] = mvFB; + if (quarter_sample) + { + mp4_LimitFMVQ(&mvFT, &mvCur[0], &limitRectL, dx, dy, 16); + mp4_LimitFMVQ(&mvFB, &mvCur[2], &limitRectL, dx, dy, 16); + mvTmp[0].dx = (int16_t)mp4_Div2(mvCur[0].dx); + mvTmp[0].dy = (int16_t)(mp4_Div2(mvCur[0].dy << 1) >> 1); + mvTmp[2].dx = (int16_t)mp4_Div2(mvCur[2].dx); + mvTmp[2].dy = (int16_t)(mp4_Div2(mvCur[2].dy << 1) >> 1); + mp4_ComputeChromaMV(&mvTmp[0], &mvCbCrT); + mp4_ComputeChromaMV(&mvTmp[2], &mvCbCrB); + } + else + { + mp4_LimitFMV(&mvFT, &mvCur[0], &limitRectL, dx, dy, 16); + mp4_LimitFMV(&mvFB, &mvCur[2], &limitRectL, dx, dy, 16); + mp4_ComputeChromaMV(&mvCur[0], &mvCbCrT); + mp4_ComputeChromaMV(&mvCur[2], &mvCbCrB); + } + } + } + } + if (!obmc_disable) + { + // OBMC for previous MB + if (colNum > 0) + if (pMBinfo[-1].type < IPPVC_MBTYPE_INTRA && !(pMBinfo[-1].field_info & 1)) + mp4_OBMC(pInfo, pMBinfo - 1, mvPrev, colNum - 1, rowNum, limitRectL, pYc - 16, stepYc, pYr - 16, stepYr, cbpyPrev, coeffMB, dct_typePrev); + if (mb_type < IPPVC_MBTYPE_INTRA && !field_prediction) + { + if (mb_not_coded) + { + cbpyPrev = 0; + mp4_Zero4MV(mvPrev); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); + } + else + { + cbpyPrev = cbpy; + dct_typePrev = dct_type; + mvPrev[0] = mvCur[0]; mvPrev[1] = mvCur[1]; mvPrev[2] = mvCur[2]; mvPrev[3] = mvCur[3]; + if (mp4_DecodeInterMB(pInfo, coeffMB, quant, (cbpy << 2) + cbpc, scan) != MP4_STATUS_OK) + goto Err_3; + mp4_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt); + mp4_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt); + } + // OBMC current MB if it is the last in the row + if (colNum == mbPerRow - 1) + mp4_OBMC(pInfo, pMBinfo, mvPrev, colNum, rowNum, limitRectL, pYc, stepYc, pYr, stepYr, cbpyPrev, coeffMB, dct_typePrev); + } + } + if (mb_type < IPPVC_MBTYPE_INTRA && (obmc_disable || field_prediction)) + { + if (mb_not_coded) + { +#ifdef USE_NOTCODED_STATE + if (!(*ncState)) + { + *ncState = 1; +#endif + ippiCopy16x16_8u_C1R(pYr, stepYr, pYc, stepYc); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); +#ifdef USE_NOTCODED_STATE + } +#endif + } + else + { +#ifdef USE_NOTCODED_STATE + // clear not_coded MB state + *ncState = 0; +#endif + if (mp4_DecodeInterMB(pInfo, coeffMB, quant, (cbpy << 2) + cbpc, scan) != MP4_STATUS_OK) + goto Err_3; + if (quarter_sample) + { + if (!field_prediction) + { + if (mb_type == IPPVC_MBTYPE_INTER4V) + { + mp4_Copy8x8QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_Copy8x8QP_8u(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], rt); + mp4_Copy8x8QP_8u(pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, &mvCur[2], rt); + mp4_Copy8x8QP_8u(pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, &mvCur[3], rt); + } + else + mp4_Copy16x16QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + } + else + { + mp4_Copy16x8QP_8u(pYr+stepYr*mb_ftfr, stepYr*2, pYc, stepYc*2, &mvCur[0], rt); + mp4_Copy16x8QP_8u(pYr+stepYr*mb_fbfr, stepYr*2, pYc+stepYc, stepYc*2, &mvCur[2], rt); + } + } + else + { + if (!field_prediction) + { + if (mb_type == IPPVC_MBTYPE_INTER4V) + { + mp4_Copy8x8HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_Copy8x8HP_8u(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], rt); + mp4_Copy8x8HP_8u(pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, &mvCur[2], rt); + mp4_Copy8x8HP_8u(pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, &mvCur[3], rt); + } + else + { + mp4_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + } + } + else + { + mp4_Copy16x8HP_8u(pYr+stepYr*mb_ftfr, stepYr*2, pYc, stepYc*2, &mvCur[0], rt); + mp4_Copy16x8HP_8u(pYr+stepYr*mb_fbfr, stepYr*2, pYc+stepYc, stepYc*2, &mvCur[2], 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); + } + if (!field_prediction) { + mp4_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt); + mp4_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt); + } else { + mp4_Copy8x4HP_8u(pCbr+(mb_ftfr ? stepCbr : 0), stepCbr*2, pCbc, stepCbc*2, &mvCbCrT, rt); + mp4_Copy8x4HP_8u(pCrr+(mb_ftfr ? stepCrr : 0), stepCrr*2, pCrc, stepCrc*2, &mvCbCrT, rt); + mp4_Copy8x4HP_8u(pCbr+(mb_fbfr ? stepCbr : 0), stepCbr*2, pCbc+stepCbc, stepCbc*2, &mvCbCrB, rt); + mp4_Copy8x4HP_8u(pCrr+(mb_fbfr ? stepCrr : 0), stepCrr*2, pCrc+stepCrc, stepCrc*2, &mvCbCrB, rt); + mp4_AddResidual(cbpc & 2, pCbc, stepCbc, coeffMB+256); + mp4_AddResidual(cbpc & 1, pCrc, stepCrc, coeffMB+320); + } + } + } +#ifdef USE_NOTCODED_STATE + ncState ++; +#endif + pMBinfo ++; + mvField += 2; + mbInVideoPacket ++; + colNum ++; + if (colNum == mbPerRow) { + colNum = 0; + rowNum ++; + if (rowNum == mbPerCol) { + // skip stuffing + while (mp4_ShowBits(pInfo, 10) == 1) + mp4_FlushBits(pInfo, 10); + return sts; + } + 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; + } + } + if (!pInfo->VisualObject.VideoObject.resync_marker_disable) { + int32_t found; +ErrRet_3: + if (mp4_CheckDecodeVideoPacket(pInfo, &found) == MP4_STATUS_OK) { + if (found) { + mbInVideoPacket = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num - mbCurr; + quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant_scale; + mbCurr = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num; + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, mbCurr - rowNum * mbPerRow - colNum); + rowNum = mbCurr / mbPerRow; + colNum = mbCurr % mbPerRow; + pYc = pInfo->VisualObject.cFrame->pY + (rowNum * stepYc + colNum) * 16; pCbc = pInfo->VisualObject.cFrame->pCb + (rowNum * stepCbc + colNum) * 8; pCrc = pInfo->VisualObject.cFrame->pCr + (rowNum * stepCrc + colNum) * 8; + pYr = pInfo->VisualObject.rFrame->pY + (rowNum * stepYr + colNum) * 16; pCbr = pInfo->VisualObject.rFrame->pCb + (rowNum * stepCbr + colNum) * 8; pCrr = pInfo->VisualObject.rFrame->pCr + (rowNum * stepCrr + colNum) * 8; + pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + mbCurr; +#ifdef USE_NOTCODED_STATE + ncState = pInfo->VisualObject.VideoObject.ncState + mbCurr; +#endif + mvField = pInfo->VisualObject.VideoObject.FieldMV + 2 * mbCurr; + break; + } + } else + goto Err_3; + } + } + // mark MBs the previous videopacket as invalid for prediction + for (i = 1; i <= IPP_MIN(mbInVideoPacket, mbPerRow + 1); i ++) { + pMBinfo[-i].validPred = 0; + } + } +Err_3: + sts = MP4_STATUS_ERROR; + if (pInfo->stopOnErr) + return sts; + if (pInfo->VisualObject.VideoObject.resync_marker_disable || !mp4_SeekResyncMarker(pInfo)) + { + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, pInfo->VisualObject.VideoObject.MacroBlockPerVOP - rowNum * mbPerRow - colNum); + return sts; + } + goto ErrRet_3; + } + // decode usual P-VOP + { + for (;;) + { + // reset Intra prediction buffer on new Video_packet + mp4_ResetIntraPredBuffer(pInfo); + mbInVideoPacket = 0; + // decode blocks + for (;;) + { + if (colNum == 0) + { + // reset B-prediction blocks on new row + mp4_ResetIntraPredBblock(pInfo); + } + mb_not_coded = mp4_GetBit(pInfo); + mb_type = IPPVC_MBTYPE_INTER; + if (!mb_not_coded) + if (mp4_DecodeMCBPC_P(pInfo, &mb_type, &cbpc, 1) != MP4_STATUS_OK) + goto Err_4; + if (mb_type != IPPVC_MB_STUFFING) + { + if (!mb_not_coded) + { + if (mb_type >= IPPVC_MBTYPE_INTRA) + ac_pred_flag = mp4_GetBit(pInfo); + if (mp4_DecodeCBPY_P(pInfo, &cbpy, mb_type) != MP4_STATUS_OK) + goto Err_4; + quantPred = quant; + if (mb_type == IPPVC_MBTYPE_INTER_Q || mb_type == IPPVC_MBTYPE_INTRA_Q) + mp4_UpdateQuant(pInfo, quant); + } + else + { + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nMB_NOTCODED); + mp4_Zero4MV(pMBinfo->mv); + } + pMBinfo->validPred = 1; + pMBinfo->not_coded = (uint8_t)mb_not_coded; + pMBinfo->type = (uint8_t)mb_type; + if (mb_type >= IPPVC_MBTYPE_INTRA) { + if (mbInVideoPacket == 0) + quantPred = quant; + dcVLC = (quantPred < mp4_DC_vlc_Threshold[pInfo->VisualObject.VideoObject.VideoObjectPlane.intra_dc_vlc_thr]) ? 1 : 0; + pFc[0] = pYc; pFc[1] = pYc + 8; pFc[2] = pYc + 8 * stepYc; pFc[3] = pYc + 8 * stepYc + 8; pFc[4] = pCbc; pFc[5] = pCrc; + if (mp4_DecodeIntraMB(pInfo, colNum, (cbpy << 2) + cbpc, quant, dcVLC, ac_pred_flag, pFc, stepFc) != MP4_STATUS_OK) + goto Err_4; + mp4_Zero4MV(pMBinfo->mv); +#ifdef USE_NOTCODED_STATE + // clear not_coded MB state + *ncState = 0; +#endif + } else { + mp4_UpdateIntraPredBuffInvalid(pInfo, colNum); + if (!mb_not_coded) { + dx = colNum * 16; + dy = rowNum * 16; + if (mb_type != IPPVC_MBTYPE_INTER4V) { + if (mp4_PredictDecode1MV(pInfo, pMBinfo, rowNum, colNum) != MP4_STATUS_OK) + goto Err_4; + pMBinfo->mv[1] = pMBinfo->mv[2] = pMBinfo->mv[3] = pMBinfo->mv[0]; + if (quarter_sample) { + mp4_LimitMVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16); + mp4_ComputeChromaMVQ(mvCur, &mvCbCr); + } else { + mp4_LimitMV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 16); + mp4_ComputeChromaMV(mvCur, &mvCbCr); + } + mvCur[1] = mvCur[2] = mvCur[3] = mvCur[0]; + } else { + if (mp4_PredictDecode4MV(pInfo, pMBinfo, rowNum, colNum) != MP4_STATUS_OK) + goto Err_4; + if (quarter_sample) { + mp4_Limit4MVQ(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8); + mp4_ComputeChroma4MVQ(pMBinfo->mv, &mvCbCr); + } else { + mp4_Limit4MV(pMBinfo->mv, mvCur, &limitRectL, dx, dy, 8); + mp4_ComputeChroma4MV(pMBinfo->mv, &mvCbCr); + } + mp4_LimitMV(&mvCbCr, &mvCbCr, &limitRectC, dx >> 1, dy >> 1, 8); + } + } + if (obmc_disable) { + if (mb_not_coded) { +#ifdef USE_NOTCODED_STATE + if (!(*ncState)) { + *ncState = 1; +#endif + ippiCopy16x16_8u_C1R(pYr, stepYr, pYc, stepYc); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); +#ifdef USE_NOTCODED_STATE + } +#endif + } else { +#ifdef USE_NOTCODED_STATE + // clear not_coded MB state + *ncState = 0; +#endif + if (quarter_sample) { + if (mb_type == IPPVC_MBTYPE_INTER4V) { + mp4_Copy8x8QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_Copy8x8QP_8u(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], rt); + mp4_Copy8x8QP_8u(pYr+8*stepYr, stepYr, pYc+8*stepYc, stepYc, &mvCur[2], rt); + mp4_Copy8x8QP_8u(pYr+8*stepYr+8, stepYr, pYc+8*stepYc+8, stepYc, &mvCur[3], rt); + } else + mp4_Copy16x16QP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 8, pYc, stepYc, Err_4); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 4, pYc+8, stepYc, Err_4); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 2, pYc+8*stepYc, stepYc, Err_4); + mp4_DecodeReconBlockInter_MPEG4(cbpy & 1, pYc+8*stepYc+8, stepYc, Err_4); + } else { + if (cbpy || mb_type == IPPVC_MBTYPE_INTER4V) { + mp4_DecodeMCBlockInter_MPEG4(cbpy & 8, pYr, stepYr, pYc, stepYc, mvCur[0], rt, Err_4); + mp4_DecodeMCBlockInter_MPEG4(cbpy & 4, pYr+8, stepYr, pYc+8, stepYc, mvCur[1], rt, Err_4); + mp4_DecodeMCBlockInter_MPEG4(cbpy & 2, pYr+8*stepYr, stepYr, pYc+8*stepYc, stepYc, mvCur[2], rt, Err_4); + mp4_DecodeMCBlockInter_MPEG4(cbpy & 1, pYr+8*stepYr+8, stepYr, pYc+8*stepYc+8, stepYc, mvCur[3], rt, Err_4); + } else { + mp4_Copy16x16HP_8u(pYr, stepYr, pYc, stepYc, &mvCur[0], rt); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + mp4_StatisticInc_(&pInfo->VisualObject.Statistic.nB_INTER_NC); + //if (cbpy) { + // mp4_DecodeReconBlockInter_MPEG4(cbpy & 8, pYc, stepYc); + // mp4_DecodeReconBlockInter_MPEG4(cbpy & 4, pYc+8, stepYc); + // mp4_DecodeReconBlockInter_MPEG4(cbpy & 2, pYc+8*stepYc, stepYc); + // mp4_DecodeReconBlockInter_MPEG4(cbpy & 1, pYc+8*stepYc+8, stepYc); + //} + } + } + mp4_DecodeMCBlockInter_MPEG4(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, mvCbCr, rt, Err_4); + mp4_DecodeMCBlockInter_MPEG4(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, mvCbCr, rt, Err_4); + } + } + } + if (!obmc_disable) { + // OBMC for previous MB + if (colNum > 0) + if (pMBinfo[-1].type < IPPVC_MBTYPE_INTRA) + mp4_OBMC(pInfo, pMBinfo - 1, mvPrev, colNum - 1, rowNum, limitRectL, pYc - 16, stepYc, pYr - 16, stepYr, cbpyPrev, coeffMB, 0); + if (mb_type < IPPVC_MBTYPE_INTRA) { + if (mb_not_coded) + { + cbpyPrev = 0; + mp4_Zero4MV(mvPrev); + ippiCopy8x8_8u_C1R(pCbr, stepCbr, pCbc, stepCbc); + ippiCopy8x8_8u_C1R(pCrr, stepCrr, pCrc, stepCrc); + } + else + { + cbpyPrev = cbpy; + mvPrev[0] = mvCur[0]; mvPrev[1] = mvCur[1]; mvPrev[2] = mvCur[2]; mvPrev[3] = mvCur[3]; + if (mp4_DecodeInterMB(pInfo, coeffMB, quant, (cbpy << 2) + cbpc, scan) != MP4_STATUS_OK) + goto Err_4; + mp4_MC_HP(cbpc & 2, pCbr, stepCbr, pCbc, stepCbc, coeffMB+256, &mvCbCr, rt); + mp4_MC_HP(cbpc & 1, pCrr, stepCrr, pCrc, stepCrc, coeffMB+320, &mvCbCr, rt); + } + // OBMC current MB if it is the last in the row + if (colNum == mbPerRow - 1) + mp4_OBMC(pInfo, pMBinfo, mvPrev, colNum, rowNum, limitRectL, pYc, stepYc, pYr, stepYr, cbpyPrev, coeffMB, 0); + } + } +#ifdef USE_NOTCODED_STATE + ncState ++; +#endif + pMBinfo ++; + mbInVideoPacket ++; + colNum ++; + if (colNum == mbPerRow) + { + colNum = 0; + rowNum ++; + if (rowNum == mbPerCol) + { + // skip stuffing + while (mp4_ShowBits(pInfo, 10) == 1) + mp4_FlushBits(pInfo, 10); + return sts; + } + 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; + } + } + if (!pInfo->VisualObject.VideoObject.resync_marker_disable) + { + int32_t found; +ErrRet_4: + if (mp4_CheckDecodeVideoPacket(pInfo, &found) == MP4_STATUS_OK) + { + if (found) { + mbInVideoPacket = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num - mbCurr; + quant = pInfo->VisualObject.VideoObject.VideoObjectPlane.quant_scale; + mbCurr = pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num; + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, mbCurr - rowNum * mbPerRow - colNum); + rowNum = mbCurr / mbPerRow; + colNum = mbCurr % mbPerRow; + pYc = pInfo->VisualObject.cFrame->pY + (rowNum * stepYc + colNum) * 16; pCbc = pInfo->VisualObject.cFrame->pCb + (rowNum * stepCbc + colNum) * 8; pCrc = pInfo->VisualObject.cFrame->pCr + (rowNum * stepCrc + colNum) * 8; + pYr = pInfo->VisualObject.rFrame->pY + (rowNum * stepYr + colNum) * 16; pCbr = pInfo->VisualObject.rFrame->pCb + (rowNum * stepCbr + colNum) * 8; pCrr = pInfo->VisualObject.rFrame->pCr + (rowNum * stepCrr + colNum) * 8; + pMBinfo = pInfo->VisualObject.VideoObject.MBinfo + mbCurr; +#ifdef USE_NOTCODED_STATE + ncState = pInfo->VisualObject.VideoObject.ncState + mbCurr; +#endif + break; + } + } + else + goto Err_4; + } + } + // mark MBs the previous videopacket as invalid for prediction + for (i = 1; i <= IPP_MIN(mbInVideoPacket, mbPerRow + 1); i ++) + { + pMBinfo[-i].validPred = 0; + } + } +Err_4: + sts = MP4_STATUS_ERROR; + if (pInfo->stopOnErr) + return sts; + if (pInfo->VisualObject.VideoObject.resync_marker_disable || !mp4_SeekResyncMarker(pInfo)) + { + mp4_CopyMacroBlocks(pInfo->VisualObject.rFrame, pInfo->VisualObject.cFrame, mbPerRow, rowNum, colNum, pInfo->VisualObject.VideoObject.MacroBlockPerVOP - rowNum * mbPerRow - colNum); + return sts; + } + goto ErrRet_4; + } +} + + |