sliceheaderbase.h

JVT-S203 contains the JSVM 6 reference software. It corresponds to CVS tag “JSVM_5_12_1”. For obt

  }

  Mmco& operator = ( const Mmco& rcMmco ) 
  {
    m_eMmcoOp = rcMmco.m_eMmcoOp;
    m_uiVal1  = rcMmco.m_uiVal1;
    m_uiVal2  = rcMmco.m_uiVal2;
    return *this;
  }

  const MmcoOp& getCommand( UInt&   ruiVal1,
                            UInt&   ruiVal2 ) const { ruiVal1 = m_uiVal1; ruiVal2 = m_uiVal2; return m_eMmcoOp; }
  Bool          isCommand ( MmcoOp  eMmcoOp ) const { return eMmcoOp == m_eMmcoOp; }
  UInt          getVal1   ()                  const { return m_uiVal1; }
  UInt          getVal2   ()                  const { return m_uiVal2; }
  Bool          isEnd     ()                  const { return MMCO_END == m_eMmcoOp; }

  
  ErrVal write( HeaderSymbolWriteIf*  pcWriteIf,
                Bool&                 rbContinue ) const
  {
    RNOK( pcWriteIf->writeUvlc( m_eMmcoOp,    "DRPM: memory_mangement_control_operation" ) );

    rbContinue = (m_eMmcoOp != MMCO_END);

    if( (m_eMmcoOp != MMCO_END) && (m_eMmcoOp != MMCO_RESET) )
    {
      RNOK( pcWriteIf->writeUvlc( m_uiVal1,   "DRPM: MMCO Param" ) );

      if( m_eMmcoOp == MMCO_ASSIGN_LONG_TERM )
      {
        RNOK( pcWriteIf->writeUvlc( m_uiVal2, "DRPM: MMCO Param" ) );
      }
    }
    return Err::m_nOK;
  }


  ErrVal read( HeaderSymbolReadIf*  pcReadIf,
               Bool&                rbContinue )
  {
    UInt uiCommand;
    RNOK( pcReadIf->getUvlc( uiCommand,     "DRPM: memory_mangement_control_operation" ) );

    ROTR( MMCO_SET_LONG_TERM < uiCommand, Err::m_nInvalidParameter );
    m_eMmcoOp = MmcoOp( uiCommand );

    rbContinue = (m_eMmcoOp != MMCO_END);

    if( (m_eMmcoOp != MMCO_END) && (m_eMmcoOp != MMCO_RESET) )
    {
      RNOK( pcReadIf->getUvlc( m_uiVal1,    "DRPM: MMCO Param" ) );

      if( m_eMmcoOp == MMCO_ASSIGN_LONG_TERM )
      {
        RNOK( pcReadIf->getUvlc( m_uiVal2,  "DRPM: MMCO Param" ) );
      }
    }
    return Err::m_nOK;
  }

private:
  MmcoOp  m_eMmcoOp;
  UInt    m_uiVal1;
  UInt    m_uiVal2;
};




class H264AVCCOMMONLIB_API MmcoBuffer :
public StatBuf<Mmco,32>
{
  public:
  Void clear()
  {
    setAll( MmcoOp() );
  }

  ErrVal write( HeaderSymbolWriteIf* pcWriteIf ) const
  {
    Bool bCont = true;
    for( Int iIndex = 0; bCont; iIndex++ )
    {
      RNOK( get( iIndex ).write( pcWriteIf, bCont ) );
    }
    return Err::m_nOK;
  }

  ErrVal read( HeaderSymbolReadIf* pcReadIf )
  {
    Bool bCont = true;
    for( Int iIndex = 0; bCont; iIndex++ )
    {
      RNOK( get( iIndex ).read( pcReadIf, bCont ) );
    }
    return Err::m_nOK;
  }

  Void copy( const StatBuf<Mmco,32>& rcSrcMmcoBuffer)
  {
    for( Int n = 0; n < 32; n++ )
    {
      get(n) = rcSrcMmcoBuffer.get( n );
      ROTVS( get(n).isEnd() );
    }
  }
};





class H264AVCCOMMONLIB_API SliceHeaderBase
{
public:
  class H264AVCCOMMONLIB_API PredWeight
  {
  public:
    PredWeight() : m_bLumaWeightFlag( false ), m_bChromaWeightFlag( false ), m_iLumaWeight( 0 ), m_iLumaOffset( 0 )
    {
      m_aiChromaWeight[0] = m_aiChromaWeight[1] = 0;
      m_aiChromaOffset[0] = m_aiChromaOffset[1] = 0;
    }
    ~PredWeight() {}

    ErrVal createRandomParameters(); // just for encoder testing

    Void scaleL1Weight( Int iDistScaleFactor )
    {
      iDistScaleFactor >>= 2;
      if( (iDistScaleFactor > 128) || (iDistScaleFactor < -64) )
      {
        iDistScaleFactor = 32;
      }

      m_iLumaWeight       = iDistScaleFactor;
      m_aiChromaWeight[0] = iDistScaleFactor;
      m_aiChromaWeight[1] = iDistScaleFactor;
    }
    Void scaleL0Weight( const PredWeight& rcPredWeightL1 )
    {
      m_iLumaWeight       = 64 - rcPredWeightL1.m_iLumaWeight;
      m_aiChromaWeight[0] = 64 - rcPredWeightL1.m_aiChromaWeight[0];
      m_aiChromaWeight[1] = 64 - rcPredWeightL1.m_aiChromaWeight[1];
    }
    ErrVal init( Int iLumaWeight, Int iChromaCbWeight, Int iChromaCrWeight )
    {
      m_iLumaWeight       = iLumaWeight;
      m_aiChromaWeight[0] = iChromaCbWeight;
      m_aiChromaWeight[1] = iChromaCrWeight;
      return Err::m_nOK;
    }

//TMM_WP
    ErrVal initOffsets( Int iLumaOffset, Int iChromaCbOffset, Int iChromaCrOffset )
    {
        m_iLumaOffset = iLumaOffset;
        m_aiChromaOffset[0] = iChromaCbOffset;
        m_aiChromaOffset[1] = iChromaCrOffset;
        return Err::m_nOK;
    }

    ErrVal setOffsets(  const Double *pafOffsets );
    ErrVal getOffsets( Double *afOffset);
//TMM_WP
    Bool  getLumaWeightFlag()                                  const { return m_bLumaWeightFlag; }
    Bool  getChromaWeightFlag()                                const { return m_bChromaWeightFlag; }
    Int   getLumaWeight()                                      const { return m_iLumaWeight; }
    Int   getLumaOffset()                                      const { return m_iLumaOffset; }
    Int   getChromaWeight( UInt uiChromaPlane )                const { return m_aiChromaWeight[uiChromaPlane]; }
    Int   getChromaOffset( UInt uiChromaPlane )                const { return m_aiChromaOffset[uiChromaPlane]; }

    Void  setLumaWeightFlag( Bool bLumaWeightFlag )                  { m_bLumaWeightFlag = bLumaWeightFlag; }
    Void  setChromaWeightFlag( Bool bChromaWeightFlag )              { m_bChromaWeightFlag = bChromaWeightFlag; }
    Void  setLumaWeight( Int iLumaWeight )                           { m_iLumaWeight = iLumaWeight; }
    Void  setLumaOffset( Int iLumaOffset )                           { m_iLumaOffset = iLumaOffset; }
    Void  setChromaWeight( UInt uiChromaPlane, Int iChromaWeight )   { m_aiChromaWeight[uiChromaPlane] = iChromaWeight; }
    Void  setChromaOffset( UInt uiChromaPlane, Int iChromaOffset )   { m_aiChromaOffset[uiChromaPlane] = iChromaOffset; }

//TMM_WP
    ErrVal getPredWeights( Double *afWeight);
    ErrVal setPredWeightsAndFlags( const Int iLumaScale, 
                                   const Int iChromaScale, 
                                   const Double *pfWeight, 
                                   Double fDiscardThr );
//TMM_WP

    ErrVal write( HeaderSymbolWriteIf*  pcWriteIf ) const;
    ErrVal read ( HeaderSymbolReadIf*   pcReadIf  );

    Bool  operator!=( const PredWeight& rcPredWeight ) const
    {
      ROTRS( m_bLumaWeightFlag    != rcPredWeight.m_bLumaWeightFlag,    true );
      ROTRS( m_bChromaWeightFlag  != rcPredWeight.m_bChromaWeightFlag,  true );
      ROTRS( m_iLumaWeight        != rcPredWeight.m_iLumaWeight,        true );
      ROTRS( m_iLumaOffset        != rcPredWeight.m_iLumaOffset,        true );
      ROTRS( m_aiChromaWeight[0]  != rcPredWeight.m_aiChromaWeight[0],  true );
      ROTRS( m_aiChromaWeight[1]  != rcPredWeight.m_aiChromaWeight[1],  true );
      ROTRS( m_aiChromaOffset[0]  != rcPredWeight.m_aiChromaOffset[0],  true );
      ROTRS( m_aiChromaOffset[1]  != rcPredWeight.m_aiChromaOffset[1],  true );
      return false;
    }
    Bool  operator==( const PredWeight& rcPredWeight ) const
    {
      return !(*this != rcPredWeight);
    }

    Void  copy( const PredWeight& rcPredWeight )
    {
      m_bLumaWeightFlag   = rcPredWeight.m_bLumaWeightFlag;
      m_bChromaWeightFlag = rcPredWeight.m_bChromaWeightFlag;
      m_iLumaWeight       = rcPredWeight.m_iLumaWeight;
      m_iLumaOffset       = rcPredWeight.m_iLumaOffset;
      m_aiChromaWeight[0] = rcPredWeight.m_aiChromaWeight[0];
      m_aiChromaWeight[1] = rcPredWeight.m_aiChromaWeight[1];
      m_aiChromaOffset[0] = rcPredWeight.m_aiChromaOffset[0];
      m_aiChromaOffset[1] = rcPredWeight.m_aiChromaOffset[1];
    }

  private:
    Bool  m_bLumaWeightFlag;
    Bool  m_bChromaWeightFlag;
    Int   m_iLumaWeight;
    Int   m_iLumaOffset;
    Int   m_aiChromaWeight[2];
    Int   m_aiChromaOffset[2];
  };

  class H264AVCCOMMONLIB_API PredWeightTable : public DynBuf<PredWeight>
  {
  public:
    ErrVal initDefaults( UInt uiLumaWeightDenom, UInt uiChromaWeightDenom );
    ErrVal createRandomParameters();

    ErrVal write( HeaderSymbolWriteIf*  pcWriteIf,  UInt uiNumber ) const;
    ErrVal read ( HeaderSymbolReadIf*   pcReadIf,   UInt uiNumber );

//TMM_WP
    ErrVal setPredWeightsAndFlags( const Int iLumaScale, 
                                   const Int iChromaScale, 
                                   const Double(*pafWeight)[3], 
                                   Double fDiscardThr );

    ErrVal setOffsets(  const Double(*pafOffsets)[3] );
//TMM_WP
    ErrVal copy ( const PredWeightTable& rcPredWeightTable );
  };

  class H264AVCCOMMONLIB_API DeblockingFilterParameter
  {
  public:
    DeblockingFilterParameter( UInt uiDisableDeblockingFilterIdc  = 0,
                               Int  iSliceAlphaC0Offset           = 0,
                               Int  iSliceBetaOffset              = 0 )
    : m_uiDisableDeblockingFilterIdc( uiDisableDeblockingFilterIdc )
    , m_iSliceAlphaC0Offset         ( iSliceAlphaC0Offset )
    , m_iSliceBetaOffset            ( iSliceBetaOffset )
    {
    }

    ErrVal write( HeaderSymbolWriteIf*  pcWriteIf ) const;
    ErrVal read ( HeaderSymbolReadIf*   pcReadIf );

    DeblockingFilterParameter* getCopy()  const
    {
      return new DeblockingFilterParameter( m_uiDisableDeblockingFilterIdc, m_iSliceAlphaC0Offset, m_iSliceBetaOffset );
    }
    
    Void setDisableDeblockingFilterIdc( UInt uiDisableDeblockingFilterIdc ) { m_uiDisableDeblockingFilterIdc = uiDisableDeblockingFilterIdc; }
    Void setSliceAlphaC0Offset        ( Int  iSliceAlphaC0Offset )          { AOT_DBG( 1 & iSliceAlphaC0Offset);  m_iSliceAlphaC0Offset = iSliceAlphaC0Offset; }
    Void setSliceBetaOffset           ( Int  iSliceBetaOffset )             { AOT_DBG( 1 & iSliceBetaOffset);     m_iSliceBetaOffset = iSliceBetaOffset; }

    UInt getDisableDeblockingFilterIdc()  const { return m_uiDisableDeblockingFilterIdc;}
    Int  getSliceAlphaC0Offset()          const { return m_iSliceAlphaC0Offset;}
    Int  getSliceBetaOffset()             const { return m_iSliceBetaOffset;}

  private:
    UInt m_uiDisableDeblockingFilterIdc;
    Int  m_iSliceAlphaC0Offset;
    Int  m_iSliceBetaOffset;
  };



protected:
	SliceHeaderBase         ( const SequenceParameterSet& rcSPS,
                            const PictureParameterSet&  rcPPS );
	virtual ~SliceHeaderBase();


public:
  ErrVal    read    ( HeaderSymbolReadIf*   pcReadIf  );
  ErrVal    write   ( HeaderSymbolWriteIf*  pcWriteIf ) const;


  //===== get properties =====
  Bool                              isH264AVCCompatible           ()  const { return ( m_eNalUnitType == NAL_UNIT_CODED_SLICE  ||
                                                                                       m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR ); }
  Bool                              isIdrNalUnit                  ()  const { return ( m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR || 
                                                                                       m_eNalUnitType == NAL_UNIT_CODED_SLICE_IDR_SCALABLE ); }
  Int                               getPicQp                      ()  const { return m_rcPPS.getPicInitQp() + getSliceQpDelta(); }
  UInt                              getMbInPic                    ()  const { return m_rcSPS.getMbInFrame(); }

  
  //===== get parameter sets =====
  const PictureParameterSet&        getPPS                        ()  const { return m_rcPPS; }
  const SequenceParameterSet&       getSPS                        ()  const { return m_rcSPS; }