History

change API for slicing part for easier usage (the UseLoadBalancing flag is still under working)

sijchen committed 11 years ago

Commit 33c378f1 parent 24916a626 files · +7334 −7329Browse files

Showing the changes to codec/encoder/core/src/encoder_ext.cpp (1 of 26 files). Show all

Unified · Split

codec/encoder/core/src/encoder_ext.cpp+195−181
@@ -411,14 +411,14 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa · 410 unmodified lines
411411 return ENC_RETURN_UNSUPPORTED_PARA;
412412 }
413413
414− if (pSpatialLayer->sSliceCfg.uiSliceMode >= SM_RESERVED) {
414+ if (pSpatialLayer->sSliceArgument.uiSliceMode >= SM_RESERVED) {
415415 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!",
416− pSpatialLayer->sSliceCfg.uiSliceMode);
416+ pSpatialLayer->sSliceArgument.uiSliceMode);
417417 return ENC_RETURN_UNSUPPORTED_PARA;
418418 }
419− if ((pCodingParam->uiMaxNalSize != 0) && (pSpatialLayer->sSliceCfg.uiSliceMode != SM_DYN_SLICE)) {
419+ if ((pCodingParam->uiMaxNalSize != 0) && (pSpatialLayer->sSliceArgument.uiSliceMode != SM_SIZELIMITED_SLICE)) {
420420 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!,MaxNalSize = %d",
421− pSpatialLayer->sSliceCfg.uiSliceMode, pCodingParam->uiMaxNalSize);
421+ pSpatialLayer->sSliceArgument.uiSliceMode, pCodingParam->uiMaxNalSize);
422422 return ENC_RETURN_UNSUPPORTED_PARA;
423423 }
424424 CheckProfileSetting (pLogCtx, pCodingParam, i, pSpatialLayer->uiProfileIdc);
@@ -426,144 +426,142 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa · 1 unmodified line
426426 //check pSlice settings under multi-pSlice
427427 if (kiPicWidth <= 16 && kiPicHeight <= 16) {
428428 //only have one MB, set to single_slice
429− pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
429+ pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
430430 }
431− switch (pSpatialLayer->sSliceCfg.uiSliceMode) {
431+ switch (pSpatialLayer->sSliceArgument.uiSliceMode) {
432432 case SM_SINGLE_SLICE:
433− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum = 1;
434− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
433+ pSpatialLayer->sSliceArgument.uiSliceNum = 1;
434+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = 0;
435435 for (iIdx = 0; iIdx < MAX_SLICES_NUM; iIdx++) {
436− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[iIdx] = 0;
436+ pSpatialLayer->sSliceArgument.uiSliceMbNum[iIdx] = 0;
437437 }
438438 break;
439439 case SM_FIXEDSLCNUM_SLICE: {
440− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
440+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = 0;
441441
442442 iMbWidth = (kiPicWidth + 15) >> 4;
443443 iMbHeight = (kiPicHeight + 15) >> 4;
444444 iMbNumInFrame = iMbWidth * iMbHeight;
445445 iMaxSliceNum = MAX_SLICES_NUM;
446− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0
447− || pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) {
446+ if (pSpatialLayer->sSliceArgument.uiSliceNum == 0) {
447+ int32_t uiCpuCores = 0;
448+ WelsCPUFeatureDetect (&uiCpuCores); // detect cpu capacity features
449+ pSpatialLayer->sSliceArgument.uiSliceNum = uiCpuCores;
450+
451+ if (uiCpuCores <= 1) {
452+ WelsLog (pLogCtx, WELS_LOG_INFO, "ParamValidationExt(), uiCpuCores = 1, switched to SM_SINGLE_SLICE");
453+ pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
454+ pSpatialLayer->sSliceArgument.uiSliceNum = 1;
455+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = 0;
456+ for (iIdx = 0; iIdx < MAX_SLICES_NUM; iIdx++) {
457+ pSpatialLayer->sSliceArgument.uiSliceMbNum[iIdx] = 0;
458+ }
459+ break;
460+ }
461+ }
462+ if (pSpatialLayer->sSliceArgument.uiSliceNum > iMaxSliceNum) {
448463 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!",
449− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
464+ pSpatialLayer->sSliceArgument.uiSliceNum);
450465 return ENC_RETURN_UNSUPPORTED_PARA;
451466 }
452− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
467+ if (pSpatialLayer->sSliceArgument.uiSliceNum == 1) {
453468 WelsLog (pLogCtx, WELS_LOG_DEBUG,
454469 "ParamValidationExt(), uiSliceNum(%d) you set for SM_FIXEDSLCNUM_SLICE, now turn to SM_SINGLE_SLICE type!",
455− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
456− pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
470+ pSpatialLayer->sSliceArgument.uiSliceNum);
471+ pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
457472 break;
458473 }
459474 if (pCodingParam->iRCMode != RC_OFF_MODE) { // multiple slices verify with gom
460475 //check uiSliceNum and set uiSliceMbNum with current uiSliceNum
461− if (!GomValidCheckSliceNum (iMbWidth, iMbHeight, &pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum)) {
476+ if (!GomValidCheckSliceNum (iMbWidth, iMbHeight, &pSpatialLayer->sSliceArgument.uiSliceNum)) {
462477 WelsLog (pLogCtx, WELS_LOG_WARNING,
463478 "ParamValidationExt(), unsupported setting with Resolution and uiSliceNum combination under RC on! So uiSliceNum is changed to %d!",
464− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
479+ pSpatialLayer->sSliceArgument.uiSliceNum);
465480 }
466− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 1 ||
467− !GomValidCheckSliceMbNum (iMbWidth, iMbHeight, &pSpatialLayer->sSliceCfg.sSliceArgument)) {
481+ if (pSpatialLayer->sSliceArgument.uiSliceNum <= 1 ||
482+ !GomValidCheckSliceMbNum (iMbWidth, iMbHeight, &pSpatialLayer->sSliceArgument)) {
468483 WelsLog (pLogCtx, WELS_LOG_ERROR,
469484 "ParamValidationExt(), unsupported setting with Resolution and uiSliceNum (%d) combination under RC on! Consider setting single slice with this resolution!",
470− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
485+ pSpatialLayer->sSliceArgument.uiSliceNum);
471486 return ENC_RETURN_UNSUPPORTED_PARA;
472487 }
473− assert (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > 1);
488+ assert (pSpatialLayer->sSliceArgument.uiSliceNum > 1);
474489 } else if (!CheckFixedSliceNumMultiSliceSetting (iMbNumInFrame,
475− &pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
490+ &pSpatialLayer->sSliceArgument)) { // verify interleave mode settings
476491 //check uiSliceMbNum with current uiSliceNum
477492 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
478− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
493+ pSpatialLayer->sSliceArgument.uiSliceMbNum[0]);
479494 return ENC_RETURN_UNSUPPORTED_PARA;
480495 }
481496 // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
482497 if (iMbNumInFrame <= MIN_NUM_MB_PER_SLICE) {
483− pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
484− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum = 1;
498+ pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
499+ pSpatialLayer->sSliceArgument.uiSliceNum = 1;
485500 break;
486501 }
487502 }
488503 break;
489− case SM_AUTO_SLICE: {
490− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
491− }
492− break;
493504 case SM_RASTER_SLICE: {
494− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
505+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = 0;
495506
496507 iMbWidth = (kiPicWidth + 15) >> 4;
497508 iMbHeight = (kiPicHeight + 15) >> 4;
498509 iMbNumInFrame = iMbWidth * iMbHeight;
499510 iMaxSliceNum = MAX_SLICES_NUM;
500− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0] <= 0) {
501− WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
502− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
503− return ENC_RETURN_UNSUPPORTED_PARA;
511+ if (pSpatialLayer->sSliceArgument.uiSliceMbNum[0] == 0) {
512+ if (iMbHeight > iMaxSliceNum) {
513+ WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings more than MAX(%d)!",
514+ iMbHeight, MAX_SLICES_NUM);
515+ return ENC_RETURN_UNSUPPORTED_PARA;
516+ }
517+ pSpatialLayer->sSliceArgument.uiSliceNum = iMbHeight;
518+ for (uint32_t j=0; j<iMbHeight; j++) {
519+ pSpatialLayer->sSliceArgument.uiSliceMbNum[j] = iMbWidth;
520+ }
521+ if (!CheckRowMbMultiSliceSetting (iMbWidth,
522+ &pSpatialLayer->sSliceArgument)) { // verify interleave mode settings
523+ WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
524+ pSpatialLayer->sSliceArgument.uiSliceMbNum[0]);
525+ return ENC_RETURN_UNSUPPORTED_PARA;
526+ }
527+ break;
504528 }
505529
506530 if (!CheckRasterMultiSliceSetting (iMbNumInFrame,
507− &pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
531+ &pSpatialLayer->sSliceArgument)) { // verify interleave mode settings
508532 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
509− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
533+ pSpatialLayer->sSliceArgument.uiSliceMbNum[0]);
510534 return ENC_RETURN_UNSUPPORTED_PARA;
511535 }
512− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0
513− || pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) { // verify interleave mode settings
536+ if (pSpatialLayer->sSliceArgument.uiSliceNum <= 0
537+ || pSpatialLayer->sSliceArgument.uiSliceNum > iMaxSliceNum) { // verify interleave mode settings
514538 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) in SM_RASTER_SLICE settings!",
515− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
539+ pSpatialLayer->sSliceArgument.uiSliceNum);
516540 return ENC_RETURN_UNSUPPORTED_PARA;
517541 }
518− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
542+ if (pSpatialLayer->sSliceArgument.uiSliceNum == 1) {
519543 WelsLog (pLogCtx, WELS_LOG_WARNING,
520544 "ParamValidationExt(), pSlice setting for SM_RASTER_SLICE now turn to SM_SINGLE_SLICE!");
521− pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
545+ pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
522546 break;
523547 }
524− if ((pCodingParam->iRCMode != RC_OFF_MODE) && pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > 1) {
548+ if ((pCodingParam->iRCMode != RC_OFF_MODE) && pSpatialLayer->sSliceArgument.uiSliceNum > 1) {
525549 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), WARNING: GOM based RC do not support SM_RASTER_SLICE!");
526550 }
527551 // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
528552 if (iMbNumInFrame <= MIN_NUM_MB_PER_SLICE) {
529− pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
530− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum = 1;
553+ pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
554+ pSpatialLayer->sSliceArgument.uiSliceNum = 1;
531555 break;
532556 }
533557 }
534558 break;
535− case SM_ROWMB_SLICE: {
536− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
537−
559+ case SM_SIZELIMITED_SLICE: {
538560 iMbWidth = (kiPicWidth + 15) >> 4;
539561 iMbHeight = (kiPicHeight + 15) >> 4;
540− iMaxSliceNum = MAX_SLICES_NUM;
541− if (iMbHeight > iMaxSliceNum) {
542− WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings more than MAX(%d)!",
543− iMbHeight, MAX_SLICES_NUM);
544− return ENC_RETURN_UNSUPPORTED_PARA;
545− }
546− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum = iMbHeight;
547−
548− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0) {
549− WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!",
550− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
551− return ENC_RETURN_UNSUPPORTED_PARA;
552− }
553− if (!CheckRowMbMultiSliceSetting (iMbWidth,
554− &pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
555− WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
556− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
557− return ENC_RETURN_UNSUPPORTED_PARA;
558− }
559− }
560− break;
561− case SM_DYN_SLICE: {
562− iMbWidth = (kiPicWidth + 15) >> 4;
563− iMbHeight = (kiPicHeight + 15) >> 4;
564− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint <= 0) {
562+ if (pSpatialLayer->sSliceArgument.uiSliceSizeConstraint <= 0) {
565563 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid iSliceSize (%d) settings!",
566− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint);
564+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint);
567565 return ENC_RETURN_UNSUPPORTED_PARA;
568566 }
569567
@@ -574,19 +572,19 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa · 4 unmodified lines
574572 return ENC_RETURN_UNSUPPORTED_PARA;
575573 }
576574
577− if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint > (pCodingParam->uiMaxNalSize -
575+ if (pSpatialLayer->sSliceArgument.uiSliceSizeConstraint > (pCodingParam->uiMaxNalSize -
578576 NAL_HEADER_ADD_0X30BYTES)) {
579577 WelsLog (pLogCtx, WELS_LOG_WARNING,
580− "ParamValidationExt(), slice mode = SM_DYN_SLICE, uiSliceSizeConstraint = %d ,uiMaxNalsize = %d, will take uiMaxNalsize!",
581− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint, pCodingParam->uiMaxNalSize);
582− pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES;
578+ "ParamValidationExt(), slice mode = SM_SIZELIMITED_SLICE, uiSliceSizeConstraint = %d ,uiMaxNalsize = %d, will take uiMaxNalsize!",
579+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint, pCodingParam->uiMaxNalSize);
580+ pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES;
583581 }
584582
585583 }
586584 break;
587585 default: {
588586 WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!",
589− pCodingParam->sSpatialLayers[0].sSliceCfg.uiSliceMode);
587+ pCodingParam->sSpatialLayers[0].sSliceArgument.uiSliceMode);
590588 return ENC_RETURN_UNSUPPORTED_PARA;
591589
592590 }
@@ -696,7 +694,7 @@ static inline int32_t AcquireLayersNals (sWelsEncCtx** ppCtx, SWelsSvcCodingPara · 103 unmodified lines
696694 //Review this part and suggest no change, since the memory over-use
697695 //(1) counts little to the overall performance
698696 //(2) should not be critial even under mobile case
699− if (SM_DYN_SLICE == pDLayer->sSliceCfg.uiSliceMode) {
697+ if (SM_SIZELIMITED_SLICE == pDLayer->sSliceArgument.uiSliceMode) {
700698 iCountNumNals += MAX_SLICES_NUM;
701699 // plus prefix NALs
702700 if (iDIndex == 0)
@@ -708,10 +706,10 @@ static inline int32_t AcquireLayersNals (sWelsEncCtx** ppCtx, SWelsSvcCodingPara · 5 unmodified lines
708706 iCountNumNals, iOrgNumNals, iDIndex, MAX_NAL_UNITS_IN_LAYER);
709707 return 1;
710708 }
711− } else { /*if ( SM_SINGLE_SLICE != pDLayer->sSliceCfg.uiSliceMode )*/
709+ } else { /*if ( SM_SINGLE_SLICE != pDLayer->sSliceArgument.uiSliceMode )*/
712710 const int32_t kiNumOfSlice = GetInitialSliceNum ((pDLayer->iVideoWidth + 0x0f) >> 4,
713711 (pDLayer->iVideoHeight + 0x0f) >> 4,
714− &pDLayer->sSliceCfg);
712+ &pDLayer->sSliceArgument);
715713
716714 // NEED check iCountNals value in case multiple slices is used
717715 iCountNumNals += kiNumOfSlice; // for pSlice VCL NALs
@@ -1159,7 +1157,7 @@ static inline int32_t InitDqLayers (sWelsEncCtx** ppCtx, SExistingParasetList* p · 441 unmodified lines
11591157 const int32_t kiMbW = (pDlayer->iVideoWidth + 0x0f) >> 4;
11601158 const int32_t kiMbH = (pDlayer->iVideoHeight + 0x0f) >> 4;
11611159 int32_t iMaxSliceNum = 1;
1162− const int32_t kiSliceNum = GetInitialSliceNum (kiMbW, kiMbH, &pDlayer->sSliceCfg);
1160+ const int32_t kiSliceNum = GetInitialSliceNum (kiMbW, kiMbH, &pDlayer->sSliceArgument);
11631161 if (iMaxSliceNum < kiSliceNum)
11641162 iMaxSliceNum = kiSliceNum;
11651163
@@ -1168,7 +1166,7 @@ static inline int32_t InitDqLayers (sWelsEncCtx** ppCtx, SExistingParasetList* p · 2 unmodified lines
11681166 WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pDqLayer), FreeMemorySvc (ppCtx))
11691167
11701168 // for dynamic slicing mode
1171− if (SM_DYN_SLICE == pDlayer->sSliceCfg.uiSliceMode) {
1169+ if (SM_SIZELIMITED_SLICE == pDlayer->sSliceArgument.uiSliceMode) {
11721170 const int32_t iSize = pParam->iCountThreadsNum * sizeof (int32_t);
11731171
11741172 pDqLayer->pNumSliceCodedOfPartition = (int32_t*)pMa->WelsMallocz (iSize, "pNumSliceCodedOfPartition");
@@ -1201,7 +1199,7 @@ static inline int32_t InitDqLayers (sWelsEncCtx** ppCtx, SExistingParasetList* p · 26 unmodified lines
12011199 pDqLayer->bDeblockingParallelFlag = pParam->bDeblockingParallelFlag;
12021200
12031201 //deblocking parameter adjustment
1204− if (SM_SINGLE_SLICE == pDlayer->sSliceCfg.uiSliceMode) {
1202+ if (SM_SINGLE_SLICE == pDlayer->sSliceArgument.uiSliceMode) {
12051203 //iLoopFilterDisableIdc: will be 0 or 1 under single_slice
12061204 if (2 == pParam->iLoopFilterDisableIdc) {
12071205 pDqLayer->iLoopFilterDisableIdc = 0;
@@ -1368,7 +1366,7 @@ static inline int32_t InitDqLayers (sWelsEncCtx** ppCtx, SExistingParasetList* p · 160 unmodified lines
13681366 false,
13691367 pSps->iMbWidth,
13701368 pSps->iMbHeight,
1371− & (pDlayerParam->sSliceCfg),
1369+ & (pDlayerParam->sSliceArgument),
13721370 pPps);
13731371 if (iResult) {
13741372 WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_WARNING, "InitDqLayers(), InitSlicePEncCtx failed(%d)!", iResult);
@@ -1776,16 +1774,16 @@ int32_t RequestMemorySvc (sWelsEncCtx** ppCtx, SExistingParasetList* pExistingPa · 401 unmodified lines
17761774 iLayerBsSize = WELS_ALIGN (iLayerBsSize, 4); // 4 bytes alinged
17771775 iVclLayersBsSizeCount += iLayerBsSize;
17781776
1779− SSliceConfig* pMso = & (fDlp->sSliceCfg);
1780− if (pMso->uiSliceMode == SM_DYN_SLICE) {
1777+ SSliceArgument* pSliceArgument = & (fDlp->sSliceArgument);
1778+ if (pSliceArgument->uiSliceMode == SM_SIZELIMITED_SLICE) {
17811779 bDynamicSlice = true;
17821780 uiMaxSliceNumEstimation = WELS_MIN (AVERSLICENUM_CONSTRAINT,
1783− (iLayerBsSize / pMso->sSliceArgument.uiSliceSizeConstraint) + 1);
1781+ (iLayerBsSize / pSliceArgument->uiSliceSizeConstraint) + 1);
17841782 (*ppCtx)->iMaxSliceCount = WELS_MAX ((*ppCtx)->iMaxSliceCount, (int) uiMaxSliceNumEstimation);
1785− iSliceBufferSize = (WELS_MAX(pMso->sSliceArgument.uiSliceSizeConstraint, iLayerBsSize/uiMaxSliceNumEstimation)<<1) + MAX_MACROBLOCK_SIZE_IN_BYTE_x2;
1783+ iSliceBufferSize = (WELS_MAX(pSliceArgument->uiSliceSizeConstraint, iLayerBsSize/uiMaxSliceNumEstimation)<<1) + MAX_MACROBLOCK_SIZE_IN_BYTE_x2;
17861784 } else {
1787− (*ppCtx)->iMaxSliceCount = WELS_MAX ((*ppCtx)->iMaxSliceCount, (int) pMso->sSliceArgument.uiSliceNum);
1788− iSliceBufferSize = ((iLayerBsSize / pMso->sSliceArgument.uiSliceNum)<<1) + MAX_MACROBLOCK_SIZE_IN_BYTE_x2;
1785+ (*ppCtx)->iMaxSliceCount = WELS_MAX ((*ppCtx)->iMaxSliceCount, (int) pSliceArgument->uiSliceNum);
1786+ iSliceBufferSize = ((iLayerBsSize / pSliceArgument->uiSliceNum)<<1) + MAX_MACROBLOCK_SIZE_IN_BYTE_x2;
17891787 }
17901788 iMaxSliceBufferSize = WELS_MAX(iMaxSliceBufferSize, iSliceBufferSize);
17911789
@@ -2090,14 +2088,14 @@ void FreeMemorySvc (sWelsEncCtx** ppCtx) { · 298 unmodified lines
20902088 SDqLayer* pDq = pCtx->ppDqLayerList[ilayer];
20912089 SSpatialLayerConfig* pDlp = &pCtx->pSvcParam->sSpatialLayers[ilayer];
20922090
2093− const bool kbIsDynamicSlicing = (SM_DYN_SLICE == pDlp->sSliceCfg.uiSliceMode);
2091+ const bool kbIsDynamicSlicing = (SM_SIZELIMITED_SLICE == pDlp->sSliceArgument.uiSliceMode);
20942092
20952093 // pDq layers
20962094 if (NULL != pDq) {
20972095 if (NULL != pDq->sLayerInfo.pSliceInLayer) {
20982096 int32_t iSliceIdx = 0;
2099− int32_t iSliceNum = GetInitialSliceNum (pDq->iMbWidth, pDq->iMbHeight, &pDlp->sSliceCfg);
2100− if (pDlp->sSliceCfg.uiSliceMode == SM_DYN_SLICE && pCtx->iActiveThreadsNum == 1) {
2097+ int32_t iSliceNum = GetInitialSliceNum (pDq->iMbWidth, pDq->iMbHeight, &pDlp->sSliceArgument);
2098+ if (pDlp->sSliceArgument.uiSliceMode == SM_SIZELIMITED_SLICE && pCtx->iActiveThreadsNum == 1) {
21012099 if (iSliceNum < pDq->pSliceEncCtx->iMaxSliceNumConstraint) {
21022100 iSliceNum = pDq->pSliceEncCtx->iMaxSliceNumConstraint;
21032101 }
@@ -2248,29 +2246,93 @@ int32_t InitSliceSettings (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPar · 144 unmodified lines
22482246
22492247 do {
22502248 SSpatialLayerConfig* pDlp = &pCodingParam->sSpatialLayers[iSpatialIdx];
2251− SSliceConfig* pMso = &pDlp->sSliceCfg;
2252− SSliceArgument* pSlcArg = &pMso->sSliceArgument;
2249+ SSliceArgument* pSliceArgument = &pDlp->sSliceArgument;
22532250 const int32_t kiMbWidth = (pDlp->iVideoWidth + 15) >> 4;
22542251 const int32_t kiMbHeight = (pDlp->iVideoHeight + 15) >> 4;
22552252 const int32_t kiMbNumInFrame = kiMbWidth * kiMbHeight;
2256− int32_t iSliceNum = (SM_AUTO_SLICE == pMso->uiSliceMode) ? kiCpuCores : pSlcArg->uiSliceNum;
2253+ int32_t iSliceNum = (SM_FIXEDSLCNUM_SLICE == pSliceArgument->uiSliceMode && 0==pSliceArgument->uiSliceNum) ? kiCpuCores : pSliceArgument->uiSliceNum;
22572254 // NOTE: Per design, in case MT/DYNAMIC_SLICE_ASSIGN enabled, for SM_FIXEDSLCNUM_SLICE mode,
2258− // uiSliceNum of current spatial layer settings equals to uiCpuCores number; SM_DYN_SLICE mode,
2255+ // uiSliceNum of current spatial layer settings equals to uiCpuCores number; SM_SIZELIMITED_SLICE mode,
22592256 // uiSliceNum intials as uiCpuCores also, stay tuned dynamically slicing in future
2260− pSlcArg->uiSliceNum = iSliceNum; // used fixed one
2257+ pSliceArgument->uiSliceNum = iSliceNum; // used fixed one
22612258
2262− switch (pMso->uiSliceMode) {
2263− case SM_DYN_SLICE:
2259+ switch (pSliceArgument->uiSliceMode) {
2260+ case SM_SIZELIMITED_SLICE:
22642261 iMaxSliceCount = AVERSLICENUM_CONSTRAINT;
2265− break; // go through for SM_DYN_SLICE?
2262+ break; // go through for SM_SIZELIMITED_SLICE?
22662263 case SM_FIXEDSLCNUM_SLICE:
2267− if (iSliceNum > iMaxSliceCount)
2264+ if (iSliceNum > iMaxSliceCount) {
22682265 iMaxSliceCount = iSliceNum;
2266+ }
2267+ if (0==iSliceNum) {
2268+ //the auto slice num logic
2269+ pDlp->sSliceArgument.uiSliceNum = kiCpuCores;
2270+
2271+ if (0==kiCpuCores){
2272+ int32_t uiCpuCores = 0;
2273+ WelsCPUFeatureDetect (&uiCpuCores); // detect cpu capacity features
2274+ pDlp->sSliceArgument.uiSliceNum = uiCpuCores;
2275+
2276+ if (uiCpuCores == 1) {
2277+ WelsLog (pLogCtx, WELS_LOG_INFO, "InitSliceSettings(), uiCpuCores = 1, switched to SM_SINGLE_SLICE");
2278+ pDlp->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
2279+ pDlp->sSliceArgument.uiSliceNum = 1;
2280+ pDlp->sSliceArgument.uiSliceSizeConstraint = 0;
2281+ for (int32_t iIdx = 0; iIdx < MAX_SLICES_NUM; iIdx++) {
2282+ pDlp->sSliceArgument.uiSliceMbNum[iIdx] = 0;
2283+ }
2284+ break;
2285+ }
2286+ }
2287+
2288+ if (pDlp->sSliceArgument.uiSliceNum == 1) {
2289+ WelsLog (pLogCtx, WELS_LOG_DEBUG,
2290+ "InitSliceSettings(), uiSliceNum(%d) you set for SM_AUTO_SLICE, now turn to SM_SINGLE_SLICE type!",
2291+ pDlp->sSliceArgument.uiSliceNum);
2292+ pDlp->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
2293+ break;
2294+ }
2295+
2296+ if (pDlp->sSliceArgument.uiSliceNum > MAX_SLICES_NUM) {
2297+ pDlp->sSliceArgument.uiSliceNum = MAX_SLICES_NUM;
2298+ }
2299+ iMaxSliceCount = WELS_MAX(iMaxSliceCount, pDlp->sSliceArgument.uiSliceNum);
2300+
2301+ if (pCodingParam->iRCMode != RC_OFF_MODE) { // multiple slices verify with gom
2302+ //check uiSliceNum and set uiSliceMbNum with current uiSliceNum
2303+ if (!GomValidCheckSliceNum (kiMbWidth, kiMbHeight, &pDlp->sSliceArgument.uiSliceNum)) {
2304+ WelsLog (pLogCtx, WELS_LOG_WARNING,
2305+ "InitSliceSettings(), unsupported setting with Resolution and uiSliceNum combination under RC on! So uiSliceNum is changed to %d!",
2306+ pDlp->sSliceArgument.uiSliceNum);
2307+ }
2308+ if (pDlp->sSliceArgument.uiSliceNum <= 1 ||
2309+ !GomValidCheckSliceMbNum (kiMbWidth, kiMbHeight, &pDlp->sSliceArgument)) {
2310+ WelsLog (pLogCtx, WELS_LOG_ERROR,
2311+ "InitSliceSettings(), unsupported setting with Resolution and uiSliceNum (%d) combination under RC on! Consider setting single slice with this resolution!",
2312+ pDlp->sSliceArgument.uiSliceNum);
2313+ return ENC_RETURN_INVALIDINPUT;
2314+ }
2315+ } else if (!CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame,
2316+ &pDlp->sSliceArgument)) { // verify interleave mode settings
2317+ //check uiSliceMbNum with current uiSliceNum
2318+ WelsLog (pLogCtx, WELS_LOG_ERROR,
2319+ "InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type",
2320+ pDlp->sSliceArgument.uiSliceMbNum[0]);
2321+ pDlp->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
2322+ pDlp->sSliceArgument.uiSliceNum = 1;
2323+ }
2324+ // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
2325+ if (kiMbNumInFrame <= MIN_NUM_MB_PER_SLICE) {
2326+ pDlp->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;
2327+ pDlp->sSliceArgument.uiSliceNum = 1;
2328+ break;
2329+ }
2330+ }
22692331 // need perform check due uiSliceNum might change, although has been initialized somewhere outside
22702332 if (pCodingParam->iRCMode != RC_OFF_MODE) {
2271− GomValidCheckSliceMbNum (kiMbWidth, kiMbHeight, pSlcArg);
2333+ GomValidCheckSliceMbNum (kiMbWidth, kiMbHeight, pSliceArgument);
22722334 } else {
2273− CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame, pSlcArg);
2335+ CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame, pSliceArgument);
22742336 }
22752337 break;
22762338 case SM_SINGLE_SLICE:
@@ -2281,53 +2343,6 @@ int32_t InitSliceSettings (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPar · 4 unmodified lines
22812343 if (iSliceNum > iMaxSliceCount)
22822344 iMaxSliceCount = iSliceNum;
22832345 break;
2284− case SM_ROWMB_SLICE:
2285− if (iSliceNum > iMaxSliceCount)
2286− iMaxSliceCount = iSliceNum;
2287− break;
2288− case SM_AUTO_SLICE:
2289− pDlp->sSliceCfg.sSliceArgument.uiSliceNum = kiCpuCores;
2290− if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum > MAX_SLICES_NUM) {
2291− pDlp->sSliceCfg.sSliceArgument.uiSliceNum = MAX_SLICES_NUM;
2292− }
2293− iMaxSliceCount = WELS_MAX(iMaxSliceCount, pDlp->sSliceCfg.sSliceArgument.uiSliceNum);
2294− if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
2295− WelsLog (pLogCtx, WELS_LOG_DEBUG,
2296− "InitSliceSettings(), uiSliceNum(%d) you set for SM_AUTO_SLICE, now turn to SM_SINGLE_SLICE type!",
2297− pDlp->sSliceCfg.sSliceArgument.uiSliceNum);
2298− pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
2299− break;
2300− }
2301− if (pCodingParam->iRCMode != RC_OFF_MODE) { // multiple slices verify with gom
2302− //check uiSliceNum and set uiSliceMbNum with current uiSliceNum
2303− if (!GomValidCheckSliceNum (kiMbWidth, kiMbHeight, &pDlp->sSliceCfg.sSliceArgument.uiSliceNum)) {
2304− WelsLog (pLogCtx, WELS_LOG_WARNING,
2305− "ParamValidationExt(), unsupported setting with Resolution and uiSliceNum combination under RC on! So uiSliceNum is changed to %d!",
2306− pDlp->sSliceCfg.sSliceArgument.uiSliceNum);
2307− }
2308− if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum <= 1 ||
2309− !GomValidCheckSliceMbNum (kiMbWidth, kiMbHeight, &pDlp->sSliceCfg.sSliceArgument)) {
2310− WelsLog (pLogCtx, WELS_LOG_ERROR,
2311− "ParamValidationExt(), unsupported setting with Resolution and uiSliceNum (%d) combination under RC on! Consider setting single slice with this resolution!",
2312− pDlp->sSliceCfg.sSliceArgument.uiSliceNum);
2313− return ENC_RETURN_INVALIDINPUT;
2314− }
2315− } else if (!CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame,
2316− &pDlp->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
2317− //check uiSliceMbNum with current uiSliceNum
2318− WelsLog (pLogCtx, WELS_LOG_ERROR,
2319− "InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type",
2320− pDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
2321− pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
2322− pDlp->sSliceCfg.sSliceArgument.uiSliceNum = 1;
2323− }
2324− // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
2325− if (kiMbNumInFrame <= MIN_NUM_MB_PER_SLICE) {
2326− pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
2327− pDlp->sSliceCfg.sSliceArgument.uiSliceNum = 1;
2328− break;
2329− }
2330− break;
23312346 default:
23322347 break;
23332348 }
@@ -2858,8 +2873,8 @@ void WelsInitCurrentLayer (sWelsEncCtx* pCtx, · 524 unmodified lines
28582873
28592874 pCurDq->pDecPic = pDecPic;
28602875
2861− if (fDlp->sSliceCfg.uiSliceMode == SM_DYN_SLICE) // need get extra slices for update
2862− iSliceCount = GetInitialSliceNum (pCurDq->iMbWidth, pCurDq->iMbHeight, &fDlp->sSliceCfg);
2876+ if (fDlp->sSliceArgument.uiSliceMode == SM_SIZELIMITED_SLICE) // need get extra slices for update
2877+ iSliceCount = GetInitialSliceNum (pCurDq->iMbWidth, pCurDq->iMbHeight, &fDlp->sSliceArgument);
28632878 else
28642879 iSliceCount = GetCurrentSliceNum (pCurDq->pSliceEncCtx);
28652880 assert (iSliceCount > 0);
@@ -3869,17 +3884,17 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 1003 unmodified lines
38693884 iDidList[iSpatialIdx] = iCurDid;
38703885
38713886 // Encoding this picture might mulitiple sQualityStat layers potentially be encoded as followed
3872− switch (pParam->sSliceCfg.uiSliceMode) {
3873− case SM_FIXEDSLCNUM_SLICE:
3874− case SM_AUTO_SLICE: {
3887+ switch (pParam->sSliceArgument.uiSliceMode) {
3888+ case SM_FIXEDSLCNUM_SLICE: {
38753889 if ((iCurDid > 0) && (pSvcParam->iMultipleThreadIdc > 1) &&
3876− (pSvcParam->sSpatialLayers[iCurDid].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE
3877− && pSvcParam->iMultipleThreadIdc >= pSvcParam->sSpatialLayers[iCurDid].sSliceCfg.sSliceArgument.uiSliceNum)
3890+ (pSvcParam->sSpatialLayers[iCurDid].sSliceArgument.uiSliceMode == SM_FIXEDSLCNUM_SLICE
3891+ && pSvcParam->bUseLoadBalancing
3892+ && pSvcParam->iMultipleThreadIdc >= pSvcParam->sSpatialLayers[iCurDid].sSliceArgument.uiSliceNum)
38783893 )
38793894 AdjustEnhanceLayer (pCtx, iCurDid);
38803895 break;
38813896 }
3882− case SM_DYN_SLICE: {
3897+ case SM_SIZELIMITED_SLICE: {
38833898 int32_t iPicIPartitionNum = PicPartitionNumDecision (pCtx);
38843899 // MT compatibility
38853900 pCtx->iActiveThreadsNum =
@@ -3961,7 +3976,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 75 unmodified lines
39613976 //TODO Complexity Calculation here for screen content
39623977 iLayerSize = 0;
39633978
3964− if (SM_SINGLE_SLICE == pParam->sSliceCfg.uiSliceMode) { // only one slice within a sQualityStat layer
3979+ if (SM_SINGLE_SLICE == pParam->sSliceArgument.uiSliceMode) { // only one slice within a sQualityStat layer
39653980 int32_t iSliceSize = 0;
39663981 int32_t iPayloadSize = 0;
39673982
@@ -4002,7 +4017,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 34 unmodified lines
40024017 pLayerBsInfo->iNalCount = ++ iNalIdxInLayer;
40034018 }
40044019 // for dynamic slicing single threading..
4005− else if ((SM_DYN_SLICE == pParam->sSliceCfg.uiSliceMode) && (pSvcParam->iMultipleThreadIdc <= 1)) {
4020+ else if ((SM_SIZELIMITED_SLICE == pParam->sSliceArgument.uiSliceMode) && (pSvcParam->iMultipleThreadIdc <= 1)) {
40064021 const int32_t kiLastMbInFrame = pCtx->pCurDqLayer->pSliceEncCtx->iMbNumInFrame;
40074022 pCtx->iEncoderError = WelsCodeOnePicPartition (pCtx, pFbi, pLayerBsInfo, &iNalIdxInLayer, &iLayerSize, 0,
40084023 kiLastMbInFrame, 0);
@@ -4010,14 +4025,13 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 1 unmodified line
40104025 } else {
40114026 //other multi-slice uiSliceMode
40124027 int32_t iRet = 0;
4013− // THREAD_FULLY_FIRE_MODE/THREAD_PICK_UP_MODE for any mode of non-SM_DYN_SLICE
4014− if ((SM_DYN_SLICE != pParam->sSliceCfg.uiSliceMode) && (pSvcParam->iMultipleThreadIdc > 1)) {
4015−
4028+ // THREAD_FULLY_FIRE_MODE/THREAD_PICK_UP_MODE for any mode of non-SM_SIZELIMITED_SLICE
4029+ if ((SM_SIZELIMITED_SLICE != pParam->sSliceArgument.uiSliceMode) && (pSvcParam->iMultipleThreadIdc > 1)) {
40164030 iSliceCount = GetCurrentSliceNum (pCtx->pCurDqLayer->pSliceEncCtx);
40174031 if (iLayerNum + 1 >= MAX_LAYER_NUM_OF_FRAME) { // check available layer_bs_info for further writing as followed
40184032 WelsLog (pLogCtx, WELS_LOG_ERROR,
40194033 "WelsEncoderEncodeExt(), iLayerNum(%d) overflow(max:%d) at iDid= %d uiSliceMode= %d, iSliceCount= %d!",
4020− iLayerNum, MAX_LAYER_NUM_OF_FRAME, iCurDid, pParam->sSliceCfg.uiSliceMode, iSliceCount);
4034+ iLayerNum, MAX_LAYER_NUM_OF_FRAME, iCurDid, pParam->sSliceArgument.uiSliceMode, iSliceCount);
40214035 return ENC_RETURN_UNSUPPORTED_PARA;
40224036 }
40234037 if (iSliceCount <= 1) {
@@ -4038,8 +4052,8 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 14 unmodified lines
40384052 pCtx->pTaskManage->ExecuteTasks();
40394053 iLayerSize = AppendSliceToFrameBs (pCtx, pLayerBsInfo, iSliceCount);
40404054 }
4041− // THREAD_FULLY_FIRE_MODE && SM_DYN_SLICE
4042− else if ((SM_DYN_SLICE == pParam->sSliceCfg.uiSliceMode) && (pSvcParam->iMultipleThreadIdc > 1)) {
4055+ // THREAD_FULLY_FIRE_MODE && SM_SIZELIMITED_SLICE
4056+ else if ((SM_SIZELIMITED_SLICE == pParam->sSliceArgument.uiSliceMode) && (pSvcParam->iMultipleThreadIdc > 1)) {
40434057 const int32_t kiPartitionCnt = pCtx->iActiveThreadsNum; //pSvcParam->iCountThreadsNum;
40444058
40454059 // to fire slice coding threads
@@ -4050,7 +4064,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 4 unmodified lines
40504064 if (iRet) {
40514065 WelsLog (pLogCtx, WELS_LOG_ERROR,
40524066 "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!",
4053− iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc);
4067+ iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceArgument.uiSliceMode, pSvcParam->iMultipleThreadIdc);
40544068 return ENC_RETURN_UNEXPECTED;
40554069 }
40564070
@@ -4295,9 +4309,10 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 238 unmodified lines
42954309 iFrameSize += iPaddingNalSize;
42964310 }
42974311
4298− if ((pParam->sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE || pParam->sSliceCfg.uiSliceMode == SM_AUTO_SLICE)
4312+ if ((pParam->sSliceArgument.uiSliceMode == SM_FIXEDSLCNUM_SLICE)
4313+ && pSvcParam->bUseLoadBalancing
42994314 && pSvcParam->iMultipleThreadIdc > 1 &&
4300− pSvcParam->iMultipleThreadIdc >= pParam->sSliceCfg.sSliceArgument.uiSliceNum) {
4315+ pSvcParam->iMultipleThreadIdc >= pParam->sSliceArgument.uiSliceNum) {
43014316 CalcSliceComplexRatio (pCtx->pSliceThreading->pSliceComplexRatio[iCurDid], pCtx->pCurDqLayer->pSliceEncCtx,
43024317 pCtx->pSliceThreading->pSliceConsumeTime[iCurDid]);
43034318 #if defined(MT_DEBUG)
@@ -4342,13 +4357,12 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour · 38 unmodified lines
43424357 #endif//MT_DEBUG
43434358
43444359 if (pSvcParam->iMultipleThreadIdc > 1 && iDidList[0] == BASE_DEPENDENCY_ID
4345− && ((pSvcParam->sSpatialLayers[0].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE)
4346− || (pSvcParam->sSpatialLayers[0].sSliceCfg.uiSliceMode == SM_AUTO_SLICE))
4347− && pSvcParam->iMultipleThreadIdc >= pSvcParam->sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum
4348− && ((pSvcParam->sSpatialLayers[iDidList[iSpatialNum - 1]].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE)
4349− || (pSvcParam->sSpatialLayers[iDidList[iSpatialNum - 1]].sSliceCfg.uiSliceMode == SM_AUTO_SLICE))
4360+ && (pSvcParam->sSpatialLayers[0].sSliceArgument.uiSliceMode == SM_FIXEDSLCNUM_SLICE)
4361+ && pSvcParam->bUseLoadBalancing
4362+ && pSvcParam->iMultipleThreadIdc >= pSvcParam->sSpatialLayers[0].sSliceArgument.uiSliceNum
4363+ && ((pSvcParam->sSpatialLayers[iDidList[iSpatialNum - 1]].sSliceArgument.uiSliceMode == SM_FIXEDSLCNUM_SLICE))
43504364 && pSvcParam->iMultipleThreadIdc >= pSvcParam->sSpatialLayers[iDidList[iSpatialNum -
4351− 1]].sSliceCfg.sSliceArgument.uiSliceNum) {
4365+ 1]].sSliceArgument.uiSliceNum) {
43524366 AdjustBaseLayer (pCtx);
43534367 }
43544368
@@ -4483,10 +4497,10 @@ int32_t WelsEncoderParamAdjust (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pNewPa · 128 unmodified lines
44834497 break;
44844498 }
44854499
4486− if (pOldParam->sSpatialLayers[iIndexD].sSliceCfg.uiSliceMode != pNewParam->sSpatialLayers[iIndexD].sSliceCfg.uiSliceMode
4500+ if (pOldParam->sSpatialLayers[iIndexD].sSliceArgument.uiSliceMode != pNewParam->sSpatialLayers[iIndexD].sSliceArgument.uiSliceMode
44874501 ||
4488− pOldParam->sSpatialLayers[iIndexD].sSliceCfg.sSliceArgument.uiSliceNum !=
4489− pNewParam->sSpatialLayers[iIndexD].sSliceCfg.sSliceArgument.uiSliceNum) {
4502+ pOldParam->sSpatialLayers[iIndexD].sSliceArgument.uiSliceNum !=
4503+ pNewParam->sSpatialLayers[iIndexD].sSliceArgument.uiSliceNum) {
44904504 bNeedReset = true;
44914505 break;
44924506 }

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t