ref: 91331e1ba451ae3b7628d075b6ac8d7075e36e57
dir: /codec/encoder/core/src/paraset_strategy.cpp/
/*! * \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; } kuiSpsId = (!kbUseSubsetSps) ? (m_sParaSetOffset.uiInUseSpsNum++) : (m_sParaSetOffset.uiInUseSubsetSpsNum++); if (kuiSpsId >= MAX_SPS_COUNT) { if (SpsReset (pCtx, kbUseSubsetSps) < 0) { return -1; } kuiSpsId = 0; } WelsGenerateNewSps (pCtx, kbUseSubsetSps, iDlayerIndex, iDlayerCount, kuiSpsId, pSps, pSubsetSps, bSvcBaselayer); } return kuiSpsId; } void CWelsParametersetSpsListing::UpdateParaSetNum (sWelsEncCtx* pCtx) { pCtx->iSpsNum = m_sParaSetOffset.uiInUseSpsNum; pCtx->iSubsetSpsNum = m_sParaSetOffset.uiInUseSubsetSpsNum; }; void CWelsParametersetSpsListing::OutputCurrentStructure (SParaSetOffsetVariable* pParaSetOffsetVariable, int32_t* pPpsIdList, sWelsEncCtx* pCtx, SExistingParasetList* pExistingParasetList) { CWelsParametersetIdNonConstant::OutputCurrentStructure (pParaSetOffsetVariable, pPpsIdList, pCtx, pExistingParasetList); pExistingParasetList->uiInUseSpsNum = m_sParaSetOffset.uiInUseSpsNum; memcpy (pExistingParasetList->sSps, pCtx->pSpsArray, MAX_SPS_COUNT * sizeof (SWelsSPS)); if (NULL != pCtx->pSubsetArray) { pExistingParasetList->uiInUseSubsetSpsNum = m_sParaSetOffset.uiInUseSubsetSpsNum; memcpy (pExistingParasetList->sSubsetSps, pCtx->pSubsetArray, MAX_SPS_COUNT * sizeof (SSubsetSps)); } else { pExistingParasetList->uiInUseSubsetSpsNum = 0; } } // //CWelsParametersetSpsPpsListing // CWelsParametersetSpsPpsListing::CWelsParametersetSpsPpsListing (const bool bSimulcastAVC, const int32_t kiSpatialLayerNum): CWelsParametersetSpsListing (bSimulcastAVC, kiSpatialLayerNum) { memset (&m_sParaSetOffset, 0, sizeof (m_sParaSetOffset)); m_bSimulcastAVC = bSimulcastAVC; m_iSpatialLayerNum = kiSpatialLayerNum; m_iBasicNeededSpsNum = MAX_SPS_COUNT; m_iBasicNeededPpsNum = MAX_PPS_COUNT; } void CWelsParametersetSpsPpsListing::LoadPreviousPps (SExistingParasetList* pExistingParasetList, SWelsPPS* pPpsArray) { // copy from existing if the pointer exists //if ((SPS_PPS_LISTING == pParam->eSpsPpsIdStrategy) && (NULL != pExistingParasetList)) { m_sParaSetOffset.uiInUsePpsNum = pExistingParasetList->uiInUsePpsNum; memcpy (pPpsArray, pExistingParasetList->sPps, MAX_PPS_COUNT * sizeof (SWelsPPS)); //} } /* if ((SPS_PPS_LISTING == pCtx->pSvcParam->eSpsPpsIdStrategy) && (pCtx->iPpsNum < MAX_PPS_COUNT)) { UpdatePpsList (pCtx); }*/ void CWelsParametersetSpsPpsListing::UpdatePpsList (sWelsEncCtx* pCtx) { if (pCtx->iPpsNum >= MAX_PPS_COUNT) { return; } assert (pCtx->iPpsNum <= MAX_DQ_LAYER_NUM); //Generate PPS LIST int32_t iPpsId = 0, iUsePpsNum = pCtx->iPpsNum; for (int32_t iIdrRound = 0; iIdrRound < MAX_PPS_COUNT; iIdrRound++) { for (iPpsId = 0; iPpsId < pCtx->iPpsNum; iPpsId++) { m_sParaSetOffset.iPpsIdList[iPpsId][iIdrRound] = ((iIdrRound * iUsePpsNum + iPpsId) % MAX_PPS_COUNT); } } for (iPpsId = iUsePpsNum; iPpsId < MAX_PPS_COUNT; iPpsId++) { memcpy (& (pCtx->pPPSArray[iPpsId]), & (pCtx->pPPSArray[iPpsId % iUsePpsNum]), sizeof (SWelsPPS)); pCtx->pPPSArray[iPpsId].iPpsId = iPpsId; pCtx->iPpsNum++; } assert (pCtx->iPpsNum == MAX_PPS_COUNT); m_sParaSetOffset.uiInUsePpsNum = pCtx->iPpsNum; } bool CWelsParametersetSpsPpsListing::CheckPpsGenerating() { /*if ((SPS_PPS_LISTING == pCtx->pSvcParam->eSpsPpsIdStrategy) && (MAX_PPS_COUNT <= pCtx->sPSOVector.uiInUsePpsNum)) { //check if we can generate new SPS or not WelsLog (& pCtx->sLogCtx, WELS_LOG_ERROR, "InitDqLayers(), cannot generate new SPS under the SPS_PPS_LISTING mode!"); return ENC_RETURN_UNSUPPORTED_PARA; }*/ if (MAX_PPS_COUNT <= m_sParaSetOffset.uiInUsePpsNum) { return false; } return true; } int32_t CWelsParametersetSpsPpsListing::SpsReset (sWelsEncCtx* pCtx, bool kbUseSubsetSps) { /* if (SPS_PPS_LISTING == pParam->eSpsPpsIdStrategy) { WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_ERROR, "InitDqLayers(), cannot generate new SPS under the SPS_PPS_LISTING mode!"); return ENC_RETURN_UNSUPPORTED_PARA; }*/ return -1; } int32_t FindExistingPps (SWelsSPS* pSps, SSubsetSps* pSubsetSps, const bool kbUseSubsetSps, const int32_t iSpsId, const bool kbEntropyCodingFlag, const int32_t iPpsNumInUse, SWelsPPS* pPpsArray) { #if !defined(DISABLE_FMO_FEATURE) // feature not supported yet return INVALID_ID; #endif//!DISABLE_FMO_FEATURE SWelsPPS sTmpPps; WelsInitPps (&sTmpPps, pSps, pSubsetSps, 0, true, kbUseSubsetSps, kbEntropyCodingFlag); assert (iPpsNumInUse <= MAX_PPS_COUNT); for (int32_t iId = 0; iId < iPpsNumInUse; iId++) { if ((sTmpPps.iSpsId == pPpsArray[iId].iSpsId) && (sTmpPps.bEntropyCodingModeFlag == pPpsArray[iId].bEntropyCodingModeFlag) && (sTmpPps.iPicInitQp == pPpsArray[iId].iPicInitQp) && (sTmpPps.iPicInitQs == pPpsArray[iId].iPicInitQs) && (sTmpPps.uiChromaQpIndexOffset == pPpsArray[iId].uiChromaQpIndexOffset) && (sTmpPps.bDeblockingFilterControlPresentFlag == pPpsArray[iId].bDeblockingFilterControlPresentFlag) ) { return iId; } } return INVALID_ID; } uint32_t CWelsParametersetSpsPpsListing::InitPps (sWelsEncCtx* pCtx, uint32_t kiSpsId, SWelsSPS* pSps, SSubsetSps* pSubsetSps, uint32_t kuiPpsId, const bool kbDeblockingFilterPresentFlag, const bool kbUsingSubsetSps, const bool kbEntropyCodingModeFlag) { const int32_t kiFoundPpsId = FindExistingPps (pSps, pSubsetSps, kbUsingSubsetSps, kiSpsId, kbEntropyCodingModeFlag, m_sParaSetOffset.uiInUsePpsNum, pCtx->pPPSArray); if (INVALID_ID != kiFoundPpsId) { //if yes, set pPps to it kuiPpsId = kiFoundPpsId; } else { kuiPpsId = (m_sParaSetOffset.uiInUsePpsNum++); WelsInitPps (& pCtx->pPPSArray[kuiPpsId], pSps, pSubsetSps, kuiPpsId, true, kbUsingSubsetSps, kbEntropyCodingModeFlag); } SetUseSubsetFlag (kuiPpsId, kbUsingSubsetSps); return kuiPpsId; } void CWelsParametersetSpsPpsListing::UpdateParaSetNum (sWelsEncCtx* pCtx) { CWelsParametersetSpsListing::UpdateParaSetNum (pCtx); //UpdatePpsList (pCtx); pCtx->iPpsNum = m_sParaSetOffset.uiInUsePpsNum; } int32_t CWelsParametersetSpsPpsListing::GetCurrentPpsId (const int32_t iPpsId, const int32_t iIdrLoop) { return m_sParaSetOffset.iPpsIdList[iPpsId][iIdrLoop]; } void CWelsParametersetSpsPpsListing::LoadPreviousStructure (SParaSetOffsetVariable* pParaSetOffsetVariable, int32_t* pPpsIdList) { memcpy (m_sParaSetOffset.sParaSetOffsetVariable, pParaSetOffsetVariable, (PARA_SET_TYPE)*sizeof (SParaSetOffsetVariable)); // confirmed_safe_unsafe_usage memcpy ((m_sParaSetOffset.iPpsIdList), pPpsIdList, MAX_DQ_LAYER_NUM * MAX_PPS_COUNT * sizeof (int32_t)); } void CWelsParametersetSpsPpsListing::OutputCurrentStructure (SParaSetOffsetVariable* pParaSetOffsetVariable, int32_t* pPpsIdList, sWelsEncCtx* pCtx, SExistingParasetList* pExistingParasetList) { CWelsParametersetSpsListing::OutputCurrentStructure (pParaSetOffsetVariable, pPpsIdList, pCtx, pExistingParasetList); pExistingParasetList->uiInUsePpsNum = m_sParaSetOffset.uiInUsePpsNum; memcpy (pExistingParasetList->sPps, pCtx->pPps, MAX_PPS_COUNT * sizeof (SWelsPPS)); memcpy (pPpsIdList, (m_sParaSetOffset.iPpsIdList), MAX_DQ_LAYER_NUM * MAX_PPS_COUNT * sizeof (int32_t)); } // //CWelsParametersetSpsListingPpsIncreasing // int32_t CWelsParametersetSpsListingPpsIncreasing::GetPpsIdOffset (const int32_t kiPpsId) { //same as CWelsParametersetIdIncreasing::GetPpsIdOffset return (m_sParaSetOffset.sParaSetOffsetVariable[PARA_SET_TYPE_PPS].iParaSetIdDelta[kiPpsId]); } void CWelsParametersetSpsListingPpsIncreasing::Update (const uint32_t kuiId, const int iParasetType) { //same as CWelsParametersetIdIncreasing::Update #if _DEBUG assert (kuiId < MAX_DQ_LAYER_NUM); #endif ParasetIdAdditionIdAdjust (& (m_sParaSetOffset.sParaSetOffsetVariable[iParasetType]), kuiId, (iParasetType != PARA_SET_TYPE_PPS) ? MAX_SPS_COUNT : MAX_PPS_COUNT); } }