Context navigation

TEncSlice.cpp @ 1399

Visit:

Last change on this file since 1399 was 294, checked in by tech, 12 years ago
Removed HM-6.1 related guard macros.
Property svn:eol-style set to `native`
File size: 58.0 KB

Rev	Line
[5]	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
[56]	4	* granted under this license.
[5]	5	*
[56]	6	* Copyright (c) 2010-2012, ITU/ISO/IEC
[5]	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.
[56]	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]	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	*/
[2]	33
	34	/** \file TEncSlice.cpp
	35	\brief slice encoder class
	36	*/
	37
	38	#include "TEncTop.h"
	39	#include "TEncSlice.h"
[100]	40	#include "../../App/TAppEncoder/TAppEncTop.h"
[56]	41	#include <math.h>
[2]	42
[56]	43	//! \ingroup TLibEncoder
	44	//! \{
	45
[2]	46	// ====================================================================================================================
	47	// Constructor / destructor / create / destroy
	48	// ====================================================================================================================
	49
	50	TEncSlice::TEncSlice()
	51	{
	52	m_apcPicYuvPred = NULL;
	53	m_apcPicYuvResi = NULL;
[56]	54
[2]	55	m_pdRdPicLambda = NULL;
	56	m_pdRdPicQp = NULL;
	57	m_piRdPicQp = NULL;
[56]	58	m_pcBufferSbacCoders = NULL;
	59	m_pcBufferBinCoderCABACs = NULL;
	60	m_pcBufferLowLatSbacCoders = NULL;
	61	m_pcBufferLowLatBinCoderCABACs = NULL;
[2]	62	}
	63
	64	TEncSlice::~TEncSlice()
	65	{
	66	}
	67
	68	Void TEncSlice::create( Int iWidth, Int iHeight, UInt iMaxCUWidth, UInt iMaxCUHeight, UChar uhTotalDepth )
	69	{
	70	// create prediction picture
	71	if ( m_apcPicYuvPred == NULL )
	72	{
	73	m_apcPicYuvPred = new TComPicYuv;
	74	m_apcPicYuvPred->create( iWidth, iHeight, iMaxCUWidth, iMaxCUHeight, uhTotalDepth );
	75	}
[56]	76
[2]	77	// create residual picture
	78	if( m_apcPicYuvResi == NULL )
	79	{
	80	m_apcPicYuvResi = new TComPicYuv;
	81	m_apcPicYuvResi->create( iWidth, iHeight, iMaxCUWidth, iMaxCUHeight, uhTotalDepth );
	82	}
	83	}
	84
	85	Void TEncSlice::destroy()
	86	{
	87	// destroy prediction picture
	88	if ( m_apcPicYuvPred )
	89	{
	90	m_apcPicYuvPred->destroy();
	91	delete m_apcPicYuvPred;
	92	m_apcPicYuvPred = NULL;
	93	}
[56]	94
[2]	95	// destroy residual picture
	96	if ( m_apcPicYuvResi )
	97	{
	98	m_apcPicYuvResi->destroy();
	99	delete m_apcPicYuvResi;
	100	m_apcPicYuvResi = NULL;
	101	}
[56]	102
[2]	103	// free lambda and QP arrays
	104	if ( m_pdRdPicLambda ) { xFree( m_pdRdPicLambda ); m_pdRdPicLambda = NULL; }
	105	if ( m_pdRdPicQp ) { xFree( m_pdRdPicQp ); m_pdRdPicQp = NULL; }
	106	if ( m_piRdPicQp ) { xFree( m_piRdPicQp ); m_piRdPicQp = NULL; }
[56]	107
	108	if ( m_pcBufferSbacCoders )
	109	{
	110	delete[] m_pcBufferSbacCoders;
	111	}
	112	if ( m_pcBufferBinCoderCABACs )
	113	{
	114	delete[] m_pcBufferBinCoderCABACs;
	115	}
	116	if ( m_pcBufferLowLatSbacCoders )
	117	delete[] m_pcBufferLowLatSbacCoders;
	118	if ( m_pcBufferLowLatBinCoderCABACs )
	119	delete[] m_pcBufferLowLatBinCoderCABACs;
[2]	120	}
	121
	122	Void TEncSlice::init( TEncTop* pcEncTop )
	123	{
	124	m_pcCfg = pcEncTop;
	125	m_pcListPic = pcEncTop->getListPic();
[56]	126
	127	m_pcGOPEncoder = pcEncTop->getGOPEncoder();
[2]	128	m_pcCuEncoder = pcEncTop->getCuEncoder();
	129	m_pcPredSearch = pcEncTop->getPredSearch();
[56]	130
[2]	131	m_pcEntropyCoder = pcEncTop->getEntropyCoder();
	132	m_pcCavlcCoder = pcEncTop->getCavlcCoder();
	133	m_pcSbacCoder = pcEncTop->getSbacCoder();
	134	m_pcBinCABAC = pcEncTop->getBinCABAC();
	135	m_pcTrQuant = pcEncTop->getTrQuant();
[56]	136
[2]	137	m_pcBitCounter = pcEncTop->getBitCounter();
	138	m_pcRdCost = pcEncTop->getRdCost();
	139	m_pppcRDSbacCoder = pcEncTop->getRDSbacCoder();
	140	m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
[56]	141
[2]	142	// create lambda and QP arrays
	143	m_pdRdPicLambda = (Double)xMalloc( Double, m_pcCfg->getDeltaQpRD() 2 + 1 );
	144	m_pdRdPicQp = (Double)xMalloc( Double, m_pcCfg->getDeltaQpRD() 2 + 1 );
	145	m_piRdPicQp = (Int* )xMalloc( Int, m_pcCfg->getDeltaQpRD() * 2 + 1 );
	146	}
	147
	148	/**
	149	- non-referenced frame marking
	150	- QP computation based on temporal structure
	151	- lambda computation based on QP
[56]	152	- set temporal layer ID and the parameter sets
[2]	153	.
	154	\param pcPic picture class
	155	\param iPOCLast POC of last picture
	156	\param uiPOCCurr current POC
	157	\param iNumPicRcvd number of received pictures
	158	\param iTimeOffset POC offset for hierarchical structure
	159	\param iDepth temporal layer depth
	160	\param rpcSlice slice header class
[56]	161	\param pSPS SPS associated with the slice
	162	\param pPPS PPS associated with the slice
[2]	163	*/
[210]	164	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
[280]	165	#if MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
	166	Void TEncSlice::initEncSlice( TComPic* pcPic, Int iPOCLast, UInt uiPOCCurr, Int iNumPicRcvd, Int iGOPid, TComSlice& rpcSlice, TComVPS pVPS, TComSPS* pSPS, TComPPS *pPPS, bool isDepth )
	167	#else
[77]	168	Void TEncSlice::initEncSlice( TComPic* pcPic, Int iPOCLast, UInt uiPOCCurr, Int iNumPicRcvd, Int iGOPid, TComSlice& rpcSlice, TComVPS pVPS, TComSPS* pSPS, TComPPS *pPPS )
[280]	169	#endif
[77]	170	#else
[56]	171	Void TEncSlice::initEncSlice( TComPic* pcPic, Int iPOCLast, UInt uiPOCCurr, Int iNumPicRcvd, Int iGOPid, TComSlice& rpcSlice, TComSPS pSPS, TComPPS *pPPS )
[77]	172	#endif
[2]	173	{
	174	Double dQP;
	175	Double dLambda;
[56]	176
[2]	177	rpcSlice = pcPic->getSlice(0);
[210]	178	#if VIDYO_VPS_INTEGRATION\|QC_MVHEVC_B0046
[77]	179	rpcSlice->setVPS( pVPS );
	180	#endif
[56]	181	rpcSlice->setSPS( pSPS );
	182	rpcSlice->setPPS( pPPS );
[2]	183	rpcSlice->setSliceBits(0);
	184	rpcSlice->setPic( pcPic );
	185	rpcSlice->initSlice();
[56]	186	rpcSlice->initTiles();
	187	rpcSlice->setPicOutputFlag( true );
	188	rpcSlice->setPOC( uiPOCCurr );
	189
[280]	190	#if INTER_VIEW_VECTOR_SCALING_C0115
	191	rpcSlice->setViewOrderIdx(m_pcCfg->getViewOrderIdx()); // will be changed to view_id
[21]	192	#endif
[189]	193	#if LGE_ILLUCOMP_B0045
	194	rpcSlice->setApplyIC(false);
	195	#endif
[56]	196	// set mutliview parameters
	197	rpcSlice->initMultiviewSlice( pcPic->getCodedScale(), pcPic->getCodedOffset() );
	198
	199	// depth computation based on GOP size
	200	int iDepth;
	201	{
	202	Int i, j;
	203	Int iPOC = rpcSlice->getPOC()%m_pcCfg->getGOPSize();
	204	if ( iPOC == 0 )
	205	{
	206	iDepth = 0;
	207	}
	208	else
	209	{
	210	Int iStep = m_pcCfg->getGOPSize();
	211	iDepth = 0;
	212	for( i=iStep>>1; i>=1; i>>=1 )
	213	{
	214	for ( j=i; j<m_pcCfg->getGOPSize(); j+=iStep )
	215	{
	216	if ( j == iPOC )
	217	{
	218	i=0;
	219	break;
	220	}
	221	}
	222	iStep>>=1;
	223	iDepth++;
	224	}
	225	}
	226	}
	227
[2]	228	// slice type
[56]	229	SliceType eSliceTypeBaseView;
	230	if( iPOCLast == 0 \|\| uiPOCCurr % m_pcCfg->getIntraPeriod() == 0 \|\| m_pcGOPEncoder->getGOPSize() == 0 )
	231	{
	232	eSliceTypeBaseView = I_SLICE;
	233	}
	234	else
	235	{
	236	eSliceTypeBaseView = B_SLICE;
	237	}
	238	SliceType eSliceType = eSliceTypeBaseView;
	239	if( eSliceTypeBaseView == I_SLICE && m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType != 'I' )
	240	{
	241	eSliceType = B_SLICE;
	242	}
	243	rpcSlice->setSliceType( eSliceType );
	244
[2]	245	// ------------------------------------------------------------------------------------------------------------------
	246	// Non-referenced frame marking
	247	// ------------------------------------------------------------------------------------------------------------------
[56]	248	rpcSlice->setReferenced( m_pcCfg->getGOPEntry(iGOPid).m_refPic );
	249	if( eSliceTypeBaseView == I_SLICE )
	250	{
	251	rpcSlice->setReferenced(true);
	252	}
	253
[2]	254	// ------------------------------------------------------------------------------------------------------------------
	255	// QP setting
	256	// ------------------------------------------------------------------------------------------------------------------
[56]	257
	258	dQP = m_pcCfg->getQP();
	259	if( eSliceType != I_SLICE )
	260	{
	261	#if LOSSLESS_CODING
	262	if (!(( m_pcCfg->getMaxDeltaQP() == 0 ) && (dQP == -rpcSlice->getSPS()->getQpBDOffsetY() ) && (rpcSlice->getSPS()->getUseLossless())))
	263	#endif
	264	{
	265	dQP += m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_QPOffset;
	266	}
	267	}
	268
	269	// modify QP
	270	Int* pdQPs = m_pcCfg->getdQPs();
	271	if ( pdQPs )
	272	{
	273	dQP += pdQPs[ rpcSlice->getPOC() ];
	274	}
	275
[2]	276	// ------------------------------------------------------------------------------------------------------------------
	277	// Lambda computation
	278	// ------------------------------------------------------------------------------------------------------------------
[56]	279
[2]	280	Int iQP;
[56]	281	Double dOrigQP = dQP;
[2]	282
	283	// pre-compute lambda and QP values for all possible QP candidates
	284	for ( Int iDQpIdx = 0; iDQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; iDQpIdx++ )
	285	{
	286	// compute QP value
	287	dQP = dOrigQP + ((iDQpIdx+1)>>1)*(iDQpIdx%2 ? -1 : 1);
[56]	288
[2]	289	// compute lambda value
[56]	290	Int NumberBFrames = ( m_pcCfg->getGOPSize() - 1 );
[2]	291	Int SHIFT_QP = 12;
	292	Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)NumberBFrames );
	293	#if FULL_NBIT
	294	Int bitdepth_luma_qp_scale = 6 * (g_uiBitDepth - 8);
	295	#else
	296	Int bitdepth_luma_qp_scale = 0;
	297	#endif
[56]	298	Double qp_temp = (Double) dQP + bitdepth_luma_qp_scale - SHIFT_QP;
[2]	299	#if FULL_NBIT
[56]	300	Double qp_temp_orig = (Double) dQP - SHIFT_QP;
[2]	301	#endif
	302	// Case #1: I or P-slices (key-frame)
[56]	303	Double dQPFactor;
	304	if( eSliceType != I_SLICE )
[2]	305	{
[56]	306	dQPFactor = m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_QPFactor;
[2]	307	}
[56]	308	else
[2]	309	{
[56]	310	dQPFactor = 0.57 * dLambda_scale;
	311	}
	312
	313	dLambda = dQPFactor*pow( 2.0, qp_temp/3.0 );
	314
	315	if ( iDepth>0 )
	316	{
[2]	317	#if FULL_NBIT
	318	dLambda *= Clip3( 2.00, 4.00, (qp_temp_orig / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
	319	#else
	320	dLambda *= Clip3( 2.00, 4.00, (qp_temp / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
	321	#endif
	322	}
[56]	323
[2]	324	// if hadamard is used in ME process
[56]	325	if ( !m_pcCfg->getUseHADME() )
	326	{
	327	dLambda *= 0.95;
	328	}
	329
	330	iQP = max( -pSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( dQP + 0.5 ) ) );
[5]	331
[2]	332	m_pdRdPicLambda[iDQpIdx] = dLambda;
	333	m_pdRdPicQp [iDQpIdx] = dQP;
	334	m_piRdPicQp [iDQpIdx] = iQP;
	335	}
[56]	336
[2]	337	// obtain dQP = 0 case
	338	dLambda = m_pdRdPicLambda[0];
	339	dQP = m_pdRdPicQp [0];
	340	iQP = m_piRdPicQp [0];
[56]	341
	342	if( rpcSlice->getSliceType( ) != I_SLICE )
	343	{
	344	dLambda *= m_pcCfg->getLambdaModifier( iDepth );
	345	}
[5]	346
[2]	347	// store lambda
[56]	348	m_pcRdCost ->setLambda( dLambda );
	349	#if WEIGHTED_CHROMA_DISTORTION
	350	// for RDO
	351	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	352	Double weight = 1.0;
	353	if(iQP >= 0)
	354	{
	355	weight = pow( 2.0, (iQP-g_aucChromaScale[iQP])/3.0 ); // takes into account of the chroma qp mapping without chroma qp Offset
	356	}
	357	m_pcRdCost ->setChromaDistortionWeight( weight );
	358	#endif
	359
[5]	360	#if HHI_VSO
	361	m_pcRdCost->setUseLambdaScaleVSO ( (m_pcCfg->getUseVSO() \|\| m_pcCfg->getForceLambdaScaleVSO()) && m_pcCfg->isDepthCoder() );
	362	m_pcRdCost->setLambdaVSO( dLambda * m_pcCfg->getLambdaScaleVSO() );
	363	#endif
[2]	364
[102]	365	#if SAIT_VSO_EST_A0033
	366	m_pcRdCost->setDisparityCoeff( m_pcCfg->getDispCoeff() );
	367	#endif
[115]	368	#if LGE_WVSO_A0119
[120]	369	if( m_pcCfg->getUseWVSO() && m_pcCfg->isDepthCoder() )
[115]	370	{
[102]	371
[115]	372	Int iDWeight, iVSOWeight, iVSDWeight;
	373	iDWeight = m_pcCfg->getDWeight();
	374	iVSOWeight = m_pcCfg->getVSOWeight();
	375	iVSDWeight = m_pcCfg->getVSDWeight();
	376
	377	m_pcRdCost->setDWeight( iDWeight );
	378	m_pcRdCost->setVSOWeight( iVSOWeight );
	379	m_pcRdCost->setVSDWeight( iVSDWeight );
	380
	381	}
	382	#endif
[56]	383	#if RDOQ_CHROMA_LAMBDA
	384	// for RDOQ
	385	m_pcTrQuant->setLambda( dLambda, dLambda / weight );
	386	#else
	387	m_pcTrQuant->setLambda( dLambda );
	388	#endif
	389
	390	#if ALF_CHROMA_LAMBDA \|\| SAO_CHROMA_LAMBDA
	391	// For ALF or SAO
	392	rpcSlice ->setLambda( dLambda, dLambda / weight );
	393	#else
	394	rpcSlice ->setLambda( dLambda );
	395	#endif
	396
[292]	397	#if H3D_IVMP
[2]	398	m_pcRdCost ->setLambdaMVReg ( dLambda * m_pcCfg->getMultiviewMvRegLambdaScale() );
[5]	399	#endif
[56]	400
	401	#if HB_LAMBDA_FOR_LDC
	402	// restore original slice type
	403	eSliceType = eSliceTypeBaseView;
	404	if( eSliceTypeBaseView == I_SLICE && m_pcCfg->getGOPEntry(MAX_GOP).m_POC == 0 && m_pcCfg->getGOPEntry(MAX_GOP).m_sliceType != 'I' )
	405	{
	406	eSliceType = B_SLICE;
	407	}
	408	rpcSlice->setSliceType( eSliceType );
	409	#endif
	410
[2]	411	rpcSlice->setSliceQp ( iQP );
[56]	412	#if ADAPTIVE_QP_SELECTION
	413	rpcSlice->setSliceQpBase ( iQP );
	414	#endif
[2]	415	rpcSlice->setSliceQpDelta ( 0 );
[56]	416	rpcSlice->setNumRefIdx(REF_PIC_LIST_0,m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_numRefPicsActive);
	417	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_numRefPicsActive);
	418
	419	rpcSlice->setLoopFilterOffsetInAPS( m_pcCfg->getLoopFilterOffsetInAPS() );
	420	if (rpcSlice->getPPS()->getDeblockingFilterControlPresent())
	421	{
	422	rpcSlice->setInheritDblParamFromAPS( m_pcCfg->getLoopFilterOffsetInAPS() ? 1 : 0 );
	423	rpcSlice->setLoopFilterDisable( m_pcCfg->getLoopFilterDisable() );
	424	if ( !rpcSlice->getLoopFilterDisable())
	425	{
	426	rpcSlice->setLoopFilterBetaOffset( m_pcCfg->getLoopFilterBetaOffset() );
	427	rpcSlice->setLoopFilterTcOffset( m_pcCfg->getLoopFilterTcOffset() );
	428	}
	429	}
[5]	430
[56]	431	rpcSlice->setDepth ( iDepth );
	432
	433	pcPic->setTLayer( m_pcCfg->getGOPEntry( (eSliceTypeBaseView == I_SLICE) ? MAX_GOP : iGOPid ).m_temporalId );
	434	if( eSliceType == I_SLICE )
	435	{
	436	pcPic->setTLayer(0);
	437	}
	438	rpcSlice->setTLayer( pcPic->getTLayer() );
[5]	439
[2]	440	assert( m_apcPicYuvPred );
	441	assert( m_apcPicYuvResi );
[56]	442
[2]	443	pcPic->setPicYuvPred( m_apcPicYuvPred );
	444	pcPic->setPicYuvResi( m_apcPicYuvResi );
	445	rpcSlice->setSliceMode ( m_pcCfg->getSliceMode() );
	446	rpcSlice->setSliceArgument ( m_pcCfg->getSliceArgument() );
	447	rpcSlice->setEntropySliceMode ( m_pcCfg->getEntropySliceMode() );
	448	rpcSlice->setEntropySliceArgument ( m_pcCfg->getEntropySliceArgument() );
[56]	449
[292]	450	#if ( HHI_MPI \|\| H3D_IVMP )
	451	#if ( HHI_MPI && H3D_IVMP )
[56]	452	const int iExtraMergeCandidates = ( pSPS->getUseMVI() \|\| pSPS->getMultiviewMvPredMode() ) ? 1 : 0;
	453	#elif HHI_MPI
	454	const int iExtraMergeCandidates = pSPS->getUseMVI() ? 1 : 0;
[280]	455	#elif MTK_DEPTH_MERGE_TEXTURE_CANDIDATE_C0137
	456	const int iExtraMergeCandidates = ( isDepth \|\| pSPS->getMultiviewMvPredMode() ) ? 1 : 0;
[56]	457	#else
	458	const int iExtraMergeCandidates = pSPS->getMultiviewMvPredMode() ? 1 : 0;
	459	#endif
	460	rpcSlice->setMaxNumMergeCand (MRG_MAX_NUM_CANDS_SIGNALED+iExtraMergeCandidates);
	461	#else
	462	rpcSlice->setMaxNumMergeCand (MRG_MAX_NUM_CANDS_SIGNALED);
	463	#endif
	464	xStoreWPparam( pPPS->getUseWP(), pPPS->getWPBiPredIdc() );
[2]	465	}
	466
	467	// ====================================================================================================================
	468	// Public member functions
	469	// ====================================================================================================================
	470
	471	Void TEncSlice::setSearchRange( TComSlice* pcSlice )
	472	{
	473	Int iCurrPOC = pcSlice->getPOC();
	474	Int iRefPOC;
[56]	475	Int iGOPSize = m_pcCfg->getGOPSize();
	476	Int iOffset = (iGOPSize >> 1);
[2]	477	Int iMaxSR = m_pcCfg->getSearchRange();
	478	Int iNumPredDir = pcSlice->isInterP() ? 1 : 2;
[56]	479
[2]	480	for (Int iDir = 0; iDir <= iNumPredDir; iDir++)
	481	{
	482	RefPicList e = (RefPicList)iDir;
	483	for (Int iRefIdx = 0; iRefIdx < pcSlice->getNumRefIdx(e); iRefIdx++)
	484	{
	485	iRefPOC = pcSlice->getRefPic(e, iRefIdx)->getPOC();
[56]	486	Int iNewSR = Clip3(8, iMaxSR, (iMaxSRADAPT_SR_SCALEabs(iCurrPOC - iRefPOC)+iOffset)/iGOPSize);
[2]	487	m_pcPredSearch->setAdaptiveSearchRange(iDir, iRefIdx, iNewSR);
	488	}
	489	}
	490	}
	491
	492	/**
	493	- multi-loop slice encoding for different slice QP
	494	.
	495	\param rpcPic picture class
	496	*/
	497	Void TEncSlice::precompressSlice( TComPic*& rpcPic )
	498	{
	499	// if deltaQP RD is not used, simply return
[56]	500	if ( m_pcCfg->getDeltaQpRD() == 0 )
	501	{
	502	return;
	503	}
	504
[2]	505	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	506	Double dPicRdCostBest = MAX_DOUBLE;
	507	UInt uiQpIdxBest = 0;
[56]	508
[2]	509	Double dFrameLambda;
	510	#if FULL_NBIT
	511	Int SHIFT_QP = 12 + 6 * (g_uiBitDepth - 8);
	512	#else
	513	Int SHIFT_QP = 12;
	514	#endif
[56]	515
[2]	516	// set frame lambda
	517	if (m_pcCfg->getGOPSize() > 1)
	518	{
	519	dFrameLambda = 0.68 * pow (2, (m_piRdPicQp[0] - SHIFT_QP) / 3.0) * (pcSlice->isInterB()? 2 : 1);
	520	}
	521	else
	522	{
	523	dFrameLambda = 0.68 * pow (2, (m_piRdPicQp[0] - SHIFT_QP) / 3.0);
	524	}
	525	m_pcRdCost ->setFrameLambda(dFrameLambda);
[56]	526
[2]	527	// for each QP candidate
	528	for ( UInt uiQpIdx = 0; uiQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; uiQpIdx++ )
	529	{
	530	pcSlice ->setSliceQp ( m_piRdPicQp [uiQpIdx] );
[56]	531	#if ADAPTIVE_QP_SELECTION
	532	pcSlice ->setSliceQpBase ( m_piRdPicQp [uiQpIdx] );
	533	#endif
[2]	534	m_pcRdCost ->setLambda ( m_pdRdPicLambda[uiQpIdx] );
[56]	535	#if WEIGHTED_CHROMA_DISTORTION
	536	// for RDO
	537	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	538	int iQP = m_piRdPicQp [uiQpIdx];
	539	Double weight = 1.0;
	540	if(iQP >= 0)
	541	{
	542	weight = pow( 2.0, (iQP-g_aucChromaScale[iQP])/3.0 ); // takes into account of the chroma qp mapping without chroma qp Offset
	543	}
	544	m_pcRdCost ->setChromaDistortionWeight( weight );
	545	#endif
	546
	547	#if RDOQ_CHROMA_LAMBDA
	548	// for RDOQ
	549	m_pcTrQuant ->setLambda( m_pdRdPicLambda[uiQpIdx], m_pdRdPicLambda[uiQpIdx] / weight );
	550	#else
[2]	551	m_pcTrQuant ->setLambda ( m_pdRdPicLambda[uiQpIdx] );
[56]	552	#endif
	553	#if ALF_CHROMA_LAMBDA \|\| SAO_CHROMA_LAMBDA
	554	// For ALF or SAO
	555	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdx], m_pdRdPicLambda[uiQpIdx] / weight );
	556	#else
[2]	557	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdx] );
[56]	558	#endif
[292]	559	#if H3D_IVMP
[2]	560	m_pcRdCost ->setLambdaMVReg ( m_pdRdPicLambda[uiQpIdx] * m_pcCfg->getMultiviewMvRegLambdaScale() );
[5]	561	#endif
[56]	562
[2]	563	// try compress
	564	compressSlice ( rpcPic );
[56]	565
[2]	566	Double dPicRdCost;
	567	UInt64 uiPicDist = m_uiPicDist;
	568	UInt64 uiALFBits = 0;
[56]	569
	570	m_pcGOPEncoder->preLoopFilterPicAll( rpcPic, uiPicDist, uiALFBits );
	571
[2]	572	// compute RD cost and choose the best
	573	dPicRdCost = m_pcRdCost->calcRdCost64( m_uiPicTotalBits + uiALFBits, uiPicDist, true, DF_SSE_FRAME);
[56]	574
[2]	575	if ( dPicRdCost < dPicRdCostBest )
	576	{
	577	uiQpIdxBest = uiQpIdx;
	578	dPicRdCostBest = dPicRdCost;
	579	}
	580	}
[56]	581
[2]	582	// set best values
	583	pcSlice ->setSliceQp ( m_piRdPicQp [uiQpIdxBest] );
[56]	584	#if ADAPTIVE_QP_SELECTION
	585	pcSlice ->setSliceQpBase ( m_piRdPicQp [uiQpIdxBest] );
	586	#endif
[2]	587	m_pcRdCost ->setLambda ( m_pdRdPicLambda[uiQpIdxBest] );
[56]	588	#if WEIGHTED_CHROMA_DISTORTION
	589	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
	590	int iQP = m_piRdPicQp [uiQpIdxBest];
	591	Double weight = 1.0;
	592	if(iQP >= 0)
	593	{
	594	weight = pow( 2.0, (iQP-g_aucChromaScale[iQP])/3.0 ); // takes into account of the chroma qp mapping without chroma qp Offset
	595	}
	596	m_pcRdCost ->setChromaDistortionWeight( weight );
	597	#endif
	598
	599	#if RDOQ_CHROMA_LAMBDA
	600	// for RDOQ
	601	m_pcTrQuant ->setLambda( m_pdRdPicLambda[uiQpIdxBest], m_pdRdPicLambda[uiQpIdxBest] / weight );
	602	#else
[2]	603	m_pcTrQuant ->setLambda ( m_pdRdPicLambda[uiQpIdxBest] );
[56]	604	#endif
	605	#if ALF_CHROMA_LAMBDA \|\| SAO_CHROMA_LAMBDA
	606	// For ALF or SAO
	607	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdxBest], m_pdRdPicLambda[uiQpIdxBest] / weight );
	608	#else
[2]	609	pcSlice ->setLambda ( m_pdRdPicLambda[uiQpIdxBest] );
[56]	610	#endif
[292]	611	#if H3D_IVMP
[2]	612	m_pcRdCost ->setLambdaMVReg ( m_pdRdPicLambda[uiQpIdxBest] * m_pcCfg->getMultiviewMvRegLambdaScale() );
[5]	613	#endif
[2]	614	}
	615
	616	/** \param rpcPic picture class
	617	*/
	618	Void TEncSlice::compressSlice( TComPic*& rpcPic )
	619	{
	620	UInt uiCUAddr;
	621	UInt uiStartCUAddr;
	622	UInt uiBoundingCUAddr;
[56]	623	rpcPic->getSlice(getSliceIdx())->setEntropySliceCounter(0);
[2]	624	TEncBinCABAC* pppcRDSbacCoder = NULL;
	625	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	626	xDetermineStartAndBoundingCUAddr ( uiStartCUAddr, uiBoundingCUAddr, rpcPic, false );
[189]	627	#if LG_ZEROINTRADEPTHRESI_A0087
[100]	628	rpcPic->setIntraPeriod(this->m_pcCfg->getIntraPeriod());
	629	#endif
[56]	630
[2]	631	// initialize cost values
	632	m_uiPicTotalBits = 0;
	633	m_dPicRdCost = 0;
	634	m_uiPicDist = 0;
[56]	635
[189]	636	#if CABAC_INIT_FLAG && FIX_POZNAN_CABAC_INIT_FLAG
[101]	637	Bool bReset =(pcSlice->getPOC() == 0) \|\|
	638	(pcSlice->getPOC() % m_pcCfg->getIntraPeriod() == 0) \|\|
	639	(pcSlice->getPPS()->getEncPrevPOC() % m_pcCfg->getIntraPeriod() == 0) \|\|
	640	(pcSlice->getPOC()/m_pcCfg->getIntraPeriod() > pcSlice->getPPS()->getEncPrevPOC()/m_pcCfg->getIntraPeriod()) \|\|
	641	(m_pcGOPEncoder->getGOPSize() == 0);
	642
	643	if ( bReset && pcSlice->getPPS()->getCabacInitPresentFlag())
	644	{
	645	pcSlice->getPPS()->setEncCABACTableIdx(pcSlice->getSliceType()); // reset cabac initialization table index
	646	};
	647	#endif
	648
[2]	649	// set entropy coder
	650	if( m_pcCfg->getUseSBACRD() )
	651	{
	652	m_pcSbacCoder->init( m_pcBinCABAC );
	653	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	654	m_pcEntropyCoder->resetEntropy ();
	655	m_pppcRDSbacCoder[0][CI_CURR_BEST]->load(m_pcSbacCoder);
	656	pppcRDSbacCoder = (TEncBinCABAC *) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
	657	pppcRDSbacCoder->setBinCountingEnableFlag( false );
	658	pppcRDSbacCoder->setBinsCoded( 0 );
	659	}
	660	else
	661	{
	662	m_pcEntropyCoder->setEntropyCoder ( m_pcCavlcCoder, pcSlice );
	663	m_pcEntropyCoder->resetEntropy ();
	664	m_pcEntropyCoder->setBitstream ( m_pcBitCounter );
	665	}
[56]	666
	667	//------------------------------------------------------------------------------
	668	// Weighted Prediction parameters estimation.
	669	//------------------------------------------------------------------------------
	670	// calculate AC/DC values for current picture
	671	if( pcSlice->getPPS()->getUseWP() \|\| pcSlice->getPPS()->getWPBiPredIdc() )
	672	{
	673	xCalcACDCParamSlice(pcSlice);
	674	}
[5]	675
[56]	676	Bool bWp_explicit = (pcSlice->getSliceType()==P_SLICE && pcSlice->getPPS()->getUseWP()) \|\| (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==1);
	677	Bool bWp_implicit = (pcSlice->getSliceType()==B_SLICE && pcSlice->getPPS()->getWPBiPredIdc()==2);
	678
	679	if ( bWp_explicit \|\| bWp_implicit )
	680	{
	681	//------------------------------------------------------------------------------
	682	// Weighted Prediction implemented at Slice level. SliceMode=2 is not supported yet.
	683	//------------------------------------------------------------------------------
	684	if ( pcSlice->getSliceMode()==2 \|\| pcSlice->getEntropySliceMode()==2 )
	685	{
	686	printf("Weighted Prediction is not supported with slice mode determined by max number of bins.\n"); exit(0);
	687	}
	688
	689	if( bWp_explicit )
	690	{
	691	xEstimateWPParamSlice( pcSlice );
	692	}
	693
	694	pcSlice->initWpScaling();
	695
	696	// check WP on/off
	697	if( bWp_explicit )
	698	{
	699	xCheckWPEnable( pcSlice );
	700	}
	701	}
	702
	703	#if ADAPTIVE_QP_SELECTION
	704	if( m_pcCfg->getUseAdaptQpSelect() )
	705	{
	706	m_pcTrQuant->clearSliceARLCnt();
	707	if(pcSlice->getSliceType()!=I_SLICE)
	708	{
	709	Int qpBase = pcSlice->getSliceQpBase();
	710	pcSlice->setSliceQp(qpBase + m_pcTrQuant->getQpDelta(qpBase));
	711	}
	712	}
	713	#endif
[2]	714	// initialize ALF parameters
	715	m_pcEntropyCoder->setAlfCtrl(false);
	716	m_pcEntropyCoder->setMaxAlfCtrlDepth(0); //unnecessary
[56]	717
[100]	718	#if SAIT_VSO_EST_A0033
	719	if( m_pcCfg->getUseVSO() )
	720	{
	721
	722	Int frameWidth = m_pcCfg->getSourceWidth();
	723	Pel* pVideoRec = m_pcRdCost->getVideoRecPicYuv()->getLumaAddr();
	724	Int iVideoRecStride = m_pcRdCost->getVideoRecPicYuv()->getStride();
	725
	726	Pel* pDepthOrg = m_pcRdCost->getDepthPicYuv()->getLumaAddr();
	727	Int iDepthOrgStride = m_pcRdCost->getDepthPicYuv()->getStride();
	728
	729	for( Int y = 0 ; y < m_pcCfg->getSourceHeight() ; y++ )
	730	{
[102]	731	pVideoRec[-1] = pVideoRec[0];
	732	pVideoRec[frameWidth] = pVideoRec[frameWidth-1];
	733	pDepthOrg[-1] = pDepthOrg[0];
	734	pDepthOrg[frameWidth] = pDepthOrg[frameWidth-1];
[100]	735
	736	pVideoRec += iVideoRecStride;
	737	pDepthOrg += iDepthOrgStride;
	738	}
	739	}
	740	#endif
[102]	741
[56]	742	TEncTop* pcEncTop = (TEncTop*) m_pcCfg;
	743	TEncSbac**** ppppcRDSbacCoders = pcEncTop->getRDSbacCoders();
	744	TComBitCounter* pcBitCounters = pcEncTop->getBitCounters();
	745	Int iNumSubstreams = 1;
	746	UInt uiTilesAcross = 0;
[5]	747
[189]	748	#if LGE_ILLUCOMP_B0045
[287]	749	if (pcEncTop->getViewId() != 0
	750	#if !LGE_ILLUCOMP_DEPTH_C0046
	751	&& !pcEncTop->isDepthCoder()
	752	#endif
	753	&& pcEncTop->getUseIC()) // DCP of ViewID 0 is not available
[189]	754	{
	755	pcSlice ->xSetApplyIC();
	756	}
	757	#endif
	758
[56]	759	if( m_pcCfg->getUseSBACRD() )
	760	{
	761	iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
	762	uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
	763	delete[] m_pcBufferSbacCoders;
	764	delete[] m_pcBufferBinCoderCABACs;
	765	m_pcBufferSbacCoders = new TEncSbac [uiTilesAcross];
	766	m_pcBufferBinCoderCABACs = new TEncBinCABAC[uiTilesAcross];
	767	for (int ui = 0; ui < uiTilesAcross; ui++)
	768	{
	769	m_pcBufferSbacCoders[ui].init( &m_pcBufferBinCoderCABACs[ui] );
	770	}
	771	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	772	{
	773	m_pcBufferSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]); //init. state
	774	}
	775
	776	for ( UInt ui = 0 ; ui < iNumSubstreams ; ui++ ) //init all sbac coders for RD optimization
	777	{
	778	ppppcRDSbacCoders[ui][0][CI_CURR_BEST]->load(m_pppcRDSbacCoder[0][CI_CURR_BEST]);
	779	}
	780	}
	781	//if( m_pcCfg->getUseSBACRD() )
	782	{
	783	delete[] m_pcBufferLowLatSbacCoders;
	784	delete[] m_pcBufferLowLatBinCoderCABACs;
	785	m_pcBufferLowLatSbacCoders = new TEncSbac [uiTilesAcross];
	786	m_pcBufferLowLatBinCoderCABACs = new TEncBinCABAC[uiTilesAcross];
	787	for (int ui = 0; ui < uiTilesAcross; ui++)
	788	{
	789	m_pcBufferLowLatSbacCoders[ui].init( &m_pcBufferLowLatBinCoderCABACs[ui] );
	790	}
	791	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	792	m_pcBufferLowLatSbacCoders[ui].load(m_pppcRDSbacCoder[0][CI_CURR_BEST]); //init. state
	793	}
[231]	794
	795	#if MERL_VSP_C0152
	796	// Send Depth/Texture pointers to slice level
	797	pcSlice->setBWVSPLUTParam(m_aiShiftLUT, m_iShiftPrec);
	798	pcSlice->setRefPicBaseTxt(m_pPicBaseTxt);
	799	pcSlice->setRefPicBaseDepth(m_pPicBaseDepth);
	800	#endif
	801
[56]	802	UInt uiWidthInLCUs = rpcPic->getPicSym()->getFrameWidthInCU();
	803	//UInt uiHeightInLCUs = rpcPic->getPicSym()->getFrameHeightInCU();
	804	UInt uiCol=0, uiLin=0, uiSubStrm=0;
	805	UInt uiTileCol = 0;
	806	UInt uiTileStartLCU = 0;
	807	UInt uiTileLCUX = 0;
[210]	808	#if !QC_MVHEVC_B0046
[100]	809	Int iLastPosY = -1;
[210]	810	#endif
[2]	811	// for every CU in slice
[56]	812	UInt uiEncCUOrder;
	813	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU());
	814	for( uiEncCUOrder = uiStartCUAddr/rpcPic->getNumPartInCU();
	815	uiEncCUOrder < (uiBoundingCUAddr+(rpcPic->getNumPartInCU()-1))/rpcPic->getNumPartInCU();
	816	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
[2]	817	{
	818	// initialize CU encoder
	819	TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
	820	pcCU->initCU( rpcPic, uiCUAddr );
[210]	821	#if !QC_MVHEVC_B0046
[100]	822	if ( m_pcRdCost->getUseRenModel() )
	823	{
	824	// updated renderer model if necessary
	825	Int iCurPosX;
	826	Int iCurPosY;
	827	pcCU->getPosInPic(0, iCurPosX, iCurPosY );
	828	if ( iCurPosY != iLastPosY )
	829	{
	830	iLastPosY = iCurPosY;
	831
	832	m_pcGOPEncoder->getEncTop()->getEncTop()->setupRenModel( rpcPic->getCurrSlice()->getPOC() , rpcPic->getCurrSlice()->getSPS()->getViewId(), rpcPic->getCurrSlice()->getSPS()->isDepth() ? 1 : 0, iCurPosY );
	833	}
	834	}
[210]	835	#endif
[56]	836	// inherit from TR if necessary, select substream to use.
	837	if( m_pcCfg->getUseSBACRD() )
	838	{
	839	uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
	840	uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
	841	uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
	842	//UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
	843	uiCol = uiCUAddr % uiWidthInLCUs;
	844	uiLin = uiCUAddr / uiWidthInLCUs;
	845	if (pcSlice->getPPS()->getNumSubstreams() > 1)
	846	{
	847	// independent tiles => substreams are "per tile". iNumSubstreams has already been multiplied.
	848	Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
	849	uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)*iNumSubstreamsPerTile
	850	+ uiLin%iNumSubstreamsPerTile;
	851	}
	852	else
	853	{
	854	// dependent tiles => substreams are "per frame".
	855	uiSubStrm = uiLin % iNumSubstreams;
	856	}
	857	if ( pcSlice->getPPS()->getNumSubstreams() > 1 && (uiCol == uiTileLCUX) )
	858	{
	859	// We'll sync if the TR is available.
	860	TComDataCU *pcCUUp = pcCU->getCUAbove();
	861	UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
	862	UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
	863	TComDataCU *pcCUTR = NULL;
	864	if ( pcCUUp && ((uiCUAddr%uiWidthInCU+1) < uiWidthInCU) )
	865	{
	866	pcCUTR = rpcPic->getCU( uiCUAddr - uiWidthInCU + 1 );
	867	}
	868	if ( ((pcCUTR==NULL) \|\| (pcCUTR->getSlice()==NULL) \|\|
	869	(pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getSliceCurStartCUAddr()) \|\|
	870	((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))
	871	)\|\|
	872	((pcCUTR==NULL) \|\| (pcCUTR->getSlice()==NULL) \|\|
	873	(pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getEntropySliceCurStartCUAddr()) \|\|
	874	((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))
	875	)
	876	)
	877	{
	878	// TR not available.
	879	}
	880	else
	881	{
	882	// TR is available, we use it.
	883	ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->loadContexts( &m_pcBufferSbacCoders[uiTileCol] );
	884	}
	885	}
	886	m_pppcRDSbacCoder[0][CI_CURR_BEST]->load( ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST] ); //this load is used to simplify the code
	887	}
	888
	889	// reset the entropy coder
	890	if( uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr() && // must be first CU of tile
	891	uiCUAddr!=0 && // cannot be first CU of picture
	892	uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU()) // cannot be first CU of slice
	893	{
	894	#if CABAC_INIT_FLAG
	895	SliceType sliceType = pcSlice->getSliceType();
	896	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag() && pcSlice->getPPS()->getEncCABACTableIdx()!=0)
	897	{
	898	sliceType = (SliceType) pcSlice->getPPS()->getEncCABACTableIdx();
	899	}
	900	m_pcEntropyCoder->updateContextTables ( sliceType, pcSlice->getSliceQp(), false );
	901	m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );
	902	m_pcEntropyCoder->updateContextTables ( sliceType, pcSlice->getSliceQp() );
	903	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	904	#else
	905	m_pcEntropyCoder->updateContextTables ( pcSlice->getSliceType(), pcSlice->getSliceQp(), false );
	906	m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );
	907	m_pcEntropyCoder->updateContextTables ( pcSlice->getSliceType(), pcSlice->getSliceQp() );
	908	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	909	#endif
	910	}
[2]	911	// if RD based on SBAC is used
	912	if( m_pcCfg->getUseSBACRD() )
	913	{
	914	// set go-on entropy coder
	915	m_pcEntropyCoder->setEntropyCoder ( m_pcRDGoOnSbacCoder, pcSlice );
[56]	916	m_pcEntropyCoder->setBitstream( &pcBitCounters[uiSubStrm] );
	917
	918	((TEncBinCABAC*)m_pcRDGoOnSbacCoder->getEncBinIf())->setBinCountingEnableFlag(true);
[2]	919	// run CU encoder
	920	m_pcCuEncoder->compressCU( pcCU );
[56]	921
[2]	922	// restore entropy coder to an initial stage
	923	m_pcEntropyCoder->setEntropyCoder ( m_pppcRDSbacCoder[0][CI_CURR_BEST], pcSlice );
[56]	924	m_pcEntropyCoder->setBitstream( &pcBitCounters[uiSubStrm] );
	925	m_pcCuEncoder->setBitCounter( &pcBitCounters[uiSubStrm] );
	926	m_pcBitCounter = &pcBitCounters[uiSubStrm];
[2]	927	pppcRDSbacCoder->setBinCountingEnableFlag( true );
[56]	928	m_pcBitCounter->resetBits();
	929	pppcRDSbacCoder->setBinsCoded( 0 );
[2]	930	m_pcCuEncoder->encodeCU( pcCU );
	931
	932	pppcRDSbacCoder->setBinCountingEnableFlag( false );
[56]	933	if (m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE && ( ( pcSlice->getSliceBits() + m_pcEntropyCoder->getNumberOfWrittenBits() ) ) > m_pcCfg->getSliceArgument()<<3)
[2]	934	{
	935	pcSlice->setNextSlice( true );
	936	break;
	937	}
[56]	938	if (m_pcCfg->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE && pcSlice->getEntropySliceCounter()+pppcRDSbacCoder->getBinsCoded() > m_pcCfg->getEntropySliceArgument()&&pcSlice->getSliceCurEndCUAddr()!=pcSlice->getEntropySliceCurEndCUAddr())
[2]	939	{
	940	pcSlice->setNextEntropySlice( true );
	941	break;
	942	}
[56]	943	if( m_pcCfg->getUseSBACRD() )
	944	{
	945	ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]->load( m_pppcRDSbacCoder[0][CI_CURR_BEST] );
	946
	947	//Store probabilties of second LCU in line into buffer
	948	if (pcSlice->getPPS()->getNumSubstreams() > 1 && uiCol == uiTileLCUX+1)
	949	{
	950	m_pcBufferSbacCoders[uiTileCol].loadContexts(ppppcRDSbacCoders[uiSubStrm][0][CI_CURR_BEST]);
	951	}
	952	}
[2]	953	}
	954	// other case: encodeCU is not called
	955	else
	956	{
	957	m_pcCuEncoder->compressCU( pcCU );
	958	m_pcCuEncoder->encodeCU( pcCU );
[56]	959	if (m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE && ( ( pcSlice->getSliceBits()+ m_pcEntropyCoder->getNumberOfWrittenBits() ) ) > m_pcCfg->getSliceArgument()<<3)
[2]	960	{
	961	pcSlice->setNextSlice( true );
	962	break;
	963	}
[56]	964	if (m_pcCfg->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE && pcSlice->getEntropySliceCounter()+ m_pcEntropyCoder->getNumberOfWrittenBits()> m_pcCfg->getEntropySliceArgument()&&pcSlice->getSliceCurEndCUAddr()!=pcSlice->getEntropySliceCurEndCUAddr())
[2]	965	{
	966	pcSlice->setNextEntropySlice( true );
	967	break;
	968	}
	969	}
[56]	970
[2]	971	m_uiPicTotalBits += pcCU->getTotalBits();
	972	m_dPicRdCost += pcCU->getTotalCost();
	973	m_uiPicDist += pcCU->getTotalDistortion();
	974	}
[56]	975	xRestoreWPparam( pcSlice );
[2]	976	}
	977
	978	/**
	979	\param rpcPic picture class
	980	\retval rpcBitstream bitstream class
	981	*/
[56]	982	Void TEncSlice::encodeSlice ( TComPic& rpcPic, TComOutputBitstream pcBitstream, TComOutputBitstream* pcSubstreams )
[2]	983	{
	984	UInt uiCUAddr;
	985	UInt uiStartCUAddr;
	986	UInt uiBoundingCUAddr;
	987	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	988
[56]	989	uiStartCUAddr=pcSlice->getEntropySliceCurStartCUAddr();
	990	uiBoundingCUAddr=pcSlice->getEntropySliceCurEndCUAddr();
[2]	991	// choose entropy coder
	992	{
	993	m_pcSbacCoder->init( (TEncBinIf*)m_pcBinCABAC );
	994	m_pcEntropyCoder->setEntropyCoder ( m_pcSbacCoder, pcSlice );
	995	}
[56]	996
	997	m_pcCuEncoder->setBitCounter( NULL );
	998	m_pcBitCounter = NULL;
	999	// Appropriate substream bitstream is switched later.
[2]	1000	// for every CU
	1001	#if ENC_DEC_TRACE
	1002	g_bJustDoIt = g_bEncDecTraceEnable;
	1003	#endif
[56]	1004	DTRACE_CABAC_VL( g_nSymbolCounter++ );
[2]	1005	DTRACE_CABAC_T( "\tPOC: " );
	1006	DTRACE_CABAC_V( rpcPic->getPOC() );
	1007	DTRACE_CABAC_T( "\n" );
	1008	#if ENC_DEC_TRACE
	1009	g_bJustDoIt = g_bEncDecTraceDisable;
	1010	#endif
	1011
[56]	1012	TEncTop* pcEncTop = (TEncTop*) m_pcCfg;
	1013	TEncSbac* pcSbacCoders = pcEncTop->getSbacCoders(); //coder for each substream
	1014	Int iNumSubstreams = pcSlice->getPPS()->getNumSubstreams();
	1015	UInt uiBitsOriginallyInSubstreams = 0;
[2]	1016	{
[56]	1017	UInt uiTilesAcross = rpcPic->getPicSym()->getNumColumnsMinus1()+1;
	1018	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	1019	{
	1020	m_pcBufferSbacCoders[ui].load(m_pcSbacCoder); //init. state
	1021	}
	1022
	1023	for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
	1024	{
	1025	uiBitsOriginallyInSubstreams += pcSubstreams[iSubstrmIdx].getNumberOfWrittenBits();
	1026	}
	1027
	1028	for (UInt ui = 0; ui < uiTilesAcross; ui++)
	1029	{
	1030	m_pcBufferLowLatSbacCoders[ui].load(m_pcSbacCoder); //init. state
	1031	}
	1032	}
	1033
	1034	UInt uiWidthInLCUs = rpcPic->getPicSym()->getFrameWidthInCU();
	1035	UInt uiCol=0, uiLin=0, uiSubStrm=0;
	1036	UInt uiTileCol = 0;
	1037	UInt uiTileStartLCU = 0;
	1038	UInt uiTileLCUX = 0;
	1039
	1040	UInt uiEncCUOrder;
[231]	1041
[56]	1042	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap( uiStartCUAddr /rpcPic->getNumPartInCU()); /*for tiles, uiStartCUAddr is NOT the real raster scan address, it is actually
	1043	an encoding order index, so we need to convert the index (uiStartCUAddr)
	1044	into the real raster scan address (uiCUAddr) via the CUOrderMap*/
	1045	for( uiEncCUOrder = uiStartCUAddr /rpcPic->getNumPartInCU();
	1046	uiEncCUOrder < (uiBoundingCUAddr+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU();
	1047	uiCUAddr = rpcPic->getPicSym()->getCUOrderMap(++uiEncCUOrder) )
	1048	{
	1049	if( m_pcCfg->getUseSBACRD() )
	1050	{
	1051	uiTileCol = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr) % (rpcPic->getPicSym()->getNumColumnsMinus1()+1); // what column of tiles are we in?
	1052	uiTileStartLCU = rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
	1053	uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
	1054	//UInt uiSliceStartLCU = pcSlice->getSliceCurStartCUAddr();
	1055	uiCol = uiCUAddr % uiWidthInLCUs;
	1056	uiLin = uiCUAddr / uiWidthInLCUs;
	1057	if (pcSlice->getPPS()->getNumSubstreams() > 1)
	1058	{
	1059	// independent tiles => substreams are "per tile". iNumSubstreams has already been multiplied.
	1060	Int iNumSubstreamsPerTile = iNumSubstreams/rpcPic->getPicSym()->getNumTiles();
	1061	uiSubStrm = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)*iNumSubstreamsPerTile
	1062	+ uiLin%iNumSubstreamsPerTile;
	1063	}
	1064	else
	1065	{
	1066	// dependent tiles => substreams are "per frame".
	1067	uiSubStrm = uiLin % iNumSubstreams;
	1068	}
	1069
	1070	m_pcEntropyCoder->setBitstream( &pcSubstreams[uiSubStrm] );
	1071
	1072	// Synchronize cabac probabilities with upper-right LCU if it's available and we're at the start of a line.
	1073	if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiCol == uiTileLCUX))
	1074	{
	1075	// We'll sync if the TR is available.
	1076	TComDataCU *pcCUUp = rpcPic->getCU( uiCUAddr )->getCUAbove();
	1077	UInt uiWidthInCU = rpcPic->getFrameWidthInCU();
	1078	UInt uiMaxParts = 1<<(pcSlice->getSPS()->getMaxCUDepth()<<1);
	1079	TComDataCU *pcCUTR = NULL;
	1080	if ( pcCUUp && ((uiCUAddr%uiWidthInCU+1) < uiWidthInCU) )
	1081	{
	1082	pcCUTR = rpcPic->getCU( uiCUAddr - uiWidthInCU + 1 );
	1083	}
	1084	if ( (true/bEnforceSliceRestriction/ &&
	1085	((pcCUTR==NULL) \|\| (pcCUTR->getSlice()==NULL) \|\|
	1086	(pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getSliceCurStartCUAddr()) \|\|
	1087	((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))
	1088	))\|\|
	1089	(true/bEnforceEntropySliceRestriction/ &&
	1090	((pcCUTR==NULL) \|\| (pcCUTR->getSlice()==NULL) \|\|
	1091	(pcCUTR->getSCUAddr()+uiMaxParts-1 < pcSlice->getEntropySliceCurStartCUAddr()) \|\|
	1092	((rpcPic->getPicSym()->getTileIdxMap( pcCUTR->getAddr() ) != rpcPic->getPicSym()->getTileIdxMap(uiCUAddr)))
	1093	))
	1094	)
	1095	{
	1096	// TR not available.
	1097	}
	1098	else
	1099	{
	1100	// TR is available, we use it.
	1101	pcSbacCoders[uiSubStrm].loadContexts( &m_pcBufferSbacCoders[uiTileCol] );
	1102	}
	1103	}
	1104	m_pcSbacCoder->load(&pcSbacCoders[uiSubStrm]); //this load is used to simplify the code (avoid to change all the call to m_pcSbacCoder)
	1105	}
	1106	// reset the entropy coder
	1107	if( uiCUAddr == rpcPic->getPicSym()->getTComTile(rpcPic->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr() && // must be first CU of tile
	1108	uiCUAddr!=0 && // cannot be first CU of picture
	1109	uiCUAddr!=rpcPic->getPicSym()->getPicSCUAddr(rpcPic->getSlice(rpcPic->getCurrSliceIdx())->getSliceCurStartCUAddr())/rpcPic->getNumPartInCU()) // cannot be first CU of slice
	1110	{
	1111	Int iTileIdx = rpcPic->getPicSym()->getTileIdxMap(uiCUAddr);
	1112	Bool bWriteTileMarker = false;
	1113	// check if current iTileIdx should have a marker
	1114	for (Int iEntryIdx=0; iEntryIdx<m_pcCfg->getMaxTileMarkerEntryPoints()-1; iEntryIdx++)
	1115	{
	1116	bWriteTileMarker = ( (((Int)((iEntryIdx+1)*m_pcCfg->getMaxTileMarkerOffset()+0.5)) == iTileIdx ) && iEntryIdx < (m_pcCfg->getMaxTileMarkerEntryPoints()-1)) ? true : false;
	1117	if (bWriteTileMarker)
	1118	{
	1119	break;
	1120	}
	1121	}
	1122	{
	1123	// We're crossing into another tile, tiles are independent.
	1124	// When tiles are independent, we have "substreams per tile". Each substream has already been terminated, and we no longer
	1125	// have to perform it here.
	1126	if (pcSlice->getPPS()->getNumSubstreams() > 1)
	1127	{
	1128	; // do nothing.
	1129	}
	1130	else
	1131	{
	1132	#if CABAC_INIT_FLAG
	1133	SliceType sliceType = pcSlice->getSliceType();
	1134	if (!pcSlice->isIntra() && pcSlice->getPPS()->getCabacInitPresentFlag() && pcSlice->getPPS()->getEncCABACTableIdx()!=0)
	1135	{
	1136	sliceType = (SliceType) pcSlice->getPPS()->getEncCABACTableIdx();
	1137	}
	1138	m_pcEntropyCoder->updateContextTables( sliceType, pcSlice->getSliceQp() );
	1139	#else
	1140	m_pcEntropyCoder->updateContextTables( pcSlice->getSliceType(), pcSlice->getSliceQp() );
	1141	#endif
	1142	pcSubstreams[uiSubStrm].write( 1, 1 );
	1143	pcSubstreams[uiSubStrm].writeAlignZero();
	1144	}
	1145	}
	1146	{
	1147	// Write TileMarker into the appropriate substream (nothing has been written to it yet).
	1148	if (m_pcCfg->getTileMarkerFlag() && bWriteTileMarker)
	1149	{
	1150	// Log locations where tile markers are to be inserted during emulation prevention
	1151	UInt uiMarkerCount = pcSubstreams[uiSubStrm].getTileMarkerLocationCount();
	1152	pcSubstreams[uiSubStrm].setTileMarkerLocation ( uiMarkerCount, pcSubstreams[uiSubStrm].getNumberOfWrittenBits() >> 3 );
	1153	pcSubstreams[uiSubStrm].setTileMarkerLocationCount( uiMarkerCount + 1 );
	1154	// Write tile index
	1155	m_pcEntropyCoder->writeTileMarker(iTileIdx, rpcPic->getPicSym()->getBitsUsedByTileIdx()); // Tile index
	1156	}
	1157
	1158
	1159	UInt uiAccumulatedSubstreamLength = 0;
	1160	for (Int iSubstrmIdx=0; iSubstrmIdx < iNumSubstreams; iSubstrmIdx++)
	1161	{
	1162	uiAccumulatedSubstreamLength += pcSubstreams[iSubstrmIdx].getNumberOfWrittenBits();
	1163	}
	1164	UInt uiLocationCount = pcSlice->getTileLocationCount();
	1165	// add bits coded in previous entropy slices + bits coded so far
	1166	pcSlice->setTileLocation( uiLocationCount, (pcSlice->getTileOffstForMultES() + uiAccumulatedSubstreamLength - uiBitsOriginallyInSubstreams) >> 3 );
	1167	pcSlice->setTileLocationCount( uiLocationCount + 1 );
	1168	}
	1169	}
	1170
[189]	1171	#if OL_QTLIMIT_PREDCODING_B0068
	1172	rpcPic->setReduceBitsFlag(true);
	1173	#endif
	1174
[56]	1175	TComDataCU*& pcCU = rpcPic->getCU( uiCUAddr );
	1176
	1177	if ( pcSlice->getSPS()->getUseSAO() && pcSlice->getAPS()->getSaoInterleavingFlag() && pcSlice->getSaoEnabledFlag() )
	1178	{
	1179	Int iNumCuInWidth = pcSlice->getAPS()->getSaoParam()->numCuInWidth;
	1180	Int iCUAddrInSlice = uiCUAddr - (pcSlice->getSliceCurStartCUAddr() /rpcPic->getNumPartInCU());
	1181	Int iCUAddrUpInSlice = iCUAddrInSlice - iNumCuInWidth;
	1182	Int rx = uiCUAddr % iNumCuInWidth;
	1183	Int ry = uiCUAddr / iNumCuInWidth;
	1184	m_pcEntropyCoder->encodeSaoUnitInterleaving( rx, ry, pcSlice->getAPS()->getSaoParam(),pcCU, iCUAddrInSlice, iCUAddrUpInSlice, pcSlice->getSPS()->getLFCrossSliceBoundaryFlag());
	1185	}
[2]	1186	#if ENC_DEC_TRACE
	1187	g_bJustDoIt = g_bEncDecTraceEnable;
	1188	#endif
[56]	1189	if ( (m_pcCfg->getSliceMode()!=0 \|\| m_pcCfg->getEntropySliceMode()!=0) &&
	1190	uiCUAddr == rpcPic->getPicSym()->getCUOrderMap((uiBoundingCUAddr+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU()-1) )
[2]	1191	{
	1192	m_pcCuEncoder->encodeCU( pcCU, true );
	1193	}
	1194	else
	1195	{
	1196	m_pcCuEncoder->encodeCU( pcCU );
	1197	}
	1198	#if ENC_DEC_TRACE
	1199	g_bJustDoIt = g_bEncDecTraceDisable;
[56]	1200	#endif
	1201	if( m_pcCfg->getUseSBACRD() )
	1202	{
	1203	pcSbacCoders[uiSubStrm].load(m_pcSbacCoder); //load back status of the entropy coder after encoding the LCU into relevant bitstream entropy coder
	1204
	1205
	1206	//Store probabilties of second LCU in line into buffer
	1207	if (pcSlice->getPPS()->getNumSubstreams() > 1 && (uiCol == uiTileLCUX+1))
	1208	{
	1209	m_pcBufferSbacCoders[uiTileCol].loadContexts( &pcSbacCoders[uiSubStrm] );
	1210	}
	1211	}
[189]	1212
	1213	#if OL_QTLIMIT_PREDCODING_B0068
	1214	rpcPic->setReduceBitsFlag(false);
	1215	#endif
	1216
[2]	1217	}
[56]	1218
	1219	#if ADAPTIVE_QP_SELECTION
	1220	if( m_pcCfg->getUseAdaptQpSelect() )
	1221	{
	1222	m_pcTrQuant->storeSliceQpNext(pcSlice);
	1223	}
	1224	#endif
	1225	#if CABAC_INIT_FLAG
	1226	if (pcSlice->getPPS()->getCabacInitPresentFlag())
	1227	{
	1228	m_pcEntropyCoder->determineCabacInitIdx();
	1229	}
	1230	#endif
[2]	1231	}
	1232
	1233	/** Determines the starting and bounding LCU address of current slice / entropy slice
	1234	* \param bEncodeSlice Identifies if the calling function is compressSlice() [false] or encodeSlice() [true]
	1235	* \returns Updates uiStartCUAddr, uiBoundingCUAddr with appropriate LCU address
	1236	*/
	1237	Void TEncSlice::xDetermineStartAndBoundingCUAddr ( UInt& uiStartCUAddr, UInt& uiBoundingCUAddr, TComPic*& rpcPic, Bool bEncodeSlice )
	1238	{
	1239	TComSlice* pcSlice = rpcPic->getSlice(getSliceIdx());
	1240	UInt uiStartCUAddrSlice, uiBoundingCUAddrSlice;
[56]	1241	UInt tileIdxIncrement;
	1242	UInt tileIdx;
	1243	UInt tileWidthInLcu;
	1244	UInt tileHeightInLcu;
	1245	UInt tileTotalCount;
	1246
[2]	1247	uiStartCUAddrSlice = pcSlice->getSliceCurStartCUAddr();
	1248	UInt uiNumberOfCUsInFrame = rpcPic->getNumCUsInFrame();
	1249	uiBoundingCUAddrSlice = uiNumberOfCUsInFrame;
[56]	1250	if (bEncodeSlice)
[2]	1251	{
	1252	UInt uiCUAddrIncrement;
	1253	switch (m_pcCfg->getSliceMode())
	1254	{
	1255	case AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE:
	1256	uiCUAddrIncrement = m_pcCfg->getSliceArgument();
[56]	1257	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
[2]	1258	break;
	1259	case AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE:
	1260	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1261	uiBoundingCUAddrSlice = pcSlice->getSliceCurEndCUAddr();
	1262	break;
[56]	1263	case AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE:
	1264	tileIdx = rpcPic->getPicSym()->getTileIdxMap(
	1265	rpcPic->getPicSym()->getCUOrderMap(uiStartCUAddrSlice/rpcPic->getNumPartInCU())
	1266	);
	1267	uiCUAddrIncrement = 0;
	1268	tileTotalCount = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1);
	1269
	1270	for(tileIdxIncrement = 0; tileIdxIncrement < m_pcCfg->getSliceArgument(); tileIdxIncrement++)
	1271	{
	1272	if((tileIdx + tileIdxIncrement) < tileTotalCount)
	1273	{
	1274	tileWidthInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth();
	1275	tileHeightInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight();
	1276	uiCUAddrIncrement += (tileWidthInLcu * tileHeightInLcu * rpcPic->getNumPartInCU()) >> (m_pcCfg->getSliceGranularity() << 1);
	1277	}
	1278	}
	1279
	1280	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1281	break;
[2]	1282	default:
	1283	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
[56]	1284	uiBoundingCUAddrSlice = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
[2]	1285	break;
[56]	1286	}
[2]	1287	pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice );
	1288	}
	1289	else
	1290	{
	1291	UInt uiCUAddrIncrement ;
	1292	switch (m_pcCfg->getSliceMode())
	1293	{
	1294	case AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE:
	1295	uiCUAddrIncrement = m_pcCfg->getSliceArgument();
[56]	1296	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
[2]	1297	break;
[56]	1298	case AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE:
	1299	tileIdx = rpcPic->getPicSym()->getTileIdxMap(
	1300	rpcPic->getPicSym()->getCUOrderMap(uiStartCUAddrSlice/rpcPic->getNumPartInCU())
	1301	);
	1302	uiCUAddrIncrement = 0;
	1303	tileTotalCount = (rpcPic->getPicSym()->getNumColumnsMinus1()+1) * (rpcPic->getPicSym()->getNumRowsMinus1()+1);
	1304
	1305	for(tileIdxIncrement = 0; tileIdxIncrement < m_pcCfg->getSliceArgument(); tileIdxIncrement++)
	1306	{
	1307	if((tileIdx + tileIdxIncrement) < tileTotalCount)
	1308	{
	1309	tileWidthInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileWidth();
	1310	tileHeightInLcu = rpcPic->getPicSym()->getTComTile(tileIdx + tileIdxIncrement)->getTileHeight();
	1311	uiCUAddrIncrement += (tileWidthInLcu * tileHeightInLcu * rpcPic->getNumPartInCU()) >> (m_pcCfg->getSliceGranularity() << 1);
	1312	}
	1313	}
	1314
	1315	uiBoundingCUAddrSlice = ((uiStartCUAddrSlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU()) ? (uiStartCUAddrSlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
	1316	break;
[2]	1317	default:
	1318	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
[56]	1319	uiBoundingCUAddrSlice = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
[2]	1320	break;
[56]	1321	}
[2]	1322	pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice );
	1323	}
	1324
[56]	1325	Bool tileBoundary = false;
	1326	if ((m_pcCfg->getSliceMode() == AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE \|\| m_pcCfg->getSliceMode() == AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE) &&
	1327	(m_pcCfg->getNumRowsMinus1() > 0 \|\| m_pcCfg->getNumColumnsMinus1() > 0))
	1328	{
	1329	UInt lcuEncAddr = (uiStartCUAddrSlice+rpcPic->getNumPartInCU()-1)/rpcPic->getNumPartInCU();
	1330	UInt lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddr);
	1331	UInt startTileIdx = rpcPic->getPicSym()->getTileIdxMap(lcuAddr);
	1332	UInt tileBoundingCUAddrSlice = 0;
	1333	while (lcuEncAddr < uiNumberOfCUsInFrame && rpcPic->getPicSym()->getTileIdxMap(lcuAddr) == startTileIdx)
	1334	{
	1335	lcuEncAddr++;
	1336	lcuAddr = rpcPic->getPicSym()->getCUOrderMap(lcuEncAddr);
	1337	}
	1338	tileBoundingCUAddrSlice = lcuEncAddr*rpcPic->getNumPartInCU();
	1339
	1340	if (tileBoundingCUAddrSlice < uiBoundingCUAddrSlice)
	1341	{
	1342	uiBoundingCUAddrSlice = tileBoundingCUAddrSlice;
	1343	pcSlice->setSliceCurEndCUAddr( uiBoundingCUAddrSlice );
	1344	tileBoundary = true;
	1345	}
	1346	}
	1347
[2]	1348	// Entropy slice
	1349	UInt uiStartCUAddrEntropySlice, uiBoundingCUAddrEntropySlice;
	1350	uiStartCUAddrEntropySlice = pcSlice->getEntropySliceCurStartCUAddr();
	1351	uiBoundingCUAddrEntropySlice = uiNumberOfCUsInFrame;
[56]	1352	if (bEncodeSlice)
[2]	1353	{
	1354	UInt uiCUAddrIncrement;
	1355	switch (m_pcCfg->getEntropySliceMode())
	1356	{
	1357	case SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE:
	1358	uiCUAddrIncrement = m_pcCfg->getEntropySliceArgument();
[56]	1359	uiBoundingCUAddrEntropySlice = ((uiStartCUAddrEntropySlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU() ) ? (uiStartCUAddrEntropySlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
[2]	1360	break;
	1361	case SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE:
	1362	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
	1363	uiBoundingCUAddrEntropySlice = pcSlice->getEntropySliceCurEndCUAddr();
	1364	break;
	1365	default:
	1366	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
[56]	1367	uiBoundingCUAddrEntropySlice = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
[2]	1368	break;
[56]	1369	}
[2]	1370	pcSlice->setEntropySliceCurEndCUAddr( uiBoundingCUAddrEntropySlice );
	1371	}
	1372	else
	1373	{
	1374	UInt uiCUAddrIncrement;
	1375	switch (m_pcCfg->getEntropySliceMode())
	1376	{
	1377	case SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE:
	1378	uiCUAddrIncrement = m_pcCfg->getEntropySliceArgument();
[56]	1379	uiBoundingCUAddrEntropySlice = ((uiStartCUAddrEntropySlice + uiCUAddrIncrement) < uiNumberOfCUsInFramerpcPic->getNumPartInCU() ) ? (uiStartCUAddrEntropySlice + uiCUAddrIncrement) : uiNumberOfCUsInFramerpcPic->getNumPartInCU();
[2]	1380	break;
	1381	default:
	1382	uiCUAddrIncrement = rpcPic->getNumCUsInFrame();
[56]	1383	uiBoundingCUAddrEntropySlice = uiNumberOfCUsInFrame*rpcPic->getNumPartInCU();
[2]	1384	break;
[56]	1385	}
[2]	1386	pcSlice->setEntropySliceCurEndCUAddr( uiBoundingCUAddrEntropySlice );
	1387	}
[56]	1388	if(uiBoundingCUAddrEntropySlice>uiBoundingCUAddrSlice)
	1389	{
	1390	uiBoundingCUAddrEntropySlice = uiBoundingCUAddrSlice;
	1391	pcSlice->setEntropySliceCurEndCUAddr(uiBoundingCUAddrSlice);
	1392	}
	1393	//calculate real entropy slice start address
	1394	UInt uiInternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurStartCUAddr()) % rpcPic->getNumPartInCU();
	1395	UInt uiExternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurStartCUAddr()) / rpcPic->getNumPartInCU();
	1396	UInt uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	1397	UInt uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	1398	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	1399	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
	1400	while((uiPosX>=uiWidth\|\|uiPosY>=uiHeight)&&!(uiPosX>=uiWidth&&uiPosY>=uiHeight))
	1401	{
	1402	uiInternalAddress++;
	1403	if(uiInternalAddress>=rpcPic->getNumPartInCU())
	1404	{
	1405	uiInternalAddress=0;
	1406	uiExternalAddress = rpcPic->getPicSym()->getCUOrderMap(rpcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
	1407	}
	1408	uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	1409	uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	1410	}
	1411	UInt uiRealStartAddress = rpcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*rpcPic->getNumPartInCU()+uiInternalAddress);
	1412
	1413	pcSlice->setEntropySliceCurStartCUAddr(uiRealStartAddress);
	1414	uiStartCUAddrEntropySlice=uiRealStartAddress;
	1415
	1416	//calculate real slice start address
	1417	uiInternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceCurStartCUAddr()) % rpcPic->getNumPartInCU();
	1418	uiExternalAddress = rpcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceCurStartCUAddr()) / rpcPic->getNumPartInCU();
	1419	uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	1420	uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	1421	uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	1422	uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
	1423	while((uiPosX>=uiWidth\|\|uiPosY>=uiHeight)&&!(uiPosX>=uiWidth&&uiPosY>=uiHeight))
	1424	{
	1425	uiInternalAddress++;
	1426	if(uiInternalAddress>=rpcPic->getNumPartInCU())
	1427	{
	1428	uiInternalAddress=0;
	1429	uiExternalAddress = rpcPic->getPicSym()->getCUOrderMap(rpcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
	1430	}
	1431	uiPosX = ( uiExternalAddress % rpcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	1432	uiPosY = ( uiExternalAddress / rpcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	1433	}
	1434	uiRealStartAddress = rpcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*rpcPic->getNumPartInCU()+uiInternalAddress);
	1435
	1436	pcSlice->setSliceCurStartCUAddr(uiRealStartAddress);
	1437	uiStartCUAddrSlice=uiRealStartAddress;
	1438
[2]	1439	// Make a joint decision based on reconstruction and entropy slice bounds
	1440	uiStartCUAddr = max(uiStartCUAddrSlice , uiStartCUAddrEntropySlice );
	1441	uiBoundingCUAddr = min(uiBoundingCUAddrSlice, uiBoundingCUAddrEntropySlice);
	1442
	1443
	1444	if (!bEncodeSlice)
	1445	{
	1446	// 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
	1447	// first. Set the flags accordingly.
	1448	if ( (m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE && m_pcCfg->getEntropySliceMode()==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
	1449	\|\| (m_pcCfg->getSliceMode()==0 && m_pcCfg->getEntropySliceMode()==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
[56]	1450	\|\| (m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_LCU_IN_SLICE && m_pcCfg->getEntropySliceMode()==0)
	1451	\|\| (m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE && m_pcCfg->getEntropySliceMode()==SHARP_FIXED_NUMBER_OF_LCU_IN_ENTROPY_SLICE)
	1452	\|\| (m_pcCfg->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_TILES_IN_SLICE && m_pcCfg->getEntropySliceMode()==0)
	1453	\|\| tileBoundary
	1454	)
[2]	1455	{
	1456	if (uiBoundingCUAddrSlice < uiBoundingCUAddrEntropySlice)
	1457	{
	1458	pcSlice->setNextSlice ( true );
	1459	pcSlice->setNextEntropySlice( false );
	1460	}
	1461	else if (uiBoundingCUAddrSlice > uiBoundingCUAddrEntropySlice)
	1462	{
	1463	pcSlice->setNextSlice ( false );
	1464	pcSlice->setNextEntropySlice( true );
	1465	}
	1466	else
	1467	{
	1468	pcSlice->setNextSlice ( true );
	1469	pcSlice->setNextEntropySlice( true );
	1470	}
	1471	}
	1472	else
	1473	{
	1474	pcSlice->setNextSlice ( false );
	1475	pcSlice->setNextEntropySlice( false );
	1476	}
	1477	}
	1478	}
[56]	1479	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-5.1-dev0/source/Lib/TLibEncoder/TEncSlice.cpp @ 1399

Download in other formats: