sequenceparameterset.cpp

jsvm开发代码包括抽样,编码,抽取,解码等一系列功能,可以做工具或研究用

UInt
SequenceParameterSet::getLevelIdc( UInt uiMbY, UInt uiMbX, UInt uiOutFreq, UInt uiMvRange, UInt uiNumRefPic )
{
  UInt uiFrameSize = uiMbY * uiMbX;
  UInt uiMbPerSec  = uiFrameSize * 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 = m_uiLayerId;
  ETRACE_LAYER(m_uiLayerId);
  ETRACE_HEADER( "SEQUENCE PARAMETER SET" );
  RNOK  ( pcWriteIf->writeFlag( 0,                                        "NALU HEADER: forbidden_zero_bit" ) );
  RNOK  ( pcWriteIf->writeCode( 3, 2,                                     "NALU HEADER: nal_ref_idc" ) );
  RNOK  ( pcWriteIf->writeCode( m_eNalUnitType, 5,                        "NALU HEADER: nal_unit_type" ) );

  //===== Sequence parameter set =====
  RNOK  ( pcWriteIf->writeCode( getProfileIdc(),                  8,      "SPS: profile_idc" ) );
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet0Flag,                   "SPS: constrained_set0_flag" ) );
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet1Flag,                   "SPS: constrained_set1_flag" ) );
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet2Flag,                   "SPS: constrained_set2_flag" ) );
  RNOK  ( pcWriteIf->writeFlag( m_bConstrainedSet3Flag,                   "SPS: constrained_set3_flag" ) );
  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 ) ); //bug fix JV 07/11/06
  
  if( m_eProfileIdc == SCALABLE_PROFILE ) // bug-fix (HS)
  {

    RNOK( pcWriteIf->writeFlag( getInterlayerDeblockingPresent(),       "SPS: interlayer_deblocking_filter_control_present_flag" ) );

    RNOK( pcWriteIf->writeCode( getExtendedSpatialScalability(), 2,     "SPS: extended_spatial_scalability" ) );
//    if ( 1 /* chroma_format_idc */ > 0 )
    {
      RNOK( pcWriteIf->writeCode( m_uiChromaPhaseXPlus1, 2,             "SPS: chroma_phase_x_plus1" ) );
      RNOK( pcWriteIf->writeCode( m_uiChromaPhaseYPlus1, 2,             "SPS: chroma_phase_y_plus1" ) );
    }
    if (getExtendedSpatialScalability() == ESS_SEQ)
    {
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseLeftOffset,              "SPS: scaled_base_left_offset" ) );
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseTopOffset,               "SPS: scaled_base_top_offset" ) );
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseRightOffset,             "SPS: scaled_base_right_offset" ) );
      RNOK( pcWriteIf->writeSvlc( m_iScaledBaseBottomOffset,            "SPS: scaled_base_bottom_offset" ) );
    }

#ifdef _JVTV074_
    Int k, kmin;
    UInt uiResampleFilterIdx;
    Int iResampleFilterParamA, iResampleFilterParamB;


    RNOK( pcWriteIf->writeUvlc(m_uiNumResampleFiltersMinus1,         "SPS: NumResampleFiltersMinus1" ) );
    for (uiResampleFilterIdx = 0; uiResampleFilterIdx <= m_uiNumResampleFiltersMinus1; uiResampleFilterIdx++)
    {
        RNOK( pcWriteIf->writeFlag( m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx],  "SPS: IntegerPosFilterPresentFlag" ) );
        kmin = (!m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx]);
        for (k = 7; k >= kmin; k--)
        {
            if (k == 6)
                iResampleFilterParamA = m_iResampleFilterParamA[uiResampleFilterIdx][6] - m_iResampleFilterParamA[uiResampleFilterIdx][7];
            else if (k < 6)
                iResampleFilterParamA = m_iResampleFilterParamA[uiResampleFilterIdx][k] - 2 * m_iResampleFilterParamA[uiResampleFilterIdx][k+1] + m_iResampleFilterParamA[uiResampleFilterIdx][k+2];
            else //k == 7
                iResampleFilterParamA = m_iResampleFilterParamA[uiResampleFilterIdx][7];
            RNOK( pcWriteIf->writeSvlc( iResampleFilterParamA, "SPS: ResampleFilterParamA" ) );
        }
        for (k = 1; k <= 8; k++) {
            if (k == 2)
                iResampleFilterParamB = m_iResampleFilterParamB[uiResampleFilterIdx][2] - m_iResampleFilterParamB[uiResampleFilterIdx][1];
            else if (k > 2)
                iResampleFilterParamB = m_iResampleFilterParamB[uiResampleFilterIdx][k] - 2 * m_iResampleFilterParamB[uiResampleFilterIdx][k-1] + m_iResampleFilterParamB[uiResampleFilterIdx][k-2];
            else //k == 1;
                iResampleFilterParamB = m_iResampleFilterParamB[uiResampleFilterIdx][1];
            RNOK( pcWriteIf->writeSvlc( iResampleFilterParamB, "SPS: ResampleFilterParamB" ) );
        }

    }
#endif // _JVTV074_

    RNOK  ( pcWriteIf->writeFlag( m_bFGSInfoPresentFlag,                       "SPS: fgs_info_present") );
    if( m_bFGSInfoPresentFlag ) 
    {
      RNOK  ( pcWriteIf->writeFlag( m_bFGSCycleAlignedFragment,                "SPS: fgs_cycle_aligned_fragment") );
      RNOK  ( pcWriteIf->writeUvlc( m_uiNumFGSVectModes-1,                     "SPS: fgs_number_vector_modes") );

      UInt ui;
      for( ui = 0; ui < m_uiNumFGSVectModes; ui++ )
      {
        RNOK  ( pcWriteIf->writeFlag( m_abFGSCodingMode[ui],                   "SPS: fgs_coding_mode") );
        if(m_abFGSCodingMode[ ui ] == false)
        {
          RNOK  ( pcWriteIf->writeUvlc((m_auiGroupingSize[ui]-1),              "SPS: GroupingSizeMinus1") );
        }
        else
        {
          UInt uiIndex = 0;
          UInt uiRemainingVectLen = 16; 
          UInt auiReverseVectLen[16]; 
          
          for( uiIndex = 0; uiIndex < m_auiNumPosVectors[ui]; uiIndex ++ )
            auiReverseVectLen [ m_auiNumPosVectors[ ui ] -1 - uiIndex ] = m_auiPosVect[ui][uiIndex];

          uiIndex = 0; 
          do 
          {
            UInt uiCodeLen = ( uiRemainingVectLen <= 4 ) ? ( ( uiRemainingVectLen <= 2 ) ? 1 : 2 ) : ( uiRemainingVectLen <= 8 ) ? 3 : 4;

            if( uiRemainingVectLen > 1 )
              RNOK( pcWriteIf->writeCode( auiReverseVectLen[uiIndex] - 1, uiCodeLen,  "SPS: ReverseVectLen") );
            uiRemainingVectLen -= auiReverseVectLen [ uiIndex ];
            uiIndex++;
          } while( uiRemainingVectLen > 0 );
        }
      }
    }

    if( getExtendedSpatialScalability() == ESS_NONE )
    {
      RNOK( pcWriteIf->writeFlag( m_bAVCRewriteFlag,                    "SPS: AVC_rewrite_flag" ) );
      if( m_bAVCRewriteFlag )
        RNOK( pcWriteIf->writeFlag( m_bAVCAdaptiveRewriteFlag,        "SPS: AVC_adaptive_rewrite_flag" ) );
    }
  }
  
  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_minus_1" ) );
  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" ) );
  RNOK  ( pcWriteIf->writeFlag( false,                                    "SPS: frame_cropping_flag" ) );

  RNOK  ( pcWriteIf->writeFlag( false,                                  "SPS: vui_parameters_present_flag" ) );

  Bool bRCDO  = ( m_bRCDOBlockSizes ||
                  m_bRCDOMotionCompensationY ||
                  m_bRCDOMotionCompensationC ||
                  m_bRCDODeblocking );
  if(  bRCDO )
  {
    RNOK( pcWriteIf->writeFlag( m_b4TapMotionCompensationY,  "4TAPMC: 4tap_motion_compensation_y" ) );  // V090
    RNOK( pcWriteIf->writeFlag( m_bRCDOBlockSizes,           "RCDO: rdco_block_sizes"           ) ); // not really required by decoder
    RNOK( pcWriteIf->writeFlag( m_bRCDOMotionCompensationY,  "RCDO: rdco_motion_compensation_y" ) );
    RNOK( pcWriteIf->writeFlag( m_bRCDOMotionCompensationC,  "RCDO: rdco_motion_compensation_c" ) );
    RNOK( pcWriteIf->writeFlag( m_bRCDODeblocking,           "RCDO: rdco_deblocking"            ) );
  }
  else if( m_b4TapMotionCompensationY)  // V090
	  RNOK( pcWriteIf->writeFlag( m_b4TapMotionCompensationY,    "4TAPMC: 4tap_motion_compensation_y" ) );  // V090


  return Err::m_nOK;
}


ErrVal
SequenceParameterSet::read( HeaderSymbolReadIf* pcReadIf,
                            NalUnitType         eNalUnitType )
{
  m_uiExtendedSpatialScalability = ESS_NONE;

  //===== NAL unit header =====
  setNalUnitType    ( eNalUnitType );

  Bool  bTmp;
  UInt  uiTmp;

  //===== Sequence parameter set =====
  RNOK  ( pcReadIf->getCode( uiTmp,                               8,      "SPS: profile_idc" ) );
  m_eProfileIdc  = Profile ( uiTmp );
  ROT   ( m_eProfileIdc != BASELINE_PROFILE &&
          m_eProfileIdc != MAIN_PROFILE  &&
          m_eProfileIdc != EXTENDED_PROFILE  &&
          m_eProfileIdc != HIGH_PROFILE  &&
          m_eProfileIdc != SCALABLE_PROFILE );
  RNOK  ( pcReadIf->getFlag( m_bConstrainedSet0Flag,                      "SPS: constrained_set0_flag" ) );
  RNOK  ( pcReadIf->getFlag( m_bConstrainedSet1Flag,                      "SPS: constrained_set1_flag" ) );
  RNOK  ( pcReadIf->getFlag( m_bConstrainedSet2Flag,                      "SPS: constrained_set2_flag" ) );
  RNOK  ( pcReadIf->getFlag( m_bConstrainedSet3Flag,                      "SPS: constrained_set3_flag" ) );
  RNOK  ( pcReadIf->getCode( uiTmp,                               4,      "SPS: reserved_zero_4bits" ) );
  ROT   ( uiTmp );
  RNOK  ( pcReadIf->getCode( m_uiLevelIdc,                        8,      "SPS: level_idc" ) );
  RNOK  ( pcReadIf->getUvlc( m_uiSeqParameterSetId,                       "SPS: seq_parameter_set_id" ) );

   //--- fidelity range extension syntax ---
  RNOK  ( xReadFrext( pcReadIf ) );//bug fix JV 07/11/06

  if( m_eProfileIdc == SCALABLE_PROFILE ) // bug-fix (HS)
  {

    RNOK( pcReadIf->getFlag( m_bInterlayerDeblockingPresent,              "SPS: interlayer_deblocking_filter_control_present_flag" ) );

    RNOK( pcReadIf->getCode( m_uiExtendedSpatialScalability, 2,           "SPS: extended_spatial_scalability" ) );
//    if ( 1 /* chroma_format_idc */ > 0 )
    {
      RNOK( pcReadIf->getCode( m_uiChromaPhaseXPlus1, 2,                  "SPS: chroma_phase_x_plus1" ) );
      RNOK( pcReadIf->getCode( m_uiChromaPhaseYPlus1, 2,                  "SPS: chroma_phase_y_plus1" ) );
    }
    if (m_uiExtendedSpatialScalability == ESS_SEQ)
    {
      RNOK( pcReadIf->getSvlc( m_iScaledBaseLeftOffset,                   "SPS: scaled_base_left_offset" ) );
      RNOK( pcReadIf->getSvlc( m_iScaledBaseTopOffset,                    "SPS: scaled_base_top_offset" ) );
      RNOK( pcReadIf->getSvlc( m_iScaledBaseRightOffset,                  "SPS: scaled_base_right_offset" ) );
      RNOK( pcReadIf->getSvlc( m_iScaledBaseBottomOffset,                 "SPS: scaled_base_bottom_offset" ) );
    }

#ifdef _JVTV074_
    UInt k, uiResampleFilterIdx, kmin;
    Int iResampleFilterParamA, iResampleFilterParamB; 
	Bool bIntegerPosFilterPresentFlag;


    RNOK( pcReadIf->getUvlc( m_uiNumResampleFiltersMinus1,         "SPS: NumResampleFiltersMinus1" ) );
    for (uiResampleFilterIdx = 0; uiResampleFilterIdx <= m_uiNumResampleFiltersMinus1; uiResampleFilterIdx++)
    {
        RNOK( pcReadIf->getFlag( bIntegerPosFilterPresentFlag,  "SPS: IntegerPosFilterPresentFlag" ) );
        m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx] = bIntegerPosFilterPresentFlag;
        if (!m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx])
        {
            m_iResampleFilterParamA[uiResampleFilterIdx][0] = 0;
        }
        m_iResampleFilterParamA[uiResampleFilterIdx][8] = 0;
        m_iResampleFilterParamB[uiResampleFilterIdx][0] = 0;
        kmin = (!m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx]);
        for (k = 7; k >= kmin; k--)
        {
            RNOK( pcReadIf->getSvlc( iResampleFilterParamA, "SPS: ResampleFilterParamA" ) );
            if (k == 6)
                m_iResampleFilterParamA[uiResampleFilterIdx][6] = iResampleFilterParamA +  m_iResampleFilterParamA[uiResampleFilterIdx][7];
            else if (k < 6)
                m_iResampleFilterParamA[uiResampleFilterIdx][k] = iResampleFilterParamA + 2 * m_iResampleFilterParamA[uiResampleFilterIdx][k+1] - m_iResampleFilterParamA[uiResampleFilterIdx][k+2];
            else //k == 7