xref: /frameworks/base/media/libstagefright/codecs/m4v_h263/dec/src/combined_decode.cpp

/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#include "mp4dec_lib.h" /* video decoder function prototypes */
#include "vlc_decode.h"
#include "bitstream.h"
#include "scaling.h"
#include "mbtype_mode.h"

#define OSCL_DISABLE_WARNING_CONDITIONAL_IS_CONSTANT
/* ======================================================================== */
/*  Function : DecodeFrameCombinedMode()                                    */
/*  Purpose  : Decode a frame of MPEG4 bitstream in combined mode.          */
/*  In/out   :                                                              */
/*  Return   :                                                              */
/*  Modified :                                                              */
/*                                                                          */
/*      03/30/2000 : Cleaned up and optimized the code.             */
/*      03/31/2000 : Added proper handling of MB stuffing.          */
/*      04/13/2000 : Rewrote this combined mode path completely     */
/*                           so that it handles "Combined Mode With Error   */
/*                           Resilience."  Now the code resembles the       */
/*                           pseudo codes in MPEG-4 standard better.        */
/*      10/13/2000 : Add fast VLC+dequant                           */
/*      04/13/2001 : fix MB_stuffing                               */
/*      08/07/2001 : remove MBzero                                  */
/* ======================================================================== */
PV_STATUS DecodeFrameCombinedMode(VideoDecData *video)
{
    PV_STATUS status;
    int mbnum;
    Vop *currVop = video->currVop;
    BitstreamDecVideo *stream = video->bitstream;
    int shortVideoHeader = video->shortVideoHeader;
    int16 QP, *QPMB = video->QPMB;
    uint8 *Mode = video->headerInfo.Mode;
    int nTotalMB = video->nTotalMB;
    int nMBPerRow = video->nMBPerRow;
    int slice_counter;
    uint32 tmpvar, long_zero_bits;
    uint code;
    int valid_stuffing;
    int resync_marker_length;
    int stuffing_length;

    /* add this for error resilient, 05/18/2000 */
    int32 startPacket;
    int mb_start;
    /* copy and pad to prev_Vop for INTER coding */
    switch (currVop->predictionType)
    {
        case I_VOP :
//      oscl_memset(Mode, MODE_INTRA, sizeof(uint8)*nTotalMB);
            resync_marker_length = 17;
            stuffing_length = 9;
            break;
        case P_VOP :
            oscl_memset(video->motX, 0, sizeof(MOT)*4*nTotalMB);
            oscl_memset(video->motY, 0, sizeof(MOT)*4*nTotalMB);
//      oscl_memset(Mode, MODE_INTER, sizeof(uint8)*nTotalMB);
            resync_marker_length = 16 + currVop->fcodeForward;
            stuffing_length = 10;
            break;
        default :
            mp4dec_log("DecodeFrameCombinedMode(): Vop type not supported.\n");
            return PV_FAIL;
    }
#ifdef PV_ANNEX_IJKT_SUPPORT
    if (video->shortVideoHeader)
    {
        if (video->advanced_INTRA)
        {
            if (video->modified_quant)
            {
                video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader_AnnexIT;
                video->vlcDecCoeffInter = &VlcDecTCOEFShortHeader_AnnexT;
            }
            else
            {
                video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader_AnnexI;
                video->vlcDecCoeffInter = &VlcDecTCOEFShortHeader;
            }
        }
        else
        {
            if (video->modified_quant)
            {
                video->vlcDecCoeffInter = video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader_AnnexT;
            }
            else
            {
                video->vlcDecCoeffInter = video->vlcDecCoeffIntra = &VlcDecTCOEFShortHeader;
            }
        }
    }

#endif

    /** Initialize sliceNo ***/
    mbnum = slice_counter = 0;
//  oscl_memset(video->sliceNo, 0, sizeof(uint8)*nTotalMB);
    QP = video->currVop->quantizer;

    do
    {
        /* This section is equivalent to motion_shape_texture() */
        /*    in the MPEG-4 standard.     04/13/2000          */
        mb_start = mbnum;
        video->usePrevQP = 0;             /*  04/27/01 */
        startPacket = getPointer(stream);

#ifdef PV_ANNEX_IJKT_SUPPORT
        if (video->modified_quant)
        {
            video->QP_CHR = MQ_chroma_QP_table[QP];
        }
        else
        {
            video->QP_CHR = QP;     /* ANNEX_T */
        }
#endif
        /* remove any stuffing bits */
        BitstreamShowBits16(stream, stuffing_length, &code);
        while (code == 1)
        {
            PV_BitstreamFlushBits(stream, stuffing_length);
            BitstreamShowBits16(stream, stuffing_length, &code);
        }

        do
        {
            /* we need video->mbnum in lower level functions */
            video->mbnum = mbnum;
            video->mbnum_row = PV_GET_ROW(mbnum, nMBPerRow);
            video->mbnum_col = mbnum - video->mbnum_row * nMBPerRow;
            /* assign slice number for each macroblocks */
            video->sliceNo[mbnum] = (uint8) slice_counter;

            /* decode COD, MCBPC, ACpred_flag, CPBY and DQUANT */
            /* We have to discard stuffed MB header */
            status = GetMBheader(video, &QP);

            if (status != PV_SUCCESS)
            {
                VideoDecoderErrorDetected(video);
                video->mbnum = mb_start;
                movePointerTo(stream, (startPacket & -8));
                break;
            }

            /* Store the QP value for later use in AC prediction */
            QPMB[mbnum] = QP;

            if (Mode[mbnum] != MODE_SKIPPED)
            {
                /* decode the DCT coeficients for the MB */
                status = GetMBData(video);
                if (status != PV_SUCCESS)
                {
                    VideoDecoderErrorDetected(video);
                    video->mbnum = mb_start;
                    movePointerTo(stream, (startPacket & -8));
                    break;
                }
            }
            else /* MODE_SKIPPED */
            {
                SkippedMBMotionComp(video); /*  08/04/05 */
            }
            // Motion compensation and put video->mblock->pred_block
            mbnum++;

            /* remove any stuffing bits */
            BitstreamShowBits16(stream, stuffing_length, &code);
            while (code == 1)
            {
                PV_BitstreamFlushBits(stream, stuffing_length);
                BitstreamShowBits16(stream, stuffing_length, &code);
            }

            /* have we reached the end of the video packet or vop? */
            if (shortVideoHeader)
            {
#ifdef PV_ANNEX_IJKT_SUPPORT
                if (!video->slice_structure)
                {
#endif
                    if (mbnum >= (int)(video->mbnum_row + 1)*video->nMBinGOB)   /*  10/11/01 */
                    {
                        if (mbnum >= nTotalMB) return PV_SUCCESS;
                        status = BitstreamShowBits32(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);

                        if (tmpvar == GOB_RESYNC_MARKER)
                        {
                            break;
                        }
                        else
                        {
                            status = PV_BitstreamShowBitsByteAlign(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);
                            if (tmpvar == GOB_RESYNC_MARKER) break;
                        }
                    }
#ifdef PV_ANNEX_IJKT_SUPPORT
                }
                else
                {

                    if (mbnum >= nTotalMB)  /* in case no valid stuffing  06/23/01 */
                    {
                        valid_stuffing = validStuffing_h263(stream);
                        if (valid_stuffing == 0)
                        {
                            VideoDecoderErrorDetected(video);
                            ConcealPacket(video, mb_start, nTotalMB, slice_counter);
                        }
                        return PV_SUCCESS;
                    }
                    /* ANNEX_K */
                    PV_BitstreamShowBitsByteAlignNoForceStuffing(stream, 17, &tmpvar);
                    if (tmpvar == RESYNC_MARKER)
                    {
                        valid_stuffing = validStuffing_h263(stream);
                        if (valid_stuffing)
                            break; /*  06/21/01 */
                    }

                }
#endif
            }
            else
            {
                if (mbnum >= nTotalMB)  /* in case no valid stuffing  06/23/01 */
                {
                    /*  11/01/2002 if we are at the end of the frame and there is some garbage data
                    at the end of the frame (i.e. no next startcode) break if the stuffing is valid */
                    valid_stuffing = validStuffing(stream);
                    if (valid_stuffing == 0)
                    {
                        /* end 11/01/2002 */
                        VideoDecoderErrorDetected(video);
                        ConcealPacket(video, mb_start, nTotalMB, slice_counter);
                    }
                    PV_BitstreamByteAlign(stream);
                    return PV_SUCCESS;
                }

                status = PV_BitstreamShowBitsByteAlign(stream, 23, &tmpvar); /* this call is valid for f_code < 8 */
                long_zero_bits = !tmpvar;

                if ((tmpvar >> (23 - resync_marker_length)) == RESYNC_MARKER || long_zero_bits)
                {
                    valid_stuffing = validStuffing(stream);
                    if (valid_stuffing)
                        break; /*  06/21/01 */
                }

            }
        }
        while (TRUE);

        if (shortVideoHeader)
        { /* We need to check newgob to refresh quantizer */
#ifdef PV_ANNEX_IJKT_SUPPORT
            if (!video->slice_structure)
            {
#endif
                while ((status = PV_GobHeader(video)) == PV_FAIL)
                {
                    if ((status = quickSearchGOBHeader(stream)) != PV_SUCCESS)
                    {
                        break;
                    }
                }

                mbnum = currVop->gobNumber * video->nMBinGOB;
#ifdef PV_ANNEX_IJKT_SUPPORT
            }
            else
            {
                while ((status = PV_H263SliceHeader(video, &mbnum)) == PV_FAIL)
                {
                    if ((status = quickSearchH263SliceHeader(stream)) != PV_SUCCESS)
                    {
                        break;
                    }
                }
            }

#endif
        }
        else
        {
            while ((status = PV_ReadVideoPacketHeader(video, &mbnum)) == PV_FAIL)
            {
                if ((status = quickSearchVideoPacketHeader(stream, resync_marker_length)) != PV_SUCCESS)
                {
                    break;
                }
            }
        }

        if (status == PV_END_OF_VOP)
        {
            mbnum = nTotalMB;
        }

        if (mbnum > video->mbnum + 1)
        {
            ConcealPacket(video, video->mbnum, mbnum, slice_counter);
        }
        QP = video->currVop->quantizer;
        slice_counter++;
        if (mbnum >= nTotalMB) break;

    }
    while (TRUE);
    return PV_SUCCESS;
}


/* ============================================================================ */
/*  Function : GetMBHeader()                                                    */
/*  Purpose  : Decode MB header, not_coded, mcbpc, ac_pred_flag, cbpy, dquant.  */
/*  In/out   :                                                                  */
/*  Return   :                                                                  */
/*  Modified :                                                                  */
/*                                                                              */
/*      3/29/00 : Changed the returned value and optimized the code.    */
/*      4/01/01 : new ACDC prediction structure                         */
/* ============================================================================ */
PV_STATUS GetMBheader(VideoDecData *video, int16 *QP)
{
    BitstreamDecVideo *stream = video->bitstream;
    int mbnum = video->mbnum;
    uint8 *Mode = video->headerInfo.Mode;
    int x_pos = video->mbnum_col;
    typeDCStore *DC = video->predDC + mbnum;
    typeDCACStore *DCAC_row = video->predDCAC_row + x_pos;
    typeDCACStore *DCAC_col = video->predDCAC_col;
    const static int16  DQ_tab[4] = { -1, -2, 1, 2};

    int CBPY, CBPC;
    int MBtype, VopType;
    int MCBPC;
    uint DQUANT;
    int comp;
    Bool mb_coded;

    VopType = video->currVop->predictionType;
    mb_coded = ((VopType == I_VOP) ? TRUE : !BitstreamRead1Bits_INLINE(stream));

    if (!mb_coded)
    {
        /* skipped macroblock */
        Mode[mbnum] = MODE_SKIPPED;
        //oscl_memset(DCAC_row, 0, sizeof(typeDCACStore));   /*  SKIPPED_ACDC */
        //oscl_memset(DCAC_col, 0, sizeof(typeDCACStore));
        ZERO_OUT_64BYTES(DCAC_row);
        ZERO_OUT_64BYTES(DCAC_col); /*  08/12/05 */

        for (comp = 0; comp < 6; comp++)
        {
            (*DC)[comp] = mid_gray;
        }
    }
    else
    {
        /* coded macroblock */
        if (VopType == I_VOP)
        {
            MCBPC = PV_VlcDecMCBPC_com_intra(stream);
        }
        else
        {
#ifdef PV_ANNEX_IJKT_SUPPORT
            if (!video->deblocking)
            {
                MCBPC = PV_VlcDecMCBPC_com_inter(stream);
            }
            else
            {
                MCBPC = PV_VlcDecMCBPC_com_inter_H263(stream);
            }
#else
            MCBPC = PV_VlcDecMCBPC_com_inter(stream);
#endif
        }

        if (VLC_ERROR_DETECTED(MCBPC))
        {
            return PV_FAIL;
        }

        Mode[mbnum] = (uint8)(MBtype = MBtype_mode[MCBPC & 7]);
        CBPC = (MCBPC >> 4) & 3;

#ifdef PV_ANNEX_IJKT_SUPPORT
        if (MBtype & INTRA_MASK)
        {
            if (!video->shortVideoHeader)
            {
                video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits(stream);
            }
            else
            {
                if (video->advanced_INTRA)
                {
                    if (!BitstreamRead1Bits(stream))
                    {
                        video->acPredFlag[mbnum] = 0;
                    }
                    else
                    {
                        video->acPredFlag[mbnum] = 1;
                        if (BitstreamRead1Bits(stream))
                        {
                            video->mblock->direction = 0;
                        }
                        else
                        {
                            video->mblock->direction = 1;
                        }
                    }
                }
                else
                {
                    video->acPredFlag[mbnum] = 0;
                }
            }
        }
#else
        if ((MBtype & INTRA_MASK) && !video->shortVideoHeader)
        {
            video->acPredFlag[mbnum] = (uint8) BitstreamRead1Bits_INLINE(stream);
        }
        else
        {
            video->acPredFlag[mbnum] = 0;
        }
#endif
        CBPY = PV_VlcDecCBPY(stream, MBtype & INTRA_MASK); /* INTRA || INTRA_Q */
        if (CBPY < 0)
        {
            return PV_FAIL;
        }

        // GW 04/23/99
        video->headerInfo.CBP[mbnum] = (uint8)(CBPY << 2 | (CBPC & 3));
#ifdef PV_ANNEX_IJKT_SUPPORT
        if (MBtype & Q_MASK)
        {
            if (!video->modified_quant)
            {
                DQUANT = BitstreamReadBits16(stream, 2);
                *QP += DQ_tab[DQUANT];

                if (*QP < 1) *QP = 1;
                else if (*QP > 31) *QP = 31;
                video->QP_CHR = *QP;  /* ANNEX_T */
            }
            else
            {
                if (BitstreamRead1Bits(stream))
                {
                    if (BitstreamRead1Bits(stream))
                    {
                        *QP += DQ_tab_Annex_T_11[*QP];
                    }
                    else
                    {
                        *QP += DQ_tab_Annex_T_10[*QP];
                    }
                    if (*QP < 1) *QP = 1;
                    else if (*QP > 31) *QP = 31;
                }
                else
                {
                    *QP = (int16)BitstreamReadBits16(stream, 5);
                }
                video->QP_CHR =  MQ_chroma_QP_table[*QP];
            }
        }
#else
        if (MBtype & Q_MASK)
        {
            DQUANT = BitstreamReadBits16(stream, 2);
            *QP += DQ_tab[DQUANT];

            if (*QP < 1) *QP = 1;
            else if (*QP > 31) *QP = 31;
        }
#endif
    }
    return PV_SUCCESS;
}





/***********************************************************CommentBegin******
*       3/10/00  : initial modification to the
*                new PV-Decoder Lib format.
*       4/2/2000 : Cleanup and error-handling modification.  This
*                   function has been divided into several sub-functions for
*                   better coding style and maintainance reason.  I also
*                   greatly shrunk the code size here.
*       9/18/2000 : VlcDecode+Dequant optimization *
*       4/01/2001 : new ACDC prediction structure
*       3/29/2002 : removed GetIntraMB and GetInterMB
***********************************************************CommentEnd********/
PV_STATUS GetMBData(VideoDecData *video)
{
    BitstreamDecVideo *stream = video->bitstream;
    int mbnum = video->mbnum;
    MacroBlock *mblock = video->mblock;
    int16 *dataBlock;
    PIXEL *c_comp;
    uint mode = video->headerInfo.Mode[mbnum];
    uint CBP = video->headerInfo.CBP[mbnum];
    typeDCStore *DC = video->predDC + mbnum;
    int intra_dc_vlc_thr = video->currVop->intraDCVlcThr;
    int16 QP = video->QPMB[mbnum];
    int16 QP_tmp = QP;
    int width = video->width;
    int  comp;
    int  switched;
    int ncoeffs[6] = {0, 0, 0, 0, 0, 0};
    int *no_coeff = mblock->no_coeff;
    int16 DC_coeff;
    PV_STATUS status;

#ifdef PV_POSTPROC_ON
    /* post-processing */
    uint8 *pp_mod[6];
    int TotalMB = video->nTotalMB;
    int MB_in_width = video->nMBPerRow;
#endif
    int y_pos = video->mbnum_row;
    int x_pos = video->mbnum_col;
    int32 offset = (int32)(y_pos << 4) * width + (x_pos << 4);

    /* Decode each 8-by-8 blocks. comp 0 ~ 3 are luminance blocks, 4 ~ 5 */
    /*  are chrominance blocks.   04/03/2000.                          */
#ifdef PV_POSTPROC_ON
    if (video->postFilterType != PV_NO_POST_PROC)
    {
        /** post-processing ***/
        pp_mod[0] = video->pstprcTypCur + (y_pos << 1) * (MB_in_width << 1) + (x_pos << 1);
        pp_mod[1] = pp_mod[0] + 1;
        pp_mod[2] = pp_mod[0] + (MB_in_width << 1);
        pp_mod[3] = pp_mod[2] + 1;
        pp_mod[4] = video->pstprcTypCur + (TotalMB << 2) + mbnum;
        pp_mod[5] = pp_mod[4] + TotalMB;
    }
#endif

    /*  oscl_memset(mblock->block, 0, sizeof(typeMBStore));    Aug 9,2005 */

    if (mode & INTRA_MASK) /* MODE_INTRA || MODE_INTRA_Q */
    {
        switched = 0;
        if (intra_dc_vlc_thr)
        {
            if (video->usePrevQP)
                QP_tmp = video->QPMB[mbnum-1];   /* running QP  04/26/01 */

            switched = (intra_dc_vlc_thr == 7 || QP_tmp >= intra_dc_vlc_thr * 2 + 11);
        }

        mblock->DCScalarLum = cal_dc_scaler(QP, LUMINANCE_DC_TYPE);   /*  3/01/01 */
        mblock->DCScalarChr = cal_dc_scaler(QP, CHROMINANCE_DC_TYPE);

        for (comp = 0; comp < 6; comp++)
        {
            dataBlock = mblock->block[comp];    /* 10/20/2000 */

            if (video->shortVideoHeader)
            {
#ifdef PV_ANNEX_IJKT_SUPPORT
                if (!video->advanced_INTRA)
                {
#endif
                    DC_coeff = (int16) BitstreamReadBits16_INLINE(stream, 8);

                    if ((DC_coeff & 0x7f) == 0) /* 128 & 0  */
                    {
                        /* currently we will only signal FAIL for 128. We will ignore the 0 case  */
                        if (DC_coeff == 128)
                        {
                            return PV_FAIL;
                        }
                        else
                        {
                            VideoDecoderErrorDetected(video);
                        }
                    }
                    if (DC_coeff == 255)
                    {
                        DC_coeff = 128;
                    }
                    dataBlock[0] = (int16) DC_coeff;
#ifdef PV_ANNEX_IJKT_SUPPORT
                }
#endif
                ncoeffs[comp] = VlcDequantH263IntraBlock_SH(video, comp, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);

            }
            else
            {
                if (switched == 0)
                {
                    status = PV_DecodePredictedIntraDC(comp, stream, &DC_coeff);
                    if (status != PV_SUCCESS) return PV_FAIL;

                    dataBlock[0] = (int16) DC_coeff;
                }
                ncoeffs[comp] = VlcDequantH263IntraBlock(video, comp,
                                switched, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
            }

            if (VLC_ERROR_DETECTED(ncoeffs[comp]))
            {
                if (switched)
                    return PV_FAIL;
                else
                {
                    ncoeffs[comp] = 1;
                    oscl_memset((dataBlock + 1), 0, sizeof(int16)*63);
                }
            }
            no_coeff[comp] = ncoeffs[comp];

#ifdef PV_POSTPROC_ON
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[comp] = (uint8) PostProcSemaphore(dataBlock);
#endif
        }
        MBlockIDCT(video);
    }
    else      /* INTER modes */
    {   /*  moved it here Aug 15, 2005 */
        /* decode the motion vector (if there are any) */
        status = PV_GetMBvectors(video, mode);
        if (status != PV_SUCCESS)
        {
            return status;
        }


        MBMotionComp(video, CBP);
        c_comp  = video->currVop->yChan + offset;

#ifdef PV_ANNEX_IJKT_SUPPORT
        for (comp = 0; comp < 4; comp++)
        {
            (*DC)[comp] = mid_gray;
            if (CBP & (1 << (5 - comp)))
            {
                ncoeffs[comp] = VlcDequantH263InterBlock(video, comp, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
                if (VLC_ERROR_DETECTED(ncoeffs[comp])) return PV_FAIL;

                BlockIDCT(c_comp + (comp&2)*(width << 2) + 8*(comp&1), mblock->pred_block + (comp&2)*64 + 8*(comp&1), mblock->block[comp], width, ncoeffs[comp],
                          mblock->bitmapcol[comp], mblock->bitmaprow[comp]);

#ifdef PV_POSTPROC_ON
                /* for inter just test for ringing */
                if (video->postFilterType != PV_NO_POST_PROC)
                    *pp_mod[comp] = (uint8)((ncoeffs[comp] > 3) ? 4 : 0);
#endif
            }
            else
            {
                /* no IDCT for all zeros blocks  03/28/2002 */
                /*              BlockIDCT();                */
#ifdef PV_POSTPROC_ON
                if (video->postFilterType != PV_NO_POST_PROC)
                    *pp_mod[comp] = 0;
#endif
            }
        }

        video->QPMB[mbnum] = video->QP_CHR;     /* ANNEX_T */



        (*DC)[4] = mid_gray;
        if (CBP & 2)
        {
            ncoeffs[4] = VlcDequantH263InterBlock(video, 4, mblock->bitmapcol[4], &mblock->bitmaprow[4]);
            if (VLC_ERROR_DETECTED(ncoeffs[4])) return PV_FAIL;

            BlockIDCT(video->currVop->uChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 256, mblock->block[4], width >> 1, ncoeffs[4],
                      mblock->bitmapcol[4], mblock->bitmaprow[4]);

#ifdef PV_POSTPROC_ON
            /* for inter just test for ringing */
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[4] = (uint8)((ncoeffs[4] > 3) ? 4 : 0);
#endif
        }
        else
        {
            /* no IDCT for all zeros blocks  03/28/2002 */
            /*              BlockIDCT();                */
#ifdef PV_POSTPROC_ON
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[4] = 0;
#endif
        }
        (*DC)[5] = mid_gray;
        if (CBP & 1)
        {
            ncoeffs[5] = VlcDequantH263InterBlock(video, 5, mblock->bitmapcol[5], &mblock->bitmaprow[5]);
            if (VLC_ERROR_DETECTED(ncoeffs[5])) return PV_FAIL;

            BlockIDCT(video->currVop->vChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 264, mblock->block[5], width >> 1, ncoeffs[5],
                      mblock->bitmapcol[5], mblock->bitmaprow[5]);

#ifdef PV_POSTPROC_ON
            /* for inter just test for ringing */
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[5] = (uint8)((ncoeffs[5] > 3) ? 4 : 0);
#endif
        }
        else
        {
            /* no IDCT for all zeros blocks  03/28/2002 */
            /*              BlockIDCT();                */
#ifdef PV_POSTPROC_ON
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[5] = 0;
#endif
        }
        video->QPMB[mbnum] = QP;  /* restore the QP values  ANNEX_T*/
#else
        for (comp = 0; comp < 4; comp++)
        {
            (*DC)[comp] = mid_gray;
            if (CBP & (1 << (5 - comp)))
            {
                ncoeffs[comp] = VlcDequantH263InterBlock(video, comp, mblock->bitmapcol[comp], &mblock->bitmaprow[comp]);
                if (VLC_ERROR_DETECTED(ncoeffs[comp])) return PV_FAIL;

                BlockIDCT(c_comp + (comp&2)*(width << 2) + 8*(comp&1), mblock->pred_block + (comp&2)*64 + 8*(comp&1), mblock->block[comp], width, ncoeffs[comp],
                          mblock->bitmapcol[comp], mblock->bitmaprow[comp]);

#ifdef PV_POSTPROC_ON
                /* for inter just test for ringing */
                if (video->postFilterType != PV_NO_POST_PROC)
                    *pp_mod[comp] = (uint8)((ncoeffs[comp] > 3) ? 4 : 0);
#endif
            }
            else
            {
                /* no IDCT for all zeros blocks  03/28/2002 */
                /*              BlockIDCT();                */
#ifdef PV_POSTPROC_ON
                if (video->postFilterType != PV_NO_POST_PROC)
                    *pp_mod[comp] = 0;
#endif
            }
        }

        (*DC)[4] = mid_gray;
        if (CBP & 2)
        {
            ncoeffs[4] = VlcDequantH263InterBlock(video, 4, mblock->bitmapcol[4], &mblock->bitmaprow[4]);
            if (VLC_ERROR_DETECTED(ncoeffs[4])) return PV_FAIL;

            BlockIDCT(video->currVop->uChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 256, mblock->block[4], width >> 1, ncoeffs[4],
                      mblock->bitmapcol[4], mblock->bitmaprow[4]);

#ifdef PV_POSTPROC_ON
            /* for inter just test for ringing */
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[4] = (uint8)((ncoeffs[4] > 3) ? 4 : 0);
#endif
        }
        else
        {
            /* no IDCT for all zeros blocks  03/28/2002 */
            /*              BlockIDCT();                */
#ifdef PV_POSTPROC_ON
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[4] = 0;
#endif
        }
        (*DC)[5] = mid_gray;
        if (CBP & 1)
        {
            ncoeffs[5] = VlcDequantH263InterBlock(video, 5, mblock->bitmapcol[5], &mblock->bitmaprow[5]);
            if (VLC_ERROR_DETECTED(ncoeffs[5])) return PV_FAIL;

            BlockIDCT(video->currVop->vChan + (offset >> 2) + (x_pos << 2), mblock->pred_block + 264, mblock->block[5], width >> 1, ncoeffs[5],
                      mblock->bitmapcol[5], mblock->bitmaprow[5]);

#ifdef PV_POSTPROC_ON
            /* for inter just test for ringing */
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[5] = (uint8)((ncoeffs[5] > 3) ? 4 : 0);
#endif
        }
        else
        {
            /* no IDCT for all zeros blocks  03/28/2002 */
            /*              BlockIDCT();                */
#ifdef PV_POSTPROC_ON
            if (video->postFilterType != PV_NO_POST_PROC)
                *pp_mod[5] = 0;
#endif
#endif  // PV_ANNEX_IJKT_SUPPORT






    }

    video->usePrevQP = 1;          /* should be set after decoding the first Coded  04/27/01 */
    return PV_SUCCESS;
}