sequenceparameterset.cpp

来自「SVC最新更新代码」· C++ 代码 · 共 773 行 · 第 1/3 页

  m_uiExtendedSpatialScalability      = rcSPS.m_uiExtendedSpatialScalability;
  m_uiChromaPhaseXPlus1               = rcSPS.m_uiChromaPhaseXPlus1;
  m_uiChromaPhaseYPlus1               = rcSPS.m_uiChromaPhaseYPlus1;
  m_uiBaseChromaPhaseXPlus1           = rcSPS.m_uiBaseChromaPhaseXPlus1;
  m_uiBaseChromaPhaseYPlus1           = rcSPS.m_uiBaseChromaPhaseYPlus1;
  m_iScaledBaseLeftOffset             = rcSPS.m_iScaledBaseLeftOffset;
  m_iScaledBaseTopOffset              = rcSPS.m_iScaledBaseTopOffset;
  m_iScaledBaseRightOffset            = rcSPS.m_iScaledBaseRightOffset;
  m_iScaledBaseBottomOffset           = rcSPS.m_iScaledBaseBottomOffset;

  return *this;
}

UInt
SequenceParameterSet::getMaxDPBSize() const
{
  const LevelLimit* pcLevelLimit = 0;
  UInt              uiFrameSize = 384*getMbInFrame();
  ANOK( xGetLevelLimit( pcLevelLimit, getConvertedLevelIdc() ) );
  UInt uiNumDPBEntries  = pcLevelLimit->uiMaxDPBSizeX2 / ( 2*uiFrameSize );
  uiNumDPBEntries       = min( uiNumDPBEntries, 16 );
  return uiNumDPBEntries;
}

// JVT-V068 HRD {
Void SequenceParameterSet::setVUI(SequenceParameterSet* pcSPS)
{
  m_pcVUI = new VUI(pcSPS);
}

UInt
SequenceParameterSet::getMaxCPBSize() const
{
  const LevelLimit* pcLevelLimit = 0;
  ANOK( xGetLevelLimit( pcLevelLimit, getConvertedLevelIdc() ) );
  return pcLevelLimit->uiMaxCPBSize;
}

UInt
SequenceParameterSet::getMaxBitRate() const
{
  const LevelLimit* pcLevelLimit = 0;
  ANOK( xGetLevelLimit( pcLevelLimit, getConvertedLevelIdc() ) );
  return pcLevelLimit->uiMaxBitRate;
}
// JVT-V068 HRD }

UInt
SequenceParameterSet::getMaxSliceSize( Bool bFieldPic ) const
{
  ROTRS( m_uiFrameWidthInMbs * m_uiFrameHeightInMbs <= UInt( bFieldPic ? 3240 : 1620 ), MSYS_UINT_MAX );
  const LevelLimit* pcLevelLimit = 0;
  ANOK( xGetLevelLimit( pcLevelLimit, getConvertedLevelIdc() ) );
  return ( pcLevelLimit->uiMaxFrameSize >> 2 );
}

UInt
SequenceParameterSet::getMaxMVsPer2Mb()  const
{
  const LevelLimit* pcLevelLimit = 0;
  ANOK( xGetLevelLimit( pcLevelLimit, getConvertedLevelIdc() ) );
  return pcLevelLimit->uiMaxMvsPer2Mb;
}

Bool
SequenceParameterSet::getBiPred8x8Disabled()  const
{
  if( m_eProfileIdc == MAIN_PROFILE || m_eProfileIdc == HIGH_PROFILE || ( ( m_eProfileIdc == BASELINE_PROFILE || m_eProfileIdc == EXTENDED_PROFILE ) && m_bConstrainedSet1Flag ) )
  {
    return ( m_uiLevelIdc >= 31 );
  }
  if( m_eProfileIdc == SCALABLE_BASELINE_PROFILE )
  {
    return true;
  }
  if( m_eProfileIdc == SCALABLE_HIGH_PROFILE )
  {
    return ( m_bConstrainedSet0Flag || m_uiLevelIdc >= 31 );
  }
  return false;
}

ErrVal
SequenceParameterSet::xGetLevelLimit( const LevelLimit*& rpcLevelLimit, Int iLevelIdc )
{
  ROT ( iLevelIdc > 51 )
  rpcLevelLimit = &m_aLevelLimit[iLevelIdc];
  ROFS( rpcLevelLimit->bValid )
  return Err::m_nOK;
}

UInt
SequenceParameterSet::getLevelIdc( UInt uiMbY, UInt uiMbX, UInt uiOutFreq, UInt uiMvRange, UInt uiNumRefPic, UInt uiRefLayerMbs )
{
  UInt uiFrameSize = uiMbY * uiMbX;
  UInt uiMbPerSec  = ( uiFrameSize + ( ( uiRefLayerMbs + 1 ) >> 1 ) ) * uiOutFreq;
  UInt uiDPBSizeX2 = (uiFrameSize*16*16*3/2) * uiNumRefPic * 2;

  for( Int n = 0; n < 52; n++ )
  {
    const LevelLimit* pcLevelLimit;
    
    if( Err::m_nOK == xGetLevelLimit( pcLevelLimit, n ) )
    {
      UInt  uiMbPerLine  = (UInt)sqrt( (Double) pcLevelLimit->uiMaxFrameSize * 8 );
      if( ( uiMbPerLine                   >= uiMbX        ) &&
          ( uiMbPerLine                   >= uiMbY        ) &&
          ( pcLevelLimit->uiMaxMbPerSec   >= uiMbPerSec   ) &&
          ( pcLevelLimit->uiMaxFrameSize  >= uiFrameSize  ) &&
          ( pcLevelLimit->uiMaxDPBSizeX2  >= uiDPBSizeX2  ) &&
          ( pcLevelLimit->uiMaxVMvRange   >= uiMvRange    )    )
      {
        return n;
      }
    }
  }
  return MSYS_UINT_MAX;
}


ErrVal
SequenceParameterSet::write( HeaderSymbolWriteIf* pcWriteIf ) const
{
  //===== NAL unit header =====
  ETRACE_DECLARE( Bool m_bTraceEnable = true );
  g_nLayer = 0;
  ETRACE_LAYER(0);
  if( m_eNalUnitType == NAL_UNIT_SUBSET_SPS )
  {
    ETRACE_HEADER( "SUBSET SEQUENCE PARAMETER SET" );
  }
  else
  {
    ETRACE_HEADER( "SEQUENCE PARAMETER SET" );
  }
  RNOK  ( pcWriteIf->writeFlag( 0,                                        "NAL unit header: forbidden_zero_bit" ) );
  RNOK  ( pcWriteIf->writeCode( 3, 2,                                     "NAL unit header: nal_ref_idc" ) );
  RNOK  ( pcWriteIf->writeCode( m_eNalUnitType, 5,                        "NAL unit header: nal_unit_type" ) );

  //===== Sequence parameter set =====
  RNOK  ( pcWriteIf->writeCode( getProfileIdc(),                  8,      "SPS: profile_idc" ) );
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet0Flag,                   "SPS: constraint_set0_flag" ) ); //VB-JV 04/08
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet1Flag,                   "SPS: constraint_set1_flag" ) );  //VB-JV 04/08
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet2Flag,                   "SPS: constraint_set2_flag" ) );  //VB-JV 04/08
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet3Flag,                   "SPS: constraint_set3_flag" ) );   //VB-JV 04/08
  RNOK  ( pcWriteIf->writeCode( 0,                                4,      "SPS: reserved_zero_4bits" ) );
  RNOK  ( pcWriteIf->writeCode( getLevelIdc(),                    8,      "SPS: level_idc" ) );
  RNOK  ( pcWriteIf->writeUvlc( getSeqParameterSetId(),                   "SPS: seq_parameter_set_id" ) );
  
  //--- fidelity range extension syntax ---
  RNOK  ( xWriteFrext( pcWriteIf ) );
    
  UInt    uiTmp = getLog2MaxFrameNum();
  ROF   ( uiTmp >= 4 );
  RNOK  ( pcWriteIf->writeUvlc( uiTmp - 4,                                "SPS: log2_max_frame_num_minus_4" ) );
  RNOK  ( pcWriteIf->writeUvlc( getPicOrderCntType(),                     "SPS: pic_order_cnt_type" ) );
  if( getPicOrderCntType() == 0 )
  {
    RNOK  ( pcWriteIf->writeUvlc( getLog2MaxPicOrderCntLsb() - 4,         "SPS: log2_max_pic_order_cnt_lsb_minus4" ) );
  }
  else if( getPicOrderCntType() == 1 )
  {
    RNOK( pcWriteIf->writeFlag( getDeltaPicOrderAlwaysZeroFlag(),         "SPS: delta_pic_order_always_zero_flag" ) );
    RNOK( pcWriteIf->writeSvlc( getOffsetForNonRefPic(),                  "SPS: offset_for_non_ref_pic" ) );
    RNOK( pcWriteIf->writeSvlc( getOffsetForTopToBottomField(),           "SPS: offset_for_top_to_bottom_field" ) );
    RNOK( pcWriteIf->writeUvlc( getNumRefFramesInPicOrderCntCycle(),      "SPS: num_ref_frames_in_pic_order_cnt_cycle" ) );
    for( UInt uiIndex = 0; uiIndex < getNumRefFramesInPicOrderCntCycle(); uiIndex++ )
    {
      RNOK( pcWriteIf->writeSvlc( getOffsetForRefFrame( uiIndex ),        "SPS: offset_for_ref_frame" ) );
    }
  }
  RNOK  ( pcWriteIf->writeUvlc( getNumRefFrames(),                        "SPS: num_ref_frames" ) );
  RNOK  ( pcWriteIf->writeFlag( getGapsInFrameNumValueAllowedFlag(),      "SPS: gaps_in_frame_num_value_allowed_flag" ) );
  
  RNOK  ( pcWriteIf->writeUvlc( getFrameWidthInMbs  () - 1,               "SPS: pic_width_in_mbs_minus1" ) );
  UInt uiHeight = ( getFrameHeightInMbs()-1) >> (1- getFrameMbsOnlyFlag() );

  RNOK  ( pcWriteIf->writeUvlc( uiHeight,                                 "SPS: pic_height_in_map_units_minus1" ) );
  RNOK  ( pcWriteIf->writeFlag( getFrameMbsOnlyFlag(),                    "SPS: frame_mbs_only_flag" ) );

  if( !getFrameMbsOnlyFlag() )
  {
    RNOK( pcWriteIf->writeFlag( getMbAdaptiveFrameFieldFlag(),            "SPS: mb_adaptive_frame_field_flag" ) );
  }


  RNOK  ( pcWriteIf->writeFlag( getDirect8x8InferenceFlag(),              "SPS: direct_8x8_inference_flag" ) );

  if( m_uiFrameCropLeftOffset || m_uiFrameCropRightOffset || m_uiFrameCropTopOffset || m_uiFrameCropBottomOffset )
  {
    RNOK( pcWriteIf->writeFlag( true,                                     "SPS: frame_cropping_flag"      ) );
    RNOK( pcWriteIf->writeUvlc( m_uiFrameCropLeftOffset,                  "SPS: frame_crop_left_offset"   ) );
    RNOK( pcWriteIf->writeUvlc( m_uiFrameCropRightOffset,                 "SPS: frame_crop_right_offset"  ) );
    RNOK( pcWriteIf->writeUvlc( m_uiFrameCropTopOffset,                   "SPS: frame_crop_top_offset"    ) );
    RNOK( pcWriteIf->writeUvlc( m_uiFrameCropBottomOffset,                "SPS: frame_crop_bottom_offset" ) );
  }
  else
  {
    RNOK( pcWriteIf->writeFlag( false,                                    "SPS: frame_cropping_flag" ) );
  }

  RNOK( m_pcVUI->write( pcWriteIf ) );
  
  ROFRS( m_eNalUnitType == NAL_UNIT_SUBSET_SPS, Err::m_nOK );


  //===== start of subset sequence parameter set extension ======
  if( m_eProfileIdc == SCALABLE_BASELINE_PROFILE || m_eProfileIdc == SCALABLE_HIGH_PROFILE )
  {
    RNOK( pcWriteIf->writeFlag( getInterlayerDeblockingPresent(),       "SPS: inter_layer_deblocking_filter_control_present_flag" ) ); //VB-JV 04/08
    RNOK( pcWriteIf->writeCode( getExtendedSpatialScalability(), 2,     "SPS: extended_spatial_scalability" ) );

    if (getChromaFormatIdc() == 1 || getChromaFormatIdc() == 2 )
    {
      RNOK( pcWriteIf->writeCode( m_uiChromaPhaseXPlus1, 1,             "SPS: chroma_phase_x_plus1_flag" ) ); //VB-JV 04/08
    }
    if (getChromaFormatIdc() == 1 )  
    {
      RNOK( pcWriteIf->writeCode( m_uiChromaPhaseYPlus1, 2,             "SPS: chroma_phase_y_plus1" ) ); 
    }
    if( getExtendedSpatialScalability() == ESS_SEQ )
    {
      if (getChromaFormatIdc() > 0 )
      {
        RNOK( pcWriteIf->writeCode( m_uiBaseChromaPhaseXPlus1, 1,       "SPS: seq_ref_layer_chroma_phase_x_plus1_flag" ) );  //VB-JV 04/08
        RNOK( pcWriteIf->writeCode( m_uiBaseChromaPhaseYPlus1, 2,       "SPS: seq_ref_layer_chroma_phase_y_plus1" ) );       //VB-JV 04/08
      }
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseLeftOffset,              "SPS: seq_scaled_ref_layer_left_offset" ) );         //VB-JV 04/08
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseTopOffset,               "SPS: seq_scaled_ref_layer_top_offset" ) );          //VB-JV 04/08
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseRightOffset,             "SPS: seq_scaled_ref_layer_right_offset" ) );        //VB-JV 04/08
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseBottomOffset,            "SPS: seq_scaled_ref_layer_bottom_offset" ) );       //VB-JV 04/08
    }
    RNOK( pcWriteIf->writeFlag( m_bAVCRewriteFlag,                      "SPS: seq_tcoeff_level_prediction_flag" ) );
    if( m_bAVCRewriteFlag )
    {
      RNOK( pcWriteIf->writeFlag( m_bAVCAdaptiveRewriteFlag,            "SPS: adaptive_tcoeff_level_prediction_flag" ) );
    }
    RNOK( pcWriteIf->writeFlag( m_bAVCHeaderRewriteFlag,                "SPS: slice_header_restriction_flag" ) );

    //===== SVC VUI extension ====
    RNOK( pcWriteIf->writeFlag( getSVCVUIParametersPresentFlag(),       "SPS: svc_vui_parameters_present_flag" ) );
    if( getSVCVUIParametersPresentFlag() )
    {
      RNOK( m_pcVUI->writeSVCExtension( pcWriteIf ) );
    }
  }

  RNOK( pcWriteIf->writeFlag( getAdditionalExtension2Flag(),            "SPS: additional_extension2_flag" ) );
  ROT ( getAdditionalExtension2Flag() ); // not supported

  return Err::m_nOK;
}


ErrVal
SequenceParameterSet::read( HeaderSymbolReadIf* pcReadIf,
                            NalUnitType         eNalUnitType )
{