TComDataCU

/** \file TComDataCU.h \brief CU data structure (header) \todo not all entities are documented*/#ifndef _TCOMDATACU_#define _TCOMDATACU_#include <assert h="">// Include files#include "CommonDef.h"#include "TComMotionInfo.h"#include "TComSlice.h"#include "TComRdCost.h"#include "TComPattern.h"#include <algorithm>#include <vector>//! \ingroup TLibCommon//! \{// ====================================================================================================================// Non-deblocking in-loop filter processing block data structure// ====================================================================================================================/// Non-deblocking filter processing block border tagenum NDBFBlockBorderTag{ SGU_L = 0, SGU_R, SGU_T, SGU_B, SGU_TL, SGU_TR, SGU_BL, SGU_BR, NUM_SGU_BORDER};/// Non-deblocking filter processing block informationstruct NDBFBlockInfo{ Int tileID; //!< tile ID Int sliceID; //!< slice ID UInt startSU; //!< starting SU z-scan address in LCU UInt endSU; //!< ending SU z-scan address in LCU UInt widthSU; //!< number of SUs in width UInt heightSU; //!< number of SUs in height UInt posX; //!< top-left X coordinate in picture UInt posY; //!< top-left Y coordinate in picture UInt width; //!< number of pixels in width UInt height; //!< number of pixels in height Bool isBorderAvailable[NUM_SGU_BORDER]; //!< the border availabilities Bool allBordersAvailable; NDBFBlockInfo():tileID(0), sliceID(0), startSU(0), endSU(0) {} //!< constructor const NDBFBlockInfo& operator= (const NDBFBlockInfo& src); //!< "=" operator};// ====================================================================================================================// Class definition// ====================================================================================================================/// CU data structure classclass TComDataCU{private: // ------------------------------------------------------------------------------------------------------------------- // class pointers // ------------------------------------------------------------------------------------------------------------------- TComPic* m_pcPic; ///< picture class pointer TComSlice* m_pcSlice; ///< slice header pointer TComPattern* m_pcPattern; ///< neighbour access class pointer // ------------------------------------------------------------------------------------------------------------------- // CU description // ------------------------------------------------------------------------------------------------------------------- UInt m_uiCUAddr; ///< CU address in a slice UInt m_uiAbsIdxInLCU; ///< absolute address in a CU. It's Z scan order UInt m_uiCUPelX; ///< CU position in a pixel (X) 这个是在整幅图像中的坐标。 UInt m_uiCUPelY; ///< CU position in a pixel (Y) UInt m_uiNumPartition; ///< total number of minimum partitions in a CU UChar* m_puhWidth; ///< array of widths UChar* m_puhHeight; ///< array of heights UChar* m_puhDepth; ///< array of depths Int m_unitSize; ///< size of a "minimum partition" // ------------------------------------------------------------------------------------------------------------------- // CU data // ------------------------------------------------------------------------------------------------------------------- Bool* m_skipFlag; ///< array of skip flags Char* m_pePartSize; ///< array of partition sizes Char* m_pePredMode; ///< array of prediction modes Bool* m_CUTransquantBypass; ///< array of cu_transquant_bypass flags Char* m_phQP; ///< array of QP values UChar* m_puhTrIdx; ///< array of transform indices UChar* m_puhTransformSkip[3];///< array of transform skipping flags UChar* m_puhCbf[3]; ///< array of coded block flags (CBF) TComCUMvField m_acCUMvField[2]; ///< array of motion vectors TCoeff* m_pcTrCoeffY; ///< transformed coefficient buffer (Y) TCoeff* m_pcTrCoeffCb; ///< transformed coefficient buffer (Cb) TCoeff* m_pcTrCoeffCr; ///< transformed coefficient buffer (Cr)#if ADAPTIVE_QP_SELECTION Int* m_pcArlCoeffY; ///< ARL coefficient buffer (Y) Int* m_pcArlCoeffCb; ///< ARL coefficient buffer (Cb) Int* m_pcArlCoeffCr; ///< ARL coefficient buffer (Cr) Bool m_ArlCoeffIsAliasedAllocation; ///< ARL coefficient buffer is an alias of the global buffer and must not be free()'d static Int* m_pcGlbArlCoeffY; ///< ARL coefficient buffer (Y) static Int* m_pcGlbArlCoeffCb; ///< ARL coefficient buffer (Cb) static Int* m_pcGlbArlCoeffCr; ///< ARL coefficient buffer (Cr)#endif Pel* m_pcIPCMSampleY; ///< PCM sample buffer (Y) Pel* m_pcIPCMSampleCb; ///< PCM sample buffer (Cb) Pel* m_pcIPCMSampleCr; ///< PCM sample buffer (Cr) Int* m_piSliceSUMap; ///< pointer of slice ID map std::vector<ndbfblockinfo> m_vNDFBlock; // ------------------------------------------------------------------------------------------------------------------- // neighbour access variables // ------------------------------------------------------------------------------------------------------------------- TComDataCU* m_pcCUAboveLeft; ///< pointer of above-left CU TComDataCU* m_pcCUAboveRight; ///< pointer of above-right CU TComDataCU* m_pcCUAbove; ///< pointer of above CU TComDataCU* m_pcCULeft; ///< pointer of left CU TComDataCU* m_apcCUColocated[2]; ///< pointer of temporally colocated CU's for both directions TComMvField m_cMvFieldA; ///< motion vector of position A TComMvField m_cMvFieldB; ///< motion vector of position B TComMvField m_cMvFieldC; ///< motion vector of position C TComMv m_cMvPred; ///< motion vector predictor // ------------------------------------------------------------------------------------------------------------------- // coding tool information // ------------------------------------------------------------------------------------------------------------------- Bool* m_pbMergeFlag; ///< array of merge flags UChar* m_puhMergeIndex; ///< array of merge candidate indices#if AMP_MRG Bool m_bIsMergeAMP;#endif UChar* m_puhLumaIntraDir; ///< array of intra directions (luma) UChar* m_puhChromaIntraDir; ///< array of intra directions (chroma) UChar* m_puhInterDir; ///< array of inter directions Char* m_apiMVPIdx[2]; ///< array of motion vector predictor candidates Char* m_apiMVPNum[2]; ///< array of number of possible motion vectors predictors Bool* m_pbIPCMFlag; ///< array of intra_pcm flags // ------------------------------------------------------------------------------------------------------------------- // misc. variables // ------------------------------------------------------------------------------------------------------------------- Bool m_bDecSubCu; ///< indicates decoder-mode Double m_dTotalCost; ///< sum of partition RD costs UInt m_uiTotalDistortion; ///< sum of partition distortion UInt m_uiTotalBits; ///< sum of partition bits UInt m_uiTotalBins; ///< sum of partition bins UInt* m_sliceStartCU; ///< Start CU address of current slice UInt* m_sliceSegmentStartCU; ///< Start CU address of current slice Char m_codedQP;protected: /// add possible motion vector predictor candidates Bool xAddMVPCand ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir ); Bool xAddMVPCandOrder ( AMVPInfo* pInfo, RefPicList eRefPicList, Int iRefIdx, UInt uiPartUnitIdx, MVP_DIR eDir ); Void deriveRightBottomIdx ( UInt uiPartIdx, UInt& ruiPartIdxRB ); Bool xGetColMVP( RefPicList eRefPicList, Int uiCUAddr, Int uiPartUnitIdx, TComMv& rcMv, Int& riRefIdx ); /// compute required bits to encode MVD (used in AMVP) UInt xGetMvdBits ( TComMv cMvd ); UInt xGetComponentBits ( Int iVal ); /// compute scaling factor from POC difference Int xGetDistScaleFactor ( Int iCurrPOC, Int iCurrRefPOC, Int iColPOC, Int iColRefPOC ); Void xDeriveCenterIdx( UInt uiPartIdx, UInt& ruiPartIdxCenter );public: TComDataCU(); virtual ~TComDataCU(); // ------------------------------------------------------------------------------------------------------------------- // create / destroy / initialize / copy // ------------------------------------------------------------------------------------------------------------------- Void create ( UInt uiNumPartition, UInt uiWidth, UInt uiHeight, Bool bDecSubCu, Int unitSize#if ADAPTIVE_QP_SELECTION , Bool bGlobalRMARLBuffer = false#endif ); Void destroy (); Void initCU ( TComPic* pcPic, UInt uiCUAddr ); Void initEstData ( UInt uiDepth, Int qp ); Void initSubCU ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth, Int qp ); Void setOutsideCUPart ( UInt uiAbsPartIdx, UInt uiDepth ); Void copySubCU ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth ); Void copyInterPredInfoFrom ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList ); Void copyPartFrom ( TComDataCU* pcCU, UInt uiPartUnitIdx, UInt uiDepth ); Void copyToPic ( UChar uiDepth ); Void copyToPic ( UChar uiDepth, UInt uiPartIdx, UInt uiPartDepth ); // ------------------------------------------------------------------------------------------------------------------- // member functions for CU description // ------------------------------------------------------------------------------------------------------------------- TComPic* getPic () { return m_pcPic; } TComSlice* getSlice () { return m_pcSlice; } UInt& getAddr () { return m_uiCUAddr; } UInt& getZorderIdxInCU () { return m_uiAbsIdxInLCU; } UInt getSCUAddr (); UInt getCUPelX () { return m_uiCUPelX; } UInt getCUPelY () { return m_uiCUPelY; } TComPattern* getPattern () { return m_pcPattern; } UChar* getDepth () { return m_puhDepth; } UChar getDepth ( UInt uiIdx ) { return m_puhDepth[uiIdx]; } Void setDepth ( UInt uiIdx, UChar uh ) { m_puhDepth[uiIdx] = uh; } Void setDepthSubParts ( UInt uiDepth, UInt uiAbsPartIdx ); // ------------------------------------------------------------------------------------------------------------------- // member functions for CU data // ------------------------------------------------------------------------------------------------------------------- Char* getPartitionSize () { return m_pePartSize; } PartSize getPartitionSize ( UInt uiIdx ) { return static_cast<partsize>( m_pePartSize[uiIdx] ); } Void setPartitionSize ( UInt uiIdx, PartSize uh){ m_pePartSize[uiIdx] = uh; } Void setPartSizeSubParts ( PartSize eMode, UInt uiAbsPartIdx, UInt uiDepth ); Void setCUTransquantBypassSubParts( Bool flag, UInt uiAbsPartIdx, UInt uiDepth ); Bool* getSkipFlag () { return m_skipFlag; } Bool getSkipFlag (UInt idx) { return m_skipFlag[idx]; } Void setSkipFlag ( UInt idx, Bool skip) { m_skipFlag[idx] = skip; } Void setSkipFlagSubParts ( Bool skip, UInt absPartIdx, UInt depth ); Char* getPredictionMode () { return m_pePredMode; } PredMode getPredictionMode ( UInt uiIdx ) { return static_cast<predmode>( m_pePredMode[uiIdx] ); } Bool* getCUTransquantBypass () { return m_CUTransquantBypass; } Bool getCUTransquantBypass( UInt uiIdx ) { return m_CUTransquantBypass[uiIdx]; } Void setPredictionMode ( UInt uiIdx, PredMode uh){ m_pePredMode[uiIdx] = uh; } Void setPredModeSubParts ( PredMode eMode, UInt uiAbsPartIdx, UInt uiDepth ); UChar* getWidth () { return m_puhWidth; } UChar getWidth ( UInt uiIdx ) { return m_puhWidth[uiIdx]; } Void setWidth ( UInt uiIdx, UChar uh ) { m_puhWidth[uiIdx] = uh; } UChar* getHeight () { return m_puhHeight; } UChar getHeight ( UInt uiIdx ) { return m_puhHeight[uiIdx]; } Void setHeight ( UInt uiIdx, UChar uh ) { m_puhHeight[uiIdx] = uh; } Void setSizeSubParts ( UInt uiWidth, UInt uiHeight, UInt uiAbsPartIdx, UInt uiDepth ); Char* getQP () { return m_phQP; } Char getQP ( UInt uiIdx ) { return m_phQP[uiIdx]; } Void setQP ( UInt uiIdx, Char value ){ m_phQP[uiIdx] = value; } Void setQPSubParts ( Int qp, UInt uiAbsPartIdx, UInt uiDepth ); Int getLastValidPartIdx ( Int iAbsPartIdx ); Char getLastCodedQP ( UInt uiAbsPartIdx ); Void setQPSubCUs ( Int qp, TComDataCU* pcCU, UInt absPartIdx, UInt depth, Bool &foundNonZeroCbf ); Void setCodedQP ( Char qp ) { m_codedQP = qp; } Char getCodedQP () { return m_codedQP; } Bool isLosslessCoded(UInt absPartIdx); UChar* getTransformIdx () { return m_puhTrIdx; } UChar getTransformIdx ( UInt uiIdx ) { return m_puhTrIdx[uiIdx]; } Void setTrIdxSubParts ( UInt uiTrIdx, UInt uiAbsPartIdx, UInt uiDepth ); UChar* getTransformSkip ( TextType eType) { return m_puhTransformSkip[g_aucConvertTxtTypeToIdx[eType]];} UChar getTransformSkip ( UInt uiIdx,TextType eType) { return m_puhTransformSkip[g_aucConvertTxtTypeToIdx[eType]][uiIdx];} Void setTransformSkipSubParts ( UInt useTransformSkip, TextType eType, UInt uiAbsPartIdx, UInt uiDepth); Void setTransformSkipSubParts ( UInt useTransformSkipY, UInt useTransformSkipU, UInt useTransformSkipV, UInt uiAbsPartIdx, UInt uiDepth ); UInt getQuadtreeTULog2MinSizeInCU( UInt absPartIdx ); TComCUMvField* getCUMvField ( RefPicList e ) { return &m_acCUMvField[e]; } TCoeff*& getCoeffY () { return m_pcTrCoeffY; } TCoeff*& getCoeffCb () { return m_pcTrCoeffCb; } TCoeff*& getCoeffCr () { return m_pcTrCoeffCr; }#if ADAPTIVE_QP_SELECTION Int*& getArlCoeffY () { return m_pcArlCoeffY; } Int*& getArlCoeffCb () { return m_pcArlCoeffCb; } Int*& getArlCoeffCr () { return m_pcArlCoeffCr; }#endif Pel*& getPCMSampleY () { return m_pcIPCMSampleY; } Pel*& getPCMSampleCb () { return m_pcIPCMSampleCb; } Pel*& getPCMSampleCr () { return m_pcIPCMSampleCr; } UChar getCbf ( UInt uiIdx, TextType eType ) { return m_puhCbf[g_aucConvertTxtTypeToIdx[eType]][uiIdx]; } UChar* getCbf ( TextType eType ) { return m_puhCbf[g_aucConvertTxtTypeToIdx[eType]]; } UChar getCbf ( UInt uiIdx, TextType eType, UInt uiTrDepth ) { return ( ( getCbf( uiIdx, eType ) >> uiTrDepth ) & 0x1 ); } Void setCbf ( UInt uiIdx, TextType eType, UChar uh ) { m_puhCbf[g_aucConvertTxtTypeToIdx[eType]][uiIdx] = uh; } Void clearCbf ( UInt uiIdx, TextType eType, UInt uiNumParts ); UChar getQtRootCbf ( UInt uiIdx ) { return getCbf( uiIdx, TEXT_LUMA, 0 ) || getCbf( uiIdx, TEXT_CHROMA_U, 0 ) || getCbf( uiIdx, TEXT_CHROMA_V, 0 ); } Void setCbfSubParts ( UInt uiCbfY, UInt uiCbfU, UInt uiCbfV, UInt uiAbsPartIdx, UInt uiDepth ); Void setCbfSubParts ( UInt uiCbf, TextType eTType, UInt uiAbsPartIdx, UInt uiDepth ); Void setCbfSubParts ( UInt uiCbf, TextType eTType, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); // ------------------------------------------------------------------------------------------------------------------- // member functions for coding tool information // ------------------------------------------------------------------------------------------------------------------- Bool* getMergeFlag () { return m_pbMergeFlag; } Bool getMergeFlag ( UInt uiIdx ) { return m_pbMergeFlag[uiIdx]; } Void setMergeFlag ( UInt uiIdx, Bool b ) { m_pbMergeFlag[uiIdx] = b; } Void setMergeFlagSubParts ( Bool bMergeFlag, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); UChar* getMergeIndex () { return m_puhMergeIndex; } UChar getMergeIndex ( UInt uiIdx ) { return m_puhMergeIndex[uiIdx]; } Void setMergeIndex ( UInt uiIdx, UInt uiMergeIndex ) { m_puhMergeIndex[uiIdx] = uiMergeIndex; } Void setMergeIndexSubParts ( UInt uiMergeIndex, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); template <typename t=""> Void setSubPart ( T bParameter, T* pbBaseLCU, UInt uiCUAddr, UInt uiCUDepth, UInt uiPUIdx );#if AMP_MRG Void setMergeAMP( Bool b ) { m_bIsMergeAMP = b; } Bool getMergeAMP( ) { return m_bIsMergeAMP; }#endif UChar* getLumaIntraDir () { return m_puhLumaIntraDir; } UChar getLumaIntraDir ( UInt uiIdx ) { return m_puhLumaIntraDir[uiIdx]; } Void setLumaIntraDir ( UInt uiIdx, UChar uh ) { m_puhLumaIntraDir[uiIdx] = uh; } Void setLumaIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth ); UChar* getChromaIntraDir () { return m_puhChromaIntraDir; } UChar getChromaIntraDir ( UInt uiIdx ) { return m_puhChromaIntraDir[uiIdx]; } Void setChromaIntraDir ( UInt uiIdx, UChar uh ) { m_puhChromaIntraDir[uiIdx] = uh; } Void setChromIntraDirSubParts( UInt uiDir, UInt uiAbsPartIdx, UInt uiDepth ); UChar* getInterDir () { return m_puhInterDir; } UChar getInterDir ( UInt uiIdx ) { return m_puhInterDir[uiIdx]; } Void setInterDir ( UInt uiIdx, UChar uh ) { m_puhInterDir[uiIdx] = uh; } Void setInterDirSubParts ( UInt uiDir, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); Bool* getIPCMFlag () { return m_pbIPCMFlag; } Bool getIPCMFlag (UInt uiIdx ) { return m_pbIPCMFlag[uiIdx]; } Void setIPCMFlag (UInt uiIdx, Bool b ) { m_pbIPCMFlag[uiIdx] = b; } Void setIPCMFlagSubParts (Bool bIpcmFlag, UInt uiAbsPartIdx, UInt uiDepth); /// get slice ID for SU Int getSUSliceID (UInt uiIdx) {return m_piSliceSUMap[uiIdx]; } /// get the pointer of slice ID map Int* getSliceSUMap () {return m_piSliceSUMap; } /// set the pointer of slice ID map Void setSliceSUMap (Int *pi) {m_piSliceSUMap = pi; } std::vector<ndbfblockinfo>* getNDBFilterBlocks() {return &m_vNDFBlock;} Void setNDBFilterBlockBorderAvailability(UInt numLCUInPicWidth, UInt numLCUInPicHeight, UInt numSUInLCUWidth, UInt numSUInLCUHeight, UInt picWidth, UInt picHeight ,std::vector<bool>& LFCrossSliceBoundary ,Bool bTopTileBoundary, Bool bDownTileBoundary, Bool bLeftTileBoundary, Bool bRightTileBoundary ,Bool bIndependentTileBoundaryEnabled ); // ------------------------------------------------------------------------------------------------------------------- // member functions for accessing partition information // ------------------------------------------------------------------------------------------------------------------- Void getPartIndexAndSize ( UInt uiPartIdx, UInt& ruiPartAddr, Int& riWidth, Int& riHeight ); UChar getNumPartInter (); Bool isFirstAbsZorderIdxInDepth (UInt uiAbsPartIdx, UInt uiDepth); // ------------------------------------------------------------------------------------------------------------------- // member functions for motion vector // ------------------------------------------------------------------------------------------------------------------- Void getMvField ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefPicList, TComMvField& rcMvField ); Void fillMvpCand ( UInt uiPartIdx, UInt uiPartAddr, RefPicList eRefPicList, Int iRefIdx, AMVPInfo* pInfo ); Bool isDiffMER ( Int xN, Int yN, Int xP, Int yP); Void getPartPosition ( UInt partIdx, Int& xP, Int& yP, Int& nPSW, Int& nPSH); Void setMVPIdx ( RefPicList eRefPicList, UInt uiIdx, Int iMVPIdx) { m_apiMVPIdx[eRefPicList][uiIdx] = iMVPIdx; } Int getMVPIdx ( RefPicList eRefPicList, UInt uiIdx) { return m_apiMVPIdx[eRefPicList][uiIdx]; } Char* getMVPIdx ( RefPicList eRefPicList ) { return m_apiMVPIdx[eRefPicList]; } Void setMVPNum ( RefPicList eRefPicList, UInt uiIdx, Int iMVPNum ) { m_apiMVPNum[eRefPicList][uiIdx] = iMVPNum; } Int getMVPNum ( RefPicList eRefPicList, UInt uiIdx ) { return m_apiMVPNum[eRefPicList][uiIdx]; } Char* getMVPNum ( RefPicList eRefPicList ) { return m_apiMVPNum[eRefPicList]; } Void setMVPIdxSubParts ( Int iMVPIdx, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); Void setMVPNumSubParts ( Int iMVPNum, RefPicList eRefPicList, UInt uiAbsPartIdx, UInt uiPartIdx, UInt uiDepth ); Void clipMv ( TComMv& rcMv ); Void getMvPredLeft ( TComMv& rcMvPred ) { rcMvPred = m_cMvFieldA.getMv(); } Void getMvPredAbove ( TComMv& rcMvPred ) { rcMvPred = m_cMvFieldB.getMv(); } Void getMvPredAboveRight ( TComMv& rcMvPred ) { rcMvPred = m_cMvFieldC.getMv(); } Void compressMV (); // ------------------------------------------------------------------------------------------------------------------- // utility functions for neighbouring information // ------------------------------------------------------------------------------------------------------------------- TComDataCU* getCULeft () { return m_pcCULeft; } TComDataCU* getCUAbove () { return m_pcCUAbove; } TComDataCU* getCUAboveLeft () { return m_pcCUAboveLeft; } TComDataCU* getCUAboveRight () { return m_pcCUAboveRight; } TComDataCU* getCUColocated ( RefPicList eRefPicList ) { return m_apcCUColocated[eRefPicList]; } TComDataCU* getPULeft ( UInt& uiLPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool bEnforceTileRestriction=true ); TComDataCU* getPUAbove ( UInt& uiAPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true, Bool planarAtLCUBoundary = false, Bool bEnforceTileRestriction=true ); TComDataCU* getPUAboveLeft ( UInt& uiALPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true ); TComDataCU* getPUAboveRight ( UInt& uiARPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true ); TComDataCU* getPUBelowLeft ( UInt& uiBLPartUnitIdx, UInt uiCurrPartUnitIdx, Bool bEnforceSliceRestriction=true ); TComDataCU* getQpMinCuLeft ( UInt& uiLPartUnitIdx , UInt uiCurrAbsIdxInLCU ); TComDataCU* getQpMinCuAbove ( UInt& aPartUnitIdx , UInt currAbsIdxInLCU ); Char getRefQP ( UInt uiCurrAbsIdxInLCU ); TComDataCU* getPUAboveRightAdi ( UInt& uiARPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true ); TComDataCU* getPUBelowLeftAdi ( UInt& uiBLPartUnitIdx, UInt uiCurrPartUnitIdx, UInt uiPartUnitOffset = 1, Bool bEnforceSliceRestriction=true ); Void deriveLeftRightTopIdx ( UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ); Void deriveLeftBottomIdx ( UInt uiPartIdx, UInt& ruiPartIdxLB ); Void deriveLeftRightTopIdxAdi ( UInt& ruiPartIdxLT, UInt& ruiPartIdxRT, UInt uiPartOffset, UInt uiPartDepth ); Void deriveLeftBottomIdxAdi ( UInt& ruiPartIdxLB, UInt uiPartOffset, UInt uiPartDepth ); Bool hasEqualMotion ( UInt uiAbsPartIdx, TComDataCU* pcCandCU, UInt uiCandAbsPartIdx ); Void getInterMergeCandidates ( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx = -1 ); Void deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLT, UInt& ruiPartIdxRT ); Void deriveLeftBottomIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt& ruiPartIdxLB ); // ------------------------------------------------------------------------------------------------------------------- // member functions for modes // ------------------------------------------------------------------------------------------------------------------- Bool isIntra ( UInt uiPartIdx ) { return m_pePredMode[ uiPartIdx ] == MODE_INTRA; } Bool isSkipped ( UInt uiPartIdx ); ///< SKIP (no residual) Bool isBipredRestriction( UInt puIdx ); // ------------------------------------------------------------------------------------------------------------------- // member functions for symbol prediction (most probable / mode conversion) // ------------------------------------------------------------------------------------------------------------------- UInt getIntraSizeIdx ( UInt uiAbsPartIdx ); Void getAllowedChromaDir ( UInt uiAbsPartIdx, UInt* uiModeList ); Int getIntraDirLumaPredictor ( UInt uiAbsPartIdx, Int* uiIntraDirPred, Int* piMode = NULL ); // ------------------------------------------------------------------------------------------------------------------- // member functions for SBAC context // ------------------------------------------------------------------------------------------------------------------- UInt getCtxSplitFlag ( UInt uiAbsPartIdx, UInt uiDepth ); UInt getCtxQtCbf ( TextType eType, UInt uiTrDepth ); UInt getCtxSkipFlag ( UInt uiAbsPartIdx ); UInt getCtxInterDir ( UInt uiAbsPartIdx ); UInt getSliceStartCU ( UInt pos ) { return m_sliceStartCU[pos-m_uiAbsIdxInLCU]; } UInt getSliceSegmentStartCU ( UInt pos ) { return m_sliceSegmentStartCU[pos-m_uiAbsIdxInLCU]; } UInt& getTotalBins () { return m_uiTotalBins; } // ------------------------------------------------------------------------------------------------------------------- // member functions for RD cost storage // ------------------------------------------------------------------------------------------------------------------- Double& getTotalCost() { return m_dTotalCost; } UInt& getTotalDistortion() { return m_uiTotalDistortion; } UInt& getTotalBits() { return m_uiTotalBits; } UInt& getTotalNumPart() { return m_uiNumPartition; } UInt getCoefScanIdx(UInt uiAbsPartIdx, UInt uiWidth, Bool bIsLuma, Bool bIsIntra);};namespace RasterAddress { /** Check whether 2 addresses point to the same column * \param addrA First address in raster scan order * \param addrB Second address in raters scan order * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool isEqualCol( Int addrA, Int addrB, Int numUnitsPerRow ) { // addrA % numUnitsPerRow == addrB % numUnitsPerRow return (( addrA ^ addrB ) & ( numUnitsPerRow - 1 ) ) == 0; } /** Check whether 2 addresses point to the same row * \param addrA First address in raster scan order * \param addrB Second address in raters scan order * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool isEqualRow( Int addrA, Int addrB, Int numUnitsPerRow ) { // addrA / numUnitsPerRow == addrB / numUnitsPerRow return (( addrA ^ addrB ) &~ ( numUnitsPerRow - 1 ) ) == 0; } /** Check whether 2 addresses point to the same row or column * \param addrA First address in raster scan order * \param addrB Second address in raters scan order * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool isEqualRowOrCol( Int addrA, Int addrB, Int numUnitsPerRow ) { return isEqualCol( addrA, addrB, numUnitsPerRow ) | isEqualRow( addrA, addrB, numUnitsPerRow ); } /** Check whether one address points to the first column * \param addr Address in raster scan order * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool isZeroCol( Int addr, Int numUnitsPerRow ) { // addr % numUnitsPerRow == 0 return ( addr & ( numUnitsPerRow - 1 ) ) == 0; } /** Check whether one address points to the first row * \param addr Address in raster scan order * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool isZeroRow( Int addr, Int numUnitsPerRow ) { // addr / numUnitsPerRow == 0 return ( addr &~ ( numUnitsPerRow - 1 ) ) == 0; } /** Check whether one address points to a column whose index is smaller than a given value * \param addr Address in raster scan order * \param val Given column index value * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool lessThanCol( Int addr, Int val, Int numUnitsPerRow ) { // addr % numUnitsPerRow < val return ( addr & ( numUnitsPerRow - 1 ) ) < val; } /** Check whether one address points to a row whose index is smaller than a given value * \param addr Address in raster scan order * \param val Given row index value * \param numUnitsPerRow Number of units in a row * \return Result of test */ static inline Bool lessThanRow( Int addr, Int val, Int numUnitsPerRow ) { // addr / numUnitsPerRow < val return addr < val * numUnitsPerRow; }};//! \}#endif</bool></ndbfblockinfo></typename></predmode></partsize></ndbfblockinfo></vector></algorithm></assert>