umc_h264_pack.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

    Ipp32s i;

    for (i = 0; i < 48; i++)

    {
        enc_cbp_intra[dec_cbp_intra[i]] = (Ipp8u)i;
        enc_cbp_inter[dec_cbp_inter[i]] = (Ipp8u)i;
    }
}   // Init_VLC_LUTs

////////////////////////////////////////////////////////////////////////////////
//
// Encode_CBP
//
////////////////////////////////////////////////////////////////////////////////
void H264VideoEncoder::Encode_CBP(int uMB)
{
    if (m_PicParamSet.entropy_coding_mode)
    {
#if 0
        MB_Type uMBType = m_pCurrentFrame->pMBData[uMB].uMBType;
        int cbp = m_pCurrentFrame->pMBData[uMB].uCBP;
        int left_cbp = Get_Left_Value(uMB,m_pCurrentFrame->pMBData[uMB].cbp_bits,IS_TRUEINTRA_MBTYPE(uMBType));
        int top_cbp = Get_Top_Value(uMB,m_pCurrentFrame->pMBData[uMB-uWidthInMBs].cbp_bits,IS_TRUEINTRA_MBTYPE(uMBType));


        if (uMBType==MBTYPE_INTRA)
        {
            cbp = enc_cbp_intra[cbp];
        }
        else
        {
            cbp = enc_cbp_inter[cbp];
        }
#endif
        T_EncodeMBData *cmb,*lmb,*tmb;
        cmb = &m_pCurrentFrame->pMBData[uMB];
        lmb = Get_Left_Value(uMB,&m_pCurrentFrame->pMBData[uMB-1],NULL);
        tmb = Get_Top_Value(uMB,&m_pCurrentFrame->pMBData[uMB-uWidthInMBs],NULL);

        m_pbitstream->CBP_CABAC(cmb,lmb,tmb);
    }
    else
    {
        Ipp32s length;
        MB_Type uMBType = m_pCurrentFrame->pMBData[uMB].uMBType;
        int cbp = m_pCurrentFrame->pMBData[uMB].uCBP;
        if (uMBType==MBTYPE_INTRA)
            cbp = enc_cbp_intra[cbp];
        else
            cbp = enc_cbp_inter[cbp];
        length = m_pbitstream->PutVLCCode(cbp);

    }
}   // Encode_CBP

////////////////////////////////////////////////////////////////////////////////
//
// Encode_Inter_Type
//
////////////////////////////////////////////////////////////////////////////////
void H264VideoEncoder::Encode_Inter_Type(Ipp32u uMB)
{
    Ipp32s N, length;
    MB_Type uMBType = m_pCurrentFrame->pMBData[uMB].uMBType;
    int uLeftMBType = Get_Left_Value(uMB,m_pCurrentFrame->pMBData[uMB-1].uMBType,NUMBER_OF_MBTYPES);
    int uTopMBType = Get_Top_Value(uMB,m_pCurrentFrame->pMBData[uMB-uWidthInMBs].uMBType,NUMBER_OF_MBTYPES);
    switch (uMBType) {
    case MBTYPE_INTER:
        N = 0;
        break;

    case MBTYPE_INTER_16x8:
        N = 1;
        break;

    case MBTYPE_INTER_8x16:
        N = 2;
        break;

    case MBTYPE_INTER_8x8:
        N = 3;
        break;
    case MBTYPE_INTER_8x8_REF0:
        N = 4;
        // P_8x8ref0 is not allowed for CABAC coding => for CAVLC we
        // do code P_8x8ref0 and for CABAC we switch to P_8x8.
        if(m_PicParamSet.entropy_coding_mode) {
            uMBType = m_pCurrentFrame->pMBData[uMB].uMBType = MBTYPE_INTER_8x8;
            N -= 1;//for cabac
        }
        break;
    default:
        N = -1;
        break;
    }
    if (m_PicParamSet.entropy_coding_mode)
        m_pbitstream->MBTypeInfo_CABAC(m_SliceHeader.slice_type,N,(MB_Type)uMBType,(MB_Type)uLeftMBType,(MB_Type)uTopMBType);
    else
        length = m_pbitstream->PutVLCCode(N);

    if (uMBType == MBTYPE_INTER_8x8 || uMBType == MBTYPE_INTER_8x8_REF0) {
        // for each of the 8x8 blocks
        for (Ipp32u block=0; block<4; block++) {
            SB_Type sb_type;
            sb_type = m_pCurrentFrame->pMBData[uMB].SBType[block];

            switch (sb_type) {
                case SBTYPE_8x8:
                    N = 0;
                    break;
                case SBTYPE_8x4:
                    N = 1;
                    break;
                case SBTYPE_4x8:
                    N = 2;
                    break;
                case SBTYPE_4x4:
                    N = 3;
                    break;
                default:
                    break;
            }

            // Sub MB Type
            if (m_PicParamSet.entropy_coding_mode)
                m_pbitstream->SubTypeInfo_CABAC(m_SliceHeader.slice_type,N);
            else
                length = m_pbitstream->PutVLCCode(N);
        }
    }

}   // Encode_Inter_Type

////////////////////////////////////////////////////////////////////////////////
//
// Encode_BiPred_Type
//
////////////////////////////////////////////////////////////////////////////////
void H264VideoEncoder::Encode_BiPred_Type(Ipp32u uMB)
{
    Ipp32s N, length;
    MB_Type uMBType = m_pCurrentFrame->pMBData[uMB].uMBType;

    switch (uMBType) {

    case MBTYPE_DIRECT:
        N = 0;
        break;

    case MBTYPE_FORWARD:
        N = 1;
        break;

    case MBTYPE_BACKWARD:
        N = 2;
        break;

    case MBTYPE_BIDIR:
        N = 3;
        break;

    case MBTYPE_FWD_FWD_16x8:
        N = 4;
        break;

    case MBTYPE_FWD_FWD_8x16:
        N = 5;
        break;

    case MBTYPE_BWD_BWD_16x8:
        N = 6;
        break;

    case MBTYPE_BWD_BWD_8x16:
        N = 7;
        break;

    case MBTYPE_FWD_BWD_16x8:
        N = 8;
        break;

    case MBTYPE_FWD_BWD_8x16:
        N = 9;
        break;

    case MBTYPE_BWD_FWD_16x8:
        N = 10;
        break;

    case MBTYPE_BWD_FWD_8x16:
        N = 11;
        break;

    case MBTYPE_FWD_BIDIR_16x8:
        N = 12;
        break;

    case MBTYPE_FWD_BIDIR_8x16:
        N = 13;
        break;

    case MBTYPE_BWD_BIDIR_16x8:
        N = 14;
        break;

    case MBTYPE_BWD_BIDIR_8x16:
        N = 15;
        break;

    case MBTYPE_BIDIR_FWD_16x8:
        N = 16;
        break;

    case MBTYPE_BIDIR_FWD_8x16:
        N = 17;
        break;

    case MBTYPE_BIDIR_BWD_16x8:
        N = 18;
        break;

    case MBTYPE_BIDIR_BWD_8x16:
        N = 19;
        break;

    case MBTYPE_BIDIR_BIDIR_16x8:
        N = 20;
        break;

    case MBTYPE_BIDIR_BIDIR_8x16:
        N = 21;
        break;

    case MBTYPE_B_8x8:
        N = 22;
        break;

    default:
        N = -1;
        break;
    }
    if (m_PicParamSet.entropy_coding_mode)
    {
        MB_Type uMBType = m_pCurrentFrame->pMBData[uMB].uMBType;
        int uLeftMBType = Get_Left_Value(uMB,m_pCurrentFrame->pMBData[uMB-1].uMBType,NUMBER_OF_MBTYPES);
        int uTopMBType = Get_Top_Value(uMB,m_pCurrentFrame->pMBData[uMB-uWidthInMBs].uMBType,NUMBER_OF_MBTYPES);
        m_pbitstream->MBTypeInfo_CABAC(m_SliceHeader.slice_type,N,(MB_Type)uMBType,(MB_Type)uLeftMBType,(MB_Type)uTopMBType);
    }
    else
        length = m_pbitstream->PutVLCCode(N);
    if (uMBType == MBTYPE_B_8x8) {
        // for each of the 8x8 blocks
        for (Ipp32u block=0; block<4; block++) {
            SB_Type sb_type;
            sb_type = m_pCurrentFrame->pMBData[uMB].SBType[block];

            switch (sb_type) {

                case SBTYPE_DIRECT:
                    N = 0;
                    break;

                case SBTYPE_FORWARD_8x8:
                    N = 1;
                    break;

                case SBTYPE_BACKWARD_8x8:
                    N = 2;
                    break;

                case SBTYPE_BIDIR_8x8:
                    N = 3;
                    break;

                case SBTYPE_FORWARD_8x4:
                    N = 4;
                    break;

                case SBTYPE_FORWARD_4x8:
                    N = 5;
                    break;

                case SBTYPE_BACKWARD_8x4:
                    N = 6;
                    break;

                case SBTYPE_BACKWARD_4x8:
                    N = 7;
                    break;

                case SBTYPE_BIDIR_8x4:
                    N = 8;
                    break;

                case SBTYPE_BIDIR_4x8:
                    N = 9;
                    break;

                case SBTYPE_FORWARD_4x4:
                    N = 10;
                    break;

                case SBTYPE_BACKWARD_4x4:
                    N = 11;
                    break;

                case SBTYPE_BIDIR_4x4:
                    N = 12;
                    break;

                default:    // Unknown SBTYPE!
                    break;
            }