sequenceparameterset.cpp

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

                m_iResampleFilterParamA[uiResampleFilterIdx][7] = iResampleFilterParamA;
        }
        for (k = 1; k <= 8; k++) 
        {
            RNOK( pcReadIf->getSvlc( iResampleFilterParamB, "SPS: ResampleFilterParamB" ) );
            if (k == 2)
                m_iResampleFilterParamB[uiResampleFilterIdx][2] = iResampleFilterParamB + m_iResampleFilterParamB[uiResampleFilterIdx][1];
            else if (k > 2)
                m_iResampleFilterParamB[uiResampleFilterIdx][k] = iResampleFilterParamB + 2 * m_iResampleFilterParamB[uiResampleFilterIdx][k-1] - m_iResampleFilterParamB[uiResampleFilterIdx][k-2];
            else //k == 1;
                m_iResampleFilterParamB[uiResampleFilterIdx][1] = iResampleFilterParamB;
        }
    }
#endif // _JVTV074_

    RNOK  ( pcReadIf->getFlag( m_bFGSInfoPresentFlag,                       "SPS: fgs_info_present") );
    if( m_bFGSInfoPresentFlag ) 
    {
      RNOK  ( pcReadIf->getFlag( m_bFGSCycleAlignedFragment,                "SPS: fgs_cycle_aligned_fragment") );
      RNOK  ( pcReadIf->getUvlc( m_uiNumFGSVectModes,                       "SPS: fgs_number_fgs_vector_modes") );
      m_uiNumFGSVectModes++;
      ROF ( m_uiNumFGSVectModes <= MAX_NUM_FGS_VECT_MODES ); 

      UInt ui;
      for( ui = 0; ui < m_uiNumFGSVectModes; ui++ )
      {
        RNOK  ( pcReadIf->getFlag( m_abFGSCodingMode[ui],                   "SPS: fgs_coding_mode") );
        if(m_abFGSCodingMode[ ui ] == false)
        {
          RNOK  ( pcReadIf->getUvlc(m_auiGroupingSize[ui],                  "SPS: GroupingSizeMinus1") );
          m_auiGroupingSize[ ui ]++;
        }
        else
        {
          UInt uiIndex = 0;
          UInt uiRemainingVectLen = 16; 
          UInt auiReverseVectLen[16]; 

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

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

          m_auiNumPosVectors[ui] = uiIndex;
          
          for( uiIndex = 0; uiIndex < m_auiNumPosVectors[ui]; uiIndex ++ )
            m_auiPosVect[ui][uiIndex] = auiReverseVectLen [ m_auiNumPosVectors[ ui ] - 1 - uiIndex ];

        }
      }
    }
    else
    {
      m_uiNumFGSVectModes = 0; 
    }

    if( getExtendedSpatialScalability() == ESS_NONE )
    {
      RNOK( pcReadIf->getFlag( m_bAVCRewriteFlag,                       "SPS: AVC_rewrite_flag" ) );
      if( m_bAVCRewriteFlag )
        RNOK( pcReadIf->getFlag( m_bAVCAdaptiveRewriteFlag,           "SPS: AVC_adaptive_rewrite_flag" ) );
    }
  }

  RNOK  ( pcReadIf->getUvlc( uiTmp,                                       "SPS: log2_max_frame_num_minus_4" ) );
  ROT   ( uiTmp > 12 );
  setLog2MaxFrameNum( uiTmp + 4 );
	RNOK  ( xReadPicOrderCntInfo( pcReadIf ) );
  RNOK( pcReadIf->getUvlc( m_uiNumRefFrames,                              "SPS: num_ref_frames" ) );
	RNOK( pcReadIf->getFlag( m_bGapsInFrameNumValueAllowedFlag,             "SPS: gaps_in_frame_num_value_allowed_flag" ) );

	RNOK( pcReadIf->getUvlc( uiTmp,                                         "SPS: pic_width_in_mbs_minus1" ) );
  setFrameWidthInMbs ( 1 + uiTmp );
  RNOK( pcReadIf->getUvlc( uiTmp,                                         "SPS: pic_height_in_map_units_minus1" ) );
  RNOK( pcReadIf->getFlag( m_bFrameMbsOnlyFlag,                           "SPS: frame_mbs_only_flag" ) );
	if( getFrameMbsOnlyFlag() )
  {
    setFrameHeightInMbs( uiTmp+1 );
		setMbAdaptiveFrameFieldFlag( false );
  }
  else
    {
    setFrameHeightInMbs( (uiTmp+1)<<1 );
		RNOK( pcReadIf->getFlag( m_bMbAdaptiveFrameFieldFlag,                 "SPS: mb_adaptive_frame_field_flag"));
    }
  RNOK( pcReadIf->getFlag( m_bDirect8x8InferenceFlag,                     "SPS: direct_8x8_inference_flag" ) );
  RNOK( pcReadIf->getFlag( bTmp,                                          "SPS: frame_cropping_flag" ) );
  ROT ( bTmp );
  
  RNOK( pcReadIf->getFlag( bTmp,                                          "SPS: vui_parameters_present_flag" ) );
  ROT ( bTmp );

  m_b4TapMotionCompensationY = false;                      // V090
  ROFRS( pcReadIf->moreRBSPData(), Err::m_nOK );           // V090
  RNOK ( pcReadIf->getFlag( m_b4TapMotionCompensationY,  "4TAPMC: 4tap_motion_compensation_y" ) );   // V090

  m_bRCDOBlockSizes          = false;
  m_bRCDOMotionCompensationY = false;
  m_bRCDOMotionCompensationC = false;
  m_bRCDODeblocking          = false;
  ROFRS( pcReadIf->moreRBSPData(), Err::m_nOK );
  RNOK ( pcReadIf->getFlag( m_bRCDOBlockSizes,           "RCDO: rdco_block_sizes"           ) ); // not really required by decoder
  RNOK ( pcReadIf->getFlag( m_bRCDOMotionCompensationY,  "RCDO: rdco_motion_compensation_y" ) );
  RNOK ( pcReadIf->getFlag( m_bRCDOMotionCompensationC,  "RCDO: rdco_motion_compensation_c" ) );
  RNOK ( pcReadIf->getFlag( m_bRCDODeblocking,           "RCDO: rdco_deblocking"            ) );

  return Err::m_nOK;
}


ErrVal
SequenceParameterSet::xWriteFrext( HeaderSymbolWriteIf* pcWriteIf ) const
{
  ROTRS( m_eProfileIdc != HIGH_PROFILE      &&
         m_eProfileIdc != HIGH_10_PROFILE   &&
         m_eProfileIdc != HIGH_422_PROFILE  &&
         m_eProfileIdc != HIGH_444_PROFILE  &&
         m_eProfileIdc != SCALABLE_PROFILE, Err::m_nOK );

  RNOK  ( pcWriteIf->writeUvlc( 1,                              "SPS: chroma_format_idc" ) );
  RNOK  ( pcWriteIf->writeUvlc( 0,                              "SPS: bit_depth_luma_minus8" ) );
  RNOK  ( pcWriteIf->writeUvlc( 0,                              "SPS: bit_depth_chroma_minus8" ) );
  RNOK  ( pcWriteIf->writeFlag( false,                          "SPS: qpprime_y_zero_transform_bypass_flag" ) );
  RNOK  ( pcWriteIf->writeFlag( m_bSeqScalingMatrixPresentFlag, "SPS: seq_scaling_matrix_present_flag"  ) );
  
  ROTRS ( ! m_bSeqScalingMatrixPresentFlag, Err::m_nOK );
  RNOK  ( m_cSeqScalingMatrix.write( pcWriteIf, true ) );

  return Err::m_nOK;
}


ErrVal
SequenceParameterSet::xReadFrext( HeaderSymbolReadIf* pcReadIf )
{
  ROTRS( m_eProfileIdc != HIGH_PROFILE      &&
         m_eProfileIdc != HIGH_10_PROFILE   &&
         m_eProfileIdc != HIGH_422_PROFILE  &&
         m_eProfileIdc != HIGH_444_PROFILE  &&
         m_eProfileIdc != SCALABLE_PROFILE, Err::m_nOK );

  UInt  uiTmp;
  Bool  bTmp;
  RNOK( pcReadIf->getUvlc( uiTmp,                               "SPS: chroma_format_idc" ) );
  ROF ( uiTmp == 1 );
  RNOK( pcReadIf->getUvlc( uiTmp,                               "SPS: bit_depth_luma_minus8" ) );
  ROF ( uiTmp == 0 );
  RNOK( pcReadIf->getUvlc( uiTmp,                               "SPS: bit_depth_chroma_minus8" ) );
  ROF ( uiTmp == 0 );
  RNOK( pcReadIf->getFlag( bTmp,                                "SPS: qpprime_y_zero_transform_bypass_flag" ) );
  ROT ( bTmp )
  RNOK( pcReadIf->getFlag( m_bSeqScalingMatrixPresentFlag,      "SPS: seq_scaling_matrix_present_flag") );
  
  ROTRS ( ! m_bSeqScalingMatrixPresentFlag, Err::m_nOK );
  RNOK  ( m_cSeqScalingMatrix.read( pcReadIf, true ) );

  return Err::m_nOK;
}


// TMM_ESS {
Void SequenceParameterSet::setResizeParameters ( const ResizeParameters * params )
{
  m_uiExtendedSpatialScalability = (UInt)params->m_iExtendedSpatialScalability;

  m_uiChromaPhaseXPlus1 = (UInt)(params->m_iChromaPhaseX+1);
  m_uiChromaPhaseYPlus1 = (UInt)(params->m_iChromaPhaseY+1);

  if (m_uiExtendedSpatialScalability == ESS_SEQ)
  {
    m_iScaledBaseLeftOffset   = params->m_iPosX /2;
    m_iScaledBaseTopOffset    = params->m_iPosY /2;
    m_iScaledBaseRightOffset  = (params->m_iGlobWidth - params->m_iPosX - params->m_iOutWidth) /2;
    m_iScaledBaseBottomOffset = (params->m_iGlobHeight - params->m_iPosY - params->m_iOutHeight) /2;
  }
  else
  {
    m_iScaledBaseBottomOffset = 0;
    m_iScaledBaseLeftOffset = 0;
    m_iScaledBaseRightOffset = 0;
    m_iScaledBaseTopOffset = 0;
  }
#ifdef _JVTV074_
  m_uiNumResampleFiltersMinus1 = params->m_uiNumResampleFiltersMinus1;
  Int k;
  UInt uiResampleFilterIdx;
  for (uiResampleFilterIdx = 0; uiResampleFilterIdx <= m_uiNumResampleFiltersMinus1; uiResampleFilterIdx++)
  {
      m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx] = params->m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx];
      for (k = 0; k < 9; k++) 
      {
          m_iResampleFilterParamA[uiResampleFilterIdx][k] = params->m_iResampleFilterParamA[uiResampleFilterIdx][k];
          m_iResampleFilterParamB[uiResampleFilterIdx][k] = params->m_iResampleFilterParamB[uiResampleFilterIdx][k];
      }
  }
#endif // _JVTV074_
 }

Void SequenceParameterSet::getResizeParameters ( ResizeParameters * params ) const
{
  params->m_iExtendedSpatialScalability = m_uiExtendedSpatialScalability;

  params->m_bCrop = (m_uiExtendedSpatialScalability != ESS_NONE);

  int w = m_uiFrameWidthInMbs * 16;
  int h = m_uiFrameHeightInMbs * 16;
  params->m_iGlobWidth  = w;
  params->m_iGlobHeight = h;

  params->m_iChromaPhaseX = (Int)m_uiChromaPhaseXPlus1 - 1;
  params->m_iChromaPhaseY = (Int)m_uiChromaPhaseYPlus1 - 1;


  if (m_uiExtendedSpatialScalability == ESS_SEQ)
  {
    params->m_iPosX       = m_iScaledBaseLeftOffset *2;
    params->m_iPosY       = m_iScaledBaseTopOffset *2;
    params->m_iOutWidth   = w - params->m_iPosX - (m_iScaledBaseRightOffset *2);
    params->m_iOutHeight  = h - params->m_iPosY - (m_iScaledBaseBottomOffset *2);
  }
  else
  {
    params->m_iOutWidth   = w;
    params->m_iOutHeight  = h;
    params->m_iPosX       = 0;
    params->m_iPosY       = 0;
  }
#ifdef _JVTV074_
    params->m_uiNumResampleFiltersMinus1 = m_uiNumResampleFiltersMinus1;
  Int k;
  UInt uiResampleFilterIdx;
  for (uiResampleFilterIdx = 0; uiResampleFilterIdx <= m_uiNumResampleFiltersMinus1; uiResampleFilterIdx++)
  {
      params->m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx] = m_bIntegerPosFilterPresentFlag[uiResampleFilterIdx];
      for (k = 0; k < 9; k++) 
      {

          params->m_iResampleFilterParamA[uiResampleFilterIdx][k] = m_iResampleFilterParamA[uiResampleFilterIdx][k];
          params->m_iResampleFilterParamB[uiResampleFilterIdx][k] = m_iResampleFilterParamB[uiResampleFilterIdx][k];
      }
  }
#endif //_JVTV074_
}
// TMM_ESS }

ErrVal SequenceParameterSet::xReadPicOrderCntInfo( HeaderSymbolReadIf* pcReadIf )
{
  RNOK( pcReadIf->getUvlc( m_uiPicOrderCntType,                  "SPS: pic_order_cnt_type" ) );
  ROT( m_uiPicOrderCntType>2 );

  ROTRS( 2 == m_uiPicOrderCntType, Err::m_nOK );

  if( 0 == m_uiPicOrderCntType )
  {
    UInt uiTmp;
    RNOK( pcReadIf->getUvlc( uiTmp,                              "SPS: log2_max_pic_order_cnt_lsb_minus4" ));
    setLog2MaxPicOrderCntLsb( 4+uiTmp );
  }
	else if( 1 == m_uiPicOrderCntType )
	{
		RNOK( pcReadIf->getFlag( m_bDeltaPicOrderAlwaysZeroFlag,     "SPS: delta_pic_order_always_zero_flag" ));
		RNOK( pcReadIf->getSvlc( m_iOffsetForNonRefPic,              "SPS: offset_for_non_ref_pic" ));
		RNOK( pcReadIf->getSvlc( m_iOffsetForTopToBottomField,       "SPS: offset_for_top_to_bottom_field" ));
		RNOK( pcReadIf->getUvlc( m_uiNumRefFramesInPicOrderCntCycle, "SPS: num_ref_frames_in_pic_order_cnt_cycle" ));
		RNOK( initOffsetForRefFrame( m_uiNumRefFramesInPicOrderCntCycle ) );

		for( UInt i = 0; i < m_uiNumRefFramesInPicOrderCntCycle; i++)
		{
			Int  iTmp;
			RNOK( pcReadIf->getSvlc( iTmp, "SPS: offset_for_ref_frame" ) );
			setOffsetForRefFrame( i, iTmp );
		}
	}

  return Err::m_nOK;
}

H264AVC_NAMESPACE_END