History

add memory allocation for screen content

ruil2 committed 12 years ago

Commit c8eaea21 parent 37201e25 files · +247 −187Browse files

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

Unified · Split

codec/encoder/core/src/encoder_ext.cpp+205−159
@@ -79,8 +79,8 @@ int32_t ParamValidation (SWelsSvcCodingParam* pCfg) { · 78 unmodified lines
7979
8080 assert (pCfg != NULL);
8181
82− if((pCfg->iUsageType != CAMERA_VIDEO_REAL_TIME)&&(pCfg->iUsageType != SCREEN_CONTENT_REAL_TIME)){
83− WelsLog (NULL, WELS_LOG_ERROR, "ParamValidation(),Invalid usage type = %d",pCfg->iUsageType);
82+ if ((pCfg->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCfg->iUsageType != SCREEN_CONTENT_REAL_TIME)) {
83+ WelsLog (NULL, WELS_LOG_ERROR, "ParamValidation(),Invalid usage type = %d", pCfg->iUsageType);
8484 return ENC_RETURN_UNSUPPORTED_PARA;
8585 }
8686 for (i = 0; i < pCfg->iSpatialLayerNum; ++ i) {
@@ -88,12 +88,13 @@ int32_t ParamValidation (SWelsSvcCodingParam* pCfg) { · 1 unmodified line
8888 if (fDlp->fOutputFrameRate > fDlp->fInputFrameRate || (fDlp->fInputFrameRate >= -fEpsn
8989 && fDlp->fInputFrameRate <= fEpsn)
9090 || (fDlp->fOutputFrameRate >= -fEpsn && fDlp->fOutputFrameRate <= fEpsn)) {
91− WelsLog (NULL, WELS_LOG_ERROR,"Invalid settings in input frame rate(%.6f) or output frame rate(%.6f) of layer #%d config file..\n",
91+ WelsLog (NULL, WELS_LOG_ERROR,
92+ "Invalid settings in input frame rate(%.6f) or output frame rate(%.6f) of layer #%d config file..\n",
9293 fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
9394 return ENC_RETURN_INVALIDINPUT;
9495 }
9596 if (UINT_MAX == GetLogFactor (fDlp->fOutputFrameRate, fDlp->fInputFrameRate)) {
96− WelsLog (NULL,WELS_LOG_ERROR,
97+ WelsLog (NULL, WELS_LOG_ERROR,
9798 "Invalid settings in input frame rate(%.6f) and output frame rate(%.6f) of layer #%d config file: iResult of output frame rate divided by input frame rate should be power of 2(i.e,in/pOut=2^n)..\n",
9899 fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
99100 return ENC_RETURN_INVALIDINPUT;
@@ -115,7 +116,7 @@ int32_t ParamValidation (SWelsSvcCodingParam* pCfg) { · 15 unmodified lines
115116 }
116117
117118
118−int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) {
119+int32_t ParamValidationExt (sWelsEncCtx* pCtx, SWelsSvcCodingParam* pCodingParam) {
119120 int8_t i = 0;
120121 int32_t iIdx = 0;
121122
@@ -123,8 +124,8 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 1 unmodified line
123124 if (NULL == pCodingParam)
124125 return ENC_RETURN_INVALIDINPUT;
125126
126− if((pCodingParam->iUsageType != CAMERA_VIDEO_REAL_TIME)&&(pCodingParam->iUsageType != SCREEN_CONTENT_REAL_TIME)){
127− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(),Invalid usage type = %d",pCodingParam->iUsageType);
127+ if ((pCodingParam->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCodingParam->iUsageType != SCREEN_CONTENT_REAL_TIME)) {
128+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(),Invalid usage type = %d", pCodingParam->iUsageType);
128129 return ENC_RETURN_UNSUPPORTED_PARA;
129130 }
130131 if (pCodingParam->iSpatialLayerNum < 1 || pCodingParam->iSpatialLayerNum > MAX_DEPENDENCY_LAYER) {
@@ -140,7 +141,8 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 9 unmodified lines
140141 }
141142
142143 if (pCodingParam->uiGopSize < 1 || pCodingParam->uiGopSize > MAX_GOP_SIZE) {
143− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->uiGopSize: %d!\n", pCodingParam->uiGopSize);
144+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->uiGopSize: %d!\n",
145+ pCodingParam->uiGopSize);
144146 return ENC_RETURN_UNSUPPORTED_PARA;
145147 }
146148
@@ -153,7 +155,8 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 6 unmodified lines
153155 }
154156
155157 if (pCodingParam->uiIntraPeriod && (pCodingParam->uiIntraPeriod & (pCodingParam->uiGopSize - 1)) != 0) {
156− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), uiIntraPeriod(%d) should be multiple of uiGopSize(%d) or -1 specified!\n",
158+ WelsLog (pCtx, WELS_LOG_ERROR,
159+ "ParamValidationExt(), uiIntraPeriod(%d) should be multiple of uiGopSize(%d) or -1 specified!\n",
157160 pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize);
158161 return ENC_RETURN_UNSUPPORTED_PARA;
159162 }
@@ -180,7 +183,8 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 20 unmodified lines
180183 int32_t iMbNumInFrame = 0;
181184 uint32_t iMaxSliceNum = MAX_SLICES_NUM;
182185 if (kiPicWidth <= 0 || kiPicHeight <= 0) {
183− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid %d x %d in dependency layer settings!\n", kiPicWidth, kiPicHeight);
186+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid %d x %d in dependency layer settings!\n", kiPicWidth,
187+ kiPicHeight);
184188 return ENC_RETURN_UNSUPPORTED_PARA;
185189 }
186190 if ((kiPicWidth & 0x0F) != 0 || (kiPicHeight & 0x0F) != 0) {
@@ -191,11 +195,13 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 4 unmodified lines
191195 }
192196
193197 if (fDlp->sSliceCfg.uiSliceMode >= SM_RESERVED) {
194− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!\n", fDlp->sSliceCfg.uiSliceMode);
198+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!\n",
199+ fDlp->sSliceCfg.uiSliceMode);
195200 return ENC_RETURN_UNSUPPORTED_PARA;
196201 }
197− if((pCodingParam->uiMaxNalSize != 0) && (fDlp->sSliceCfg.uiSliceMode != SM_DYN_SLICE)){
198− WelsLog (pCtx, WELS_LOG_ERROR,"ParamValidationExt(), invalid uiSliceMode (%d) settings!,MaxNalSize = %d\n", fDlp->sSliceCfg.uiSliceMode,pCodingParam->uiMaxNalSize);
202+ if ((pCodingParam->uiMaxNalSize != 0) && (fDlp->sSliceCfg.uiSliceMode != SM_DYN_SLICE)) {
203+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!,MaxNalSize = %d\n",
204+ fDlp->sSliceCfg.uiSliceMode, pCodingParam->uiMaxNalSize);
199205 return ENC_RETURN_UNSUPPORTED_PARA;
200206 }
201207 //check pSlice settings under multi-pSlice
@@ -212,7 +218,7 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 10 unmodified lines
212218 fDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[iIdx] = 0;
213219 }
214220 break;
215− case SM_FIXEDSLCNUM_SLICE:{
221+ case SM_FIXEDSLCNUM_SLICE: {
216222 fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
217223
218224 iMbWidth = (kiPicWidth + 15) >> 4;
@@ -220,8 +226,9 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 1 unmodified line
220226 iMbNumInFrame = iMbWidth * iMbHeight;
221227 iMaxSliceNum = MAX_SLICES_NUM;
222228 if (fDlp->sSliceCfg.sSliceArgument.uiSliceNum <= 0
223− || fDlp->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) {
224− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n", fDlp->sSliceCfg.sSliceArgument.uiSliceNum);
229+ || fDlp->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) {
230+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n",
231+ fDlp->sSliceCfg.sSliceArgument.uiSliceNum);
225232 return ENC_RETURN_UNSUPPORTED_PARA;
226233 }
227234 if (fDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
@@ -240,7 +247,7 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 12 unmodified lines
240247 } else if (!CheckFixedSliceNumMultiSliceSetting (iMbNumInFrame,
241248 &fDlp->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
242249 //check uiSliceMbNum with current uiSliceNum
243− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n",
250+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n",
244251 fDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
245252 return ENC_RETURN_UNSUPPORTED_PARA;
246253 }
@@ -252,7 +259,7 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 5 unmodified lines
252259 }
253260 }
254261 break;
255− case SM_AUTO_SLICE:{
262+ case SM_AUTO_SLICE: {
256263 fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = 0;
257264 }
258265 break;
@@ -281,11 +288,12 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 22 unmodified lines
281288 return ENC_RETURN_UNSUPPORTED_PARA;
282289 }
283290 if (fDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
284− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), pSlice setting for SM_RASTER_SLICE now turn to SM_SINGLE_SLICE!\n");
291+ WelsLog (pCtx, WELS_LOG_ERROR,
292+ "ParamValidationExt(), pSlice setting for SM_RASTER_SLICE now turn to SM_SINGLE_SLICE!\n");
285293 fDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
286294 break;
287295 }
288− if ((pCodingParam->iRCMode!=RC_OFF_MODE) && fDlp->sSliceCfg.sSliceArgument.uiSliceNum > 1) {
296+ if ((pCodingParam->iRCMode != RC_OFF_MODE) && fDlp->sSliceCfg.sSliceArgument.uiSliceNum > 1) {
289297 WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), WARNING: GOM based RC do not support SM_RASTER_SLICE!\n");
290298 }
291299 // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
@@ -309,7 +317,8 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 17 unmodified lines
309317 fDlp->sSliceCfg.sSliceArgument.uiSliceNum = iMbHeight;
310318
311319 if (fDlp->sSliceCfg.sSliceArgument.uiSliceNum <= 0) {
312− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n", fDlp->sSliceCfg.sSliceArgument.uiSliceNum);
320+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n",
321+ fDlp->sSliceCfg.sSliceArgument.uiSliceNum);
313322 return ENC_RETURN_UNSUPPORTED_PARA;
314323 }
315324 if (!CheckRowMbMultiSliceSetting (iMbWidth, &fDlp->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
@@ -328,15 +337,16 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 12 unmodified lines
328337 return ENC_RETURN_UNSUPPORTED_PARA;
329338 }
330339
331− if( pCodingParam->uiMaxNalSize <= NAL_HEADER_ADD_0X30BYTES) {
332− WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiMaxNalSize (%d) settings!\n",
333− pCodingParam->uiMaxNalSize);
334− return ENC_RETURN_UNSUPPORTED_PARA;
340+ if (pCodingParam->uiMaxNalSize <= NAL_HEADER_ADD_0X30BYTES) {
341+ WelsLog (pCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiMaxNalSize (%d) settings!\n",
342+ pCodingParam->uiMaxNalSize);
343+ return ENC_RETURN_UNSUPPORTED_PARA;
335344 }
336345
337− if( fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint > (pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES)){
338− WelsLog (pCtx, WELS_LOG_WARNING, "ParamValidationExt(), slice mode = SM_DYN_SLICE, uiSliceSizeConstraint = %d ,uiMaxNalsize = %d!\n",
339− fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint,pCodingParam->uiMaxNalSize);
346+ if (fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint > (pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES)) {
347+ WelsLog (pCtx, WELS_LOG_WARNING,
348+ "ParamValidationExt(), slice mode = SM_DYN_SLICE, uiSliceSizeConstraint = %d ,uiMaxNalsize = %d!\n",
349+ fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint, pCodingParam->uiMaxNalSize);
340350 fDlp->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES;
341351 }
342352
@@ -362,8 +372,7 @@ int32_t ParamValidationExt (sWelsEncCtx*pCtx,SWelsSvcCodingParam* pCodingParam) · 19 unmodified lines
362372 }
363373
364374
365−void WelsEncoderApplyFrameRate(SWelsSvcCodingParam* pParam)
366−{
375+void WelsEncoderApplyFrameRate (SWelsSvcCodingParam* pParam) {
367376 SDLayerParam* pLayerParam;
368377 const float kfEpsn = 0.000001f;
369378 const int32_t kiNumLayer = pParam->iSpatialLayerNum;
@@ -373,50 +382,51 @@ void WelsEncoderApplyFrameRate(SWelsSvcCodingParam* pParam) · 3 unmodified lines
373382 float fTargetOutputFrameRate;
374383
375384 //set input frame rate to each layer
376− for (i=0;i<kiNumLayer;i++) {
377− pLayerParam = &(pParam->sDependencyLayers[i]);
385+ for (i = 0; i < kiNumLayer; i++) {
386+ pLayerParam = & (pParam->sDependencyLayers[i]);
378387
379388 fRatio = pLayerParam->fOutputFrameRate / pLayerParam->fInputFrameRate;
380− if ( (kfMaxFrameRate - pLayerParam->fInputFrameRate) > kfEpsn
381− || (kfMaxFrameRate - pLayerParam->fInputFrameRate) < -kfEpsn ) {
389+ if ((kfMaxFrameRate - pLayerParam->fInputFrameRate) > kfEpsn
390+ || (kfMaxFrameRate - pLayerParam->fInputFrameRate) < -kfEpsn) {
382391 pLayerParam->fInputFrameRate = kfMaxFrameRate;
383− fTargetOutputFrameRate = kfMaxFrameRate*fRatio;
384− pLayerParam->fOutputFrameRate = (fTargetOutputFrameRate>=6)?fTargetOutputFrameRate:(pLayerParam->fInputFrameRate);
392+ fTargetOutputFrameRate = kfMaxFrameRate * fRatio;
393+ pLayerParam->fOutputFrameRate = (fTargetOutputFrameRate >= 6) ? fTargetOutputFrameRate : (pLayerParam->fInputFrameRate);
385394 //TODO:{Sijia} from design, there is no sense to have temporal layer when under 6fps even with such setting?
386395 }
387396 }
388397 }
389398
390399
391−void WelsEncoderApplyBitRate(SWelsSvcCodingParam* pParam,int iLayer)
392−{
400+void WelsEncoderApplyBitRate (SWelsSvcCodingParam* pParam, int iLayer) {
393401 //TODO (Sijia): this is a temporary solution which keep the ratio between layers
394402 //but it is also possible to fulfill the bitrate of lower layer first
395403
396404 SDLayerParam* pLayerParam;
397405 const int32_t iNumLayers = pParam->iSpatialLayerNum;
398− int32_t i, iOrigTotalBitrate=0;
399− if(iLayer == SPATIAL_LAYER_ALL){
400− if(pParam->iMaxBitrate <pParam->iTargetBitrate){
401− WelsLog (NULL, WELS_LOG_WARNING,"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,overall settting,TargetBitrate = %d,iMaxBitrate = %d\n",
402− pParam->iTargetBitrate,pParam->iMaxBitrate);
406+ int32_t i, iOrigTotalBitrate = 0;
407+ if (iLayer == SPATIAL_LAYER_ALL) {
408+ if (pParam->iMaxBitrate < pParam->iTargetBitrate) {
409+ WelsLog (NULL, WELS_LOG_WARNING,
410+ "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,overall settting,TargetBitrate = %d,iMaxBitrate = %d\n",
411+ pParam->iTargetBitrate, pParam->iMaxBitrate);
403412 pParam->iMaxBitrate = pParam->iTargetBitrate;
404413 }
405414 //read old BR
406− for (i=0;i<iNumLayers;i++) {
407− iOrigTotalBitrate += pParam->sDependencyLayers[i].iSpatialBitrate;
415+ for (i = 0; i < iNumLayers; i++) {
416+ iOrigTotalBitrate += pParam->sDependencyLayers[i].iSpatialBitrate;
408417 }
409418 //write new BR
410419 float fRatio = 0.0;
411− for (i=0;i<iNumLayers;i++) {
412− pLayerParam = &(pParam->sDependencyLayers[i]);
413− fRatio = pLayerParam->iSpatialBitrate/(static_cast<float>(iOrigTotalBitrate));
414− pLayerParam->iSpatialBitrate = static_cast<int32_t>(pParam->iTargetBitrate*fRatio);
415− }
416− }else{
417− if(pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate <pParam->sSpatialLayers[iLayer].iSpatialBitrate){
418− WelsLog (NULL, WELS_LOG_WARNING,"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iLayer = %d,iTargetBitrate = %d,iMaxBitrate = %d\n",
419− iLayer,pParam->sSpatialLayers[iLayer].iSpatialBitrate,pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate);
420+ for (i = 0; i < iNumLayers; i++) {
421+ pLayerParam = & (pParam->sDependencyLayers[i]);
422+ fRatio = pLayerParam->iSpatialBitrate / (static_cast<float> (iOrigTotalBitrate));
423+ pLayerParam->iSpatialBitrate = static_cast<int32_t> (pParam->iTargetBitrate * fRatio);
424+ }
425+ } else {
426+ if (pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate < pParam->sSpatialLayers[iLayer].iSpatialBitrate) {
427+ WelsLog (NULL, WELS_LOG_WARNING,
428+ "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iLayer = %d,iTargetBitrate = %d,iMaxBitrate = %d\n",
429+ iLayer, pParam->sSpatialLayers[iLayer].iSpatialBitrate, pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate);
420430 pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate = pParam->sSpatialLayers[iLayer].iSpatialBitrate;
421431 }
422432
@@ -479,8 +489,8 @@ static inline int32_t AcquireLayersNals (sWelsEncCtx** ppCtx, SWelsSvcCodingPara · 56 unmodified lines
479489
480490 if (iCountNumNals - iOrgNumNals > MAX_NAL_UNITS_IN_LAYER) {
481491 WelsLog (*ppCtx, WELS_LOG_ERROR,
482− "AcquireLayersNals(), num_of_nals(%d) > MAX_NAL_UNITS_IN_LAYER(%d) per (iDid= %d, qid= %d) settings!\n",
483− (iCountNumNals - iOrgNumNals), MAX_NAL_UNITS_IN_LAYER, iDIndex, 0);
492+ "AcquireLayersNals(), num_of_nals(%d) > MAX_NAL_UNITS_IN_LAYER(%d) per (iDid= %d, qid= %d) settings!\n",
493+ (iCountNumNals - iOrgNumNals), MAX_NAL_UNITS_IN_LAYER, iDIndex, 0);
484494 return 1;
485495 }
486496
@@ -862,7 +872,7 @@ static inline int32_t InitDqLayers (sWelsEncCtx** ppCtx) { · 375 unmodified lines
862872 }
863873 } else {
864874 WelsInitSubsetSps (pSubsetSps, pDlayerParam, pParam->uiIntraPeriod, pParam->iNumRefFrame, iSpsId,
865− pParam->bEnableFrameCroppingFlag, pParam->iRCMode!=RC_OFF_MODE);
875+ pParam->bEnableFrameCroppingFlag, pParam->iRCMode != RC_OFF_MODE);
866876 }
867877
868878 // initialize pPps
@@ -1154,7 +1164,31 @@ int32_t AllocStrideTables (sWelsEncCtx** ppCtx, const int32_t kiNumSpatialLayers · 285 unmodified lines
11541164
11551165 return 0;
11561166 }
1167+int32_t RequestMemoryVaaScreen (SVAAFrameInfo* pVaa, CMemoryAlign* pMa, const int32_t iNumRef,
1168+ const int32_t iCountMax8x8BNum) {
1169+ SVAAFrameInfoExt* pVaaExt = static_cast<SVAAFrameInfoExt*> (pVaa);
11571170
1171+ pVaaExt->pVaaBlockStaticIdc[0] = (static_cast<uint8_t*> (pMa->WelsMallocz (iNumRef * iCountMax8x8BNum * sizeof (
1172+ uint8_t), "pVaa->pVaaBlockStaticIdc[0]")));
1173+ if (NULL == pVaaExt->pVaaBlockStaticIdc[0]) {
1174+ return 1;
1175+ }
1176+
1177+ for (int32_t idx = 1; idx < iNumRef; idx++) {
1178+ pVaaExt->pVaaBlockStaticIdc[idx] = pVaaExt->pVaaBlockStaticIdc[idx - 1] + iCountMax8x8BNum;
1179+ }
1180+ return 0;
1181+}
1182+void ReleaseMemoryVaaScreen (SVAAFrameInfo* pVaa, CMemoryAlign* pMa, const int32_t iNumRef) {
1183+ SVAAFrameInfoExt* pVaaExt = static_cast<SVAAFrameInfoExt*> (pVaa);
1184+ if (pVaaExt && pMa && pVaaExt->pVaaBlockStaticIdc[0]) {
1185+ pMa->WelsFree (pVaaExt->pVaaBlockStaticIdc[0], "pVaa->pVaaBlockStaticIdc");
1186+
1187+ for (int32_t idx = 0; idx < iNumRef; idx++) {
1188+ pVaaExt->pVaaBlockStaticIdc[idx] = NULL;
1189+ }
1190+ }
1191+}
11581192 /*!
11591193 * \brief request specific memory for SVC
11601194 * \pParam pEncCtx sWelsEncCtx*
@@ -1174,8 +1208,9 @@ int32_t RequestMemorySvc (sWelsEncCtx** ppCtx) { · 13 unmodified lines
11741208 int32_t iResult = 0;
11751209 float fCompressRatioThr = .5f;
11761210 const int32_t kiNumDependencyLayers = pParam->iSpatialLayerNum;
1177− (*ppCtx)->iMvRange = pParam->iUsageType?EXPANDED_MV_RANGE:CAMERA_STARTMV_RANGE;
1178− const int32_t kiMvdRange = (pParam->iUsageType?EXPANDED_MVD_RANGE:((kiNumDependencyLayers == 1)?CAMERA_MVD_RANGE:CAMERA_HIGHLAYER_MVD_RANGE));
1211+ (*ppCtx)->iMvRange = pParam->iUsageType ? EXPANDED_MV_RANGE : CAMERA_STARTMV_RANGE;
1212+ const int32_t kiMvdRange = (pParam->iUsageType ? EXPANDED_MVD_RANGE : ((kiNumDependencyLayers == 1) ? CAMERA_MVD_RANGE :
1213+ CAMERA_HIGHLAYER_MVD_RANGE));
11791214 const uint32_t kuiMvdInterTableSize = 1 + (kiMvdRange << 3);//intepel*4=qpel; qpel_mv_range*2=(+/-);
11801215 const uint32_t kuiMvdCacheAlignedSize = kuiMvdInterTableSize * sizeof (uint16_t);
11811216 int32_t iVclLayersBsSizeCount = 0;
@@ -1245,8 +1280,7 @@ int32_t RequestMemorySvc (sWelsEncCtx** ppCtx) { · 63 unmodified lines
12451280 (*ppCtx)->pFrameBs = (uint8_t*)pMa->WelsMalloc (iTotalLength, "pFrameBs");
12461281 WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pFrameBs), FreeMemorySvc (ppCtx))
12471282 (*ppCtx)->iFrameBsSize = iTotalLength;
1248− } else
1249− {
1283+ } else {
12501284 (*ppCtx)->pFrameBs = (uint8_t*)pMa->WelsMalloc (iCountBsLen, "pFrameBs");
12511285 WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pFrameBs), FreeMemorySvc (ppCtx))
12521286 (*ppCtx)->iFrameBsSize = iCountBsLen;
@@ -1313,13 +1347,19 @@ int32_t RequestMemorySvc (sWelsEncCtx** ppCtx) { · 60 unmodified lines
13131347 WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pWelsSvcRc), FreeMemorySvc (ppCtx))
13141348 //End of Rate control module memory allocation
13151349
1316− //pVaa memory allocation
1317− if(pParam->iUsageType == SCREEN_CONTENT_REAL_TIME)
1318− (*ppCtx)->pVaa = (SVAAFrameInfoExt*)pMa->WelsMallocz (sizeof (SVAAFrameInfoExt), "pVaa");
1319− else
1320− (*ppCtx)->pVaa = (SVAAFrameInfo*)pMa->WelsMallocz (sizeof (SVAAFrameInfo), "pVaa");
1321−
1322− WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pVaa), FreeMemorySvc (ppCtx))
1350+ //pVaa memory allocation
1351+ if (pParam->iUsageType == SCREEN_CONTENT_REAL_TIME) {
1352+ (*ppCtx)->pVaa = (SVAAFrameInfoExt*)pMa->WelsMallocz (sizeof (SVAAFrameInfoExt), "pVaa");
1353+ WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pVaa), FreeMemorySvc (ppCtx))
1354+ if(RequestMemoryVaaScreen ((*ppCtx)->pVaa, pMa, (*ppCtx)->pSvcParam->iNumRefFrame, iCountMaxMbNum << 2)){
1355+ WelsLog (*ppCtx, WELS_LOG_WARNING, "RequestMemorySvc(), RequestMemoryVaaScreen failed!");
1356+ FreeMemorySvc (ppCtx);
1357+ return 1;
1358+ }
1359+ } else {
1360+ (*ppCtx)->pVaa = (SVAAFrameInfo*)pMa->WelsMallocz (sizeof (SVAAFrameInfo), "pVaa");
1361+ WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pVaa), FreeMemorySvc (ppCtx))
1362+ }
13231363
13241364 if ((*ppCtx)->pSvcParam->bEnableAdaptiveQuant) { //malloc mem
13251365 (*ppCtx)->pVaa->sAdaptiveQuantParam.pMotionTextureUnit = static_cast<SMotionTextureUnit*>
@@ -1601,7 +1641,8 @@ void FreeMemorySvc (sWelsEncCtx** ppCtx) { · 275 unmodified lines
16011641 pMa->WelsFree (pCtx->pVaa->sVaaCalcInfo.pMad8x8, "pVaa->sVaaCalcInfo.pMad8x8");
16021642 pCtx->pVaa->sVaaCalcInfo.pMad8x8 = NULL;
16031643 }
1604−
1644+ if(pCtx->pSvcParam->iUsageType == SCREEN_CONTENT_REAL_TIME)
1645+ ReleaseMemoryVaaScreen(pCtx->pVaa, pMa,pCtx->pSvcParam->iNumRefFrame);
16051646 pMa->WelsFree (pCtx->pVaa, "pVaa");
16061647 pCtx->pVaa = NULL;
16071648 }
@@ -1660,7 +1701,7 @@ int32_t InitSliceSettings (SWelsSvcCodingParam* pCodingParam, const int32_t kiCp · 52 unmodified lines
16601701 const int32_t kiMbWidth = (pDlp->iFrameWidth + 15) >> 4;
16611702 const int32_t kiMbHeight = (pDlp->iFrameHeight + 15) >> 4;
16621703 const int32_t kiMbNumInFrame = kiMbWidth * kiMbHeight;
1663− int32_t iSliceNum = (SM_AUTO_SLICE == pMso->uiSliceMode)? kiCpuCores :pSlcArg->uiSliceNum;
1704+ int32_t iSliceNum = (SM_AUTO_SLICE == pMso->uiSliceMode) ? kiCpuCores : pSlcArg->uiSliceNum;
16641705 // NOTE: Per design, in case MT/DYNAMIC_SLICE_ASSIGN enabled, for SM_FIXEDSLCNUM_SLICE mode,
16651706 // uiSliceNum of current spatial layer settings equals to uiCpuCores number; SM_DYN_SLICE mode,
16661707 // uiSliceNum intials as uiCpuCores also, stay tuned dynamically slicing in future
@@ -1674,7 +1715,7 @@ int32_t InitSliceSettings (SWelsSvcCodingParam* pCodingParam, const int32_t kiCp · 7 unmodified lines
16741715 if (iSliceNum > iMaxSliceCount)
16751716 iMaxSliceCount = iSliceNum;
16761717 // need perform check due uiSliceNum might change, although has been initialized somewhere outside
1677− if (pCodingParam->iRCMode!=RC_OFF_MODE) {
1718+ if (pCodingParam->iRCMode != RC_OFF_MODE) {
16781719 GomValidCheckSliceMbNum (kiMbWidth, kiMbHeight, pSlcArg);
16791720 } else {
16801721 CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame, pSlcArg);
@@ -1695,7 +1736,7 @@ int32_t InitSliceSettings (SWelsSvcCodingParam* pCodingParam, const int32_t kiCp · 14 unmodified lines
16951736 case SM_AUTO_SLICE:
16961737 iMaxSliceCount = MAX_SLICES_NUM;
16971738 pDlp->sSliceCfg.sSliceArgument.uiSliceNum = kiCpuCores;
1698− if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceCount){
1739+ if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceCount) {
16991740 pDlp->sSliceCfg.sSliceArgument.uiSliceNum = iMaxSliceCount;
17001741 }
17011742 if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
@@ -1714,10 +1755,11 @@ int32_t InitSliceSettings (SWelsSvcCodingParam* pCodingParam, const int32_t kiCp · 12 unmodified lines
17141755 } else if (!CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame,
17151756 &pDlp->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
17161757 //check uiSliceMbNum with current uiSliceNum
1717− WelsLog (NULL, WELS_LOG_ERROR, "InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type\n",
1758+ WelsLog (NULL, WELS_LOG_ERROR,
1759+ "InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type\n",
17181760 pDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
1719− pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
1720− pDlp->sSliceCfg.sSliceArgument.uiSliceNum = 1;
1761+ pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
1762+ pDlp->sSliceCfg.sSliceArgument.uiSliceNum = 1;
17211763 }
17221764 // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
17231765 if (kiMbNumInFrame <= MIN_NUM_MB_PER_SLICE) {
@@ -1819,7 +1861,7 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar · 95 unmodified lines
18191861 return 1;
18201862 }
18211863
1822− iRet = ParamValidationExt (*ppCtx,pCodingParam);
1864+ iRet = ParamValidationExt (*ppCtx, pCodingParam);
18231865 if (iRet != 0) {
18241866 WelsLog (NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), ParamValidationExt failed return %d.\n", iRet);
18251867 return iRet;
@@ -1922,7 +1964,7 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar · 96 unmodified lines
19221964 if (pCodingParam->iMultipleThreadIdc > 1)
19231965 iRet = CreateSliceThreads (pCtx);
19241966
1925− WelsRcInitModule (pCtx, pCtx->pSvcParam->iRCMode!=RC_OFF_MODE ? WELS_RC_GOM : WELS_RC_DISABLE);
1967+ WelsRcInitModule (pCtx, pCtx->pSvcParam->iRCMode != RC_OFF_MODE ? WELS_RC_GOM : WELS_RC_DISABLE);
19261968
19271969 pCtx->pVpp = new CWelsPreProcess (pCtx);
19281970 if (pCtx->pVpp == NULL) {
@@ -1931,9 +1973,9 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar · 2 unmodified lines
19311973 FreeMemorySvc (&pCtx);
19321974 return iRet;
19331975 }
1934− if( (iRet = pCtx->pVpp->AllocSpatialPictures(pCtx, pCtx->pSvcParam)) != 0 ){
1935− WelsLog( pCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pVPP alloc spatial pictures failed\n");
1936− FreeMemorySvc(&pCtx);
1976+ if ((iRet = pCtx->pVpp->AllocSpatialPictures (pCtx, pCtx->pSvcParam)) != 0) {
1977+ WelsLog (pCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pVPP alloc spatial pictures failed\n");
1978+ FreeMemorySvc (&pCtx);
19371979 return iRet;
19381980 }
19391981
@@ -2067,7 +2109,7 @@ void WelsUninitEncoderExt (sWelsEncCtx** ppCtx) { · 127 unmodified lines
20672109 }
20682110
20692111 if ((*ppCtx)->pVpp) {
2070− (*ppCtx)->pVpp->FreeSpatialPictures(*ppCtx);
2112+ (*ppCtx)->pVpp->FreeSpatialPictures (*ppCtx);
20712113 delete (*ppCtx)->pVpp;
20722114 (*ppCtx)->pVpp = NULL;
20732115 }
@@ -2333,15 +2375,13 @@ void WelsInitCurrentLayer (sWelsEncCtx* pCtx, · 259 unmodified lines
23332375 }
23342376 }
23352377
2336−static inline void SetFastCodingFunc(SWelsFuncPtrList* pFuncList)
2337−{
2378+static inline void SetFastCodingFunc (SWelsFuncPtrList* pFuncList) {
23382379 pFuncList->pfIntraFineMd = WelsMdIntraFinePartitionVaa;
23392380 pFuncList->sSampleDealingFuncs.pfMdCost = pFuncList->sSampleDealingFuncs.pfSampleSad;
23402381 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad;
23412382 pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad;
23422383 }
2343−static inline void SetNormalCodingFunc(SWelsFuncPtrList* pFuncList)
2344−{
2384+static inline void SetNormalCodingFunc (SWelsFuncPtrList* pFuncList) {
23452385 pFuncList->pfIntraFineMd = WelsMdIntraFinePartition;
23462386 pFuncList->sSampleDealingFuncs.pfMdCost = pFuncList->sSampleDealingFuncs.pfSampleSatd;
23472387 pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 =
@@ -2362,18 +2402,18 @@ void PreprocessSliceCoding (sWelsEncCtx* pCtx) { · 14 unmodified lines
23622402
23632403 /* function pointers conditional assignment under sWelsEncCtx, layer_mb_enc_rec (in stack) is exclusive */
23642404 if (kbHighestSpatialLayer) {
2365− SetFastCodingFunc(pFuncList);
2405+ SetFastCodingFunc (pFuncList);
23662406 } else {
2367− SetNormalCodingFunc(pFuncList);
2407+ SetNormalCodingFunc (pFuncList);
23682408 }
23692409
23702410 if (P_SLICE == pCtx->eSliceType) {
23712411 pFuncList->pfMotionSearch[0] = WelsMotionEstimateSearch;
23722412 pFuncList->pfSearchMethod[BLOCK_16x16] =
23732413 pFuncList->pfSearchMethod[BLOCK_16x8] =
2374− pFuncList->pfSearchMethod[BLOCK_8x16] =
2375− pFuncList->pfSearchMethod[BLOCK_8x8] =
2376− pFuncList->pfSearchMethod[BLOCK_4x4] = WelsDiamondSearch;
2414+ pFuncList->pfSearchMethod[BLOCK_8x16] =
2415+ pFuncList->pfSearchMethod[BLOCK_8x8] =
2416+ pFuncList->pfSearchMethod[BLOCK_4x4] = WelsDiamondSearch;
23772417 pFuncList->pfFirstIntraMode = WelsMdFirstIntraMode;
23782418 pFuncList->sSampleDealingFuncs.pfMeCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSatd;
23792419 if (kbHighestSpatialLayer) {
@@ -2539,11 +2579,11 @@ int32_t WelsWriteParameterSets (sWelsEncCtx* pCtx, int32_t* pNalLen, int32_t* pN · 159 unmodified lines
25392579 }
25402580
25412581 iReturn = WelsEncodeNal (&pCtx->pOut->sNalList[iNal], NULL,
2542− pCtx->iFrameBsSize - pCtx->iPosBsBuffer,//available buffer to be written, so need to substract the used length
2543− pCtx->pFrameBs + pCtx->iPosBsBuffer,
2544− &iNalLength);
2545− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
2546− pNalLen[iCountNal] =iNalLength;
2582+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,//available buffer to be written, so need to substract the used length
2583+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
2584+ &iNalLength);
2585+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
2586+ pNalLen[iCountNal] = iNalLength;
25472587
25482588 pCtx->iPosBsBuffer += iNalLength;
25492589 iSize += iNalLength;
@@ -2568,10 +2608,10 @@ int32_t WelsWriteParameterSets (sWelsEncCtx* pCtx, int32_t* pNalLen, int32_t* pN · 18 unmodified lines
25682608 WelsUnloadNal (pCtx->pOut);
25692609
25702610 iReturn = WelsEncodeNal (&pCtx->pOut->sNalList[iNal], NULL,
2571− pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
2572− pCtx->pFrameBs + pCtx->iPosBsBuffer,
2573− &iNalLength);
2574− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
2611+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
2612+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
2613+ &iNalLength);
2614+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
25752615 pNalLen[iCountNal] = iNalLength;
25762616 pCtx->iPosBsBuffer += iNalLength;
25772617 iSize += iNalLength;
@@ -2603,11 +2643,11 @@ static inline int32_t AddPrefixNal (sWelsEncCtx* pCtx, · 25 unmodified lines
26032643 WelsUnloadNal (pCtx->pOut);
26042644
26052645 iReturn = WelsEncodeNal (&pCtx->pOut->sNalList[pCtx->pOut->iNalIndex - 1],
2606− &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
2607− pCtx->iFrameBsSize-pCtx->iPosBsBuffer,
2608− pCtx->pFrameBs+pCtx->iPosBsBuffer,
2609− &pNalLen[*pNalIdxInLayer]);
2610− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
2646+ &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
2647+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
2648+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
2649+ &pNalLen[*pNalIdxInLayer]);
2650+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
26112651 iPayloadSize = pNalLen[*pNalIdxInLayer];
26122652
26132653 pCtx->iPosBsBuffer += iPayloadSize;
@@ -2620,11 +2660,11 @@ static inline int32_t AddPrefixNal (sWelsEncCtx* pCtx, · 6 unmodified lines
26202660 WelsUnloadNal (pCtx->pOut);
26212661
26222662 iReturn = WelsEncodeNal (&pCtx->pOut->sNalList[pCtx->pOut->iNalIndex - 1],
2623− &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
2624− pCtx->iFrameBsSize-pCtx->iPosBsBuffer,
2625− pCtx->pFrameBs+pCtx->iPosBsBuffer,
2626− &pNalLen[*pNalIdxInLayer]);
2627− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
2663+ &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
2664+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
2665+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
2666+ &pNalLen[*pNalIdxInLayer]);
2667+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
26282668 iPayloadSize = pNalLen[*pNalIdxInLayer];
26292669
26302670 pCtx->iPosBsBuffer += iPayloadSize;
@@ -2667,10 +2707,10 @@ int32_t WritePadding (sWelsEncCtx* pCtx, int32_t iLen, int32_t& iSize) { · 36 unmodified lines
26672707
26682708 WelsUnloadNal (pCtx->pOut);
26692709 int32_t iReturn = WelsEncodeNal (&pCtx->pOut->sNalList[iNal], NULL,
2670− pCtx->iFrameBsSize-pCtx->iPosBsBuffer,
2671− pCtx->pFrameBs + pCtx->iPosBsBuffer,
2672− &iNalLen);
2673− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
2710+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
2711+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
2712+ &iNalLen);
2713+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
26742714
26752715 pCtx->iPosBsBuffer += iNalLen;
26762716 iSize += iNalLen;
@@ -2701,7 +2741,7 @@ int32_t WelsEncoderEncodeParameterSets (sWelsEncCtx* pCtx, void* pDst) { · 24 unmodified lines
27012741 InitBits (&pCtx->pOut->sBsWrite, pCtx->pOut->pBsBuffer, pCtx->pOut->uiSize);
27022742
27032743 int32_t iReturn = WelsWriteParameterSets (pCtx, &iNalLen[0], &iCountNal);
2704− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
2744+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
27052745
27062746 pLayerBsInfo->uiPriorityId = 0;
27072747 pLayerBsInfo->uiSpatialId = 0;
@@ -2729,7 +2769,7 @@ int32_t WelsEncoderEncodeParameterSets (sWelsEncCtx* pCtx, void* pDst) { · 21 unmodified lines
27292769 * \pParam pSrcPic Source Picture
27302770 * \return EFrameType (videoFrameTypeIDR/videoFrameTypeI/videoFrameTypeP)
27312771 */
2732−int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSourcePicture* pSrcPic) {
2772+int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSourcePicture* pSrcPic) {
27332773 SLayerBSInfo* pLayerBsInfo = &pFbi->sLayerInfo[0];
27342774 SWelsSvcCodingParam* pSvcParam = pCtx->pSvcParam;
27352775 SSpatialPicIndex* pSpatialIndexMap = &pCtx->sSpatialIndexMap[0];
@@ -2793,7 +2833,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 57 unmodified lines
27932833
27942834 // write parameter sets bitstream here
27952835 pCtx->iEncoderError = WelsWriteParameterSets (pCtx, &iNalLen[0], &iCountNal);
2796− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
2836+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
27972837
27982838 pLayerBsInfo->uiPriorityId = 0;
27992839 pLayerBsInfo->uiSpatialId = 0;
@@ -2833,7 +2873,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 33 unmodified lines
28332873
28342874 switch (param_d->sSliceCfg.uiSliceMode) {
28352875 case SM_FIXEDSLCNUM_SLICE:
2836− case SM_AUTO_SLICE:{
2876+ case SM_AUTO_SLICE: {
28372877 if ((iCurDid > 0) && (pSvcParam->iMultipleThreadIdc > 1) &&
28382878 (pSvcParam->sDependencyLayers[iCurDid].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE
28392879 && pSvcParam->iMultipleThreadIdc >= pSvcParam->sDependencyLayers[iCurDid].sSliceCfg.sSliceArgument.uiSliceNum)
@@ -2893,11 +2933,12 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 53 unmodified lines
28932933
28942934 WelsInitCurrentLayer (pCtx, iCurWidth, iCurHeight);
28952935
2896− pCtx->pFuncList->pMarkPic(pCtx);
2897− if (!pCtx->pFuncList->pBuildRefList (pCtx, pCtx->iPOC,0)) {
2936+ pCtx->pFuncList->pMarkPic (pCtx);
2937+ if (!pCtx->pFuncList->pBuildRefList (pCtx, pCtx->iPOC, 0)) {
28982938 // Force coding IDR as followed
28992939 ForceCodingIDR (pCtx);
2900− WelsLog (pCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), WelsBuildRefList failed for P frames, pCtx->iNumRef0= %d. ForceCodingIDR!\n",
2940+ WelsLog (pCtx, WELS_LOG_WARNING,
2941+ "WelsEncoderEncodeExt(), WelsBuildRefList failed for P frames, pCtx->iNumRef0= %d. ForceCodingIDR!\n",
29012942 pCtx->iNumRef0);
29022943 pFbi->eOutputFrameType = videoFrameTypeIDR;
29032944 pCtx->iEncoderError = ENC_RETURN_CORRECTED;
@@ -2921,24 +2962,25 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 17 unmodified lines
29212962 int32_t iPayloadSize = 0;
29222963
29232964 if (pCtx->bNeedPrefixNalFlag) {
2924− pCtx->iEncoderError = AddPrefixNal (pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, eNalType, eNalRefIdc, iPayloadSize);
2925− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
2965+ pCtx->iEncoderError = AddPrefixNal (pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, eNalType, eNalRefIdc,
2966+ iPayloadSize);
2967+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
29262968 iLayerSize += iPayloadSize;
29272969 }
29282970
29292971 WelsLoadNal (pCtx->pOut, eNalType, eNalRefIdc);
29302972
29312973 pCtx->iEncoderError = WelsCodeOneSlice (pCtx, 0, eNalType);
2932− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
2974+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
29332975
29342976 WelsUnloadNal (pCtx->pOut);
29352977
29362978 pCtx->iEncoderError = WelsEncodeNal (&pCtx->pOut->sNalList[pCtx->pOut->iNalIndex - 1],
2937− &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
2938− pCtx->iFrameBsSize-pCtx->iPosBsBuffer,
2939− pCtx->pFrameBs+pCtx->iPosBsBuffer,
2940− &iNalLen[iNalIdxInLayer]);
2941− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
2979+ &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
2980+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
2981+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
2982+ &iNalLen[iNalIdxInLayer]);
2983+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
29422984 iSliceSize = iNalLen[iNalIdxInLayer];
29432985
29442986 iLayerSize += iSliceSize;
@@ -2952,11 +2994,10 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 7 unmodified lines
29522994 pLayerBsInfo->iNalCount = ++ iNalIdxInLayer;
29532995 }
29542996 // for dynamic slicing single threading..
2955− else if ((SM_DYN_SLICE == param_d->sSliceCfg.uiSliceMode) && (pSvcParam->iMultipleThreadIdc <= 1))
2956− {
2997+ else if ((SM_DYN_SLICE == param_d->sSliceCfg.uiSliceMode) && (pSvcParam->iMultipleThreadIdc <= 1)) {
29572998 const int32_t kiLastMbInFrame = pCtx->pCurDqLayer->pSliceEncCtx->iMbNumInFrame;
29582999 pCtx->iEncoderError = WelsCodeOnePicPartition (pCtx, pLayerBsInfo, &iNalIdxInLayer, &iLayerSize, 0, kiLastMbInFrame, 0);
2959− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3000+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
29603001 } else {
29613002 //other multi-slice uiSliceMode
29623003 int err = 0;
@@ -2993,11 +3034,12 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 30 unmodified lines
29933034 return ENC_RETURN_UNEXPECTED;
29943035 }
29953036
2996− WelsMultipleEventsWaitAllBlocking (iSliceCount, &pCtx->pSliceThreading->pSliceCodedEvent[0], &pCtx->pSliceThreading->pSliceCodedMasterEvent);
3037+ WelsMultipleEventsWaitAllBlocking (iSliceCount, &pCtx->pSliceThreading->pSliceCodedEvent[0],
3038+ &pCtx->pSliceThreading->pSliceCodedMasterEvent);
29973039
29983040
29993041 // all slices are finished coding here
3000− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3042+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
30013043
30023044 // append exclusive slice 0 bs to pFrameBs
30033045 #if defined(MT_DEBUG)
@@ -3077,12 +3119,12 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 73 unmodified lines
30773119 return ENC_RETURN_UNEXPECTED;
30783120 }
30793121
3080− WelsMultipleEventsWaitAllBlocking (kiPartitionCnt, &pCtx->pSliceThreading->pSliceCodedEvent[0], &pCtx->pSliceThreading->pSliceCodedMasterEvent);
3081− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3122+ WelsMultipleEventsWaitAllBlocking (kiPartitionCnt, &pCtx->pSliceThreading->pSliceCodedEvent[0],
3123+ &pCtx->pSliceThreading->pSliceCodedMasterEvent);
3124+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
30823125
30833126 iLayerSize = AppendSliceToFrameBs (pCtx, pLayerBsInfo, kiPartitionCnt);
3084− } else // for non-dynamic-slicing mode single threading branch..
3085− {
3127+ } else { // for non-dynamic-slicing mode single threading branch..
30863128 const bool bNeedPrefix = pCtx->bNeedPrefixNalFlag;
30873129 int32_t iSliceIdx = 0;
30883130
@@ -3091,22 +3133,23 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 2 unmodified lines
30913133 int32_t iSliceSize = 0;
30923134 int32_t iPayloadSize = 0;
30933135 if (bNeedPrefix) {
3094− pCtx->iEncoderError = AddPrefixNal (pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, eNalType, eNalRefIdc, iPayloadSize);
3095− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3136+ pCtx->iEncoderError = AddPrefixNal (pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, eNalType, eNalRefIdc,
3137+ iPayloadSize);
3138+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
30963139 iLayerSize += iPayloadSize;
30973140 }
30983141
30993142 WelsLoadNal (pCtx->pOut, eNalType, eNalRefIdc);
31003143 pCtx->iEncoderError = WelsCodeOneSlice (pCtx, iSliceIdx, eNalType);
3101− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3144+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
31023145
31033146 WelsUnloadNal (pCtx->pOut);
31043147
31053148 pCtx->iEncoderError = WelsEncodeNal (&pCtx->pOut->sNalList[pCtx->pOut->iNalIndex - 1],
3106− &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
3107− pCtx->iFrameBsSize-pCtx->iPosBsBuffer,
3108− pCtx->pFrameBs+pCtx->iPosBsBuffer, &iNalLen[iNalIdxInLayer]);
3109− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3149+ &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
3150+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
3151+ pCtx->pFrameBs + pCtx->iPosBsBuffer, &iNalLen[iNalIdxInLayer]);
3152+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
31103153 iSliceSize = iNalLen[iNalIdxInLayer];
31113154
31123155 pCtx->iPosBsBuffer += iSliceSize;
@@ -3251,7 +3294,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 138 unmodified lines
32513294 if (pSvcParam->iPaddingFlag && pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize > 0) {
32523295 int32_t iPaddingNalSize = 0;
32533296 pCtx->iEncoderError = WritePadding (pCtx, pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize, iPaddingNalSize);
3254− WELS_VERIFY_RETURN_IFNEQ(pCtx->iEncoderError, ENC_RETURN_SUCCESS)
3297+ WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
32553298
32563299 #if GOM_TRACE_FLAG
32573300 WelsLog (pCtx, WELS_LOG_INFO, "[RC] encoding_qp%d Padding: %d\n", pCtx->uiDependencyId,
@@ -3276,7 +3319,8 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 18 unmodified lines
32763319 ++ iLayerNum;
32773320 }
32783321
3279− if ((param_d->sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE||param_d->sSliceCfg.uiSliceMode == SM_AUTO_SLICE) && pSvcParam->iMultipleThreadIdc > 1 &&
3322+ if ((param_d->sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE || param_d->sSliceCfg.uiSliceMode == SM_AUTO_SLICE)
3323+ && pSvcParam->iMultipleThreadIdc > 1 &&
32803324 pSvcParam->iMultipleThreadIdc >= param_d->sSliceCfg.sSliceArgument.uiSliceNum) {
32813325 CalcSliceComplexRatio (pCtx->pSliceThreading->pSliceComplexRatio[iCurDid], pCtx->pCurDqLayer->pSliceEncCtx,
32823326 pCtx->pSliceThreading->pSliceConsumeTime[iCurDid]);
@@ -3296,8 +3340,8 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 13 unmodified lines
32963340 pCtx->bLongTermRefFlag[d_idx][0] = true;
32973341 }
32983342
3299− if( pCtx->pVpp->UpdateSpatialPictures(pCtx, pSvcParam, iCurTid, d_idx) != 0 ){
3300− ForceCodingIDR(pCtx);
3343+ if (pCtx->pVpp->UpdateSpatialPictures (pCtx, pSvcParam, iCurTid, d_idx) != 0) {
3344+ ForceCodingIDR (pCtx);
33013345 WelsLog (pCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), Logic Error Found in temporal level. ForceCodingIDR!\n");
33023346 //the above is to set the next frame IDR
33033347 pFbi->eOutputFrameType = eFrameType;
@@ -3315,9 +3359,11 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo * pFbi, const SSou · 11 unmodified lines
33153359 #endif//MT_DEBUG
33163360
33173361 if (pSvcParam->iMultipleThreadIdc > 1 && did_list[0] == BASE_DEPENDENCY_ID
3318− && ((pSvcParam->sDependencyLayers[0].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE)||(pSvcParam->sDependencyLayers[0].sSliceCfg.uiSliceMode == SM_AUTO_SLICE))
3362+ && ((pSvcParam->sDependencyLayers[0].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE)
3363+ || (pSvcParam->sDependencyLayers[0].sSliceCfg.uiSliceMode == SM_AUTO_SLICE))
33193364 && pSvcParam->iMultipleThreadIdc >= pSvcParam->sDependencyLayers[0].sSliceCfg.sSliceArgument.uiSliceNum
3320− && ((pSvcParam->sDependencyLayers[did_list[iSpatialNum - 1]].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE)||(pSvcParam->sDependencyLayers[did_list[iSpatialNum - 1]].sSliceCfg.uiSliceMode == SM_AUTO_SLICE))
3365+ && ((pSvcParam->sDependencyLayers[did_list[iSpatialNum - 1]].sSliceCfg.uiSliceMode == SM_FIXEDSLCNUM_SLICE)
3366+ || (pSvcParam->sDependencyLayers[did_list[iSpatialNum - 1]].sSliceCfg.uiSliceMode == SM_AUTO_SLICE))
33213367 && pSvcParam->iMultipleThreadIdc >= pSvcParam->sDependencyLayers[did_list[iSpatialNum -
33223368 1]].sSliceCfg.sSliceArgument.uiSliceNum) {
33233369 AdjustBaseLayer (pCtx);
@@ -3351,7 +3397,7 @@ int32_t WelsEncoderParamAdjust (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pNewPa · 27 unmodified lines
33513397 if (NULL == ppCtx || NULL == *ppCtx || NULL == pNewParam) return 1;
33523398
33533399 /* Check validation in new parameters */
3354− iReturn = ParamValidationExt (*ppCtx,pNewParam);
3400+ iReturn = ParamValidationExt (*ppCtx, pNewParam);
33553401 if (iReturn != ENC_RETURN_SUCCESS) return iReturn;
33563402
33573403 pOldParam = (*ppCtx)->pSvcParam;
@@ -3555,21 +3601,21 @@ int32_t WelsCodeOnePicPartition (sWelsEncCtx* pCtx, · 197 unmodified lines
35553601
35563602 if (kbNeedPrefix) {
35573603 iReturn = AddPrefixNal (pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, keNalType, keNalRefIdc, iPayloadSize);
3558− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
3604+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
35593605 iPartitionBsSize += iPayloadSize;
35603606 }
35613607
35623608 WelsLoadNal (pCtx->pOut, keNalType, keNalRefIdc);
3563− iReturn=WelsCodeOneSlice (pCtx, iSliceIdx, keNalType);
3564− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
3609+ iReturn = WelsCodeOneSlice (pCtx, iSliceIdx, keNalType);
3610+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
35653611 WelsUnloadNal (pCtx->pOut);
35663612
35673613 iReturn = WelsEncodeNal (&pCtx->pOut->sNalList[pCtx->pOut->iNalIndex - 1],
3568− &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
3569− pCtx->iFrameBsSize-pCtx->iPosBsBuffer,
3570− pCtx->pFrameBs+pCtx->iPosBsBuffer,
3571− &iNalLen[iNalIdxInLayer]);
3572− WELS_VERIFY_RETURN_IFNEQ(iReturn, ENC_RETURN_SUCCESS)
3614+ &pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
3615+ pCtx->iFrameBsSize - pCtx->iPosBsBuffer,
3616+ pCtx->pFrameBs + pCtx->iPosBsBuffer,
3617+ &iNalLen[iNalIdxInLayer]);
3618+ WELS_VERIFY_RETURN_IFNEQ (iReturn, ENC_RETURN_SUCCESS)
35733619 iSliceSize = iNalLen[iNalIdxInLayer];
35743620
35753621 pCtx->iPosBsBuffer += iSliceSize;

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