Context navigation

← Previous revision
Next revision →
Normal
Revision log

TEncSlice.cpp

Visit:

Last change on this file was 542, checked in by tech, 11 years ago
Further removal of unused macros.
Property svn:eol-style set to `native`
File size: 82.2 KB

Rev	Line
[324]	1	/* The copyright in this software is being made available under the BSD
	2	* License, included below. This software may be subject to other third party
	3	* and contributor rights, including patent rights, and no such rights are
	4	* granted under this license.
	5	*
	6	* Copyright (c) 2010-2013, ITU/ISO/IEC
	7	* All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions are met:
	11	*
	12	* * Redistributions of source code must retain the above copyright notice,
	13	* this list of conditions and the following disclaimer.
	14	* * Redistributions in binary form must reproduce the above copyright notice,
	15	* this list of conditions and the following disclaimer in the documentation
	16	* and/or other materials provided with the distribution.
	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
	18	* be used to endorse or promote products derived from this software without
	19	* specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	22	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
	25	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	28	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	29	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	30	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	31	* THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
	33
	34	/** \file TEncSlice.cpp
	35	\brief slice encoder class
	36	*/
	37
	38	#include "TEncTop.h"
	39	#include "TEncSlice.h"
	40	#include <math.h>
	41
	42	//! \ingroup TLibEncoder
	43	//! \{
	44
	45	// ====================================================================================================================
	46	// Constructor / destructor / create / destroy
	47	// ====================================================================================================================
	48
	49	TEncSlice::TEncSlice()
	50	{
	51	m_apcPicYuvPred = NULL;
	52	m_apcPicYuvResi = NULL;
	53
	54	m_pdRdPicLambda = NULL;
	55	m_pdRdPicQp = NULL;
	56	m_piRdPicQp = NULL;
	57	m_pcBufferSbacCoders = NULL;
	58	m_pcBufferBinCoderCABACs = NULL;
	59	m_pcBufferLowLatSbacCoders = NULL;
	60	m_pcBufferLowLatBinCoderCABACs = NULL;
	61	}
	62
	63	TEncSlice::~TEncSlice()
	64	{
	65	for (std::vector<TEncSbac*>::iterator i = CTXMem.begin(); i != CTXMem.end(); i++)
	66	{
	67	delete (*i);
	68	}
	69	}
	70
	71	Void TEncSlice::initCtxMem( UInt i )
	72	{
	73	for (std::vector<TEncSbac*>::iterator j = CTXMem.begin(); j != CTXMem.end(); j++)
	74	{
	75	delete (*j);
	76	}
	77	CTXMem.clear();
	78	CTXMem.resize(i);
	79	}
	80
	81	Void TEncSlice::create( Int iWidth, Int iHeight, UInt iMaxCUWidth, UInt iMaxCUHeight, UChar uhTotalDepth )
	82	{
	83	// create prediction picture
	84	if ( m_apcPicYuvPred == NULL )
	85	{
	86	m_apcPicYuvPred = new TComPicYuv;
	87	m_apcPicYuvPred->create( iWidth, iHeight, iMaxCUWidth, iMaxCUHeight, uhTotalDepth );
	88	}
	89
	90	// create residual picture
	91	if( m_apcPicYuvResi == NULL )
	92	{
	93	m_apcPicYuvResi = new TComPicYuv;
	94	m_apcPicYuvResi->create( iWidth, iHeight, iMaxCUWidth, iMaxCUHeight, uhTotalDepth );
	95	}
	96	}
	97
	98	Void TEncSlice::destroy()
	99	{
	100	// destroy prediction picture
	101	if ( m_apcPicYuvPred )
	102	{
	103	m_apcPicYuvPred->destroy();
	104	delete m_apcPicYuvPred;
	105	m_apcPicYuvPred = NULL;
	106	}
	107
	108	// destroy residual picture
	109	if ( m_apcPicYuvResi )
	110	{
	111	m_apcPicYuvResi->destroy();
	112	delete m_apcPicYuvResi;
	113	m_apcPicYuvResi = NULL;
	114	}
	115
	116	// free lambda and QP arrays
	117	if ( m_pdRdPicLambda ) { xFree( m_pdRdPicLambda ); m_pdRdPicLambda = NULL; }
	118	if ( m_pdRdPicQp ) { xFree( m_pdRdPicQp ); m_pdRdPicQp = NULL; }
	119	if ( m_piRdPicQp ) { xFree( m_piRdPicQp ); m_piRdPicQp = NULL; }
	120
	121	if ( m_pcBufferSbacCoders )
	122	{
	123	delete[] m_pcBufferSbacCoders;
	124	}
	125	if ( m_pcBufferBinCoderCABACs )
	126	{
	127	delete[] m_pcBufferBinCoderCABACs;
	128	}
	129	if ( m_pcBufferLowLatSbacCoders )
	130	delete[] m_pcBufferLowLatSbacCoders;
	131	if ( m_pcBufferLowLatBinCoderCABACs )
	132	delete[] m_pcBufferLowLatBinCoderCABACs;
	133	}
	134
	135	Void TEncSlice::init( TEncTop* pcEncTop )
	136	{
	137	m_pcCfg = pcEncTop;
	138	m_pcListPic = pcEncTop->getListPic();
	139
	140	m_pcGOPEncoder = pcEncTop->getGOPEncoder();
	141	m_pcCuEncoder = pcEncTop->getCuEncoder();
	142	m_pcPredSearch = pcEncTop->getPredSearch();
	143
	144	m_pcEntropyCoder = pcEncTop->getEntropyCoder();
	145	m_pcCavlcCoder = pcEncTop->getCavlcCoder();
	146	m_pcSbacCoder = pcEncTop->getSbacCoder();
	147	m_pcBinCABAC = pcEncTop->getBinCABAC();
	148	m_pcTrQuant = pcEncTop->getTrQuant();
	149
	150	m_pcBitCounter = pcEncTop->getBitCounter();
	151	m_pcRdCost = pcEncTop->getRdCost();
	152	m_pppcRDSbacCoder = pcEncTop->getRDSbacCoder();
	153	m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
	154
	155	// create lambda and QP arrays
	156	m_pdRdPicLambda = (Double)xMalloc( Double, m_pcCfg->getDeltaQpRD() 2 + 1 );
	157	m_pdRdPicQp = (Double)xMalloc( Double, m_pcCfg->getDeltaQpRD() 2 + 1 );
	158	m_piRdPicQp = (Int* )xMalloc( Int, m_pcCfg->getDeltaQpRD() * 2 + 1 );
	159	m_pcRateCtrl = pcEncTop->getRateCtrl();
	160	}
	161
	162	/**
	163	- non-referenced frame marking
	164	- QP computation based on temporal structure
	165	- lambda computation based on QP
	166	- set temporal layer ID and the parameter sets
	167	.
	168	\param pcPic picture class
	169	\param pocLast POC of last picture
	170	\param pocCurr current POC
	171	\param iNumPicRcvd number of received pictures
	172	\param iTimeOffset POC offset for hierarchical structure
	173	\param iDepth temporal layer depth
	174	\param rpcSlice slice header class
	175	\param pSPS SPS associated with the slice
	176	\param pPPS PPS associated with the slice
	177	*/
[542]	178	#if H_3D
[481]	179	Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice& rpcSlice, TComVPS pVPS, TComSPS* pSPS, TComPPS *pPPS, Int layerId )
[479]	180	#else
[324]	181	Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice& rpcSlice, TComSPS pSPS, TComPPS *pPPS )
[479]	182	#endif
[324]	183	{
	184	Double dQP;
	185	Double dLambda;
	186
	187	rpcSlice = pcPic->getSlice(0);
[542]	188	#if H_3D
[481]	189	// GT: Should also be activated for MV-HEVC at some stage
[479]	190	rpcSlice->setVPS( pVPS );
[481]	191	Int vpsLayerId = pVPS->getLayerIdInNuh( layerId );
	192
	193	rpcSlice->setLayerId ( layerId );
	194	rpcSlice->setViewId ( pVPS->getViewId ( vpsLayerId ) );
	195	rpcSlice->setViewIndex ( pVPS->getViewIndex ( vpsLayerId ) );
	196	rpcSlice->setIsDepth ( pVPS->getDepthId ( vpsLayerId ) != 0 );
[479]	197	#endif
[324]	198	rpcSlice->setSPS( pSPS );
	199	rpcSlice->setPPS( pPPS );
	200	rpcSlice->setSliceBits(0);
	201	rpcSlice->setPic( pcPic );
	202	rpcSlice->initSlice();
	203	rpcSlice->setPicOutputFlag( true );
	204	rpcSlice->setPOC( pocCurr );
[504]	205	#if H_3D_IC
	206	rpcSlice->setApplyIC( false );
	207	#endif
[324]	208	// depth computation based on GOP size
	209	Int depth;
	210	{
	211	Int poc = rpcSlice->getPOC()%m_pcCfg->getGOPSize();
	212	if ( poc == 0 )
	213	{
	214	depth = 0;
	215	}
	216	else
	217	{
	218	Int step = m_pcCfg->getGOPSize();
	219	depth = 0;
	220	for( Int i=step>>1; i>=1; i>>=1 )
	221	{
	222	for ( Int j=i; j<m_pcCfg->getGOPSize(); j+=step )
	223	{
	224	if ( j == poc )
	225	{
	226	i=0;
	227	break;
	228	}
	229	}
	230	step >>= 1;
	231	depth++;
	232	}
	233	}
	234	}
	235
	236	// slice type
[368]	237	#if H_MV
	238	SliceType eSliceTypeBaseView;
	239	if( pocLast == 0 \|\| pocCurr % m_pcCfg->getIntraPeriod() == 0 \|\| m_pcGOPEncoder->getGOPSize() == 0 )
	240	{
	241	eSliceTypeBaseView = I_SLICE;
	242	}
	243	else
	244	{
	245	eSliceTypeBaseView = B_SLICE;
	246	}
	247	SliceType eSliceType = eSliceTypeBaseView;
	248	if( eSliceTypeBaseView == I_SLICE && m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType != 'I' )
	249	{
	250	eSliceType = B_SLICE;
	251	}
	252	#else
[324]	253	SliceType eSliceType;
	254
	255	eSliceType=B_SLICE;
	256	eSliceType = (pocLast == 0 \|\| pocCurr % m_pcCfg->getIntraPeriod() == 0 \|\| m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
	257
	258	rpcSlice->setSliceType ( eSliceType );
[368]	259	#endif
[324]	260
	261	// ------------------------------------------------------------------------------------------------------------------
	262	// Non-referenced frame marking
	263	// ------------------------------------------------------------------------------------------------------------------
	264
	265	if(pocLast == 0)
	266	{
	267	rpcSlice->setTemporalLayerNonReferenceFlag(false);
	268	}
	269	else
	270	{
	271	#if 0 // Check this! H_MV
	272	rpcSlice->setTemporalLayerNonReferenceFlag(!m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_refPic);
	273	#else
	274	rpcSlice->setTemporalLayerNonReferenceFlag(!m_pcCfg->getGOPEntry(iGOPid).m_refPic);
	275	#endif
	276	}
	277	rpcSlice->setReferenced(true);
	278
	279	// ------------------------------------------------------------------------------------------------------------------
	280	// QP setting
	281	// ------------------------------------------------------------------------------------------------------------------
	282
	283	dQP = m_pcCfg->getQP();
	284	if(eSliceType!=I_SLICE)
	285	{
	286	if (!(( m_pcCfg->getMaxDeltaQP() == 0 ) && (dQP == -rpcSlice->getSPS()->getQpBDOffsetY() ) && (rpcSlice->getSPS()->getUseLossless())))
	287	{
[368]	288	#if H_MV
	289	dQP += m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_QPOffset;
	290	#else
[324]	291	dQP += m_pcCfg->getGOPEntry(iGOPid).m_QPOffset;
[368]	292	#endif
[324]	293	}
	294	}
	295
	296	// modify QP
	297	Int* pdQPs = m_pcCfg->getdQPs();
	298	if ( pdQPs )
	299	{
	300	dQP += pdQPs[ rpcSlice->getPOC() ];
	301	}
	302	#if !RATE_CONTROL_LAMBDA_DOMAIN
	303	if ( m_pcCfg->getUseRateCtrl())
	304	{
	305	dQP = m_pcRateCtrl->getFrameQP(rpcSlice->isReferenced(), rpcSlice->getPOC());
	306	}
	307	#endif
	308	// ------------------------------------------------------------------------------------------------------------------
	309	// Lambda computation
	310	// ------------------------------------------------------------------------------------------------------------------
	311
	312	Int iQP;
	313	Double dOrigQP = dQP;
	314
	315	// pre-compute lambda and QP values for all possible QP candidates
	316	for ( Int iDQpIdx = 0; iDQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; iDQpIdx++ )
	317	{
	318	// compute QP value
	319	dQP = dOrigQP + ((iDQpIdx+1)>>1)*(iDQpIdx%2 ? -1 : 1);
	320
	321	// compute lambda value
	322	Int NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
	323	Int SHIFT_QP = 12;
	324	Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
	325	#if FULL_NBIT
	326	Int bitdepth_luma_qp_scale = 6 * (g_bitDepth - 8);
	327	#else
	328	Int bitdepth_luma_qp_scale = 0;
	329	#endif
	330	Double qp_temp = (Double) dQP + bitdepth_luma_qp_scale - SHIFT_QP;
	331	#if FULL_NBIT
	332	Double qp_temp_orig = (Double) dQP - SHIFT_QP;
	333	#endif
	334	// Case #1: I or P-slices (key-frame)
[368]	335	#if H_MV
	336	Double dQPFactor;
	337	if( eSliceType != I_SLICE )
	338	{
	339	dQPFactor = m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_QPFactor;
	340	}
	341	else
	342	#else
[324]	343	Double dQPFactor = m_pcCfg->getGOPEntry(iGOPid).m_QPFactor;
	344	if ( eSliceType==I_SLICE )
[368]	345	#endif
[324]	346	{
	347	dQPFactor=0.57*dLambda_scale;
	348	}
	349	dLambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
	350
	351	if ( depth>0 )
	352	{
	353	#if FULL_NBIT
	354	dLambda *= Clip3( 2.00, 4.00, (qp_temp_orig / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
	355	#else
	356	dLambda *= Clip3( 2.00, 4.00, (qp_temp / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
	357	#endif
	358	}
	359
	360	// if hadamard is used in ME process
	361	if ( !m_pcCfg->getUseHADME() && rpcSlice->getSliceType( ) != I_SLICE )
	362	{
	363	dLambda *= 0.95;
	364	}
	365
	366	iQP = max( -pSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( dQP + 0.5 ) ) );
	367
	368	m_pdRdPicLambda[iDQpIdx] = dLambda;
	369	m_pdRdPicQp [iDQpIdx] = dQP;
	370	m_piRdPicQp [iDQpIdx] = iQP;
	371	}
	372
	373	// obtain dQP = 0 case
	374	dLambda = m_pdRdPicLambda[0];
	375	dQP = m_pdRdPicQp [0];
	376	iQP = m_piRdPicQp [0];
	377
	378	if( rpcSlice->getSliceType( ) != I_SLICE )
	379	{
[368]	380	#if H_MV
	381	dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_temporalId );
	382	#else
[324]	383	dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
[368]	384	#endif
[324]	385	}
	386
	387	// store lambda
	388	m_pcRdCost ->setLambda( dLambda );
[446]	389
	390	#if H_3D_VSO
	391	m_pcRdCost->setUseLambdaScaleVSO ( (m_pcCfg->getUseVSO() \|\| m_pcCfg->getForceLambdaScaleVSO()) && m_pcCfg->getIsDepth() );
	392	m_pcRdCost->setLambdaVSO ( dLambda * m_pcCfg->getLambdaScaleVSO() );
	393
	394	// Should be moved to TEncTop
	395
	396	// SAIT_VSO_EST_A0033
	397	m_pcRdCost->setDisparityCoeff( m_pcCfg->getDispCoeff() );
	398
	399	// LGE_WVSO_A0119
	400	if( m_pcCfg->getUseWVSO() && m_pcCfg->getIsDepth() )
	401	{
	402	m_pcRdCost->setDWeight ( m_pcCfg->getDWeight() );
	403	m_pcRdCost->setVSOWeight( m_pcCfg->getVSOWeight() );
	404	m_pcRdCost->setVSDWeight( m_pcCfg->getVSDWeight() );
	405	}
	406
	407	#endif
	408
[324]	409	#if WEIGHTED_CHROMA_DISTORTION
	410	// for RDO
	411	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	412	Double weight = 1.0;
	413	Int qpc;
	414	Int chromaQPOffset;
	415
	416	chromaQPOffset = rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb();
	417	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	418	weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	419	m_pcRdCost->setCbDistortionWeight(weight);
	420
	421	chromaQPOffset = rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr();
	422	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	423	weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	424	m_pcRdCost->setCrDistortionWeight(weight);
	425	#endif
	426
	427	#if RDOQ_CHROMA_LAMBDA
	428	// for RDOQ
	429	m_pcTrQuant->setLambda( dLambda, dLambda / weight );
	430	#else
	431	m_pcTrQuant->setLambda( dLambda );
	432	#endif
	433
	434	#if SAO_CHROMA_LAMBDA
	435	// For SAO
	436	rpcSlice ->setLambda( dLambda, dLambda / weight );
	437	#else
	438	rpcSlice ->setLambda( dLambda );
	439	#endif
	440
	441	#if HB_LAMBDA_FOR_LDC
	442	// restore original slice type
[368]	443	#if H_MV
	444	eSliceType = eSliceTypeBaseView;
	445	if( eSliceTypeBaseView == I_SLICE && m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType != 'I' )
	446	{
	447	eSliceType = B_SLICE;
	448	}
	449	#else
[324]	450	eSliceType = (pocLast == 0 \|\| pocCurr % m_pcCfg->getIntraPeriod() == 0 \|\| m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
[368]	451	#endif
[446]	452
[324]	453	rpcSlice->setSliceType ( eSliceType );
	454	#endif
	455
	456	if (m_pcCfg->getUseRecalculateQPAccordingToLambda())
	457	{
	458	dQP = xGetQPValueAccordingToLambda( dLambda );
	459	iQP = max( -pSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( dQP + 0.5 ) ) );
	460	}
	461
	462	rpcSlice->setSliceQp ( iQP );
	463	#if ADAPTIVE_QP_SELECTION
	464	rpcSlice->setSliceQpBase ( iQP );
	465	#endif
	466	rpcSlice->setSliceQpDelta ( 0 );
	467	rpcSlice->setSliceQpDeltaCb ( 0 );
	468	rpcSlice->setSliceQpDeltaCr ( 0 );
[368]	469	#if H_MV
	470	rpcSlice->setNumRefIdx(REF_PIC_LIST_0,m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_numRefPicsActive);
	471	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_numRefPicsActive);
	472	#else
[324]	473	rpcSlice->setNumRefIdx(REF_PIC_LIST_0,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);
	474	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);
[368]	475	#endif
[324]	476
[446]	477	if ( m_pcCfg->getDeblockingFilterMetric() )
	478	{
	479	rpcSlice->setDeblockingFilterOverrideFlag(true);
	480	rpcSlice->setDeblockingFilterDisable(false);
	481	rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
	482	rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
	483	} else
[324]	484	if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
	485	{
	486	rpcSlice->getPPS()->setDeblockingFilterOverrideEnabledFlag( !m_pcCfg->getLoopFilterOffsetInPPS() );
	487	rpcSlice->setDeblockingFilterOverrideFlag( !m_pcCfg->getLoopFilterOffsetInPPS() );
	488	rpcSlice->getPPS()->setPicDisableDeblockingFilterFlag( m_pcCfg->getLoopFilterDisable() );
	489	rpcSlice->setDeblockingFilterDisable( m_pcCfg->getLoopFilterDisable() );
	490	if ( !rpcSlice->getDeblockingFilterDisable())
	491	{
	492	if ( !m_pcCfg->getLoopFilterOffsetInPPS() && eSliceType!=I_SLICE)
	493	{
[368]	494	#if H_MV
	495	rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
	496	rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
	497	rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
	498	rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry((eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
	499	#else
[324]	500	rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
	501	rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
	502	rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
	503	rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
[368]	504	#endif
[324]	505	}
	506	else
	507	{
	508	rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getLoopFilterBetaOffset() );
	509	rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getLoopFilterTcOffset() );
	510	rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getLoopFilterBetaOffset() );
	511	rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getLoopFilterTcOffset() );
	512	}
	513	}
	514	}
	515	else
	516	{
	517	rpcSlice->setDeblockingFilterOverrideFlag( false );
	518	rpcSlice->setDeblockingFilterDisable( false );
	519	rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
	520	rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
	521	}
	522
	523	rpcSlice->setDepth ( depth );
	524
[368]	525	#if H_MV
	526	pcPic->setTLayer( m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_temporalId );
	527	#else
[324]	528	pcPic->setTLayer( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
[368]	529	#endif
[324]	530	if(eSliceType==I_SLICE)
	531	{
	532	pcPic->setTLayer(0);
	533	}
	534	rpcSlice->setTLayer( pcPic->getTLayer() );
	535
	536	assert( m_apcPicYuvPred );
	537	assert( m_apcPicYuvResi );
	538
	539	pcPic->setPicYuvPred( m_apcPicYuvPred );
	540	pcPic->setPicYuvResi( m_apcPicYuvResi );
	541	rpcSlice->setSliceMode ( m_pcCfg->getSliceMode() );
	542	rpcSlice->setSliceArgument ( m_pcCfg->getSliceArgument() );
	543	rpcSlice->setSliceSegmentMode ( m_pcCfg->getSliceSegmentMode() );
	544	rpcSlice->setSliceSegmentArgument ( m_pcCfg->getSliceSegmentArgument() );
[476]	545	#if H_3D_IV_MERGE
[486]	546	rpcSlice->setMaxNumMergeCand ( m_pcCfg->getMaxNumMergeCand() + ( rpcSlice->getVPS()->getIvMvPredFlag( rpcSlice->getLayerIdInVps() ) ? 1 : 0 ) );
[476]	547	#else
[324]	548	rpcSlice->setMaxNumMergeCand ( m_pcCfg->getMaxNumMergeCand() );
[476]	549	#endif
[324]	550	xStoreWPparam( pPPS->getUseWP(), pPPS->getWPBiPred() );
	551	}
	552
	553	#if RATE_CONTROL_LAMBDA_DOMAIN
	554	Void TEncSlice::resetQP( TComPic* pic, Int sliceQP, Double lambda )
	555	{
	556	TComSlice* slice = pic->getSlice(0);
	557
	558	// store lambda
	559	slice->setSliceQp( sliceQP );
	560	slice->setSliceQpBase ( sliceQP );
	561	m_pcRdCost ->setLambda( lambda );
	562	#if WEIGHTED_CHROMA_DISTORTION
	563	// for RDO
	564	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	565	Double weight;
	566	Int qpc;
	567	Int chromaQPOffset;
	568
	569	chromaQPOffset = slice->getPPS()->getChromaCbQpOffset() + slice->getSliceQpDeltaCb();
	570	qpc = Clip3( 0, 57, sliceQP + chromaQPOffset);
	571	weight = pow( 2.0, (sliceQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	572	m_pcRdCost->setCbDistortionWeight(weight);
	573
	574	chromaQPOffset = slice->getPPS()->getChromaCrQpOffset() + slice->getSliceQpDeltaCr();
	575	qpc = Clip3( 0, 57, sliceQP + chromaQPOffset);
	576	weight = pow( 2.0, (sliceQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	577	m_pcRdCost->setCrDistortionWeight(weight);
	578	#endif
	579
	580	#if RDOQ_CHROMA_LAMBDA
	581	// for RDOQ
	582	m_pcTrQuant->setLambda( lambda, lambda / weight );
	583	#else
	584	m_pcTrQuant->setLambda( lambda );
	585	#endif
	586
	587	#if SAO_CHROMA_LAMBDA
	588	// For SAO
	589	slice ->setLambda( lambda, lambda / weight );
	590	#else
	591	slice ->setLambda( lambda );
	592	#endif
	593	}
	594	#else
	595	/**
	596	- lambda re-computation based on rate control QP
	597	*/
	598	Void TEncSlice::xLamdaRecalculation(Int changeQP, Int idGOP, Int depth, SliceType eSliceType, TComSPS* pcSPS, TComSlice* pcSlice)
	599	{
	600	Int qp;
	601	Double recalQP= (Double)changeQP;
	602	Double origQP = (Double)recalQP;
	603	Double lambda;
	604
	605	// pre-compute lambda and QP values for all possible QP candidates
	606	for ( Int deltqQpIdx = 0; deltqQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; deltqQpIdx++ )
	607	{
	608	// compute QP value
	609	recalQP = origQP + ((deltqQpIdx+1)>>1)*(deltqQpIdx%2 ? -1 : 1);
	610
	611	// compute lambda value
	612	Int NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
	613	Int SHIFT_QP = 12;
	614	Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
	615	#if FULL_NBIT
	616	Int bitdepth_luma_qp_scale = 6 * (g_bitDepth - 8);
	617	#else
	618	Int bitdepth_luma_qp_scale = 0;
	619	#endif
	620	Double qp_temp = (Double) recalQP + bitdepth_luma_qp_scale - SHIFT_QP;
	621	#if FULL_NBIT
	622	Double qp_temp_orig = (Double) recalQP - SHIFT_QP;
	623	#endif
	624	// Case #1: I or P-slices (key-frame)
	625	Double dQPFactor = m_pcCfg->getGOPEntry(idGOP).m_QPFactor;
	626	if ( eSliceType==I_SLICE )
	627	{
	628	dQPFactor=0.57*dLambda_scale;
	629	}
	630	lambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
	631
	632	if ( depth>0 )
	633	{
	634	#if FULL_NBIT
	635	lambda *= Clip3( 2.00, 4.00, (qp_temp_orig / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
	636	#else
	637	lambda *= Clip3( 2.00, 4.00, (qp_temp / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
	638	#endif
	639	}
	640
	641	// if hadamard is used in ME process
	642	if ( !m_pcCfg->getUseHADME() )
	643	{
	644	lambda *= 0.95;
	645	}
	646
	647	qp = max( -pcSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( recalQP + 0.5 ) ) );
	648
	649	m_pdRdPicLambda[deltqQpIdx] = lambda;
	650	m_pdRdPicQp [deltqQpIdx] = recalQP;
	651	m_piRdPicQp [deltqQpIdx] = qp;
	652	}
	653
	654	// obtain dQP = 0 case
	655	lambda = m_pdRdPicLambda[0];
	656	recalQP = m_pdRdPicQp [0];
	657	qp = m_piRdPicQp [0];
	658
	659	if( pcSlice->getSliceType( ) != I_SLICE )
	660	{
	661	lambda *= m_pcCfg->getLambdaModifier( depth );
	662	}
	663
	664	// store lambda
	665	m_pcRdCost ->setLambda( lambda );
	666	#if WEIGHTED_CHROMA_DISTORTION
	667	// for RDO
	668	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	669	Double weight = 1.0;
	670	Int qpc;
	671	Int chromaQPOffset;
	672
	673	chromaQPOffset = pcSlice->getPPS()->getChromaCbQpOffset() + pcSlice->getSliceQpDeltaCb();
	674	qpc = Clip3( 0, 57, qp + chromaQPOffset);
	675	weight = pow( 2.0, (qp-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	676	m_pcRdCost->setCbDistortionWeight(weight);
	677
	678	chromaQPOffset = pcSlice->getPPS()->getChromaCrQpOffset() + pcSlice->getSliceQpDeltaCr();
	679	qpc = Clip3( 0, 57, qp + chromaQPOffset);
	680	weight = pow( 2.0, (qp-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	681	m_pcRdCost->setCrDistortionWeight(weight);
	682	#endif
	683
	684	#if RDOQ_CHROMA_LAMBDA
	685	// for RDOQ
	686	m_pcTrQuant->setLambda( lambda, lambda / weight );
	687	#else
	688	m_pcTrQuant->setLambda( lambda );
	689	#endif
	690
	691	#if SAO_CHROMA_LAMBDA
	692	// For SAO
	693	pcSlice ->setLambda( lambda, lambda / weight );
	694	#else
	695	pcSlice ->setLambda( lambda );
	696	#endif
	697	}
	698	#endif
	699	// ====================================================================================================================
	700	// Public member functions
	701	// ====================================================================================================================
	702
	703	Void TEncSlice::setSearchRange( TComSlice* pcSlice )
	704	{
	705	Int iCurrPOC = pcSlice->getPOC();
	706	Int iRefPOC;
	707	Int iGOPSize = m_pcCfg->getGOPSize();
	708	Int iOffset = (iGOPSize >> 1);
	709	Int iMaxSR = m_pcCfg->getSearchRange();
	710	Int iNumPredDir = pcSlice->isInterP() ? 1 : 2;
	711
	712	for (Int iDir = 0; iDir <= iNumPredDir; iDir++)
	713	{
	714	//RefPicList e = (RefPicList)iDir;
	715	RefPicList e = ( iDir ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
	716	for (Int iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(e); iRefIdx++)
	717	{
	718	iRefPOC = pcSlice->getRefPic(e, iRefIdx)->getPOC();
	719	Int iNewSR = Clip3(8, iMaxSR, (iMaxSRADAPT_SR_SCALEabs(iCurrPOC - iRefPOC)+iOffset)/iGOPSize);
	720	m_pcPredSearch->setAdaptiveSearchRange(iDir, iRefIdx, iNewSR);
	721	}
	722	}
	723	}
	724
	725	/**
	726	- multi-loop slice encoding for different slice QP
	727	.
	728	\param rpcPic picture class
	729	*/
	730	Void TEncSlice::precompressSlice( TComPic*& rpcPic )
	731	{
	732	// if deltaQP RD is not used, simply return
	733	if ( m_pcCfg->getDeltaQpRD() == 0 )
	734	{
	735	return;
	736	}
	737
	738	#if RATE_CONTROL_LAMBDA_DOMAIN
	739	if ( m_pcCfg->getUseRateCtrl() )
	740	{
	741	printf( "\nMultiple QP optimization is not allowed when rate control is enabled." );
	742	assert(0);
	743	}
	744	#endif
	745
	746	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	747	Double dPicRdCostBest = MAX_DOUBLE;
	748	UInt uiQpIdxBest = 0;
	749
	750	Double dFrameLambda;
	751	#if FULL_NBIT
	752	Int SHIFT_QP = 12 + 6 * (g_bitDepth - 8);
	753	#else
	754	Int SHIFT_QP = 12;
	755	#endif
	756
	757	// set frame lambda
	758	if (m_pcCfg->getGOPSize() > 1)
	759	{
	760	dFrameLambda = 0.68 * pow (2, (m_piRdPicQp[0] - SHIFT_QP) / 3.0) * (pcSlice->isInterB()? 2 : 1);
	761	}
	762	else
	763	{
	764	dFrameLambda = 0.68 * pow (2, (m_piRdPicQp[0] - SHIFT_QP) / 3.0);
	765	}
	766	m_pcRdCost ->setFrameLambda(dFrameLambda);
	767
	768	// for each QP candidate
	769	for ( UInt uiQpIdx = 0; uiQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; uiQpIdx++ )
	770	{
	771	pcSlice ->setSliceQp ( m_piRdPicQp [uiQpIdx] );
	772	#if ADAPTIVE_QP_SELECTION
	773	pcSlice ->setSliceQpBase ( m_piRdPicQp [uiQpIdx] );
	774	#endif
	775	m_pcRdCost ->setLambda ( m_pdRdPicLambda[uiQpIdx] );
	776	#if WEIGHTED_CHROMA_DISTORTION
	777	// for RDO
	778	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	779	Int iQP = m_piRdPicQp [uiQpIdx];
	780	Double weight = 1.0;
	781	Int qpc;
	782	Int chromaQPOffset;
	783
	784	chromaQPOffset = pcSlice->getPPS()->getChromaCbQpOffset() + pcSlice->getSliceQpDeltaCb();
	785	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	786	weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	787	m_pcRdCost->setCbDistortionWeight(weight);
	788
	789	chromaQPOffset = pcSlice->getPPS()->getChromaCrQpOffset() + pcSlice->getSliceQpDeltaCr();
	790	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	791	weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	792	m_pcRdCost->setCrDistortionWeight(weight);
	793	#endif
	794
	795	#if RDOQ_CHROMA_LAMBDA
	796	// for RDOQ
	797	m_pcTrQuant ->setLambda( m_pdRdPicLambda[uiQpIdx], m_pdRdPicLambda[uiQpIdx] / weight );
	798	#else
	799	m_pcTrQuant ->setLambda ( m_pdRdPicLambda[uiQpIdx] );
	800	#endif
	801	#if SAO_CHROMA_LAMBDA
	802	// For SAO
	803	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdx], m_pdRdPicLambda[uiQpIdx] / weight );
	804	#else
	805	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdx] );
	806	#endif
	807
	808	// try compress
	809	compressSlice ( rpcPic );
	810
	811	Double dPicRdCost;
[446]	812	#if H_3D_VSO
	813	Dist64 uiPicDist = m_uiPicDist;
	814	#else
[324]	815	UInt64 uiPicDist = m_uiPicDist;
[446]	816	#endif
[324]	817	UInt64 uiALFBits = 0;
	818
	819	m_pcGOPEncoder->preLoopFilterPicAll( rpcPic, uiPicDist, uiALFBits );
	820
	821	// compute RD cost and choose the best
	822	dPicRdCost = m_pcRdCost->calcRdCost64( m_uiPicTotalBits + uiALFBits, uiPicDist, true, DF_SSE_FRAME);
[446]	823	#if H_3D
	824	// Above calculation need to be fixed for VSO, including frameLambda value.
	825	#endif
[324]	826
	827	if ( dPicRdCost < dPicRdCostBest )
	828	{
	829	uiQpIdxBest = uiQpIdx;
	830	dPicRdCostBest = dPicRdCost;
	831	}
	832	}
	833
	834	// set best values
	835	pcSlice ->setSliceQp ( m_piRdPicQp [uiQpIdxBest] );
	836	#if ADAPTIVE_QP_SELECTION
	837	pcSlice ->setSliceQpBase ( m_piRdPicQp [uiQpIdxBest] );
	838	#endif
	839	m_pcRdCost ->setLambda ( m_pdRdPicLambda[uiQpIdxBest] );
	840	#if WEIGHTED_CHROMA_DISTORTION
	841	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	842	Int iQP = m_piRdPicQp [uiQpIdxBest];
	843	Double weight = 1.0;
	844	Int qpc;
	845	Int chromaQPOffset;
	846
	847	chromaQPOffset = pcSlice->getPPS()->getChromaCbQpOffset() + pcSlice->getSliceQpDeltaCb();
	848	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	849	weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	850	m_pcRdCost->setCbDistortionWeight(weight);
	851
	852	chromaQPOffset = pcSlice->getPPS()->getChromaCrQpOffset() + pcSlice->getSliceQpDeltaCr();
	853	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	854	weight = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 ); // takes into account of the chroma qp mapping and chroma qp Offset
	855	m_pcRdCost->setCrDistortionWeight(weight);
	856	#endif
	857
	858	#if RDOQ_CHROMA_LAMBDA
	859	// for RDOQ
	860	m_pcTrQuant ->setLambda( m_pdRdPicLambda[uiQpIdxBest], m_pdRdPicLambda[uiQpIdxBest] / weight );
	861	#else
	862	m_pcTrQuant ->setLambda ( m_pdRdPicLambda[uiQpIdxBest] );
	863	#endif
	864	#if SAO_CHROMA_LAMBDA
	865	// For SAO
	866	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdxBest], m_pdRdPicLambda[uiQpIdxBest] / weight );
	867	#else
	868	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdxBest] );
	869	#endif
	870	}
	871
	872	/** \param rpcPic picture class
	873	*/
[537]	874	#if RATE_CONTROL_INTRA
	875	Void TEncSlice::calCostSliceI(TComPic*& rpcPic)
	876	{
	877	UInt uiCUAddr;
	878	UInt uiStartCUAddr;
	879	UInt uiBoundingCUAddr;
	880	Int iSumHad, shift = g_bitDepthY-8, offset = (shift>0)?(1<<(shift-1)):0;;
	881	Double iSumHadSlice = 0;
	882
	883	rpcPic->getSlice(getSliceIdx())->setSliceSegmentBits(0);
	884	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	885	xDetermineStartAndBoundingCUAddr ( uiStartCUAddr, uiBoundingCUAddr, rpcPic, false );
	886
	887	UInt uiEncCUOrder;
	888	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());
	889	for( uiEncCUOrder = uiStartCUAddr/rpcPic->getNumPartInCU();
	890	uiEncCUOrder < (uiBoundingCUAddr+(rpcPic->getNumPartInCU()-1))/rpcPic->getNumPartInCU();
	891	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
	892	{
	893	// initialize CU encoder
	894	TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
	895	pcCU->initCU( rpcPic, uiCUAddr );
	896
	897	Int height = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
	898	Int width = min( pcSlice->getSPS()->getMaxCUWidth(),pcSlice->getSPS()->getPicWidthInLumaSamples() - uiCUAddr % rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUWidth() );
	899
	900	iSumHad = m_pcCuEncoder->updateLCUDataISlice(pcCU, uiCUAddr, width, height);
	901
	902	(m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr)).m_costIntra=(iSumHad+offset)>>shift;
	903	iSumHadSlice += (m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr)).m_costIntra;
	904
	905	}
	906	m_pcRateCtrl->getRCPic()->setTotalIntraCost(iSumHadSlice);
	907	}
	908	#endif
	909
[324]	910	Void TEncSlice::compressSlice( TComPic*& rpcPic )
	911	{
	912	UInt uiCUAddr;
	913	UInt uiStartCUAddr;
	914	UInt uiBoundingCUAddr;
	915	rpcPic->getSlice(getSliceIdx())->setSliceSegmentBits(0);
	916	TEncBinCABAC* pppcRDSbacCoder = NULL;
	917	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	918	xDetermineStartAndBoundingCUAddr ( uiStartCUAddr, uiBoundingCUAddr, rpcPic, false );
	919
	920	// initialize cost values
	921	m_uiPicTotalBits = 0;
	922	m_dPicRdCost = 0;
	923	m_uiPicDist = 0;
	924
	925	// set entropy coder
	926	if( m_pcCfg->getUseSBACRD() )
	927	{
	928	m_pcSbacCoder->init( m_pcBinCABAC );
	929	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	930	m_pcEntropyCoder->resetEntropy ();
	931	m_pppcRDSbacCoder[0][CI_CURR_BEST]->load(m_pcSbacCoder);
	932	pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
	933	pppcRDSbacCoder->setBinCountingEnableFlag( false );
	934	pppcRDSbacCoder->setBinsCoded( 0 );
	935	}
	936	else
	937	{
	938	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
	939	m_pcEntropyCoder->resetEntropy ();
	940	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
	941	}
	942
	943	//------------------------------------------------------------------------------
	944	// Weighted Prediction parameters estimation.
	945	//------------------------------------------------------------------------------
	946	// calculate AC/DC values for current picture
	947	if( pcSlice->getPPS()->getUseWP() \|\| pcSlice->getPPS()->getWPBiPred() )
	948	{
	949	xCalcACDCParamSlice(pcSlice);
	950	}
	951
	952	Bool bWp_explicit = (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) \|\| (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPred());
	953
	954	if ( bWp_explicit )
	955	{
	956	//------------------------------------------------------------------------------
	957	// Weighted Prediction implemented at Slice level. SliceMode=2 is not supported yet.
	958	//------------------------------------------------------------------------------
	959	if ( pcSlice->getSliceMode()==2 \|\| pcSlice->getSliceSegmentMode()==2 )
	960	{
	961	printf("Weighted Prediction is not supported with slice mode determined by max number of bins.\n"); exit(0);
	962	}
	963
	964	xEstimateWPParamSlice( pcSlice );
	965	pcSlice->initWpScaling();
	966
	967	// check WP on/off
	968	xCheckWPEnable( pcSlice );
	969	}
	970
	971	#if ADAPTIVE_QP_SELECTION
	972	if( m_pcCfg->getUseAdaptQpSelect() )
	973	{
	974	m_pcTrQuant->clearSliceARLCnt();
	975	if(pcSlice->getSliceType()!=I_SLICE)
	976	{
	977	Int qpBase = pcSlice->getSliceQpBase();
	978	pcSlice->setSliceQp(qpBase + m_pcTrQuant->getQpDelta(qpBase));
	979	}
	980	}
	981	#endif
	982	TEncTop* pcEncTop = (TEncTop*) m_pcCfg;
	983	TEncSbac**** ppppcRDSbacCoders = pcEncTop->getRDSbacCoders();
	984	TComBitCounter* pcBitCounters = pcEncTop->getBitCounters();
	985	Int iNumSubstreams = 1;
	986	UInt uiTilesAcross = 0;
[504]	987	#if H_3D_IC
	988	if ( pcEncTop->getViewIndex() && pcEncTop->getUseIC() &&
	989	!( ( pcSlice->getSliceType() == P_SLICE && pcSlice->getPPS()->getUseWP() ) \|\| ( pcSlice->getSliceType() == B_SLICE && pcSlice->getPPS()->getWPBiPred() ) )
	990	)
	991	{
	992	pcSlice ->xSetApplyIC();
	993	if ( pcSlice->getApplyIC() )
	994	{
	995	pcSlice->setIcSkipParseFlag( pcSlice->getPOC() % m_pcCfg->getIntraPeriod() != 0 );
	996	}
	997	}
	998	#endif
[324]	999	if( m_pcCfg->getUseSBACRD() )
	1000	{
	1001	iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
	1002	uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
	1003	delete[] m_pcBufferSbacCoders;
	1004	delete[] m_pcBufferBinCoderCABACs;
	1005	m_pcBufferSbacCoders = new TEncSbac [uiTilesAcross];
	1006	m_pcBufferBinCoderCABACs = new TEncBinCABAC[uiTilesAcross];
	1007	for (Int ui = 0; ui < uiTilesAcross; ui++)
	1008	{
	1009	m_pcBufferSbacCoders[ui].init( &m_pcBufferBinCoderCABACs[ui] );
	1010	}
	1011	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	1012	{
	1013	m_pcBufferSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]); //init. state
	1014	}
	1015
	1016	for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ ) //init all sbac coders for RD optimization
	1017	{
	1018	ppppcRDSbacCoders[ui][0][CI_CURR_BEST]->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
	1019	}
	1020	}
	1021	//if( m_pcCfg->getUseSBACRD() )
	1022	{
	1023	delete[] m_pcBufferLowLatSbacCoders;
	1024	delete[] m_pcBufferLowLatBinCoderCABACs;
	1025	m_pcBufferLowLatSbacCoders = new TEncSbac [uiTilesAcross];
	1026	m_pcBufferLowLatBinCoderCABACs = new TEncBinCABAC[uiTilesAcross];
	1027	for (Int ui = 0; ui < uiTilesAcross; ui++)
	1028	{
	1029	m_pcBufferLowLatSbacCoders[ui].init( &m_pcBufferLowLatBinCoderCABACs[ui] );
	1030	}
	1031	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	1032	m_pcBufferLowLatSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]); //init. state
	1033	}
	1034	UInt uiWidthInLCUs = rpcPic->getPicSym()->getFrameWidthInCU();
	1035	//UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();
	1036	UInt uiCol=0, uiLin=0, uiSubStrm=0;
	1037	UInt uiTileCol = 0;
	1038	UInt uiTileStartLCU = 0;
	1039	UInt uiTileLCUX = 0;
	1040	Bool depSliceSegmentsEnabled = pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag();
	1041	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());
	1042	uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
	1043	if( depSliceSegmentsEnabled )
	1044	{
	1045	if((pcSlice->getSliceSegmentCurStartCUAddr()!= pcSlice->getSliceCurStartCUAddr())&&(uiCUAddr != uiTileStartLCU))
	1046	{
	1047	if( m_pcCfg->getWaveFrontsynchro() )
	1048	{
	1049	uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);
	1050	m_pcBufferSbacCoders[uiTileCol].loadContexts( CTXMem[1] );
	1051	Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
	1052	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());
	1053	uiLin = uiCUAddr / uiWidthInLCUs;
	1054	uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(rpcPic->getPicSym()->getCUOrderMap(uiCUAddr))*iNumSubstreamsPerTile
	1055	+ uiLin%iNumSubstreamsPerTile;
	1056	if ( (uiCUAddr%uiWidthInLCUs+1) >= uiWidthInLCUs )
	1057	{
	1058	uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
	1059	uiCol = uiCUAddr % uiWidthInLCUs;
	1060	if(uiCol==uiTileStartLCU)
	1061	{
	1062	CTXMem[0]->loadContexts(m_pcSbacCoder);
	1063	}
	1064	}
	1065	}
	1066	m_pppcRDSbacCoder[0][CI_CURR_BEST]->loadContexts( CTXMem[0] );
	1067	ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->loadContexts( CTXMem[0] );
	1068	}
	1069	else
	1070	{
	1071	if(m_pcCfg->getWaveFrontsynchro())
	1072	{
	1073	CTXMem[1]->loadContexts(m_pcSbacCoder);
	1074	}
	1075	CTXMem[0]->loadContexts(m_pcSbacCoder);
	1076	}
	1077	}
	1078	// for every CU in slice
[446]	1079	#if H_3D
	1080	Int iLastPosY = -1;
	1081	#endif
[324]	1082	UInt uiEncCUOrder;
	1083	for( uiEncCUOrder = uiStartCUAddr/rpcPic->getNumPartInCU();
	1084	uiEncCUOrder < (uiBoundingCUAddr+(rpcPic->getNumPartInCU()-1))/rpcPic->getNumPartInCU();
	1085	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
	1086	{
	1087	// initialize CU encoder
	1088	TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
	1089	pcCU->initCU( rpcPic, uiCUAddr );
[446]	1090	#if H_3D_VSO
	1091	if ( m_pcRdCost->getUseRenModel() )
	1092	{
	1093	// updated renderer model if necessary
	1094	Int iCurPosX;
	1095	Int iCurPosY;
	1096	pcCU->getPosInPic(0, iCurPosX, iCurPosY );
	1097	if ( iCurPosY != iLastPosY )
	1098	{
	1099	iLastPosY = iCurPosY;
	1100	pcEncTop->setupRenModel( pcSlice->getPOC() , pcSlice->getViewIndex(), pcSlice->getIsDepth() ? 1 : 0, iCurPosY );
	1101	}
	1102	}
	1103	#endif
[324]	1104	#if !RATE_CONTROL_LAMBDA_DOMAIN
	1105	if(m_pcCfg->getUseRateCtrl())
	1106	{
	1107	if(m_pcRateCtrl->calculateUnitQP())
	1108	{
	1109	xLamdaRecalculation(m_pcRateCtrl->getUnitQP(), m_pcRateCtrl->getGOPId(), pcSlice->getDepth(), pcSlice->getSliceType(), pcSlice->getSPS(), pcSlice );
	1110	}
	1111	}
	1112	#endif
	1113	// inherit from TR if necessary, select substream to use.
	1114	if( m_pcCfg->getUseSBACRD() )
	1115	{
	1116	uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
	1117	uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
	1118	uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
	1119	//UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
	1120	uiCol = uiCUAddr % uiWidthInLCUs;
	1121	uiLin = uiCUAddr / uiWidthInLCUs;
	1122	if (pcSlice->getPPS()->getNumSubstreams() > 1)
	1123	{
	1124	// independent tiles => substreams are "per tile". iNumSubstreams has already been multiplied.
	1125	Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
	1126	uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)*iNumSubstreamsPerTile
	1127	+ uiLin%iNumSubstreamsPerTile;
	1128	}
	1129	else
	1130	{
	1131	// dependent tiles => substreams are "per frame".
	1132	uiSubStrm = uiLin % iNumSubstreams;
	1133	}
	1134	if ( ((pcSlice->getPPS()->getNumSubstreams() > 1) \|\| depSliceSegmentsEnabled ) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())
	1135	{
	1136	// We'll sync if the TR is available.
	1137	TComDataCU *pcCUUp = pcCU->getCUAbove();
	1138	UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
	1139	UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
	1140	TComDataCU *pcCUTR = NULL;
	1141	if ( pcCUUp && ((uiCUAddr%uiWidthInCU+1) < uiWidthInCU) )
	1142	{
	1143	pcCUTR = rpcPic->getCU( uiCUAddr - uiWidthInCU + 1 );
	1144	}
	1145	if ( ((pcCUTR==NULL) \|\| (pcCUTR->getSlice()==NULL) \|\|
	1146	(pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getSliceCurStartCUAddr()) \|\|
	1147	((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))
	1148	)
	1149	)
	1150	{
	1151	// TR not available.
	1152	}
	1153	else
	1154	{
	1155	// TR is available, we use it.
	1156	ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->loadContexts( &m_pcBufferSbacCoders[uiTileCol] );
	1157	}
	1158	}
	1159	m_pppcRDSbacCoder[0][CI_CURR_BEST]->load( ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST] ); //this load is used to simplify the code
	1160	}
	1161
	1162	// reset the entropy coder
	1163	if( uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr() && // must be first CU of tile
	1164	uiCUAddr!=0 && // cannot be first CU of picture
	1165	uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceSegmentCurStartCUAddr())/rpcPic->getNumPartInCU() &&
	1166	uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU()) // cannot be first CU of slice
	1167	{
	1168	SliceType sliceType = pcSlice->getSliceType();
	1169	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag() && pcSlice->getPPS()->getEncCABACTableIdx()!=I_SLICE)
	1170	{
	1171	sliceType = (SliceType) pcSlice->getPPS()->getEncCABACTableIdx();
	1172	}
	1173	m_pcEntropyCoder->updateContextTables ( sliceType, pcSlice->getSliceQp(), false );
	1174	m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );
	1175	m_pcEntropyCoder->updateContextTables ( sliceType, pcSlice->getSliceQp() );
	1176	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	1177	}
	1178	// if RD based on SBAC is used
	1179	if( m_pcCfg->getUseSBACRD() )
	1180	{
	1181	// set go-on entropy coder
	1182	m_pcEntropyCoder->setEntropyCoder ( m_pcRDGoOnSbacCoder, pcSlice );
	1183	m_pcEntropyCoder->setBitstream( &pcBitCounters[uiSubStrm] );
	1184
	1185	((TEncBinCABAC*)m_pcRDGoOnSbacCoder->getEncBinIf())->setBinCountingEnableFlag(true);
	1186
	1187	#if RATE_CONTROL_LAMBDA_DOMAIN
	1188	Double oldLambda = m_pcRdCost->getLambda();
	1189	if ( m_pcCfg->getUseRateCtrl() )
	1190	{
	1191	Int estQP = pcSlice->getSliceQp();
	1192	Double estLambda = -1.0;
	1193	Double bpp = -1.0;
	1194
[537]	1195	#if M0036_RC_IMPROVEMENT
	1196	if ( ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE && m_pcCfg->getForceIntraQP() ) \|\| !m_pcCfg->getLCULevelRC() )
	1197	#else
[324]	1198	if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE \|\| !m_pcCfg->getLCULevelRC() )
[537]	1199	#endif
[324]	1200	{
	1201	estQP = pcSlice->getSliceQp();
	1202	}
	1203	else
	1204	{
[537]	1205	#if RATE_CONTROL_INTRA
	1206	bpp = m_pcRateCtrl->getRCPic()->getLCUTargetBpp(pcSlice->getSliceType());
	1207	if ( rpcPic->getSlice( 0 )->getSliceType() == I_SLICE)
	1208	{
	1209	estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambdaAndQP(bpp, pcSlice->getSliceQp(), &estQP);
	1210	}
	1211	else
	1212	{
	1213	estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
	1214	estQP = m_pcRateCtrl->getRCPic()->getLCUEstQP ( estLambda, pcSlice->getSliceQp() );
	1215	}
	1216	#else
[324]	1217	bpp = m_pcRateCtrl->getRCPic()->getLCUTargetBpp();
	1218	estLambda = m_pcRateCtrl->getRCPic()->getLCUEstLambda( bpp );
	1219	estQP = m_pcRateCtrl->getRCPic()->getLCUEstQP ( estLambda, pcSlice->getSliceQp() );
[537]	1220	#endif
	1221
[324]	1222	estQP = Clip3( -pcSlice->getSPS()->getQpBDOffsetY(), MAX_QP, estQP );
	1223
	1224	m_pcRdCost->setLambda(estLambda);
[537]	1225	#if M0036_RC_IMPROVEMENT
	1226	#if RDOQ_CHROMA_LAMBDA
	1227	// set lambda for RDOQ
	1228	Double weight=m_pcRdCost->getChromaWeight();
	1229	m_pcTrQuant->setLambda( estLambda, estLambda / weight );
	1230	#else
	1231	m_pcTrQuant->setLambda( estLambda );
	1232	#endif
	1233	#endif
[324]	1234	}
	1235
	1236	m_pcRateCtrl->setRCQP( estQP );
	1237	pcCU->getSlice()->setSliceQpBase( estQP );
	1238	}
	1239	#endif
	1240
	1241	// run CU encoder
	1242	m_pcCuEncoder->compressCU( pcCU );
	1243
[537]	1244	#if !TICKET_1090_FIX
[324]	1245	#if RATE_CONTROL_LAMBDA_DOMAIN
	1246	if ( m_pcCfg->getUseRateCtrl() )
	1247	{
[537]	1248	#if !M0036_RC_IMPROVEMENT
[324]	1249	UInt SAD = m_pcCuEncoder->getLCUPredictionSAD();
	1250	Int height = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
	1251	Int width = min( pcSlice->getSPS()->getMaxCUWidth(),pcSlice->getSPS()->getPicWidthInLumaSamples() - uiCUAddr % rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUWidth() );
	1252	Double MAD = (Double)SAD / (Double)(height * width);
	1253	MAD = MAD * MAD;
	1254	( m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr) ).m_MAD = MAD;
[537]	1255	#endif
[324]	1256
	1257	Int actualQP = g_RCInvalidQPValue;
	1258	Double actualLambda = m_pcRdCost->getLambda();
	1259	Int actualBits = pcCU->getTotalBits();
	1260	Int numberOfEffectivePixels = 0;
	1261	for ( Int idx = 0; idx < rpcPic->getNumPartInCU(); idx++ )
	1262	{
	1263	if ( pcCU->getPredictionMode( idx ) != MODE_NONE && ( !pcCU->isSkipped( idx ) ) )
	1264	{
	1265	numberOfEffectivePixels = numberOfEffectivePixels + 16;
	1266	break;
	1267	}
	1268	}
	1269
	1270	if ( numberOfEffectivePixels == 0 )
	1271	{
	1272	actualQP = g_RCInvalidQPValue;
	1273	}
	1274	else
	1275	{
	1276	actualQP = pcCU->getQP( 0 );
	1277	}
	1278	m_pcRdCost->setLambda(oldLambda);
[537]	1279	#if RATE_CONTROL_INTRA
	1280	m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
	1281	pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
	1282	#else
[324]	1283	m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda, m_pcCfg->getLCULevelRC() );
[537]	1284	#endif
[324]	1285	}
	1286	#endif
[537]	1287	#endif
[324]	1288
	1289	// restore entropy coder to an initial stage
	1290	m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );
	1291	m_pcEntropyCoder->setBitstream( &pcBitCounters[uiSubStrm] );
	1292	m_pcCuEncoder->setBitCounter( &pcBitCounters[uiSubStrm] );
	1293	m_pcBitCounter = &pcBitCounters[uiSubStrm];
	1294	pppcRDSbacCoder->setBinCountingEnableFlag( true );
	1295	m_pcBitCounter->resetBits();
	1296	pppcRDSbacCoder->setBinsCoded( 0 );
	1297	m_pcCuEncoder->encodeCU( pcCU );
	1298
	1299	pppcRDSbacCoder->setBinCountingEnableFlag( false );
	1300	if (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_BYTES && ( ( pcSlice->getSliceBits() + m_pcEntropyCoder->getNumberOfWrittenBits() ) ) > m_pcCfg->getSliceArgument()<<3)
	1301	{
	1302	pcSlice->setNextSlice( true );
	1303	break;
	1304	}
	1305	if (m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES && pcSlice->getSliceSegmentBits()+m_pcEntropyCoder->getNumberOfWrittenBits() > (m_pcCfg->getSliceSegmentArgument() << 3) &&pcSlice->getSliceCurEndCUAddr()!=pcSlice->getSliceSegmentCurEndCUAddr())
	1306	{
	1307	pcSlice->setNextSliceSegment( true );
	1308	break;
	1309	}
	1310	if( m_pcCfg->getUseSBACRD() )
	1311	{
	1312	ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
	1313
	1314	//Store probabilties of second LCU in line into buffer
	1315	if ( ( uiCol == uiTileLCUX+1) && (depSliceSegmentsEnabled \|\| (pcSlice->getPPS()->getNumSubstreams() > 1)) && m_pcCfg->getWaveFrontsynchro())
	1316	{
	1317	m_pcBufferSbacCoders[uiTileCol].loadContexts(ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]);
	1318	}
	1319	}
[537]	1320
	1321	#if TICKET_1090_FIX
	1322	#if RATE_CONTROL_LAMBDA_DOMAIN
	1323	if ( m_pcCfg->getUseRateCtrl() )
	1324	{
	1325	#if !M0036_RC_IMPROVEMENT
	1326	UInt SAD = m_pcCuEncoder->getLCUPredictionSAD();
	1327	Int height = min( pcSlice->getSPS()->getMaxCUHeight(),pcSlice->getSPS()->getPicHeightInLumaSamples() - uiCUAddr / rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUHeight() );
	1328	Int width = min( pcSlice->getSPS()->getMaxCUWidth(),pcSlice->getSPS()->getPicWidthInLumaSamples() - uiCUAddr % rpcPic->getFrameWidthInCU() * pcSlice->getSPS()->getMaxCUWidth() );
	1329	Double MAD = (Double)SAD / (Double)(height * width);
	1330	MAD = MAD * MAD;
	1331	( m_pcRateCtrl->getRCPic()->getLCU(uiCUAddr) ).m_MAD = MAD;
	1332	#endif
	1333
	1334	Int actualQP = g_RCInvalidQPValue;
	1335	Double actualLambda = m_pcRdCost->getLambda();
	1336	Int actualBits = pcCU->getTotalBits();
	1337	Int numberOfEffectivePixels = 0;
	1338	for ( Int idx = 0; idx < rpcPic->getNumPartInCU(); idx++ )
	1339	{
	1340	if ( pcCU->getPredictionMode( idx ) != MODE_NONE && ( !pcCU->isSkipped( idx ) ) )
	1341	{
	1342	numberOfEffectivePixels = numberOfEffectivePixels + 16;
	1343	break;
	1344	}
	1345	}
	1346
	1347	if ( numberOfEffectivePixels == 0 )
	1348	{
	1349	actualQP = g_RCInvalidQPValue;
	1350	}
	1351	else
	1352	{
	1353	actualQP = pcCU->getQP( 0 );
	1354	}
	1355	m_pcRdCost->setLambda(oldLambda);
	1356
	1357	#if RATE_CONTROL_INTRA
	1358	m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda,
	1359	pcCU->getSlice()->getSliceType() == I_SLICE ? 0 : m_pcCfg->getLCULevelRC() );
	1360	#else
	1361	m_pcRateCtrl->getRCPic()->updateAfterLCU( m_pcRateCtrl->getRCPic()->getLCUCoded(), actualBits, actualQP, actualLambda, m_pcCfg->getLCULevelRC() );
	1362	#endif
	1363	}
	1364	#endif
	1365	#endif
[324]	1366	}
	1367	// other case: encodeCU is not called
	1368	else
	1369	{
	1370	m_pcCuEncoder->compressCU( pcCU );
	1371	m_pcCuEncoder->encodeCU( pcCU );
	1372	if (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_BYTES && ( ( pcSlice->getSliceBits()+ m_pcEntropyCoder->getNumberOfWrittenBits() ) ) > m_pcCfg->getSliceArgument()<<3)
	1373	{
	1374	pcSlice->setNextSlice( true );
	1375	break;
	1376	}
	1377	if (m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES && pcSlice->getSliceSegmentBits()+ m_pcEntropyCoder->getNumberOfWrittenBits()> m_pcCfg->getSliceSegmentArgument()<<3 &&pcSlice->getSliceCurEndCUAddr()!=pcSlice->getSliceSegmentCurEndCUAddr())
	1378	{
	1379	pcSlice->setNextSliceSegment( true );
	1380	break;
	1381	}
	1382	}
	1383
	1384	m_uiPicTotalBits += pcCU->getTotalBits();
	1385	m_dPicRdCost += pcCU->getTotalCost();
	1386	m_uiPicDist += pcCU->getTotalDistortion();
	1387	#if !RATE_CONTROL_LAMBDA_DOMAIN
	1388	if(m_pcCfg->getUseRateCtrl())
	1389	{
	1390	m_pcRateCtrl->updateLCUData(pcCU, pcCU->getTotalBits(), pcCU->getQP(0));
	1391	m_pcRateCtrl->updataRCUnitStatus();
	1392	}
	1393	#endif
	1394	}
	1395	if ((pcSlice->getPPS()->getNumSubstreams() > 1) && !depSliceSegmentsEnabled)
	1396	{
	1397	pcSlice->setNextSlice( true );
	1398	}
	1399	if( depSliceSegmentsEnabled )
	1400	{
	1401	if (m_pcCfg->getWaveFrontsynchro())
	1402	{
	1403	CTXMem[1]->loadContexts( &m_pcBufferSbacCoders[uiTileCol] );//ctx 2.LCU
	1404	}
	1405	CTXMem[0]->loadContexts( m_pppcRDSbacCoder[0][CI_CURR_BEST] );//ctx end of dep.slice
	1406	}
	1407	xRestoreWPparam( pcSlice );
	1408	#if !RATE_CONTROL_LAMBDA_DOMAIN
	1409	if(m_pcCfg->getUseRateCtrl())
	1410	{
	1411	m_pcRateCtrl->updateFrameData(m_uiPicTotalBits);
	1412	}
	1413	#endif
	1414	}
	1415
	1416	/**
	1417	\param rpcPic picture class
	1418	\retval rpcBitstream bitstream class
	1419	*/
[446]	1420	Void TEncSlice::encodeSlice ( TComPic& rpcPic, TComOutputBitstream pcSubstreams )
[324]	1421	{
	1422	UInt uiCUAddr;
	1423	UInt uiStartCUAddr;
	1424	UInt uiBoundingCUAddr;
	1425	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	1426
	1427	uiStartCUAddr=pcSlice->getSliceSegmentCurStartCUAddr();
	1428	uiBoundingCUAddr=pcSlice->getSliceSegmentCurEndCUAddr();
	1429	// choose entropy coder
	1430	{
	1431	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
	1432	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	1433	}
	1434
	1435	m_pcCuEncoder->setBitCounter( NULL );
	1436	m_pcBitCounter = NULL;
	1437	// Appropriate substream bitstream is switched later.
	1438	// for every CU
	1439	#if ENC_DEC_TRACE
	1440	g_bJustDoIt = g_bEncDecTraceEnable;
	1441	#endif
	1442	DTRACE_CABAC_VL( g_nSymbolCounter++ );
	1443	DTRACE_CABAC_T( "\tPOC: " );
	1444	DTRACE_CABAC_V( rpcPic->getPOC() );
[521]	1445	#if H_MV_ENC_DEC_TRAC
	1446	DTRACE_CABAC_T( " Layer: " );
	1447	DTRACE_CABAC_V( rpcPic->getLayerId() );
	1448	#endif
[324]	1449	DTRACE_CABAC_T( "\n" );
	1450	#if ENC_DEC_TRACE
	1451	g_bJustDoIt = g_bEncDecTraceDisable;
	1452	#endif
	1453
	1454	TEncTop* pcEncTop = (TEncTop*) m_pcCfg;
	1455	TEncSbac* pcSbacCoders = pcEncTop->getSbacCoders(); //coder for each substream
	1456	Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
	1457	UInt uiBitsOriginallyInSubstreams = 0;
	1458	{
	1459	UInt uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
	1460	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	1461	{
	1462	m_pcBufferSbacCoders[ui].load(m_pcSbacCoder); //init. state
	1463	}
	1464
	1465	for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
	1466	{
	1467	uiBitsOriginallyInSubstreams += pcSubstreams[iSubstrmIdx].getNumberOfWrittenBits();
	1468	}
	1469
	1470	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	1471	{
	1472	m_pcBufferLowLatSbacCoders[ui].load(m_pcSbacCoder); //init. state
	1473	}
	1474	}
	1475
	1476	UInt uiWidthInLCUs = rpcPic->getPicSym()->getFrameWidthInCU();
	1477	UInt uiCol=0, uiLin=0, uiSubStrm=0;
	1478	UInt uiTileCol = 0;
	1479	UInt uiTileStartLCU = 0;
	1480	UInt uiTileLCUX = 0;
	1481	Bool depSliceSegmentsEnabled = pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag();
	1482	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU()); /* for tiles, uiStartCUAddr is NOT the real raster scan address, it is actually
	1483	an encoding order index, so we need to convert the index (uiStartCUAddr)
	1484	into the real raster scan address (uiCUAddr) via the CUOrderMap */
	1485	uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
	1486	if( depSliceSegmentsEnabled )
	1487	{
	1488	if( pcSlice->isNextSlice()\|\|
	1489	uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr())
	1490	{
	1491	if(m_pcCfg->getWaveFrontsynchro())
	1492	{
	1493	CTXMem[1]->loadContexts(m_pcSbacCoder);
	1494	}
	1495	CTXMem[0]->loadContexts(m_pcSbacCoder);
	1496	}
	1497	else
	1498	{
	1499	if(m_pcCfg->getWaveFrontsynchro())
	1500	{
	1501	uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1);
	1502	m_pcBufferSbacCoders[uiTileCol].loadContexts( CTXMem[1] );
	1503	Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
	1504	uiLin = uiCUAddr / uiWidthInLCUs;
	1505	uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(rpcPic->getPicSym()->getCUOrderMap( uiCUAddr))*iNumSubstreamsPerTile
	1506	+ uiLin%iNumSubstreamsPerTile;
	1507	if ( (uiCUAddr%uiWidthInLCUs+1) >= uiWidthInLCUs )
	1508	{
	1509	uiCol = uiCUAddr % uiWidthInLCUs;
	1510	uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
	1511	if(uiCol==uiTileLCUX)
	1512	{
	1513	CTXMem[0]->loadContexts(m_pcSbacCoder);
	1514	}
	1515	}
	1516	}
	1517	pcSbacCoders[uiSubStrm].loadContexts( CTXMem[0] );
	1518	}
	1519	}
	1520
	1521	UInt uiEncCUOrder;
	1522	for( uiEncCUOrder = uiStartCUAddr /rpcPic->getNumPartInCU();
	1523	uiEncCUOrder < (uiBoundingCUAddr+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU();
	1524	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
	1525	{
	1526	if( m_pcCfg->getUseSBACRD() )
	1527	{
	1528	uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
	1529	uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
	1530	uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
	1531	//UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
	1532	uiCol = uiCUAddr % uiWidthInLCUs;
	1533	uiLin = uiCUAddr / uiWidthInLCUs;
	1534	if (pcSlice->getPPS()->getNumSubstreams() > 1)
	1535	{
	1536	// independent tiles => substreams are "per tile". iNumSubstreams has already been multiplied.
	1537	Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
	1538	uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)*iNumSubstreamsPerTile
	1539	+ uiLin%iNumSubstreamsPerTile;
	1540	}
	1541	else
	1542	{
	1543	// dependent tiles => substreams are "per frame".
	1544	uiSubStrm = uiLin % iNumSubstreams;
	1545	}
	1546
	1547	m_pcEntropyCoder->setBitstream( &pcSubstreams[uiSubStrm] );
	1548	// Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
	1549	if (((pcSlice->getPPS()->getNumSubstreams() > 1) \|\| depSliceSegmentsEnabled) && (uiCol == uiTileLCUX) && m_pcCfg->getWaveFrontsynchro())
	1550	{
	1551	// We'll sync if the TR is available.
	1552	TComDataCU *pcCUUp = rpcPic->getCU( uiCUAddr )->getCUAbove();
	1553	UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
	1554	UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
	1555	TComDataCU *pcCUTR = NULL;
	1556	if ( pcCUUp && ((uiCUAddr%uiWidthInCU+1) < uiWidthInCU) )
	1557	{
	1558	pcCUTR = rpcPic->getCU( uiCUAddr - uiWidthInCU + 1 );
	1559	}
	1560	if ( (true/bEnforceSliceRestriction/ &&
	1561	((pcCUTR==NULL) \|\| (pcCUTR->getSlice()==NULL) \|\|
	1562	(pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getSliceCurStartCUAddr()) \|\|
	1563	((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))
	1564	))
	1565	)
	1566	{
	1567	// TR not available.
	1568	}
	1569	else
	1570	{
	1571	// TR is available, we use it.
	1572	pcSbacCoders[uiSubStrm].loadContexts( &m_pcBufferSbacCoders[uiTileCol] );
	1573	}
	1574	}
	1575	m_pcSbacCoder->load(&pcSbacCoders[uiSubStrm]); //this load is used to simplify the code (avoid to change all the call to m_pcSbacCoder)
	1576	}
	1577	// reset the entropy coder
	1578	if( uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr() && // must be first CU of tile
	1579	uiCUAddr!=0 && // cannot be first CU of picture
	1580	uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceSegmentCurStartCUAddr())/rpcPic->getNumPartInCU() &&
	1581	uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU()) // cannot be first CU of slice
	1582	{
	1583	{
	1584	// We're crossing into another tile, tiles are independent.
	1585	// When tiles are independent, we have "substreams per tile". Each substream has already been terminated, and we no longer
	1586	// have to perform it here.
	1587	if (pcSlice->getPPS()->getNumSubstreams() > 1)
	1588	{
	1589	; // do nothing.
	1590	}
	1591	else
	1592	{
	1593	SliceType sliceType = pcSlice->getSliceType();
	1594	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag() && pcSlice->getPPS()->getEncCABACTableIdx()!=I_SLICE)
	1595	{
	1596	sliceType = (SliceType) pcSlice->getPPS()->getEncCABACTableIdx();
	1597	}
	1598	m_pcEntropyCoder->updateContextTables( sliceType, pcSlice->getSliceQp() );
	1599	// Byte-alignment in slice_data() when new tile
	1600	pcSubstreams[uiSubStrm].writeByteAlignment();
	1601	}
	1602	}
	1603	{
[446]	1604	UInt numStartCodeEmulations = pcSubstreams[uiSubStrm].countStartCodeEmulations();
[324]	1605	UInt uiAccumulatedSubstreamLength = 0;
	1606	for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
	1607	{
	1608	uiAccumulatedSubstreamLength += pcSubstreams[iSubstrmIdx].getNumberOfWrittenBits();
	1609	}
	1610	// add bits coded in previous dependent slices + bits coded so far
	1611	// add number of emulation prevention byte count in the tile
[446]	1612	pcSlice->addTileLocation( ((pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3) + numStartCodeEmulations );
[324]	1613	}
	1614	}
	1615
[539]	1616	#if H_3D_QTLPC
	1617	rpcPic->setReduceBitsFlag(true);
	1618	#endif
[324]	1619	TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
	1620	if ( pcSlice->getSPS()->getUseSAO() && (pcSlice->getSaoEnabledFlag()\|\|pcSlice->getSaoEnabledFlagChroma()) )
	1621	{
	1622	SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
	1623	Int iNumCuInWidth = saoParam->numCuInWidth;
	1624	Int iCUAddrInSlice = uiCUAddr - rpcPic->getPicSym()->getCUOrderMap(pcSlice->getSliceCurStartCUAddr()/rpcPic->getNumPartInCU());
	1625	Int iCUAddrUpInSlice = iCUAddrInSlice - iNumCuInWidth;
	1626	Int rx = uiCUAddr % iNumCuInWidth;
	1627	Int ry = uiCUAddr / iNumCuInWidth;
	1628	Int allowMergeLeft = 1;
	1629	Int allowMergeUp = 1;
	1630	if (rx!=0)
	1631	{
	1632	if (rpcPic->getPicSym()->getTileIdxMap(uiCUAddr-1) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))
	1633	{
	1634	allowMergeLeft = 0;
	1635	}
	1636	}
	1637	if (ry!=0)
	1638	{
	1639	if (rpcPic->getPicSym()->getTileIdxMap(uiCUAddr-iNumCuInWidth) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))
	1640	{
	1641	allowMergeUp = 0;
	1642	}
	1643	}
	1644	Int addr = pcCU->getAddr();
	1645	allowMergeLeft = allowMergeLeft && (rx>0) && (iCUAddrInSlice!=0);
	1646	allowMergeUp = allowMergeUp && (ry>0) && (iCUAddrUpInSlice>=0);
	1647	if( saoParam->bSaoFlag[0] \|\| saoParam->bSaoFlag[1] )
	1648	{
	1649	Int mergeLeft = saoParam->saoLcuParam[0][addr].mergeLeftFlag;
	1650	Int mergeUp = saoParam->saoLcuParam[0][addr].mergeUpFlag;
	1651	if (allowMergeLeft)
	1652	{
	1653	m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(mergeLeft);
	1654	}
	1655	else
	1656	{
	1657	mergeLeft = 0;
	1658	}
	1659	if(mergeLeft == 0)
	1660	{
	1661	if (allowMergeUp)
	1662	{
	1663	m_pcEntropyCoder->m_pcEntropyCoderIf->codeSaoMerge(mergeUp);
	1664	}
	1665	else
	1666	{
	1667	mergeUp = 0;
	1668	}
	1669	if(mergeUp == 0)
	1670	{
	1671	for (Int compIdx=0;compIdx<3;compIdx++)
	1672	{
	1673	if( (compIdx == 0 && saoParam->bSaoFlag[0]) \|\| (compIdx > 0 && saoParam->bSaoFlag[1]))
	1674	{
	1675	m_pcEntropyCoder->encodeSaoOffset(&saoParam->saoLcuParam[compIdx][addr], compIdx);
	1676	}
	1677	}
	1678	}
	1679	}
	1680	}
	1681	}
	1682	else if (pcSlice->getSPS()->getUseSAO())
	1683	{
	1684	Int addr = pcCU->getAddr();
	1685	SAOParam *saoParam = pcSlice->getPic()->getPicSym()->getSaoParam();
	1686	for (Int cIdx=0; cIdx<3; cIdx++)
	1687	{
	1688	SaoLcuParam *saoLcuParam = &(saoParam->saoLcuParam[cIdx][addr]);
	1689	if ( ((cIdx == 0) && !pcSlice->getSaoEnabledFlag()) \|\| ((cIdx == 1 \|\| cIdx == 2) && !pcSlice->getSaoEnabledFlagChroma()))
	1690	{
	1691	saoLcuParam->mergeUpFlag = 0;
	1692	saoLcuParam->mergeLeftFlag = 0;
	1693	saoLcuParam->subTypeIdx = 0;
	1694	saoLcuParam->typeIdx = -1;
	1695	saoLcuParam->offset[0] = 0;
	1696	saoLcuParam->offset[1] = 0;
	1697	saoLcuParam->offset[2] = 0;
	1698	saoLcuParam->offset[3] = 0;
	1699	}
	1700	}
	1701	}
	1702	#if ENC_DEC_TRACE
	1703	g_bJustDoIt = g_bEncDecTraceEnable;
	1704	#endif
	1705	if ( (m_pcCfg->getSliceMode()!=0 \|\| m_pcCfg->getSliceSegmentMode()!=0) &&
	1706	uiCUAddr == rpcPic->getPicSym()->getCUOrderMap((uiBoundingCUAddr+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU()-1) )
	1707	{
	1708	m_pcCuEncoder->encodeCU( pcCU );
	1709	}
	1710	else
	1711	{
	1712	m_pcCuEncoder->encodeCU( pcCU );
	1713	}
	1714	#if ENC_DEC_TRACE
	1715	g_bJustDoIt = g_bEncDecTraceDisable;
	1716	#endif
	1717	if( m_pcCfg->getUseSBACRD() )
	1718	{
	1719	pcSbacCoders[uiSubStrm].load(m_pcSbacCoder); //load back status of the entropy coder after encoding the LCU into relevant bitstream entropy coder
	1720
	1721
	1722	//Store probabilties of second LCU in line into buffer
	1723	if ( (depSliceSegmentsEnabled \|\| (pcSlice->getPPS()->getNumSubstreams() > 1)) && (uiCol == uiTileLCUX+1) && m_pcCfg->getWaveFrontsynchro())
	1724	{
	1725	m_pcBufferSbacCoders[uiTileCol].loadContexts( &pcSbacCoders[uiSubStrm] );
	1726	}
	1727	}
[539]	1728	#if H_3D_QTLPC
	1729	rpcPic->setReduceBitsFlag(false);
	1730	#endif
[324]	1731	}
	1732	if( depSliceSegmentsEnabled )
	1733	{
	1734	if (m_pcCfg->getWaveFrontsynchro())
	1735	{
	1736	CTXMem[1]->loadContexts( &m_pcBufferSbacCoders[uiTileCol] );//ctx 2.LCU
	1737	}
	1738	CTXMem[0]->loadContexts( m_pcSbacCoder );//ctx end of dep.slice
	1739	}
	1740	#if ADAPTIVE_QP_SELECTION
	1741	if( m_pcCfg->getUseAdaptQpSelect() )
	1742	{
	1743	m_pcTrQuant->storeSliceQpNext(pcSlice);
	1744	}
	1745	#endif
	1746	if (pcSlice->getPPS()->getCabacInitPresentFlag())
	1747	{
	1748	if (pcSlice->getPPS()->getDependentSliceSegmentsEnabledFlag())
	1749	{
	1750	pcSlice->getPPS()->setEncCABACTableIdx( pcSlice->getSliceType() );
	1751	}
	1752	else
	1753	{
	1754	m_pcEntropyCoder->determineCabacInitIdx();
	1755	}
	1756	}
	1757	}
	1758
	1759	/** Determines the starting and bounding LCU address of current slice / dependent slice
	1760	* \param bEncodeSlice Identifies if the calling function is compressSlice() [false] or encodeSlice() [true]
	1761	* \returns Updates uiStartCUAddr, uiBoundingCUAddr with appropriate LCU address
	1762	*/
	1763	Void TEncSlice::xDetermineStartAndBoundingCUAddr ( UInt& startCUAddr, UInt& boundingCUAddr, TComPic*& rpcPic, Bool bEncodeSlice )
	1764	{
	1765	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	1766	UInt uiStartCUAddrSlice, uiBoundingCUAddrSlice;
	1767	UInt tileIdxIncrement;
	1768	UInt tileIdx;
	1769	UInt tileWidthInLcu;
	1770	UInt tileHeightInLcu;
	1771	UInt tileTotalCount;
	1772
	1773	uiStartCUAddrSlice = pcSlice->getSliceCurStartCUAddr();
	1774	UInt uiNumberOfCUsInFrame = rpcPic->getNumCUsInFrame();
	1775	uiBoundingCUAddrSlice = uiNumberOfCUsInFrame;
	1776	if (bEncodeSlice)
	1777	{
	1778	UInt uiCUAddrIncrement;
	1779	switch (m_pcCfg->getSliceMode())
	1780	{
	1781	case FIXED_NUMBER_OF_LCU:
	1782	uiCUAddrIncrement = m_pcCfg->getSliceArgument();
	1783	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1784	break;
	1785	case FIXED_NUMBER_OF_BYTES:
	1786	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1787	uiBoundingCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
	1788	break;
	1789	case FIXED_NUMBER_OF_TILES:
	1790	tileIdx = rpcPic->getPicSym()->getTileIdxMap(
	1791	rpcPic->getPicSym()->getCUOrderMap(uiStartCUAddrSlice/rpcPic->getNumPartInCU())
	1792	);
	1793	uiCUAddrIncrement = 0;
	1794	tileTotalCount = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1);
	1795
	1796	for(tileIdxIncrement = 0; tileIdxIncrement < m_pcCfg->getSliceArgument(); tileIdxIncrement++)
	1797	{
	1798	if((tileIdx + tileIdxIncrement) < tileTotalCount)
	1799	{
	1800	tileWidthInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth();
	1801	tileHeightInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight();
	1802	uiCUAddrIncrement += (tileWidthInLcu * tileHeightInLcu * rpcPic->getNumPartInCU());
	1803	}
	1804	}
	1805
	1806	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1807	break;
	1808	default:
	1809	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1810	uiBoundingCUAddrSlice = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
	1811	break;
	1812	}
	1813	// WPP: if a slice does not start at the beginning of a CTB row, it must end within the same CTB row
	1814	if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiStartCUAddrSlice % (rpcPic->getFrameWidthInCU()*rpcPic->getNumPartInCU()) != 0))
	1815	{
	1816	uiBoundingCUAddrSlice = min(uiBoundingCUAddrSlice, uiStartCUAddrSlice - (uiStartCUAddrSlice % (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU())) + (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU()));
	1817	}
	1818	pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice );
	1819	}
	1820	else
	1821	{
	1822	UInt uiCUAddrIncrement ;
	1823	switch (m_pcCfg->getSliceMode())
	1824	{
	1825	case FIXED_NUMBER_OF_LCU:
	1826	uiCUAddrIncrement = m_pcCfg->getSliceArgument();
	1827	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1828	break;
	1829	case FIXED_NUMBER_OF_TILES:
	1830	tileIdx = rpcPic->getPicSym()->getTileIdxMap(
	1831	rpcPic->getPicSym()->getCUOrderMap(uiStartCUAddrSlice/rpcPic->getNumPartInCU())
	1832	);
	1833	uiCUAddrIncrement = 0;
	1834	tileTotalCount = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1);
	1835
	1836	for(tileIdxIncrement = 0; tileIdxIncrement < m_pcCfg->getSliceArgument(); tileIdxIncrement++)
	1837	{
	1838	if((tileIdx + tileIdxIncrement) < tileTotalCount)
	1839	{
	1840	tileWidthInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth();
	1841	tileHeightInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight();
	1842	uiCUAddrIncrement += (tileWidthInLcu * tileHeightInLcu * rpcPic->getNumPartInCU());
	1843	}
	1844	}
	1845
	1846	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1847	break;
	1848	default:
	1849	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1850	uiBoundingCUAddrSlice = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
	1851	break;
	1852	}
	1853	// WPP: if a slice does not start at the beginning of a CTB row, it must end within the same CTB row
	1854	if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiStartCUAddrSlice % (rpcPic->getFrameWidthInCU()*rpcPic->getNumPartInCU()) != 0))
	1855	{
	1856	uiBoundingCUAddrSlice = min(uiBoundingCUAddrSlice, uiStartCUAddrSlice - (uiStartCUAddrSlice % (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU())) + (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU()));
	1857	}
	1858	pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice );
	1859	}
	1860
	1861	Bool tileBoundary = false;
	1862	if ((m_pcCfg->getSliceMode() == FIXED_NUMBER_OF_LCU \|\| m_pcCfg->getSliceMode() == FIXED_NUMBER_OF_BYTES) &&
	1863	(m_pcCfg->getNumRowsMinus1() > 0 \|\| m_pcCfg->getNumColumnsMinus1() > 0))
	1864	{
	1865	UInt lcuEncAddr = (uiStartCUAddrSlice+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU();
	1866	UInt lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddr);
	1867	UInt startTileIdx = rpcPic->getPicSym()->getTileIdxMap(lcuAddr);
	1868	UInt tileBoundingCUAddrSlice = 0;
	1869	while (lcuEncAddr < uiNumberOfCUsInFrame && rpcPic->getPicSym()->getTileIdxMap(lcuAddr) == startTileIdx)
	1870	{
	1871	lcuEncAddr++;
	1872	lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddr);
	1873	}
	1874	tileBoundingCUAddrSlice = lcuEncAddr*rpcPic->getNumPartInCU();
	1875
	1876	if (tileBoundingCUAddrSlice < uiBoundingCUAddrSlice)
	1877	{
	1878	uiBoundingCUAddrSlice = tileBoundingCUAddrSlice;
	1879	pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice );
	1880	tileBoundary = true;
	1881	}
	1882	}
	1883
	1884	// Dependent slice
	1885	UInt startCUAddrSliceSegment, boundingCUAddrSliceSegment;
	1886	startCUAddrSliceSegment = pcSlice->getSliceSegmentCurStartCUAddr();
	1887	boundingCUAddrSliceSegment = uiNumberOfCUsInFrame;
	1888	if (bEncodeSlice)
	1889	{
	1890	UInt uiCUAddrIncrement;
	1891	switch (m_pcCfg->getSliceSegmentMode())
	1892	{
	1893	case FIXED_NUMBER_OF_LCU:
	1894	uiCUAddrIncrement = m_pcCfg->getSliceSegmentArgument();
	1895	boundingCUAddrSliceSegment = ((startCUAddrSliceSegment + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU() ) ? (startCUAddrSliceSegment + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1896	break;
	1897	case FIXED_NUMBER_OF_BYTES:
	1898	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1899	boundingCUAddrSliceSegment = pcSlice->getSliceSegmentCurEndCUAddr();
	1900	break;
	1901	case FIXED_NUMBER_OF_TILES:
	1902	tileIdx = rpcPic->getPicSym()->getTileIdxMap(
	1903	rpcPic->getPicSym()->getCUOrderMap(pcSlice->getSliceSegmentCurStartCUAddr()/rpcPic->getNumPartInCU())
	1904	);
	1905	uiCUAddrIncrement = 0;
	1906	tileTotalCount = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1);
	1907
	1908	for(tileIdxIncrement = 0; tileIdxIncrement < m_pcCfg->getSliceSegmentArgument(); tileIdxIncrement++)
	1909	{
	1910	if((tileIdx + tileIdxIncrement) < tileTotalCount)
	1911	{
	1912	tileWidthInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth();
	1913	tileHeightInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight();
	1914	uiCUAddrIncrement += (tileWidthInLcu * tileHeightInLcu * rpcPic->getNumPartInCU());
	1915	}
	1916	}
	1917	boundingCUAddrSliceSegment = ((startCUAddrSliceSegment + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU() ) ? (startCUAddrSliceSegment + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1918	break;
	1919	default:
	1920	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1921	boundingCUAddrSliceSegment = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
	1922	break;
	1923	}
	1924	// WPP: if a slice segment does not start at the beginning of a CTB row, it must end within the same CTB row
	1925	if (pcSlice->getPPS()->getNumSubstreams() > 1 && (startCUAddrSliceSegment % (rpcPic->getFrameWidthInCU()*rpcPic->getNumPartInCU()) != 0))
	1926	{
	1927	boundingCUAddrSliceSegment = min(boundingCUAddrSliceSegment, startCUAddrSliceSegment - (startCUAddrSliceSegment % (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU())) + (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU()));
	1928	}
	1929	pcSlice->setSliceSegmentCurEndCUAddr( boundingCUAddrSliceSegment );
	1930	}
	1931	else
	1932	{
	1933	UInt uiCUAddrIncrement;
	1934	switch (m_pcCfg->getSliceSegmentMode())
	1935	{
	1936	case FIXED_NUMBER_OF_LCU:
	1937	uiCUAddrIncrement = m_pcCfg->getSliceSegmentArgument();
	1938	boundingCUAddrSliceSegment = ((startCUAddrSliceSegment + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU() ) ? (startCUAddrSliceSegment + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1939	break;
	1940	case FIXED_NUMBER_OF_TILES:
	1941	tileIdx = rpcPic->getPicSym()->getTileIdxMap(
	1942	rpcPic->getPicSym()->getCUOrderMap(pcSlice->getSliceSegmentCurStartCUAddr()/rpcPic->getNumPartInCU())
	1943	);
	1944	uiCUAddrIncrement = 0;
	1945	tileTotalCount = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1);
	1946
	1947	for(tileIdxIncrement = 0; tileIdxIncrement < m_pcCfg->getSliceSegmentArgument(); tileIdxIncrement++)
	1948	{
	1949	if((tileIdx + tileIdxIncrement) < tileTotalCount)
	1950	{
	1951	tileWidthInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth();
	1952	tileHeightInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight();
	1953	uiCUAddrIncrement += (tileWidthInLcu * tileHeightInLcu * rpcPic->getNumPartInCU());
	1954	}
	1955	}
	1956	boundingCUAddrSliceSegment = ((startCUAddrSliceSegment + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU() ) ? (startCUAddrSliceSegment + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1957	break;
	1958	default:
	1959	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1960	boundingCUAddrSliceSegment = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
	1961	break;
	1962	}
	1963	// WPP: if a slice segment does not start at the beginning of a CTB row, it must end within the same CTB row
	1964	if (pcSlice->getPPS()->getNumSubstreams() > 1 && (startCUAddrSliceSegment % (rpcPic->getFrameWidthInCU()*rpcPic->getNumPartInCU()) != 0))
	1965	{
	1966	boundingCUAddrSliceSegment = min(boundingCUAddrSliceSegment, startCUAddrSliceSegment - (startCUAddrSliceSegment % (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU())) + (rpcPic->getFrameWidthInCU()rpcPic->getNumPartInCU()));
	1967	}
	1968	pcSlice->setSliceSegmentCurEndCUAddr( boundingCUAddrSliceSegment );
	1969	}
	1970	if ((m_pcCfg->getSliceSegmentMode() == FIXED_NUMBER_OF_LCU \|\| m_pcCfg->getSliceSegmentMode() == FIXED_NUMBER_OF_BYTES) &&
	1971	(m_pcCfg->getNumRowsMinus1() > 0 \|\| m_pcCfg->getNumColumnsMinus1() > 0))
	1972	{
	1973	UInt lcuEncAddr = (startCUAddrSliceSegment+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU();
	1974	UInt lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddr);
	1975	UInt startTileIdx = rpcPic->getPicSym()->getTileIdxMap(lcuAddr);
	1976	UInt tileBoundingCUAddrSlice = 0;
	1977	while (lcuEncAddr < uiNumberOfCUsInFrame && rpcPic->getPicSym()->getTileIdxMap(lcuAddr) == startTileIdx)
	1978	{
	1979	lcuEncAddr++;
	1980	lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddr);
	1981	}
	1982	tileBoundingCUAddrSlice = lcuEncAddr*rpcPic->getNumPartInCU();
	1983
	1984	if (tileBoundingCUAddrSlice < boundingCUAddrSliceSegment)
	1985	{
	1986	boundingCUAddrSliceSegment = tileBoundingCUAddrSlice;
	1987	pcSlice->setSliceSegmentCurEndCUAddr( boundingCUAddrSliceSegment );
	1988	tileBoundary = true;
	1989	}
	1990	}
	1991
	1992	if(boundingCUAddrSliceSegment>uiBoundingCUAddrSlice)
	1993	{
	1994	boundingCUAddrSliceSegment = uiBoundingCUAddrSlice;
	1995	pcSlice->setSliceSegmentCurEndCUAddr(uiBoundingCUAddrSlice);
	1996	}
	1997
	1998	//calculate real dependent slice start address
	1999	UInt uiInternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurStartCUAddr()) % rpcPic->getNumPartInCU();
	2000	UInt uiExternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurStartCUAddr()) / rpcPic->getNumPartInCU();
	2001	UInt uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	2002	UInt uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	2003	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	2004	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
	2005	while((uiPosX>=uiWidth\|\|uiPosY>=uiHeight)&&!(uiPosX>=uiWidth&&uiPosY>=uiHeight))
	2006	{
	2007	uiInternalAddress++;
	2008	if(uiInternalAddress>=rpcPic->getNumPartInCU())
	2009	{
	2010	uiInternalAddress=0;
	2011	uiExternalAddress = rpcPic->getPicSym()->getCUOrderMap(rpcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
	2012	}
	2013	uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	2014	uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	2015	}
	2016	UInt uiRealStartAddress = rpcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*rpcPic->getNumPartInCU()+uiInternalAddress);
	2017
	2018	pcSlice->setSliceSegmentCurStartCUAddr(uiRealStartAddress);
	2019	startCUAddrSliceSegment=uiRealStartAddress;
	2020
	2021	//calculate real slice start address
	2022	uiInternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceCurStartCUAddr()) % rpcPic->getNumPartInCU();
	2023	uiExternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceCurStartCUAddr()) / rpcPic->getNumPartInCU();
	2024	uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	2025	uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	2026	uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	2027	uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
	2028	while((uiPosX>=uiWidth\|\|uiPosY>=uiHeight)&&!(uiPosX>=uiWidth&&uiPosY>=uiHeight))
	2029	{
	2030	uiInternalAddress++;
	2031	if(uiInternalAddress>=rpcPic->getNumPartInCU())
	2032	{
	2033	uiInternalAddress=0;
	2034	uiExternalAddress = rpcPic->getPicSym()->getCUOrderMap(rpcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
	2035	}
	2036	uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	2037	uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	2038	}
	2039	uiRealStartAddress = rpcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*rpcPic->getNumPartInCU()+uiInternalAddress);
	2040
	2041	pcSlice->setSliceCurStartCUAddr(uiRealStartAddress);
	2042	uiStartCUAddrSlice=uiRealStartAddress;
	2043
	2044	// Make a joint decision based on reconstruction and dependent slice bounds
	2045	startCUAddr = max(uiStartCUAddrSlice , startCUAddrSliceSegment );
	2046	boundingCUAddr = min(uiBoundingCUAddrSlice, boundingCUAddrSliceSegment);
	2047
	2048
	2049	if (!bEncodeSlice)
	2050	{
	2051	// For fixed number of LCU within an entropy and reconstruction slice we already know whether we will encounter end of entropy and/or reconstruction slice
	2052	// first. Set the flags accordingly.
	2053	if ( (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU)
	2054	\|\| (m_pcCfg->getSliceMode()==0 && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU)
	2055	\|\| (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_LCU && m_pcCfg->getSliceSegmentMode()==0)
	2056	\|\| (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_TILES && m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_LCU)
	2057	\|\| (m_pcCfg->getSliceMode()==FIXED_NUMBER_OF_TILES && m_pcCfg->getSliceSegmentMode()==0)
	2058	\|\| (m_pcCfg->getSliceSegmentMode()==FIXED_NUMBER_OF_TILES && m_pcCfg->getSliceMode()==0)
	2059	\|\| tileBoundary
	2060	)
	2061	{
	2062	if (uiBoundingCUAddrSlice < boundingCUAddrSliceSegment)
	2063	{
	2064	pcSlice->setNextSlice ( true );
	2065	pcSlice->setNextSliceSegment( false );
	2066	}
	2067	else if (uiBoundingCUAddrSlice > boundingCUAddrSliceSegment)
	2068	{
	2069	pcSlice->setNextSlice ( false );
	2070	pcSlice->setNextSliceSegment( true );
	2071	}
	2072	else
	2073	{
	2074	pcSlice->setNextSlice ( true );
	2075	pcSlice->setNextSliceSegment( true );
	2076	}
	2077	}
	2078	else
	2079	{
	2080	pcSlice->setNextSlice ( false );
	2081	pcSlice->setNextSliceSegment( false );
	2082	}
	2083	}
	2084	}
	2085
	2086	Double TEncSlice::xGetQPValueAccordingToLambda ( Double lambda )
	2087	{
	2088	return 4.2005*log(lambda) + 13.7122;
	2089	}
	2090
	2091	//! \}

Note: See TracBrowser for help on using the repository browser.

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/Lib/TLibEncoder/TEncSlice.cpp

Download in other formats: