umc_h264_segment_decoder_decode_mb_types_cabac.cpp

audio-video-codecs.rar语音编解码器

                                                && bUseConstrainedIntra)))
    {
        memset(uModeAbove, 0, sizeof(uModeAbove));
    }
    else
    {
        if (gmbinfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].mbtype == MBTYPE_INTRA)
        {
            pRefIntraTypes = m_pMBIntraTypes +
                m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num * NUM_INTRA_TYPE_ELEMENTS;
            uModeAbove[0] = pRefIntraTypes[10] + 1;
            uModeAbove[1] = pRefIntraTypes[11] + 1;
            uModeAbove[2] = pRefIntraTypes[14] + 1;
            uModeAbove[3] = pRefIntraTypes[15] + 1;
        }
        else
        {
            // MB above in slice but not INTRA, use mode 2 (+1)
            uModeAbove[0] = uModeAbove[1] = uModeAbove[2] = uModeAbove[3] = 3;
        }
    }

    H264DecoderBlockLocation *pMbsLeft = m_cur_mb.CurrentBlockNeighbours.mbs_left;
    Ipp32s mb_num;
    Ipp32s i;
    for(i = 0; i < 4; i++)
    {
        mb_num = pMbsLeft[i].mb_num;
        if ((mb_num<0) ||
           ((!IS_INTRA_MBTYPE(gmbinfo[mb_num].mbtype) && bUseConstrainedIntra)))
        {
            uModeLeft[i] = 0;
        }
        else
        {
            if (gmbinfo[mb_num].mbtype  == MBTYPE_INTRA)
            {
                pRefIntraTypes = m_pMBIntraTypes + mb_num*NUM_INTRA_TYPE_ELEMENTS;
                uModeLeft[i]   = pRefIntraTypes[NIT2LIN[pMbsLeft[i].block_num]] + 1;
            }
            else
            {                 // MB left in slice but not INTRA, use mode 2 (+1)
                uModeLeft[i] = 2+1;
            }
        }
    }

    Ipp32s predModeValues[16];
    Ipp32s flag_context = ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG];
    Ipp32s pred_context = ctxIdxOffset[REM_INTRA4X4_PRED_MODE];
    for(i = 0; i < 16; i++)
    {
        if (0 == m_pBitStream->DecodeSingleBin_CABAC(flag_context))
        {
            predModeValues[i]  = 0;
            predModeValues[i] |= (m_pBitStream->DecodeSingleBin_CABAC(pred_context));
            predModeValues[i] |= (m_pBitStream->DecodeSingleBin_CABAC(pred_context) << 1);
            predModeValues[i] |= (m_pBitStream->DecodeSingleBin_CABAC(pred_context) << 2);
        }
        else
            predModeValues[i] = -1;
    }

    // Loop over the 4 8x8 blocks
    for (block=0; block<4; block++)
    {
        uAboveIndex = (block & 1) * 2;        // 0,2,0,2
        uLeftIndex = (block & 2);            // 0,0,2,2

        // upper left 4x4

        // Predicted mode is minimum of the above and left modes, or
        // mode 2 if above or left is outside slice, indicated by 0 in
        // mode array.
        uPredMode = IPP_MIN(uModeLeft[uLeftIndex], uModeAbove[uAboveIndex]);
        if (uPredMode)
            uPredMode--;
        else
            uPredMode = 2;

        // use_most_probable_mode

        // remaining_mode_selector
        if(predModeValues[4*block + 0] != -1)
        {
            if(predModeValues[4*block + 0] >= uPredMode)
                predModeValues[4*block + 0]++;
            uPredMode = predModeValues[4*block + 0];
        }

        // Save mode
        pMBIntraTypes[0] = (Ipp8u)uPredMode;
        uModeAbove[uAboveIndex] = uPredMode + 1;

        // upper right 4x4
        uPredMode = IPP_MIN(uPredMode+1, uModeAbove[uAboveIndex+1]);
        if (uPredMode)
            uPredMode--;
        else
            uPredMode = 2;

        if(predModeValues[4*block + 1] != -1)
        {
            if(predModeValues[4*block + 1] >= uPredMode)
                predModeValues[4*block + 1]++;
            uPredMode = predModeValues[4*block + 1];
        }

        pMBIntraTypes[1] = (IntraType)uPredMode;
        uModeAbove[uAboveIndex+1] = uPredMode + 1;
        uModeLeft[uLeftIndex] = uPredMode + 1;

        // lower left 4x4
        uPredMode = IPP_MIN(uModeLeft[uLeftIndex+1], uModeAbove[uAboveIndex]);
        if (uPredMode)
            uPredMode--;
        else
            uPredMode = 2;

        if(predModeValues[4*block + 2] != -1)
        {
         if(predModeValues[4*block + 2] >= uPredMode)
             predModeValues[4*block + 2]++;
            uPredMode = predModeValues[4*block + 2];
        }

        pMBIntraTypes[2] = (IntraType)uPredMode;
        uModeAbove[uAboveIndex] = uPredMode + 1;

        // lower right 4x4 (above and left must always both be in slice)
        uPredMode = IPP_MIN(uPredMode+1, uModeAbove[uAboveIndex+1]) - 1;

        if(predModeValues[4*block + 3] != -1)
        {
          if(predModeValues[4*block + 3] >= uPredMode)
              predModeValues[4*block + 3]++;
            uPredMode = predModeValues[4*block + 3];
        }

        pMBIntraTypes[3] = (IntraType)uPredMode;
        uModeAbove[uAboveIndex+1] = uPredMode + 1;
        uModeLeft[uLeftIndex+1] = uPredMode + 1;

        pMBIntraTypes += 4;
    }    // block

} // void H264SegmentDecoder::DecodeIntraTypes4x4_CABAC(Ipp32u *pMBIntraTypes, bool bUseConstrainedIntra)

void H264SegmentDecoder::DecodeIntraTypes8x8_CABAC(IntraType *pMBIntraTypes, bool bUseConstrainedIntra)
{
    Ipp32s uModeAbove[2];
    Ipp32s uModeLeft[2];
    Ipp32s uPredMode;        // predicted mode for current 4x4 block

    IntraType *pRefIntraTypes;
    Ipp32s val;

    H264DecoderMacroblockGlobalInfo *gmbinfo=m_gmbinfo->mbs;
    Ipp32u predictors=7;//5 lsb bits set
    //new version
    {
        // above, left MB available only if they are INTRA
        if ((m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num<0) || ((!IS_INTRA_MBTYPE(gmbinfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].mbtype) && bUseConstrainedIntra)))
            predictors &= (~1);//clear 1-st bit
        if ((m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num<0) || ((!IS_INTRA_MBTYPE(gmbinfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num].mbtype) && bUseConstrainedIntra)))
            predictors &= (~2); //clear 2-nd bit
        if ((m_cur_mb.CurrentBlockNeighbours.mbs_left[2].mb_num<0) || ((!IS_INTRA_MBTYPE(gmbinfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[2].mb_num].mbtype) && bUseConstrainedIntra)))
            predictors &= (~4); //clear 4-th bit
    }

    // Get modes of blocks above and to the left, substituting 0
    // when above or to left is outside this MB slice. Substitute mode 2
    // when the adjacent macroblock is not 4x4 INTRA. Add 1 to actual
    // modes, so mode range is 1..9.

    if (predictors&1)
    {
        if (gmbinfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].mbtype == MBTYPE_INTRA)
        {
            pRefIntraTypes = m_pMBIntraTypes + m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num * NUM_INTRA_TYPE_ELEMENTS;
            uModeAbove[0] = pRefIntraTypes[10] + 1;
            uModeAbove[1] = pRefIntraTypes[14] + 1;
        }
        else
        {   // MB above in slice but not INTRA, use mode 2 (+1)
            uModeAbove[0] = uModeAbove[1] = 2 + 1;
        }
    }
    else
    {
        uModeAbove[0] = uModeAbove[1]= 0;
    }
    if (predictors&2)
    {
        if (gmbinfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num].mbtype  == MBTYPE_INTRA)
        {
            pRefIntraTypes = m_pMBIntraTypes + m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num*NUM_INTRA_TYPE_ELEMENTS;
            uModeLeft[0] = pRefIntraTypes[NIT2LIN[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].block_num]] + 1;
        }
        else
        {
            // MB left in slice but not INTRA, use mode 2 (+1)
            uModeLeft[0] = 2+1;
        }
    }
    else
    {
        uModeLeft[0] = 0;
    }

    if (predictors&4)
    {
        if (gmbinfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[2].mb_num].mbtype == MBTYPE_INTRA)
        {
            pRefIntraTypes = m_pMBIntraTypes + m_cur_mb.CurrentBlockNeighbours.mbs_left[2].mb_num*NUM_INTRA_TYPE_ELEMENTS;
            uModeLeft[1] = pRefIntraTypes[NIT2LIN[m_cur_mb.CurrentBlockNeighbours.mbs_left[2].block_num]] + 1;
        }
        else
        {
            // MB left in slice but not INTRA, use mode 2 (+1)
            uModeLeft[1] = 2+1;
        }
    }
    else
    {
        uModeLeft[1] = 0;
    }

    // upper left 8x8

    // Predicted mode is minimum of the above and left modes, or
    // mode 2 if above or left is outside slice, indicated by 0 in
    // mode array.
    uPredMode = IPP_MIN(uModeLeft[0], uModeAbove[0]);
    if (uPredMode)
        uPredMode--;
    else
        uPredMode = 2;

    // If next bitstream bit is 1, use predicted mode, else read new mode
    if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG]))
    {
        val  = 0;
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]));
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 1);
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 2);

        uPredMode = val + (val >= uPredMode);
    }
    // Save mode
    pMBIntraTypes[0] =
    pMBIntraTypes[1] =
    pMBIntraTypes[2] =
    pMBIntraTypes[3] =
        (IntraType)uPredMode;
    uModeAbove[0] = uPredMode + 1;

    // upper right 8x8
    uPredMode = IPP_MIN(uPredMode+1, uModeAbove[1]);
    if (uPredMode)
        uPredMode--;
    else
        uPredMode = 2;

    if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG]))
    {
        val  = 0;
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]));
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 1);
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 2);

        uPredMode = val + (val >= uPredMode);
    }

    pMBIntraTypes[4] =
    pMBIntraTypes[5] =
    pMBIntraTypes[6] =
    pMBIntraTypes[7] =
        (IntraType)uPredMode;
    uModeAbove[1] = uPredMode + 1;

    // lower left 4x4
    uPredMode = IPP_MIN(uModeLeft[1], uModeAbove[0]);
    if (uPredMode)
        uPredMode--;
    else
        uPredMode = 2;

    if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG]))
    {
        val  = 0;
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]));
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 1);
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 2);

        uPredMode = val + (val >= uPredMode);
    }
    pMBIntraTypes[8] =
    pMBIntraTypes[9] =
    pMBIntraTypes[10] =
    pMBIntraTypes[11] =
        (IntraType)uPredMode;
    uModeAbove[0] = uPredMode + 1;

    // lower right 4x4 (above and left must always both be in slice)
    uPredMode = IPP_MIN(uPredMode+1, uModeAbove[1]) - 1;

    if (0 == m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[PREV_INTRA4X4_PRED_MODE_FLAG]))
    {
        val  = 0;
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]));
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 1);
        val |= (m_pBitStream->DecodeSingleBin_CABAC(ctxIdxOffset[REM_INTRA4X4_PRED_MODE]) << 2);

        uPredMode = val + (val >= uPredMode);
    }
    pMBIntraTypes[12] =
    pMBIntraTypes[13] =
    pMBIntraTypes[14] =
    pMBIntraTypes[15] =
        (IntraType)uPredMode;

    // copy last IntraTypes to first 4 for reconstruction since they're not used for further prediction
    pMBIntraTypes[1] = pMBIntraTypes[4];
    pMBIntraTypes[2] = pMBIntraTypes[8];
    pMBIntraTypes[3] = pMBIntraTypes[12];

}  // void H264SegmentDecoder::DecodeIntraTypes8x8_CABAC( Ipp32u *pMBIntraTypes,bool bUseConstrainedIntra)

void H264SegmentDecoder::DecodeIntraPredChromaMode_CABAC(void)
{
    Ipp32u ctxIdxInc;

    {
        Ipp32u condTermFlagA = 0, condTermFlagB = 0;
        Ipp32s nNum;

        // to obtain more details