Initial Commit

Ethan Hugg committed 12 years ago

Commit 70e5e621 parent bd509b2308 files · +97095 −-5Browse files

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

Unified · Split

codec/encoder/core/src/encoder_ext.cpp+4250−0

@@ -0,0 +1,4250 @@
	1	/*!
	2	* \copy
	3	* Copyright (c) 2009-2013, Cisco Systems
	4	* All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	*
	10	* * Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	*
	13	* * Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in
	15	* the documentation and/or other materials provided with the
	16	* distribution.
	17	*
	18	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	19	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	20	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	21	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	22	* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
	24	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	25	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	26	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	27	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
	28	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	29	* POSSIBILITY OF SUCH DAMAGE.
	30	*
	31	*
	32	* \file encoder_ext.c
	33	*
	34	* \brief core encoder for SVC
	35	*
	36	* \date 7/24/2009 Created
	37	*
	38	*************************************************************************************
	39	*/
	40	#include <string.h>
	41	#include <stdlib.h>
	42	#include <assert.h>
	43
	44	#include "encoder.h"
	45	#include "extern.h"
	46	#include "encoder_context.h"
	47	#include "typedefs.h"
	48	#include "wels_const.h"
	49	#include "wels_common_basis.h"
	50	#include "codec_def.h"
	51	#include "param_svc.h"
	52	#include "cpu_core.h"
	53	#include "cpu.h"
	54	#include "utils.h"
	55	#include "svc_enc_frame.h"
	56	#include "svc_enc_golomb.h"
	57	#include "svc_enc_slice_segment.h"
	58	#include "au_set.h"
	59	#include "picture_handle.h"
	60	#include "codec_app_def.h"
	61	#include "svc_base_layer_md.h"
	62	#include "svc_encode_slice.h"
	63	#include "decode_mb_aux.h"
	64	#include "deblocking.h"
	65	#include "rc.h"
	66	#include "ref_list_mgr_svc.h"
	67	#include "md.h"
	68	#include "ls_defines.h"
	69	#include "set_mb_syn_cavlc.h"
	70	#include "crt_util_safe_x.h" // Safe CRT routines like utils for cross platforms
	71	#include "array_stack_align.h"
	72	// for MT, 4/22/2010
	73	#include "slice_multi_threading.h"
	74	#if defined(DYNAMIC_SLICE_ASSIGN) \|\| defined(MT_DEBUG)
	75	#include "measure_time.h"
	76	#endif//DYNAMIC_SLICE_ASSIGN
	77
	78	namespace WelsSVCEnc {
	79
	80
	81	int32_t WelsCodeOnePicPartition( sWelsEncCtx *pCtx,
	82	SLayerBSInfo *pLbi,
	83	int32_t *pNalIdxInLayer,
	84	int32_t* pLayerSize,
	85	int32_t iFirstMbInPartition, // first mb inclusive in partition
	86	int32_t iEndMbInPartition, // end mb exclusive in partition
	87	int32_t iStartSliceIdx
	88	);
	89
	90
	91	/*!
	92	* \brief validate checking in parameter configuration
	93	* \pParam pParam SWelsSvcCodingParam*
	94	* \return successful - 0; otherwise none 0 for failed
	95	*/
	96	int32_t ParamValidation( SWelsSvcCodingParam *pCfg )
	97	{
	98	float fMaxFrameRate = 0.0f;
	99	const float fEpsn = 0.000001f;
	100	int32_t i = 0;
	101	int32_t iLastSpatialWidth = 0;
	102	int32_t iLastSpatialHeight = 0;
	103	float fLastFrameRateIn = 0.0f;
	104	float fLastFrameRateOut = 0.0f;
	105	SDLayerParam *pLastSpatialParam = NULL;
	106
	107	assert( pCfg != NULL );
	108
	109	for (i = 0; i < pCfg->iNumDependencyLayer; ++ i)
	110	{
	111	SDLayerParam *fDlp = &pCfg->sDependencyLayers[i];
	112	if ( fDlp->fOutputFrameRate > fDlp->fInputFrameRate \|\| (fDlp->fInputFrameRate >= -fEpsn && fDlp->fInputFrameRate <= fEpsn)
	113	\|\| (fDlp->fOutputFrameRate >= -fEpsn && fDlp->fOutputFrameRate <= fEpsn) )
	114	{
	115	#if defined (_DEBUG)
	116	fprintf(stderr, "Invalid settings in input frame rate(%.6f) or output frame rate(%.6f) of layer #%d config file..\n",
	117	fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
	118	#endif
	119	return 1;
	120	}
	121	if ( UINT_MAX == GetLogFactor(fDlp->fOutputFrameRate, fDlp->fInputFrameRate) )
	122	{
	123	#if defined (_DEBUG)
	124	fprintf(stderr, "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",
	125	fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
	126	#endif
	127	return 1;
	128	}
	129	}
	130
	131	for (i = 0; i < pCfg->iNumDependencyLayer; ++ i)
	132	{
	133	SDLayerParam *fDlp = &pCfg->sDependencyLayers[i];
	134	if ( fDlp->fInputFrameRate > fMaxFrameRate )
	135	fMaxFrameRate = fDlp->fInputFrameRate;
	136	}
	137
	138	if ( fMaxFrameRate > fEpsn && (fMaxFrameRate - pCfg->fMaxFrameRate > fEpsn \|\| fMaxFrameRate - pCfg->fMaxFrameRate < -fEpsn) )
	139	{
	140	pCfg->fMaxFrameRate = fMaxFrameRate;
	141	}
	142
	143	for (i = 0; i < pCfg->iNumDependencyLayer; ++ i)
	144	{
	145	SDLayerParam *fDlp = &pCfg->sDependencyLayers[i];
	146
	147	pLastSpatialParam = fDlp;
	148	iLastSpatialWidth = fDlp->iFrameWidth;
	149	iLastSpatialHeight = fDlp->iFrameHeight;
	150	fLastFrameRateIn = fDlp->fInputFrameRate;
	151	fLastFrameRateOut = fDlp->fOutputFrameRate;
	152	}
	153
	154	return 0;
	155	}
	156
	157	int32_t ParamValidationExt( void *pParam )
	158	{
	159	SWelsSvcCodingParam pCodingParam = (SWelsSvcCodingParam )pParam;
	160	int8_t i = 0;
	161	int32_t iIdx = 0;
	162
	163	assert ( pCodingParam != NULL );
	164	if ( NULL == pCodingParam )
	165	return 1;
	166
	167	if ( pCodingParam->iNumDependencyLayer < 1 \|\| pCodingParam->iNumDependencyLayer > MAX_DEPENDENCY_LAYER ){
	168	#if defined (_DEBUG)
	169	fprintf(stderr, "ParamValidationExt(), monitor invalid pCodingParam->iNumDependencyLayer: %d!\n", pCodingParam->iNumDependencyLayer);
	170	#endif//#if _DEBUG
	171
	172	return 1;
	173	}
	174
	175	if ( pCodingParam->iNumTemporalLayer < 1 \|\| pCodingParam->iNumTemporalLayer > MAX_TEMPORAL_LEVEL ){
	176	#if defined (_DEBUG)
	177	fprintf(stderr, "ParamValidationExt(), monitor invalid pCodingParam->iNumTemporalLayer: %d!\n", pCodingParam->iNumTemporalLayer);
	178	#endif//#if _DEBUG
	179	return 1;
	180	}
	181
	182	if ( pCodingParam->uiGopSize < 1 \|\| pCodingParam->uiGopSize > MAX_GOP_SIZE ){
	183	#if defined (_DEBUG)
	184	fprintf(stderr, "ParamValidationExt(), monitor invalid pCodingParam->uiGopSize: %d!\n", pCodingParam->uiGopSize);
	185	#endif//#if _DEBUG
	186	return 1;
	187	}
	188
	189
	190	if ( pCodingParam->uiIntraPeriod && pCodingParam->uiIntraPeriod < pCodingParam->uiGopSize )
	191	{
	192	#if defined (_DEBUG)
	193	fprintf(stderr, "ParamValidationExt(), uiIntraPeriod(%d) should be not less than that of uiGopSize(%d) or -1 specified!\n",
	194	pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize);
	195	#endif//#if _DEBUG
	196	return 1;
	197	}
	198
	199	if ( pCodingParam->uiIntraPeriod && (pCodingParam->uiIntraPeriod & (pCodingParam->uiGopSize-1)) != 0 )
	200	{
	201	#if defined (_DEBUG)
	202	fprintf(stderr, "ParamValidationExt(), uiIntraPeriod(%d) should be multiple of uiGopSize(%d) or -1 specified!\n",
	203	pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize);
	204	#endif//#if _DEBUG
	205	return 1;
	206	}
	207
	208
	209	#ifdef MT_ENABLED
	210	//about iMultipleThreadIdc, bDeblockingParallelFlag, iLoopFilterDisableIdc, & uiSliceMode
	211	// (1) Single Thread
	212	// if (THREAD==1)//single thread
	213	// no parallel_deblocking: bDeblockingParallelFlag = 0;
	214	// (2) Multi Thread: see uiSliceMode decision
	215	if ( pCodingParam->iMultipleThreadIdc == 1 )
	216	{
	217	//now is single thread. no parallel deblocking, set flag=0
	218	pCodingParam->bDeblockingParallelFlag = false;
	219	}
	220	else
	221	{
	222	pCodingParam->bDeblockingParallelFlag = true;
	223	}
	224	#else
	225	pCodingParam->bDeblockingParallelFlag = false;
	226	#endif//MT_ENABLED
	227
	228	for ( i = 0; i < pCodingParam->iNumDependencyLayer; ++ i ){
	229	SDLayerParam *fDlp = &pCodingParam->sDependencyLayers[i];
	230	const int32_t kiPicWidth = fDlp->iFrameWidth;
	231	const int32_t kiPicHeight= fDlp->iFrameHeight;
	232	int32_t iMbWidth = 0;
	233	int32_t iMbHeight = 0;
	234	int32_t iMbNumInFrame = 0;
	235	int32_t iMaxSliceNum = MAX_SLICES_NUM;
	236	if ( kiPicWidth <= 0 \|\| kiPicHeight <= 0 ){
	237	#if defined (_DEBUG)
	238	fprintf(stderr, "ParamValidationExt(), invalid %d x %d in dependency layer settings!\n", kiPicWidth, kiPicHeight);
	239	#endif//#if _DEBUG
	240	return 1;
	241	}
	242	if ( (kiPicWidth & 0x0F) != 0 \|\| (kiPicHeight & 0x0F) != 0 ){
	243	#if defined (_DEBUG)
	244	fprintf(stderr, "ParamValidationExt(), in layer #%d iWidth x iHeight(%d x %d) both should be multiple of 16, can not support with arbitrary size currently!\n", i, kiPicWidth, kiPicHeight);
	245	#endif//#if _DEBUG
	246	return 1;
	247	}
	248
	249	if ( fDlp->sMso.uiSliceMode >= SM_RESERVED ){
	250	#if defined (_DEBUG)
	251	fprintf(stderr, "ParamValidationExt(), invalid uiSliceMode (%d) settings!\n", fDlp->sMso.uiSliceMode );
	252	#endif//#if _DEBUG
	253	return 1;
	254	}
	255
	256	//check pSlice settings under multi-pSlice
	257	if ( kiPicWidth<=16 && kiPicHeight<=16 ){
	258	//only have one MB, set to single_slice
	259	fDlp->sMso.uiSliceMode = SM_SINGLE_SLICE;
	260	}
	261	switch ( fDlp->sMso.uiSliceMode )
	262	{
	263	case SM_SINGLE_SLICE:
	264	fDlp->sMso.sSliceArgument.iSliceNum = 1;
	265	fDlp->sMso.sSliceArgument.uiSliceSizeConstraint = 0;
	266	fDlp->sMso.sSliceArgument.iSliceNum = 0;
	267	for (iIdx=0; iIdx<MAX_SLICES_NUM;iIdx++)
	268	{
	269	fDlp->sMso.sSliceArgument.uiSliceMbNum[iIdx] = 0;
	270	}
	271	break;
	272	case SM_FIXEDSLCNUM_SLICE:
	273	{
	274	fDlp->sMso.sSliceArgument.uiSliceSizeConstraint = 0;
	275
	276	iMbWidth = (kiPicWidth+15)>>4;
	277	iMbHeight = (kiPicHeight+15)>>4;
	278	iMbNumInFrame = iMbWidth * iMbHeight;
	279	iMaxSliceNum = MAX_SLICES_NUM;
	280	if ( fDlp->sMso.sSliceArgument.iSliceNum <= 0
	281	\|\| fDlp->sMso.sSliceArgument.iSliceNum > iMaxSliceNum )
	282	{
	283	#if defined (_DEBUG)
	284	fprintf(stderr, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n", fDlp->sMso.sSliceArgument.iSliceNum );
	285	#endif//#if _DEBUG
	286	return 1;
	287	}
	288	if (fDlp->sMso.sSliceArgument.iSliceNum == 1)
	289	{
	290	#if defined (_DEBUG)
	291	fprintf(stderr, "ParamValidationExt(), uiSliceNum(%d) you set for SM_FIXEDSLCNUM_SLICE, now turn to SM_SINGLE_SLICE type!\n", fDlp->sMso.sSliceArgument.iSliceNum );
	292	#endif//#if _DEBUG
	293	fDlp->sMso.uiSliceMode = SM_SINGLE_SLICE;
	294	break;
	295	}
	296	if (pCodingParam->bEnableRc) // multiple slices verify with gom
	297	{
	298	//check uiSliceNum
	299	GomValidCheckSliceNum( iMbWidth, iMbHeight, (int32_t*)&fDlp->sMso.sSliceArgument.iSliceNum );
	300	assert(fDlp->sMso.sSliceArgument.iSliceNum > 1);
	301	//set uiSliceMbNum with current uiSliceNum
	302	GomValidCheckSliceMbNum( iMbWidth, iMbHeight, &fDlp->sMso.sSliceArgument );
	303	}
	304	else if ( !CheckFixedSliceNumMultiSliceSetting( iMbNumInFrame, &fDlp->sMso.sSliceArgument ) ) // verify interleave mode settings
	305	{//check uiSliceMbNum with current uiSliceNum
	306	#if defined (_DEBUG)
	307	fprintf(stderr, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", fDlp->sMso.sSliceArgument.uiSliceMbNum[0] );
	308	#endif//#if _DEBUG
	309	return 1;
	310	}
	311	// considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
	312	if ( iMbNumInFrame <= MIN_NUM_MB_PER_SLICE )
	313	{
	314	fDlp->sMso.uiSliceMode = SM_SINGLE_SLICE;
	315	fDlp->sMso.sSliceArgument.iSliceNum = 1;
	316	break;
	317	}
	318	}
	319	break;
	320	case SM_RASTER_SLICE:
	321	{
	322	fDlp->sMso.sSliceArgument.uiSliceSizeConstraint = 0;
	323
	324	iMbWidth = (kiPicWidth+15)>>4;
	325	iMbHeight = (kiPicHeight+15)>>4;
	326	iMbNumInFrame = iMbWidth * iMbHeight;
	327	iMaxSliceNum = MAX_SLICES_NUM;
	328	if ( fDlp->sMso.sSliceArgument.uiSliceMbNum[0] <= 0 )
	329	{
	330	#if defined (_DEBUG)
	331	fprintf(stderr, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", fDlp->sMso.sSliceArgument.uiSliceMbNum[0] );
	332	#endif//#if _DEBUG
	333	return 1;
	334	}
	335
	336	if ( !CheckRasterMultiSliceSetting( iMbNumInFrame, &fDlp->sMso.sSliceArgument ) ) // verify interleave mode settings
	337	{
	338	#if defined (_DEBUG)
	339	fprintf(stderr, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", fDlp->sMso.sSliceArgument.uiSliceMbNum[0] );
	340	#endif//#if _DEBUG
	341	return 1;
	342	}
	343	if ( fDlp->sMso.sSliceArgument.iSliceNum <= 0 \|\| fDlp->sMso.sSliceArgument.iSliceNum > iMaxSliceNum ) // verify interleave mode settings
	344	{
	345	#if defined (_DEBUG)
	346	fprintf(stderr, "ParamValidationExt(), invalid uiSliceNum (%d) in SM_RASTER_SLICE settings!\n", fDlp->sMso.sSliceArgument.iSliceNum );
	347	#endif//#if _DEBUG
	348	return 1;
	349	}
	350	if (fDlp->sMso.sSliceArgument.iSliceNum == 1)
	351	{
	352	#if defined (_DEBUG)
	353	fprintf(stderr, "ParamValidationExt(), pSlice setting for SM_RASTER_SLICE now turn to SM_SINGLE_SLICE!\n" );
	354	#endif//#if _DEBUG
	355	fDlp->sMso.uiSliceMode = SM_SINGLE_SLICE;
	356	break;
	357	}
	358	#ifdef MT_ENABLED
	359	if (pCodingParam->bEnableRc && fDlp->sMso.sSliceArgument.iSliceNum > 1)
	360	{
	361	#if defined (_DEBUG)
	362	fprintf(stderr, "ParamValidationExt(), WARNING: GOM based RC do not support SM_RASTER_SLICE!\n" );
	363	#endif//#if _DEBUG
	364	}
	365	#endif
	366	// considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
	367	if ( iMbNumInFrame <= MIN_NUM_MB_PER_SLICE )
	368	{
	369	fDlp->sMso.uiSliceMode = SM_SINGLE_SLICE;
	370	fDlp->sMso.sSliceArgument.iSliceNum = 1;
	371	break;
	372	}
	373	}
	374	break;
	375	case SM_ROWMB_SLICE:
	376	{
	377	fDlp->sMso.sSliceArgument.uiSliceSizeConstraint = 0;
	378
	379	iMbWidth = (kiPicWidth+15)>>4;
	380	iMbHeight = (kiPicHeight+15)>>4;
	381	iMaxSliceNum = MAX_SLICES_NUM;
	382	if ( iMbHeight > iMaxSliceNum )
	383	{
	384	#if defined (_DEBUG)
	385	fprintf(stderr, "ParamValidationExt(), invalid uiSliceNum (%d) settings more than MAX!\n", iMbHeight );
	386	#endif//#if _DEBUG
	387	return 1;
	388	}
	389	fDlp->sMso.sSliceArgument.iSliceNum = iMbHeight;
	390
	391	if ( fDlp->sMso.sSliceArgument.iSliceNum <= 0 )
	392	{
	393	#if defined (_DEBUG)
	394	fprintf(stderr, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n", fDlp->sMso.sSliceArgument.iSliceNum );
	395	#endif//#if _DEBUG
	396	return 1;
	397	}
	398	if ( !CheckRowMbMultiSliceSetting( iMbWidth, &fDlp->sMso.sSliceArgument ) ) // verify interleave mode settings
	399	{
	400	#if defined (_DEBUG)
	401	fprintf(stderr, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", fDlp->sMso.sSliceArgument.uiSliceMbNum[0] );
	402	#endif//#if _DEBUG
	403	return 1;
	404	}
	405	}
	406	break;
	407	case SM_DYN_SLICE:
	408	{
	409	iMbWidth = (kiPicWidth+15)>>4;
	410	iMbHeight = (kiPicHeight+15)>>4;
	411	if ( fDlp->sMso.sSliceArgument.uiSliceSizeConstraint <= 0 )
	412	{
	413	#if defined (_DEBUG)
	414	fprintf(stderr, "ParamValidationExt(), invalid iSliceSize (%d) settings!\n", fDlp->sMso.sSliceArgument.uiSliceSizeConstraint );
	415	#endif//#if _DEBUG
	416	return 1;
	417	}
	418	// considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
	419	if ( iMbWidth * iMbHeight <= MIN_NUM_MB_PER_SLICE )
	420	{
	421	fDlp->sMso.uiSliceMode = SM_SINGLE_SLICE;
	422	fDlp->sMso.sSliceArgument.iSliceNum = 1;
	423	break;
	424	}
	425	}
	426	break;
	427	default:
	428	{
	429
	430	#if defined (_DEBUG)
	431	fprintf(stderr, "ParamValidationExt(), invalid uiSliceMode (%d) settings!\n", pCodingParam->sDependencyLayers[0].sMso.uiSliceMode );
	432	#endif//#if _DEBUG
	433	return 1;
	434
	435	}
	436	break;
	437	}
	438	}
	439
	440	return ParamValidation(pCodingParam);
	441	}
	442
	443	/*!
	444	* \brief acquire count number of layers and NALs based on configurable paramters dependency
	445	* \pParam pCtx sWelsEncCtx*
	446	* \pParam pParam SWelsSvcCodingParam*
	447	* \pParam pCountLayers pointer of count number of layers indeed
	448	* \pParam iCountNals pointer of count number of nals indeed
	449	* \return 0 - successful; otherwise failed
	450	*/
	451	static inline int32_t AcquireLayersNals( sWelsEncCtx *ppCtx, SWelsSvcCodingParam pParam, int32_t pCountLayers, int32_t pCountNals )
	452	{
	453	int32_t iCountNumLayers = 0;
	454	int32_t iCountNumNals = 0;
	455	int32_t iNumDependencyLayers = 0;
	456	int32_t iDIndex = 0;
	457	#if defined(MT_ENABLED) && defined(PACKING_ONE_SLICE_PER_LAYER)
	458	int32_t iNumLayersPack = 0;
	459	#endif//MT_ENABLED && PACKING_ONE_SLICE_PER_LAYER
	460
	461	if ( NULL == pParam \|\| NULL == ppCtx \|\| NULL == *ppCtx )
	462	return 1;
	463
	464	iNumDependencyLayers = pParam->iNumDependencyLayer;
	465
	466	do {
	467	SDLayerParam *pDLayer = &pParam->sDependencyLayers[iDIndex];
	468	// pDLayer->ptr_cfg = pParam;
	469	int32_t iOrgNumNals = iCountNumNals;
	470
	471	//Note: Sep. 2010
	472	//Review this part and suggest no change, since the memory over-use
	473	//(1) counts little to the overall performance
	474	//(2) should not be critial even under mobile case
	475	if ( SM_DYN_SLICE == pDLayer->sMso.uiSliceMode )
	476	{
	477	iCountNumNals += MAX_SLICES_NUM;
	478	// plus prefix NALs
	479	if ( iDIndex == 0 )
	480	iCountNumNals += MAX_SLICES_NUM;
	481	// MAX_SLICES_NUM < MAX_LAYER_NUM_OF_FRAME ensured at svc_enc_slice_segment.h
	482	#if defined(MT_ENABLED) && defined(PACKING_ONE_SLICE_PER_LAYER)
	483	assert(MAX_SLICES_NUM < MAX_LAYER_NUM_OF_FRAME);
	484	// iNumLayersPack += MAX_SLICES_NUM; // do not count it for dynamic slicing mode
	485	#else//!MT_ENABLED \|\| !PACKING_ONE_SLICE_PER_LAYER
	486	assert(iCountNumNals - iOrgNumNals <= MAX_NAL_UNITS_IN_LAYER );
	487	#endif//MT_ENABLED && PACKING_ONE_SLICE_PER_LAYER
	488	}
	489	else /if ( SM_SINGLE_SLICE != pDLayer->sMso.uiSliceMode )/
	490	{
	491	const int32_t kiNumOfSlice = GetInitialSliceNum( (pDLayer->iFrameWidth+0x0f)>>4,
	492	(pDLayer->iFrameHeight+0x0f)>>4,
	493	&pDLayer->sMso );
	494
	495	// NEED check iCountNals value in case multiple slices is used
	496	iCountNumNals += kiNumOfSlice; // for pSlice VCL NALs
	497	// plus prefix NALs
	498	if ( iDIndex == 0 )
	499	iCountNumNals += kiNumOfSlice;
	500	#if defined(MT_ENABLED) && defined(PACKING_ONE_SLICE_PER_LAYER)
	501	assert(num_of_slice <= MAX_SLICES_NUM && MAX_SLICES_NUM < MAX_LAYER_NUM_OF_FRAME);
	502	iNumLayersPack += num_of_slice;
	503	#else//!MT_ENABLED \|\| !PACKING_ONE_SLICE_PER_LAYER
	504	assert(iCountNumNals - iOrgNumNals <= MAX_NAL_UNITS_IN_LAYER );
	505	#endif//MT_ENALBED && PACKING_ONE_SLICE_PER_LAYER
	506	if ( kiNumOfSlice > MAX_SLICES_NUM )
	507	{
	508	WelsLog( *ppCtx, WELS_LOG_ERROR, "AcquireLayersNals(), num_of_slice(%d) > MAX_SLICES_NUM(%d) per (iDid= %d, qid= %d) settings!\n",
	509	kiNumOfSlice, MAX_SLICES_NUM, iDIndex, 0 );
	510	return 1;
	511	}
	512	}
	513	#if !defined(MT_ENABLED) \|\| !defined(PACKING_ONE_SLICE_PER_LAYER)
	514	if ( iCountNumNals - iOrgNumNals > MAX_NAL_UNITS_IN_LAYER )
	515	{
	516	WelsLog( *ppCtx, WELS_LOG_ERROR, "AcquireLayersNals(), num_of_nals(%d) > MAX_NAL_UNITS_IN_LAYER(%d) per (iDid= %d, qid= %d) settings!\n",
	517	(iCountNumNals - iOrgNumNals), MAX_NAL_UNITS_IN_LAYER, iDIndex, 0 );
	518	return 1;
	519	}
	520	#endif//!MT_ENABLED) \|\| !PACKING_ONE_SLICE_PER_LAYER
	521
	522	iCountNumLayers ++;
	523
	524	++ iDIndex;
	525	} while(iDIndex < iNumDependencyLayers);
	526
	527	iCountNumNals += 1 + iNumDependencyLayers + (iCountNumLayers<<1) + iCountNumLayers; // plus iCountNumLayers for reserved application
	528	#if defined(MT_ENABLED) && defined(PACKING_ONE_SLICE_PER_LAYER)
	529	iNumLayersPack += 1 + iNumDependencyLayers + (iCountNumLayers<<1);
	530	#endif//MT_ENABLED && PACKING_ONE_SLICE_PER_LAYER
	531
	532	// to check number of layers / nals / slices dependencies, 12/8/2010
	533	#if !defined(MT_ENABLED)
	534	if ( iCountNumLayers > MAX_LAYER_NUM_OF_FRAME )
	535	{
	536	WelsLog( *ppCtx, WELS_LOG_ERROR, "AcquireLayersNals(), iCountNumLayers(%d) > MAX_LAYER_NUM_OF_FRAME(%d)!", iCountNumLayers, MAX_LAYER_NUM_OF_FRAME );
	537	return 1;
	538	}
	539	#else//MT_ENABLED
	540	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	541	if ( iNumLayersPack > MAX_LAYER_NUM_OF_FRAME )
	542	{
	543	WelsLog( *ppCtx, WELS_LOG_ERROR, "AcquireLayersNals(), num_layers_pack_overall(%d) > MAX_LAYER_NUM_OF_FRAME(%d)!", iNumLayersPack, MAX_LAYER_NUM_OF_FRAME );
	544	return 1;
	545	}
	546	#else//!PACKING_ONE_SLICE_PER_LAYER
	547	if ( iCountNumLayers > MAX_LAYER_NUM_OF_FRAME )
	548	{
	549	WelsLog( *ppCtx, WELS_LOG_ERROR, "AcquireLayersNals(), iCountNumLayers(%d) > MAX_LAYER_NUM_OF_FRAME(%d)!", iCountNumLayers, MAX_LAYER_NUM_OF_FRAME );
	550	return 1;
	551	}
	552	#endif//PACKING_ONE_SLICE_PER_LAYER
	553	#endif//!MT_ENABLED
	554
	555	if ( NULL != pCountLayers )
	556	*pCountLayers = iCountNumLayers;
	557	if ( NULL != pCountNals )
	558	*pCountNals = iCountNumNals;
	559	return 0;
	560	}
	561
	562	/*!
	563	* \brief alloc spatial layers pictures (I420 based source pictures)
	564	*/
	565	int32_t AllocSpatialPictures( sWelsEncCtx *ppCtx, SWelsSvcCodingParam pParam )
	566	{
	567	CMemoryAlign pMa = (ppCtx)->pMemAlign;
	568	const int32_t kiDlayerCount = pParam->iNumDependencyLayer;
	569	int32_t iDlayerIndex = 0;
	570
	571	// spatial pictures
	572	iDlayerIndex = 0;
	573	do {
	574	const int32_t kiPicWidth = pParam->sDependencyLayers[iDlayerIndex].iFrameWidth;
	575	const int32_t kiPicHeight = pParam->sDependencyLayers[iDlayerIndex].iFrameHeight;
	576	const uint8_t kuiLayerInTemporal = 2 + WELS_MAX(pParam->sDependencyLayers[iDlayerIndex].iHighestTemporalId, 1);
	577	const uint8_t kuiRefNumInTemporal = kuiLayerInTemporal + pParam->iLTRRefNum;
	578	uint8_t i = 0;
	579
	580	do {
	581	SPicture *pPic = AllocPicture( pMa, kiPicWidth, kiPicHeight, false );
	582	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pPic), FreeMemorySvc(ppCtx); *ppCtx = NULL )
	583	(*ppCtx)->pSpatialPic[iDlayerIndex][i] = pPic;
	584	++ i;
	585	} while( i < kuiRefNumInTemporal);
	586
	587	(*ppCtx)->uiSpatialLayersInTemporal[iDlayerIndex] = kuiLayerInTemporal;
	588	(*ppCtx)->uiSpatialPicNum[iDlayerIndex] = kuiRefNumInTemporal;
	589	++ iDlayerIndex;
	590	} while( iDlayerIndex < kiDlayerCount );
	591
	592	return 0;
	593	}
	594
	595	void FreeSpatialPictures( sWelsEncCtx *pCtx )
	596	{
	597	CMemoryAlign *pMa = pCtx->pMemAlign;
	598	int32_t j = 0;
	599	while( j < pCtx->pSvcParam->iNumDependencyLayer )
	600	{
	601	uint8_t i = 0;
	602	uint8_t uiRefNumInTemporal = pCtx->uiSpatialPicNum[j];
	603
	604	while( i < uiRefNumInTemporal )
	605	{
	606	if ( NULL != pCtx->pSpatialPic[j][i] )
	607	{
	608	FreePicture( pMa, &pCtx->pSpatialPic[j][i] );
	609	}
	610	++ i;
	611	}
	612	pCtx->uiSpatialLayersInTemporal[j] = 0;
	613	++ j;
	614	}
	615
	616	}
	617
	618	static void InitMbInfo(sWelsEncCtx * pEnc, SMB * pList, SDqLayer * pLayer, const int32_t kiDlayerId, const int32_t kiMaxMbNum )
	619	{
	620	int32_t iMbWidth = pLayer->iMbWidth;
	621	int32_t iMbHeight = pLayer->iMbHeight;
	622	int32_t iIdx;
	623	int32_t iMbNum = iMbWidth * iMbHeight;
	624	SSliceCtx *pSliceCtx= pLayer->pSliceEncCtx;
	625	uint32_t uiNeighborAvail;
	626	const int32_t kiOffset = (kiDlayerId & 0x01) * kiMaxMbNum;
	627	SMVUnitXY (pLayerMvUnitBlock4x4)[MB_BLOCK4x4_NUM] = (SMVUnitXY()[MB_BLOCK4x4_NUM])(&pEnc->pMvUnitBlock4x4[MB_BLOCK4x4_NUM*kiOffset]);
	628	int8_t (pLayerRefIndexBlock8x8)[MB_BLOCK8x8_NUM] = (int8_t()[MB_BLOCK8x8_NUM])(&pEnc->pRefIndexBlock4x4[MB_BLOCK8x8_NUM*kiOffset]);
	629
	630	for( iIdx = 0; iIdx<iMbNum; iIdx++ ){
	631	BOOL_T bLeft;
	632	BOOL_T bTop;
	633	BOOL_T bLeftTop;
	634	BOOL_T bRightTop;
	635	int32_t iLeftXY, iTopXY, iLeftTopXY, iRightTopXY;
	636	uint8_t uiSliceIdc;
	637
	638	pList[iIdx].iMbX = pEnc->pStrideTab->pMbIndexX[kiDlayerId][iIdx];
	639	pList[iIdx].iMbY = pEnc->pStrideTab->pMbIndexY[kiDlayerId][iIdx];
	640	pList[iIdx].iMbXY = iIdx;
	641
	642	uiSliceIdc = WelsMbToSliceIdc(pSliceCtx, iIdx);
	643	iLeftXY = iIdx - 1;
	644	iTopXY = iIdx - iMbWidth;
	645	iLeftTopXY = iTopXY - 1;
	646	iRightTopXY = iTopXY + 1;
	647
	648	bLeft = (pList[iIdx].iMbX > 0) && (uiSliceIdc == WelsMbToSliceIdc(pSliceCtx, iLeftXY));
	649	bTop = (pList[iIdx].iMbY > 0) && (uiSliceIdc == WelsMbToSliceIdc(pSliceCtx, iTopXY));
	650	bLeftTop = (pList[iIdx].iMbX > 0) && (pList[iIdx].iMbY > 0) && (uiSliceIdc ==
	651	WelsMbToSliceIdc(pSliceCtx, iLeftTopXY));
	652	bRightTop = (pList[iIdx].iMbX < (iMbWidth-1)) && (pList[iIdx].iMbY > 0) && (uiSliceIdc ==
	653	WelsMbToSliceIdc(pSliceCtx, iRightTopXY));
	654
	655	uiNeighborAvail = 0;
	656	if( bLeft ){
	657	uiNeighborAvail \|= LEFT_MB_POS;
	658	}
	659	if( bTop ){
	660	uiNeighborAvail \|= TOP_MB_POS;
	661	}
	662	if( bLeftTop ){
	663	uiNeighborAvail \|= TOPLEFT_MB_POS;
	664	}
	665	if( bRightTop ){
	666	uiNeighborAvail \|= TOPRIGHT_MB_POS;
	667	}
	668	pList[iIdx].uiSliceIdc = uiSliceIdc; // merge from svc_hd_opt_b for multiple slices coding
	669	pList[iIdx].uiNeighborAvail = uiNeighborAvail;
	670	uiNeighborAvail = 0;
	671	if(pList[iIdx].iMbX >= BASE_MV_MB_NMB)
	672	uiNeighborAvail \|= LEFT_MB_POS;
	673	if(pList[iIdx].iMbX <= (iMbWidth-1-BASE_MV_MB_NMB))
	674	uiNeighborAvail \|= RIGHT_MB_POS;
	675	if (pList[iIdx].iMbY >= BASE_MV_MB_NMB)
	676	uiNeighborAvail \|= TOP_MB_POS;
	677	if(pList[iIdx].iMbY <= (iMbHeight-1-BASE_MV_MB_NMB))
	678	uiNeighborAvail \|= BOTTOM_MB_POS;
	679
	680	pList[iIdx].sMv = pLayerMvUnitBlock4x4[iIdx];
	681	pList[iIdx].pRefIndex = pLayerRefIndexBlock8x8[iIdx];
	682	pList[iIdx].pSadCost = &pEnc->pSadCostMb[iIdx];
	683	pList[iIdx].pIntra4x4PredMode = &pEnc->pIntra4x4PredModeBlocks[iIdx*INTRA_4x4_MODE_NUM];
	684	pList[iIdx].pNonZeroCount = &pEnc->pNonZeroCountBlocks[iIdx*MB_LUMA_CHROMA_BLOCK4x4_NUM];
	685	}
	686	}
	687
	688
	689	int32_t InitMbListD( sWelsEncCtx ** ppCtx)
	690	{
	691	int32_t iNumDlayer = (*ppCtx)->pSvcParam->iNumDependencyLayer;
	692	int32_t iMbSize[MAX_DEPENDENCY_LAYER] = { 0 };
	693	int32_t iOverallMbNum = 0;
	694	int32_t iMbWidth = 0;
	695	int32_t iMbHeight= 0;
	696	int32_t i;
	697
	698	if ( iNumDlayer > MAX_DEPENDENCY_LAYER )
	699	return 1;
	700
	701	for( i=0;i<iNumDlayer;i++ ){
	702	iMbWidth = ((*ppCtx)->pSvcParam->sDependencyLayers[i].iFrameWidth + 15)>>4;
	703	iMbHeight = ((*ppCtx)->pSvcParam->sDependencyLayers[i].iFrameHeight + 15)>>4;
	704	iMbSize[i] = iMbWidth * iMbHeight;
	705	iOverallMbNum += iMbSize[i];
	706	}
	707
	708	(ppCtx)->ppMbListD = static_cast<SMB >((ppCtx)->pMemAlign->WelsMalloc(iNumDlayer * sizeof(SMB *), "ppMbListD"));
	709	(*ppCtx)->ppMbListD[0] = NULL;
	710	WELS_VERIFY_RETURN_PROC_IF(1, (*ppCtx)->ppMbListD==NULL, FreeMemorySvc(ppCtx));
	711	(ppCtx)->ppMbListD[0] = static_cast<SMB>((ppCtx)->pMemAlign->WelsMallocz(iOverallMbNum sizeof(SMB), "ppMbListD[0]"));
	712	WELS_VERIFY_RETURN_PROC_IF(1, (*ppCtx)->ppMbListD[0]==NULL, FreeMemorySvc(ppCtx));
	713	(ppCtx)->ppDqLayerList[0]->sMbDataP = (ppCtx)->ppMbListD[0];
	714	InitMbInfo(ppCtx, (ppCtx)->ppMbListD[0], (*ppCtx)->ppDqLayerList[0], 0, iMbSize[iNumDlayer-1]);
	715	for( i=1;i<iNumDlayer;i++ ){
	716	(ppCtx)->ppMbListD[i] = (ppCtx)->ppMbListD[i-1] + iMbSize[i-1];
	717	(ppCtx)->ppDqLayerList[i]->sMbDataP = (ppCtx)->ppMbListD[i];
	718	InitMbInfo(ppCtx, (ppCtx)->ppMbListD[i], (*ppCtx)->ppDqLayerList[i], i, iMbSize[iNumDlayer-1]);
	719	}
	720
	721	return 0;
	722	}
	723
	724	int32_t AllocMbCacheAligned( SMbCache pMbCache, CMemoryAlign pMa )
	725	{
	726	pMbCache->pCoeffLevel = (int16_t )pMa->WelsMalloc(MB_COEFF_LIST_SIZEsizeof(int16_t), "pMbCache->pCoeffLevel");
	727	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pCoeffLevel));
	728	pMbCache->pMemPredMb = (uint8_t )pMa->WelsMalloc(2256*sizeof(uint8_t), "pMbCache->pMemPredMb");
	729	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pMemPredMb));
	730	pMbCache->pSkipMb = (uint8_t )pMa->WelsMalloc(384sizeof(uint8_t), "pMbCache->pSkipMb");
	731	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pSkipMb));
	732	pMbCache->pMemPredBlk4 = (uint8_t )pMa->WelsMalloc(216*sizeof(uint8_t), "pMbCache->pMemPredBlk4");
	733	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pMemPredBlk4));
	734	pMbCache->pBufferInterPredMe = (uint8_t )pMa->WelsMalloc(4640*sizeof(uint8_t), "pMbCache->pBufferInterPredMe");
	735	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pBufferInterPredMe));
	736	pMbCache->pPrevIntra4x4PredModeFlag = (bool_t )pMa->WelsMalloc(16sizeof(bool_t), "pMbCache->pPrevIntra4x4PredModeFlag");
	737	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pPrevIntra4x4PredModeFlag));
	738	pMbCache->pRemIntra4x4PredModeFlag = (int8_t )pMa->WelsMalloc(16sizeof(int8_t), "pMbCache->pRemIntra4x4PredModeFlag");
	739	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pRemIntra4x4PredModeFlag));
	740	pMbCache->pDct = (SDCTCoeff *)pMa->WelsMalloc(sizeof(SDCTCoeff), "pMbCache->pDct");
	741	WELS_VERIFY_RETURN_IF(1, (NULL==pMbCache->pDct));
	742	return 0;
	743	}
	744
	745	void FreeMbCache( SMbCache pMbCache, CMemoryAlign pMa )
	746	{
	747	if ( NULL != pMbCache->pCoeffLevel )
	748	{
	749	pMa->WelsFree( pMbCache->pCoeffLevel, "pMbCache->pCoeffLevel" );
	750	pMbCache->pCoeffLevel = NULL;
	751	}
	752	if ( NULL != pMbCache->pMemPredMb )
	753	{
	754	pMa->WelsFree( pMbCache->pMemPredMb, "pMbCache->pMemPredMb" );
	755	pMbCache->pMemPredMb = NULL;
	756	}
	757	if ( NULL != pMbCache->pSkipMb )
	758	{
	759	pMa->WelsFree( pMbCache->pSkipMb, "pMbCache->pSkipMb" );
	760	pMbCache->pSkipMb = NULL;
	761	}
	762	if ( NULL != pMbCache->pMemPredBlk4 )
	763	{
	764	pMa->WelsFree( pMbCache->pMemPredBlk4, "pMbCache->pMemPredBlk4" );
	765	pMbCache->pMemPredBlk4 = NULL;
	766	}
	767	if ( NULL != pMbCache->pBufferInterPredMe )
	768	{
	769	pMa->WelsFree( pMbCache->pBufferInterPredMe, "pMbCache->pBufferInterPredMe" );
	770	pMbCache->pBufferInterPredMe = NULL;
	771	}
	772	if ( NULL != pMbCache->pPrevIntra4x4PredModeFlag )
	773	{
	774	pMa->WelsFree( pMbCache->pPrevIntra4x4PredModeFlag, "pMbCache->pPrevIntra4x4PredModeFlag" );
	775	pMbCache->pPrevIntra4x4PredModeFlag = NULL;
	776	}
	777	if ( NULL != pMbCache->pRemIntra4x4PredModeFlag )
	778	{
	779	pMa->WelsFree( pMbCache->pRemIntra4x4PredModeFlag, "pMbCache->pRemIntra4x4PredModeFlag" );
	780	pMbCache->pRemIntra4x4PredModeFlag = NULL;
	781	}
	782	if ( NULL != pMbCache->pDct )
	783	{
	784	pMa->WelsFree( pMbCache->pDct, "pMbCache->pDct" );
	785	pMbCache->pDct = NULL;
	786	}
	787	}
	788
	789
	790	/*!
	791	* \brief initialize ppDqLayerList and slicepEncCtx_list due to count number of layers available
	792	* \pParam pCtx sWelsEncCtx*
	793	* \return 0 - successful; otherwise failed
	794	*/
	795	static inline int32_t InitDqLayers( sWelsEncCtx **ppCtx )
	796	{
	797	SWelsSvcCodingParam *pParam = NULL;
	798	SWelsSPS *pSps = NULL;
	799	SSubsetSps *pSubsetSps = NULL;
	800	SWelsPPS *pPps = NULL;
	801	CMemoryAlign *pMa = NULL;
	802	SStrideTables *pStrideTab = NULL;
	803	int32_t iDlayerCount = 0;
	804	int32_t iDlayerIndex = 0;
	805	uint32_t iSpsId = 0;
	806	uint32_t iPpsId = 0;
	807	uint32_t iNumRef = 0;
	808	int32_t iResult = 0;
	809
	810	if ( NULL == ppCtx \|\| NULL == *ppCtx )
	811	return 1;
	812
	813	pMa = (*ppCtx)->pMemAlign;
	814	pParam = (*ppCtx)->pSvcParam;
	815	iDlayerCount = pParam->iNumDependencyLayer;
	816	iNumRef = pParam->iNumRefFrame;
	817	// highest_layers_in_temporal = 1 + WELS_MAX(pParam->iDecompStages, 1);
	818	pStrideTab = (*ppCtx)->pStrideTab;
	819
	820	iDlayerIndex = 0;
	821	while (iDlayerIndex < iDlayerCount)
	822	{
	823	SRefList *pRefList = NULL;
	824	uint32_t i = 0;
	825	const int32_t kiWidth = pParam->sDependencyLayers[iDlayerIndex].iFrameWidth;
	826	const int32_t kiHeight = pParam->sDependencyLayers[iDlayerIndex].iFrameHeight;
	827	int32_t iPicWidth = WELS_ALIGN(kiWidth, MB_WIDTH_LUMA) + (PADDING_LENGTH<<1); // with iWidth of horizon
	828	int32_t iPicChromaWidth = iPicWidth >> 1;
	829
	830	iPicWidth = WELS_ALIGN( iPicWidth, 32 ); // 32(or 16 for chroma below) to match original imp. here instead of iCacheLineSize
	831	iPicChromaWidth = WELS_ALIGN( iPicChromaWidth, 16 );
	832
	833	WelsGetEncBlockStrideOffset( (*ppCtx)->pStrideTab->pStrideEncBlockOffset[iDlayerIndex], iPicWidth, iPicChromaWidth);
	834
	835	// pRef list
	836	pRefList = (SRefList *)pMa->WelsMallocz( sizeof(SRefList), "pRefList" );
	837	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pRefList), FreeMemorySvc(ppCtx) )
	838
	839	do {
	840	pRefList->pRef[i] = AllocPicture( pMa, kiWidth, kiHeight, true ); // to use actual size of current layer
	841	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pRefList->pRef[i]), FreeMemorySvc(ppCtx) )
	842	++ i;
	843	} while(i < 1 + iNumRef);
	844
	845	pRefList->pNextBuffer = pRefList->pRef[0];
	846	(*ppCtx)->ppRefPicListExt[iDlayerIndex] = pRefList;
	847	++ iDlayerIndex;
	848	}
	849
	850	// for I420 based source spatial pictures
	851	if ( AllocSpatialPictures( ppCtx, pParam ) )
	852	{
	853	FreeMemorySvc( ppCtx );
	854	return 1;
	855	}
	856
	857	iDlayerIndex = 0;
	858	while (iDlayerIndex < iDlayerCount) {
	859	SDqLayer *pDqLayer = NULL;
	860	SDLayerParam *pDlayer = &pParam->sDependencyLayers[iDlayerIndex];
	861	const int32_t kiMbW = (pDlayer->iFrameWidth + 0x0f) >> 4;
	862	const int32_t kiMbH = (pDlayer->iFrameHeight + 0x0f) >> 4;
	863	int32_t iMaxSliceNum = 1;
	864	const int32_t kiSliceNum = GetInitialSliceNum( kiMbW, kiMbH, &pDlayer->sMso );
	865	if ( iMaxSliceNum < kiSliceNum )
	866	iMaxSliceNum = kiSliceNum;
	867
	868	// pDq layers list
	869	pDqLayer = (SDqLayer *)pMa->WelsMallocz( sizeof(SDqLayer), "pDqLayer" );
	870	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pDqLayer), FreeMemorySvc(ppCtx) )
	871
	872	// for dynamic slicing mode
	873	if ( SM_DYN_SLICE == pDlayer->sMso.uiSliceMode )
	874	{
	875	const int32_t iSize = pParam->iCountThreadsNum * sizeof(int32_t);
	876
	877	pDqLayer->pNumSliceCodedOfPartition = (int32_t *)pMa->WelsMallocz( iSize, "pNumSliceCodedOfPartition" );
	878	pDqLayer->pLastCodedMbIdxOfPartition = (int32_t *)pMa->WelsMallocz( iSize, "pLastCodedMbIdxOfPartition" );
	879	pDqLayer->pLastMbIdxOfPartition = (int32_t *)pMa->WelsMallocz( iSize, "pLastMbIdxOfPartition" );
	880
	881	WELS_VERIFY_RETURN_PROC_IF( 1,
	882	(NULL == pDqLayer->pNumSliceCodedOfPartition \|\|
	883	NULL == pDqLayer->pLastCodedMbIdxOfPartition \|\|
	884	NULL == pDqLayer->pLastMbIdxOfPartition),
	885	FreeMemorySvc(ppCtx) )
	886	}
	887
	888	pDqLayer->iMbWidth = kiMbW;
	889	pDqLayer->iMbHeight = kiMbH;
	890	#ifndef MT_ENABLED
	891	if ( SM_DYN_SLICE == pDlayer->sMso.uiSliceMode )//wmalloc pSliceInLayer
	892	{
	893	SSlice *pSlice = NULL;
	894	int32_t iSliceIdx = 0;
	895	//wmalloc AVERSLICENUM_CONSTANT of pDqLayer->sLayerInfo.pSliceInLayer,
	896	//wmalloc AVERSLICENUM_CONSTANT num of pSlice as initialization
	897	//only set value for the first pSlice
	898	pDqLayer->sLayerInfo.pSliceInLayer = (SSlice )pMa->WelsMallocz( sizeof(SSlice) iMaxSliceNum, "pSliceInLayer" );
	899
	900	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pDqLayer->sLayerInfo.pSliceInLayer), FreeMemorySvc(ppCtx) )
	901	{
	902	pSlice = &pDqLayer->sLayerInfo.pSliceInLayer[0];
	903	pSlice->uiSliceIdx = 0;
	904	pSlice->pSliceBsa = &(*ppCtx)->pOut->sBsWrite;
	905	}
	906
	907	while(iSliceIdx < iMaxSliceNum)
	908	{
	909	pSlice = &pDqLayer->sLayerInfo.pSliceInLayer[iSliceIdx];
	910	if ( AllocMbCacheAligned(&pSlice->sMbCacheInfo, pMa) )
	911	{
	912	FreeMemorySvc(ppCtx);
	913	return 1;
	914	}
	915	++ iSliceIdx;
	916	}
	917	}
	918	else
	919	#endif//!MT_ENABLED
	920	{
	921	int32_t iSliceIdx = 0;
	922	pDqLayer->sLayerInfo.pSliceInLayer = (SSlice )pMa->WelsMallocz( sizeof(SSlice) iMaxSliceNum, "pSliceInLayer" );
	923
	924	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pDqLayer->sLayerInfo.pSliceInLayer), FreeMemorySvc(ppCtx) )
	925	if ( iMaxSliceNum > 1 )
	926	{
	927	while (iSliceIdx < iMaxSliceNum) {
	928	SSlice *pSlice = &pDqLayer->sLayerInfo.pSliceInLayer[iSliceIdx];
	929	pSlice->uiSliceIdx = iSliceIdx;
	930	#ifdef MT_ENABLED
	931	if ( pParam->iMultipleThreadIdc > 1 )
	932	pSlice->pSliceBsa = &(*ppCtx)->pSliceBs[iSliceIdx].sBsWrite;
	933	else
	934	pSlice->pSliceBsa = &(*ppCtx)->pOut->sBsWrite;
	935	#else
	936	pSlice->pSliceBsa = &(*ppCtx)->pOut->sBsWrite;
	937	#endif//MT_ENABLED
	938	if ( AllocMbCacheAligned(&pSlice->sMbCacheInfo, pMa) )
	939	{
	940	FreeMemorySvc(ppCtx);
	941	return 1;
	942	}
	943	++ iSliceIdx;
	944	}
	945	}
	946	// fix issue in case single pSlice coding might be inclusive exist in variant spatial layer setting, also introducing multi-pSlice modes
	947	else // only one pSlice
	948	{
	949	SSlice *pSlice = &pDqLayer->sLayerInfo.pSliceInLayer[0];
	950	pSlice->uiSliceIdx = 0;
	951	pSlice->pSliceBsa = &(*ppCtx)->pOut->sBsWrite;
	952	if ( AllocMbCacheAligned(&pSlice->sMbCacheInfo, pMa) )
	953	{
	954	FreeMemorySvc(ppCtx);
	955	return 1;
	956	}
	957	}
	958	}
	959
	960	//deblocking parameters initialization
	961	//target-layer deblocking
	962	pDqLayer->iLoopFilterDisableIdc = pParam->iLoopFilterDisableIdc;
	963	pDqLayer->iLoopFilterAlphaC0Offset = (pParam->iLoopFilterAlphaC0Offset)<<1;
	964	pDqLayer->iLoopFilterBetaOffset = (pParam->iLoopFilterBetaOffset)<<1;
	965	//inter-layer deblocking
	966	pDqLayer->uiDisableInterLayerDeblockingFilterIdc = pParam->iInterLayerLoopFilterDisableIdc;
	967	pDqLayer->iInterLayerSliceAlphaC0Offset = (pParam->iInterLayerLoopFilterAlphaC0Offset)<<1;
	968	pDqLayer->iInterLayerSliceBetaOffset = (pParam->iInterLayerLoopFilterBetaOffset)<<1;
	969	//parallel deblocking
	970	pDqLayer->bDeblockingParallelFlag = pParam->bDeblockingParallelFlag;
	971
	972	//deblocking parameter adjustment
	973	if ( SM_SINGLE_SLICE == pDlayer->sMso.uiSliceMode )
	974	{
	975	//iLoopFilterDisableIdc: will be 0 or 1 under single_slice
	976	if ( 2 == pParam->iLoopFilterDisableIdc )
	977	{
	978	pDqLayer->iLoopFilterDisableIdc = 0;
	979	}
	980	//bDeblockingParallelFlag
	981	pDqLayer->bDeblockingParallelFlag = false;
	982	}
	983	else
	984	{//multi-pSlice
	985	#ifdef MT_ENABLED
	986	if ( 0 == pDqLayer->iLoopFilterDisableIdc )
	987	{
	988	pDqLayer->bDeblockingParallelFlag = false;
	989	}
	990	#endif
	991	}
	992
	993	(*ppCtx)->ppDqLayerList[iDlayerIndex] = pDqLayer;
	994
	995	++ iDlayerIndex;
	996	}
	997
	998	// for dynamically malloc for parameter sets memory instead of maximal items for standard to reduce size, 3/18/2010
	999	if ( &(*ppCtx)->pSvcParam->bMgsT0OnlyStrategy )
	1000	{
	1001	(ppCtx)->pPPSArray = (SWelsPPS )pMa->WelsMalloc( (1+iDlayerCount) * sizeof(SWelsPPS), "pPPSArray" );
	1002	}
	1003	else
	1004	{
	1005	(ppCtx)->pPPSArray = (SWelsPPS )pMa->WelsMalloc( iDlayerCount * sizeof(SWelsPPS), "pPPSArray" );
	1006	}
	1007	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pPPSArray), FreeMemorySvc(ppCtx) )
	1008
	1009	(ppCtx)->pSpsArray = (SWelsSPS )pMa->WelsMalloc( sizeof(SWelsSPS), "pSpsArray" );
	1010	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pSpsArray), FreeMemorySvc(ppCtx) )
	1011	if ( iDlayerCount > 1 )
	1012	{
	1013	(ppCtx)->pSubsetArray = (SSubsetSps )pMa->WelsMalloc( (iDlayerCount-1) * sizeof(SSubsetSps), "pSubsetArray" );
	1014	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pSubsetArray), FreeMemorySvc(ppCtx) )
	1015	}
	1016
	1017	(ppCtx)->pDqIdcMap = (SDqIdc )pMa->WelsMallocz( iDlayerCount * sizeof(SDqIdc), "pDqIdcMap" );
	1018	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pDqIdcMap), FreeMemorySvc(ppCtx) )
	1019
	1020	iDlayerIndex = 0;
	1021	while (iDlayerIndex < iDlayerCount) {
	1022	SDqIdc pDqIdc = &(ppCtx)->pDqIdcMap[iDlayerIndex];
	1023	const bool_t bUseSubsetSps = (iDlayerIndex > BASE_DEPENDENCY_ID);
	1024	SDLayerParam *pDlayerParam = &pParam->sDependencyLayers[iDlayerIndex];
	1025
	1026	pDqIdc->uiSpatialId = iDlayerIndex;
	1027	pPps = &(*ppCtx)->pPPSArray[iPpsId];
	1028	if ( !bUseSubsetSps )
	1029	{
	1030	pSps = &(*ppCtx)->pSpsArray[iSpsId];
	1031	}
	1032	else
	1033	{
	1034	pSubsetSps = &(*ppCtx)->pSubsetArray[iSpsId];
	1035	pSps = &pSubsetSps->pSps;
	1036	}
	1037
	1038	// Need port pSps/pPps initialization due to spatial scalability changed
	1039	if ( !bUseSubsetSps )
	1040	{
	1041	WelsInitSps( pSps, pDlayerParam, pParam->uiIntraPeriod, pParam->iNumRefFrame, iSpsId,
	1042	pParam->bEnableFrameCroppingFlag, pParam->bEnableRc );
	1043
	1044	if( iDlayerCount > 1 )
	1045	{
	1046	pSps->bConstraintSet0Flag = true;
	1047	pSps->bConstraintSet1Flag = true;
	1048	pSps->bConstraintSet2Flag = true;
	1049	}
	1050	}
	1051	else
	1052	{
	1053	WelsInitSubsetSps( pSubsetSps, pDlayerParam, pParam->uiIntraPeriod, pParam->iNumRefFrame, iSpsId,
	1054	pParam->bEnableFrameCroppingFlag, pParam->bEnableRc );
	1055	}
	1056
	1057	// initialize pPps
	1058	WelsInitPps( pPps, pSps, pSubsetSps, iPpsId, true, bUseSubsetSps );
	1059
	1060	// Not using FMO in SVC coding so far, come back if need FMO
	1061	{
	1062	iResult = InitSlicePEncCtx( &(*ppCtx)->pSliceCtxList[iDlayerIndex],
	1063	(*ppCtx)->pMemAlign,
	1064	false,
	1065	pSps->iMbWidth,
	1066	pSps->iMbHeight,
	1067	&(pDlayerParam->sMso),
	1068	pPps );
	1069	if ( iResult )
	1070	{
	1071	WelsLog( *ppCtx, WELS_LOG_WARNING, "InitDqLayers(), InitSlicePEncCtx failed(%d)!", iResult );
	1072	FreeMemorySvc( ppCtx );
	1073	return 1;
	1074	}
	1075	(ppCtx)->ppDqLayerList[iDlayerIndex]->pSliceEncCtx = &(ppCtx)->pSliceCtxList[iDlayerIndex];
	1076	}
	1077	pDqIdc->iSpsId = iSpsId;
	1078	pDqIdc->iPpsId = iPpsId;
	1079
	1080	(*ppCtx)->sPSOVector.bPpsIdMappingIntoSubsetsps[iPpsId] = bUseSubsetSps;
	1081
	1082	if ( bUseSubsetSps )
	1083	++ iSpsId;
	1084	++ iPpsId;
	1085	++ (*ppCtx)->iSpsNum;
	1086	++ (*ppCtx)->iPpsNum;
	1087
	1088	++ iDlayerIndex;
	1089	}
	1090	return 0;
	1091	}
	1092
	1093	int32_t AllocStrideTables( sWelsEncCtx **ppCtx, const int32_t kiNumSpatialLayers )
	1094	{
	1095	CMemoryAlign pMa = (ppCtx)->pMemAlign;
	1096	SWelsSvcCodingParam pParam = (ppCtx)->pSvcParam;
	1097	SStrideTables *pPtr = NULL;
	1098	int16_t pTmpRow = NULL, pRowX = NULL, pRowY = NULL, p = NULL;
	1099	uint8_t *pBase = NULL;
	1100	uint8_t pBaseDec = NULL, pBaseEnc = NULL, pBaseMbX = NULL, pBaseMbY = NULL;
	1101	struct {
	1102	int32_t iMbWidth;
	1103	int32_t iCountMbNum; // count number of SMB in each spatial
	1104	int32_t iSizeAllMbAlignCache; // cache line size aligned in each spatial
	1105	} sMbSizeMap[MAX_DEPENDENCY_LAYER] = {0};
	1106	int32_t iLineSizeY[MAX_DEPENDENCY_LAYER][2] = {0};
	1107	int32_t iLineSizeUV[MAX_DEPENDENCY_LAYER][2]= {0};
	1108	int32_t iMapSpatialIdx[MAX_DEPENDENCY_LAYER][2] = {0};
	1109	int32_t iSizeDec = 0;
	1110	int32_t iSizeEnc = 0;
	1111	int32_t iCountLayersNeedCs[2] = {0};
	1112	const int32_t kiUnit1Size = 24 * sizeof(int32_t);
	1113	int32_t iUnit2Size = 0;
	1114	int32_t iNeedAllocSize = 0;
	1115	int32_t iRowSize = 0;
	1116	int16_t iMaxMbWidth = 0;
	1117	int16_t iMaxMbHeight = 0;
	1118	int32_t i = 0;
	1119	int32_t iSpatialIdx = 0;
	1120	int32_t iTemporalIdx = 0;
	1121	int32_t iCntTid = 0;
	1122
	1123	if ( kiNumSpatialLayers <= 0 \|\| kiNumSpatialLayers > MAX_DEPENDENCY_LAYER)
	1124	return 1;
	1125
	1126	pPtr = (SStrideTables *)pMa->WelsMalloc(sizeof(SStrideTables), "SStrideTables");
	1127	if (NULL == pPtr)
	1128	return 1;
	1129	(*ppCtx)->pStrideTab = pPtr;
	1130
	1131	iCntTid = pParam->iNumTemporalLayer > 1 ? 2 : 1;
	1132
	1133	iSpatialIdx = 0;
	1134	while (iSpatialIdx < kiNumSpatialLayers) {
	1135	const int32_t kiTmpWidth = (pParam->sDependencyLayers[iSpatialIdx].iFrameWidth + 15) >> 4;
	1136	const int32_t kiTmpHeight= (pParam->sDependencyLayers[iSpatialIdx].iFrameHeight + 15) >> 4;
	1137	int32_t iNumMb = kiTmpWidth * kiTmpHeight;
	1138
	1139	sMbSizeMap[iSpatialIdx].iMbWidth = kiTmpWidth;
	1140	sMbSizeMap[iSpatialIdx].iCountMbNum = iNumMb;
	1141
	1142	iNumMb *= sizeof(int16_t);
	1143	sMbSizeMap[iSpatialIdx].iSizeAllMbAlignCache = iNumMb;
	1144	iUnit2Size += iNumMb;
	1145
	1146	++ iSpatialIdx;
	1147	}
	1148
	1149	// Adaptive size_cs, size_fdec by implementation dependency
	1150	iTemporalIdx= 0;
	1151	while ( iTemporalIdx < iCntTid )
	1152	{
	1153	const bool_t kbBaseTemporalFlag = (iTemporalIdx == 0);
	1154
	1155	iSpatialIdx = 0;
	1156	while ( iSpatialIdx < kiNumSpatialLayers )
	1157	{
	1158	SDLayerParam *fDlp = &pParam->sDependencyLayers[iSpatialIdx];
	1159
	1160	const int32_t kiWidthPad = WELS_ALIGN( fDlp->iFrameWidth, 16 ) + (PADDING_LENGTH<<1);
	1161	iLineSizeY[iSpatialIdx][kbBaseTemporalFlag] = WELS_ALIGN( kiWidthPad, 32 );
	1162	iLineSizeUV[iSpatialIdx][kbBaseTemporalFlag]= WELS_ALIGN( (kiWidthPad>>1), 16 );
	1163
	1164	iMapSpatialIdx[iCountLayersNeedCs[kbBaseTemporalFlag]][kbBaseTemporalFlag] = iSpatialIdx;
	1165	++ iCountLayersNeedCs[kbBaseTemporalFlag];
	1166	++ iSpatialIdx;
	1167	}
	1168	++ iTemporalIdx;
	1169	}
	1170	iSizeDec= kiUnit1Size * (iCountLayersNeedCs[0] + iCountLayersNeedCs[1]);
	1171	iSizeEnc= kiUnit1Size * kiNumSpatialLayers;
	1172
	1173	iNeedAllocSize = iSizeDec + iSizeEnc + (iUnit2Size << 1);
	1174
	1175	pBase = (uint8_t *)pMa->WelsMalloc( iNeedAllocSize, "pBase" );
	1176	if ( NULL == pBase )
	1177	{
	1178	return 1;
	1179	}
	1180
	1181	pBaseDec= pBase; // iCountLayersNeedCs
	1182	pBaseEnc= pBaseDec + iSizeDec; // iNumSpatialLayers
	1183	pBaseMbX = pBaseEnc + iSizeEnc; // iNumSpatialLayers
	1184	pBaseMbY = pBaseMbX + iUnit2Size; // iNumSpatialLayers
	1185
	1186	iTemporalIdx= 0;
	1187	while ( iTemporalIdx < iCntTid )
	1188	{
	1189	const bool_t kbBaseTemporalFlag = (iTemporalIdx == 0);
	1190
	1191	iSpatialIdx = 0;
	1192	while ( iSpatialIdx < iCountLayersNeedCs[kbBaseTemporalFlag] )
	1193	{
	1194	const int32_t kiActualSpatialIdx = iMapSpatialIdx[iSpatialIdx][kbBaseTemporalFlag];
	1195	const int32_t kiLumaWidth = iLineSizeY[kiActualSpatialIdx][kbBaseTemporalFlag];
	1196	const int32_t kiChromaWidth = iLineSizeUV[kiActualSpatialIdx][kbBaseTemporalFlag];
	1197
	1198	WelsGetEncBlockStrideOffset( (int32_t *)pBaseDec, kiLumaWidth, kiChromaWidth );
	1199
	1200	pPtr->pStrideDecBlockOffset[kiActualSpatialIdx][kbBaseTemporalFlag] = (int32_t *)pBaseDec;
	1201	pBaseDec+= kiUnit1Size;
	1202
	1203	++ iSpatialIdx;
	1204	}
	1205	++ iTemporalIdx;
	1206	}
	1207	iTemporalIdx= 0;
	1208	while ( iTemporalIdx < iCntTid )
	1209	{
	1210	const bool_t kbBaseTemporalFlag = (iTemporalIdx == 0);
	1211
	1212	iSpatialIdx = 0;
	1213	while (iSpatialIdx < kiNumSpatialLayers)
	1214	{
	1215	int32_t iMatchIndex = 0;
	1216	bool_t bInMap = false;
	1217	bool_t bMatchFlag = false;
	1218
	1219	i = 0;
	1220	while ( i < iCountLayersNeedCs[kbBaseTemporalFlag] )
	1221	{
	1222	const int32_t kiActualIdx = iMapSpatialIdx[i][kbBaseTemporalFlag];
	1223	if ( kiActualIdx == iSpatialIdx )
	1224	{
	1225	bInMap = true;
	1226	break;
	1227	}
	1228	if ( !bMatchFlag )
	1229	{
	1230	iMatchIndex = kiActualIdx;
	1231	bMatchFlag = true;
	1232	}
	1233	++ i;
	1234	}
	1235
	1236	if ( bInMap )
	1237	{
	1238	++ iSpatialIdx;
	1239	continue;
	1240	}
	1241
	1242	// not in spatial map and assign match one to it
	1243	pPtr->pStrideDecBlockOffset[iSpatialIdx][kbBaseTemporalFlag] = pPtr->pStrideDecBlockOffset[iMatchIndex][kbBaseTemporalFlag];
	1244
	1245	++ iSpatialIdx;
	1246	}
	1247	++ iTemporalIdx;
	1248	}
	1249
	1250	iSpatialIdx = 0;
	1251	while ( iSpatialIdx < kiNumSpatialLayers )
	1252	{
	1253	const int32_t kiAllocMbSize = sMbSizeMap[iSpatialIdx].iSizeAllMbAlignCache;
	1254
	1255	pPtr->pStrideEncBlockOffset[iSpatialIdx] = (int32_t *)pBaseEnc;
	1256
	1257	pPtr->pMbIndexX[iSpatialIdx] = (int16_t *)pBaseMbX;
	1258	pPtr->pMbIndexY[iSpatialIdx] = (int16_t *)pBaseMbY;
	1259
	1260	pBaseEnc += kiUnit1Size;
	1261	pBaseMbX += kiAllocMbSize;
	1262	pBaseMbY += kiAllocMbSize;
	1263
	1264	++ iSpatialIdx;
	1265	}
	1266
	1267	while ( iSpatialIdx < MAX_DEPENDENCY_LAYER )
	1268	{
	1269	pPtr->pStrideDecBlockOffset[iSpatialIdx][0] = NULL;
	1270	pPtr->pStrideDecBlockOffset[iSpatialIdx][1] = NULL;
	1271	pPtr->pStrideEncBlockOffset[iSpatialIdx] = NULL;
	1272	pPtr->pMbIndexX[iSpatialIdx] = NULL;
	1273	pPtr->pMbIndexY[iSpatialIdx] = NULL;
	1274
	1275	++ iSpatialIdx;
	1276	}
	1277
	1278	// initialize pMbIndexX and pMbIndexY tables as below
	1279
	1280	iMaxMbWidth = sMbSizeMap[kiNumSpatialLayers-1].iMbWidth;
	1281	iMaxMbWidth = WELS_ALIGN(iMaxMbWidth, 4); // 4 loops for int16_t required introduced as below
	1282	iRowSize = iMaxMbWidth * sizeof(int16_t);
	1283
	1284	pTmpRow = (int16_t*)pMa->WelsMalloc( iRowSize, "pTmpRow" );
	1285	if ( NULL == pTmpRow )
	1286	{
	1287	return 1;
	1288	}
	1289	pRowX = pTmpRow;
	1290	pRowY = pRowX;
	1291	// initialize pRowX & pRowY
	1292	i = 0;
	1293	p = pRowX;
	1294	while ( i < iMaxMbWidth )
	1295	{
	1296	*p = i;
	1297	*(p+1) = 1+i;
	1298	*(p+2) = 2+i;
	1299	*(p+3) = 3+i;
	1300
	1301	p += 4;
	1302	i += 4;
	1303	}
	1304
	1305	iSpatialIdx = kiNumSpatialLayers;
	1306	while ( --iSpatialIdx >= 0 )
	1307	{
	1308	int16_t *pMbIndexX = pPtr->pMbIndexX[iSpatialIdx];
	1309	const int32_t kiMbWidth = sMbSizeMap[iSpatialIdx].iMbWidth;
	1310	const int32_t kiMbHeight = sMbSizeMap[iSpatialIdx].iCountMbNum / kiMbWidth;
	1311	const int32_t kiLineSize = kiMbWidth * sizeof(int16_t);
	1312
	1313	i = 0;
	1314	while ( i < kiMbHeight )
	1315	{
	1316	memcpy( pMbIndexX, pRowX, kiLineSize ); // confirmed_safe_unsafe_usage
	1317
	1318	pMbIndexX += kiMbWidth;
	1319	++ i;
	1320	}
	1321	}
	1322
	1323	memset(pRowY, 0, iRowSize);
	1324	iMaxMbHeight = sMbSizeMap[kiNumSpatialLayers-1].iCountMbNum / sMbSizeMap[kiNumSpatialLayers-1].iMbWidth;
	1325	i = 0;
	1326	for (;;)
	1327	{
	1328	ENFORCE_STACK_ALIGN_1D(int16_t, t, 4, 16)
	1329
	1330	int32_t t32 = 0;
	1331	int16_t j = 0;
	1332
	1333	for ( iSpatialIdx = kiNumSpatialLayers-1; iSpatialIdx >= 0; -- iSpatialIdx )
	1334	{
	1335	const int32_t kiMbWidth = sMbSizeMap[iSpatialIdx].iMbWidth;
	1336	const int32_t kiMbHeight = sMbSizeMap[iSpatialIdx].iCountMbNum / kiMbWidth;
	1337	const int32_t kiLineSize = kiMbWidth * sizeof(int16_t);
	1338	int16_t pMbIndexY = pPtr->pMbIndexY[iSpatialIdx] + i kiMbWidth;
	1339
	1340	if ( i < kiMbHeight )
	1341	{
	1342	memcpy( pMbIndexY, pRowY, kiLineSize ); // confirmed_safe_unsafe_usage
	1343	}
	1344	}
	1345	++ i;
	1346	if (i >= iMaxMbHeight)
	1347	break;
	1348
	1349	t32 = i \| (i << 16);
	1350	ST32( t , t32 );
	1351	ST32( t+2, t32 );
	1352
	1353	p = pRowY;
	1354	while ( j < iMaxMbWidth )
	1355	{
	1356	ST64( p, LD64(t) );
	1357
	1358	p += 4;
	1359	j += 4;
	1360	}
	1361	}
	1362
	1363	pMa->WelsFree( pTmpRow, "pTmpRow" );
	1364	pTmpRow = NULL;
	1365
	1366	return 0;
	1367	}
	1368
	1369	/*!
	1370	* \brief request specific memory for SVC
	1371	* \pParam pEncCtx sWelsEncCtx*
	1372	* \return successful - 0; otherwise none 0 for failed
	1373	*/
	1374	int32_t RequestMemorySvc( sWelsEncCtx **ppCtx )
	1375	{
	1376	SWelsSvcCodingParam pParam = (ppCtx)->pSvcParam;
	1377	CMemoryAlign pMa = (ppCtx)->pMemAlign;
	1378	SDLayerParam *pFinalSpatial = NULL;
	1379	int32_t iCountBsLen = 0;
	1380	int32_t iCountNals = 0;
	1381	int32_t iMaxPicWidth = 0;
	1382	int32_t iMaxPicHeight = 0;
	1383	int32_t iCountMaxMbNum = 0;
	1384	int32_t iIndex = 0;
	1385	int32_t iCountLayers = 0;
	1386	int32_t iResult = 0;
	1387	float fCompressRatioThr = .5f;
	1388	const int32_t kiNumDependencyLayers = pParam->iNumDependencyLayer;
	1389	const uint32_t kuiMvdInterTableSize = ( kiNumDependencyLayers == 1 ? (1 + (648 << 1)) : (1 + (972 << 1)) );
	1390	const uint32_t kuiMvdCacheAlginedSize = kuiMvdInterTableSize * sizeof(uint16_t);
	1391	int32_t iVclLayersBsSizeCount = 0;
	1392	int32_t iNonVclLayersBsSizeCount = 0;
	1393	#if defined(MT_ENABLED)
	1394	int32_t iTargetSpatialBsSize = 0;
	1395	#endif//MT_ENABLED
	1396
	1397	if ( kiNumDependencyLayers < 1 \|\| kiNumDependencyLayers > MAX_DEPENDENCY_LAYER )
	1398	{
	1399	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc() failed due to invalid iNumDependencyLayers(%d)!\n", kiNumDependencyLayers);
	1400	FreeMemorySvc( ppCtx );
	1401	return 1;
	1402	}
	1403
	1404	if ( pParam->uiGopSize == 0 \|\| ( pParam->uiIntraPeriod && ((pParam->uiIntraPeriod % pParam->uiGopSize) != 0)) )
	1405	{
	1406	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc() failed due to invalid uiIntraPeriod(%d) (=multipler of uiGopSize(%d)!",
	1407	pParam->uiIntraPeriod, pParam->uiGopSize);
	1408	FreeMemorySvc( ppCtx );
	1409	return 1;
	1410	}
	1411
	1412	pFinalSpatial = &pParam->sDependencyLayers[kiNumDependencyLayers - 1];
	1413	iMaxPicWidth = pFinalSpatial->iFrameWidth;
	1414	iMaxPicHeight = pFinalSpatial->iFrameHeight;
	1415	iCountMaxMbNum= ((15+iMaxPicWidth)>>4) * ((15+iMaxPicHeight)>>4);
	1416
	1417	iResult = AcquireLayersNals( ppCtx, pParam, &iCountLayers, &iCountNals );
	1418	if ( iResult )
	1419	{
	1420	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc(), AcquireLayersNals failed(%d)!", iResult);
	1421	FreeMemorySvc( ppCtx );
	1422	return 1;
	1423	}
	1424
	1425	iNonVclLayersBsSizeCount = SSEI_BUFFER_SIZE + pParam->iNumDependencyLayer * SPS_BUFFER_SIZE + (1+pParam->iNumDependencyLayer) * PPS_BUFFER_SIZE;
	1426
	1427	int32_t iLayerBsSize = 0;
	1428	iIndex = 0;
	1429	while(iIndex < pParam->iNumDependencyLayer)
	1430	{
	1431	SDLayerParam *fDlp = &pParam->sDependencyLayers[iIndex];
	1432
	1433	fCompressRatioThr = COMPRESS_RATIO_DECIDED_BY_RESOLUTION(fDlp->iFrameWidth, fDlp->iFrameHeight);
	1434
	1435	iLayerBsSize = WELS_ROUND( ( (3 * fDlp->iFrameWidth * fDlp->iFrameHeight)>>1) * fCompressRatioThr);
	1436	iLayerBsSize = WELS_ALIGN(iLayerBsSize, 4); // 4 bytes alinged
	1437	iVclLayersBsSizeCount += iLayerBsSize;
	1438	++ iIndex;
	1439	}
	1440	#if defined(MT_ENABLED)
	1441	iTargetSpatialBsSize = iLayerBsSize;
	1442	#endif//MT_ENABLED
	1443	iCountBsLen = iNonVclLayersBsSizeCount + iVclLayersBsSizeCount;
	1444
	1445	pParam->iNumRefFrame = WELS_CLIP3(pParam->iNumRefFrame, MIN_REF_PIC_COUNT, MAX_REFERENCE_PICTURE_COUNT_NUM);
	1446
	1447	// Output
	1448	(ppCtx)->pOut = (SWelsEncoderOutput )pMa->WelsMalloc( sizeof(SWelsEncoderOutput), "SWelsEncoderOutput" );
	1449	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pOut), FreeMemorySvc(ppCtx) )
	1450	(ppCtx)->pOut->pBsBuffer = (uint8_t )pMa->WelsMalloc( iCountBsLen, "pOut->pBsBuffer" );
	1451	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pOut->pBsBuffer), FreeMemorySvc(ppCtx) )
	1452	(*ppCtx)->pOut->uiSize = iCountBsLen;
	1453	(ppCtx)->pOut->sNalList = (SWelsNalRaw )pMa->WelsMalloc( iCountNals * sizeof(SWelsNalRaw), "pOut->sNalList" );
	1454	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pOut->sNalList), FreeMemorySvc(ppCtx) )
	1455	(*ppCtx)->pOut->iCountNals = iCountNals;
	1456	(*ppCtx)->pOut->iNalIndex = 0;
	1457
	1458	#ifdef MT_ENABLED
	1459	if ( pParam->iMultipleThreadIdc > 1 )
	1460	{
	1461	(ppCtx)->pFrameBs = (uint8_t )pMa->WelsMalloc( iCountBsLen + (iTargetSpatialBsSize * ((*ppCtx)->iMaxSliceCount-1)), "pFrameBs" );
	1462	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pFrameBs), FreeMemorySvc(ppCtx) )
	1463	(ppCtx)->iFrameBsSize = iCountBsLen (*ppCtx)->iMaxSliceCount;
	1464	}
	1465	else
	1466	#endif//MT_ENABLED
	1467	{
	1468	(ppCtx)->pFrameBs = (uint8_t )pMa->WelsMalloc( iCountBsLen, "pFrameBs" );
	1469	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pFrameBs), FreeMemorySvc(ppCtx) )
	1470	(*ppCtx)->iFrameBsSize = iCountBsLen;
	1471	}
	1472	(*ppCtx)->iPosBsBuffer = 0;
	1473
	1474	#ifdef MT_ENABLED
	1475	// for pSlice bs buffers
	1476	if ( pParam->iMultipleThreadIdc > 1 && RequestMtResource( ppCtx, pParam, iCountBsLen, iTargetSpatialBsSize ) )
	1477	{
	1478	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc(), RequestMtResource failed!");
	1479	FreeMemorySvc( ppCtx );
	1480	return 1;
	1481	}
	1482	#endif
	1483
	1484	(ppCtx)->pIntra4x4PredModeBlocks = static_cast<int8_t>
	1485	(pMa->WelsMallocz( iCountMaxMbNum * INTRA_4x4_MODE_NUM, "pIntra4x4PredModeBlocks" ));
	1486	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pIntra4x4PredModeBlocks), FreeMemorySvc(ppCtx) )
	1487
	1488	(ppCtx)->pNonZeroCountBlocks = static_cast<int8_t>
	1489	(pMa->WelsMallocz( iCountMaxMbNum * MB_LUMA_CHROMA_BLOCK4x4_NUM, "pNonZeroCountBlocks" ));
	1490	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pNonZeroCountBlocks), FreeMemorySvc(ppCtx) )
	1491
	1492	(ppCtx)->pMvUnitBlock4x4 = static_cast<SMVUnitXY>
	1493	(pMa->WelsMallocz( iCountMaxMbNum * 2 * MB_BLOCK4x4_NUM * sizeof(SMVUnitXY), "pMvUnitBlock4x4" ));
	1494	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pMvUnitBlock4x4), FreeMemorySvc(ppCtx) )
	1495
	1496	(ppCtx)->pRefIndexBlock4x4 = static_cast<int8_t>
	1497	(pMa->WelsMallocz( iCountMaxMbNum * 2 * MB_BLOCK8x8_NUM * sizeof(int8_t), "pRefIndexBlock4x4" ));
	1498	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pRefIndexBlock4x4), FreeMemorySvc(ppCtx) )
	1499
	1500	(ppCtx)->pSadCostMb = static_cast<int32_t>
	1501	(pMa->WelsMallocz( iCountMaxMbNum * sizeof(int32_t), "pSadCostMb" ));
	1502	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pSadCostMb), FreeMemorySvc(ppCtx))
	1503
	1504	(*ppCtx)->bEncCurFrmAsIdrFlag = true; // make sure first frame is IDR
	1505	(*ppCtx)->iGlobalQp = 26; // global qp in default
	1506
	1507	(ppCtx)->pLtr = (SLTRState )pMa->WelsMalloc( kiNumDependencyLayers*sizeof(SLTRState), "SLTRState" );
	1508	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pLtr), FreeMemorySvc(ppCtx) )
	1509	int32_t i = 0;
	1510	for( i = 0; i < kiNumDependencyLayers; i++ )
	1511	{
	1512	ResetLtrState( &(*ppCtx)->pLtr[i] );
	1513	}
	1514
	1515	(ppCtx)->ppRefPicListExt = (SRefList)pMa->WelsMalloc( kiNumDependencyLayers sizeof(SRefList *), "ppRefPicListExt" );
	1516	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->ppRefPicListExt), FreeMemorySvc(ppCtx) )
	1517
	1518	// pSlice context list
	1519	(ppCtx)->pSliceCtxList = (SSliceCtx )pMa->WelsMallocz( kiNumDependencyLayers * sizeof(SSliceCtx), "pSliceCtxList" );
	1520	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pSliceCtxList), FreeMemorySvc(ppCtx) )
	1521
	1522	(ppCtx)->ppDqLayerList = (SDqLayer )pMa->WelsMalloc( kiNumDependencyLayers sizeof(SDqLayer *), "ppDqLayerList" );
	1523	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->ppDqLayerList), FreeMemorySvc(ppCtx) )
	1524
	1525	// stride tables
	1526	if ( AllocStrideTables( ppCtx, kiNumDependencyLayers ) )
	1527	{
	1528	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc(), AllocStrideTables failed!");
	1529	FreeMemorySvc( ppCtx );
	1530	return 1;
	1531	}
	1532
	1533	//Rate control module memory allocation
	1534	// only malloc once for RC pData, 12/14/2009
	1535	(ppCtx)->pWelsSvcRc = (SWelsSvcRc )pMa->WelsMallocz( kiNumDependencyLayers * sizeof(SWelsSvcRc), "pWelsSvcRc" );
	1536	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pWelsSvcRc), FreeMemorySvc(ppCtx) )
	1537	//End of Rate control module memory allocation
	1538
	1539	//pVaa memory allocation
	1540	(ppCtx)->pVaa = (SVAAFrameInfo )pMa->WelsMallocz( sizeof(SVAAFrameInfo), "pVaa" );
	1541	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa), FreeMemorySvc(ppCtx) )
	1542
	1543	if((*ppCtx)->pSvcParam->bEnableAdaptiveQuant)//malloc mem
	1544	{
	1545	(ppCtx)->pVaa->sAdaptiveQuantParam.pMotionTextureUnit = static_cast<SMotionTextureUnit>
	1546	(pMa->WelsMallocz( iCountMaxMbNum * sizeof(SMotionTextureUnit), "pVaa->sAdaptiveQuantParam.pMotionTextureUnit" ));
	1547	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sAdaptiveQuantParam.pMotionTextureUnit), FreeMemorySvc(ppCtx) )
	1548	(ppCtx)->pVaa->sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp = static_cast<int8_t>
	1549	(pMa->WelsMallocz( iCountMaxMbNum * sizeof(int8_t), "pVaa->sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp" ));
	1550	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp), FreeMemorySvc(ppCtx) )
	1551	}
	1552
	1553	(ppCtx)->pVaa->pVaaBackgroundMbFlag = (int8_t )pMa->WelsMallocz( iCountMaxMbNum * sizeof(int8_t), "pVaa->vaa_skip_mb_flag" );
	1554	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->pVaaBackgroundMbFlag), FreeMemorySvc(ppCtx) )
	1555
	1556	(ppCtx)->pVaa->sVaaCalcInfo.pSad8x8 = static_cast<int32_t()[4]>
	1557	(pMa->WelsMallocz( iCountMaxMbNum * 4 * sizeof(int32_t), "pVaa->sVaaCalcInfo.sad8x8" ));
	1558	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sVaaCalcInfo.pSad8x8), FreeMemorySvc(ppCtx) )
	1559	(ppCtx)->pVaa->sVaaCalcInfo.pSsd16x16 = static_cast<int32_t>
	1560	(pMa->WelsMallocz( iCountMaxMbNum * sizeof(int32_t), "pVaa->sVaaCalcInfo.pSsd16x16" ));
	1561	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sVaaCalcInfo.pSsd16x16), FreeMemorySvc(ppCtx) )
	1562	(ppCtx)->pVaa->sVaaCalcInfo.pSum16x16 = static_cast<int32_t>
	1563	(pMa->WelsMallocz( iCountMaxMbNum * sizeof(int32_t), "pVaa->sVaaCalcInfo.pSum16x16" ));
	1564	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sVaaCalcInfo.pSum16x16), FreeMemorySvc(ppCtx) )
	1565	(ppCtx)->pVaa->sVaaCalcInfo.pSumOfSquare16x16 = static_cast<int32_t>
	1566	(pMa->WelsMallocz( iCountMaxMbNum * sizeof(int32_t), "pVaa->sVaaCalcInfo.pSumOfSquare16x16" ));
	1567	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sVaaCalcInfo.pSumOfSquare16x16), FreeMemorySvc(ppCtx) )
	1568
	1569	if ((*ppCtx)->pSvcParam->bEnableBackgroundDetection) //BGD control
	1570	{
	1571	(ppCtx)->pVaa->sVaaCalcInfo.pSumOfDiff8x8 = static_cast<int32_t()[4]>
	1572	(pMa->WelsMallocz( iCountMaxMbNum * 4 * sizeof(int32_t), "pVaa->sVaaCalcInfo.sd_16x16" ));
	1573	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sVaaCalcInfo.pSumOfDiff8x8), FreeMemorySvc(ppCtx) )
	1574	(ppCtx)->pVaa->sVaaCalcInfo.pMad8x8 = static_cast<uint8_t()[4]>
	1575	(pMa->WelsMallocz( iCountMaxMbNum * 4 * sizeof(uint8_t), "pVaa->sVaaCalcInfo.mad_16x16" ));
	1576	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pVaa->sVaaCalcInfo.pMad8x8), FreeMemorySvc(ppCtx) )
	1577	}
	1578
	1579	//End of pVaa memory allocation
	1580
	1581	iResult = InitDqLayers( ppCtx );
	1582	if ( iResult )
	1583	{
	1584	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc(), InitDqLayers failed(%d)!", iResult );
	1585	FreeMemorySvc( ppCtx );
	1586	return iResult;
	1587	}
	1588
	1589	if( InitMbListD( ppCtx ) )
	1590	{
	1591	WelsLog( *ppCtx, WELS_LOG_WARNING, "RequestMemorySvc(), InitMbListD failed!" );
	1592	FreeMemorySvc( ppCtx );
	1593	return 1;
	1594	}
	1595
	1596	(ppCtx)->pMvdCostTableInter = (uint16_t )pMa->WelsMallocz( 52 * kuiMvdCacheAlginedSize, "pMvdCostTableInter" );
	1597	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == (*ppCtx)->pMvdCostTableInter), FreeMemorySvc(ppCtx) )
	1598	MvdCostInit( (*ppCtx)->pMvdCostTableInter, kuiMvdInterTableSize ); //should put to a better place?
	1599
	1600	if ( (ppCtx)->ppRefPicListExt[0] != NULL && (ppCtx)->ppRefPicListExt[0]->pRef[0] != NULL )
	1601	(ppCtx)->pDecPic = (ppCtx)->ppRefPicListExt[0]->pRef[0];
	1602	else
	1603	(*ppCtx)->pDecPic = NULL; // error here
	1604
	1605	(ppCtx)->pSps = &(ppCtx)->pSpsArray[0];
	1606	(ppCtx)->pPps = &(ppCtx)->pPPSArray[0];
	1607
	1608	return 0;
	1609	}
	1610
	1611
	1612	/*!
	1613	* \brief free memory in SVC core encoder
	1614	* \pParam pEncCtx sWelsEncCtx*
	1615	* \return none
	1616	*/
	1617	void FreeMemorySvc( sWelsEncCtx **ppCtx )
	1618	{
	1619	if ( NULL != *ppCtx )
	1620	{
	1621	sWelsEncCtx pCtx = ppCtx;
	1622	CMemoryAlign *pMa = pCtx->pMemAlign;
	1623	SWelsSvcCodingParam *pParam= pCtx->pSvcParam;
	1624	int32_t ilayer = 0;
	1625
	1626	// SStrideTables
	1627	if ( NULL != pCtx->pStrideTab )
	1628	{
	1629	if ( NULL != pCtx->pStrideTab->pStrideDecBlockOffset[0][1] )
	1630	{
	1631	pMa->WelsFree( pCtx->pStrideTab->pStrideDecBlockOffset[0][1], "pBase" );
	1632	pCtx->pStrideTab->pStrideDecBlockOffset[0][1] = NULL;
	1633	}
	1634	pMa->WelsFree(pCtx->pStrideTab, "SStrideTables");
	1635	pCtx->pStrideTab = NULL;
	1636	}
	1637	// pDq idc map
	1638	if ( NULL != pCtx->pDqIdcMap )
	1639	{
	1640	pMa->WelsFree( pCtx->pDqIdcMap, "pDqIdcMap" );
	1641	pCtx->pDqIdcMap = NULL;
	1642	}
	1643
	1644	if ( NULL != pCtx->pOut )
	1645	{
	1646	// bs pBuffer
	1647	if ( NULL != pCtx->pOut->pBsBuffer )
	1648	{
	1649	pMa->WelsFree( pCtx->pOut->pBsBuffer, "pOut->pBsBuffer" );
	1650	pCtx->pOut->pBsBuffer = NULL;
	1651	}
	1652	// NALs list
	1653	if ( NULL != pCtx->pOut->sNalList )
	1654	{
	1655	pMa->WelsFree( pCtx->pOut->sNalList, "pOut->sNalList" );
	1656	pCtx->pOut->sNalList = NULL;
	1657	}
	1658	pMa->WelsFree( pCtx->pOut, "SWelsEncoderOutput" );
	1659	pCtx->pOut = NULL;
	1660	}
	1661
	1662	#ifdef MT_ENABLED
	1663	if ( pParam != NULL && pParam->iMultipleThreadIdc > 1 )
	1664	ReleaseMtResource( ppCtx );
	1665	#endif//MT_ENABLED
	1666
	1667	// frame bitstream pBuffer
	1668	if ( NULL != pCtx->pFrameBs )
	1669	{
	1670	pMa->WelsFree( pCtx->pFrameBs, "pFrameBs" );
	1671	pCtx->pFrameBs = NULL;
	1672	}
	1673
	1674	// pSpsArray
	1675	if ( NULL != pCtx->pSpsArray )
	1676	{
	1677	pMa->WelsFree( pCtx->pSpsArray, "pSpsArray" );
	1678	pCtx->pSpsArray = NULL;
	1679	}
	1680	// pPPSArray
	1681	if ( NULL != pCtx->pPPSArray )
	1682	{
	1683	pMa->WelsFree( pCtx->pPPSArray, "pPPSArray" );
	1684	pCtx->pPPSArray = NULL;
	1685	}
	1686	// subset_sps_array
	1687	if ( NULL != pCtx->pSubsetArray )
	1688	{
	1689	pMa->WelsFree( pCtx->pSubsetArray, "pSubsetArray" );
	1690	pCtx->pSubsetArray = NULL;
	1691	}
	1692
	1693	if( NULL != pCtx->pIntra4x4PredModeBlocks ){
	1694	pMa->WelsFree( pCtx->pIntra4x4PredModeBlocks, "pIntra4x4PredModeBlocks" );
	1695	pCtx->pIntra4x4PredModeBlocks = NULL;
	1696	}
	1697
	1698	if( NULL != pCtx->pNonZeroCountBlocks ){
	1699	pMa->WelsFree( pCtx->pNonZeroCountBlocks, "pNonZeroCountBlocks" );
	1700	pCtx->pNonZeroCountBlocks = NULL;
	1701	}
	1702
	1703	if ( NULL != pCtx->pMvUnitBlock4x4)
	1704	{
	1705	pMa->WelsFree( pCtx->pMvUnitBlock4x4, "pMvUnitBlock4x4" );
	1706	pCtx->pMvUnitBlock4x4 = NULL;
	1707	}
	1708
	1709	if ( NULL != pCtx->pRefIndexBlock4x4)
	1710	{
	1711	pMa->WelsFree( pCtx->pRefIndexBlock4x4, "pRefIndexBlock4x4" );
	1712	pCtx->pRefIndexBlock4x4 = NULL;
	1713	}
	1714
	1715	if ( NULL != pCtx->ppMbListD )
	1716	{
	1717	if( NULL != pCtx->ppMbListD[0] ){
	1718	pMa->WelsFree( pCtx->ppMbListD[0], "ppMbListD[0]" );
	1719	(*ppCtx)->ppMbListD[0] = NULL;
	1720	}
	1721	pMa->WelsFree( pCtx->ppMbListD, "ppMbListD" );
	1722	pCtx->ppMbListD = NULL;
	1723	}
	1724
	1725	if ( NULL != pCtx->pSadCostMb)
	1726	{
	1727	pMa->WelsFree( pCtx->pSadCostMb, "pSadCostMb" );
	1728	pCtx->pSadCostMb = NULL;
	1729	}
	1730
	1731	// SLTRState
	1732	if ( NULL != pCtx->pLtr )
	1733	{
	1734	pMa->WelsFree( pCtx->pLtr, "SLTRState" );
	1735	pCtx->pLtr = NULL;
	1736	}
	1737
	1738	// pDq layers list
	1739	ilayer = 0;
	1740	if ( NULL != pCtx->ppDqLayerList && pParam != NULL )
	1741	{
	1742	while (ilayer < pParam->iNumDependencyLayer) {
	1743	SDqLayer *pDq = pCtx->ppDqLayerList[ilayer];
	1744	SDLayerParam *pDlp = &pCtx->pSvcParam->sDependencyLayers[ilayer];
	1745	const BOOL_T kbIsDynamicSlicing = (SM_DYN_SLICE == pDlp->sMso.uiSliceMode);
	1746
	1747	// pDq layers
	1748	if ( NULL != pDq )
	1749	{
	1750	if ( NULL != pDq->sLayerInfo.pSliceInLayer )
	1751	{
	1752	int32_t iSliceIdx = 0;
	1753	int32_t iSliceNum = GetInitialSliceNum( pDq->iMbWidth, pDq->iMbHeight, &pDlp->sMso );
	1754	if (iSliceNum < 1)
	1755	iSliceNum = 1;
	1756	while(iSliceIdx < iSliceNum)
	1757	{
	1758	SSlice *pSlice = &pDq->sLayerInfo.pSliceInLayer[iSliceIdx];
	1759	FreeMbCache(&pSlice->sMbCacheInfo, pMa);
	1760	++ iSliceIdx;
	1761	}
	1762	pMa->WelsFree( pDq->sLayerInfo.pSliceInLayer, "pSliceInLayer" );
	1763	pDq->sLayerInfo.pSliceInLayer = NULL;
	1764	}
	1765	if ( kbIsDynamicSlicing )
	1766	{
	1767	pMa->WelsFree( pDq->pNumSliceCodedOfPartition, "pNumSliceCodedOfPartition" );
	1768	pDq->pNumSliceCodedOfPartition = NULL;
	1769	pMa->WelsFree( pDq->pLastCodedMbIdxOfPartition, "pLastCodedMbIdxOfPartition" );
	1770	pDq->pLastCodedMbIdxOfPartition = NULL;
	1771	pMa->WelsFree( pDq->pLastMbIdxOfPartition, "pLastMbIdxOfPartition" );
	1772	pDq->pLastMbIdxOfPartition = NULL;
	1773	}
	1774
	1775	pMa->WelsFree( pDq, "pDq" );
	1776	pDq = NULL;
	1777	pCtx->ppDqLayerList[ilayer] = NULL;
	1778	}
	1779	++ ilayer;
	1780	}
	1781	pMa->WelsFree( pCtx->ppDqLayerList, "ppDqLayerList" );
	1782	pCtx->ppDqLayerList = NULL;
	1783	}
	1784	FreeSpatialPictures( pCtx );
	1785
	1786	// reference picture list extension
	1787	if ( NULL != pCtx->ppRefPicListExt && pParam != NULL )
	1788	{
	1789	ilayer = 0;
	1790	while (ilayer < pParam->iNumDependencyLayer) {
	1791	SRefList *pRefList = pCtx->ppRefPicListExt[ilayer];
	1792	if ( NULL != pRefList )
	1793	{
	1794	int32_t iRef = 0;
	1795	do {
	1796	if ( pRefList->pRef[iRef] != NULL )
	1797	{
	1798	FreePicture( pMa, &pRefList->pRef[iRef] );
	1799	}
	1800	++ iRef;
	1801	} while(iRef < 1 + pParam->iNumRefFrame);
	1802
	1803	pMa->WelsFree( pCtx->ppRefPicListExt[ilayer], "ppRefPicListExt[]" );
	1804	pCtx->ppRefPicListExt[ilayer] = NULL;
	1805	}
	1806	++ ilayer;
	1807	}
	1808
	1809	pMa->WelsFree( pCtx->ppRefPicListExt, "ppRefPicListExt" );
	1810	pCtx->ppRefPicListExt = NULL;
	1811	}
	1812
	1813	// pSlice context list
	1814	if ( NULL != pCtx->pSliceCtxList && pParam != NULL )
	1815	{
	1816	ilayer = 0;
	1817	while (ilayer < pParam->iNumDependencyLayer) {
	1818	SSliceCtx *pSliceCtx = &pCtx->pSliceCtxList[ilayer];
	1819	if ( NULL != pSliceCtx )
	1820	UninitSlicePEncCtx( pSliceCtx, pMa );
	1821	++ ilayer;
	1822	}
	1823	pMa->WelsFree( pCtx->pSliceCtxList, "pSliceCtxList" );
	1824	pCtx->pSliceCtxList = NULL;
	1825	}
	1826
	1827	// VAA
	1828	if ( NULL != pCtx->pVaa )
	1829	{
	1830	if(pCtx->pSvcParam->bEnableAdaptiveQuant)//free mem
	1831	{
	1832	pMa->WelsFree( pCtx->pVaa->sAdaptiveQuantParam.pMotionTextureUnit, "pVaa->sAdaptiveQuantParam.pMotionTextureUnit" );
	1833	pCtx->pVaa->sAdaptiveQuantParam.pMotionTextureUnit = NULL;
	1834	pMa->WelsFree( pCtx->pVaa->sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp, "pVaa->sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp" );
	1835	pCtx->pVaa->sAdaptiveQuantParam.pMotionTextureIndexToDeltaQp = NULL;
	1836	}
	1837
	1838	pMa->WelsFree( pCtx->pVaa->pVaaBackgroundMbFlag, "pVaa->pVaaBackgroundMbFlag");
	1839	pCtx->pVaa->pVaaBackgroundMbFlag = NULL;
	1840	pMa->WelsFree( pCtx->pVaa->sVaaCalcInfo.pSad8x8, "pVaa->sVaaCalcInfo.sad8x8" );
	1841	pCtx->pVaa->sVaaCalcInfo.pSad8x8 = NULL;
	1842	pMa->WelsFree( pCtx->pVaa->sVaaCalcInfo.pSsd16x16, "pVaa->sVaaCalcInfo.pSsd16x16" );
	1843	pCtx->pVaa->sVaaCalcInfo.pSsd16x16 = NULL;
	1844	pMa->WelsFree( pCtx->pVaa->sVaaCalcInfo.pSum16x16, "pVaa->sVaaCalcInfo.pSum16x16" );
	1845	pCtx->pVaa->sVaaCalcInfo.pSum16x16 = NULL;
	1846	pMa->WelsFree( pCtx->pVaa->sVaaCalcInfo.pSumOfSquare16x16, "pVaa->sVaaCalcInfo.pSumOfSquare16x16" );
	1847	pCtx->pVaa->sVaaCalcInfo.pSumOfSquare16x16 = NULL;
	1848
	1849	if (pCtx->pSvcParam->bEnableBackgroundDetection) //BGD control
	1850	{
	1851	pMa->WelsFree( pCtx->pVaa->sVaaCalcInfo.pSumOfDiff8x8, "pVaa->sVaaCalcInfo.pSumOfDiff8x8" );
	1852	pCtx->pVaa->sVaaCalcInfo.pSumOfDiff8x8 = NULL;
	1853	pMa->WelsFree( pCtx->pVaa->sVaaCalcInfo.pMad8x8, "pVaa->sVaaCalcInfo.pMad8x8" );
	1854	pCtx->pVaa->sVaaCalcInfo.pMad8x8 = NULL;
	1855	}
	1856
	1857	pMa->WelsFree( pCtx->pVaa, "pVaa" );
	1858	pCtx->pVaa = NULL;
	1859	}
	1860
	1861	WelsRcFreeMemory(pCtx);
	1862	// rate control module memory free
	1863	if ( NULL != pCtx->pWelsSvcRc )
	1864	{
	1865	pMa->WelsFree( pCtx->pWelsSvcRc, "pWelsSvcRc" );
	1866	pCtx->pWelsSvcRc = NULL;
	1867	}
	1868
	1869	/* MVD cost tables for Inter */
	1870	if ( NULL != pCtx->pMvdCostTableInter )
	1871	{
	1872	pMa->WelsFree( pCtx->pMvdCostTableInter, "pMvdCostTableInter" );
	1873	pCtx->pMvdCostTableInter = NULL;
	1874	}
	1875
	1876	#ifdef ENABLE_TRACE_FILE
	1877	if ( NULL != pCtx->pFileLog )
	1878	{
	1879	fclose( pCtx->pFileLog );
	1880	pCtx->pFileLog = NULL;
	1881	}
	1882	pCtx->uiSizeLog = 0;
	1883	#endif//ENABLE_TRACE_FILE
	1884
	1885	FreeCodingParam( &pCtx->pSvcParam, pMa );
	1886	if ( NULL != pCtx->pFuncList )
	1887	{
	1888	pMa->WelsFree(pCtx->pFuncList, "SWelsFuncPtrList");
	1889	pCtx->pFuncList = NULL;
	1890	}
	1891
	1892	#if defined(MEMORY_MONITOR)
	1893	assert(pMa->WelsGetMemoryUsage() == 0); // ensure all memory free well
	1894	#endif//MEMORY_MONITOR
	1895
	1896	if ( (*ppCtx)->pMemAlign != NULL )
	1897	{
	1898	WelsLog( NULL, WELS_LOG_INFO, "FreeMemorySvc(), verify memory usage (%d bytes) after free..\n", (*ppCtx)->pMemAlign->WelsGetMemoryUsage() );
	1899	delete (*ppCtx)->pMemAlign;
	1900	(*ppCtx)->pMemAlign = NULL;
	1901	}
	1902
	1903	free(*ppCtx);
	1904	*ppCtx = NULL;
	1905	}
	1906	}
	1907
	1908	int32_t InitSliceSettings( SWelsSvcCodingParam pCodingParam, const int32_t kiCpuCores, int16_t pMaxSliceCount )
	1909	{
	1910	int32_t iSpatialIdx = 0, iSpatialNum = pCodingParam->iNumDependencyLayer;
	1911	int16_t iMaxSliceCount = 0;
	1912
	1913	do {
	1914	SDLayerParam *pDlp = &pCodingParam->sDependencyLayers[iSpatialIdx];
	1915	SMulSliceOption *pMso = &pDlp->sMso;
	1916	SSliceArgument *pSlcArg = &pMso->sSliceArgument;
	1917	const int32_t kiMbWidth = (pDlp->iFrameWidth+15)>>4;
	1918	const int32_t kiMbHeight = (pDlp->iFrameHeight+15)>>4;
	1919	const int32_t kiMbNumInFrame = kiMbWidth * kiMbHeight;
	1920	#if defined(MT_ENABLED)
	1921	#if defined(DYNAMIC_SLICE_ASSIGN)
	1922	int32_t iSliceNum = (SM_FIXEDSLCNUM_SLICE == pMso->uiSliceMode \|\| SM_DYN_SLICE == pMso->uiSliceMode) ? kiCpuCores : pSlcArg->iSliceNum; // uiSliceNum per input has been validated at ParamValidationExt()
	1923	#else//!DYNAMIC_SLICE_ASSIGN
	1924	int32_t iSliceNum = (SM_DYN_SLICE == pMso->uiSliceMode) ? kiCpuCores : pSlcArg->uiSliceNum; // uiSliceNum per input has been validated at ParamValidationExt()
	1925	#endif//DYNAMIC_SLICE_ASSIGN
	1926	#else//!MT_ENABLED
	1927	int16_t iSliceNum = pSlcArg->iSliceNum; // uiSliceNum per input has been validated at ParamValidationExt()
	1928	#endif//MT_ENABLED
	1929
	1930	// NOTE: Per design, in case MT/DYNAMIC_SLICE_ASSIGN enabled, for SM_FIXEDSLCNUM_SLICE mode,
	1931	// uiSliceNum of current spatial layer settings equals to uiCpuCores number; SM_DYN_SLICE mode,
	1932	// uiSliceNum intials as uiCpuCores also, stay tuned dynamically slicing in future
	1933	pSlcArg->iSliceNum = iSliceNum; // used fixed one
	1934
	1935	switch(pMso->uiSliceMode)
	1936	{
	1937	case SM_DYN_SLICE:
	1938	iMaxSliceCount = AVERSLICENUM_CONSTRAINT;
	1939	//#ifndef MT_ENABLED
	1940	break; // go through for MT_ENABLED & SM_DYN_SLICE?
	1941	//#endif//MT_ENABLED
	1942	case SM_FIXEDSLCNUM_SLICE:
	1943	if ( iSliceNum > iMaxSliceCount )
	1944	iMaxSliceCount = iSliceNum;
	1945	// need perform check due uiSliceNum might change, although has been initialized somewhere outside
	1946	if (pCodingParam->bEnableRc)
	1947	{
	1948	GomValidCheckSliceMbNum( kiMbWidth, kiMbHeight, pSlcArg );
	1949	}
	1950	else
	1951	{
	1952	CheckFixedSliceNumMultiSliceSetting( kiMbNumInFrame, pSlcArg );
	1953	}
	1954	break;
	1955	case SM_SINGLE_SLICE:
	1956	if ( iSliceNum > iMaxSliceCount )
	1957	iMaxSliceCount = iSliceNum;
	1958	break;
	1959	case SM_RASTER_SLICE:
	1960	if ( iSliceNum > iMaxSliceCount )
	1961	iMaxSliceCount = iSliceNum;
	1962	break;
	1963	case SM_ROWMB_SLICE:
	1964	if ( iSliceNum > iMaxSliceCount )
	1965	iMaxSliceCount = iSliceNum;
	1966	break;
	1967	default:
	1968	break;
	1969	}
	1970
	1971	++ iSpatialIdx;
	1972	} while(iSpatialIdx < iSpatialNum);
	1973
	1974	#ifdef MT_ENABLED
	1975	pCodingParam->iCountThreadsNum = WELS_MIN(kiCpuCores, iMaxSliceCount);
	1976	pCodingParam->iMultipleThreadIdc = pCodingParam->iCountThreadsNum;
	1977	#else
	1978	pCodingParam->iMultipleThreadIdc = 1;
	1979	pCodingParam->iCountThreadsNum = 1;
	1980	#endif//MT_ENABLED
	1981
	1982	#ifndef WELS_TESTBED // for product release and non-SGE testing
	1983
	1984	if ( kiCpuCores < 2 ) // single CPU core, make no sense for MT parallelization
	1985	{
	1986	pCodingParam->iMultipleThreadIdc = 1;
	1987	pCodingParam->iCountThreadsNum = 1;
	1988	}
	1989	#endif
	1990
	1991	*pMaxSliceCount = iMaxSliceCount;
	1992
	1993	return 0;
	1994	}
	1995
	1996	/*!
	1997	* \brief log output for cpu features/capabilities
	1998	*/
	1999	void OutputCpuFeaturesLog( uint32_t uiCpuFeatureFlags, uint32_t uiCpuCores, int32_t iCacheLineSize )
	2000	{
	2001	// welstracer output
	2002	WelsLog(NULL, WELS_LOG_INFO, "WELS CPU features/capacities (0x%x) detected: \t" \
	2003	"HTT: %c, " \
	2004	"MMX: %c, " \
	2005	"MMXEX: %c, " \
	2006	"SSE: %c, " \
	2007	"SSE2: %c, " \
	2008	"SSE3: %c, " \
	2009	"SSSE3: %c, " \
	2010	"SSE4.1: %c, " \
	2011	"SSE4.2: %c, " \
	2012	"AVX: %c, " \
	2013	"FMA: %c, " \
	2014	"X87-FPU: %c, " \
	2015	"3DNOW: %c, " \
	2016	"3DNOWEX: %c, " \
	2017	"ALTIVEC: %c, " \
	2018	"CMOV: %c, " \
	2019	"MOVBE: %c, " \
	2020	"AES: %c, " \
	2021	"NUMBER OF LOGIC PROCESSORS ON CHIP: %d, " \
	2022	"CPU CACHE LINE SIZE (BYTES): %d\n",
	2023	uiCpuFeatureFlags,
	2024	(uiCpuFeatureFlags & WELS_CPU_HTT) ? 'Y' : 'N',
	2025	(uiCpuFeatureFlags & WELS_CPU_MMX) ? 'Y' : 'N',
	2026	(uiCpuFeatureFlags & WELS_CPU_MMXEXT) ? 'Y' : 'N',
	2027	(uiCpuFeatureFlags & WELS_CPU_SSE) ? 'Y' : 'N',
	2028	(uiCpuFeatureFlags & WELS_CPU_SSE2) ? 'Y' : 'N',
	2029	(uiCpuFeatureFlags & WELS_CPU_SSE3) ? 'Y' : 'N',
	2030	(uiCpuFeatureFlags & WELS_CPU_SSSE3) ? 'Y' : 'N',
	2031	(uiCpuFeatureFlags & WELS_CPU_SSE41) ? 'Y' : 'N',
	2032	(uiCpuFeatureFlags & WELS_CPU_SSE42) ? 'Y' : 'N',
	2033	(uiCpuFeatureFlags & WELS_CPU_AVX) ? 'Y' : 'N',
	2034	(uiCpuFeatureFlags & WELS_CPU_FMA) ? 'Y' : 'N',
	2035	(uiCpuFeatureFlags & WELS_CPU_FPU) ? 'Y' : 'N',
	2036	(uiCpuFeatureFlags & WELS_CPU_3DNOW) ? 'Y' : 'N',
	2037	(uiCpuFeatureFlags & WELS_CPU_3DNOWEXT) ? 'Y' : 'N',
	2038	(uiCpuFeatureFlags & WELS_CPU_ALTIVEC) ? 'Y' : 'N',
	2039	(uiCpuFeatureFlags & WELS_CPU_CMOV) ? 'Y' : 'N',
	2040	(uiCpuFeatureFlags & WELS_CPU_MOVBE) ? 'Y' : 'N',
	2041	(uiCpuFeatureFlags & WELS_CPU_AES) ? 'Y' : 'N',
	2042	uiCpuCores,
	2043	iCacheLineSize );
	2044
	2045	#ifdef _DEBUG // output at console & _debug
	2046	fprintf( stderr, "WELS CPU features/capacities (0x%x) detected: \n" \
	2047	"HTT: %c, " \
	2048	"MMX: %c, " \
	2049	"MMXEX: %c, " \
	2050	"SSE: %c, " \
	2051	"SSE2: %c, " \
	2052	"SSE3: %c, " \
	2053	"SSSE3: %c, " \
	2054	"SSE4.1: %c, " \
	2055	"SSE4.2: %c, " \
	2056	"AVX: %c, " \
	2057	"FMA: %c, " \
	2058	"X87-FPU: %c, " \
	2059	"3DNOW: %c, " \
	2060	"3DNOWEX: %c, " \
	2061	"ALTIVEC: %c, " \
	2062	"CMOV: %c, " \
	2063	"MOVBE: %c, " \
	2064	"AES: %c, " \
	2065	"NUMBER OF LOGIC PROCESSORS ON CHIP: %d, " \
	2066	"CPU CACHE LINE SIZE (BYTES): %d\n",
	2067	uiCpuFeatureFlags,
	2068	(uiCpuFeatureFlags & WELS_CPU_HTT) ? 'Y' : 'N',
	2069	(uiCpuFeatureFlags & WELS_CPU_MMX) ? 'Y' : 'N',
	2070	(uiCpuFeatureFlags & WELS_CPU_MMXEXT) ? 'Y' : 'N',
	2071	(uiCpuFeatureFlags & WELS_CPU_SSE) ? 'Y' : 'N',
	2072	(uiCpuFeatureFlags & WELS_CPU_SSE2) ? 'Y' : 'N',
	2073	(uiCpuFeatureFlags & WELS_CPU_SSE3) ? 'Y' : 'N',
	2074	(uiCpuFeatureFlags & WELS_CPU_SSSE3) ? 'Y' : 'N',
	2075	(uiCpuFeatureFlags & WELS_CPU_SSE41) ? 'Y' : 'N',
	2076	(uiCpuFeatureFlags & WELS_CPU_SSE42) ? 'Y' : 'N',
	2077	(uiCpuFeatureFlags & WELS_CPU_AVX) ? 'Y' : 'N',
	2078	(uiCpuFeatureFlags & WELS_CPU_FMA) ? 'Y' : 'N',
	2079	(uiCpuFeatureFlags & WELS_CPU_FPU) ? 'Y' : 'N',
	2080	(uiCpuFeatureFlags & WELS_CPU_3DNOW) ? 'Y' : 'N',
	2081	(uiCpuFeatureFlags & WELS_CPU_3DNOWEXT) ? 'Y' : 'N',
	2082	(uiCpuFeatureFlags & WELS_CPU_ALTIVEC) ? 'Y' : 'N',
	2083	(uiCpuFeatureFlags & WELS_CPU_CMOV) ? 'Y' : 'N',
	2084	(uiCpuFeatureFlags & WELS_CPU_MOVBE) ? 'Y' : 'N',
	2085	(uiCpuFeatureFlags & WELS_CPU_AES) ? 'Y' : 'N',
	2086	uiCpuCores,
	2087	iCacheLineSize );
	2088	#endif//_DEBUG
	2089	}
	2090
	2091	/*!
	2092	* \brief initialize Wels avc encoder core library
	2093	* \pParam ppCtx sWelsEncCtx**
	2094	* \pParam pParam SWelsSvcCodingParam*
	2095	* \return successful - 0; otherwise none 0 for failed
	2096	*/
	2097	int32_t WelsInitEncoderExt( sWelsEncCtx *ppCtx, SWelsSvcCodingParam pCodingParam )
	2098	{
	2099	sWelsEncCtx *pCtx = NULL;
	2100	int32_t iRet = 0;
	2101	uint32_t uiCpuFeatureFlags = 0; // CPU features
	2102	int32_t uiCpuCores = 1; // number of logic processors on physical processor package, one logic processor means HTT not supported
	2103	int32_t iCacheLineSize = 16; // on chip cache line size in byte
	2104	int16_t iSliceNum = 1; // number of slices used
	2105
	2106	if ( NULL == ppCtx \|\| NULL == pCodingParam )
	2107	{
	2108	WelsLog(NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), NULL == ppCtx(0x%p) or NULL == pCodingParam(0x%p).\n", (void )ppCtx, (void )pCodingParam);
	2109	return 1;
	2110	}
	2111
	2112	iRet = ParamValidationExt( pCodingParam );
	2113	if ( iRet != 0 )
	2114	{
	2115	WelsLog(NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), ParamValidationExt failed return %d.\n", iRet);
	2116	return iRet;
	2117	}
	2118
	2119	// for cpu features detection, Only detect once??
	2120	#ifdef X86_ASM
	2121	uiCpuFeatureFlags = WelsCPUFeatureDetect( &uiCpuCores ); // detect cpu capacity features
	2122	if ( uiCpuFeatureFlags & WELS_CPU_CACHELINE_128 )
	2123	iCacheLineSize = 128;
	2124	else if ( uiCpuFeatureFlags & WELS_CPU_CACHELINE_64 )
	2125	iCacheLineSize = 64;
	2126	else if ( uiCpuFeatureFlags & WELS_CPU_CACHELINE_32 )
	2127	iCacheLineSize = 32;
	2128	else if ( uiCpuFeatureFlags & WELS_CPU_CACHELINE_16 )
	2129	iCacheLineSize = 16;
	2130	OutputCpuFeaturesLog( uiCpuFeatureFlags, uiCpuCores, iCacheLineSize );
	2131	#else
	2132	iCacheLineSize = 16; // 16 bytes aligned in default
	2133	#endif//X86_ASM
	2134
	2135	#ifndef WELS_TESTBED
	2136
	2137	#if defined(MT_ENABLED) && defined(DYNAMIC_DETECT_CPU_CORES)
	2138	if ( pCodingParam->iMultipleThreadIdc > 0 )
	2139	uiCpuCores = pCodingParam->iMultipleThreadIdc;
	2140	else
	2141	{
	2142	if ( uiCpuFeatureFlags == 0 ) // cpuid not supported, use high level system API as followed to detect number of pysical/logic processor
	2143	uiCpuCores = DynamicDetectCpuCores();
	2144	// So far so many cpu cores up to MAX_THREADS_NUM mean for server platforms,
	2145	// for client application here it is constrained by maximal to MAX_THREADS_NUM
	2146	if ( uiCpuCores > MAX_THREADS_NUM ) // MAX_THREADS_NUM
	2147	uiCpuCores = MAX_THREADS_NUM; // MAX_THREADS_NUM
	2148	else if ( uiCpuCores < 1 ) // just for safe
	2149	uiCpuCores = 1;
	2150	}
	2151	#endif//MT_ENABLED && DYNAMIC_DETECT_CPU_CORES
	2152
	2153	#else//WELS_TESTBED
	2154
	2155	uiCpuCores = pCodingParam->iMultipleThreadIdc; // assigned uiCpuCores from iMultipleThreadIdc from SGE testing
	2156
	2157	#endif//WELS_TESTBED
	2158
	2159	uiCpuCores = WELS_CLIP3(uiCpuCores, 1, MAX_THREADS_NUM);
	2160
	2161	if ( InitSliceSettings(pCodingParam, uiCpuCores, &iSliceNum ) )
	2162	{
	2163	WelsLog(NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), InitSliceSettings failed.\n");
	2164	return 1;
	2165	}
	2166
	2167	*ppCtx = NULL;
	2168
	2169	pCtx = static_cast<sWelsEncCtx*>(malloc( sizeof(sWelsEncCtx) ));
	2170
	2171	WELS_VERIFY_RETURN_IF(1, (NULL == pCtx))
	2172	memset( pCtx, 0, sizeof(sWelsEncCtx) );
	2173
	2174	pCtx->pMemAlign = new CMemoryAlign( iCacheLineSize );
	2175	WELS_VERIFY_RETURN_PROC_IF( 1, (NULL == pCtx->pMemAlign), FreeMemorySvc(&pCtx) )
	2176
	2177	// for logs
	2178	#ifdef ENABLE_TRACE_FILE
	2179	if (wlog == WelsLogDefault)
	2180	{
	2181	str_t fname[MAX_FNAME_LEN] = {0};
	2182
	2183	#if defined (_MSC_VER)
	2184	#if _MSC_VER>=1500
	2185	SNPRINTF(fname, MAX_FNAME_LEN, MAX_FNAME_LEN, "%swels_svc_encoder_trace.txt", pCodingParam->sTracePath ); // confirmed_safe_unsafe_usage
	2186	#else
	2187	SNPRINTF(fname, MAX_FNAME_LEN, "%swels_svc_encoder_trace.txt", pCodingParam->sTracePath ); // confirmed_safe_unsafe_usage
	2188	#endif//_MSC_VER>=1500
	2189	#else
	2190	//GNUC/
	2191	SNPRINTF(fname, MAX_FNAME_LEN, "%swels_svc_encoder_trace.txt", pCodingParam->sTracePath ); // confirmed_safe_unsafe_usage
	2192	#endif//_MSC_VER
	2193
	2194
	2195	#if defined(__GNUC__)
	2196	pCtx->pFileLog = FOPEN(fname, "wt+");
	2197	#else//WIN32
	2198	#if defined(WIN32) && defined(_MSC_VER)
	2199	#if _MSC_VER >= 1500
	2200	FOPEN(&pCtx->pFileLog,fname, "wt+");
	2201	#else
	2202	pCtx->pFileLog = FOPEN(fname, "wt+");
	2203	#endif//_MSC_VER>=1500
	2204	#endif//WIN32 && _MSC_VER
	2205	#endif//__GNUC__
	2206	pCtx->uiSizeLog = 0;
	2207	}
	2208	#endif//ENABLE_TRACE_FILE
	2209
	2210	pCodingParam->DetermineTemporalSettings();
	2211	iRet = AllocCodingParam( &pCtx->pSvcParam, pCtx->pMemAlign, pCodingParam->iNumDependencyLayer );
	2212	if ( iRet != 0 )
	2213	{
	2214	FreeMemorySvc( &pCtx );
	2215	return iRet;
	2216	}
	2217	memcpy( pCtx->pSvcParam, pCodingParam, sizeof(SWelsSvcCodingParam) ); // confirmed_safe_unsafe_usage
	2218
	2219	pCtx->pFuncList = (SWelsFuncPtrList *)pCtx->pMemAlign->WelsMalloc(sizeof(SWelsFuncPtrList), "SWelsFuncPtrList");
	2220	if ( NULL == pCtx->pFuncList )
	2221	{
	2222	FreeMemorySvc( &pCtx );
	2223	return 1;
	2224	}
	2225	InitFunctionPointers( pCtx->pFuncList, pCtx->pSvcParam, uiCpuFeatureFlags );
	2226
	2227	pCtx->iActiveThreadsNum = pCodingParam->iCountThreadsNum;
	2228	pCtx->iMaxSliceCount = iSliceNum;
	2229	iRet = RequestMemorySvc( &pCtx );
	2230	if ( iRet != 0 )
	2231	{
	2232	WelsLog(pCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), RequestMemorySvc failed return %d.\n", iRet);
	2233	FreeMemorySvc( &pCtx );
	2234	return iRet;
	2235	}
	2236
	2237	#ifdef MT_ENABLED
	2238	if ( pCodingParam->iMultipleThreadIdc > 1 )
	2239	iRet = CreateSliceThreads( pCtx);
	2240	#endif
	2241
	2242	WelsRcInitModule( pCtx, pCtx->pSvcParam->bEnableRc ? WELS_RC_GOM : WELS_RC_DISABLE);
	2243
	2244	pCtx->pVpp = new CWelsPreProcess((void *)pCtx);
	2245	if ( pCtx->pVpp == NULL )
	2246	{
	2247	WelsLog(pCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pOut of memory in case new CWelsPreProcess().\n");
	2248	FreeMemorySvc( &pCtx );
	2249	return iRet;
	2250	}
	2251
	2252	#if defined(MEMORY_MONITOR)
	2253	WelsLog(pCtx, WELS_LOG_INFO, "WelsInitEncoderExt() exit, overall memory usage: %lu bytes\n", sizeof(sWelsEncCtx) /* requested size from malloc() or new operator */
	2254	+ pCtx->pMemAlign->WelsGetMemoryUsage() /* requested size from CMemoryAlign::WelsMalloc() */
	2255	);
	2256	#endif//MEMORY_MONITOR
	2257
	2258	*ppCtx = pCtx;
	2259
	2260	WelsLog(pCtx, WELS_LOG_DEBUG, "WelsInitEncoderExt(), pCtx= 0x%p.\n", (void *)pCtx);
	2261
	2262	return 0;
	2263	}
	2264	/*
	2265	*
	2266	* status information output
	2267	*/
	2268	#if defined(STAT_OUTPUT)
	2269	void StatOverallEncodingExt(sWelsEncCtx *pCtx)
	2270	{
	2271	int8_t i = 0;
	2272	int8_t j = 0;
	2273	for (i = 0;i<pCtx->pSvcParam->iNumDependencyLayer;i++)
	2274	{
	2275	fprintf( stdout,"\nDependency layer : %d\n",i);
	2276	fprintf( stdout,"Quality layer : %d\n",j);
	2277	{
	2278	const int32_t iCount = pCtx->sStatData[i][j].sSliceData.iSliceCount[I_SLICE] +
	2279	pCtx->sStatData[i][j].sSliceData.iSliceCount[P_SLICE] +
	2280	pCtx->sStatData[i][j].sSliceData.iSliceCount[B_SLICE];
	2281	#if defined(MB_TYPES_CHECK)
	2282	if (iCount > 0){
	2283	int32_t iCountNumIMb = pCtx->sStatData[i][j].sSliceData.iMbCount[I_SLICE][Intra4x4] + pCtx->sStatData[i][j].sSliceData.iMbCount[I_SLICE][Intra16x16]+ pCtx->sStatData[i][j].sSliceData.iMbCount[I_SLICE][7];
	2284	int32_t iCountNumPMb = pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Intra4x4] +
	2285	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Intra16x16] +
	2286	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][7] +
	2287	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter16x16] +
	2288	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter16x8] +
	2289	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter8x16] +
	2290	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter8x8] +
	2291	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][10] +
	2292	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][PSkip];
	2293	int32_t count_p_mbL0 = pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter16x16] +
	2294	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter16x8] +
	2295	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter8x16] +
	2296	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter8x8] +
	2297	pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][10];
	2298
	2299	int32_t iMbCount = iCountNumIMb + iCountNumPMb;
	2300	if ( iMbCount > 0 ){
	2301	fprintf( stderr,
	2302	"SVC: overall Slices MBs: %d Avg\nI4x4: %.3f%% I16x16: %.3f%% IBL: %.3f%%\nP16x16: %.3f%% P16x8: %.3f%% P8x16: %.3f%% P8x8: %.3f%% SUBP8x8: %.3f%% PSKIP: %.3f%%\nILP(All): %.3f%% ILP(PL0): %.3f%% BLSKIP(PL0): %.3f%% RP(PL0): %.3f%%\n",
	2303	iMbCount,
	2304	(100.0f * (pCtx->sStatData[i][j].sSliceData.iMbCount[I_SLICE][Intra4x4] + pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Intra4x4]) / iMbCount),
	2305	(100.0f * (pCtx->sStatData[i][j].sSliceData.iMbCount[I_SLICE][Intra16x16] + pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Intra16x16]) / iMbCount),
	2306	(100.0f * (pCtx->sStatData[i][j].sSliceData.iMbCount[I_SLICE][7] + pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][7]) / iMbCount),
	2307	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter16x16] / iMbCount ),
	2308	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter16x8] / iMbCount ),
	2309	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter8x16] / iMbCount ),
	2310	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][Inter8x8] / iMbCount),
	2311	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][10] / iMbCount),
	2312	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][PSkip] / iMbCount),
	2313	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][11] / iMbCount),
	2314	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][11] / count_p_mbL0),
	2315	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][8] / count_p_mbL0),
	2316	(100.0f * pCtx->sStatData[i][j].sSliceData.iMbCount[P_SLICE][9] / count_p_mbL0)
	2317	);
	2318	}
	2319	}
	2320	#endif //#if defined(MB_TYPES_CHECK)
	2321
	2322	if (iCount > 0){
	2323	fprintf( stdout, "SVC: overall PSNR Y: %2.3f U: %2.3f V: %2.3f kb/s: %.1f fps: %.3f\n\n",
	2324	(pCtx->sStatData[i][j].sQualityStat.rYPsnr[I_SLICE]+pCtx->sStatData[i][j].sQualityStat.rYPsnr[P_SLICE]+pCtx->sStatData[i][j].sQualityStat.rYPsnr[B_SLICE]) / (float)(iCount),
	2325	(pCtx->sStatData[i][j].sQualityStat.rUPsnr[I_SLICE]+pCtx->sStatData[i][j].sQualityStat.rUPsnr[P_SLICE]+pCtx->sStatData[i][j].sQualityStat.rUPsnr[B_SLICE]) / (float)(iCount),
	2326	(pCtx->sStatData[i][j].sQualityStat.rVPsnr[I_SLICE]+pCtx->sStatData[i][j].sQualityStat.rVPsnr[P_SLICE]+pCtx->sStatData[i][j].sQualityStat.rVPsnr[B_SLICE]) / (float)(iCount),
	2327	1.0f * pCtx->pSvcParam->sDependencyLayers[i].fOutputFrameRate *(pCtx->sStatData[i][j].sSliceData.iSliceSize[I_SLICE] +pCtx->sStatData[i][j].sSliceData.iSliceSize[P_SLICE] +pCtx->sStatData[i][j].sSliceData.iSliceSize[B_SLICE] ) / (float)(iCount+pCtx->pWelsSvcRc[i].iSkipFrameNum)/1000,
	2328	1.0f * pCtx->pSvcParam->sDependencyLayers[i].fOutputFrameRate );
	2329
	2330	}
	2331
	2332	}
	2333
	2334	}
	2335	}
	2336	#endif
	2337	/*!
	2338	* \brief uninitialize Wels encoder core library
	2339	* \pParam pEncCtx sWelsEncCtx*
	2340	* \return none
	2341	*/
	2342	void WelsUninitEncoderExt( sWelsEncCtx **ppCtx )
	2343	{
	2344	if ( NULL == ppCtx \|\| NULL == *ppCtx )
	2345	return;
	2346
	2347	WelsLog( ppCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), pCtx= %p, iThreadCount= %d, iMultipleThreadIdc= %d.\n", (void )(ppCtx), (ppCtx)->pSvcParam->iCountThreadsNum, (*ppCtx)->pSvcParam->iMultipleThreadIdc );
	2348
	2349	#if defined(STAT_OUTPUT)
	2350	StatOverallEncodingExt( *ppCtx );
	2351	#endif
	2352
	2353	#if defined(MT_ENABLED)
	2354	if ( (ppCtx)->pSvcParam->iMultipleThreadIdc > 1 && (ppCtx)->pSliceThreading != NULL )
	2355	{
	2356	const int32_t iThreadCount = (*ppCtx)->pSvcParam->iCountThreadsNum;
	2357	int32_t iThreadIdx = 0;
	2358
	2359	#if defined(WIN32)
	2360	if ( (*ppCtx)->pSliceThreading->pExitEncodeEvent != NULL )
	2361	{
	2362	do {
	2363	if ( (*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] != NULL ) // iThreadIdx is already created successfully
	2364	WelsEventSignal( &(*ppCtx)->pSliceThreading->pExitEncodeEvent[iThreadIdx] );
	2365	++ iThreadIdx;
	2366	} while(iThreadIdx < iThreadCount);
	2367
	2368	WelsMultipleEventsWaitAllBlocking( iThreadCount, &(*ppCtx)->pSliceThreading->pFinSliceCodingEvent[0] );
	2369
	2370	}
	2371	#elif defined(__GNUC__)
	2372	while ( iThreadIdx < iThreadCount )
	2373	{
	2374	int res = 0;
	2375	if ( (*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] )
	2376	{
	2377	res = WelsThreadCancel( (*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] );
	2378	WelsLog( *ppCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), WelsThreadCancel(pThreadHandles%d) return %d..\n", iThreadIdx, res);
	2379	res = WelsThreadJoin( (*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] ); // waiting thread exit
	2380	WelsLog( *ppCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), pthread_join(pThreadHandles%d) return %d..\n", iThreadIdx, res);
	2381	(*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] = 0;
	2382	}
	2383	#if defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)
	2384	if ( (*ppCtx)->pSliceThreading->pUpdateMbListThrdHandles[iThreadIdx] )
	2385	{
	2386	res = WelsThreadCancel( (*ppCtx)->pSliceThreading->pUpdateMbListThrdHandles[iThreadIdx] );
	2387	WelsLog( *ppCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), WelsThreadCancel(pUpdateMbListThrdHandles%d) return %d..\n", iThreadIdx, res);
	2388	res = WelsThreadJoin( (*ppCtx)->pSliceThreading->pUpdateMbListThrdHandles[iThreadIdx] ); // waiting thread exit
	2389	WelsLog( *ppCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), pthread_join(pUpdateMbListThrdHandles%d) return %d..\n", iThreadIdx, res);
	2390	(*ppCtx)->pSliceThreading->pUpdateMbListThrdHandles[iThreadIdx] = 0;
	2391	}
	2392	#endif//DYNAMIC_SLICE_ASSIGN && TRY_SLICING_BALANCE
	2393	++ iThreadIdx;
	2394	}
	2395	#endif//WIN32
	2396	}
	2397	#endif//MT_ENABLED
	2398
	2399	if ((*ppCtx)->pVpp)
	2400	{
	2401	delete (*ppCtx)->pVpp;
	2402	(*ppCtx)->pVpp = NULL;
	2403	}
	2404	FreeMemorySvc( ppCtx );
	2405	*ppCtx = NULL;
	2406	}
	2407
	2408	/*!
	2409	* \brief get temporal level due to configuration and coding context
	2410	*/
	2411	static inline int32_t GetTemporalLevel( SDLayerParam *fDlp, const int32_t kiFrameNum, const int32_t kiGopSize )
	2412	{
	2413	const int32_t kiCodingIdx = kiFrameNum & (kiGopSize-1);
	2414
	2415	return fDlp->uiCodingIdx2TemporalId[kiCodingIdx];
	2416	}
	2417
	2418	void DynslcUpdateMbNeighbourInfoListForAllSlices( SSliceCtx pSliceCtx, SMB pMbList )
	2419	{
	2420	const int32_t kiMbWidth = pSliceCtx->iMbWidth;
	2421	const int32_t kiEndMbInSlice = pSliceCtx->iMbNumInFrame - 1;
	2422	int32_t iIdx = 0;
	2423
	2424	do {
	2425	SMB *pMb = &pMbList[iIdx];
	2426	uint32_t uiNeighborAvailFlag = 0;
	2427	const int32_t kiMbXY = pMb->iMbXY;
	2428	const int32_t kiMbX = pMb->iMbX;
	2429	const int32_t kiMbY = pMb->iMbY;
	2430	BOOL_T bLeft;
	2431	BOOL_T bTop;
	2432	BOOL_T bLeftTop;
	2433	BOOL_T bRightTop;
	2434	int32_t uiSliceIdc;
	2435	int32_t iLeftXY, iTopXY, iLeftTopXY, iRightTopXY;
	2436
	2437	uiSliceIdc = WelsMbToSliceIdc(pSliceCtx, kiMbXY);
	2438	pMb->uiSliceIdc = uiSliceIdc;
	2439	iLeftXY = kiMbXY - 1;
	2440	iTopXY = kiMbXY - kiMbWidth;
	2441	iLeftTopXY = iTopXY - 1;
	2442	iRightTopXY = iTopXY + 1;
	2443
	2444	bLeft = (kiMbX > 0) && (uiSliceIdc == WelsMbToSliceIdc(pSliceCtx, iLeftXY));
	2445	bTop = (kiMbY > 0) && (uiSliceIdc == WelsMbToSliceIdc(pSliceCtx, iTopXY));
	2446	bLeftTop = (kiMbX > 0) && (kiMbY > 0) && (uiSliceIdc == WelsMbToSliceIdc(pSliceCtx, iLeftTopXY));
	2447	bRightTop = (kiMbX < (kiMbWidth-1)) && (kiMbY > 0) && (uiSliceIdc == WelsMbToSliceIdc(pSliceCtx, iRightTopXY));
	2448
	2449	if( bLeft ){
	2450	uiNeighborAvailFlag \|= LEFT_MB_POS;
	2451	}
	2452	if( bTop ){
	2453	uiNeighborAvailFlag \|= TOP_MB_POS;
	2454	}
	2455	if( bLeftTop ){
	2456	uiNeighborAvailFlag \|= TOPLEFT_MB_POS;
	2457	}
	2458	if( bRightTop ){
	2459	uiNeighborAvailFlag \|= TOPRIGHT_MB_POS;
	2460	}
	2461	pMb->uiNeighborAvail = (uint8_t)uiNeighborAvailFlag;
	2462
	2463	++ iIdx;
	2464	} while(iIdx <= kiEndMbInSlice);
	2465	}
	2466
	2467	/*
	2468	* TUNE back if number of picture partition decision algorithm based on past if available
	2469	*/
	2470	int32_t PicPartitionNumDecision( sWelsEncCtx *pCtx )
	2471	{
	2472	int32_t iPartitionNum = 1;
	2473	#ifdef MT_ENABLED
	2474	if ( pCtx->pSvcParam->iMultipleThreadIdc > 1 )
	2475	{
	2476	iPartitionNum = pCtx->pSvcParam->iCountThreadsNum;
	2477	#if !defined(FIXED_PARTITION_ASSIGN)
	2478	if ( P_SLICE == pCtx->eSliceType )
	2479	iPartitionNum = 1;
	2480	#endif//!FIXED_PARTITION_ASSIGN
	2481	}
	2482	return iPartitionNum;
	2483	#else
	2484	return iPartitionNum;
	2485	#endif//MT_ENABLED
	2486	}
	2487
	2488	#if defined(MT_ENABLED)
	2489	void WelsInitCurrentQBLayerMltslc( sWelsEncCtx *pCtx )
	2490	{
	2491	//pData init
	2492	SDqLayer* pCurDq = pCtx->pCurDqLayer;
	2493	SSliceCtx* pSliceCtx = (pCurDq->pSliceEncCtx);
	2494
	2495	//mb_neighbor
	2496	DynslcUpdateMbNeighbourInfoListForAllSlices( pSliceCtx, pCurDq->sMbDataP );
	2497	}
	2498
	2499	void UpdateSlicepEncCtxWithPartition( SSliceCtx *pSliceCtx, int32_t iPartitionNum )
	2500	{
	2501	const int32_t kiMbNumInFrame = pSliceCtx->iMbNumInFrame;
	2502	int32_t iCountMbNumPerPartition = kiMbNumInFrame;
	2503	int32_t iAssignableMbLeft = kiMbNumInFrame;
	2504	int32_t iFirstMbIdx = 0;
	2505	int32_t i/, j/;
	2506
	2507	if ( iPartitionNum <= 0 )
	2508	iPartitionNum = 1;
	2509	else if ( iPartitionNum > AVERSLICENUM_CONSTRAINT )
	2510	iPartitionNum = AVERSLICENUM_CONSTRAINT; // AVERSLICENUM_CONSTRAINT might be variable, however not fixed by MACRO
	2511	iCountMbNumPerPartition /= iPartitionNum;
	2512	pSliceCtx->iSliceNumInFrame = iPartitionNum;
	2513	i = 0;
	2514	while( i < iPartitionNum )
	2515	{
	2516	if ( i + 1 == iPartitionNum )
	2517	{
	2518	pSliceCtx->pCountMbNumInSlice[i] = iAssignableMbLeft;
	2519	}
	2520	else
	2521	{
	2522	pSliceCtx->pCountMbNumInSlice[i] = iCountMbNumPerPartition;
	2523	}
	2524	pSliceCtx->pFirstMbInSlice[i] = iFirstMbIdx;
	2525
	2526	memset( pSliceCtx->pOverallMbMap+iFirstMbIdx, (uint8_t)i, pSliceCtx->pCountMbNumInSlice[i]*sizeof(uint8_t) );
	2527
	2528	// for next partition(or pSlice)
	2529	iFirstMbIdx += pSliceCtx->pCountMbNumInSlice[i];
	2530	iAssignableMbLeft -= pSliceCtx->pCountMbNumInSlice[i];
	2531	++ i;
	2532	}
	2533	}
	2534
	2535	void WelsInitCurrentDlayerMltslc( sWelsEncCtx *pCtx, int32_t iPartitionNum )
	2536	{
	2537	SDqLayer* pCurDq = pCtx->pCurDqLayer;
	2538	SSliceCtx* pSliceCtx = pCurDq->pSliceEncCtx;
	2539
	2540	UpdateSlicepEncCtxWithPartition( pSliceCtx, iPartitionNum );
	2541
	2542	if ( I_SLICE == pCtx->eSliceType )//check if uiSliceSizeConstraint too small
	2543	{
	2544	#define byte_complexIMBat26 (60)
	2545	uint8_t iCurDid = pCtx->uiDependencyId;
	2546	uint32_t uiFrmByte = 0;
	2547
	2548	if ( pCtx->pSvcParam->bEnableRc )
	2549	{//RC case
	2550	uiFrmByte = (
	2551	( (uint32_t)(pCtx->pSvcParam->sDependencyLayers[iCurDid].iSpatialBitrate)
	2552	/(uint32_t)(pCtx->pSvcParam->sDependencyLayers[iCurDid].fInputFrameRate) ) >> 3 );
	2553	}
	2554	else
	2555	{//fixed QP case
	2556	const int32_t iTtlMbNumInFrame = pSliceCtx->iMbNumInFrame;
	2557	int32_t iQDeltaTo26 = ( 26 - pCtx->pSvcParam->sDependencyLayers[iCurDid].iDLayerQp );
	2558
	2559	uiFrmByte = (iTtlMbNumInFrame * byte_complexIMBat26);
	2560	if ( iQDeltaTo26 > 0 )
	2561	{
	2562	//smaller QP than 26
	2563	uiFrmByte = (uint32_t)( uiFrmByte * ( (float)iQDeltaTo26 / 4 ) );
	2564	}
	2565	else if ( iQDeltaTo26 < 0 )
	2566	{
	2567	//larger QP than 26
	2568	iQDeltaTo26 = ( (-iQDeltaTo26) >> 2 ); //delta mod 4
	2569	uiFrmByte = ( uiFrmByte >> (iQDeltaTo26) ); //if delta 4, byte /2
	2570	}
	2571	}
	2572
	2573	//MINPACKETSIZE_CONSTRAINT
	2574	if ( pSliceCtx->uiSliceSizeConstraint
	2575	<
	2576	(uint32_t)( uiFrmByte//suppose 16 byte per mb at average
	2577	/ ( pSliceCtx->iMaxSliceNumConstraint ) )
	2578	)
	2579	{
	2580
	2581	WelsLog( pCtx,
	2582	WELS_LOG_WARNING,
	2583	"Set-SliceConstraint(%d) too small for current resolution (MB# %d) under QP/BR!\n",
	2584	pSliceCtx->uiSliceSizeConstraint,
	2585	pSliceCtx->iMbNumInFrame
	2586	);
	2587	}
	2588	}
	2589
	2590	WelsInitCurrentQBLayerMltslc( pCtx );
	2591	}
	2592	#else
	2593	void WelsInitCurrentQBLayerMltslc( sWelsEncCtx *pCtx )
	2594	{
	2595	//pData init
	2596	SDqLayer* pCurDq = pCtx->pCurDqLayer;
	2597	SSliceCtx* pSliceCtx = (pCurDq->pSliceEncCtx);
	2598	SSlice * pSlice = &pCurDq->sLayerInfo.pSliceInLayer[0];
	2599	int32_t iTtlMbNumInFrame = pSliceCtx->iMbNumInFrame;
	2600
	2601	//pSliceCtx
	2602	memset( pSliceCtx->pOverallMbMap, 0, iTtlMbNumInFrame * sizeof(uint8_t) );
	2603	memset( pSliceCtx->pCountMbNumInSlice, 0, pSliceCtx->iSliceNumInFrame * sizeof(int32_t) );
	2604	memset( pSliceCtx->pFirstMbInSlice, 0, pSliceCtx->iSliceNumInFrame * sizeof(int16_t) );
	2605	pSliceCtx->iSliceNumInFrame = 1;//
	2606	pSliceCtx->pCountMbNumInSlice[0] = iTtlMbNumInFrame;
	2607
	2608	//mb_neighbor
	2609	DynslcUpdateMbNeighbourInfoListForAllSlices( pSliceCtx, pCurDq->sMbDataP );
	2610
	2611	//pSlice init
	2612	pSlice->uiSliceIdx = 0;
	2613	pSlice->pSliceBsa = &pCtx->pOut->sBsWrite;
	2614	pSlice->bDynamicSlicingSliceSizeCtrlFlag = false;
	2615	pSlice->uiAssumeLog2BytePerMb = ( pCtx->eSliceType == P_SLICE ) ? 0 : 1;
	2616	}
	2617
	2618	void WelsInitCurrentDlayerMltslc( sWelsEncCtx *pCtx, int32_t iPartitionNum )
	2619	{
	2620	SDqLayer* pCurDq = pCtx->pCurDqLayer;
	2621	SSliceCtx* pSliceCtx = ( pCurDq->pSliceEncCtx );
	2622	int32_t iTtlMbNumInFrame = pCurDq->iMbHeight*pCurDq->iMbWidth;
	2623
	2624	pSliceCtx->iMbNumInFrame
	2625	= pSliceCtx->pCountMbNumInSlice[0] = iTtlMbNumInFrame;
	2626
	2627	if ( I_SLICE == pCtx->eSliceType )//check if uiSliceSizeConstraint too small
	2628	{
	2629	#define byte_complexIMBat26 (60)
	2630	uint8_t iCurDid = pCtx->uiDependencyId;
	2631	uint32_t uiFrmByte = 0;
	2632
	2633	if ( pCtx->pSvcParam->bEnableRc )
	2634	{//RC case
	2635	uiFrmByte = (
	2636	( (uint32_t)(pCtx->pSvcParam->sDependencyLayers[iCurDid].iSpatialBitrate)
	2637	/(uint32_t)(pCtx->pSvcParam->sDependencyLayers[iCurDid].fInputFrameRate) ) >> 3 );
	2638	}
	2639	else
	2640	{//fixed QP case
	2641	int32_t iQDeltaTo26 = ( 26 - pCtx->pSvcParam->sDependencyLayers[iCurDid].iDLayerQp );
	2642
	2643	uiFrmByte = (iTtlMbNumInFrame * byte_complexIMBat26);
	2644	if ( iQDeltaTo26 > 0 )
	2645	{
	2646	//smaller QP than 26
	2647	uiFrmByte = (uint32_t)( uiFrmByte * ( (float)iQDeltaTo26 / 4 ) );
	2648	}
	2649	else if ( iQDeltaTo26 < 0 )
	2650	{
	2651	//larger QP than 26
	2652	iQDeltaTo26 = ( (-iQDeltaTo26) >> 2 ); //delta mod 4
	2653	uiFrmByte = ( uiFrmByte >> (iQDeltaTo26) ); //if delta 4, byte /2
	2654	}
	2655	}
	2656
	2657	//MINPACKETSIZE_CONSTRAINT
	2658	if ( pSliceCtx->uiSliceSizeConstraint
	2659	<
	2660	(uint32_t)( uiFrmByte//suppose 16 byte per mb at average
	2661	/ ( pSliceCtx->iMaxSliceNumConstraint ) )
	2662	)
	2663	{
	2664
	2665	WelsLog( pCtx,
	2666	WELS_LOG_WARNING,
	2667	"Set-SliceConstraint(%d) too small for current resolution (MB# %d) under QP/BR!\n",
	2668	pSliceCtx->uiSliceSizeConstraint,
	2669	pSliceCtx->iMbNumInFrame
	2670	);
	2671	}
	2672	}
	2673
	2674	WelsInitCurrentQBLayerMltslc( pCtx );
	2675	}
	2676	#endif
	2677
	2678	/*!
	2679	* \brief initialize current layer
	2680	*/
	2681	void WelsInitCurrentLayer( sWelsEncCtx *pCtx,
	2682	const int32_t kiWidth,
	2683	const int32_t kiHeight )
	2684	{
	2685	SWelsSvcCodingParam *pParam = pCtx->pSvcParam;
	2686	SPicture *pEncPic = pCtx->pEncPic;
	2687	SPicture *pDecPic = pCtx->pDecPic;
	2688	SDqLayer *pCurDq = pCtx->pCurDqLayer;
	2689	SSlice *pBaseSlice = &pCurDq->sLayerInfo.pSliceInLayer[0];
	2690	SSlice *pSlice = NULL;
	2691	const uint8_t kiCurDid = pCtx->uiDependencyId;
	2692	const bool_t kbUseSubsetSpsFlag= (kiCurDid > BASE_DEPENDENCY_ID);
	2693	SDLayerParam *fDlp = &pParam->sDependencyLayers[kiCurDid];
	2694	SNalUnitHeaderExt *pNalHdExt = &pCurDq->sLayerInfo.sNalHeaderExt;
	2695	SNalUnitHeader *pNalHd = &pNalHdExt->sNalHeader;
	2696	SDqIdc *pDqIdc = &pCtx->pDqIdcMap[kiCurDid];
	2697	int32_t iIdx = 0;
	2698	int32_t iSliceCount = 0;
	2699
	2700	if ( NULL == pCurDq )
	2701	return;
	2702
	2703	pCurDq->pDecPic = pDecPic;
	2704
	2705	if ( fDlp->sMso.uiSliceMode == SM_DYN_SLICE ) // need get extra slices for update
	2706	iSliceCount = GetInitialSliceNum( pCurDq->iMbWidth, pCurDq->iMbHeight, &fDlp->sMso );
	2707	else
	2708	iSliceCount = GetCurrentSliceNum( pCurDq->pSliceEncCtx );
	2709	assert( iSliceCount > 0 );
	2710
	2711	pBaseSlice->sSliceHeaderExt.sSliceHeader.iPpsId = pDqIdc->iPpsId;
	2712	pCurDq->sLayerInfo.pPpsP =
	2713	pBaseSlice->sSliceHeaderExt.sSliceHeader.pPps = &pCtx->pPPSArray[pBaseSlice->sSliceHeaderExt.sSliceHeader.iPpsId];
	2714	pBaseSlice->sSliceHeaderExt.sSliceHeader.iSpsId = pDqIdc->iSpsId;
	2715	if ( kbUseSubsetSpsFlag )
	2716	{
	2717	pCurDq->sLayerInfo.pSubsetSpsP = &pCtx->pSubsetArray[pDqIdc->iSpsId];
	2718	pCurDq->sLayerInfo.pSpsP =
	2719	pBaseSlice->sSliceHeaderExt.sSliceHeader.pSps = &pCurDq->sLayerInfo.pSubsetSpsP->pSps;
	2720	}
	2721	else
	2722	{
	2723	pCurDq->sLayerInfo.pSubsetSpsP = NULL;
	2724	pCurDq->sLayerInfo.pSpsP =
	2725	pBaseSlice->sSliceHeaderExt.sSliceHeader.pSps = &pCtx->pSpsArray[pBaseSlice->sSliceHeaderExt.sSliceHeader.iSpsId];
	2726	}
	2727
	2728	pSlice = pBaseSlice;
	2729	iIdx = 1;
	2730	while ( iIdx < iSliceCount ) {
	2731	++ pSlice;
	2732	pSlice->sSliceHeaderExt.sSliceHeader.iPpsId = pBaseSlice->sSliceHeaderExt.sSliceHeader.iPpsId;
	2733	pSlice->sSliceHeaderExt.sSliceHeader.pPps = pBaseSlice->sSliceHeaderExt.sSliceHeader.pPps;
	2734	pSlice->sSliceHeaderExt.sSliceHeader.iSpsId = pBaseSlice->sSliceHeaderExt.sSliceHeader.iSpsId;
	2735	pSlice->sSliceHeaderExt.sSliceHeader.pSps = pBaseSlice->sSliceHeaderExt.sSliceHeader.pSps;
	2736	++ iIdx;
	2737	}
	2738
	2739	memset( pNalHdExt, 0, sizeof(SNalUnitHeaderExt) );
	2740	pNalHd->uiNalRefIdc = pCtx->eNalPriority;
	2741	pNalHd->eNalUnitType = pCtx->eNalType;
	2742
	2743	pNalHdExt->uiDependencyId = kiCurDid;
	2744	pNalHdExt->bDiscardableFlag = (pCtx->bNeedPrefixNalFlag) ? (pNalHd->uiNalRefIdc == NRI_PRI_LOWEST) : false;
	2745	pNalHdExt->bIdrFlag = (pCtx->iFrameNum == 0) && ((pCtx->eNalType == NAL_UNIT_CODED_SLICE_IDR) \|\| (pCtx->eSliceType == I_SLICE));
	2746	pNalHdExt->uiTemporalId = pCtx->uiTemporalId;
	2747
	2748	pBaseSlice->bSliceHeaderExtFlag = (NAL_UNIT_CODED_SLICE_EXT == pNalHd->eNalUnitType);
	2749
	2750	pSlice = pBaseSlice;
	2751	iIdx = 1;
	2752	while (iIdx < iSliceCount) {
	2753	++ pSlice;
	2754	pSlice->bSliceHeaderExtFlag = pBaseSlice->bSliceHeaderExtFlag;
	2755	++ iIdx;
	2756	}
	2757
	2758	// pEncPic pData
	2759	pCurDq->pEncData[0] = pEncPic->pData[0];
	2760	pCurDq->pEncData[1] = pEncPic->pData[1];
	2761	pCurDq->pEncData[2] = pEncPic->pData[2];
	2762	pCurDq->iEncStride[0] = pEncPic->iLineSize[0];
	2763	pCurDq->iEncStride[1] = pEncPic->iLineSize[1];
	2764	pCurDq->iEncStride[2] = pEncPic->iLineSize[2];
	2765	// cs pData
	2766	pCurDq->pCsData[0] = pDecPic->pData[0];
	2767	pCurDq->pCsData[1] = pDecPic->pData[1];
	2768	pCurDq->pCsData[2] = pDecPic->pData[2];
	2769	pCurDq->iCsStride[0] = pDecPic->iLineSize[0];
	2770	pCurDq->iCsStride[1] = pDecPic->iLineSize[1];
	2771	pCurDq->iCsStride[2] = pDecPic->iLineSize[2];
	2772
	2773	if ( pCurDq->pRefLayer != NULL )
	2774	{
	2775	pCurDq->bBaseLayerAvailableFlag = true;
	2776	}
	2777	else
	2778	{
	2779	pCurDq->bBaseLayerAvailableFlag = false;
	2780	}
	2781	}
	2782
	2783	void PreprocessSliceCoding( sWelsEncCtx *pCtx )
	2784	{
	2785	SDqLayer *pCurLayer = pCtx->pCurDqLayer;
	2786	const bool_t kbBaseAvail = pCurLayer->bBaseLayerAvailableFlag;
	2787
	2788	/* function pointers conditional assignment under sWelsEncCtx, layer_mb_enc_rec (in stack) is exclusive */
	2789
	2790	if ( P_SLICE == pCtx->eSliceType )
	2791	{
	2792	if ( kbBaseAvail )
	2793	{
	2794	if ( pCtx->pSvcParam->iNumDependencyLayer == (pCurLayer->sLayerInfo.sNalHeaderExt.uiDependencyId + 1) ) //
	2795	{
	2796	pCtx->pFuncList->pfMotionSearch = WelsMotionEstimateSearchSad;
	2797	pCtx->pFuncList->pfFirstIntraMode = WelsMdFirstIntraMode;
	2798	pCtx->pFuncList->pfIntraFineMd = WelsMdIntraFinePartitionVaa;
	2799	pCtx->pFuncList->pfInterFineMd = WelsMdInterFinePartitionVaa;
	2800	pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad;
	2801	pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad;
	2802	pCtx->pFuncList->sSampleDealingFuncs.pfMdCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSad;
	2803	}
	2804	else
	2805	{
	2806	pCtx->pFuncList->pfMotionSearch = WelsMotionEstimateSearchSatd;
	2807	pCtx->pFuncList->pfFirstIntraMode = WelsMdFirstIntraMode;
	2808	pCtx->pFuncList->pfIntraFineMd = WelsMdIntraFinePartition;
	2809	pCtx->pFuncList->pfInterFineMd = WelsMdInterFinePartition;
	2810	pCtx->pFuncList->sSampleDealingFuncs.pfMdCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSatd;
	2811	pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd;
	2812	pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd;
	2813	pCtx->pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd;
	2814	}
	2815	pCtx->pFuncList->sSampleDealingFuncs.pfMeCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSatd;
	2816	}
	2817	else
	2818	{
	2819	//case 3: pBase layer MD + encoding
	2820	if ( pCurLayer->sLayerInfo.sNalHeaderExt.uiDependencyId+1 == pCtx->pSvcParam->iNumDependencyLayer )
	2821	{
	2822	pCtx->pFuncList->pfMotionSearch = WelsMotionEstimateSearchSad;
	2823	pCtx->pFuncList->pfFirstIntraMode = WelsMdFirstIntraMode;
	2824	pCtx->pFuncList->pfIntraFineMd = WelsMdIntraFinePartitionVaa;
	2825	pCtx->pFuncList->pfInterFineMd = WelsMdInterFinePartitionVaa;
	2826	pCtx->pFuncList->sSampleDealingFuncs.pfMdCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSad;
	2827	pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad;
	2828	pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad;
	2829	}
	2830	else
	2831	{
	2832	pCtx->pFuncList->pfMotionSearch = WelsMotionEstimateSearchSatd;
	2833	pCtx->pFuncList->pfFirstIntraMode = WelsMdFirstIntraMode;
	2834	pCtx->pFuncList->pfIntraFineMd = WelsMdIntraFinePartition;
	2835	pCtx->pFuncList->pfInterFineMd = WelsMdInterFinePartition;
	2836	pCtx->pFuncList->sSampleDealingFuncs.pfMdCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSatd;
	2837	pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd;
	2838	pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd;
	2839	pCtx->pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd;
	2840	}
	2841	pCtx->pFuncList->sSampleDealingFuncs.pfMeCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSatd;
	2842	}
	2843	}
	2844	else if ( I_SLICE == pCtx->eSliceType )
	2845	{
	2846	if ( pCurLayer->sLayerInfo.sNalHeaderExt.uiDependencyId+1 == pCtx->pSvcParam->iNumDependencyLayer )
	2847	{
	2848	pCtx->pFuncList->sSampleDealingFuncs.pfMdCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSad;
	2849	pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Sad;
	2850	pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Sad;
	2851	pCtx->pFuncList->pfIntraFineMd = WelsMdIntraFinePartitionVaa;
	2852	}
	2853	else
	2854	{
	2855	pCtx->pFuncList->sSampleDealingFuncs.pfMdCost = pCtx->pFuncList->sSampleDealingFuncs.pfSampleSatd;
	2856	pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra16x16Combined3Satd;
	2857	pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra8x8Combined3Satd;
	2858	pCtx->pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3 = pCtx->pFuncList->sSampleDealingFuncs.pfIntra4x4Combined3Satd;
	2859	pCtx->pFuncList->pfIntraFineMd = WelsMdIntraFinePartition;
	2860	}
	2861	}
	2862	}
	2863
	2864	/*!
	2865	* \brief swap pDq layers between current pDq layer and reference pDq layer
	2866	*/
	2867
	2868	static inline void WelsSwapDqLayers( sWelsEncCtx *pCtx )
	2869	{
	2870	// swap and assign reference
	2871	const int32_t kiDid = pCtx->uiDependencyId;
	2872	const int32_t kiNextDqIdx = 1 + kiDid;
	2873
	2874	SDqLayer *pTmpLayer = pCtx->ppDqLayerList[kiNextDqIdx];
	2875	SDqLayer *pRefLayer = pCtx->pCurDqLayer;
	2876	pCtx->pCurDqLayer = pTmpLayer;
	2877	pCtx->pCurDqLayer->pRefLayer = pRefLayer;
	2878	}
	2879
	2880	/*!
	2881	* \brief prefetch reference picture after WelsBuildRefList
	2882	*/
	2883	static inline void PrefetchReferencePicture( sWelsEncCtx *pCtx, const EFrameType keFrameType )
	2884	{
	2885	SSlice *pSliceBase = &pCtx->pCurDqLayer->sLayerInfo.pSliceInLayer[0];
	2886	const int32_t kiSliceCount = GetCurrentSliceNum( pCtx->pCurDqLayer->pSliceEncCtx );
	2887	int32_t iIdx = 0;
	2888	uint8_t uiRefIdx = -1;
	2889
	2890	assert( kiSliceCount > 0 );
	2891	if ( keFrameType != WELS_FRAME_TYPE_IDR )
	2892	{
	2893	assert( pCtx->iNumRef0 > 0 );
	2894	pCtx->pRefPic = pCtx->pRefList0[0]; // always get item 0 due to reordering done
	2895	pCtx->pCurDqLayer->pRefPic = pCtx->pRefPic;
	2896	uiRefIdx = 0; // reordered reference iIndex
	2897	}
	2898	else // safe for IDR coding
	2899	{
	2900	pCtx->pRefPic = NULL;
	2901	pCtx->pCurDqLayer->pRefPic = NULL;
	2902	}
	2903
	2904	iIdx = 0;
	2905	while (iIdx < kiSliceCount) {
	2906	pSliceBase->sSliceHeaderExt.sSliceHeader.uiRefIndex = uiRefIdx;
	2907	++ pSliceBase;
	2908	++ iIdx;
	2909	}
	2910	}
	2911
	2912
	2913	void ParasetIdAdditionIdAdjust( SParaSetOffsetVariable *sParaSetOffsetVariable, const int32_t kiCurEncoderParaSetId, const uint32_t kuiMaxIdInBs )//paraset_type = 0: SPS; =1: PPS
	2914	{
	2915	//SPS_ID in avc_sps and pSubsetSps will be different using this
	2916	//SPS_ID case example:
	2917	//1st enter: next_spsid_in_bs == 0; spsid == 0; delta==0; //actual spsid_in_bs == 0
	2918	//1st finish: next_spsid_in_bs == 1;
	2919	//2nd enter: next_spsid_in_bs == 1; spsid == 0; delta==1; //actual spsid_in_bs == 1
	2920	//2nd finish: next_spsid_in_bs == 2;
	2921	//31st enter: next_spsid_in_bs == 31; spsid == 0~2; delta==31~29; //actual spsid_in_bs == 31
	2922	//31st finish: next_spsid_in_bs == 0;
	2923	//31st enter: next_spsid_in_bs == 0; spsid == 0~2; delta==-2~0; //actual spsid_in_bs == 0
	2924	//31st finish: next_spsid_in_bs == 1;
	2925
	2926	const int32_t kiEncId = kiCurEncoderParaSetId;
	2927	const uint32_t kuiPrevIdInBs = sParaSetOffsetVariable->iParaSetIdDelta[kiEncId] + kiEncId;//mark current_id
	2928	const bool_t *kpUsedIdPointer = &sParaSetOffsetVariable->bUsedParaSetIdInBs[0];
	2929	uint32_t uiNextIdInBs = sParaSetOffsetVariable->uiNextParaSetIdToUseInBs;
	2930
	2931	#if _DEBUG
	2932	if ( 0 != sParaSetOffsetVariable->iParaSetIdDelta[kiEncId] )
	2933	assert ( sParaSetOffsetVariable->bUsedParaSetIdInBs[kuiPrevIdInBs] ); //sure the prev-used one was marked activated correctly
	2934	#endif
	2935	//update current layer's pCodingParam
	2936	sParaSetOffsetVariable->iParaSetIdDelta[kiEncId] = uiNextIdInBs - kiEncId; //for current parameter set, change its id_delta
	2937	//write pso pData for next update:
	2938	sParaSetOffsetVariable->bUsedParaSetIdInBs[kuiPrevIdInBs] = false; //
	2939	sParaSetOffsetVariable->bUsedParaSetIdInBs[uiNextIdInBs] = true; // update current used_id
	2940
	2941	//prepare for next update:
	2942	// find the next avaibable iId
	2943	do
	2944	{
	2945	++uiNextIdInBs;
	2946	if (uiNextIdInBs >= kuiMaxIdInBs )
	2947	{
	2948	uiNextIdInBs = 0;//ensure the SPS_ID wound not exceed MAX_SPS_COUNT
	2949	}
	2950	}while ( kpUsedIdPointer[uiNextIdInBs] );
	2951
	2952	// update next_id
	2953	sParaSetOffsetVariable->uiNextParaSetIdToUseInBs = uiNextIdInBs;
	2954
	2955	#if _DEBUG
	2956	assert ( !sParaSetOffsetVariable->bUsedParaSetIdInBs[uiNextIdInBs] ); //sure the next-to-use one is marked activated correctly
	2957	#endif
	2958
	2959	}
	2960
	2961	/*!
	2962	* \brief write all parameter sets introduced in SVC extension
	2963	* \return size in bytes of bitstream wrote
	2964	*/
	2965	int32_t WelsWriteParameterSets( sWelsEncCtx pCtx, int32_t pNalLen, int32_t *pNumNal )
	2966	{
	2967	int32_t iSize = 0;
	2968	int32_t iNal = 0;
	2969	int32_t iIdx = 0;
	2970	int32_t iId = 0;
	2971	int32_t iCountNal = 0;
	2972
	2973	if ( NULL == pCtx \|\| NULL == pNalLen \|\| NULL == pNumNal )
	2974	return 0;
	2975
	2976	/* write all SPS */
	2977	iIdx = 0;
	2978	while (iIdx < pCtx->iSpsNum) {
	2979	SDqIdc *pDqIdc = &pCtx->pDqIdcMap[iIdx];
	2980	const int32_t kiDid = pDqIdc->uiSpatialId;
	2981	const bool_t kbUsingSubsetSps = (kiDid > BASE_DEPENDENCY_ID);
	2982
	2983	iNal = pCtx->pOut->iNalIndex;
	2984
	2985	if ( pCtx->pSvcParam->bEnableSpsPpsIdAddition )
	2986	{
	2987	#if _DEBUG
	2988	pCtx->sPSOVector.bEnableSpsPpsIdAddition = 1;
	2989	assert(kiDid < MAX_DEPENDENCY_LAYER);
	2990	assert(iIdx < MAX_DQ_LAYER_NUM);
	2991	#endif
	2992
	2993	ParasetIdAdditionIdAdjust( &(pCtx->sPSOVector.sParaSetOffsetVariable[kbUsingSubsetSps ? PARA_SET_TYPE_SUBSETSPS : PARA_SET_TYPE_AVCSPS]),
	2994	(kbUsingSubsetSps)?(pCtx->pSubsetArray[iIdx - 1].pSps.uiSpsId):(pCtx->pSpsArray[0].uiSpsId ),
	2995	MAX_SPS_COUNT );
	2996	}
	2997	else
	2998	{
	2999	memset(&(pCtx->sPSOVector), 0, sizeof(pCtx->sPSOVector) );
	3000	}
	3001
	3002	if ( kbUsingSubsetSps ){
	3003	iId = iIdx - 1;
	3004
	3005	/* generate Subset SPS */
	3006	WelsLoadNal( pCtx->pOut, NAL_UNIT_SUBSET_SPS, NRI_PRI_HIGHEST );
	3007
	3008	WelsWriteSubsetSpsSyntax( &pCtx->pSubsetArray[iId], &pCtx->pOut->sBsWrite, &(pCtx->sPSOVector.sParaSetOffsetVariable[PARA_SET_TYPE_SUBSETSPS].iParaSetIdDelta[0]) );
	3009	WelsUnloadNal( pCtx->pOut );
	3010	}
	3011	else{
	3012	iId = 0;
	3013
	3014	/* generate sequence parameters set */
	3015	WelsLoadNal( pCtx->pOut, NAL_UNIT_SPS, NRI_PRI_HIGHEST );
	3016	WelsWriteSpsNal( &pCtx->pSpsArray[0], &pCtx->pOut->sBsWrite, &(pCtx->sPSOVector.sParaSetOffsetVariable[PARA_SET_TYPE_AVCSPS].iParaSetIdDelta[0]) );
	3017	WelsUnloadNal( pCtx->pOut );
	3018	}
	3019
	3020	pNalLen[iCountNal] = WelsEncodeNal( &pCtx->pOut->sNalList[iNal], pCtx->pFrameBs + pCtx->iPosBsBuffer, &pNalLen[iCountNal] );
	3021
	3022	pCtx->iPosBsBuffer += pNalLen[iCountNal];
	3023	iSize += pNalLen[iCountNal];
	3024
	3025	++ iIdx;
	3026	++ iCountNal;
	3027	}
	3028
	3029	/* write all PPS */
	3030	iIdx = 0;
	3031	while (iIdx < pCtx->iPpsNum) {
	3032	if ( pCtx->pSvcParam->bEnableSpsPpsIdAddition )
	3033	{
	3034	//para_set_type = 2: PPS, use MAX_PPS_COUNT
	3035	ParasetIdAdditionIdAdjust( &pCtx->sPSOVector.sParaSetOffsetVariable[PARA_SET_TYPE_PPS], pCtx->pPPSArray[iIdx].iPpsId, MAX_PPS_COUNT );
	3036	}
	3037
	3038	iNal = pCtx->pOut->iNalIndex;
	3039	/* generate picture parameter set */
	3040	WelsLoadNal( pCtx->pOut, NAL_UNIT_PPS, NRI_PRI_HIGHEST );
	3041	WelsWritePpsSyntax( &pCtx->pPPSArray[iIdx], &pCtx->pOut->sBsWrite, &(pCtx->sPSOVector) );
	3042	WelsUnloadNal( pCtx->pOut );
	3043
	3044	pNalLen[iCountNal] = WelsEncodeNal( &pCtx->pOut->sNalList[iNal], pCtx->pFrameBs + pCtx->iPosBsBuffer, &pNalLen[iCountNal] );
	3045
	3046	pCtx->iPosBsBuffer += pNalLen[iCountNal];
	3047	iSize += pNalLen[iCountNal];
	3048
	3049	++ iIdx;
	3050	++ iCountNal;
	3051	}
	3052
	3053	*pNumNal = iCountNal;
	3054
	3055	return iSize;
	3056	}
	3057
	3058	static inline int32_t AddPrefixNal( sWelsEncCtx *pCtx,
	3059	SLayerBSInfo *pLayerBsInfo,
	3060	int32_t *pNalLen,
	3061	int32_t *pNalIdxInLayer,
	3062	const EWelsNalUnitType keNalType,
	3063	const EWelsNalRefIdc keNalRefIdc )
	3064	{
	3065	int32_t iPayloadSize = 0;
	3066
	3067	if ( keNalRefIdc != NRI_PRI_LOWEST )
	3068	{
	3069	WelsLoadNal( pCtx->pOut, NAL_UNIT_PREFIX, keNalRefIdc );
	3070
	3071	WelsWriteSVCPrefixNal( &pCtx->pOut->sBsWrite, keNalRefIdc, (NAL_UNIT_CODED_SLICE_IDR == keNalType) );
	3072
	3073	WelsUnloadNal( pCtx->pOut );
	3074
	3075	iPayloadSize = WelsEncodeNalExt( &pCtx->pOut->sNalList[pCtx->pOut->iNalIndex-1],
	3076	&pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
	3077	pCtx->pFrameBs + pCtx->iPosBsBuffer,
	3078	&pNalLen[*pNalIdxInLayer] );
	3079
	3080	pCtx->iPosBsBuffer += iPayloadSize;
	3081	pLayerBsInfo->iNalLengthInByte[*pNalIdxInLayer] = iPayloadSize;
	3082
	3083	(*pNalIdxInLayer) ++;
	3084	}
	3085	else // No Prefix NAL Unit RBSP syntax here, but need add NAL Unit Header extension
	3086	{
	3087	WelsLoadNal( pCtx->pOut, NAL_UNIT_PREFIX, keNalRefIdc );
	3088	// No need write any syntax of prefix NAL Unit RBSP here
	3089	WelsUnloadNal( pCtx->pOut );
	3090
	3091	iPayloadSize = WelsEncodeNalExt( &pCtx->pOut->sNalList[pCtx->pOut->iNalIndex-1],
	3092	&pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
	3093	pCtx->pFrameBs + pCtx->iPosBsBuffer,
	3094	&pNalLen[*pNalIdxInLayer] );
	3095
	3096	pCtx->iPosBsBuffer += iPayloadSize;
	3097	pLayerBsInfo->iNalLengthInByte[*pNalIdxInLayer] = iPayloadSize;
	3098
	3099	(*pNalIdxInLayer) ++;
	3100	}
	3101
	3102	return iPayloadSize;
	3103	}
	3104
	3105	int32_t WritePadding(sWelsEncCtx *pCtx, int32_t iLen)
	3106	{
	3107	int32_t i=0;
	3108	int32_t iNal = 0;
	3109	SBitStringAux *pBs = NULL;
	3110	int32_t iNalLen;
	3111	int32_t iSize=0;
	3112
	3113	iNal = pCtx->pOut->iNalIndex;
	3114	pBs = &pCtx->pOut->sBsWrite; // SBitStringAux instance for non VCL NALs decoding
	3115
	3116	if((pBs->pBufEnd - pBs->pBufPtr) < iLen \|\| iNal >= pCtx->pOut->iCountNals)
	3117	{
	3118	#if GOM_TRACE_FLAG
	3119	WelsLog( pCtx, WELS_LOG_ERROR,"[RC] paddingcal pBuffer overflow, bufferlen=%d, paddinglen=%d, iNalIdx= %d, iCountNals= %d\n",
	3120	(pBs->pBufEnd-pBs->pBufPtr), iLen, iNal, pCtx->pOut->iCountNals);
	3121	#endif
	3122	return 0;
	3123	}
	3124
	3125	WelsLoadNal( pCtx->pOut, NAL_UNIT_FILLER_DATA, NRI_PRI_LOWEST );
	3126
	3127	for(i=0;i<iLen;i++)
	3128	{
	3129	BsWriteBits( pBs, 8, 0xff);
	3130	}
	3131
	3132	BsRbspTrailingBits( pBs );
	3133
	3134	BsFlush( pBs );
	3135
	3136	WelsUnloadNal( pCtx->pOut );
	3137	iNalLen = WelsEncodeNal( &pCtx->pOut->sNalList[iNal], pCtx->pFrameBs + pCtx->iPosBsBuffer, &iNalLen );
	3138
	3139	pCtx->iPosBsBuffer += iNalLen;
	3140	iSize += iNalLen;
	3141
	3142	return iSize;
	3143	}
	3144
	3145	/*
	3146	* post process of dynamic slicing bs writing in case PACKING_ONE_SLICE_PER_LAYER
	3147	* include: count bs size of over all the slices in layer,
	3148	* return: count number of slices in layer
	3149	*/
	3150	#if defined(MT_ENABLED) && defined(PACKING_ONE_SLICE_PER_LAYER)
	3151	int32_t PostProcDynamicSlicingBsWriting( sWelsEncCtx pCtx, SLayerBSInfo pLayerBsInfo, int32_t *pLayerSize, const int32_t kiPartitionCnt )
	3152	{
	3153	SDqLayer *pCurDq = pCtx->pCurDqLayer;
	3154	int32_t iPartitionIdx = 0;
	3155	int32_t iCheckingIdx = 0;
	3156	int32_t iSwappingIdx = -1;
	3157	int32_t iSliceCount = 0;
	3158	int32_t iLayerSize = 0;
	3159
	3160	// count number of slices in layer and layer size
	3161	while(iPartitionIdx < kiPartitionCnt)
	3162	{
	3163	const int32_t coded_slice_cnt = pCurDq->pNumSliceCodedOfPartition[iPartitionIdx];
	3164	iLayerSize += pCtx->pSliceThreading->pCountBsSizeInPartition[iPartitionIdx];
	3165	iSliceCount += coded_slice_cnt;
	3166	++ iPartitionIdx;
	3167	}
	3168	*pLayerSize = iLayerSize;
	3169
	3170	// reordering pLayerBs pointers, but do not ensure raster scan order of picture
	3171	// just maintain discontinuous items,i.e,
	3172	// input:
	3173	// partition 1: uiSliceIdx: 0 2 4 6
	3174	// partition 2: uiSliceIdx: 1 3 5 7 9 11 13
	3175	// output:
	3176	// uiSliceIdx: 0 1 2 3 4 5 6 7 8 9 10
	3177	iCheckingIdx = 0;
	3178	while(true)
	3179	{
	3180	bool_t bMatchFlag = false;
	3181	iPartitionIdx = 0;
	3182	while(iPartitionIdx < kiPartitionCnt)
	3183	{
	3184	const int32_t coded_slice_cnt = pCurDq->pNumSliceCodedOfPartition[iPartitionIdx];
	3185	// iCheckingIdx need convert to iIndex of iPartitionIdx based to avoid linear searching
	3186	// belong this partition and not exceed the number of slices coded in partition
	3187	if ( iPartitionIdx == (iCheckingIdx % kiPartitionCnt)
	3188	&& iCheckingIdx / kiPartitionCnt < coded_slice_cnt )
	3189	{
	3190	if ( iSwappingIdx >= 0 )
	3191	{
	3192	// memory swapping
	3193	memmove(pLayerBsInfo+iSwappingIdx, LayerBsInfo+iCheckingIdx, sizeof(SLayerBSInfo)); // confirmed_safe_unsafe_usage
	3194	++ iSwappingIdx; // record iSwappingIdx
	3195	}
	3196	++ iCheckingIdx;
	3197	bMatchFlag = true;
	3198	break;
	3199	}
	3200	++ iPartitionIdx;
	3201	}
	3202	if ( !bMatchFlag )
	3203	{
	3204	if ( iSwappingIdx < 0 )
	3205	iSwappingIdx = iCheckingIdx;
	3206	++ iCheckingIdx;
	3207	}
	3208	if ( iSwappingIdx >= iSliceCount )
	3209	break;
	3210	}
	3211
	3212	return iSliceCount;
	3213	}
	3214	#endif//MT_ENABLED && PACKING_ONE_SLICE_PER_LAYER
	3215
	3216	/*
	3217	* Force coding IDR as follows
	3218	*/
	3219	int32_t ForceCodingIDR( sWelsEncCtx *pCtx )
	3220	{
	3221	if ( NULL == pCtx )
	3222	return 1;
	3223
	3224	pCtx->bEncCurFrmAsIdrFlag = true;
	3225	pCtx->iCodingIndex = 0;
	3226
	3227	return 0;
	3228	}
	3229
	3230	/*!
	3231	* \brief core svc encoding process
	3232	*
	3233	* \pParam pCtx sWelsEncCtx*, encoder context
	3234	* \pParam pDst FrameBSInfo*
	3235	* \pParam pSrc SSourcePicture* for need_ds = true or SSourcePicture** for need_ds = false
	3236	* \pParam iConfiguredLayerNum =1 in case need_ds = true or >1 in case need_ds = false
	3237	* \pParam need_ds Indicate whether need down sampling desired
	3238	* [NO in picture list case, YES in console aplication based]
	3239	* \return EFrameType (WELS_FRAME_TYPE_IDR/WELS_FRAME_TYPE_I/WELS_FRAME_TYPE_P)
	3240	*/
	3241	int32_t WelsEncoderEncodeExt( sWelsEncCtx pCtx, void pDst, const SSourcePicture **ppSrcList, const int32_t iConfiguredLayerNum )
	3242	{
	3243	SFrameBSInfo pFbi = (SFrameBSInfo )pDst;
	3244	SLayerBSInfo *pLayerBsInfo = &pFbi->sLayerInfo[0];
	3245	SWelsSvcCodingParam *pSvcParam = pCtx->pSvcParam;
	3246	SSpatialPicIndex *pSpatialIndexMap= &pCtx->sSpatialIndexMap[0];
	3247	#if defined(ENABLE_FRAME_DUMP) \|\| defined(ENABLE_PSNR_CALC)
	3248	SPicture *fsnr = NULL;
	3249	#endif//ENABLE_FRAME_DUMP \|\| ENABLE_PSNR_CALC
	3250	SPicture *pEncPic = NULL; // to be decided later
	3251	#if defined(MT_ENABLED) && (defined(DYNAMIC_SLICE_ASSIGN) \|\| defined(MT_DEBUG))
	3252	int32_t did_list[MAX_DEPENDENCY_LAYER] = {0};
	3253	#endif//MT_ENABLED && DYNAMIC_SLICE_ASSIGN
	3254	int32_t iLayerNum = 0;
	3255	int32_t iLayerSize = 0;
	3256	int32_t iSpatialNum = 0; // available count number of spatial layers due to frame size changed in this given frame
	3257	int32_t iSpatialIdx = 0; // iIndex of spatial layers due to frame size changed in this given frame
	3258	int32_t iFrameSize = 0;
	3259	int32_t iNalLen[128] = {0};
	3260	int32_t iNalIdxInLayer = 0;
	3261	int32_t iCountNal = 0;
	3262	EFrameType eFrameType = WELS_FRAME_TYPE_AUTO;
	3263	int32_t iCurWidth = 0;
	3264	int32_t iCurHeight = 0;
	3265	EWelsNalUnitType eNalType = NAL_UNIT_UNSPEC_0;
	3266	EWelsNalRefIdc eNalRefIdc = NRI_PRI_LOWEST;
	3267	int8_t iCurDid = 0;
	3268	int8_t iCurTid = 0;
	3269	bool_t bAvcBased = false;
	3270	#if defined(ENABLE_PSNR_CALC)
	3271	real32_t snr_y = .0f, snr_u = .0f, snr_v = .0f;
	3272	#endif//ENABLE_PSNR_CALC
	3273
	3274	#if defined(_DEBUG)
	3275	int32_t i = 0, j = 0, k = 0;
	3276	#endif//_DEBUG
	3277
	3278	pFbi->iLayerNum = 0; // for initialization
	3279
	3280	// perform csc/denoise/downsample/padding, generate spatial layers
	3281	iSpatialNum = pCtx->pVpp->WelsPreprocessStep1(pCtx, ppSrcList, iConfiguredLayerNum);
	3282	if ( iSpatialNum < 1 ) // skip due to temporal layer settings (different frame rate)
	3283	{
	3284	++ pCtx->iCodingIndex;
	3285	return WELS_FRAME_TYPE_SKIP;
	3286	}
	3287
	3288	eFrameType = DecideFrameType( pCtx, iSpatialNum );
	3289	if (eFrameType == WELS_FRAME_TYPE_SKIP)
	3290	return eFrameType;
	3291
	3292	InitFrameCoding( pCtx, eFrameType );
	3293
	3294	iCurTid = GetTemporalLevel( &pSvcParam->sDependencyLayers[pSpatialIndexMap->iDid], pCtx->iCodingIndex, pSvcParam->uiGopSize );
	3295	pCtx->uiTemporalId = iCurTid;
	3296
	3297	pLayerBsInfo->pBsBuf = pCtx->pFrameBs ;
	3298
	3299	if ( eFrameType == WELS_FRAME_TYPE_IDR )
	3300	{
	3301	++ pCtx->sPSOVector.uiIdrPicId;
	3302	//if ( pSvcParam->bEnableSSEI )
	3303
	3304	// write parameter sets bitstream here
	3305	WelsWriteParameterSets( pCtx, &iNalLen[0], &iCountNal );
	3306
	3307	pLayerBsInfo->uiPriorityId = 0;
	3308	pLayerBsInfo->uiSpatialId = 0;
	3309	pLayerBsInfo->uiTemporalId = 0;
	3310	pLayerBsInfo->uiQualityId = 0;
	3311	pLayerBsInfo->uiLayerType = NON_VIDEO_CODING_LAYER;
	3312	pLayerBsInfo->iNalCount = iCountNal;
	3313	for (int32_t iNalIndex = 0; iNalIndex < iCountNal; ++ iNalIndex)
	3314	{
	3315	pLayerBsInfo->iNalLengthInByte[iNalIndex] = iNalLen[iNalIndex];
	3316	}
	3317
	3318	++ pLayerBsInfo;
	3319	pLayerBsInfo->pBsBuf = pCtx->pFrameBs + pCtx->iPosBsBuffer;
	3320	++ iLayerNum;
	3321	}
	3322
	3323	pCtx->pCurDqLayer = pCtx->ppDqLayerList[pSpatialIndexMap->iDid];
	3324	pCtx->pCurDqLayer->pRefLayer = NULL;
	3325
	3326	while ( iSpatialIdx < iSpatialNum )
	3327	{
	3328	const int32_t d_idx = (pSpatialIndexMap+iSpatialIdx)->iDid; // get iDid
	3329	SDLayerParam *param_d = &pSvcParam->sDependencyLayers[d_idx];
	3330
	3331	pCtx->uiDependencyId = iCurDid = (int8_t)d_idx;
	3332	pCtx->pVpp->WelsPreprocessStep3(pCtx, d_idx);
	3333
	3334	pCtx->pEncPic = pEncPic = (pSpatialIndexMap+iSpatialIdx)->pSrc;
	3335	pCtx->pEncPic->iPictureType = pCtx->eSliceType;
	3336	pCtx->pEncPic->iFramePoc = pCtx->iPOC;
	3337
	3338	iCurWidth = param_d->iFrameWidth;
	3339	iCurHeight = param_d->iFrameHeight;
	3340
	3341	#if defined(MT_ENABLED) && (defined(DYNAMIC_SLICE_ASSIGN) \|\| defined(MT_DEBUG))
	3342	did_list[iSpatialIdx] = iCurDid;
	3343	#endif//MT_ENABLED && DYNAMIC_SLICE_ASSIGN
	3344
	3345	// Encoding this picture might mulitiple sQualityStat layers potentially be encoded as followed
	3346
	3347	switch ( param_d->sMso.uiSliceMode )
	3348	{
	3349	case SM_FIXEDSLCNUM_SLICE:
	3350	{
	3351	#if defined(MT_ENABLED) && defined(DYNAMIC_SLICE_ASSIGN)
	3352	if ( (iCurDid > 0) && (pSvcParam->iMultipleThreadIdc > 1) &&
	3353	(pSvcParam->sDependencyLayers[iCurDid].sMso.uiSliceMode == SM_FIXEDSLCNUM_SLICE && pSvcParam->iMultipleThreadIdc >= pSvcParam->sDependencyLayers[iCurDid].sMso.sSliceArgument.iSliceNum )
	3354	)
	3355	AdjustEnhanceLayer( pCtx, iCurDid );
	3356	#endif//MT_ENABLED && DYNAMIC_SLICE_ASSIGN
	3357	break;
	3358	}
	3359	case SM_DYN_SLICE:
	3360	{
	3361	int32_t iPicIPartitionNum = PicPartitionNumDecision( pCtx );
	3362	// MT compatibility
	3363	pCtx->iActiveThreadsNum = iPicIPartitionNum; // we try to active number of threads, equal to number of picture partitions
	3364	WelsInitCurrentDlayerMltslc( pCtx, iPicIPartitionNum );
	3365	break;
	3366	}
	3367	default:
	3368	{
	3369	break;
	3370	}
	3371	}
	3372
	3373	/* coding each spatial layer, only one sQualityStat layer within spatial support */
	3374	int32_t iSliceCount = 1;
	3375	if ( iLayerNum >= MAX_LAYER_NUM_OF_FRAME ) // check available layer_bs_info writing as follows
	3376	{
	3377	WelsLog( pCtx, WELS_LOG_ERROR, "WelsEncoderEncodeExt(), iLayerNum(%d) overflow(max:%d)!", iLayerNum, MAX_LAYER_NUM_OF_FRAME);
	3378	return -1;
	3379	}
	3380
	3381	iNalIdxInLayer = 0;
	3382	bAvcBased = (iCurDid == BASE_DEPENDENCY_ID);
	3383	pCtx->bNeedPrefixNalFlag = (bAvcBased &&
	3384	(pSvcParam->bPrefixNalAddingCtrl \|\|
	3385	(pSvcParam->iNumDependencyLayer > 1) ));
	3386
	3387	if ( eFrameType == WELS_FRAME_TYPE_P )
	3388	{
	3389	eNalType = bAvcBased ? NAL_UNIT_CODED_SLICE : NAL_UNIT_CODED_SLICE_EXT;
	3390	}
	3391	else if ( eFrameType == WELS_FRAME_TYPE_IDR )
	3392	{
	3393	eNalType = bAvcBased ? NAL_UNIT_CODED_SLICE_IDR : NAL_UNIT_CODED_SLICE_EXT;
	3394	}
	3395	if ( iCurTid == 0 \|\| pCtx->eSliceType == I_SLICE )
	3396	eNalRefIdc = NRI_PRI_HIGHEST;
	3397	else if ( iCurTid == pSvcParam->iDecompStages )
	3398	eNalRefIdc = NRI_PRI_LOWEST;
	3399	else if ( 1 + iCurTid == pSvcParam->iDecompStages )
	3400	eNalRefIdc = NRI_PRI_LOW;
	3401	else // more details for other temporal layers?
	3402	eNalRefIdc = NRI_PRI_HIGHEST;
	3403	pCtx->eNalType = eNalType;
	3404	pCtx->eNalPriority = eNalRefIdc;
	3405
	3406	pCtx->pDecPic = pCtx->ppRefPicListExt[iCurDid]->pNextBuffer;
	3407	#if defined(ENABLE_FRAME_DUMP) \|\| defined(ENABLE_PSNR_CALC)
	3408	fsnr = pCtx->pDecPic;
	3409	#endif//#if defined(ENABLE_FRAME_DUMP) \|\| defined(ENABLE_PSNR_CALC)
	3410	pCtx->pDecPic->iPictureType = pCtx->eSliceType;
	3411	pCtx->pDecPic->iFramePoc = pCtx->iPOC;
	3412
	3413	WelsInitCurrentLayer( pCtx, iCurWidth, iCurHeight );
	3414
	3415	WelsMarkPic(pCtx);
	3416	if ( !WelsBuildRefList( pCtx, pCtx->iPOC ) )
	3417	{
	3418	// Force coding IDR as followed
	3419	ForceCodingIDR( pCtx );
	3420	WelsLog(pCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), WelsBuildRefList failed for P frames, pCtx->iNumRef0= %d.\n", pCtx->iNumRef0);
	3421	return -1;
	3422	}
	3423	#ifdef LONG_TERM_REF_DUMP
	3424	dump_ref(pCtx);
	3425	#endif
	3426	WelsUpdateRefSyntax(pCtx, pCtx->iPOC, eFrameType); //get reordering syntax used for writing slice header and transmit to encoder.
	3427	PrefetchReferencePicture( pCtx, eFrameType ); // update reference picture for current pDq layer
	3428
	3429	pCtx->pFuncList->pfRc.pfWelsRcPictureInit(pCtx);
	3430	PreprocessSliceCoding( pCtx ); // MUST be called after pfWelsRcPictureInit() and WelsInitCurrentLayer()
	3431
	3432	iLayerSize = 0;
	3433	if ( SM_SINGLE_SLICE == param_d->sMso.uiSliceMode ) // only one slice within a sQualityStat layer
	3434	{
	3435	int32_t iSliceSize = 0;
	3436
	3437	if ( pCtx->bNeedPrefixNalFlag )
	3438	{
	3439	iLayerSize += AddPrefixNal( pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, eNalType, eNalRefIdc );
	3440	}
	3441
	3442	WelsLoadNal( pCtx->pOut, eNalType, eNalRefIdc );
	3443
	3444	WelsCodeOneSlice( pCtx, 0, eNalType );
	3445
	3446	WelsUnloadNal( pCtx->pOut );
	3447
	3448	iSliceSize = WelsEncodeNalExt( &pCtx->pOut->sNalList[pCtx->pOut->iNalIndex-1],
	3449	&pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
	3450	pCtx->pFrameBs + pCtx->iPosBsBuffer,
	3451	&iNalLen[iNalIdxInLayer] );
	3452	iLayerSize += iSliceSize;
	3453	pCtx->iPosBsBuffer += iSliceSize;
	3454	pLayerBsInfo->uiLayerType = VIDEO_CODING_LAYER;
	3455	pLayerBsInfo->uiSpatialId = iCurDid;
	3456	pLayerBsInfo->uiTemporalId = iCurTid;
	3457	pLayerBsInfo->uiQualityId = 0;
	3458	pLayerBsInfo->uiPriorityId = 0;
	3459	pLayerBsInfo->iNalLengthInByte[iNalIdxInLayer] = iSliceSize;
	3460	pLayerBsInfo->iNalCount = ++ iNalIdxInLayer;
	3461	}
	3462	// for dynamic slicing single threading..
	3463	#ifndef MT_ENABLED
	3464	else if ( SM_DYN_SLICE == param_d->sMso.uiSliceMode )
	3465	#else // MT_ENABLED
	3466	else if ( (SM_DYN_SLICE == param_d->sMso.uiSliceMode) && (pSvcParam->iMultipleThreadIdc <= 1) )
	3467	#endif//MT_ENABLED
	3468	{
	3469	const int32_t kiLastMbInFrame = pCtx->pCurDqLayer->pSliceEncCtx->iMbNumInFrame;
	3470	WelsCodeOnePicPartition( pCtx, pLayerBsInfo, &iNalIdxInLayer, &iLayerSize, 0, kiLastMbInFrame, 0 );
	3471	}
	3472	else
	3473	{//other multi-slice uiSliceMode
	3474	#if defined(MT_ENABLED)
	3475	int err = 0;
	3476	// THREAD_FULLY_FIRE_MODE/THREAD_PICK_UP_MODE for any mode of non-SM_DYN_SLICE
	3477	if ( (SM_DYN_SLICE != param_d->sMso.uiSliceMode) && (pSvcParam->iMultipleThreadIdc > 1) )
	3478	{
	3479	iSliceCount = GetCurrentSliceNum( pCtx->pCurDqLayer->pSliceEncCtx );
	3480	if ( iLayerNum +
	3481	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3482	iSliceCount
	3483	#else
	3484	1
	3485	#endif//PACKING_ONE_SLICE_PER_LAYER
	3486	>= MAX_LAYER_NUM_OF_FRAME ) // check available layer_bs_info for further writing as followed
	3487	{
	3488	WelsLog( pCtx, WELS_LOG_ERROR, "WelsEncoderEncodeExt(), iLayerNum(%d) overflow(max:%d) at iDid= %d uiSliceMode= %d, iSliceCount= %d!",
	3489	iLayerNum, MAX_LAYER_NUM_OF_FRAME, iCurDid, param_d->sMso.uiSliceMode, iSliceCount );
	3490	return -1;
	3491	}
	3492	if ( iSliceCount <= 1 )
	3493	{
	3494	WelsLog( pCtx, WELS_LOG_ERROR, "WelsEncoderEncodeExt(), iSliceCount(%d) from GetCurrentSliceNum() is untrusted due stack/heap crupted!\n", iSliceCount );
	3495	return -1;
	3496	}
	3497
	3498	if ( pSvcParam->iCountThreadsNum >= iSliceCount ) //THREAD_FULLY_FIRE_MODE
	3499	{
	3500	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3501	int32_t iSliceIdx = 1;
	3502	int32_t iOrgSlicePos[MAX_SLICES_NUM] = {0};
	3503	iOrgSlicePos[0] = pCtx->iPosBsBuffer;
	3504	while (uiSliceIdx < iSliceCount)
	3505	{
	3506	iOrgSlicePos[uiSliceIdx] = pCtx->pSliceBs[uiSliceIdx].uiBsPos;
	3507	++ uiSliceIdx;
	3508	}
	3509	#elif defined(MT_DEBUG)
	3510	int64_t t_bs_append = 0;
	3511	#endif//PACKING_ONE_SLICE_PER_LAYER
	3512
	3513	pCtx->iActiveThreadsNum = iSliceCount;
	3514	// to fire slice coding threads
	3515	err = FiredSliceThreads( &pCtx->pSliceThreading->pThreadPEncCtx[0], &pCtx->pSliceThreading->pReadySliceCodingEvent[0], pLayerBsInfo, iSliceCount, pCtx->pCurDqLayer->pSliceEncCtx, FALSE );
	3516	if ( err )
	3517	{
	3518	WelsLog( pCtx, WELS_LOG_ERROR, "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!\n",
	3519	err, pSvcParam->iCountThreadsNum, iSliceCount, param_d->sMso.uiSliceMode, pSvcParam->iMultipleThreadIdc );
	3520	return -1;
	3521	}
	3522
	3523	WelsMultipleEventsWaitAllBlocking( iSliceCount, &pCtx->pSliceThreading->pSliceCodedEvent[0] );
	3524
	3525
	3526	// all slices are finished coding here
	3527	// append exclusive slice 0 bs to pFrameBs
	3528	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3529	iLayerSize = pCtx->iPosBsBuffer - iOrgSlicePos[0];
	3530	uiSliceIdx = 1;
	3531	while (uiSliceIdx < iSliceCount)
	3532	{
	3533	iLayerSize += pCtx->pSliceBs[uiSliceIdx].uiBsPos - iOrgSlicePos[uiSliceIdx];
	3534	++ uiSliceIdx;
	3535	}
	3536	iLayerNum += iSliceCount; // each slice stickly output as layer info for performance improvement directly
	3537	pLayerBsInfo += iSliceCount;
	3538	#else
	3539	#if defined(MT_DEBUG)
	3540	t_bs_append = WelsTime();
	3541	#endif//MT_DEBUG
	3542	iLayerSize = AppendSliceToFrameBs( pCtx, pLayerBsInfo, iSliceCount );
	3543	#if defined(MT_DEBUG)
	3544	t_bs_append = WelsTime() - t_bs_append;
	3545	if ( pCtx->pSliceThreading->pFSliceDiff )
	3546	{
	3547	fprintf(pCtx->pSliceThreading->pFSliceDiff,
	3548	#if defined(WIN32)
	3549	"%6I64d us consumed at AppendSliceToFrameBs() for coding_idx: %d iDid: %d qid: %d\n",
	3550	#else
	3551	"%6lld us consumed at AppendSliceToFrameBs() for coding_idx: %d iDid: %d qid: %d\n",
	3552	#endif//WIN32
	3553	t_bs_append, pCtx->iCodingIndex, iCurDid, 0 );
	3554	}
	3555	#endif//MT_DEBUG
	3556	#endif//PACKING_ONE_SLICE_PER_LAYER
	3557	}
	3558	else //THREAD_PICK_UP_MODE
	3559	{
	3560	int32_t iNumThreadsRunning = 0;
	3561	int32_t iNumThreadsScheduled = 0;
	3562	int32_t iIndexOfSliceToBeCoded = 0;
	3563	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3564	int32_t iSliceIdx = 1;
	3565	int32_t iOrgSlicePos[MAX_SLICES_NUM] = {0};
	3566	iOrgSlicePos[0] = pCtx->iPosBsBuffer;
	3567	while (uiSliceIdx < iSliceCount)
	3568	{
	3569	iOrgSlicePos[uiSliceIdx] = pCtx->pSliceBs[uiSliceIdx].uiBsPos;
	3570	++ uiSliceIdx;
	3571	}
	3572	#endif//PACKING_ONE_SLICE_PER_LAYER
	3573
	3574	pCtx->iActiveThreadsNum = pSvcParam->iCountThreadsNum;
	3575	iNumThreadsScheduled = pCtx->iActiveThreadsNum;
	3576	iNumThreadsRunning = iNumThreadsScheduled;
	3577	// to fire slice coding threads
	3578	err = FiredSliceThreads( &pCtx->pSliceThreading->pThreadPEncCtx[0], &pCtx->pSliceThreading->pReadySliceCodingEvent[0], pLayerBsInfo, iNumThreadsRunning, pCtx->pCurDqLayer->pSliceEncCtx, FALSE );
	3579	if ( err )
	3580	{
	3581	WelsLog( pCtx, WELS_LOG_ERROR, "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!\n",
	3582	err, pSvcParam->iCountThreadsNum, iSliceCount, param_d->sMso.uiSliceMode, pSvcParam->iMultipleThreadIdc );
	3583	return -1;
	3584	}
	3585
	3586	iIndexOfSliceToBeCoded = iNumThreadsRunning;
	3587	while (1)
	3588	{
	3589	if ( iIndexOfSliceToBeCoded >= iSliceCount && iNumThreadsRunning <= 0 )
	3590	break;
	3591	#ifdef WIN32
	3592	WELS_THREAD_ERROR_CODE lwait = 0;
	3593	int32_t iEventId = -1;
	3594
	3595	lwait = WelsMultipleEventsWaitSingleBlocking( iNumThreadsScheduled,
	3596	&pCtx->pSliceThreading->pSliceCodedEvent[0],
	3597	2 ); // 2 ms for one tick
	3598	iEventId = (int32_t)(lwait - WELS_THREAD_ERROR_WAIT_OBJECT_0);
	3599	if ( iEventId >= 0 && iEventId < iNumThreadsScheduled )
	3600	{
	3601	if ( iIndexOfSliceToBeCoded < iSliceCount )
	3602	{
	3603	// pick up succeeding slice for threading
	3604	// thread_id equal to iEventId per implementation here
	3605	pCtx->pSliceThreading->pThreadPEncCtx[iEventId].iSliceIndex = iIndexOfSliceToBeCoded;
	3606	#ifdef PACKING_ONE_SLICE_PER_LAYER
	3607	pCtx->pSliceThreading->pThreadPEncCtx[iEventId].pLayerBs = pLayerBsInfo+iIndexOfSliceToBeCoded;
	3608	#endif//PACKING_ONE_SLICE_PER_LAYER
	3609	WelsEventSignal( &pCtx->pSliceThreading->pReadySliceCodingEvent[iEventId] );
	3610
	3611	++ iIndexOfSliceToBeCoded;
	3612	}
	3613	else // no other slices left for coding
	3614	{
	3615	-- iNumThreadsRunning;
	3616	}
	3617	}
	3618	else
	3619	{
	3620	WelsSleep(1);
	3621	}
	3622	#else//__GNUC__
	3623	// TODO for pthread platforms
	3624	// alternate implementation using blocking due non-blocking with timeout mode not support at wels thread lib, tune back if available
	3625	WelsMultipleEventsWaitAllBlocking( iNumThreadsRunning, &pCtx->pSliceThreading->pSliceCodedEvent[0] );
	3626	if ( iIndexOfSliceToBeCoded < iSliceCount )
	3627	{
	3628	int32_t iThreadIdx = 0;
	3629	// pick up succeeding slices for threading if left
	3630	while ( iThreadIdx < iNumThreadsScheduled )
	3631	{
	3632	if ( iIndexOfSliceToBeCoded >= iSliceCount )
	3633	break;
	3634	pCtx->pSliceThreading->pThreadPEncCtx[iThreadIdx].iSliceIndex = iIndexOfSliceToBeCoded;
	3635	#ifdef PACKING_ONE_SLICE_PER_LAYER
	3636	pCtx->pSliceThreading->pThreadPEncCtx[iThreadIdx].pLayerBs = pLayerBsInfo+iIndexOfSliceToBeCoded;
	3637	#endif//PACKING_ONE_SLICE_PER_LAYER
	3638	WelsEventSignal( pCtx->pSliceThreading->pReadySliceCodingEvent[iThreadIdx] );
	3639
	3640	++ iIndexOfSliceToBeCoded;
	3641	++ iThreadIdx;
	3642	}
	3643	// update iNumThreadsRunning
	3644	iNumThreadsRunning = iThreadIdx;
	3645	}
	3646	else
	3647	{
	3648	iNumThreadsRunning = 0;
	3649	}
	3650	#endif//WIN32
	3651	}//while(1)
	3652
	3653	// all slices are finished coding here
	3654	// append exclusive slice 0 bs to pFrameBs
	3655	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3656	iLayerSize = pCtx->iPosBsBuffer - iOrgSlicePos[0];
	3657	uiSliceIdx = 1;
	3658	while (uiSliceIdx < iSliceCount)
	3659	{
	3660	iLayerSize += pCtx->pSliceBs[uiSliceIdx].uiBsPos - iOrgSlicePos[uiSliceIdx];
	3661	++ uiSliceIdx;
	3662	}
	3663	iLayerNum += iSliceCount; // each slice stickly output as layer info for performance improvement directly
	3664	pLayerBsInfo += iSliceCount;
	3665	#else
	3666	iLayerSize = AppendSliceToFrameBs( pCtx, pLayerBsInfo, iSliceCount );
	3667	#endif//PACKING_ONE_SLICE_PER_LAYER
	3668	}
	3669	}
	3670	// THREAD_FULLY_FIRE_MODE && SM_DYN_SLICE
	3671	else if ( (SM_DYN_SLICE == param_d->sMso.uiSliceMode) && (pSvcParam->iMultipleThreadIdc > 1) )
	3672	{
	3673	const int32_t kiPartitionCnt = pCtx->iActiveThreadsNum; //pSvcParam->iCountThreadsNum;
	3674	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3675	ResetCountBsSizeInPartitions( pCtx->pSliceThreading->pCountBsSizeInPartition, kiPartitionCnt );
	3676	pCtx->pCurDqLayer->pSliceEncCtx->iMaxSliceNumConstraint = WELS_MIN ( MAX_SLICES_NUM, DynamicMaxSliceNumConstraint( MAX_LAYER_NUM_OF_FRAME, iLayerNum, 1 + /( num_qlayer - 1) +/ ( ( (iCurDid==0) && ( pSvcParam->uiGopSize>1 ) ) ? 1: 0 ) ) );
	3677	#endif//PACKING_ONE_SLICE_PER_LAYER
	3678
	3679	// to fire slice coding threads
	3680	err = FiredSliceThreads( &pCtx->pSliceThreading->pThreadPEncCtx[0], &pCtx->pSliceThreading->pReadySliceCodingEvent[0], pLayerBsInfo, kiPartitionCnt, pCtx->pCurDqLayer->pSliceEncCtx, TRUE );
	3681	if ( err )
	3682	{
	3683	WelsLog( pCtx, WELS_LOG_ERROR, "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!\n",
	3684	err, pSvcParam->iCountThreadsNum, iSliceCount, param_d->sMso.uiSliceMode, pSvcParam->iMultipleThreadIdc );
	3685	return -1;
	3686	}
	3687
	3688	WelsMultipleEventsWaitAllBlocking( kiPartitionCnt, &pCtx->pSliceThreading->pSliceCodedEvent[0] );
	3689
	3690	#if defined(PACKING_ONE_SLICE_PER_LAYER)
	3691	iSliceCount = PostProcDynamicSlicingBsWriting( pCtx, pLayerBsInfo, &iLayerSize, kiPartitionCnt );
	3692	assert(iLayerNum + iSliceCount < MAX_LAYER_NUM_OF_FRAME);
	3693	pLayerBsInfo += iSliceCount;
	3694	iLayerNum += iSliceCount;
	3695	#else
	3696	iLayerSize = AppendSliceToFrameBs( pCtx, pLayerBsInfo, kiPartitionCnt );
	3697	#endif//PACKING_ONE_SLICE_PER_LAYER
	3698	}
	3699	else // for non-dynamic-slicing mode single threading branch..
	3700	#endif//MT_ENABLED
	3701	{
	3702	const bool_t bNeedPrefix = pCtx->bNeedPrefixNalFlag;
	3703	int32_t iSliceIdx = 0;
	3704
	3705	iSliceCount = GetCurrentSliceNum( pCtx->pCurDqLayer->pSliceEncCtx );
	3706	while (iSliceIdx < iSliceCount)
	3707	{
	3708	int32_t iSliceSize = 0;
	3709
	3710	if ( bNeedPrefix )
	3711	{
	3712	iLayerSize += AddPrefixNal( pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, eNalType, eNalRefIdc );
	3713	}
	3714
	3715	WelsLoadNal( pCtx->pOut, eNalType, eNalRefIdc );
	3716	WelsCodeOneSlice( pCtx, iSliceIdx, eNalType );
	3717	WelsUnloadNal( pCtx->pOut );
	3718
	3719	iSliceSize = WelsEncodeNalExt( &pCtx->pOut->sNalList[pCtx->pOut->iNalIndex-1],
	3720	&pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
	3721	pCtx->pFrameBs + pCtx->iPosBsBuffer,
	3722	&iNalLen[iNalIdxInLayer] );
	3723	pCtx->iPosBsBuffer += iSliceSize;
	3724	iLayerSize += iSliceSize;
	3725	pLayerBsInfo->iNalLengthInByte[iNalIdxInLayer] = iSliceSize;
	3726
	3727	#if defined(SLICE_INFO_OUTPUT)
	3728	fprintf( stderr,
	3729	"@slice=%-6d sliceType:%c idc:%d size:%-6d\n",
	3730	iSliceIdx,
	3731	(pCtx->eSliceType == P_SLICE ? 'P' : 'I'),
	3732	eNalRefIdc,
	3733	iSliceSize );
	3734	#endif//SLICE_INFO_OUTPUT
	3735	++ iNalIdxInLayer;
	3736	++ iSliceIdx;
	3737	}
	3738
	3739	pLayerBsInfo->uiLayerType = VIDEO_CODING_LAYER;
	3740	pLayerBsInfo->uiSpatialId = iCurDid;
	3741	pLayerBsInfo->uiTemporalId = iCurTid;
	3742	pLayerBsInfo->uiQualityId = 0;
	3743	pLayerBsInfo->uiPriorityId = 0;
	3744	pLayerBsInfo->iNalCount = iNalIdxInLayer;
	3745	}
	3746	}
	3747
	3748	// deblocking filter
	3749	if (
	3750	#if defined(MT_ENABLED)
	3751	(!pCtx->pCurDqLayer->bDeblockingParallelFlag) &&
	3752	#endif//MT_ENABLED
	3753	#if !defined(ENABLE_FRAME_DUMP)
	3754	( (eNalRefIdc != NRI_PRI_LOWEST) && (param_d->iHighestTemporalId == 0 \|\| iCurTid < param_d->iHighestTemporalId) ) &&
	3755	#endif//!ENABLE_FRAME_DUMP
	3756	true
	3757	)
	3758	{
	3759	PerformDeblockingFilter( pCtx );
	3760	}
	3761
	3762	// reference picture list update
	3763	if ( eNalRefIdc != NRI_PRI_LOWEST )
	3764	{
	3765	if ( !WelsUpdateRefList( pCtx ) )
	3766	{
	3767	// Force coding IDR as followed
	3768	ForceCodingIDR( pCtx );
	3769	WelsLog(pCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), WelsUpdateRefList failed.\n");
	3770	return -1;
	3771	}
	3772	}
	3773
	3774	iFrameSize += iLayerSize;
	3775
	3776	pCtx->pFuncList->pfRc.pfWelsRcPictureInfoUpdate(pCtx, iLayerSize);
	3777
	3778	#ifdef ENABLE_FRAME_DUMP
	3779	// Dump reconstruction picture for each sQualityStat layer
	3780	if ( iCurDid+1 < pSvcParam->iNumDependencyLayer )
	3781	DumpDependencyRec( fsnr, &param_d->sRecFileName[0], iCurDid );
	3782	#endif//ENABLE_FRAME_DUMP
	3783
	3784	#if defined(ENABLE_PSNR_CALC)
	3785	snr_y = WelsCalcPsnr( fsnr->pData[0],
	3786	fsnr->iLineSize[0],
	3787	pEncPic->pData[0],
	3788	pEncPic->iLineSize[0],
	3789	iCurWidth,
	3790	iCurHeight );
	3791	snr_u = WelsCalcPsnr( fsnr->pData[1],
	3792	fsnr->iLineSize[1],
	3793	pEncPic->pData[1],
	3794	pEncPic->iLineSize[1],
	3795	(iCurWidth>>1),
	3796	(iCurHeight>>1) );
	3797	snr_v = WelsCalcPsnr( fsnr->pData[2],
	3798	fsnr->iLineSize[2],
	3799	pEncPic->pData[2],
	3800	pEncPic->iLineSize[2],
	3801	(iCurWidth>>1),
	3802	(iCurHeight>>1) );
	3803	#endif//ENABLE_PSNR_CALC
	3804
	3805	#if defined(LAYER_INFO_OUTPUT)
	3806	fprintf( stderr, "%2s %5d: %-5d %2s T%1d D%1d Q%-2d QP%3d Y%2.2f U%2.2f V%2.2f %8d bits\n",
	3807	(iSpatialIdx == 0) ? "#AU" : " ",
	3808	pCtx->iPOC,
	3809	pCtx->iFrameNum,
	3810	(uiFrameType == WELS_FRAME_TYPE_I \|\| uiFrameType == WELS_FRAME_TYPE_IDR) ? "I": "P",
	3811	iCurTid,
	3812	iCurDid,
	3813	0,
	3814	pCtx->pWelsSvcRc[pCtx->uiDependencyId].iAverageFrameQp,
	3815	snr_y,
	3816	snr_u,
	3817	snr_v,
	3818	(iLayerSize<<3) );
	3819	#endif//LAYER_INFO_OUTPUT
	3820
	3821	#if defined(STAT_OUTPUT)
	3822
	3823	#if defined(ENABLE_PSNR_CALC)
	3824	{
	3825	pCtx->sStatData[iCurDid][0].sQualityStat.rYPsnr[pCtx->eSliceType] += snr_y;
	3826	pCtx->sStatData[iCurDid][0].sQualityStat.rUPsnr[pCtx->eSliceType] += snr_u;
	3827	pCtx->sStatData[iCurDid][0].sQualityStat.rVPsnr[pCtx->eSliceType] += snr_v;
	3828	}
	3829	#endif//ENABLE_PSNR_CALC
	3830
	3831	#if defined(MB_TYPES_CHECK) //091025, frame output
	3832	if (pCtx->eSliceType == P_SLICE)
	3833	{
	3834	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][Intra4x4] += pCtx->sPerInfo.iMbCount[P_SLICE][Intra4x4];
	3835	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][Intra16x16] += pCtx->sPerInfo.iMbCount[P_SLICE][Intra16x16];
	3836	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][Inter16x16] += pCtx->sPerInfo.iMbCount[P_SLICE][Inter16x16];
	3837	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][Inter16x8] += pCtx->sPerInfo.iMbCount[P_SLICE][Inter16x8];
	3838	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][Inter8x16] += pCtx->sPerInfo.iMbCount[P_SLICE][Inter8x16];
	3839	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][Inter8x8] += pCtx->sPerInfo.iMbCount[P_SLICE][Inter8x8];
	3840	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][PSkip] += pCtx->sPerInfo.iMbCount[P_SLICE][PSkip];
	3841	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][8] += pCtx->sPerInfo.iMbCount[P_SLICE][8];
	3842	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][9] += pCtx->sPerInfo.iMbCount[P_SLICE][9];
	3843	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][10] += pCtx->sPerInfo.iMbCount[P_SLICE][10];
	3844	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[P_SLICE][11] += pCtx->sPerInfo.iMbCount[P_SLICE][11];
	3845	}
	3846	else if (pCtx->eSliceType == I_SLICE)
	3847	{
	3848	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[I_SLICE][Intra4x4] += pCtx->sPerInfo.iMbCount[I_SLICE][Intra4x4];
	3849	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[I_SLICE][Intra16x16] += pCtx->sPerInfo.iMbCount[I_SLICE][Intra16x16];
	3850	pCtx->sStatData[iCurDid][0].sSliceData.iMbCount[I_SLICE][7] += pCtx->sPerInfo.iMbCount[I_SLICE][7];
	3851	}
	3852
	3853	memset(pCtx->sPerInfo.iMbCount[P_SLICE], 0, 18*sizeof( int32_t ));
	3854	memset(pCtx->sPerInfo.iMbCount[I_SLICE], 0, 18*sizeof( int32_t ));
	3855
	3856	#endif//MB_TYPES_CHECK
	3857	{
	3858	//no pCtx->pSvcParam->bMgsT0OnlyStrategy
	3859	++ pCtx->sStatData[iCurDid][0].sSliceData.iSliceCount[pCtx->eSliceType]; // for multiple slices coding
	3860	pCtx->sStatData[iCurDid][0].sSliceData.iSliceSize[pCtx->eSliceType] += (iLayerSize<<3); // bits
	3861	}
	3862	#endif//STAT_OUTPUT
	3863
	3864	#if defined(MT_ENABLED) && defined(PACKING_ONE_SLICE_PER_LAYER)
	3865	if ( pSvcParam->iMultipleThreadIdc <= 1 \|\| SM_SINGLE_SLICE == param_d->sMso.uiSliceMode ) // sigle thread actually used
	3866	#else
	3867	if ( 1 )
	3868	#endif//MT_ENABLED && PACKING_ONE_SLICE_PER_LAYER
	3869	{
	3870	++ iLayerNum;
	3871	++ pLayerBsInfo;
	3872	}
	3873
	3874
	3875	pLayerBsInfo->pBsBuf = pCtx->pFrameBs + pCtx->iPosBsBuffer;
	3876
	3877	if( pSvcParam->iPaddingFlag && pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize > 0 )
	3878	{
	3879	const int32_t kiPaddingNalSize = WritePadding(pCtx, pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize);
	3880
	3881	#if GOM_TRACE_FLAG
	3882	WelsLog( pCtx, WELS_LOG_INFO,"[RC] encoding_qp%d Padding: %d\n",pCtx->uiDependencyId, pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize);
	3883	#endif
	3884	if ( kiPaddingNalSize <= 0 )
	3885	return -1;
	3886
	3887	pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingBitrateStat += pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize;
	3888
	3889	pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize=0;
	3890
	3891	pLayerBsInfo->uiPriorityId = 0;
	3892	pLayerBsInfo->uiSpatialId = 0;
	3893	pLayerBsInfo->uiTemporalId = 0;
	3894	pLayerBsInfo->uiQualityId = 0;
	3895	pLayerBsInfo->uiLayerType = NON_VIDEO_CODING_LAYER;
	3896	pLayerBsInfo->iNalCount = 1;
	3897	pLayerBsInfo->iNalLengthInByte[0] = kiPaddingNalSize;
	3898	++ pLayerBsInfo;
	3899	pLayerBsInfo->pBsBuf = pCtx->pFrameBs + pCtx->iPosBsBuffer;
	3900	++ iLayerNum;
	3901	}
	3902
	3903	#if defined(MT_ENABLED) && defined(DYNAMIC_SLICE_ASSIGN) && defined(TRY_SLICING_BALANCE)
	3904	if ( param_d->sMso.uiSliceMode == SM_FIXEDSLCNUM_SLICE && pSvcParam->iMultipleThreadIdc > 1 &&
	3905	pSvcParam->iMultipleThreadIdc >= param_d->sMso.sSliceArgument.iSliceNum )
	3906	{
	3907	CalcSliceComplexRatio( pCtx->pSliceThreading->pSliceComplexRatio[iCurDid], pCtx->pCurDqLayer->pSliceEncCtx, pCtx->pSliceThreading->pSliceConsumeTime[iCurDid] );
	3908	#if defined(MT_DEBUG)
	3909	TrackSliceComplexities( pCtx, iCurDid );
	3910	#endif//#if defined(MT_DEBUG)
	3911	}
	3912	#endif//MT_ENABLED && DYNAMIC_SLICE_ASSIGN && TRY_SLICING_BALANCE
	3913
	3914	++ iSpatialIdx;
	3915
	3916	if ( iCurDid+1 < pSvcParam->iNumDependencyLayer )
	3917	{
	3918	WelsSwapDqLayers( pCtx );
	3919	}
	3920
	3921	if ( pSvcParam->bEnableLongTermReference && (pCtx->pLtr[pCtx->uiDependencyId].bLTRMarkingFlag && (pCtx->pLtr[pCtx->uiDependencyId].iLTRMarkMode == LTR_DELAY_MARK)))
	3922	{
	3923	pCtx->bLongTermRefFlag[d_idx][0] = true;
	3924	}
	3925
	3926	if ( iCurTid < pCtx->uiSpatialLayersInTemporal[d_idx] - 1 \|\| pSvcParam->iDecompStages == 0 )
	3927	{
	3928	if ( (iCurTid >= MAX_TEMPORAL_LEVEL)\|\|(pCtx->uiSpatialLayersInTemporal[d_idx]-1>= MAX_TEMPORAL_LEVEL))
	3929	{
	3930	ForceCodingIDR( pCtx ); // some logic error
	3931	return -1;
	3932	}
	3933
	3934	if ( pSvcParam->bEnableLongTermReference && pCtx->bLongTermRefFlag[d_idx][iCurTid] )
	3935	{
	3936	SPicture *tmp = pCtx->pSpatialPic[d_idx][pCtx->uiSpatialLayersInTemporal[d_idx]+pCtx->pVaa->uiMarkLongTermPicIdx];
	3937	pCtx->pSpatialPic[d_idx][pCtx->uiSpatialLayersInTemporal[d_idx]+pCtx->pVaa->uiMarkLongTermPicIdx] = pCtx->pSpatialPic[d_idx][iCurTid];
	3938	pCtx->pSpatialPic[d_idx][iCurTid] = pCtx->pSpatialPic[d_idx][pCtx->uiSpatialLayersInTemporal[d_idx]-1];
	3939	pCtx->pSpatialPic[d_idx][pCtx->uiSpatialLayersInTemporal[d_idx]-1] = tmp;
	3940	pCtx->bLongTermRefFlag[d_idx][iCurTid] = false;
	3941	}
	3942	else
	3943	{
	3944	WelsExchangeSpatialPictures( &pCtx->pSpatialPic[d_idx][pCtx->uiSpatialLayersInTemporal[d_idx]-1], &pCtx->pSpatialPic[d_idx][iCurTid] );
	3945	}
	3946	}
	3947
	3948	if ( pSvcParam->bEnableLongTermReference && ((pCtx->pLtr[pCtx->uiDependencyId].bLTRMarkingFlag && (pCtx->pLtr[pCtx->uiDependencyId].iLTRMarkMode == LTR_DIRECT_MARK)) \|\| eFrameType == WELS_FRAME_TYPE_IDR))
	3949	{
	3950	pCtx->bLongTermRefFlag[d_idx][iCurTid] = true;
	3951	}
	3952	}
	3953
	3954	#if defined(MT_ENABLED) && defined(MT_DEBUG)
	3955	TrackSliceConsumeTime( pCtx, did_list, iSpatialNum );
	3956	#endif//MT_ENABLED && MT_DEBUG
	3957
	3958	#if defined(MT_ENABLED) && defined(DYNAMIC_SLICE_ASSIGN)
	3959	if ( pSvcParam->iMultipleThreadIdc > 1 && did_list[0] == BASE_DEPENDENCY_ID
	3960	&& pSvcParam->sDependencyLayers[0].sMso.uiSliceMode == SM_FIXEDSLCNUM_SLICE && pSvcParam->iMultipleThreadIdc >= pSvcParam->sDependencyLayers[0].sMso.sSliceArgument.iSliceNum
	3961	&& pSvcParam->sDependencyLayers[did_list[iSpatialNum-1]].sMso.uiSliceMode == SM_FIXEDSLCNUM_SLICE && pSvcParam->iMultipleThreadIdc >= pSvcParam->sDependencyLayers[did_list[iSpatialNum-1]].sMso.sSliceArgument.iSliceNum )
	3962	{
	3963	AdjustBaseLayer( pCtx );
	3964	}
	3965	#endif//DYNAMIC_SLICE_ASSIGN
	3966
	3967	#ifdef ENABLE_FRAME_DUMP
	3968	DumpRecFrame( fsnr, &pSvcParam->sDependencyLayers[pSvcParam->iNumDependencyLayer-1].sRecFileName[0] ); // pDecPic: final reconstruction output
	3969	#endif//ENABLE_FRAME_DUMP
	3970
	3971	++ pCtx->iCodingIndex;
	3972	pCtx->eLastNalPriority = eNalRefIdc;
	3973	pFbi->iLayerNum = iLayerNum;
	3974
	3975	#if defined(X86_ASM)
	3976	WelsEmms();
	3977	#endif //X86_ASM
	3978
	3979	return eFrameType;
	3980	}
	3981
	3982	/*!
	3983	* \brief Wels SVC encoder parameters adjustment
	3984	* SVC adjustment results in new requirement in memory blocks adjustment
	3985	*/
	3986	int32_t WelsEncoderParamAdjust( sWelsEncCtx *ppCtx, SWelsSvcCodingParam pNewParam )
	3987	{
	3988	SWelsSvcCodingParam *pOldParam = NULL;
	3989	int32_t iReturn = 0;
	3990	int8_t iIndexD= 0;
	3991	bool_t bNeedReset = false;
	3992
	3993	if ( NULL == ppCtx \|\| NULL == *ppCtx \|\| NULL == pNewParam ) return 1;
	3994
	3995	/* Check validation in new parameters */
	3996	iReturn = ParamValidationExt( pNewParam );
	3997	if ( iReturn != 0 ) return iReturn;
	3998
	3999	pOldParam = (*ppCtx)->pSvcParam;
	4000
	4001	/* Decide whether need reset for IDR frame based on adjusting prarameters changed */
	4002	/* Temporal levels, spatial settings and/ or quality settings changed need update parameter sets related. */
	4003	bNeedReset = (pOldParam == NULL ) \|\|
	4004	(pOldParam->iNumTemporalLayer != pNewParam->iNumTemporalLayer) \|\|
	4005	(pOldParam->uiGopSize != pNewParam->uiGopSize) \|\|
	4006	(pOldParam->iNumDependencyLayer != pNewParam->iNumDependencyLayer) \|\|
	4007	(pOldParam->iDecompStages != pNewParam->iDecompStages) \|\|
	4008	(pOldParam->iActualPicWidth != pNewParam->iActualPicWidth \|\| pOldParam->iActualPicHeight != pNewParam->iActualPicHeight) \|\|
	4009	(pOldParam->SUsedPicRect.iWidth != pNewParam->SUsedPicRect.iWidth \|\| pOldParam->SUsedPicRect.iHeight != pNewParam->SUsedPicRect.iHeight) \|\|
	4010	(pOldParam->bEnableLongTermReference != pNewParam->bEnableLongTermReference);
	4011	if ( !bNeedReset ){ // Check its picture resolutions/quality settings respectively in each dependency layer
	4012	iIndexD = 0;
	4013	assert( pOldParam->iNumDependencyLayer == pNewParam->iNumDependencyLayer );
	4014	do
	4015	{
	4016	const SDLayerParam *kpOldDlp = &pOldParam->sDependencyLayers[iIndexD];
	4017	const SDLayerParam *kpNewDlp = &pNewParam->sDependencyLayers[iIndexD];
	4018	float fT1 = .0f;
	4019	float fT2 = .0f;
	4020
	4021	// check frame size settings
	4022	if ( kpOldDlp->iFrameWidth != kpNewDlp->iFrameWidth \|\|
	4023	kpOldDlp->iFrameHeight != kpNewDlp->iFrameHeight \|\|
	4024	kpOldDlp->iActualWidth != kpNewDlp->iActualWidth \|\|
	4025	kpOldDlp->iActualHeight != kpNewDlp->iActualHeight ){
	4026	bNeedReset = true;
	4027	break;
	4028	}
	4029
	4030	if ( kpOldDlp->sMso.uiSliceMode != kpNewDlp->sMso.uiSliceMode \|\|
	4031	kpOldDlp->sMso.sSliceArgument.iSliceNum != kpNewDlp->sMso.sSliceArgument.iSliceNum )
	4032	{
	4033	bNeedReset = true;
	4034	break;
	4035	}
	4036
	4037	// check frame rate
	4038	// we can not check whether corresponding fFrameRate is equal or not,
	4039	// only need to check d_max/d_min and max_fr/d_max whether it is equal or not
	4040	if ( kpNewDlp->fInputFrameRate > EPSN && kpOldDlp->fInputFrameRate > EPSN )
	4041	fT1 = kpNewDlp->fOutputFrameRate/kpNewDlp->fInputFrameRate - kpOldDlp->fOutputFrameRate/kpOldDlp->fInputFrameRate;
	4042	if ( kpNewDlp->fOutputFrameRate > EPSN && kpOldDlp->fOutputFrameRate > EPSN )
	4043	fT2 = pNewParam->fMaxFrameRate/kpNewDlp->fOutputFrameRate - pOldParam->fMaxFrameRate/kpOldDlp->fOutputFrameRate;
	4044	if ( fT1 > EPSN \|\| fT1 < -EPSN \|\| fT2 > EPSN \|\| fT2 < -EPSN )
	4045	{
	4046	bNeedReset = true;
	4047	break;
	4048	}
	4049
	4050	if ( kpOldDlp->iHighestTemporalId != kpNewDlp->iHighestTemporalId )
	4051	{
	4052	bNeedReset = true;
	4053	break;
	4054	}
	4055
	4056	++ iIndexD;
	4057	} while (iIndexD < pOldParam->iNumDependencyLayer);
	4058	}
	4059
	4060	if ( bNeedReset ){
	4061	SParaSetOffsetVariable sTmpPsoVariable[PARA_SET_TYPE];
	4062	uint16_t uiTmpIdrPicId;//this is for LTR!
	4063	memcpy( sTmpPsoVariable, (ppCtx)->sPSOVector.sParaSetOffsetVariable, (PARA_SET_TYPE)sizeof(SParaSetOffsetVariable) );// confirmed_safe_unsafe_usage
	4064	uiTmpIdrPicId = (*ppCtx)->sPSOVector.uiIdrPicId;
	4065
	4066	WelsUninitEncoderExt( ppCtx );
	4067
	4068	/* Update new parameters */
	4069	if ( WelsInitEncoderExt( ppCtx, pNewParam ) )
	4070	return 1;
	4071
	4072	// reset the scaled spatial picture size
	4073	(ppCtx)->pVpp->WelsPreprocessReset(ppCtx);
	4074	//if WelsInitEncoderExt succeed
	4075
	4076	//for FLEXIBLE_PARASET_ID
	4077	memcpy( (ppCtx)->sPSOVector.sParaSetOffsetVariable, sTmpPsoVariable, (PARA_SET_TYPE)sizeof(SParaSetOffsetVariable) );// confirmed_safe_unsafe_usage
	4078	(*ppCtx)->sPSOVector.uiIdrPicId = uiTmpIdrPicId;
	4079	}
	4080	else{
	4081	/* maybe adjustment introduced in bitrate or little settings adjustment and so on.. */
	4082	pNewParam->iNumRefFrame = WELS_CLIP3(pNewParam->iNumRefFrame, MIN_REF_PIC_COUNT, MAX_REFERENCE_PICTURE_COUNT_NUM);
	4083	pNewParam->iLoopFilterDisableIdc = WELS_CLIP3(pNewParam->iLoopFilterDisableIdc, 0, 6);
	4084	pNewParam->iLoopFilterAlphaC0Offset = WELS_CLIP3(pNewParam->iLoopFilterAlphaC0Offset, -6, 6);
	4085	pNewParam->iLoopFilterBetaOffset = WELS_CLIP3(pNewParam->iLoopFilterBetaOffset, -6, 6);
	4086	pNewParam->iInterLayerLoopFilterDisableIdc = WELS_CLIP3(pNewParam->iInterLayerLoopFilterDisableIdc, 0, 6);
	4087	pNewParam->iInterLayerLoopFilterAlphaC0Offset = WELS_CLIP3(pNewParam->iInterLayerLoopFilterAlphaC0Offset, -6, 6);
	4088	pNewParam->iInterLayerLoopFilterBetaOffset = WELS_CLIP3(pNewParam->iInterLayerLoopFilterBetaOffset, -6, 6);
	4089	pNewParam->fMaxFrameRate = WELS_CLIP3(pNewParam->fMaxFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);
	4090
	4091	// we can not use direct struct based memcpy due some fields need keep unchanged as before
	4092	pOldParam->fMaxFrameRate = pNewParam->fMaxFrameRate; // maximal frame rate [Hz / fps]
	4093	pOldParam->iInputCsp = pNewParam->iInputCsp; // color space of input sequence
	4094	pOldParam->uiIntraPeriod = pNewParam->uiIntraPeriod; // intra period (multiple of GOP size as desired)
	4095	pOldParam->bEnableSpsPpsIdAddition = pNewParam->bEnableSpsPpsIdAddition;
	4096	pOldParam->bPrefixNalAddingCtrl = pNewParam->bPrefixNalAddingCtrl;
	4097	pOldParam->iNumRefFrame = pNewParam->iNumRefFrame; // number of reference frame used
	4098
	4099	/* denoise control */
	4100	pOldParam->bEnableDenoise = pNewParam->bEnableDenoise;
	4101
	4102	/* background detection control */
	4103	pOldParam->bEnableBackgroundDetection = pNewParam->bEnableBackgroundDetection;
	4104
	4105	/* adaptive quantization control */
	4106	pOldParam->bEnableAdaptiveQuant = pNewParam->bEnableAdaptiveQuant;
	4107
	4108	/* int32_t term reference control */
	4109	pOldParam->bEnableLongTermReference = pNewParam->bEnableLongTermReference;
	4110	pOldParam->uiLtrMarkPeriod = pNewParam->uiLtrMarkPeriod;
	4111
	4112	// keep below values unchanged as before
	4113	pOldParam->bEnableSSEI = pNewParam->bEnableSSEI;
	4114	pOldParam->bEnableFrameCroppingFlag = pNewParam->bEnableFrameCroppingFlag; // enable frame cropping flag
	4115
	4116	/* Motion search */
	4117
	4118	/* Deblocking loop filter */
	4119	pOldParam->iLoopFilterDisableIdc = pNewParam->iLoopFilterDisableIdc; // 0: on, 1: off, 2: on except for slice boundaries
	4120	pOldParam->iLoopFilterAlphaC0Offset = pNewParam->iLoopFilterAlphaC0Offset;// AlphaOffset: valid range [-6, 6], default 0
	4121	pOldParam->iLoopFilterBetaOffset = pNewParam->iLoopFilterBetaOffset; // BetaOffset: valid range [-6, 6], default 0
	4122	pOldParam->iInterLayerLoopFilterDisableIdc = pNewParam->iInterLayerLoopFilterDisableIdc; // Employed based upon inter-layer, same comment as above
	4123	pOldParam->iInterLayerLoopFilterAlphaC0Offset = pNewParam->iInterLayerLoopFilterAlphaC0Offset; // InterLayerLoopFilterAlphaC0Offset
	4124	pOldParam->iInterLayerLoopFilterBetaOffset = pNewParam->iInterLayerLoopFilterBetaOffset; // InterLayerLoopFilterBetaOffset
	4125
	4126	/* Rate Control */
	4127	pOldParam->bEnableRc = pNewParam->bEnableRc;
	4128	pOldParam->iRCMode = pNewParam->iRCMode;
	4129	pOldParam->iTargetBitrate = pNewParam->iTargetBitrate; // overall target bitrate introduced in RC module
	4130	pOldParam->iPaddingFlag = pNewParam->iPaddingFlag;
	4131
	4132	/* Layer definition */
	4133	pOldParam->bPrefixNalAddingCtrl = pNewParam->bPrefixNalAddingCtrl;
	4134
	4135	// d
	4136	iIndexD = 0;
	4137	do
	4138	{
	4139	SDLayerParam *pOldDlp = &pOldParam->sDependencyLayers[iIndexD];
	4140	SDLayerParam *pNewDlp = &pNewParam->sDependencyLayers[iIndexD];
	4141
	4142	pOldDlp->fInputFrameRate = pNewDlp->fInputFrameRate; // input frame rate
	4143	pOldDlp->fOutputFrameRate = pNewDlp->fOutputFrameRate; // output frame rate
	4144	pOldDlp->iSpatialBitrate = pNewDlp->iSpatialBitrate;
	4145
	4146	pOldDlp->uiProfileIdc = pNewDlp->uiProfileIdc; // value of profile IDC (0 for auto-detection)
	4147
	4148	/* Derived variants below */
	4149	pOldDlp->iTemporalResolution = pNewDlp->iTemporalResolution;
	4150	pOldDlp->iDecompositionStages = pNewDlp->iDecompositionStages;
	4151
	4152	memcpy(pOldDlp->uiCodingIdx2TemporalId, pNewDlp->uiCodingIdx2TemporalId, sizeof(pOldDlp->uiCodingIdx2TemporalId)); // confirmed_safe_unsafe_usage
	4153
	4154	++ iIndexD;
	4155	} while (iIndexD < pOldParam->iNumDependencyLayer);
	4156	}
	4157
	4158	/* Any else initialization/reset for rate control here? */
	4159
	4160	return 0;
	4161	}
	4162
	4163
	4164	int32_t WelsCodeOnePicPartition( sWelsEncCtx *pCtx,
	4165	SLayerBSInfo *pLayerBsInfo,
	4166	int32_t *pNalIdxInLayer,
	4167	int32_t* pLayerSize,
	4168	int32_t iFirstMbInPartition, // first mb inclusive in partition
	4169	int32_t iEndMbInPartition, // end mb exclusive in partition
	4170	int32_t iStartSliceIdx
	4171	)
	4172	{
	4173
	4174	SDqLayer * pCurLayer = pCtx->pCurDqLayer;
	4175	SSliceCtx * pSliceCtx = pCurLayer->pSliceEncCtx;
	4176	int32_t iNalLen[MAX_NAL_UNITS_IN_LAYER] = {0};
	4177	int32_t iNalIdxInLayer = *pNalIdxInLayer;
	4178	int32_t iSliceIdx = iStartSliceIdx;
	4179	const int32_t kiSliceStep = pCtx->iActiveThreadsNum;
	4180	const int32_t kiPartitionId = iStartSliceIdx % kiSliceStep;
	4181	int32_t iPartitionBsSize = 0;
	4182	int32_t iAnyMbLeftInPartition= iEndMbInPartition - iFirstMbInPartition;
	4183	const EWelsNalUnitType keNalType = pCtx->eNalType;
	4184	const EWelsNalRefIdc keNalRefIdc = pCtx->eNalPriority;
	4185	const bool_t kbNeedPrefix = pCtx->bNeedPrefixNalFlag;
	4186
	4187	//init
	4188	{
	4189	pSliceCtx->pFirstMbInSlice[iSliceIdx] = iFirstMbInPartition;
	4190	pCurLayer->pNumSliceCodedOfPartition[kiPartitionId] = 1; // one slice per partition intialized, dynamic slicing inside
	4191	pCurLayer->pLastMbIdxOfPartition[kiPartitionId] = iEndMbInPartition-1;
	4192	}
	4193	pCurLayer->pLastCodedMbIdxOfPartition[kiPartitionId] = 0;
	4194
	4195	while ( iAnyMbLeftInPartition > 0 )
	4196	{
	4197	int32_t iSliceSize = 0;
	4198
	4199	if ( iSliceIdx >= pSliceCtx->iMaxSliceNumConstraint ) // insufficient memory in pSliceInLayer[]
	4200	{
	4201	// TODO: need exception handler for not large enough of MAX_SLICES_NUM related memory usage
	4202	// No idea about its solution due MAX_SLICES_NUM is fixed lenght in relevent pData structure
	4203	return 1;
	4204	}
	4205
	4206	if ( kbNeedPrefix )
	4207	{
	4208	iPartitionBsSize += AddPrefixNal( pCtx, pLayerBsInfo, &iNalLen[0], &iNalIdxInLayer, keNalType, keNalRefIdc );
	4209	}
	4210
	4211	WelsLoadNal( pCtx->pOut, keNalType, keNalRefIdc );
	4212	WelsCodeOneSlice( pCtx, iSliceIdx, keNalType );
	4213	WelsUnloadNal( pCtx->pOut );
	4214
	4215	iSliceSize = WelsEncodeNalExt( &pCtx->pOut->sNalList[pCtx->pOut->iNalIndex-1],
	4216	&pCtx->pCurDqLayer->sLayerInfo.sNalHeaderExt,
	4217	pCtx->pFrameBs + pCtx->iPosBsBuffer,
	4218	&iNalLen[iNalIdxInLayer] );
	4219	pCtx->iPosBsBuffer += iSliceSize;
	4220	iPartitionBsSize += iSliceSize;
	4221	pLayerBsInfo->iNalLengthInByte[iNalIdxInLayer] = iSliceSize;
	4222
	4223	#if defined(SLICE_INFO_OUTPUT)
	4224	fprintf( stderr,
	4225	"@slice=%-6d sliceType:%c idc:%d size:%-6d\n",
	4226	iSliceIdx,
	4227	(pCtx->eSliceType == P_SLICE ? 'P' : 'I'),
	4228	eNalRefIdc,
	4229	iSliceSize );
	4230	#endif//SLICE_INFO_OUTPUT
	4231
	4232	++ iNalIdxInLayer;
	4233	iSliceIdx += kiSliceStep; //if uiSliceIdx is not continuous
	4234	iAnyMbLeftInPartition = iEndMbInPartition - (1 + pCurLayer->pLastCodedMbIdxOfPartition[kiPartitionId]);
	4235	}
	4236
	4237	*pLayerSize = iPartitionBsSize;
	4238	*pNalIdxInLayer = iNalIdxInLayer;
	4239
	4240	// slice based packing???
	4241	pLayerBsInfo->uiLayerType = VIDEO_CODING_LAYER;
	4242	pLayerBsInfo->uiSpatialId = pCtx->uiDependencyId;
	4243	pLayerBsInfo->uiTemporalId = pCtx->uiTemporalId;
	4244	pLayerBsInfo->uiQualityId = 0;
	4245	pLayerBsInfo->uiPriorityId = 0;
	4246	pLayerBsInfo->iNalCount = iNalIdxInLayer;
	4247
	4248	return 0;
	4249	}
	4250	} // namespace WelsSVCEnc

Initial Commit

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code