sliceheaderbase.h

SVC最新更新代码

  virtual ~MmcoCommand();

  Void    copy  ( const MmcoCommand&    rcMmcoCommand );
  ErrVal  write ( HeaderSymbolWriteIf&  rcWriteIf,
                  Bool                  bRefBasePic,
                  Bool&                 rbEnd )   const;
  ErrVal  read  ( HeaderSymbolReadIf&   rcReadIf,
                  Bool                  bRefBasePic,
                  Bool&                 rbEnd );

  Mmco        getCommand  ( UInt&       ruiValue1,
                            UInt&       ruiValue2 ) const { ruiValue1 = m_uiValue1, ruiValue2 = m_uiValue2; return m_eMmco; }
  Mmco        getCommand  ()                        const { return m_eMmco; }
  UInt        getValue1   ()                        const { return m_uiValue1; }
  UInt        getValue2   ()                        const { return m_uiValue2; }
  Bool        isEnd       ()                        const { return m_eMmco == MMCO_END; }
  
  Bool                operator != ( const MmcoCommand& rcMmcoCommand  )   const { return m_eMmco != rcMmcoCommand.m_eMmco || m_uiValue1 != rcMmcoCommand.m_uiValue1 || m_uiValue2 != rcMmcoCommand.m_uiValue2; }
  const MmcoCommand&  operator  = ( const MmcoCommand& rcMmcoCommand  )         { copy( rcMmcoCommand ); return *this; }
  
private:
  Mmco    m_eMmco;
  UInt    m_uiValue1;
  UInt    m_uiValue2;
};


class H264AVCCOMMONLIB_API DecRefPicMarking : public StatBuf< MmcoCommand, 33 >
{
public:
  DecRefPicMarking( Bool                    bDecRefBasePicMarking = false );
  DecRefPicMarking( const DecRefPicMarking& rcDecRefPicMarking );
  virtual ~DecRefPicMarking();

  Void    clear ( Bool                      bDecRefBasePicMarking,
                  Bool                      bAdaptiveRefPicMarkingModeFlag = false );
  Void    copy  ( const DecRefPicMarking&   rcDecRefPicMarking );
  ErrVal  write ( HeaderSymbolWriteIf&      rcWriteIf ) const;
  ErrVal  read  ( HeaderSymbolReadIf&       rcReadIf );

  Bool    hasMMCO5                          ()                                  const;
  Bool    isDecRefBasePicMarking            ()                                  const   { return m_bDecRefBasePicMarking; }
  Bool    getAdaptiveRefPicMarkingModeFlag  ()                                  const   { return m_bAdaptiveRefPicMarkingModeFlag; }

  Void    setDecRefBasePicMarking           ( Bool  bDecRefBasePicMarking )             { m_bDecRefBasePicMarking           = bDecRefBasePicMarking; }
  Void    setAdaptiveRefPicMarkingModeFlag  ( Bool  bAdaptiveRefPicMarkingModeFlag  )   { m_bAdaptiveRefPicMarkingModeFlag  = bAdaptiveRefPicMarkingModeFlag; }

  const DecRefPicMarking& operator = ( const DecRefPicMarking& rcDecRefPicMarking )     { copy( rcDecRefPicMarking ); return *this; }

private:
  Bool    m_bDecRefBasePicMarking;
  Bool    m_bAdaptiveRefPicMarkingModeFlag;
};



class H264AVCCOMMONLIB_API PredWeight
{
public:
  PredWeight();
  PredWeight( const PredWeight& rcPredWeight );
  virtual ~PredWeight();

  Void    copy  ( const PredWeight&     rcPredWeight );
  ErrVal  write ( HeaderSymbolWriteIf&  rcWriteIf ) const;
  ErrVal  read  ( HeaderSymbolReadIf&   rcReadIf,
                  UInt                  uiLumaLog2WeightDenom,
                  UInt                  uiChromaLog2WeightDenom );

  ErrVal  initRandomly  ();
  ErrVal  initWeights   ( Int iLumaWeight, Int iCbWeight, Int iCrWeight );
  ErrVal  initOffsets   ( Int iLumaOffset, Int iCbOffset, Int iCrOffset );
  
  ErrVal  setOffsets    ( const Double* padOffsets );
  ErrVal  setWeights    ( const Double* padWeights, Int iLumaScale, Int iChromaScale );
  ErrVal  getOffsets    ( Double*       padOffsets );
  ErrVal  getWeights    ( Double*       padWeights );

  Void    scaleL1Weight ( Int               iDistScaleFactor );
  Void    scaleL0Weight ( const PredWeight& rcPredWeightL1 );

  Bool    getLumaWeightFlag   ()  const { return m_bLumaWeightFlag; }
  Int     getLumaWeight       ()  const { return m_iLumaWeight; }
  Int     getLumaOffset       ()  const { return m_iLumaOffset; }
  Bool    getChromaWeightFlag ()  const { return m_bChromaWeightFlag; }
  Int     getChromaCbWeight   ()  const { return m_iChromaCbWeight; }
  Int     getChromaCbOffset   ()  const { return m_iChromaCbOffset; }
  Int     getChromaCrWeight   ()  const { return m_iChromaCrWeight; }
  Int     getChromaCrOffset   ()  const { return m_iChromaCrOffset; }

  Void    setLumaWeightFlag   ( Bool  bLumaWeightFlag   )   { m_bLumaWeightFlag   = bLumaWeightFlag; }
  Void    setLumaWeight       ( Int   iLumaWeight       )   { m_iLumaWeight       = iLumaWeight; }
  Void    setLumaOffset       ( Int   iLumaOffset       )   { m_iLumaOffset       = iLumaOffset; }
  Void    setChromaWeightFlag ( Bool  bChromaWeightFlag )   { m_bChromaWeightFlag = bChromaWeightFlag; }
  Void    setChromaCbWeight   ( Int   iChromaCbWeight   )   { m_iChromaCbWeight   = iChromaCbWeight; }
  Void    setChromaCbOffset   ( Int   iChromaCbOffset   )   { m_iChromaCbOffset   = iChromaCbOffset; }
  Void    setChromaCrWeight   ( Int   iChromaCrWeight   )   { m_iChromaCrWeight   = iChromaCrWeight; }
  Void    setChromaCrOffset   ( Int   iChromaCrOffset   )   { m_iChromaCrOffset   = iChromaCrOffset; }

  Bool              operator  ==  ( const PredWeight& rcPredWeight )  const;
  Bool              operator  !=  ( const PredWeight& rcPredWeight )  const;
  const PredWeight& operator   =  ( const PredWeight& rcPredWeight )          { copy( rcPredWeight ); return *this; }

private:
  Int     xRandom( Int iMin, Int iMax );

private:
  Bool    m_bLumaWeightFlag;
  Int     m_iLumaWeight;
  Int     m_iLumaOffset;
  Bool    m_bChromaWeightFlag;
  Int     m_iChromaCbWeight;
  Int     m_iChromaCbOffset;
  Int     m_iChromaCrWeight;
  Int     m_iChromaCrOffset;
};


class H264AVCCOMMONLIB_API PredWeightTable : public StatBuf< PredWeight, 32 >
{
public:
  PredWeightTable();
  PredWeightTable( const PredWeightTable& rcPredWeightTable );
  virtual ~PredWeightTable();

  ErrVal  initRandomly  ();
  ErrVal  initDefaults  ( UInt  uiLumaWeightDenom,
                          UInt  uiChromaWeightDenom );

  ErrVal  setOffsets    ( const Double (*padOffsets)[3] );
  ErrVal  setWeights    ( const Double (*padOffsets)[3], Int iLumaScale, Int iChromaScale );

  Void    clear ();
  Void    copy  ( const PredWeightTable&  rcPredWeightTable );
  ErrVal  write ( HeaderSymbolWriteIf&    rcWriteIf,  UInt uiNumRefIdxActiveMinus1 ) const;
  ErrVal  read  ( HeaderSymbolReadIf&     rcReadIf,   UInt uiNumRefIdxActiveMinus1, UInt uiLumaLog2WeightDenom, UInt uiChromaLog2WeightDenom );

  const PredWeightTable& operator = ( const PredWeightTable& rcPredWeightTable )    { copy( rcPredWeightTable ); return *this; }
};


class H264AVCCOMMONLIB_API DBFilterParameter
{
public:
  DBFilterParameter( Bool                     bInterLayerParameters = false );
  DBFilterParameter( const DBFilterParameter& rcDBFilterParameter );
  virtual ~DBFilterParameter();

  Void    clear ( Bool                      InterLayerParameters = false );
  Void    copy  ( const DBFilterParameter&  rcDBFilterParameter );
  ErrVal  write ( HeaderSymbolWriteIf&      rcWriteIf ) const;
  ErrVal  read  ( HeaderSymbolReadIf&       rcReadIf, Bool bSVCNalUnit );

  Bool    isInterLayerParameters        ()  const   { return m_bInterLayerParameters; }
  UInt    getDisableDeblockingFilterIdc ()  const   { return m_uiDisableDeblockingFilterIdc; }
  Int     getSliceAlphaC0OffsetDiv2     ()  const   { return m_iSliceAlphaC0OffsetDiv2; }
  Int     getSliceAlphaC0Offset         ()  const   { return m_iSliceAlphaC0OffsetDiv2 << 1; }
  Int     getSliceBetaOffsetDiv2        ()  const   { return m_iSliceBetaOffsetDiv2; }
  Int     getSliceBetaOffset            ()  const   { return m_iSliceBetaOffsetDiv2 << 1; }

  Void    setDisableDeblockingFilterIdc ( UInt  uiDisableDeblockingFilterIdc  )   { m_uiDisableDeblockingFilterIdc  = uiDisableDeblockingFilterIdc; }
  Void    setSliceAlphaC0OffsetDiv2     ( Int   iSliceAlphaC0OffsetDiv2       )   { m_iSliceAlphaC0OffsetDiv2       = iSliceAlphaC0OffsetDiv2; }
  Void    setSliceAlphaC0Offset         ( Int   iSliceAlphaC0Offset           )   { m_iSliceAlphaC0OffsetDiv2       = iSliceAlphaC0Offset >> 1; }
  Void    setSliceBetaOffsetDiv2        ( Int   iSliceBetaOffsetDiv2          )   { m_iSliceBetaOffsetDiv2          = iSliceBetaOffsetDiv2; }
  Void    setSliceBetaOffset            ( Int   iSliceBetaOffset              )   { m_iSliceBetaOffsetDiv2          = iSliceBetaOffset >> 1; }

  const DBFilterParameter&  operator = ( const DBFilterParameter& rcDBFilterParameter ) { copy( rcDBFilterParameter ); return *this; }

private:
  Bool  m_bInterLayerParameters;
  UInt  m_uiDisableDeblockingFilterIdc;
  Int   m_iSliceAlphaC0OffsetDiv2;
  Int   m_iSliceBetaOffsetDiv2;
};



class H264AVCCOMMONLIB_API NalUnitHeader
{
public:
  NalUnitHeader();
  NalUnitHeader( const NalUnitHeader& rcNalUnitHeader );
  virtual ~NalUnitHeader();

  Void              copy  ( const NalUnitHeader&  rcNalUnitHeader,
                            Bool                  bInclusiveSVCExtension = true );
  ErrVal            write ( HeaderSymbolWriteIf&  rcWriteIf ) const;
  ErrVal            read  ( HeaderSymbolReadIf&   rcReadIf );

  Bool              isH264AVCCompatible     ()  const { return  m_eNalUnitType != NAL_UNIT_CODED_SLICE_SCALABLE && m_eNalUnitType != NAL_UNIT_PREFIX && m_eNalUnitType != NAL_UNIT_SUBSET_SPS; }
  Bool              isRefPic                ()  const { return  m_eNalRefIdc != NAL_REF_IDC_PRIORITY_LOWEST; }
  NalRefIdc         getNalRefIdc            ()  const { return  m_eNalRefIdc;             }
  NalUnitType       getNalUnitType          ()  const { return  m_eNalUnitType;           }
  Bool              getIdrFlag              ()  const { return  m_bIdrFlag;               }
  UInt              getPriorityId           ()  const { return  m_uiPriorityId;           }
  Bool              getNoInterLayerPredFlag ()  const { return  m_bNoInterLayerPredFlag;  }
  UInt              getDependencyId         ()  const { return  m_uiDependencyId;         }
  UInt              getQualityId            ()  const { return  m_uiQualityId;            }
  UInt              getTemporalId           ()  const { return  m_uiTemporalId;           }
  Bool              getUseRefBasePicFlag    ()  const { return  m_bUseRefBasePicFlag;     }