umc_h264_dec_mblevel_calc.cpp

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

/*
//
//              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) 2003-2005 Intel Corporation. All Rights Reserved.
//
//
*/
#include "umc_h264_dec.h"
#include "umc_h264_bitstream.h"
using namespace UMC_H264_DECODER;
namespace UMC
{
Ipp32s H264VideoDecoder::CorrectAddrForMBAFF(Ipp32s MbAddr)
{
    if (MbAddr<=0) return MbAddr;
    Ipp32s width_in_mbs = mb_width;
    Ipp32s mb_y = (MbAddr*2)/(2*width_in_mbs);
    Ipp32s mb_x = (MbAddr*2)%(2*width_in_mbs);
    Ipp32s bottom_mb = mb_x&1;
    mb_x>>=1;//real mb_x
    return (mb_y*2+bottom_mb)*width_in_mbs+mb_x;
}
Ipp32s H264VideoDecoder::MBAddr2MBCount(Ipp32s MbAddr)
{
    if (MbAddr<=0) return MbAddr;
    if (m_CurSliceHeader.MbaffFrameFlag==1)
    {
        Ipp32s width_in_mbs = mb_width;
        Ipp32s mb_y = (MbAddr)/(width_in_mbs);
        Ipp32s mb_x = (MbAddr)%(width_in_mbs);
        return (mb_y/2)*width_in_mbs*2+mb_x*2+(mb_y&1);
    }
    else if (m_pCurrentFrame->m_PictureStructureForDec<2)
    {
        return MbAddr-m_pCurrentFrame->totalMBs*m_field_index;
    }
    else
        return MbAddr;

}
Ipp32s H264VideoDecoder::CorrectAddrFromMBAFF(Ipp32s MbAddr)
{
    if (MbAddr<=0) return MbAddr;
    Ipp32s width_in_mbs = mb_width;
    Ipp32s mb_y = (MbAddr)/(width_in_mbs);
    Ipp32s mb_x = (MbAddr)%(width_in_mbs);
    return (mb_y/2)*width_in_mbs*2+mb_x*2+(mb_y&1);
}
Ipp32s H264VideoDecoder::GetColocatedLocation(
       H264DecoderFrame *pRefFrame,
       Ipp8u Field,
       Ipp32s& block,Ipp8s *scale)
{
    Ipp32u cur_pic_struct=m_pCurrentFrame->m_PictureStructureForDec;
    Ipp32u ref_pic_struct=pRefFrame->m_PictureStructureForDec;
    Ipp32s xCol=block&3;
    Ipp32s yCol=block-xCol;
    //Ipp32s mb_width = pRefFrame->macroBlockSize().width;

    if (cur_pic_struct==FRM_STRUCTURE && ref_pic_struct==FRM_STRUCTURE)
    {
        if(scale) *scale=0;
        return m_CurMBAddr;
    }
    else if (cur_pic_struct==AFRM_STRUCTURE && ref_pic_struct==AFRM_STRUCTURE)
    {
        Ipp32s preColMBAddr=m_CurMBAddr;
        H264DecoderMacroblockGlobalInfo *preColMB = &pRefFrame->m_mbinfo.mbs[preColMBAddr];
        int cur_mbfdf = pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
        int ref_mbfdf = pGetMBFieldDecodingFlag(preColMB);

        if (cur_mbfdf==ref_mbfdf)
        {
            if(scale) *scale=0;
            return m_CurMBAddr;
        }
        else if (cur_mbfdf>ref_mbfdf) //current - field reference - frame
        {
            if (pGetMBBottomFlag(preColMB))
            {
                preColMBAddr-=mb_width;//get pair
                if (yCol>=8)
                    preColMBAddr+=mb_width;//get pair again
            }
            else
            {
                if (yCol>=8)
                    preColMBAddr+=mb_width;//get pair
            }
            yCol*=2;
            yCol&=15;
            if(scale) *scale=1;
        }
        else
        {
            if (pGetMBBottomFlag(preColMB))
            {
                Ipp32s curPOC = m_pCurrentFrame->PicOrderCnt(0,3);
                Ipp32s topPOC = pRefFrame->PicOrderCnt(0,1);
                Ipp32s bottomPOC = pRefFrame->PicOrderCnt(1,1);

                preColMBAddr-=mb_width;//get pair
                if (abs(curPOC-topPOC)>=abs(curPOC-bottomPOC))
                    preColMBAddr+=mb_width;//get pair again
            }
            else
            {
                if (pRefFrame->PicOrderCnt(0,1)>=pRefFrame->PicOrderCnt(1,1))
                    preColMBAddr+=mb_width;//get pair
            }
            yCol=pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo)*8+4*(yCol/8);
            if(scale) *scale=-1;
        }
        block=yCol+xCol;
        return preColMBAddr;


    }
    else if (cur_pic_struct==FLD_STRUCTURE && ref_pic_struct==FLD_STRUCTURE)
    {
        if(scale) *scale=0;
        Ipp32s RefField = pRefFrame->GetNumberByParity(Field);

        if(RefField>m_field_index)
        {
            return(m_CurMBAddr + m_pCurrentFrame->totalMBs);
        }
        if(RefField<m_field_index)
        {
            return(m_CurMBAddr - m_pCurrentFrame->totalMBs);
        }
        else
        {
            return(m_CurMBAddr);
        }
    }
    else if (cur_pic_struct==FLD_STRUCTURE && ref_pic_struct==FRM_STRUCTURE)
    {
        Ipp32u PicWidthInMbs =m_pCurrentFrame->macroBlockSize().width;
        Ipp32u CurrMbAddr = m_field_index?m_CurMBAddr-m_pCurrentFrame->totalMBs:m_CurMBAddr;
        if(scale) *scale=1;
        yCol=((2*yCol)&15);
        block=yCol+xCol;
        return 2*PicWidthInMbs*(CurrMbAddr/PicWidthInMbs)+(CurrMbAddr%PicWidthInMbs)+PicWidthInMbs*(yCol/8);

    }
    else if (cur_pic_struct==FRM_STRUCTURE && ref_pic_struct==FLD_STRUCTURE)
    {
        if(scale) *scale=-1;
        //Ipp32s RefFieldBottom = -pRefFrame->GetNumberByParity(Field);
        Ipp32u PicWidthInMbs=m_pCurrentFrame->macroBlockSize().width;
        Ipp32u CurrMbAddr = m_CurMBAddr;
        yCol = 8*((CurrMbAddr/PicWidthInMbs)&1) + 4 * (yCol/8);
        block=yCol+xCol;
        return (PicWidthInMbs*(CurrMbAddr/(2*PicWidthInMbs))+(CurrMbAddr%PicWidthInMbs))/*+
            (pRefFrame->totalMBs&RefFieldBottom)*/;
    }
    else if (cur_pic_struct==FLD_STRUCTURE && ref_pic_struct==AFRM_STRUCTURE)
    {
        Ipp32u CurrMbAddr = m_CurMBAddr;
        if (m_field_index) CurrMbAddr-=m_pCurrentFrame->totalMBs;
        Ipp8u bottom_field_flag = m_pCurrentFrame->m_bottom_field_flag[m_field_index];
        Ipp32s preColMBAddr=CorrectAddrForMBAFF(CurrMbAddr);
        H264DecoderMacroblockGlobalInfo *preColMB = &pRefFrame->m_mbinfo.mbs[preColMBAddr];
        Ipp8u col_mbfdf = pGetMBFieldDecodingFlag(preColMB);

        if (!col_mbfdf)
        {
            if (yCol>8)
                preColMBAddr+=mb_width;
            yCol=((2*yCol)&15);
            if(scale) *scale=1;
        }
        else
        {
            if (bottom_field_flag)
                preColMBAddr+=mb_width;
            if(scale) *scale=0;
        }
        block=yCol+xCol;
        return preColMBAddr;
    }
    else if (cur_pic_struct==AFRM_STRUCTURE && ref_pic_struct==FLD_STRUCTURE)
    {
        Ipp32u CurrMbAddr = m_CurMBAddr;
        Ipp32s preColMBAddr=CurrMbAddr;


        Ipp8u cur_mbfdf = pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
        Ipp8u cur_mbbf = pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo);
        Ipp32s curPOC = m_pCurrentFrame->PicOrderCnt(0,3);
        Ipp32s topPOC = pRefFrame->PicOrderCnt(0,1);
        Ipp32s bottomPOC = pRefFrame->PicOrderCnt(1,1);

        Ipp8u bottom_field_flag = cur_mbfdf?pRefFrame->GetNumberByParity(cur_mbbf):pRefFrame->GetNumberByParity(
            abs(curPOC-topPOC)>=abs(curPOC-bottomPOC));
        if (cur_mbbf)
                preColMBAddr-=mb_width;
        preColMBAddr = CorrectAddrFromMBAFF(preColMBAddr)/2;

        if (!cur_mbfdf)
        {
            yCol=8*cur_mbbf+4*(yCol/8);
            if(scale) *scale=-1;
        }
        else
        {
            if(scale) *scale=0;
        }
        block=yCol+xCol;
        VM_ASSERT(preColMBAddr+(bottom_field_flag)*pRefFrame->totalMBs<m_pCurrentFrame->totalMBs);
        return preColMBAddr+(bottom_field_flag)*pRefFrame->totalMBs;
    }
    VM_ASSERT(0);
    return -1;
}
Status H264VideoDecoder::AdjustIndex(Ipp8u ref_mb_is_bottom,Ipp8s ref_mb_is_field,Ipp8s& RefIdx)
{

    Status ps=UMC_OK;
    if (RefIdx<0)
    {
        RefIdx=0;
        return ps;
    }
        if (ref_mb_is_field) //both are AFRM
        {
            Ipp8s cur_mb_is_bottom = pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo);
            Ipp8s cur_mb_is_field = pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
            if (cur_mb_is_field)
            {
                bool same_parity = (((RefIdx&1) ^ ref_mb_is_bottom) == cur_mb_is_bottom);
                if (same_parity)
                {
                    RefIdx&=-2;
                }
                else
                {
                    RefIdx|=1;
                }
            }
            else if (m_pCurrentFrame->m_PictureStructureForDec!=AFRM_STRUCTURE)
            {
                RefIdx>>=1;
            }
        }
    return ps;
}


void H264VideoDecoder::GetLeftLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
        //luma
    if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        Block->block_num+=3;
        Block->mb_num=m_cur_mb.CurrentMacroblockNeighbours.mb_A;
    }
    else
    {
        Block->block_num--;
        Block->mb_num=m_CurMBAddr;
    }
    return;
}
void H264VideoDecoder::GetLeftLocationForCurrentMBChromaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //chroma
    if (CHROMA_BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        Block->block_num+=1;
        Block->mb_num=m_cur_mb.CurrentMacroblockNeighbours.mb_A;
    }
    else
    {
        Block->block_num--;
        Block->mb_num=m_CurMBAddr;
    }
    return;
}
void H264VideoDecoder::GetLeftLocationForCurrentMBLumaMBAFF(H264DecoderBlockLocation *Block,Ipp32s AdditionalDecrement)
{
    bool curmbfff = !pGetMBFieldDecodingFlag(m_cur_mb.GlobalMacroblockInfo);
    bool curmbtf  = !pGetMBBottomFlag(m_cur_mb.GlobalMacroblockInfo);
    //Ipp32s mb_width = m_pCurrentFrame->macroBlockSize().width;
    Ipp32s MB_X=m_cur_mb.CurrentMacroblockNeighbours.mb_A;
    Ipp32s MB_N;
        //luma
    if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        if (MB_X>=0)
        {
            Ipp8u xfff=!GetMBFieldDecodingFlag(m_pCurrentFrame->m_mbinfo.mbs[MB_X]);
            if (curmbfff)
            {
                if (curmbtf)
                {
                    if (xfff)
                    {
                        // 1 1 1
                        MB_N=MB_X;
                    }
                    else
                    {
                        // 1 1 0
                        Ipp32u yN = Block->block_num/4;
                        yN*=4;
                        yN-=AdditionalDecrement;
                        yN/=2;
                        Block->block_num=(yN/4)*4;
                        if (AdditionalDecrement)
                            MB_N=MB_X  + mb_width;
                        else
                            MB_N=MB_X;
                        AdditionalDecrement=0;
                    }
                }
                else
                {
                    if (xfff)
                    {
                        // 1 0 1
                        MB_N=MB_X + mb_width;
                    }
                    else
                    {
                        // 1 0 0
                        Ipp32u yN = Block->block_num/4;
                        yN*=4;
                        yN-=AdditionalDecrement;
                        yN+=16;
                        yN/=2;
                        Block->block_num=(yN/4)*4;
                        if (AdditionalDecrement)
                            MB_N=MB_X + mb_width;
                        else
                            MB_N=MB_X;
                        AdditionalDecrement=0;
                    }
                }
            }
            else
            {
                if (curmbtf)
                {
                    if (xfff)
                    {
                        //0 1 1
                        Ipp32u yN = Block->block_num/4;
                        yN*=4;
                        yN-=AdditionalDecrement;
                        yN*=2;
                        if (yN<16)
                        {
                            MB_N=MB_X;
                        }
                        else
                        {
                            yN-=16;
                            MB_N=MB_X + mb_width;
                        }
                        Block->block_num=(yN/4)*4;
                        AdditionalDecrement=0;
                    }
                    else
                    {
                        // 0 1 0
                        MB_N=MB_X;
                    }
                }
                else
                {
                    if (xfff)
                    {
                        // 0 0 1
                        Ipp32u yN = Block->block_num/4;
                        yN*=4;
                        yN-=AdditionalDecrement;
                        yN*=2;
                        if (yN<15)
                        {
                            yN++;
                            MB_N=MB_X;
                        }
                        else
                        {
                            yN-=15;
                            MB_N=MB_X + mb_width;
                        }
                        Block->block_num=(yN/4)*4;
                        AdditionalDecrement=0;
                    }
                    else
                    {
                        // 0 0 0
                        MB_N=MB_X + mb_width;
                    }
                }
            }
        }
        else
        {
            Block->mb_num = -1;//no left neighbours
            return;
        }
        Block->block_num+=3-4*AdditionalDecrement;
        Block->mb_num = MB_N;
    }
    else
    {