umc_h264_dec.h

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

        // Perform deblocking on whole frame.
        // It is possible only for Baseline profile.
        void DeblockFrame(Ipp32u uFirstMB,Ipp32u uNumMBs);
        // Perform deblocking on single slice
        void DeblockSlice(Ipp32u uFirstMB, Ipp32u uNumMBs, bool bLastSlice = false);
        // Non-optimized deblocking function
        void DeblockMacroblockCommon(Ipp32u MBAddr);

        //
        // Optimized deblocking functions
        //

        // Reset deblocking variables
        void ResetDeblockingVariables(DeblockingParameters *pParams);
        void ResetDeblockingVariablesMBAFF(DeblockingParametersMBAFF *pParams);
        // Function to do luma deblocking
        void DeblockLuma(Ipp32u dir, DeblockingParameters *pParams);
        void DeblockLumaVerticalMBAFF(DeblockingParametersMBAFF *pParams);
        void DeblockLumaHorizontalMBAFF(DeblockingParametersMBAFF *pParams);
        // Function to do chroma deblocking
        void DeblockChroma(Ipp32u dir, DeblockingParameters *pParams);
        void DeblockChromaVerticalMBAFF(DeblockingParametersMBAFF *pParams);
        void DeblockChromaHorizontalMBAFF(DeblockingParametersMBAFF *pParams);
        // Function to prepare deblocking parameters for mixed MB types
        void DeblockMacroblockMSlice(Ipp32u MBAddr);

        //
        // Function to do deblocking on I slices
        //

        void DeblockMacroblockISlice(Ipp32u MBAddr);
        void PrepareDeblockingParametersISlice(DeblockingParameters *pParams);
        void DeblockMacroblockISliceMBAFF(Ipp32u MBAddr);
        void PrepareDeblockingParametersISliceMBAFF(DeblockingParametersMBAFF *pParams);

        //
        // Function to do deblocking on P slices
        //

        void DeblockMacroblockPSlice(Ipp32u MBAddr);
        void DeblockMacroblockPSliceMBAFF(Ipp32u MBAddr);
        void PrepareDeblockingParametersPSlice(DeblockingParameters *pParams);
        void PrepareDeblockingParametersPSliceMBAFF(DeblockingParametersMBAFF *pParams);
        // Prepare deblocking parameters for macroblocks from P slice
        // MbPart is 16, MbPart of opposite direction is 16
        void PrepareDeblockingParametersPSlice16(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblocks from P slice
        // MbPart is 8, MbPart of opposite direction is 16
        void PrepareDeblockingParametersPSlice8x16(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblocks from P slice
        // MbPart is 16, MbPart of opposite direction is 8
        void PrepareDeblockingParametersPSlice16x8(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblocks from P slice
        // MbParts of both directions are 4
        void PrepareDeblockingParametersPSlice4(Ipp32u dir, DeblockingParameters *pParams);
        void PrepareDeblockingParametersPSlice4MBAFFField(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblock from P slice,
        // which coded in frame mode, but above macroblock is coded in field mode
        void PrepareDeblockingParametersPSlice4MBAFFMixedExternalEdge(DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblock from P slice,
        // which coded in frame mode, but left macroblock is coded in field mode
        void PrepareDeblockingParametersPSlice4MBAFFComplexFrameExternalEdge(DeblockingParametersMBAFF *pParams);
        // Prepare deblocking parameters for macroblock from P slice,
        // which coded in field mode, but left macroblock is coded in frame mode
        void PrepareDeblockingParametersPSlice4MBAFFComplexFieldExternalEdge(DeblockingParametersMBAFF *pParams);

        //
        // Function to do deblocking on B slices
        //

        void DeblockMacroblockBSlice(Ipp32u MBAddr);
        void DeblockMacroblockBSliceMBAFF(Ipp32u MBAddr);
        void PrepareDeblockingParametersBSlice(DeblockingParameters *pParams);
        void PrepareDeblockingParametersBSliceMBAFF(DeblockingParametersMBAFF *pParams);
        // Prepare deblocking parameters for macroblocks from B slice
        // MbPart is 16, MbPart of opposite direction is 16
        void PrepareDeblockingParametersBSlice16(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblocks from B slice
        // MbPart is 8, MbPart of opposite direction is 16
        void PrepareDeblockingParametersBSlice8x16(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblocks from B slice
        // MbPart is 16, MbPart of opposite direction is 8
        void PrepareDeblockingParametersBSlice16x8(Ipp32u dir, DeblockingParameters *pParams);
        // Prepare deblocking parameters for macroblocks from B slice
        // MbParts of both directions are 4
        void PrepareDeblockingParametersBSlice4(Ipp32u dir, DeblockingParameters *pParams);
        void PrepareDeblockingParametersBSlice4MBAFFField(Ipp32u dir, DeblockingParameters *pParams);

       // Multitreaded deblocking tools
        H264ThreadedDeblockingTools *m_pThreadedDeblockingTools;

        // Update limited slice info array
        Status UpdateLimitedSliceInfo(H264SliceHeader *pHeader);
        Ipp32u m_nAllocatedLimitedSliceInfo;
        H264LimitedSliceHeader *m_pLimitedSliceInfo;


//        Status        DeblockSegmentIP(Ipp32u uFirstMB, Ipp32u unumMBs);
        //Status        DeblockSegmentIP00(Ipp32u uFirstMB, Ipp32u unumMBs);
        // Reconstruct into m_pCurrentFrame.
        Status      UpdateRefPicList(
                           H264SliceHeader SHdr,
                           RefPicListReorderInfo *pReorderInfo_L0,
                           RefPicListReorderInfo *pReorderInfo_L1,
                           Ipp32u uSliceNum);
            // Called after decoding a slice header to update the reference
            // picture lists using information in the slice header.
        void            InitPSliceRefPicList(
                            bool bIsFieldSlice,
                            Ipp32s NumL0RefActive,
                            H264DecoderFrame **pRefPicList);

        void            InitBSliceRefPicLists(
                            bool bIsFieldSlice,
                            Ipp32s NumL0RefActive,
                            Ipp32s NumL1RefActive,
                            H264DecoderFrame **pRefPicList0,
                            H264DecoderFrame **pRefPicList1);

        void            ReOrderRefPicList(
                            bool bIsFieldSlice,
                            H264DecoderFrame **pRefPicList,
                            Ipp8s  *pFields,
                            RefPicListReorderInfo *pReorderInfo,
                            Ipp32s uMaxPicNum,
                            Ipp32s uNumRefActive);

        void            AdjustRefPicListForFields(
                            H264DecoderFrame **pRefPicList,
                            Ipp8s *pFields);

        void                ProcessFrameNumGap();

        void            InitDistScaleFactor(
                            Ipp32s NumL0RefActive,
                            H264DecoderFrame **pRefPicList0,
                            H264DecoderFrame **pRefPicList1,
                            Ipp8s       *pFields0,
                            Ipp8s       *pFields1);
            // Called after decoding a slice header to initialize
            // m_CurSliceInfo.DistScaleFactor array.

        Status              UpdateRefPicMarking();
        void                DecodePictureOrderCount();
        Status              SetDPBSize();
            // After decoding a frame, updates marking of reference pictures
            // in decoded frame buffer.

        Status              SetMBMap();
            // Initialize MB ordering for the picture using slice groups as
            // defined in the picture parameter set.


        void                ResetGMBData();

        Status      DecodeIntraTypes4x4_CAVLC( Ipp32u *pMBIntraTypes,bool bUseConstrainedIntra);
        Status      DecodeIntraTypes8x8_CAVLC( Ipp32u *pMBIntraTypes,bool bUseConstrainedIntra);

        // Decode the intra-coding type for each subblock in the given
        // macroblock, storing the results in pMBIntraTypes.
        Status      DecodeIntraTypes4x4_CABAC(Ipp32u *pMBIntraTypes,bool bUseConstrainedIntra);
        Status      DecodeIntraTypes8x8_CABAC(Ipp32u *pMBIntraTypes,bool bUseConstrainedIntra);

        // Decode and return the coded block pattern.
        // Return 255 is there is an error in the CBP.
        Ipp8u       DecodeCBP_CAVLC        (Ipp32u mbtype,Ipp8u color_format);

        Status       DecodeMacroBlockType(
                                            Ipp32u *pMBIntraTypes,
                                            Ipp32s *MBSkipCount,
                                            Ipp32s *PassFDFDecode
                                            );
        Status DecodeMBType_CABAC(
                                  Ipp32u *pMBIntraTypes,
                                  Ipp32u *MBSkipFlag,
                                  bool skip_next_fdf);
        void DecodeMBSkipAndFDF(Ipp32u *MBSkipFlag, bool bIsBSlice);


        Status DecodeMotionVectors_CABAC();
        Status GetRefIdx4x4_CABAC(const Ipp32u nActive,
                                   Ipp32u* pBlkIdx,
                                   Ipp32u* pCodRIx,
                                   Ipp32s ListNum
                                   );
        Status GetMVD4x4_CABAC(
                                Ipp32u* pBlkIdx,
                                Ipp32u* pCodMVd,
                                Ipp32s ListNum
                                );

        Ipp32s GetSE_RefIdx_CABAC(
                                  Ipp32s ListNum,
                                  Ipp32s BlockNum
                                  );
        H264DecoderMotionVector GetSE_MVD_CABAC(
                                                Ipp32s ListNum,
                                                Ipp32s BlockNum
                                                );


        void        GetDirectTemporalMV    (
                                            Ipp32s MBCol,
                                            Ipp32u ipos,
                                            H264DecoderFrame **pRefPicList0,
                                            H264DecoderFrame **pRefPicList1,
                                            H264DecoderMotionVector &MVL0,    // return colocated MV here
                                            Ipp8s &RefIndexL0                        // return ref index here
                                            );
        void        GetDirectTemporalMVFLD  (
                                            Ipp32s MBCol,
                                            Ipp32u ipos,
                                            H264DecoderFrame **pRefPicList0,
                                            H264DecoderFrame **pRefPicList1,
                                            Ipp8s         *pFields0,
                                            Ipp8s         *pFields1,
                                            H264DecoderMotionVector &MVL0,    // return colocated MV here
                                            Ipp8s &RefIndexL0                        // return ref index here
                                            );
        void        GetDirectTemporalMVMBAFF    (
                                            Ipp32s MBCol,
                                            Ipp32u ipos,
                                            H264DecoderFrame **pRefPicList0,
                                            H264DecoderFrame **pRefPicList1,
                                            H264DecoderMotionVector &MVL0,    // return colocated MV here
                                            Ipp8s &RefIndexL0                        // return ref index here
                                            );
        void        ComputeMotionVectorPredictors(
                                                  Ipp8u ListNum,
                                                  Ipp8s RefIndex,    // reference index for this part
                                                  Ipp32s block,    // block or subblock number, depending on mbtype
                                                  Ipp32s *pMVx,    // resulting MV predictors
                                                  Ipp32s *pMVy
                                            );
        void        DecodeDirectMotionVectorsTemporal(
                                            Ipp32u sboffset,        // offset into MV and RefIndex storage
                                            H264DecoderFrame **pRefPicList0,
                                            H264DecoderFrame **pRefPicList1,
                                            Ipp8s *pFields0,
                                            Ipp8s *pFields1,
                                            bool bIs8x8);

        void        DecodeDirectMotionVectorsTemporal_8x8Inference(
                                            H264DecoderFrame **pRefPicList0,
                                            H264DecoderFrame **pRefPicList1,
                                            Ipp8s *pFields0,
                                            Ipp8s *pFields1,
                                            Ipp32s iWhich8x8);        // 0..3 if 8x8 block; -1 if 16x16
        Status      AdjustIndex             (
                                             Ipp8u ref_mb_is_bottom,
                                             Ipp8s ref_mb_is_field,
                                             Ipp8s& RefIdx);
        void        ComputeDirectSpatialRefIdx(
                                            Ipp8s *pRefIndexL0,    // neighbor RefIdx relative to this, forward result here
                                            Ipp8s *pRefIndexL1        // neighbor RefIdx relative to this, backward result here
                                            );
        Ipp32s      GetColocatedMB        (H264DecoderFrame *pRefFrame,Ipp8u   Field,
                                            Ipp32s& block,Ipp8s *scale=NULL);
        Ipp32s      GetColocatedLocation     (H264DecoderFrame *pRefFrame,
                                                Ipp8u   Field,
                                                Ipp32s& block,Ipp8s *scale=NULL);
        Ipp32s      CorrectAddrForMBAFF(Ipp32s MbAddr);
        Ipp32s      MBAddr2MBCount(Ipp32s MbAddr);
        Ipp32s      CorrectAddrFromMBAFF(Ipp32s MbAddr);