/*! * \copy *     Copyright (c)  2009-2013, Cisco Systems *     All rights reserved. * *     Redistribution and use in source and binary forms, with or without *     modification, are permitted provided that the following conditions *     are met: * *        * Redistributions of source code must retain the above copyright *          notice, this list of conditions and the following disclaimer. * *        * Redistributions in binary form must reproduce the above copyright *          notice, this list of conditions and the following disclaimer in *          the documentation and/or other materials provided with the *          distribution. * *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT *     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS *     FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE *     COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, *     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER *     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT *     LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN *     ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE *     POSSIBILITY OF SUCH DAMAGE. * * * \file	au_set.c * * \brief	Interfaces introduced in Access Unit level based writer * * \date	05/18/2009 Created * ************************************************************************************* */ #include "au_set.h"#include "svc_enc_golomb.h"#include "macros.h" #include "wels_common_defs.h" using namespace WelsCommon; namespace WelsEnc { static inline int32_t WelsCheckLevelLimitation (const SWelsSPS* kpSps, const SLevelLimits* kpLevelLimit,    float fFrameRate, int32_t iTargetBitRate) {  uint32_t uiPicWidthInMBs = kpSps->iMbWidth;  uint32_t uiPicHeightInMBs = kpSps->iMbHeight;  uint32_t uiPicInMBs = uiPicWidthInMBs * uiPicHeightInMBs;  uint32_t uiNumRefFrames = kpSps->iNumRefFrames;   if (kpLevelLimit->uiMaxMBPS < (uint32_t) (uiPicInMBs * fFrameRate))    return 0;  if (kpLevelLimit->uiMaxFS < uiPicInMBs)    return 0;  if ((kpLevelLimit->uiMaxFS << 3) < (uiPicWidthInMBs * uiPicWidthInMBs))    return 0;  if ((kpLevelLimit->uiMaxFS << 3) < (uiPicHeightInMBs * uiPicHeightInMBs))    return 0;  if (kpLevelLimit->uiMaxDPBMbs < uiNumRefFrames * uiPicInMBs)    return 0;  if ((iTargetBitRate != UNSPECIFIED_BIT_RATE)      && ((int32_t) kpLevelLimit->uiMaxBR  * 1200) < iTargetBitRate)    //RC enabled, considering bitrate constraint    return 0;  //add more checks here if needed in future   return 1; }int32_t WelsAdjustLevel (SSpatialLayerConfig* pSpatialLayer) {  int32_t iLevel = (int32_t)pSpatialLayer->uiLevelIdc;  int32_t iMaxBitrate = pSpatialLayer->iMaxSpatialBitrate;  while (iLevel <= LEVEL_5_2) {    int32_t iLevelMaxBitrate = g_ksLevelLimits[pSpatialLayer->uiLevelIdc - 1].uiMaxBR * CpbBrNalFactor;    if (iMaxBitrate < iLevelMaxBitrate) {      pSpatialLayer->uiLevelIdc = (ELevelIdc)iLevel;      return 0;    }    iLevel++;  }  return 1;} static int32_t WelsCheckNumRefSetting (SLogContext* pLogCtx, SWelsSvcCodingParam* pParam, bool bStrictCheck) {  // validate LTR num  int32_t iCurrentSupportedLtrNum = (pParam->iUsageType == CAMERA_VIDEO_REAL_TIME) ? LONG_TERM_REF_NUM :                                    LONG_TERM_REF_NUM_SCREEN;  if ((pParam->bEnableLongTermReference) && (iCurrentSupportedLtrNum != pParam->iLTRRefNum)) {    WelsLog (pLogCtx, WELS_LOG_WARNING, "iLTRRefNum(%d) does not equal to currently supported %d, will be reset",             pParam->iLTRRefNum, iCurrentSupportedLtrNum);    pParam->iLTRRefNum = iCurrentSupportedLtrNum;  }   //TODO: here is a fix needed here, the most reasonable value should be:  //        iCurrentStrNum = WELS_MAX (1, WELS_LOG2 (pParam->uiGopSize));  //      but reference list updating need to be changed  int32_t iCurrentStrNum = ((pParam->iUsageType == SCREEN_CONTENT_REAL_TIME && pParam->bEnableLongTermReference)                            ? (WELS_MAX (1, WELS_LOG2 (pParam->uiGopSize)))                            : (WELS_MAX (1, (pParam->uiGopSize >> 1))));  int32_t iNeededRefNum = (pParam->uiIntraPeriod != 1) ? (iCurrentStrNum + pParam->iLTRRefNum) : 0;  iNeededRefNum		= WELS_CLIP3 (iNeededRefNum,                                MIN_REF_PIC_COUNT,                                (pParam->iUsageType == CAMERA_VIDEO_REAL_TIME) ? MAX_REFERENCE_PICTURE_COUNT_NUM_CAMERA :                                MAX_REFERENCE_PICTURE_COUNT_NUM_SCREEN);   // to adjust default or invalid input, in case pParam->iNumRefFrame do not have a valid value for the next step  if (pParam->iNumRefFrame == AUTO_REF_PIC_COUNT) {    pParam->iNumRefFrame = iNeededRefNum;  } else if (pParam->iNumRefFrame < iNeededRefNum) {    WelsLog (pLogCtx, WELS_LOG_WARNING,             "iNumRefFrame(%d) setting does not support the temporal and LTR setting, will be reset to %d",             pParam->iNumRefFrame, iNeededRefNum);    if (bStrictCheck) {      return ENC_RETURN_UNSUPPORTED_PARA;    }    pParam->iNumRefFrame = iNeededRefNum;  }   // after adjustment, do the following:  // if the setting is larger than needed, we will use the needed, and write the max into sps and for memory to wait for further expanding  if (pParam->iMaxNumRefFrame < pParam->iNumRefFrame) {    pParam->iMaxNumRefFrame = pParam->iNumRefFrame;  }  pParam->iNumRefFrame = iNeededRefNum;   return ENC_RETURN_SUCCESS;} int32_t WelsCheckRefFrameLimitationNumRefFirst (SLogContext* pLogCtx, SWelsSvcCodingParam* pParam) {   if (WelsCheckNumRefSetting (pLogCtx, pParam, true)) {    // we take num-ref as the honored setting but it conflicts with temporal and LTR    return ENC_RETURN_UNSUPPORTED_PARA;  }  for (int32_t i = 0; i < pParam->iSpatialLayerNum; ++ i) {    SSpatialLayerConfig* pSpatialLayer = &pParam->sSpatialLayers[i];    // when it is NumRefFirst and level is unknown, the level can be set to the lowest and be adjusted later    if (pSpatialLayer->uiLevelIdc == LEVEL_UNKNOWN) {      pSpatialLayer->uiLevelIdc = LEVEL_1_0;    }  }  return ENC_RETURN_SUCCESS;}int32_t WelsCheckRefFrameLimitationLevelIdcFirst (SLogContext* pLogCtx, SWelsSvcCodingParam* pParam) {  if ((pParam->iNumRefFrame == AUTO_REF_PIC_COUNT) || (pParam->iMaxNumRefFrame == AUTO_REF_PIC_COUNT)) {    //no need to do the checking    return ENC_RETURN_SUCCESS;  }   WelsCheckNumRefSetting (pLogCtx, pParam, false);   int32_t i = 0;  int32_t iRefFrame;  //get the number of reference frame according to level limitation.  for (i = 0; i < pParam->iSpatialLayerNum; ++ i) {    SSpatialLayerConfig* pSpatialLayer = &pParam->sSpatialLayers[i];    if (pSpatialLayer->uiLevelIdc == LEVEL_UNKNOWN) {      continue;    }     uint32_t uiPicInMBs = ((pSpatialLayer->iVideoHeight + 15) >> 4) * ((pSpatialLayer->iVideoWidth + 15) >> 4);    iRefFrame = g_ksLevelLimits[pSpatialLayer->uiLevelIdc - 1].uiMaxDPBMbs / uiPicInMBs;     //check iMaxNumRefFrame    if (iRefFrame < pParam->iMaxNumRefFrame) {      WelsLog (pLogCtx, WELS_LOG_WARNING, "iMaxNumRefFrame(%d) adjusted to %d because of limitation from uiLevelIdc=%d",               pParam->iMaxNumRefFrame, iRefFrame, pSpatialLayer->uiLevelIdc);      pParam->iMaxNumRefFrame = iRefFrame;       //check iNumRefFrame      if (iRefFrame < pParam->iNumRefFrame) {        WelsLog (pLogCtx, WELS_LOG_WARNING, "iNumRefFrame(%d) adjusted to %d because of limitation from uiLevelIdc=%d",                 pParam->iNumRefFrame, iRefFrame, pSpatialLayer->uiLevelIdc);        pParam->iNumRefFrame = iRefFrame;      }    } else {      //because it is level first now, so adjust max-ref      WelsLog (pLogCtx, WELS_LOG_INFO,               "iMaxNumRefFrame(%d) adjusted to %d because of uiLevelIdc=%d -- under level-idc first strategy ",               pParam->iMaxNumRefFrame, iRefFrame, pSpatialLayer->uiLevelIdc);      pParam->iMaxNumRefFrame = iRefFrame;    }  }   return ENC_RETURN_SUCCESS;} static inline ELevelIdc WelsGetLevelIdc (const SWelsSPS* kpSps, float fFrameRate, int32_t iTargetBitRate) {  int32_t iOrder;  for (iOrder = 0; iOrder < LEVEL_NUMBER; iOrder++) {    if (WelsCheckLevelLimitation (kpSps, & (g_ksLevelLimits[iOrder]), fFrameRate, iTargetBitRate)) {      return (g_ksLevelLimits[iOrder].uiLevelIdc);    }  }  return LEVEL_5_1; //final decision: select the biggest level}  /*! ************************************************************************************* * \brief	to set Sequence Parameter Set (SPS) * * \param 	pSps 	SWelsSPS to be wrote, update iSpsId dependency * \param	pBitStringAux		bitstream writer auxiliary * * \return	0 - successed *	    	1 - failed * * \note	Call it in case EWelsNalUnitType is SPS. ************************************************************************************* */int32_t WelsWriteSpsSyntax (SWelsSPS* pSps, SBitStringAux* pBitStringAux, int32_t* pSpsIdDelta) {  SBitStringAux* pLocalBitStringAux = pBitStringAux;   assert (pSps != NULL && pBitStringAux != NULL);   BsWriteBits (pLocalBitStringAux, 8, pSps->uiProfileIdc);   BsWriteOneBit (pLocalBitStringAux, pSps->bConstraintSet0Flag);	// bConstraintSet0Flag  BsWriteOneBit (pLocalBitStringAux, pSps->bConstraintSet1Flag);	// bConstraintSet1Flag  BsWriteOneBit (pLocalBitStringAux, pSps->bConstraintSet2Flag);	// bConstraintSet2Flag  BsWriteOneBit (pLocalBitStringAux, pSps->bConstraintSet3Flag);	// bConstraintSet3Flag  BsWriteBits (pLocalBitStringAux, 4, 0);							// reserved_zero_4bits, equal to 0  BsWriteBits (pLocalBitStringAux, 8, pSps->iLevelIdc);				// iLevelIdc  BsWriteUE (pLocalBitStringAux, pSps->uiSpsId + pSpsIdDelta[pSps->uiSpsId]);					     // seq_parameter_set_id   if (PRO_SCALABLE_BASELINE == pSps->uiProfileIdc || PRO_SCALABLE_HIGH == pSps->uiProfileIdc ||      PRO_HIGH == pSps->uiProfileIdc || PRO_HIGH10 == pSps->uiProfileIdc ||      PRO_HIGH422 == pSps->uiProfileIdc || PRO_HIGH444 == pSps->uiProfileIdc ||      PRO_CAVLC444 == pSps->uiProfileIdc || 44 == pSps->uiProfileIdc) {    BsWriteUE (pLocalBitStringAux, 1);  //uiChromaFormatIdc, now should be 1    BsWriteUE (pLocalBitStringAux, 0); //uiBitDepthLuma    BsWriteUE (pLocalBitStringAux, 0); //uiBitDepthChroma    BsWriteOneBit (pLocalBitStringAux, 0); //qpprime_y_zero_transform_bypass_flag    BsWriteOneBit (pLocalBitStringAux, 0); //seq_scaling_matrix_present_flag  }   BsWriteUE (pLocalBitStringAux, pSps->uiLog2MaxFrameNum - 4);	// log2_max_frame_num_minus4  BsWriteUE (pLocalBitStringAux, 0/*pSps->uiPocType*/);		     // pic_order_cnt_type  BsWriteUE (pLocalBitStringAux, pSps->iLog2MaxPocLsb - 4);	// log2_max_pic_order_cnt_lsb_minus4   BsWriteUE (pLocalBitStringAux, pSps->iNumRefFrames);		// max_num_ref_frames  BsWriteOneBit (pLocalBitStringAux, true/*pSps->bGapsInFrameNumValueAllowedFlag*/);	// bGapsInFrameNumValueAllowedFlag  BsWriteUE (pLocalBitStringAux, pSps->iMbWidth - 1);		// pic_width_in_mbs_minus1  BsWriteUE (pLocalBitStringAux, pSps->iMbHeight - 1);		// pic_height_in_map_units_minus1  BsWriteOneBit (pLocalBitStringAux, true/*pSps->bFrameMbsOnlyFlag*/);	// bFrameMbsOnlyFlag   BsWriteOneBit (pLocalBitStringAux, 0/*pSps->bDirect8x8InferenceFlag*/);	// direct_8x8_inference_flag  BsWriteOneBit (pLocalBitStringAux, pSps->bFrameCroppingFlag);	// bFrameCroppingFlag  if (pSps->bFrameCroppingFlag) {    BsWriteUE (pLocalBitStringAux, pSps->sFrameCrop.iCropLeft);	// frame_crop_left_offset    BsWriteUE (pLocalBitStringAux, pSps->sFrameCrop.iCropRight);	// frame_crop_right_offset    BsWriteUE (pLocalBitStringAux, pSps->sFrameCrop.iCropTop);	// frame_crop_top_offset    BsWriteUE (pLocalBitStringAux, pSps->sFrameCrop.iCropBottom);	// frame_crop_bottom_offset  }   BsWriteOneBit (pLocalBitStringAux, 0/*pSps->bVuiParamPresentFlag*/);	// vui_parameters_present_flag   return 0;}  int32_t WelsWriteSpsNal (SWelsSPS* pSps, SBitStringAux* pBitStringAux, int32_t* pSpsIdDelta) {  WelsWriteSpsSyntax (pSps, pBitStringAux, pSpsIdDelta);   BsRbspTrailingBits (pBitStringAux);   return 0;} /*! ************************************************************************************* * \brief	to write SubSet Sequence Parameter Set * * \param 	sub_sps		subset pSps parsed * \param	pBitStringAux		bitstream writer auxiliary * * \return	0 - successed *		    1 - failed * * \note	Call it in case EWelsNalUnitType is SubSet SPS. ************************************************************************************* */ int32_t WelsWriteSubsetSpsSyntax (SSubsetSps* pSubsetSps, SBitStringAux* pBitStringAux , int32_t* pSpsIdDelta) {  SWelsSPS* pSps = &pSubsetSps->pSps;   WelsWriteSpsSyntax (pSps, pBitStringAux, pSpsIdDelta);   if (pSps->uiProfileIdc == PRO_SCALABLE_BASELINE || pSps->uiProfileIdc == PRO_SCALABLE_HIGH) {    SSpsSvcExt* pSubsetSpsExt = &pSubsetSps->sSpsSvcExt;     BsWriteOneBit (pBitStringAux, true/*pSubsetSpsExt->bInterLayerDeblockingFilterCtrlPresentFlag*/);    BsWriteBits (pBitStringAux, 2, pSubsetSpsExt->iExtendedSpatialScalability);    BsWriteOneBit (pBitStringAux, 0/*pSubsetSpsExt->uiChromaPhaseXPlus1Flag*/);    BsWriteBits (pBitStringAux, 2, 1/*pSubsetSpsExt->uiChromaPhaseYPlus1*/);    if (pSubsetSpsExt->iExtendedSpatialScalability == 1) {      BsWriteOneBit (pBitStringAux, 0/*pSubsetSpsExt->uiSeqRefLayerChromaPhaseXPlus1Flag*/);      BsWriteBits (pBitStringAux, 2, 1/*pSubsetSpsExt->uiSeqRefLayerChromaPhaseYPlus1*/);      BsWriteSE (pBitStringAux, 0/*pSubsetSpsExt->sSeqScaledRefLayer.left_offset*/);      BsWriteSE (pBitStringAux, 0/*pSubsetSpsExt->sSeqScaledRefLayer.top_offset*/);      BsWriteSE (pBitStringAux, 0/*pSubsetSpsExt->sSeqScaledRefLayer.right_offset*/);      BsWriteSE (pBitStringAux, 0/*pSubsetSpsExt->sSeqScaledRefLayer.bottom_offset*/);    }    BsWriteOneBit (pBitStringAux, pSubsetSpsExt->bSeqTcoeffLevelPredFlag);    if (pSubsetSpsExt->bSeqTcoeffLevelPredFlag) {      BsWriteOneBit (pBitStringAux, pSubsetSpsExt->bAdaptiveTcoeffLevelPredFlag);    }    BsWriteOneBit (pBitStringAux, pSubsetSpsExt->bSliceHeaderRestrictionFlag);     BsWriteOneBit (pBitStringAux, false/*pSubsetSps->bSvcVuiParamPresentFlag*/);  }  BsWriteOneBit (pBitStringAux, false/*pSubsetSps->bAdditionalExtension2Flag*/);   BsRbspTrailingBits (pBitStringAux);   return 0;} /*! ************************************************************************************* * \brief	to write Picture Parameter Set (PPS) * * \param 	pPps     	pPps * \param	pBitStringAux		bitstream writer auxiliary * * \return	0 - successed *	    	1 - failed * * \note	Call it in case EWelsNalUnitType is PPS. ************************************************************************************* */int32_t WelsWritePpsSyntax (SWelsPPS* pPps, SBitStringAux* pBitStringAux, SParaSetOffset* pPSOVector) {  SBitStringAux* pLocalBitStringAux = pBitStringAux;   const int32_t kiParameterSetType = (pPSOVector != NULL) ? (pPSOVector->bPpsIdMappingIntoSubsetsps[pPps->iPpsId] ?                                     PARA_SET_TYPE_SUBSETSPS : PARA_SET_TYPE_AVCSPS) : 0;   BsWriteUE (pLocalBitStringAux, pPps->iPpsId             + ((pPSOVector != NULL) ? (pPSOVector->sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[pPps->iPpsId]) : 0));  BsWriteUE (pLocalBitStringAux, pPps->iSpsId             + ((pPSOVector != NULL) ? (pPSOVector->sParaSetOffsetVariable[kiParameterSetType].iParaSetIdDelta[pPps->iSpsId]) : 0)); #if _DEBUG  //SParaSetOffset use, 110421  if ((pPSOVector != NULL) && (INCREASING_ID & pPSOVector->eSpsPpsIdStrategy)) {    const int32_t kiTmpSpsIdInBs = pPps->iSpsId +                                   pPSOVector->sParaSetOffsetVariable[kiParameterSetType].iParaSetIdDelta[pPps->iSpsId];    const int32_t tmp_pps_id_in_bs = pPps->iPpsId +                                     pPSOVector->sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[pPps->iPpsId];    assert (MAX_SPS_COUNT > kiTmpSpsIdInBs);    assert (MAX_PPS_COUNT > tmp_pps_id_in_bs);    assert (pPSOVector->sParaSetOffsetVariable[kiParameterSetType].bUsedParaSetIdInBs[kiTmpSpsIdInBs]);  }#endif   BsWriteOneBit (pLocalBitStringAux, pPps->bEntropyCodingModeFlag);  BsWriteOneBit (pLocalBitStringAux, false/*pPps->bPicOrderPresentFlag*/); #ifdef DISABLE_FMO_FEATURE  BsWriteUE (pLocalBitStringAux, 0/*pPps->uiNumSliceGroups - 1*/);#else  BsWriteUE (pLocalBitStringAux, pPps->uiNumSliceGroups - 1);  if (pPps->uiNumSliceGroups > 1) {    uint32_t i, uiNumBits;     BsWriteUE (pLocalBitStringAux, pPps->uiSliceGroupMapType);     switch (pPps->uiSliceGroupMapType) {    case 0:      for (i = 0; i < pPps->uiNumSliceGroups; i ++) {        BsWriteUE (pLocalBitStringAux, pPps->uiRunLength[i] - 1);      }      break;    case 2:      for (i = 0; i < pPps->uiNumSliceGroups; i ++) {        BsWriteUE (pLocalBitStringAux, pPps->uiTopLeft[i]);        BsWriteUE (pLocalBitStringAux, pPps->uiBottomRight[i]);      }      break;    case 3:    case 4:    case 5:      BsWriteOneBit (pLocalBitStringAux, pPps->bSliceGroupChangeDirectionFlag);      BsWriteUE (pLocalBitStringAux, pPps->uiSliceGroupChangeRate - 1);      break;    case 6:      BsWriteUE (pLocalBitStringAux, pPps->uiPicSizeInMapUnits - 1);      uiNumBits = 0;///////////////////WELS_CEILLOG2(pPps->uiPicSizeInMapUnits);      for (i = 0; i < pPps->uiPicSizeInMapUnits; i ++) {        BsWriteBits (pLocalBitStringAux, uiNumBits, pPps->uiSliceGroupId[i]);      }      break;    default:      break;    }  }#endif//!DISABLE_FMO_FEATURE   BsWriteUE (pLocalBitStringAux, 0/*pPps->uiNumRefIdxL0Active - 1*/);  BsWriteUE (pLocalBitStringAux, 0/*pPps->uiNumRefIdxL1Active - 1*/);    BsWriteOneBit (pLocalBitStringAux, false/*pPps->bWeightedPredFlag*/);  BsWriteBits (pLocalBitStringAux, 2, 0/*pPps->uiWeightedBiPredIdc*/);   BsWriteSE (pLocalBitStringAux, pPps->iPicInitQp - 26);  BsWriteSE (pLocalBitStringAux, pPps->iPicInitQs - 26);   BsWriteSE (pLocalBitStringAux, pPps->uiChromaQpIndexOffset);  BsWriteOneBit (pLocalBitStringAux, pPps->bDeblockingFilterControlPresentFlag);  BsWriteOneBit (pLocalBitStringAux, false/*pPps->bConstainedIntraPredFlag*/);  BsWriteOneBit (pLocalBitStringAux, false/*pPps->bRedundantPicCntPresentFlag*/);   BsRbspTrailingBits (pLocalBitStringAux);   return 0;} static inline bool WelsGetPaddingOffset (int32_t iActualWidth, int32_t iActualHeight,  int32_t iWidth,    int32_t iHeight, SCropOffset& pOffset) {  if ((iWidth < iActualWidth) || (iHeight < iActualHeight))    return false;   // make actual size even  iActualWidth -= (iActualWidth & 1);  iActualHeight -= (iActualHeight & 1);   pOffset.iCropLeft = 0;  pOffset.iCropRight = (iWidth - iActualWidth) / 2;  pOffset.iCropTop = 0;  pOffset.iCropBottom = (iHeight - iActualHeight) / 2;   return (iWidth > iActualWidth) || (iHeight > iActualHeight);}int32_t WelsInitSps (SWelsSPS* pSps, SSpatialLayerConfig* pLayerParam, SSpatialLayerInternal* pLayerParamInternal,                     const uint32_t kuiIntraPeriod, const int32_t kiNumRefFrame,                     const uint32_t kuiSpsId, const bool kbEnableFrameCropping, bool bEnableRc,                     const int32_t kiDlayerCount) {  memset (pSps, 0, sizeof (SWelsSPS));  pSps->uiSpsId		= kuiSpsId;  pSps->iMbWidth	= (pLayerParam->iVideoWidth + 15) >> 4;  pSps->iMbHeight	= (pLayerParam->iVideoHeight + 15) >> 4;   //max value of both iFrameNum and POC are 2^16-1, in our encoder, iPOC=2*iFrameNum, so max of iFrameNum should be 2^15-1.--  pSps->uiLog2MaxFrameNum = 15;//16;  pSps->iLog2MaxPocLsb	= 1 + pSps->uiLog2MaxFrameNum;   pSps->iNumRefFrames	= kiNumRefFrame;	/* min pRef size when fifo pRef operation*/   if (kbEnableFrameCropping) {    // TODO: get frame_crop_left_offset, frame_crop_right_offset, frame_crop_top_offset, frame_crop_bottom_offset    pSps->bFrameCroppingFlag = WelsGetPaddingOffset (pLayerParamInternal->iActualWidth, pLayerParamInternal->iActualHeight,                               pLayerParam->iVideoWidth, pLayerParam->iVideoHeight, pSps->sFrameCrop);  } else {    pSps->bFrameCroppingFlag	= false;  }   pSps->uiProfileIdc	= pLayerParam->uiProfileIdc ? pLayerParam->uiProfileIdc : PRO_BASELINE;  if (pLayerParam->uiProfileIdc == PRO_BASELINE) {    pSps->bConstraintSet0Flag = true;  }  if (pLayerParam->uiProfileIdc <= PRO_MAIN) {    pSps->bConstraintSet1Flag = true;  }  if (kiDlayerCount > 1) {    pSps->bConstraintSet2Flag = true;  }   ELevelIdc uiLevel	= WelsGetLevelIdc (pSps, pLayerParamInternal->fOutputFrameRate, pLayerParam->iSpatialBitrate);  //update level  //for Scalable Baseline, Scalable High, and Scalable High Intra profiles.If level_idc is equal to 9, the indicated level is level 1b.  //for the Baseline, Constrained Baseline, Main, and Extended profiles,If level_idc is equal to 11 and constraint_set3_flag is equal to 1, the indicated level is level 1b.  if ((uiLevel == LEVEL_1_B) &&      ((pSps->uiProfileIdc == PRO_BASELINE) || (pSps->uiProfileIdc == PRO_MAIN) || (pSps->uiProfileIdc == PRO_EXTENDED))) {    uiLevel = LEVEL_1_1;    pSps->bConstraintSet3Flag = true;  }  if (pLayerParam->uiLevelIdc < uiLevel) {    pLayerParam->uiLevelIdc = uiLevel;  }  pSps->iLevelIdc = g_kuiLevelMaps[pLayerParam->uiLevelIdc - 1];  return 0;}  int32_t WelsInitSubsetSps (SSubsetSps* pSubsetSps, SSpatialLayerConfig* pLayerParam,                           SSpatialLayerInternal* pLayerParamInternal,                           const uint32_t kuiIntraPeriod, const int32_t kiNumRefFrame,                           const uint32_t kuiSpsId, const bool kbEnableFrameCropping, bool bEnableRc) {  SWelsSPS* pSps = &pSubsetSps->pSps;   memset (pSubsetSps, 0, sizeof (SSubsetSps)); 

Lines 1–500 of 573. Load more