shithub: openh264

--- a/codec/encoder/core/inc/svc_enc_frame.h

+++ b/codec/encoder/core/inc/svc_enc_frame.h

@@ -118,6 +118,8 @@

 int32_t*                pLastCodedMbIdxOfPartition;     // for dynamic slicing mode

 int32_t*                pFirstMbIdxOfPartition;         // for dynamic slicing mode

 int32_t*                pEndMbIdxOfPartition;           // for dynamic slicing mode

+int32_t*                pFirstMbIdxOfSlice;

+int32_t*                pCountMbNumInSlice;

 bool                    bNeedAdjustingSlicing;

--- a/codec/encoder/core/inc/svc_encode_slice.h

+++ b/codec/encoder/core/inc/svc_encode_slice.h

@@ -143,7 +143,7 @@

 int32_t WelsCodePSlice (sWelsEncCtx* pEncCtx, SSlice* pSlice);

 int32_t WelsCodePOverDynamicSlice (sWelsEncCtx* pEncCtx, SSlice* pSlice);

-int32_t WelsCodeOneSlice (sWelsEncCtx* pEncCtx, const int32_t kiSliceIdx,

+int32_t WelsCodeOneSlice (sWelsEncCtx* pEncCtx, SSlice* pCurSlice,

                           const int32_t keNalType);

 void WelsInitSliceEncodingFuncs (uint32_t uiCpuFlag);

--- a/codec/encoder/core/src/encoder_ext.cpp

+++ b/codec/encoder/core/src/encoder_ext.cpp

@@ -943,6 +943,16 @@

     pDq->ppSliceInLayer = NULL;

+  if (pDq->pFirstMbIdxOfSlice) {

+    pMa->WelsFree (pDq->pFirstMbIdxOfSlice, "pDq->pFirstMbIdxOfSlice");

+    pDq->pFirstMbIdxOfSlice = NULL;

+  }

+  if (pDq->pCountMbNumInSlice) {

+    pMa->WelsFree (pDq->pCountMbNumInSlice, "pDq->pCountMbNumInSlice");

+    pDq->pCountMbNumInSlice = NULL;

+  }

   if (pDq->pNumSliceCodedOfPartition) {

     pMa->WelsFree (pDq->pNumSliceCodedOfPartition, "pNumSliceCodedOfPartition");

     pDq->pNumSliceCodedOfPartition = NULL;

@@ -2468,6 +2478,7 @@

 void WelsInitCurrentDlayerMltslc (sWelsEncCtx* pCtx, int32_t iPartitionNum) {

   SDqLayer* pCurDq      = pCtx->pCurDqLayer;

   SSliceCtx* pSliceCtx  = &pCurDq->sSliceEncCtx;

+  uint32_t  uiMiniPacketSize  = 0;

   UpdateSlicepEncCtxWithPartition (pCurDq, iPartitionNum);

@@ -2498,12 +2509,9 @@

     //MINPACKETSIZE_CONSTRAINT

-    if (pSliceCtx->uiSliceSizeConstraint

-        <

-        (uint32_t) (uiFrmByte//suppose 16 byte per mb at average

-                    / (pSliceCtx->iMaxSliceNumConstraint))

-       ) {

+    //suppose 16 byte per mb at average

+    uiMiniPacketSize = (uint32_t) (uiFrmByte / pSliceCtx->iMaxSliceNumConstraint);

+    if (pSliceCtx->uiSliceSizeConstraint < uiMiniPacketSize ) {

       WelsLog (& (pCtx->sLogCtx),

                WELS_LOG_WARNING,

                "Set-SliceConstraint(%d) too small for current resolution (MB# %d) under QP/BR!",

@@ -3660,8 +3668,9 @@

     iLayerSize = 0;

     if (SM_SINGLE_SLICE == pParam->sSliceArgument.uiSliceMode) { // only one slice within a sQualityStat layer

-      int32_t iSliceSize = 0;

+      int32_t iSliceSize   = 0;

       int32_t iPayloadSize = 0;

+      SSlice* pCurSlice    = pCtx->pCurDqLayer->ppSliceInLayer[0];

       if (pCtx->bNeedPrefixNalFlag) {

         pCtx->iEncoderError = AddPrefixNal (pCtx, pLayerBsInfo, &pLayerBsInfo->pNalLengthInByte[0], &iNalIdxInLayer, eNalType,

@@ -3672,8 +3681,8 @@

       WelsLoadNal (pCtx->pOut, eNalType, eNalRefIdc);

-      pCtx->iEncoderError = WelsCodeOneSlice (pCtx, 0, eNalType);

+      assert (0 == (int) pCurSlice->uiSliceIdx);

+      pCtx->iEncoderError   = WelsCodeOneSlice (pCtx, pCurSlice, eNalType);

       WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)

       WelsUnloadNal (pCtx->pOut);

@@ -3793,11 +3802,11 @@

 #endif

         //TO DO: add update ppSliceInLayer module based on pSliceInThread[ThreadNum]

         // UpdateSliceInLayerInfo(); // reordering

         iLayerSize = AppendSliceToFrameBs (pCtx, pLayerBsInfo, kiPartitionCnt);

       } else { // for non-dynamic-slicing mode single threading branch..

         const bool bNeedPrefix = pCtx->bNeedPrefixNalFlag;

         int32_t iSliceIdx = 0;

+        SSlice* pCurSlice = NULL;

         iSliceCount = GetCurrentSliceNum (pCtx->pCurDqLayer);

         while (iSliceIdx < iSliceCount) {

@@ -3812,7 +3821,9 @@

           WelsLoadNal (pCtx->pOut, eNalType, eNalRefIdc);

-          pCtx->iEncoderError = WelsCodeOneSlice (pCtx, iSliceIdx, eNalType);

+          pCurSlice = pCtx->pCurDqLayer->ppSliceInLayer[iSliceIdx];

+          assert (iSliceIdx == (int) pCurSlice->uiSliceIdx);

+          pCtx->iEncoderError = WelsCodeOneSlice (pCtx, pCurSlice, eNalType);

           WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)

           WelsUnloadNal (pCtx->pOut);

@@ -4432,7 +4443,7 @@

   SDqLayer* pCurLayer = pCtx->pCurDqLayer;

   int32_t iCountNals = pCtx->pOut->iCountNals;

-  int32_t iMaxSliceNumOld = pCurLayer->sSliceEncCtx.iMaxSliceNumConstraint;

+  int32_t iMaxSliceNumOld = pCurLayer->iMaxSliceNum;

   int32_t iMaxSliceNum = iMaxSliceNumOld;

   iCountNals += iMaxSliceNum * (pCtx->pSvcParam->iSpatialLayerNum + pCtx->bNeedPrefixNalFlag);

   iMaxSliceNum *= SLICE_NUM_EXPAND_COEF;

@@ -4499,7 +4510,6 @@

) {

   SDqLayer* pCurLayer                   = pCtx->pCurDqLayer;

-  SSliceCtx* pSliceCtx                  = &pCurLayer->sSliceEncCtx;

   SSlice* pStartSlice                   = pCurLayer->ppSliceInLayer[iStartSliceIdx];

   int32_t iNalIdxInLayer                = *pNalIdxInLayer;

   int32_t iSliceIdx                     = iStartSliceIdx;

@@ -4523,8 +4533,9 @@

   while (iAnyMbLeftInPartition > 0) {

     int32_t iSliceSize      = 0;

     int32_t iPayloadSize    = 0;

+    SSlice* pCurSlice = NULL;

-    if (iSliceIdx >= (pSliceCtx->iMaxSliceNumConstraint - kiSliceIdxStep)) { // insufficient memory in pSliceInLayer[]

+    if (iSliceIdx >= (pCurLayer->iMaxSliceNum - kiSliceIdxStep)) { // insufficient memory in pSliceInLayer[]

       if (pCtx->iActiveThreadsNum == 1) {

         //only single thread support re-alloc now

         if (DynSliceRealloc (pCtx, pFrameBSInfo, pLayerBsInfo)) {

@@ -4532,10 +4543,10 @@

                    "CWelsH264SVCEncoder::WelsCodeOnePicPartition: DynSliceRealloc not successful");

           return ENC_RETURN_MEMALLOCERR;

-      } else if (iSliceIdx >= pSliceCtx->iMaxSliceNumConstraint) {

+      } else if (iSliceIdx >= pCurLayer->iMaxSliceNum) {

         WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR,

-                 "CWelsH264SVCEncoder::WelsCodeOnePicPartition: iSliceIdx(%d) over iMaxSliceNumConstraint(%d)", iSliceIdx,

-                 pSliceCtx->iMaxSliceNumConstraint);

+                 "CWelsH264SVCEncoder::WelsCodeOnePicPartition: iSliceIdx(%d) over iMaxSliceNum(%d)", iSliceIdx,

+                 pCurLayer->iMaxSliceNum);

         return ENC_RETURN_MEMALLOCERR;

@@ -4548,7 +4559,9 @@

     WelsLoadNal (pCtx->pOut, keNalType, keNalRefIdc);

-    iReturn = WelsCodeOneSlice (pCtx, iSliceIdx, keNalType);

+    pCurSlice = pCtx->pCurDqLayer->ppSliceInLayer[iSliceIdx];

+    assert (iSliceIdx == (int) pCurSlice->uiSliceIdx);

+    iReturn = WelsCodeOneSlice (pCtx, pCurSlice, keNalType);

     WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)

     WelsUnloadNal (pCtx->pOut);

--- a/codec/encoder/core/src/ref_list_mgr_svc.cpp

+++ b/codec/encoder/core/src/ref_list_mgr_svc.cpp

@@ -708,7 +708,7 @@

*/

 void WelsUpdateRefSyntax (sWelsEncCtx* pCtx, const int32_t iPOC, const int32_t uiFrameType) {

   int32_t iAbsDiffPicNumMinus1   = -1;

-  SSpatialLayerInternal* pParamD = &pCtx->pSvcParam->sDependencyLayers[pCtx->uiDependencyId];

+  SSpatialLayerInternal* pParamD    = &pCtx->pSvcParam->sDependencyLayers[pCtx->uiDependencyId];

   /*syntax for ref_pic_list_reordering()*/

   if (pCtx->iNumRef0 > 0) {

     iAbsDiffPicNumMinus1 = pParamD->iFrameNum - (pCtx->pRefList0[0]->iFrameNum) - 1;

@@ -911,7 +911,6 @@

   SLTRState* pLtr          = &pCtx->pLtr[pCtx->uiDependencyId];

   int32_t iMaxTid          = WELS_LOG2 (pCtx->pSvcParam->uiGopSize);

   int32_t iMaxActualLtrIdx = -1;

   SSpatialLayerInternal* pParamD    = &pCtx->pSvcParam->sDependencyLayers[pCtx->uiDependencyId];

   if (pCtx->pSvcParam->bEnableLongTermReference)

     iMaxActualLtrIdx = pCtx->pSvcParam->iNumRefFrame - STR_ROOM - 1 -  WELS_MAX (iMaxTid , 1);

--- a/codec/encoder/core/src/slice_multi_threading.cpp

+++ b/codec/encoder/core/src/slice_multi_threading.cpp

@@ -594,6 +594,7 @@

       const int32_t kiCurDid            = pEncPEncCtx->uiDependencyId;

       SWelsSvcCodingParam* pCodingParam = pEncPEncCtx->pSvcParam;

       SSpatialLayerConfig* pParamD      = &pCodingParam->sSpatialLayers[kiCurDid];

+      SSlice* pCurSlice                 = NULL;

       pCurDq            = pEncPEncCtx->pCurDqLayer;

       eNalType          = pEncPEncCtx->eNalType;

@@ -635,8 +636,9 @@

         WelsLoadNalForSlice (pSliceBs, eNalType, eNalRefIdc);

-        iReturn = WelsCodeOneSlice (pEncPEncCtx, iSliceIdx, eNalType);

+        pCurSlice = pEncPEncCtx->pCurDqLayer->ppSliceInLayer[iSliceIdx];

+        assert (iSliceIdx == (int) pCurSlice->uiSliceIdx);

+        iReturn = WelsCodeOneSlice (pEncPEncCtx, pCurSlice, eNalType);

         if (ENC_RETURN_SUCCESS != iReturn) {

           uiThrdRet = iReturn;

           WELS_THREAD_SIGNAL_AND_BREAK (pEncPEncCtx->pSliceThreading->pSliceCodedEvent,

@@ -686,7 +688,6 @@

         WelsEventSignal (

           &pEncPEncCtx->pSliceThreading->pSliceCodedMasterEvent);

       } else { // for SM_SIZELIMITED_SLICE parallelization

-        SSliceCtx* pSliceCtx                    = &pCurDq->sSliceEncCtx;

         const int32_t kiPartitionId             = iThreadIdx;

         const int32_t kiSliceIdxStep            = pEncPEncCtx->iActiveThreadsNum;

         const int32_t kiFirstMbInPartition      = pCurDq->pFirstMbIdxOfPartition[kiPartitionId];

@@ -700,14 +701,14 @@

         pCurDq->pLastCodedMbIdxOfPartition[kiPartitionId]       = 0;

         while (iAnyMbLeftInPartition > 0) {

-          if (iSliceIdx >= pSliceCtx->iMaxSliceNumConstraint) {

+          if (iSliceIdx >= pCurDq->iMaxSliceNum) {

             // TODO: need exception handler for not large enough of MAX_SLICES_NUM related memory usage

             // No idea about its solution due MAX_SLICES_NUM is fixed lenght in relevent pData structure

             uiThrdRet = 1;

             WelsLog (&pEncPEncCtx->sLogCtx, WELS_LOG_WARNING,

-                     "[MT] CodingSliceThreadProc Too many slices: coding_idx %d, iSliceIdx %d, pSliceCtx->iMaxSliceNumConstraint %d",

+                     "[MT] CodingSliceThreadProc Too many slices: coding_idx %d, iSliceIdx %d, pCurDq->iMaxSliceNum %d",

                      pParamInternal->iCodingIndex,

-                     iSliceIdx, pSliceCtx->iMaxSliceNumConstraint);

+                     iSliceIdx, pCurDq->iMaxSliceNum);

             WELS_THREAD_SIGNAL_AND_BREAK (pEncPEncCtx->pSliceThreading->pSliceCodedEvent,

                                           pEncPEncCtx->pSliceThreading->pSliceCodedMasterEvent,

                                           iEventIdx);

@@ -735,8 +736,9 @@

           WelsLoadNalForSlice (pSliceBs, eNalType, eNalRefIdc);

-          iReturn = WelsCodeOneSlice (pEncPEncCtx, iSliceIdx, eNalType);

+          pCurSlice = pEncPEncCtx->pCurDqLayer->ppSliceInLayer[iSliceIdx];

+          assert (iSliceIdx == (int) pCurSlice->uiSliceIdx);

+          iReturn = WelsCodeOneSlice (pEncPEncCtx, pCurSlice, eNalType);

           if (ENC_RETURN_SUCCESS != iReturn) {

             uiThrdRet = iReturn;

             WELS_THREAD_SIGNAL_AND_BREAK (pEncPEncCtx->pSliceThreading->pSliceCodedEvent,

--- a/codec/encoder/core/src/svc_enc_slice_segment.cpp

+++ b/codec/encoder/core/src/svc_enc_slice_segment.cpp

@@ -455,8 +455,8 @@

     pSliceSeg->iMbHeight        = 0;

     pSliceSeg->iSliceNumInFrame = 0;

     pSliceSeg->iMbNumInFrame    = 0;

-    pSliceSeg->uiSliceSizeConstraint = 0;

-    pSliceSeg->iMaxSliceNumConstraint    = 0;

+    pSliceSeg->uiSliceSizeConstraint   = 0;

+    pSliceSeg->iMaxSliceNumConstraint  = 0;

@@ -663,6 +663,8 @@

     SSliceHeaderExt* pSliceHeaderExt              = &ppSliceInLayer[iSliceIdx]->sSliceHeaderExt;

     pSliceHeaderExt->sSliceHeader.iFirstMbInSlice = iFirstMbIdx;

     ppSliceInLayer[iSliceIdx]->iCountMbNumInSlice = kiSliceRun;

+    pCurDq->pFirstMbIdxOfSlice[iSliceIdx]         = iFirstMbIdx;

+    pCurDq->pCountMbNumInSlice[iSliceIdx]         = kiSliceRun;

     WelsSetMemMultiplebytes_c(pSliceCtx->pOverallMbMap + iFirstMbIdx, iSliceIdx,

                               kiSliceRun, sizeof(uint16_t));

--- a/codec/encoder/core/src/svc_encode_slice.cpp

+++ b/codec/encoder/core/src/svc_encode_slice.cpp

@@ -1061,6 +1061,18 @@

     return ENC_RETURN_MEMALLOCERR;

+  pDqLayer->pFirstMbIdxOfSlice = (int32_t*)pMa->WelsMallocz (sizeof (int32_t*) * iMaxSliceNum, "pFirstMbIdxOfSlice");

+  if (NULL ==  pDqLayer->pFirstMbIdxOfSlice) {

+    WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitSliceInLayer() pDqLayer->pFirstMbIdxOfSlice is NULL");

+    return ENC_RETURN_MEMALLOCERR;

+  }

+  pDqLayer->pCountMbNumInSlice = (int32_t*)pMa->WelsMallocz (sizeof (int32_t*) * iMaxSliceNum, "pCountMbNumInSlice");

+  if (NULL ==  pDqLayer->pCountMbNumInSlice) {

+    WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitSliceInLayer() pDqLayer->pCountMbNumInSlice is NULL");

+    return ENC_RETURN_MEMALLOCERR;

+  }

   InitSliceThreadInfo (pCtx,

                        pDqLayer,

                        kiDlayerIndex,

@@ -1267,17 +1279,20 @@

*/

 int32_t ReallocSliceBuffer (sWelsEncCtx* pCtx) {

   CMemoryAlign* pMA        = pCtx->pMemAlign;

   SDqLayer* pCurLayer      = pCtx->pCurDqLayer;

   SSlice** ppSlice         = NULL;

-  int32_t iMaxSliceNumOld  = pCurLayer->sSliceEncCtx.iMaxSliceNumConstraint;

+  int32_t iMaxSliceNumOld  = pCurLayer->iMaxSliceNum;

   int32_t iMaxSliceNumNew  = 0;

   int32_t iRet             = 0;

   int32_t iSliceIdx        = 0;

   const int32_t kiCurDid   = pCtx->uiDependencyId;

+  int32_t* pFirstMbIdxofSlice    = NULL;

+  int32_t* pCountMbNumInSlice    = NULL;

   SSlice* pLastCodedSlice        = pCurLayer->sSliceThreadInfo.pSliceInThread[0] + (iMaxSliceNumOld - 1);

   SSliceArgument* pSliceArgument = & pCtx->pSvcParam->sSpatialLayers[kiCurDid].sSliceArgument;

   iRet = CalculateNewSliceNum (pCurLayer,

@@ -1307,6 +1322,28 @@

   pMA->WelsFree (pCurLayer->ppSliceInLayer, "ppSliceInLayer");

   pCurLayer->ppSliceInLayer = ppSlice;

+  // update for pFirstMbIdxInSlice

+  pFirstMbIdxofSlice = (int32_t*)pMA->WelsMallocz (sizeof (int32_t*) * iMaxSliceNumNew, "pFirstMbIdxofSlice");

+  if (NULL == pFirstMbIdxofSlice) {

+    WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "CWelsH264SVCEncoder::ReallocSliceBuffer: pFirstMbIdxofSlice is NULL");

+    return ENC_RETURN_MEMALLOCERR;

+  }

+  memset (pFirstMbIdxofSlice, 0, sizeof(int32_t) * iMaxSliceNumNew);

+  memcpy (pFirstMbIdxofSlice, pCurLayer->pFirstMbIdxOfSlice, sizeof (int32_t) * iMaxSliceNumOld);

+  pMA->WelsFree (pCurLayer->pFirstMbIdxOfSlice, "pFirstMbIdxofSlice");

+  pCurLayer->pFirstMbIdxOfSlice = pFirstMbIdxofSlice;

+  // update for pCountMbNumInSlice

+  pCountMbNumInSlice = (int32_t*)pMA->WelsMallocz (sizeof (int32_t*) * iMaxSliceNumNew, "pCountMbNumInSlice");

+  if (NULL == pCountMbNumInSlice) {

+    WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "CWelsH264SVCEncoder::ReallocSliceBuffer: pCountMbNumInSlice is NULL");

+    return ENC_RETURN_MEMALLOCERR;

+  }

+  memset (pCountMbNumInSlice, 0, sizeof(int32_t) * iMaxSliceNumNew);

+  memcpy (pCountMbNumInSlice, pCurLayer->pCountMbNumInSlice, sizeof (int32_t) * iMaxSliceNumOld);

+  pMA->WelsFree (pCurLayer->pCountMbNumInSlice, "pCountMbNumInSlice");

+  pCurLayer->pCountMbNumInSlice = pCountMbNumInSlice;

   for (iSliceIdx = 0; iSliceIdx < iMaxSliceNumNew; iSliceIdx++) {

     pCurLayer->ppSliceInLayer[iSliceIdx] = pCurLayer->sSliceThreadInfo.pSliceInThread[0] + iSliceIdx;

@@ -1315,7 +1352,6 @@

     pCtx->iMaxSliceCount = iMaxSliceNumNew;

-  pCurLayer->sSliceEncCtx.iMaxSliceNumConstraint      = iMaxSliceNumNew;

   pCurLayer->sSliceThreadInfo.iMaxSliceNumInThread[0] = iMaxSliceNumNew;

   pCurLayer->iMaxSliceNum = iMaxSliceNumNew;

   return ENC_RETURN_SUCCESS;

@@ -1394,7 +1430,7 @@

   //reallocate ppSliceInLayer if total encoded slice num exceed max slice num

-  if (iCodedSliceNum > pCurLayer->sSliceEncCtx.iMaxSliceNumConstraint) {

+  if (iCodedSliceNum > pCurLayer->iMaxSliceNum) {

     ppSlice = (SSlice**)pMA->WelsMallocz (sizeof (SSlice*) * iCodedSliceNum, "ppSlice");

     if (NULL == ppSlice) {

       WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "CWelsH264SVCEncoder::SliceLayerInfoUpdate: ppSlice is NULL");

@@ -1403,7 +1439,7 @@

     pMA->WelsFree (pCurLayer->ppSliceInLayer, "ppSliceInLayer");

     pCurLayer->ppSliceInLayer = ppSlice;

-    pCurLayer->sSliceEncCtx.iMaxSliceNumConstraint = iCodedSliceNum;

+    pCurLayer->iMaxSliceNum = iCodedSliceNum;

   //update ppSliceInLayer based on pSliceInThread, reordering based on slice index

@@ -1425,16 +1461,12 @@

*/

-int32_t WelsCodeOneSlice (sWelsEncCtx* pEncCtx, const int32_t kiSliceIdx, const int32_t kiNalType) {

+int32_t WelsCodeOneSlice (sWelsEncCtx* pEncCtx, SSlice* pCurSlice, const int32_t kiNalType) {

   SDqLayer* pCurLayer                   = pEncCtx->pCurDqLayer;

   SNalUnitHeaderExt* pNalHeadExt        = &pCurLayer->sLayerInfo.sNalHeaderExt;

-  SSlice* pCurSlice                     = pCurLayer->ppSliceInLayer[kiSliceIdx];

   SBitStringAux* pBs                    = pCurSlice->pSliceBsa;

   const int32_t kiDynamicSliceFlag      = (pEncCtx->pSvcParam->sSpatialLayers[pEncCtx->uiDependencyId].sSliceArgument.uiSliceMode

                                           == SM_SIZELIMITED_SLICE);

-  assert (kiSliceIdx == (int) pCurSlice->uiSliceIdx);

   if (I_SLICE == pEncCtx->eSliceType) {

     pNalHeadExt->bIdrFlag = 1;

     pCurSlice->sScaleShift = 0;

@@ -1502,7 +1534,6 @@

 #if _DEBUG

   assert (NULL != pNextSlice);

-  // now ( pSliceCtx->iSliceNumInFrame < pSliceCtx->iMaxSliceNumConstraint ) always true by the call of this pFunc

 #endif

   //init next pSlice info

@@ -1554,12 +1585,15 @@

       WelsMutexLock (&pEncCtx->pSliceThreading->mutexSliceNumUpdate);

       //lock the acessing to this variable: pSliceCtx->iSliceNumInFrame

-    const bool    kbSliceNumNotExceedConstraint = pSliceCtx->iSliceNumInFrame <

-        pSliceCtx->iMaxSliceNumConstraint; /*tmp choice to avoid complex memory operation, 100520, to be modify*/

-    const bool    kbSliceIdxNotExceedConstraint = ((int) pCurSlice->uiSliceIdx + kiActiveThreadsNum) <

-        pSliceCtx->iMaxSliceNumConstraint;

-    const bool    kbSliceNumReachConstraint = (pSliceCtx->iSliceNumInFrame ==

-        pSliceCtx->iMaxSliceNumConstraint);

+    //tmp choice to avoid complex memory operation, 100520, to be modify

+    //TODO: pSliceCtx->iSliceNumInFrame should match max slice num limitation in given profile based on standard

+    //      current change is tmp solution which equal to origin design,

+    //      as iMaxSliceNum is always equal to iMaxSliceNumConstraint in origin design

+    //      and will also extend when reallocated,

+    //  tmp change is:  iMaxSliceNumConstraint is alway set to be MAXSLICENUM, will not change even reallocate

+    const bool kbSliceNumNotExceedConstraint = pSliceCtx->iSliceNumInFrame < pEncCtx->pCurDqLayer->iMaxSliceNum;

+    const bool kbSliceIdxNotExceedConstraint = ((int) pCurSlice->uiSliceIdx + kiActiveThreadsNum) < pEncCtx->pCurDqLayer->iMaxSliceNum;

+    const bool kbSliceNumReachConstraint     = (pSliceCtx->iSliceNumInFrame == pEncCtx->pCurDqLayer->iMaxSliceNum);

     //DYNAMIC_SLICING_ONE_THREAD: judge jump_avoiding_pack_exceed

     if (kbSliceNumNotExceedConstraint && kbSliceIdxNotExceedConstraint) {//able to add new pSlice

--- a/codec/encoder/core/src/wels_task_encoder.cpp

+++ b/codec/encoder/core/src/wels_task_encoder.cpp

@@ -163,7 +163,9 @@

   WelsLoadNalForSlice (m_pSliceBs, m_eNalType, m_eNalRefIdc);

-  int32_t iReturn = WelsCodeOneSlice (m_pCtx, m_iSliceIdx, m_eNalType);

+  SSlice* pCurSlice    = m_pCtx->pCurDqLayer->ppSliceInLayer[m_iSliceIdx];

+  assert (m_iSliceIdx == (int) pCurSlice->uiSliceIdx);

+  int32_t iReturn = WelsCodeOneSlice (m_pCtx, pCurSlice, m_eNalType);

   if (ENC_RETURN_SUCCESS != iReturn) {

     return iReturn;

@@ -230,15 +232,11 @@

 //CWelsConstrainedSizeSlicingEncodingTask

 WelsErrorType CWelsConstrainedSizeSlicingEncodingTask::ExecuteTask() {

-  SDqLayer* pCurDq            = m_pCtx->pCurDqLayer;

+  SDqLayer* pCurDq                        = m_pCtx->pCurDqLayer;

   SSliceCtx* pSliceCtx                    = &pCurDq->sSliceEncCtx;

   const int32_t kiSliceIdxStep            = m_pCtx->iActiveThreadsNum;

-  SSpatialLayerInternal* pParamInternal = &m_pCtx->pSvcParam->sDependencyLayers[m_pCtx->uiDependencyId];

+  SSpatialLayerInternal* pParamInternal   = &m_pCtx->pSvcParam->sDependencyLayers[m_pCtx->uiDependencyId];

   SSliceHeaderExt* pStartSliceHeaderExt   = &pCurDq->ppSliceInLayer[m_iSliceIdx]->sSliceHeaderExt;

-  //deal with partition: TODO: here SSliceThreadPrivateData is just for parition info and actually has little relationship with threadbuffer, and iThreadIndex is not used in threadpool model, need renaming after removing old logic to avoid confusion

   const int32_t kiPartitionId             = m_iSliceIdx % kiSliceIdxStep;

   const int32_t kiFirstMbInPartition      = pCurDq->pFirstMbIdxOfPartition[kiPartitionId];

   const int32_t kiEndMbIdxInPartition     = pCurDq->pEndMbIdxOfPartition[kiPartitionId];

@@ -245,11 +243,13 @@

   pStartSliceHeaderExt->sSliceHeader.iFirstMbInSlice      = kiFirstMbInPartition;

   pCurDq->pNumSliceCodedOfPartition[kiPartitionId]        = 1;

   pCurDq->pLastCodedMbIdxOfPartition[kiPartitionId]       = 0;

-  //end of deal with partition

+  //deal with partition: TODO: here SSliceThreadPrivateData is just for parition info and actually has little relationship with threadbuffer, and iThreadIndex is not used in threadpool model, need renaming after removing old logic to avoid confusion

   int32_t iAnyMbLeftInPartition           = kiEndMbIdxInPartition - kiFirstMbInPartition + 1;

   int32_t iLocalSliceIdx = m_iSliceIdx;

   while (iAnyMbLeftInPartition > 0) {

+    //TODO: will reallocate

     if (iLocalSliceIdx >= pSliceCtx->iMaxSliceNumConstraint) {

       WelsLog (&m_pCtx->sLogCtx, WELS_LOG_WARNING,

                "[MT] CWelsConstrainedSizeSlicingEncodingTask ExecuteTask() coding_idx %d, uiLocalSliceIdx %d, pSliceCtx->iMaxSliceNumConstraint %d",

@@ -280,7 +280,9 @@

     WelsLoadNalForSlice (m_pSliceBs, m_eNalType, m_eNalRefIdc);

-    int32_t iReturn = WelsCodeOneSlice (m_pCtx, iLocalSliceIdx, m_eNalType);

+    SSlice* pCurSlice    = m_pCtx->pCurDqLayer->ppSliceInLayer[iLocalSliceIdx];

+    assert (iLocalSliceIdx == (int) pCurSlice->uiSliceIdx);

+    int32_t iReturn = WelsCodeOneSlice (m_pCtx, pCurSlice, m_eNalType);

     if (ENC_RETURN_SUCCESS != iReturn) {

       return iReturn;