winamp/Src/mpeg4dec/mp4decvop.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);
	}
}