/*! * \copy *     Copyright (c)  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. * */ #include "au_set.h"#include "encoder_context.h"#include "paraset_strategy.h" namespace WelsEnc {  IWelsParametersetStrategy*   IWelsParametersetStrategy::CreateParametersetStrategy (  EParameterSetStrategy eSpsPpsIdStrategy, bool bSimulcastAVC,  const int32_t kiSpatialLayerNum) {   IWelsParametersetStrategy* pParametersetStrategy = NULL;  switch (eSpsPpsIdStrategy) {  case INCREASING_ID:    pParametersetStrategy = WELS_NEW_OP (CWelsParametersetIdIncreasing (bSimulcastAVC, kiSpatialLayerNum),                                         CWelsParametersetIdIncreasing);    WELS_VERIFY_RETURN_IF (NULL, NULL == pParametersetStrategy)    break;  case SPS_LISTING:    pParametersetStrategy = WELS_NEW_OP (CWelsParametersetSpsListing (bSimulcastAVC, kiSpatialLayerNum),                                         CWelsParametersetSpsListing);    WELS_VERIFY_RETURN_IF (NULL, NULL == pParametersetStrategy)    break;  case SPS_LISTING_AND_PPS_INCREASING:    pParametersetStrategy = WELS_NEW_OP (CWelsParametersetSpsListingPpsIncreasing (bSimulcastAVC, kiSpatialLayerNum),                                         CWelsParametersetSpsListingPpsIncreasing);    WELS_VERIFY_RETURN_IF (NULL, NULL == pParametersetStrategy)    break;  case SPS_PPS_LISTING:    pParametersetStrategy = WELS_NEW_OP (CWelsParametersetSpsPpsListing (bSimulcastAVC, kiSpatialLayerNum),                                         CWelsParametersetSpsPpsListing);    WELS_VERIFY_RETURN_IF (NULL, NULL == pParametersetStrategy)    break;  case CONSTANT_ID:  default:    pParametersetStrategy = WELS_NEW_OP (CWelsParametersetIdConstant (bSimulcastAVC, kiSpatialLayerNum),                                         CWelsParametersetIdConstant);    WELS_VERIFY_RETURN_IF (NULL, NULL == pParametersetStrategy)    break;  }   return pParametersetStrategy;}  static int32_t WelsGenerateNewSps (sWelsEncCtx* pCtx, const bool kbUseSubsetSps, const int32_t iDlayerIndex,                                   const int32_t iDlayerCount, const int32_t kiSpsId,                                   SWelsSPS*& pSps, SSubsetSps*& pSubsetSps, bool bSVCBaselayer) {  int32_t iRet = 0;   if (!kbUseSubsetSps) {    pSps        = & (pCtx->pSpsArray[kiSpsId]);  } else {    pSubsetSps  = & (pCtx->pSubsetArray[kiSpsId]);    pSps        = &pSubsetSps->pSps;  }   SWelsSvcCodingParam* pParam = pCtx->pSvcParam;  SSpatialLayerConfig* pDlayerParam = &pParam->sSpatialLayers[iDlayerIndex];  // Need port pSps/pPps initialization due to spatial scalability changed  if (!kbUseSubsetSps) {    iRet = WelsInitSps (pSps, pDlayerParam, &pParam->sDependencyLayers[iDlayerIndex], pParam->uiIntraPeriod,                        pParam->iMaxNumRefFrame,                        kiSpsId, pParam->bEnableFrameCroppingFlag, pParam->iRCMode != RC_OFF_MODE, iDlayerCount,                        bSVCBaselayer);  } else {    iRet = WelsInitSubsetSps (pSubsetSps, pDlayerParam, &pParam->sDependencyLayers[iDlayerIndex], pParam->uiIntraPeriod,                              pParam->iMaxNumRefFrame,                              kiSpsId, pParam->bEnableFrameCroppingFlag, pParam->iRCMode != RC_OFF_MODE, iDlayerCount);  }  return iRet;} static bool CheckMatchedSps (SWelsSPS* const pSps1, SWelsSPS* const pSps2) {   if ((pSps1->iMbWidth != pSps2->iMbWidth)      || (pSps1->iMbHeight != pSps2->iMbHeight)) {    return false;  }   if ((pSps1->uiLog2MaxFrameNum != pSps2->uiLog2MaxFrameNum)      || (pSps1->iLog2MaxPocLsb != pSps2->iLog2MaxPocLsb)) {    return false;  }   if (pSps1->iNumRefFrames != pSps2->iNumRefFrames) {    return false;  }   if ((pSps1->bFrameCroppingFlag != pSps2->bFrameCroppingFlag)      || (pSps1->sFrameCrop.iCropLeft != pSps2->sFrameCrop.iCropLeft)      || (pSps1->sFrameCrop.iCropRight != pSps2->sFrameCrop.iCropRight)      || (pSps1->sFrameCrop.iCropTop != pSps2->sFrameCrop.iCropTop)      || (pSps1->sFrameCrop.iCropBottom != pSps2->sFrameCrop.iCropBottom)     ) {    return false;  }   if ((pSps1->uiProfileIdc != pSps2->uiProfileIdc)      || (pSps1->bConstraintSet0Flag != pSps2->bConstraintSet0Flag)      || (pSps1->bConstraintSet1Flag != pSps2->bConstraintSet1Flag)      || (pSps1->bConstraintSet2Flag != pSps2->bConstraintSet2Flag)      || (pSps1->bConstraintSet3Flag != pSps2->bConstraintSet3Flag)      || (pSps1->iLevelIdc != pSps2->iLevelIdc)) {    return false;  }   return true;} static bool CheckMatchedSubsetSps (SSubsetSps* const pSubsetSps1, SSubsetSps* const pSubsetSps2) {  if (!CheckMatchedSps (&pSubsetSps1->pSps, &pSubsetSps2->pSps)) {    return false;  }   if ((pSubsetSps1->sSpsSvcExt.iExtendedSpatialScalability      != pSubsetSps2->sSpsSvcExt.iExtendedSpatialScalability)      || (pSubsetSps1->sSpsSvcExt.bAdaptiveTcoeffLevelPredFlag  != pSubsetSps2->sSpsSvcExt.bAdaptiveTcoeffLevelPredFlag)      || (pSubsetSps1->sSpsSvcExt.bSeqTcoeffLevelPredFlag != pSubsetSps2->sSpsSvcExt.bSeqTcoeffLevelPredFlag)      || (pSubsetSps1->sSpsSvcExt.bSliceHeaderRestrictionFlag != pSubsetSps2->sSpsSvcExt.bSliceHeaderRestrictionFlag)) {    return false;  }   return true;} /*! * \brief   check if the current parameter can found a presenting sps * \param   pParam          the current encoding paramter in SWelsSvcCodingParam * \param   kbUseSubsetSps  bool * \param   iDlayerIndex    int, the index of current D layer * \param   iDlayerCount    int, the number of total D layer * \param pSpsArray         array of all the stored SPSs * \param   pSubsetArray    array of all the stored Subset-SPSs * \return  0 - successful *         -1 - cannot find existing SPS for current encoder parameter */int32_t FindExistingSps (SWelsSvcCodingParam* pParam, const bool kbUseSubsetSps, const int32_t iDlayerIndex,                         const int32_t iDlayerCount, const int32_t iSpsNumInUse,                         SWelsSPS* pSpsArray,                         SSubsetSps* pSubsetArray, bool bSVCBaseLayer) {  SSpatialLayerConfig* pDlayerParam = &pParam->sSpatialLayers[iDlayerIndex];   assert (iSpsNumInUse <= MAX_SPS_COUNT);  if (!kbUseSubsetSps) {    SWelsSPS sTmpSps;    WelsInitSps (&sTmpSps, pDlayerParam, &pParam->sDependencyLayers[iDlayerIndex], pParam->uiIntraPeriod,                 pParam->iMaxNumRefFrame,                 0, pParam->bEnableFrameCroppingFlag, pParam->iRCMode != RC_OFF_MODE, iDlayerCount,                 bSVCBaseLayer);    for (int32_t iId = 0; iId < iSpsNumInUse; iId++) {      if (CheckMatchedSps (&sTmpSps, &pSpsArray[iId])) {        return iId;      }    }  } else {    SSubsetSps sTmpSubsetSps;    WelsInitSubsetSps (&sTmpSubsetSps, pDlayerParam, &pParam->sDependencyLayers[iDlayerIndex], pParam->uiIntraPeriod,                       pParam->iMaxNumRefFrame,                       0, pParam->bEnableFrameCroppingFlag, pParam->iRCMode != RC_OFF_MODE, iDlayerCount);     for (int32_t iId = 0; iId < iSpsNumInUse; iId++) {      if (CheckMatchedSubsetSps (&sTmpSubsetSps, &pSubsetArray[iId])) {        return iId;      }    }  }   return INVALID_ID;} CWelsParametersetIdConstant::CWelsParametersetIdConstant (const bool bSimulcastAVC, const int32_t kiSpatialLayerNum) {  memset (&m_sParaSetOffset, 0, sizeof (m_sParaSetOffset));   m_bSimulcastAVC = bSimulcastAVC;  m_iSpatialLayerNum = kiSpatialLayerNum;   m_iBasicNeededSpsNum = 1;  m_iBasicNeededPpsNum = (1 + m_iSpatialLayerNum);} CWelsParametersetIdConstant::~CWelsParametersetIdConstant() {} int32_t CWelsParametersetIdConstant::GetPpsIdOffset (const int32_t iPpsId) {  return 0;};int32_t CWelsParametersetIdConstant::GetSpsIdOffset (const int32_t iPpsId, const int32_t iSpsId) {  return 0;}; int32_t* CWelsParametersetIdConstant::GetSpsIdOffsetList (const int iParasetType) {  return & (m_sParaSetOffset.sParaSetOffsetVariable[iParasetType].iParaSetIdDelta[0]);} uint32_t CWelsParametersetIdConstant::GetAllNeededParasetNum() {  return (GetNeededSpsNum()          + GetNeededSubsetSpsNum()          + GetNeededPpsNum());} uint32_t CWelsParametersetIdConstant::GetNeededSpsNum() {  if (0 >= m_sParaSetOffset.uiNeededSpsNum) {    m_sParaSetOffset.uiNeededSpsNum = m_iBasicNeededSpsNum * ((m_bSimulcastAVC) ? (m_iSpatialLayerNum) : (1));  }  return m_sParaSetOffset.uiNeededSpsNum;}  uint32_t CWelsParametersetIdConstant::GetNeededSubsetSpsNum() {  if (0 >= m_sParaSetOffset.uiNeededSubsetSpsNum) {    m_sParaSetOffset.uiNeededSubsetSpsNum = (m_bSimulcastAVC ? 0 : (m_iSpatialLayerNum - 1));  }  return m_sParaSetOffset.uiNeededSubsetSpsNum;} uint32_t CWelsParametersetIdConstant::GetNeededPpsNum() {  if (0 == m_sParaSetOffset.uiNeededPpsNum) {    m_sParaSetOffset.uiNeededPpsNum = m_iBasicNeededPpsNum * ((m_bSimulcastAVC) ? (m_iSpatialLayerNum) :                                      (1));  }  return m_sParaSetOffset.uiNeededPpsNum;} void CWelsParametersetIdConstant::LoadPrevious (SExistingParasetList* pExistingParasetList,  SWelsSPS* pSpsArray,    SSubsetSps*       pSubsetArray, SWelsPPS* pPpsArray) {  return;} void CWelsParametersetIdConstant::Update (const uint32_t kuiId, const int iParasetType) {  memset (&m_sParaSetOffset, 0, sizeof (SParaSetOffset));} uint32_t CWelsParametersetIdConstant::GenerateNewSps (sWelsEncCtx* pCtx, const bool kbUseSubsetSps,    const int32_t iDlayerIndex,    const int32_t iDlayerCount, uint32_t kuiSpsId,    SWelsSPS*& pSps, SSubsetSps*& pSubsetSps, bool bSVCBaselayer) {  WelsGenerateNewSps (pCtx, kbUseSubsetSps, iDlayerIndex,                      iDlayerCount, kuiSpsId,                      pSps, pSubsetSps, bSVCBaselayer);  return kuiSpsId;}  uint32_t CWelsParametersetIdConstant::InitPps (sWelsEncCtx* pCtx, uint32_t kiSpsId,    SWelsSPS* pSps,    SSubsetSps* pSubsetSps,    uint32_t kuiPpsId,    const bool kbDeblockingFilterPresentFlag,    const bool kbUsingSubsetSps,    const bool kbEntropyCodingModeFlag) {  WelsInitPps (& pCtx->pPPSArray[kuiPpsId], pSps, pSubsetSps, kuiPpsId, true, kbUsingSubsetSps, kbEntropyCodingModeFlag);  SetUseSubsetFlag (kuiPpsId, kbUsingSubsetSps);  return kuiPpsId;} void CWelsParametersetIdConstant::SetUseSubsetFlag (const uint32_t iPpsId, const bool bUseSubsetSps) {  m_sParaSetOffset.bPpsIdMappingIntoSubsetsps[iPpsId] = bUseSubsetSps;} void CWelsParametersetIdNonConstant::OutputCurrentStructure (SParaSetOffsetVariable* pParaSetOffsetVariable,    int32_t* pPpsIdList, sWelsEncCtx* pCtx, SExistingParasetList* pExistingParasetList) {  for (int32_t k = 0; k < PARA_SET_TYPE; k++) {    memset ((m_sParaSetOffset.sParaSetOffsetVariable[k].bUsedParaSetIdInBs), 0, MAX_PPS_COUNT * sizeof (bool));  }  memcpy (pParaSetOffsetVariable, m_sParaSetOffset.sParaSetOffsetVariable,          (PARA_SET_TYPE)*sizeof (SParaSetOffsetVariable)); // confirmed_safe_unsafe_usage}void CWelsParametersetIdNonConstant::LoadPreviousStructure (SParaSetOffsetVariable* pParaSetOffsetVariable,    int32_t* pPpsIdList) {  memcpy (m_sParaSetOffset.sParaSetOffsetVariable, pParaSetOffsetVariable,          (PARA_SET_TYPE)*sizeof (SParaSetOffsetVariable)); // confirmed_safe_unsafe_usage} ////CWelsParametersetIdIncreasing// void CWelsParametersetIdIncreasing::DebugSpsPps (const int32_t kiPpsId, const int32_t kiSpsId) {#if _DEBUG  //SParaSetOffset use, 110421  //if ( (INCREASING_ID & eSpsPpsIdStrategy)) {  const int32_t kiParameterSetType = (m_sParaSetOffset.bPpsIdMappingIntoSubsetsps[kiPpsId] ?                                      PARA_SET_TYPE_SUBSETSPS : PARA_SET_TYPE_AVCSPS) ;   const int32_t kiTmpSpsIdInBs = kiSpsId +                                 m_sParaSetOffset.sParaSetOffsetVariable[kiParameterSetType].iParaSetIdDelta[kiSpsId];  const int32_t tmp_pps_id_in_bs = kiPpsId +                                   m_sParaSetOffset.sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[kiPpsId];  assert (MAX_SPS_COUNT > kiTmpSpsIdInBs);  assert (MAX_PPS_COUNT > tmp_pps_id_in_bs);  assert (m_sParaSetOffset.sParaSetOffsetVariable[kiParameterSetType].bUsedParaSetIdInBs[kiTmpSpsIdInBs]);  //}#endif}void CWelsParametersetIdIncreasing::DebugPps (const int32_t kiPpsId) {#if _DEBUG  const int32_t kiTmpPpsIdInBs = kiPpsId +                                 m_sParaSetOffset.sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[ kiPpsId ];  assert (MAX_PPS_COUNT > kiTmpPpsIdInBs);   //when activated need to sure there is avialable PPS  assert (m_sParaSetOffset.sParaSetOffsetVariable[PARA_SET_TYPE_PPS].bUsedParaSetIdInBs[kiTmpPpsIdInBs]);#endif} void ParasetIdAdditionIdAdjust (SParaSetOffsetVariable* sParaSetOffsetVariable,                                const int32_t kiCurEncoderParaSetId,                                const uint32_t kuiMaxIdInBs) { //paraset_type = 0: SPS; =1: PPS  //SPS_ID in avc_sps and pSubsetSps will be different using this  //SPS_ID case example:  //1st enter:  next_spsid_in_bs == 0; spsid == 0; delta==0;            //actual spsid_in_bs == 0  //1st finish: next_spsid_in_bs == 1;  //2nd enter:  next_spsid_in_bs == 1; spsid == 0; delta==1;            //actual spsid_in_bs == 1  //2nd finish: next_spsid_in_bs == 2;  //31st enter: next_spsid_in_bs == 31; spsid == 0~2; delta==31~29;     //actual spsid_in_bs == 31  //31st finish:next_spsid_in_bs == 0;  //31st enter: next_spsid_in_bs == 0; spsid == 0~2; delta==-2~0;       //actual spsid_in_bs == 0  //31st finish:next_spsid_in_bs == 1;   const int32_t kiEncId = kiCurEncoderParaSetId;  uint32_t uiNextIdInBs = sParaSetOffsetVariable->uiNextParaSetIdToUseInBs;   //update current layer's pCodingParam  sParaSetOffsetVariable->iParaSetIdDelta[kiEncId] = uiNextIdInBs -      kiEncId;  //for current parameter set, change its id_delta  //write pso pData for next update:  sParaSetOffsetVariable->bUsedParaSetIdInBs[uiNextIdInBs] = true; //   update current used_id   //prepare for next update:  //   find the next avaibable iId  ++uiNextIdInBs;  if (uiNextIdInBs >= kuiMaxIdInBs) {    uiNextIdInBs = 0;//ensure the SPS_ID wound not exceed MAX_SPS_COUNT  }  //   update next_id  sParaSetOffsetVariable->uiNextParaSetIdToUseInBs = uiNextIdInBs;} void CWelsParametersetIdIncreasing::Update (const uint32_t kuiId, const int iParasetType) {#if _DEBUG  m_sParaSetOffset.eSpsPpsIdStrategy = INCREASING_ID;  assert (kuiId < MAX_DQ_LAYER_NUM);#endif   ParasetIdAdditionIdAdjust (& (m_sParaSetOffset.sParaSetOffsetVariable[iParasetType]),                             kuiId,                             (iParasetType != PARA_SET_TYPE_PPS) ? MAX_SPS_COUNT : MAX_PPS_COUNT);}//((SPS_PPS_LISTING != pEncCtx->pSvcParam->eSpsPpsIdStrategy) ? (&//  (pEncCtx->sPSOVector.sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[0])) : NULL) int32_t CWelsParametersetIdIncreasing::GetPpsIdOffset (const int32_t kiPpsId) {#if _DEBUG  DebugPps (kiPpsId);#endif  return (m_sParaSetOffset.sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[kiPpsId]);} int32_t CWelsParametersetIdIncreasing::GetSpsIdOffset (const int32_t kiPpsId, const int32_t kiSpsId) {  const int32_t kiParameterSetType = (m_sParaSetOffset.bPpsIdMappingIntoSubsetsps[kiPpsId] ?                                      PARA_SET_TYPE_SUBSETSPS : PARA_SET_TYPE_AVCSPS);#if _DEBUG  DebugSpsPps (kiPpsId, kiSpsId);#endif  return (m_sParaSetOffset.sParaSetOffsetVariable[kiParameterSetType].iParaSetIdDelta[kiSpsId]);} ////CWelsParametersetSpsListing// CWelsParametersetSpsListing::CWelsParametersetSpsListing (const bool bSimulcastAVC,    const int32_t kiSpatialLayerNum) : CWelsParametersetIdNonConstant (bSimulcastAVC, kiSpatialLayerNum) {  memset (&m_sParaSetOffset, 0, sizeof (m_sParaSetOffset));   m_bSimulcastAVC = bSimulcastAVC;  m_iSpatialLayerNum = kiSpatialLayerNum;   m_iBasicNeededSpsNum = MAX_SPS_COUNT;  m_iBasicNeededPpsNum = 1;} uint32_t CWelsParametersetSpsListing::GetNeededSubsetSpsNum() {  if (0 >= m_sParaSetOffset.uiNeededSubsetSpsNum) {    //      sPSOVector.uiNeededSubsetSpsNum = ((pSvcParam->bSimulcastAVC) ? (0) :((SPS_LISTING & pSvcParam->eSpsPpsIdStrategy) ? (MAX_SPS_COUNT) : (pSvcParam->iSpatialLayerNum - 1)));    m_sParaSetOffset.uiNeededSubsetSpsNum = ((m_bSimulcastAVC) ? (0) :                                            (MAX_SPS_COUNT));  }  return m_sParaSetOffset.uiNeededSubsetSpsNum;} void CWelsParametersetSpsListing::LoadPreviousSps (SExistingParasetList* pExistingParasetList, SWelsSPS* pSpsArray,    SSubsetSps*       pSubsetArray) {  //if ((SPS_LISTING & pParam->eSpsPpsIdStrategy) && (NULL != pExistingParasetList)) {  m_sParaSetOffset.uiInUseSpsNum = pExistingParasetList->uiInUseSpsNum;  memcpy (pSpsArray, pExistingParasetList->sSps, MAX_SPS_COUNT * sizeof (SWelsSPS));   if (GetNeededSubsetSpsNum() > 0) {    m_sParaSetOffset.uiInUseSubsetSpsNum = pExistingParasetList->uiInUseSubsetSpsNum;    memcpy (pSubsetArray, pExistingParasetList->sSubsetSps, MAX_SPS_COUNT * sizeof (SSubsetSps));  } else {    m_sParaSetOffset.uiInUseSubsetSpsNum = 0;  }  //} }void CWelsParametersetSpsListing::LoadPrevious (SExistingParasetList* pExistingParasetList,  SWelsSPS* pSpsArray,    SSubsetSps*       pSubsetArray, SWelsPPS* pPpsArray) {  if (NULL == pExistingParasetList) {    return;  }  LoadPreviousSps (pExistingParasetList, pSpsArray, pSubsetArray);  LoadPreviousPps (pExistingParasetList, pPpsArray);} bool CWelsParametersetSpsListing::CheckParamCompatibility (SWelsSvcCodingParam* pCodingParam, SLogContext* pLogCtx) {  if (pCodingParam->iSpatialLayerNum > 1 && (!pCodingParam->bSimulcastAVC)) {    WelsLog (pLogCtx, WELS_LOG_WARNING,             "ParamValidationExt(), eSpsPpsIdStrategy setting (%d) with multiple svc SpatialLayers (%d) not supported! eSpsPpsIdStrategy adjusted to CONSTANT_ID",             pCodingParam->eSpsPpsIdStrategy, pCodingParam->iSpatialLayerNum);    pCodingParam->eSpsPpsIdStrategy = CONSTANT_ID;    return false;  }  return true;} bool CWelsParametersetSpsListing::CheckPpsGenerating() {  return true;}int32_t CWelsParametersetSpsListing::SpsReset (sWelsEncCtx* pCtx, bool kbUseSubsetSps) {   // reset current list  if (!kbUseSubsetSps) {    m_sParaSetOffset.uiInUseSpsNum = 1;    memset (pCtx->pSpsArray, 0, MAX_SPS_COUNT * sizeof (SWelsSPS));  } else {    m_sParaSetOffset.uiInUseSubsetSpsNum = 1;    memset (pCtx->pSubsetArray, 0, MAX_SPS_COUNT * sizeof (SSubsetSps));  }   //iSpsId = 0;  return 0;}uint32_t CWelsParametersetSpsListing::GenerateNewSps (sWelsEncCtx* pCtx, const bool kbUseSubsetSps,    const int32_t iDlayerIndex,    const int32_t iDlayerCount, uint32_t kuiSpsId,    SWelsSPS*& pSps, SSubsetSps*& pSubsetSps, bool bSvcBaselayer) {  //check if the current param can fit in an existing SPS  const int32_t kiFoundSpsId = FindExistingSps (pCtx->pSvcParam, kbUseSubsetSps, iDlayerIndex, iDlayerCount,                               kbUseSubsetSps ? (m_sParaSetOffset.uiInUseSubsetSpsNum) : (m_sParaSetOffset.uiInUseSpsNum),                               pCtx->pSpsArray,                               pCtx->pSubsetArray, bSvcBaselayer);    if (INVALID_ID != kiFoundSpsId) {    //if yes, set pSps or pSubsetSps to it    kuiSpsId = kiFoundSpsId;    if (!kbUseSubsetSps) {      pSps = & (pCtx->pSpsArray[kiFoundSpsId]);    } else {      pSubsetSps = & (pCtx->pSubsetArray[kiFoundSpsId]);    }  } else {    //if no, generate a new SPS as usual    if (!CheckPpsGenerating()) {      return -1;    } 

Lines 1–500 of 713. Load more