Context navigation

source: SHVCSoftware/trunk/source/Lib/TLibEncoder/TEncCu.cpp @ 594

Visit:

Last change on this file since 594 was 588, checked in by seregin, 11 years ago
merge with SHM-5.0-dev
Property svn:eol-style set to `native`
File size: 71.5 KB

Rev	Line
[313]	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 TEncCu.cpp
	35	\brief Coding Unit (CU) encoder class
	36	*/
	37
	38	#include <stdio.h>
	39	#include "TEncTop.h"
	40	#include "TEncCu.h"
	41	#include "TEncAnalyze.h"
	42
	43	#include <cmath>
	44	#include <algorithm>
	45	using namespace std;
	46
	47	//! \ingroup TLibEncoder
	48	//! \{
	49
	50	// ====================================================================================================================
	51	// Constructor / destructor / create / destroy
	52	// ====================================================================================================================
	53
	54	/**
	55	\param uiTotalDepth total number of allowable depth
	56	\param uiMaxWidth largest CU width
	57	\param uiMaxHeight largest CU height
	58	*/
	59	Void TEncCu::create(UChar uhTotalDepth, UInt uiMaxWidth, UInt uiMaxHeight)
	60	{
	61	Int i;
	62
	63	m_uhTotalDepth = uhTotalDepth + 1;
	64	m_ppcBestCU = new TComDataCU*[m_uhTotalDepth-1];
	65	m_ppcTempCU = new TComDataCU*[m_uhTotalDepth-1];
	66
	67	m_ppcPredYuvBest = new TComYuv*[m_uhTotalDepth-1];
	68	m_ppcResiYuvBest = new TComYuv*[m_uhTotalDepth-1];
	69	m_ppcRecoYuvBest = new TComYuv*[m_uhTotalDepth-1];
	70	m_ppcPredYuvTemp = new TComYuv*[m_uhTotalDepth-1];
	71	m_ppcResiYuvTemp = new TComYuv*[m_uhTotalDepth-1];
	72	m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
	73	m_ppcOrigYuv = new TComYuv*[m_uhTotalDepth-1];
	74
	75	UInt uiNumPartitions;
	76	for( i=0 ; i<m_uhTotalDepth-1 ; i++)
	77	{
	78	uiNumPartitions = 1<<( ( m_uhTotalDepth - i - 1 )<<1 );
	79	UInt uiWidth = uiMaxWidth >> i;
	80	UInt uiHeight = uiMaxHeight >> i;
	81
	82	m_ppcBestCU[i] = new TComDataCU; m_ppcBestCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
	83	m_ppcTempCU[i] = new TComDataCU; m_ppcTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
	84
	85	m_ppcPredYuvBest[i] = new TComYuv; m_ppcPredYuvBest[i]->create(uiWidth, uiHeight);
	86	m_ppcResiYuvBest[i] = new TComYuv; m_ppcResiYuvBest[i]->create(uiWidth, uiHeight);
	87	m_ppcRecoYuvBest[i] = new TComYuv; m_ppcRecoYuvBest[i]->create(uiWidth, uiHeight);
	88
	89	m_ppcPredYuvTemp[i] = new TComYuv; m_ppcPredYuvTemp[i]->create(uiWidth, uiHeight);
	90	m_ppcResiYuvTemp[i] = new TComYuv; m_ppcResiYuvTemp[i]->create(uiWidth, uiHeight);
	91	m_ppcRecoYuvTemp[i] = new TComYuv; m_ppcRecoYuvTemp[i]->create(uiWidth, uiHeight);
	92
	93	m_ppcOrigYuv [i] = new TComYuv; m_ppcOrigYuv [i]->create(uiWidth, uiHeight);
	94	}
	95
	96	m_bEncodeDQP = false;
	97
	98	// initialize partition order.
	99	UInt* piTmp = &g_auiZscanToRaster[0];
	100	initZscanToRaster( m_uhTotalDepth, 1, 0, piTmp);
	101	initRasterToZscan( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
	102
	103	// initialize conversion matrix from partition index to pel
	104	initRasterToPelXY( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
	105	}
	106
	107	Void TEncCu::destroy()
	108	{
	109	Int i;
	110
	111	for( i=0 ; i<m_uhTotalDepth-1 ; i++)
	112	{
	113	if(m_ppcBestCU[i])
	114	{
	115	m_ppcBestCU[i]->destroy(); delete m_ppcBestCU[i]; m_ppcBestCU[i] = NULL;
	116	}
	117	if(m_ppcTempCU[i])
	118	{
	119	m_ppcTempCU[i]->destroy(); delete m_ppcTempCU[i]; m_ppcTempCU[i] = NULL;
	120	}
	121	if(m_ppcPredYuvBest[i])
	122	{
	123	m_ppcPredYuvBest[i]->destroy(); delete m_ppcPredYuvBest[i]; m_ppcPredYuvBest[i] = NULL;
	124	}
	125	if(m_ppcResiYuvBest[i])
	126	{
	127	m_ppcResiYuvBest[i]->destroy(); delete m_ppcResiYuvBest[i]; m_ppcResiYuvBest[i] = NULL;
	128	}
	129	if(m_ppcRecoYuvBest[i])
	130	{
	131	m_ppcRecoYuvBest[i]->destroy(); delete m_ppcRecoYuvBest[i]; m_ppcRecoYuvBest[i] = NULL;
	132	}
	133	if(m_ppcPredYuvTemp[i])
	134	{
	135	m_ppcPredYuvTemp[i]->destroy(); delete m_ppcPredYuvTemp[i]; m_ppcPredYuvTemp[i] = NULL;
	136	}
	137	if(m_ppcResiYuvTemp[i])
	138	{
	139	m_ppcResiYuvTemp[i]->destroy(); delete m_ppcResiYuvTemp[i]; m_ppcResiYuvTemp[i] = NULL;
	140	}
	141	if(m_ppcRecoYuvTemp[i])
	142	{
	143	m_ppcRecoYuvTemp[i]->destroy(); delete m_ppcRecoYuvTemp[i]; m_ppcRecoYuvTemp[i] = NULL;
	144	}
	145	if(m_ppcOrigYuv[i])
	146	{
	147	m_ppcOrigYuv[i]->destroy(); delete m_ppcOrigYuv[i]; m_ppcOrigYuv[i] = NULL;
	148	}
	149	}
	150	if(m_ppcBestCU)
	151	{
	152	delete [] m_ppcBestCU;
	153	m_ppcBestCU = NULL;
	154	}
	155	if(m_ppcTempCU)
	156	{
	157	delete [] m_ppcTempCU;
	158	m_ppcTempCU = NULL;
	159	}
	160
	161	if(m_ppcPredYuvBest)
	162	{
	163	delete [] m_ppcPredYuvBest;
	164	m_ppcPredYuvBest = NULL;
	165	}
	166	if(m_ppcResiYuvBest)
	167	{
	168	delete [] m_ppcResiYuvBest;
	169	m_ppcResiYuvBest = NULL;
	170	}
	171	if(m_ppcRecoYuvBest)
	172	{
	173	delete [] m_ppcRecoYuvBest;
	174	m_ppcRecoYuvBest = NULL;
	175	}
	176	if(m_ppcPredYuvTemp)
	177	{
	178	delete [] m_ppcPredYuvTemp;
	179	m_ppcPredYuvTemp = NULL;
	180	}
	181	if(m_ppcResiYuvTemp)
	182	{
	183	delete [] m_ppcResiYuvTemp;
	184	m_ppcResiYuvTemp = NULL;
	185	}
	186	if(m_ppcRecoYuvTemp)
	187	{
	188	delete [] m_ppcRecoYuvTemp;
	189	m_ppcRecoYuvTemp = NULL;
	190	}
	191	if(m_ppcOrigYuv)
	192	{
	193	delete [] m_ppcOrigYuv;
	194	m_ppcOrigYuv = NULL;
	195	}
	196	}
	197
	198	/** \param pcEncTop pointer of encoder class
	199	*/
	200	Void TEncCu::init( TEncTop* pcEncTop )
	201	{
	202	m_pcEncCfg = pcEncTop;
	203	m_pcPredSearch = pcEncTop->getPredSearch();
	204	m_pcTrQuant = pcEncTop->getTrQuant();
	205	m_pcBitCounter = pcEncTop->getBitCounter();
	206	m_pcRdCost = pcEncTop->getRdCost();
	207
	208	#if SVC_EXTENSION
	209	m_ppcTEncTop = pcEncTop->getLayerEnc();
	210	for(UInt i=0 ; i< m_uhTotalDepth-1 ; i++)
	211	{
	212	m_ppcBestCU[i]->setLayerId(pcEncTop->getLayerId());
	213	m_ppcTempCU[i]->setLayerId(pcEncTop->getLayerId());
	214	}
	215	#endif
	216
	217	m_pcEntropyCoder = pcEncTop->getEntropyCoder();
	218	m_pcCavlcCoder = pcEncTop->getCavlcCoder();
	219	m_pcSbacCoder = pcEncTop->getSbacCoder();
	220	m_pcBinCABAC = pcEncTop->getBinCABAC();
	221
	222	m_pppcRDSbacCoder = pcEncTop->getRDSbacCoder();
	223	m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
	224
	225	m_bUseSBACRD = pcEncTop->getUseSBACRD();
	226	m_pcRateCtrl = pcEncTop->getRateCtrl();
	227	}
	228
	229	// ====================================================================================================================
	230	// Public member functions
	231	// ====================================================================================================================
	232
	233	/** \param rpcCU pointer of CU data class
	234	*/
	235	Void TEncCu::compressCU( TComDataCU*& rpcCU )
	236	{
	237	// initialize CU data
	238	m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
	239	m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
	240
[494]	241	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	242	m_disableILP = xCheckTileSetConstraint(rpcCU);
	243	m_pcPredSearch->setDisableILP(m_disableILP);
	244	#endif
	245
[313]	246	// analysis of CU
	247	xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
	248
	249	#if ADAPTIVE_QP_SELECTION
	250	if( m_pcEncCfg->getUseAdaptQpSelect() )
	251	{
	252	if(rpcCU->getSlice()->getSliceType()!=I_SLICE) //IIII
	253	{
	254	xLcuCollectARLStats( rpcCU);
	255	}
	256	}
	257	#endif
[494]	258
	259	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	260	xVerifyTileSetConstraint(rpcCU);
	261	#endif
[313]	262	}
	263	/** \param pcCU pointer of CU data class
	264	*/
	265	Void TEncCu::encodeCU ( TComDataCU* pcCU )
	266	{
	267	if ( pcCU->getSlice()->getPPS()->getUseDQP() )
	268	{
	269	setdQPFlag(true);
	270	}
	271
	272	// Encode CU data
	273	xEncodeCU( pcCU, 0, 0 );
	274	}
	275
	276	// ====================================================================================================================
	277	// Protected member functions
	278	// ====================================================================================================================
	279	/** Derive small set of test modes for AMP encoder speed-up
	280	*\param rpcBestCU
	281	*\param eParentPartSize
	282	*\param bTestAMP_Hor
	283	*\param bTestAMP_Ver
	284	*\param bTestMergeAMP_Hor
	285	*\param bTestMergeAMP_Ver
	286	*\returns Void
	287	*/
	288	#if AMP_ENC_SPEEDUP
	289	#if AMP_MRG
	290	Void TEncCu::deriveTestModeAMP (TComDataCU *&rpcBestCU, PartSize eParentPartSize, Bool &bTestAMP_Hor, Bool &bTestAMP_Ver, Bool &bTestMergeAMP_Hor, Bool &bTestMergeAMP_Ver)
	291	#else
	292	Void TEncCu::deriveTestModeAMP (TComDataCU *&rpcBestCU, PartSize eParentPartSize, Bool &bTestAMP_Hor, Bool &bTestAMP_Ver)
	293	#endif
	294	{
	295	if ( rpcBestCU->getPartitionSize(0) == SIZE_2NxN )
	296	{
	297	bTestAMP_Hor = true;
	298	}
	299	else if ( rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
	300	{
	301	bTestAMP_Ver = true;
	302	}
	303	else if ( rpcBestCU->getPartitionSize(0) == SIZE_2Nx2N && rpcBestCU->getMergeFlag(0) == false && rpcBestCU->isSkipped(0) == false )
	304	{
	305	bTestAMP_Hor = true;
	306	bTestAMP_Ver = true;
	307	}
	308
	309	#if AMP_MRG
	310	//! Utilizing the partition size of parent PU
	311	if ( eParentPartSize >= SIZE_2NxnU && eParentPartSize <= SIZE_nRx2N )
	312	{
	313	bTestMergeAMP_Hor = true;
	314	bTestMergeAMP_Ver = true;
	315	}
	316
	317	if ( eParentPartSize == SIZE_NONE ) //! if parent is intra
	318	{
	319	if ( rpcBestCU->getPartitionSize(0) == SIZE_2NxN )
	320	{
	321	bTestMergeAMP_Hor = true;
	322	}
	323	else if ( rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
	324	{
	325	bTestMergeAMP_Ver = true;
	326	}
	327	}
	328
	329	if ( rpcBestCU->getPartitionSize(0) == SIZE_2Nx2N && rpcBestCU->isSkipped(0) == false )
	330	{
	331	bTestMergeAMP_Hor = true;
	332	bTestMergeAMP_Ver = true;
	333	}
	334
	335	if ( rpcBestCU->getWidth(0) == 64 )
	336	{
	337	bTestAMP_Hor = false;
	338	bTestAMP_Ver = false;
	339	}
	340	#else
	341	//! Utilizing the partition size of parent PU
	342	if ( eParentPartSize >= SIZE_2NxnU && eParentPartSize <= SIZE_nRx2N )
	343	{
	344	bTestAMP_Hor = true;
	345	bTestAMP_Ver = true;
	346	}
	347
	348	if ( eParentPartSize == SIZE_2Nx2N )
	349	{
	350	bTestAMP_Hor = false;
	351	bTestAMP_Ver = false;
	352	}
	353	#endif
	354	}
	355	#endif
	356
	357	// ====================================================================================================================
	358	// Protected member functions
	359	// ====================================================================================================================
	360	/** Compress a CU block recursively with enabling sub-LCU-level delta QP
	361	*\param rpcBestCU
	362	*\param rpcTempCU
	363	*\param uiDepth
	364	*\returns Void
	365	*
	366	*- for loop of QP value to compress the current CU with all possible QP
	367	*/
	368	#if AMP_ENC_SPEEDUP
	369	Void TEncCu::xCompressCU( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UInt uiDepth, PartSize eParentPartSize )
	370	#else
	371	Void TEncCu::xCompressCU( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UInt uiDepth )
	372	#endif
	373	{
	374	TComPic* pcPic = rpcBestCU->getPic();
	375
	376	// get Original YUV data from picture
	377	m_ppcOrigYuv[uiDepth]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
	378
	379	// variable for Early CU determination
	380	Bool bSubBranch = true;
	381
	382	// variable for Cbf fast mode PU decision
	383	Bool doNotBlockPu = true;
	384	Bool earlyDetectionSkipMode = false;
	385
	386	Bool bBoundary = false;
	387	UInt uiLPelX = rpcBestCU->getCUPelX();
	388	UInt uiRPelX = uiLPelX + rpcBestCU->getWidth(0) - 1;
	389	UInt uiTPelY = rpcBestCU->getCUPelY();
	390	UInt uiBPelY = uiTPelY + rpcBestCU->getHeight(0) - 1;
	391
	392	Int iBaseQP = xComputeQP( rpcBestCU, uiDepth );
	393	Int iMinQP;
	394	Int iMaxQP;
	395	Bool isAddLowestQP = false;
[442]	396	#if REPN_FORMAT_IN_VPS
	397	Int lowestQP = -rpcTempCU->getSlice()->getQpBDOffsetY();
	398	#else
[313]	399	Int lowestQP = -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY();
[442]	400	#endif
[313]	401
	402	if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
	403	{
	404	Int idQP = m_pcEncCfg->getMaxDeltaQP();
[442]	405	#if REPN_FORMAT_IN_VPS
[313]	406	iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
	407	iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
[442]	408	#else
	409	iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
	410	iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
	411	#endif
[313]	412	if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
	413	{
	414	isAddLowestQP = true;
	415	iMinQP = iMinQP - 1;
	416	}
	417	}
	418	else
	419	{
	420	iMinQP = rpcTempCU->getQP(0);
	421	iMaxQP = rpcTempCU->getQP(0);
	422	}
	423
	424	if ( m_pcEncCfg->getUseRateCtrl() )
	425	{
	426	iMinQP = m_pcRateCtrl->getRCQP();
	427	iMaxQP = m_pcRateCtrl->getRCQP();
	428	}
	429
	430	// If slice start or slice end is within this cu...
	431	TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
	432	Bool bSliceStart = pcSlice->getSliceSegmentCurStartCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getSliceSegmentCurStartCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart();
	433	Bool bSliceEnd = (pcSlice->getSliceSegmentCurEndCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getSliceSegmentCurEndCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart());
[442]	434	#if REPN_FORMAT_IN_VPS
	435	Bool bInsidePicture = ( uiRPelX < rpcBestCU->getSlice()->getPicWidthInLumaSamples() ) && ( uiBPelY < rpcBestCU->getSlice()->getPicHeightInLumaSamples() );
	436	#else
[313]	437	Bool bInsidePicture = ( uiRPelX < rpcBestCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < rpcBestCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
[442]	438	#endif
[313]	439	// We need to split, so don't try these modes.
	440	if(!bSliceEnd && !bSliceStart && bInsidePicture )
	441	{
[540]	442	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	443	if (m_pcEncCfg->getSkipPictureAtArcSwitch() && m_pcEncCfg->getAdaptiveResolutionChange() > 0 && pcSlice->getLayerId() == 1 && pcSlice->getPOC() == m_pcEncCfg->getAdaptiveResolutionChange())
	444	{
	445	rpcTempCU->initEstData( uiDepth, iBaseQP );
	446
	447	xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, &earlyDetectionSkipMode, true );
	448	}
	449	else
	450	{
	451	#endif
[313]	452	#if (ENCODER_FAST_MODE)
	453	Bool testInter = true;
	454	if (rpcBestCU->getLayerId() > 0)
	455	{
[442]	456	if(pcSlice->getSliceType() == P_SLICE && pcSlice->getNumRefIdx(REF_PIC_LIST_0) == pcSlice->getActiveNumILRRefIdx())
	457	{
	458	testInter = false;
	459	}
	460	if(pcSlice->getSliceType() == B_SLICE && pcSlice->getNumRefIdx(REF_PIC_LIST_0) == pcSlice->getActiveNumILRRefIdx() && pcSlice->getNumRefIdx(REF_PIC_LIST_1) == pcSlice->getActiveNumILRRefIdx())
	461	{
	462	testInter = false;
	463	}
[313]	464	}
	465	#endif
	466	for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
	467	{
	468	if (isAddLowestQP && (iQP == iMinQP))
	469	{
	470	iQP = lowestQP;
	471	}
	472
	473	rpcTempCU->initEstData( uiDepth, iQP );
	474
	475	// do inter modes, SKIP and 2Nx2N
	476	#if (ENCODER_FAST_MODE == 1)
	477	if( rpcBestCU->getSlice()->getSliceType() != I_SLICE && testInter )
	478	#else
	479	if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
	480	#endif
	481	{
	482	// 2Nx2N
	483	if(m_pcEncCfg->getUseEarlySkipDetection())
	484	{
	485	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N ); rpcTempCU->initEstData( uiDepth, iQP );//by Competition for inter_2Nx2N
	486	}
	487	// SKIP
	488	xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, &earlyDetectionSkipMode );//by Merge for inter_2Nx2N
	489	rpcTempCU->initEstData( uiDepth, iQP );
[442]	490
[313]	491	#if (ENCODER_FAST_MODE == 2)
	492	if (testInter)
	493	{
	494	#endif
	495	if(!m_pcEncCfg->getUseEarlySkipDetection())
	496	{
	497	// 2Nx2N, NxN
[442]	498	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N ); rpcTempCU->initEstData( uiDepth, iQP );
	499	if(m_pcEncCfg->getUseCbfFastMode())
[313]	500	{
[442]	501	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
[313]	502	}
	503	}
	504	#if (ENCODER_FAST_MODE == 2)
[442]	505	}
[313]	506	#endif
	507	}
	508
	509	if (isAddLowestQP && (iQP == lowestQP))
	510	{
	511	iQP = iMinQP;
	512	}
	513	}
	514
	515	if(!earlyDetectionSkipMode)
	516	{
	517	for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
	518	{
	519	if (isAddLowestQP && (iQP == iMinQP))
	520	{
	521	iQP = lowestQP;
	522	}
	523	rpcTempCU->initEstData( uiDepth, iQP );
	524
	525	// do inter modes, NxN, 2NxN, and Nx2N
	526	#if (ENCODER_FAST_MODE)
[442]	527	if( rpcBestCU->getSlice()->getSliceType() != I_SLICE && testInter )
[313]	528	#else
	529	if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
	530	#endif
	531	{
	532	// 2Nx2N, NxN
[442]	533	if(!( (rpcBestCU->getWidth(0)==8) && (rpcBestCU->getHeight(0)==8) ))
[313]	534	{
[442]	535	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && doNotBlockPu)
[313]	536	{
[442]	537	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN );
	538	rpcTempCU->initEstData( uiDepth, iQP );
[313]	539	}
	540	}
	541
	542	// 2NxN, Nx2N
	543	if(doNotBlockPu)
	544	{
	545	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N );
	546	rpcTempCU->initEstData( uiDepth, iQP );
	547	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
	548	{
	549	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	550	}
	551	}
	552	if(doNotBlockPu)
	553	{
	554	xCheckRDCostInter ( rpcBestCU, rpcTempCU, SIZE_2NxN );
	555	rpcTempCU->initEstData( uiDepth, iQP );
	556	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxN)
	557	{
	558	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	559	}
	560	}
	561
	562	#if 1
	563	//! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
	564	if( pcPic->getSlice(0)->getSPS()->getAMPAcc(uiDepth) )
	565	{
	566	#if AMP_ENC_SPEEDUP
	567	Bool bTestAMP_Hor = false, bTestAMP_Ver = false;
	568
	569	#if AMP_MRG
	570	Bool bTestMergeAMP_Hor = false, bTestMergeAMP_Ver = false;
	571
	572	deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver, bTestMergeAMP_Hor, bTestMergeAMP_Ver);
	573	#else
	574	deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver);
	575	#endif
	576
	577	//! Do horizontal AMP
	578	if ( bTestAMP_Hor )
	579	{
	580	if(doNotBlockPu)
	581	{
	582	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
	583	rpcTempCU->initEstData( uiDepth, iQP );
	584	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
	585	{
	586	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	587	}
	588	}
	589	if(doNotBlockPu)
	590	{
	591	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
	592	rpcTempCU->initEstData( uiDepth, iQP );
	593	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
	594	{
	595	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	596	}
	597	}
	598	}
	599	#if AMP_MRG
	600	else if ( bTestMergeAMP_Hor )
	601	{
	602	if(doNotBlockPu)
	603	{
	604	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, true );
	605	rpcTempCU->initEstData( uiDepth, iQP );
	606	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
	607	{
	608	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	609	}
	610	}
	611	if(doNotBlockPu)
	612	{
	613	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, true );
	614	rpcTempCU->initEstData( uiDepth, iQP );
	615	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
	616	{
	617	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	618	}
	619	}
	620	}
	621	#endif
	622
	623	//! Do horizontal AMP
	624	if ( bTestAMP_Ver )
	625	{
	626	if(doNotBlockPu)
	627	{
	628	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
	629	rpcTempCU->initEstData( uiDepth, iQP );
	630	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
	631	{
	632	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	633	}
	634	}
	635	if(doNotBlockPu)
	636	{
	637	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
	638	rpcTempCU->initEstData( uiDepth, iQP );
	639	}
	640	}
	641	#if AMP_MRG
	642	else if ( bTestMergeAMP_Ver )
	643	{
	644	if(doNotBlockPu)
	645	{
	646	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, true );
	647	rpcTempCU->initEstData( uiDepth, iQP );
	648	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
	649	{
	650	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
	651	}
	652	}
	653	if(doNotBlockPu)
	654	{
	655	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, true );
	656	rpcTempCU->initEstData( uiDepth, iQP );
	657	}
	658	}
	659	#endif
	660
	661	#else
	662	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
	663	rpcTempCU->initEstData( uiDepth, iQP );
	664	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
	665	rpcTempCU->initEstData( uiDepth, iQP );
	666	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
	667	rpcTempCU->initEstData( uiDepth, iQP );
	668
	669	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
	670	rpcTempCU->initEstData( uiDepth, iQP );
	671
	672	#endif
	673	}
	674	#endif
	675	}
	676
	677	// do normal intra modes
	678	// speedup for inter frames
	679	#if (ENCODER_FAST_MODE)
	680	if( rpcBestCU->getSlice()->getSliceType() == I_SLICE \|\|
	681	!testInter \|\|
	682	rpcBestCU->getCbf( 0, TEXT_LUMA ) != 0 \|\|
	683	rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0 \|\|
	684	rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0 ) // avoid very complex intra if it is unlikely
	685	#else
	686	if( rpcBestCU->getSlice()->getSliceType() == I_SLICE \|\|
	687	rpcBestCU->getCbf( 0, TEXT_LUMA ) != 0 \|\|
	688	rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0 \|\|
	689	rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0 ) // avoid very complex intra if it is unlikely
	690	#endif
	691	{
	692	xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
	693	rpcTempCU->initEstData( uiDepth, iQP );
	694	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
	695	{
	696	if( rpcTempCU->getWidth(0) > ( 1 << rpcTempCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() ) )
	697	{
	698	xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN );
	699	rpcTempCU->initEstData( uiDepth, iQP );
	700	}
	701	}
	702	}
	703
	704	// test PCM
	705	if(pcPic->getSlice(0)->getSPS()->getUsePCM()
	706	&& rpcTempCU->getWidth(0) <= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MaxSize())
	707	&& rpcTempCU->getWidth(0) >= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MinSize()) )
	708	{
	709	UInt uiRawBits = (2 * g_bitDepthY + g_bitDepthC) * rpcBestCU->getWidth(0) * rpcBestCU->getHeight(0) / 2;
	710	UInt uiBestBits = rpcBestCU->getTotalBits();
	711	if((uiBestBits > uiRawBits) \|\| (rpcBestCU->getTotalCost() > m_pcRdCost->calcRdCost(uiRawBits, 0)))
	712	{
	713	xCheckIntraPCM (rpcBestCU, rpcTempCU);
	714	rpcTempCU->initEstData( uiDepth, iQP );
	715	}
	716	}
	717	#if (ENCODER_FAST_MODE)
[494]	718	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	719	if(pcPic->getLayerId() > 0 && !m_disableILP)
	720	#else
[313]	721	if(pcPic->getLayerId() > 0)
[494]	722	#endif
[313]	723	{
	724	for(Int refLayer = 0; refLayer < pcSlice->getActiveNumILRRefIdx(); refLayer++)
	725	{
	726	xCheckRDCostILRUni( rpcBestCU, rpcTempCU, pcSlice->getInterLayerPredLayerIdc(refLayer));
	727	rpcTempCU->initEstData( uiDepth, iQP );
	728	}
	729	}
	730	#endif
	731
	732	if (isAddLowestQP && (iQP == lowestQP))
	733	{
	734	iQP = iMinQP;
	735	}
	736	}
	737	}
	738
	739	m_pcEntropyCoder->resetBits();
	740	m_pcEntropyCoder->encodeSplitFlag( rpcBestCU, 0, uiDepth, true );
	741	rpcBestCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
	742	if(m_pcEncCfg->getUseSBACRD())
	743	{
	744	rpcBestCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
	745	}
	746	rpcBestCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
	747
	748	// Early CU determination
	749	if( m_pcEncCfg->getUseEarlyCU() && rpcBestCU->isSkipped(0) )
	750	{
	751	bSubBranch = false;
	752	}
	753	else
	754	{
	755	bSubBranch = true;
	756	}
[540]	757	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	758	}
	759	#endif
[313]	760	}
	761	else if(!(bSliceEnd && bInsidePicture))
	762	{
	763	bBoundary = true;
	764	}
	765
	766	// copy orginal YUV samples to PCM buffer
	767	if( rpcBestCU->isLosslessCoded(0) && (rpcBestCU->getIPCMFlag(0) == false))
	768	{
	769	xFillPCMBuffer(rpcBestCU, m_ppcOrigYuv[uiDepth]);
	770	}
	771	if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
	772	{
	773	Int idQP = m_pcEncCfg->getMaxDeltaQP();
[442]	774	#if REPN_FORMAT_IN_VPS
	775	iMinQP = Clip3( -rpcTempCU->getSlice()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
	776	iMaxQP = Clip3( -rpcTempCU->getSlice()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
	777	#else
[313]	778	iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
	779	iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
[442]	780	#endif
[313]	781	if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
	782	{
	783	isAddLowestQP = true;
	784	iMinQP = iMinQP - 1;
	785	}
	786	}
	787	else if( (g_uiMaxCUWidth>>uiDepth) > rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
	788	{
	789	iMinQP = iBaseQP;
	790	iMaxQP = iBaseQP;
	791	}
	792	else
	793	{
	794	Int iStartQP;
	795	if( pcPic->getCU( rpcTempCU->getAddr() )->getSliceSegmentStartCU(rpcTempCU->getZorderIdxInCU()) == pcSlice->getSliceSegmentCurStartCUAddr())
	796	{
	797	iStartQP = rpcTempCU->getQP(0);
	798	}
	799	else
	800	{
	801	UInt uiCurSliceStartPartIdx = pcSlice->getSliceSegmentCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
	802	iStartQP = rpcTempCU->getQP(uiCurSliceStartPartIdx);
	803	}
	804	iMinQP = iStartQP;
	805	iMaxQP = iStartQP;
	806	}
	807	if ( m_pcEncCfg->getUseRateCtrl() )
	808	{
	809	iMinQP = m_pcRateCtrl->getRCQP();
	810	iMaxQP = m_pcRateCtrl->getRCQP();
	811	}
	812	for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
	813	{
	814	if (isAddLowestQP && (iQP == iMinQP))
	815	{
	816	iQP = lowestQP;
	817	}
	818	rpcTempCU->initEstData( uiDepth, iQP );
	819
	820	// further split
[442]	821	if( bSubBranch && uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth )
[313]	822	{
	823	UChar uhNextDepth = uiDepth+1;
	824	TComDataCU* pcSubBestPartCU = m_ppcBestCU[uhNextDepth];
	825	TComDataCU* pcSubTempPartCU = m_ppcTempCU[uhNextDepth];
	826
	827	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
	828	{
	829	pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP ); // clear sub partition datas or init.
	830	pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP ); // clear sub partition datas or init.
	831
	832	Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getSliceSegmentCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getSliceSegmentCurEndCUAddr();
[442]	833	#if REPN_FORMAT_IN_VPS
	834	if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getPicHeightInLumaSamples() ) )
	835	#else
[313]	836	if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
[442]	837	#endif
[313]	838	{
	839	if( m_bUseSBACRD )
	840	{
	841	if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
	842	{
	843	m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
	844	}
	845	else
	846	{
	847	m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
	848	}
	849	}
	850
	851	#if AMP_ENC_SPEEDUP
	852	if ( rpcBestCU->isIntra(0) )
	853	{
	854	xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, SIZE_NONE );
	855	}
	856	else
	857	{
	858	xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, rpcBestCU->getPartitionSize(0) );
	859	}
	860	#else
	861	xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth );
	862	#endif
	863
	864	rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth ); // Keep best part data to current temporary data.
	865	xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
	866	}
	867	else if (bInSlice)
	868	{
	869	pcSubBestPartCU->copyToPic( uhNextDepth );
	870	rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
	871	}
	872	}
	873
	874	if( !bBoundary )
	875	{
	876	m_pcEntropyCoder->resetBits();
	877	m_pcEntropyCoder->encodeSplitFlag( rpcTempCU, 0, uiDepth, true );
	878
	879	rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
	880	if(m_pcEncCfg->getUseSBACRD())
	881	{
	882	rpcTempCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
	883	}
	884	}
	885	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
	886
	887	if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
	888	{
	889	Bool hasResidual = false;
	890	for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
	891	{
	892	if( ( pcPic->getCU( rpcTempCU->getAddr() )->getSliceSegmentStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getSliceSegmentCurStartCUAddr() ) &&
	893	( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) \|\| rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) \|\| rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
	894	{
	895	hasResidual = true;
	896	break;
	897	}
	898	}
	899
	900	UInt uiTargetPartIdx;
	901	if ( pcPic->getCU( rpcTempCU->getAddr() )->getSliceSegmentStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getSliceSegmentCurStartCUAddr() )
	902	{
	903	uiTargetPartIdx = pcSlice->getSliceSegmentCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
	904	}
	905	else
	906	{
	907	uiTargetPartIdx = 0;
	908	}
	909	if ( hasResidual )
	910	{
	911	#if !RDO_WITHOUT_DQP_BITS
	912	m_pcEntropyCoder->resetBits();
	913	m_pcEntropyCoder->encodeQP( rpcTempCU, uiTargetPartIdx, false );
	914	rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
	915	if(m_pcEncCfg->getUseSBACRD())
	916	{
	917	rpcTempCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
	918	}
	919	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
	920	#endif
	921
	922	Bool foundNonZeroCbf = false;
	923	rpcTempCU->setQPSubCUs( rpcTempCU->getRefQP( uiTargetPartIdx ), rpcTempCU, 0, uiDepth, foundNonZeroCbf );
	924	assert( foundNonZeroCbf );
	925	}
	926	else
	927	{
	928	rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uiDepth ); // set QP to default QP
	929	}
	930	}
	931
	932	if( m_bUseSBACRD )
	933	{
	934	m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
	935	}
	936	Bool isEndOfSlice = rpcBestCU->getSlice()->getSliceMode()==FIXED_NUMBER_OF_BYTES
	937	&& (rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getSliceArgument()<<3);
	938	Bool isEndOfSliceSegment = rpcBestCU->getSlice()->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES
	939	&& (rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getSliceSegmentArgument()<<3);
	940	if(isEndOfSlice\|\|isEndOfSliceSegment)
	941	{
	942	rpcBestCU->getTotalCost()=rpcTempCU->getTotalCost()+1;
	943	}
	944	xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth); // RD compare current larger prediction
	945	} // with sub partitioned prediction.
	946	if (isAddLowestQP && (iQP == lowestQP))
	947	{
	948	iQP = iMinQP;
	949	}
	950	}
	951
	952	rpcBestCU->copyToPic(uiDepth); // Copy Best data to Picture for next partition prediction.
	953
	954	xCopyYuv2Pic( rpcBestCU->getPic(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU(), uiDepth, uiDepth, rpcBestCU, uiLPelX, uiTPelY ); // Copy Yuv data to picture Yuv
	955	if( bBoundary \|\|(bSliceEnd && bInsidePicture))
	956	{
	957	return;
	958	}
	959
	960	// Assert if Best prediction mode is NONE
	961	// Selected mode's RD-cost must be not MAX_DOUBLE.
	962	assert( rpcBestCU->getPartitionSize ( 0 ) != SIZE_NONE );
	963	assert( rpcBestCU->getPredictionMode( 0 ) != MODE_NONE );
	964	assert( rpcBestCU->getTotalCost ( ) != MAX_DOUBLE );
	965	}
	966
	967	/** finish encoding a cu and handle end-of-slice conditions
	968	* \param pcCU
	969	* \param uiAbsPartIdx
	970	* \param uiDepth
	971	* \returns Void
	972	*/
	973	Void TEncCu::finishCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	974	{
	975	TComPic* pcPic = pcCU->getPic();
	976	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
	977
	978	//Calculate end address
	979	UInt uiCUAddr = pcCU->getSCUAddr()+uiAbsPartIdx;
	980
	981	UInt uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) % pcPic->getNumPartInCU();
	982	UInt uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getSliceSegmentCurEndCUAddr()-1) / pcPic->getNumPartInCU();
	983	UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	984	UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
[442]	985	#if REPN_FORMAT_IN_VPS
	986	UInt uiWidth = pcSlice->getPicWidthInLumaSamples();
	987	UInt uiHeight = pcSlice->getPicHeightInLumaSamples();
	988	#else
[313]	989	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
	990	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
[442]	991	#endif
[313]	992	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
	993	{
	994	uiInternalAddress--;
	995	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
	996	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
	997	}
	998	uiInternalAddress++;
	999	if(uiInternalAddress==pcCU->getPic()->getNumPartInCU())
	1000	{
	1001	uiInternalAddress = 0;
	1002	uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
	1003	}
	1004	UInt uiRealEndAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
	1005
	1006	// Encode slice finish
	1007	Bool bTerminateSlice = false;
	1008	if (uiCUAddr+(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)) == uiRealEndAddress)
	1009	{
	1010	bTerminateSlice = true;
	1011	}
	1012	UInt uiGranularityWidth = g_uiMaxCUWidth;
	1013	uiPosX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
	1014	uiPosY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
	1015	Bool granularityBoundary=((uiPosX+pcCU->getWidth(uiAbsPartIdx))%uiGranularityWidth==0\|\|(uiPosX+pcCU->getWidth(uiAbsPartIdx)==uiWidth))
	1016	&&((uiPosY+pcCU->getHeight(uiAbsPartIdx))%uiGranularityWidth==0\|\|(uiPosY+pcCU->getHeight(uiAbsPartIdx)==uiHeight));
	1017
	1018	if(granularityBoundary)
	1019	{
	1020	// The 1-terminating bit is added to all streams, so don't add it here when it's 1.
	1021	if (!bTerminateSlice)
	1022	m_pcEntropyCoder->encodeTerminatingBit( bTerminateSlice ? 1 : 0 );
	1023	}
	1024
	1025	Int numberOfWrittenBits = 0;
	1026	if (m_pcBitCounter)
	1027	{
	1028	numberOfWrittenBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	1029	}
	1030
	1031	// Calculate slice end IF this CU puts us over slice bit size.
	1032	UInt iGranularitySize = pcCU->getPic()->getNumPartInCU();
	1033	Int iGranularityEnd = ((pcCU->getSCUAddr()+uiAbsPartIdx)/iGranularitySize)*iGranularitySize;
	1034	if(iGranularityEnd<=pcSlice->getSliceSegmentCurStartCUAddr())
	1035	{
	1036	iGranularityEnd+=max(iGranularitySize,(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)));
	1037	}
	1038	// Set slice end parameter
	1039	if(pcSlice->getSliceMode()==FIXED_NUMBER_OF_BYTES&&!pcSlice->getFinalized()&&pcSlice->getSliceBits()+numberOfWrittenBits>pcSlice->getSliceArgument()<<3)
	1040	{
	1041	pcSlice->setSliceSegmentCurEndCUAddr(iGranularityEnd);
	1042	pcSlice->setSliceCurEndCUAddr(iGranularityEnd);
	1043	return;
	1044	}
	1045	// Set dependent slice end parameter
	1046	if(pcSlice->getSliceSegmentMode()==FIXED_NUMBER_OF_BYTES&&!pcSlice->getFinalized()&&pcSlice->getSliceSegmentBits()+numberOfWrittenBits > pcSlice->getSliceSegmentArgument()<<3)
	1047	{
	1048	pcSlice->setSliceSegmentCurEndCUAddr(iGranularityEnd);
	1049	return;
	1050	}
	1051	if(granularityBoundary)
	1052	{
	1053	pcSlice->setSliceBits( (UInt)(pcSlice->getSliceBits() + numberOfWrittenBits) );
	1054	pcSlice->setSliceSegmentBits(pcSlice->getSliceSegmentBits()+numberOfWrittenBits);
	1055	if (m_pcBitCounter)
	1056	{
	1057	m_pcEntropyCoder->resetBits();
	1058	}
	1059	}
	1060	}
	1061
	1062	/** Compute QP for each CU
	1063	* \param pcCU Target CU
	1064	* \param uiDepth CU depth
	1065	* \returns quantization parameter
	1066	*/
	1067	Int TEncCu::xComputeQP( TComDataCU* pcCU, UInt uiDepth )
	1068	{
	1069	Int iBaseQp = pcCU->getSlice()->getSliceQp();
	1070	Int iQpOffset = 0;
	1071	if ( m_pcEncCfg->getUseAdaptiveQP() )
	1072	{
	1073	TEncPic* pcEPic = dynamic_cast<TEncPic*>( pcCU->getPic() );
	1074	UInt uiAQDepth = min( uiDepth, pcEPic->getMaxAQDepth()-1 );
	1075	TEncPicQPAdaptationLayer* pcAQLayer = pcEPic->getAQLayer( uiAQDepth );
	1076	UInt uiAQUPosX = pcCU->getCUPelX() / pcAQLayer->getAQPartWidth();
	1077	UInt uiAQUPosY = pcCU->getCUPelY() / pcAQLayer->getAQPartHeight();
	1078	UInt uiAQUStride = pcAQLayer->getAQPartStride();
	1079	TEncQPAdaptationUnit* acAQU = pcAQLayer->getQPAdaptationUnit();
	1080
	1081	Double dMaxQScale = pow(2.0, m_pcEncCfg->getQPAdaptationRange()/6.0);
	1082	Double dAvgAct = pcAQLayer->getAvgActivity();
	1083	Double dCUAct = acAQU[uiAQUPosY * uiAQUStride + uiAQUPosX].getActivity();
	1084	Double dNormAct = (dMaxQScaledCUAct + dAvgAct) / (dCUAct + dMaxQScaledAvgAct);
	1085	Double dQpOffset = log(dNormAct) / log(2.0) * 6.0;
	1086	iQpOffset = Int(floor( dQpOffset + 0.49999 ));
	1087	}
[442]	1088	#if REPN_FORMAT_IN_VPS
	1089	return Clip3(-pcCU->getSlice()->getQpBDOffsetY(), MAX_QP, iBaseQp+iQpOffset );
	1090	#else
[313]	1091	return Clip3(-pcCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQp+iQpOffset );
[442]	1092	#endif
[313]	1093	}
	1094
	1095	/** encode a CU block recursively
	1096	* \param pcCU
	1097	* \param uiAbsPartIdx
	1098	* \param uiDepth
	1099	* \returns Void
	1100	*/
	1101	Void TEncCu::xEncodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
	1102	{
	1103	TComPic* pcPic = pcCU->getPic();
	1104
	1105	Bool bBoundary = false;
	1106	UInt uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
	1107	UInt uiRPelX = uiLPelX + (g_uiMaxCUWidth>>uiDepth) - 1;
	1108	UInt uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
	1109	UInt uiBPelY = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
	1110
	1111	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
[540]	1112	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	1113	if (m_pcEncCfg->getSkipPictureAtArcSwitch() && m_pcEncCfg->getAdaptiveResolutionChange() > 0 && pcSlice->getLayerId() == 1 && pcSlice->getPOC() == m_pcEncCfg->getAdaptiveResolutionChange())
	1114	{
	1115	pcCU->setSkipFlagSubParts(true, uiAbsPartIdx, uiDepth);
	1116	}
	1117	#endif
[313]	1118	// If slice start is within this cu...
	1119	Bool bSliceStart = pcSlice->getSliceSegmentCurStartCUAddr() > pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
	1120	pcSlice->getSliceSegmentCurStartCUAddr() < pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcPic->getNumPartInCU() >> (uiDepth<<1) );
	1121	// We need to split, so don't try these modes.
[442]	1122	#if REPN_FORMAT_IN_VPS
	1123	if(!bSliceStart&&( uiRPelX < pcSlice->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getPicHeightInLumaSamples() ) )
	1124	#else
[313]	1125	if(!bSliceStart&&( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
[442]	1126	#endif
[313]	1127	{
	1128	m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
	1129	}
	1130	else
	1131	{
	1132	bBoundary = true;
	1133	}
	1134
	1135	if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < (g_uiMaxCUDepth-g_uiAddCUDepth) ) ) \|\| bBoundary )
	1136	{
	1137	UInt uiQNumParts = ( pcPic->getNumPartInCU() >> (uiDepth<<1) )>>2;
	1138	if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
	1139	{
	1140	setdQPFlag(true);
	1141	}
	1142	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
	1143	{
	1144	uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
	1145	uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
	1146	Bool bInSlice = pcCU->getSCUAddr()+uiAbsPartIdx+uiQNumParts>pcSlice->getSliceSegmentCurStartCUAddr()&&pcCU->getSCUAddr()+uiAbsPartIdx<pcSlice->getSliceSegmentCurEndCUAddr();
[442]	1147	#if REPN_FORMAT_IN_VPS
	1148	if(bInSlice&&( uiLPelX < pcSlice->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getPicHeightInLumaSamples() ) )
	1149	#else
[313]	1150	if(bInSlice&&( uiLPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
[442]	1151	#endif
[313]	1152	{
	1153	xEncodeCU( pcCU, uiAbsPartIdx, uiDepth+1 );
	1154	}
	1155	}
	1156	return;
	1157	}
	1158
	1159	if( (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
	1160	{
	1161	setdQPFlag(true);
	1162	}
	1163	if (pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	1164	{
	1165	m_pcEntropyCoder->encodeCUTransquantBypassFlag( pcCU, uiAbsPartIdx );
	1166	}
	1167	if( !pcCU->getSlice()->isIntra() )
	1168	{
	1169	m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
	1170	}
	1171
	1172	if( pcCU->isSkipped( uiAbsPartIdx ) )
	1173	{
	1174	m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx );
	1175	finishCU(pcCU,uiAbsPartIdx,uiDepth);
	1176	return;
	1177	}
	1178	m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
	1179
	1180	m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
	1181
	1182	if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
	1183	{
	1184	m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );
	1185
	1186	if(pcCU->getIPCMFlag(uiAbsPartIdx))
	1187	{
	1188	// Encode slice finish
	1189	finishCU(pcCU,uiAbsPartIdx,uiDepth);
	1190	return;
	1191	}
	1192	}
	1193
	1194	// prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
	1195	m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
	1196
	1197	// Encode Coefficients
	1198	Bool bCodeDQP = getdQPFlag();
	1199	m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, pcCU->getWidth (uiAbsPartIdx), pcCU->getHeight(uiAbsPartIdx), bCodeDQP );
	1200	setdQPFlag( bCodeDQP );
	1201
	1202	// --- write terminating bit ---
	1203	finishCU(pcCU,uiAbsPartIdx,uiDepth);
	1204	}
	1205
	1206	Int xCalcHADs8x8_ISlice(Pel *piOrg, Int iStrideOrg)
	1207	{
	1208	Int k, i, j, jj;
	1209	Int diff[64], m1[8][8], m2[8][8], m3[8][8], iSumHad = 0;
	1210
	1211	for( k = 0; k < 64; k += 8 )
	1212	{
	1213	diff[k+0] = piOrg[0] ;
	1214	diff[k+1] = piOrg[1] ;
	1215	diff[k+2] = piOrg[2] ;
	1216	diff[k+3] = piOrg[3] ;
	1217	diff[k+4] = piOrg[4] ;
	1218	diff[k+5] = piOrg[5] ;
	1219	diff[k+6] = piOrg[6] ;
	1220	diff[k+7] = piOrg[7] ;
	1221
	1222	piOrg += iStrideOrg;
	1223	}
	1224
	1225	//horizontal
	1226	for (j=0; j < 8; j++)
	1227	{
	1228	jj = j << 3;
	1229	m2[j][0] = diff[jj ] + diff[jj+4];
	1230	m2[j][1] = diff[jj+1] + diff[jj+5];
	1231	m2[j][2] = diff[jj+2] + diff[jj+6];
	1232	m2[j][3] = diff[jj+3] + diff[jj+7];
	1233	m2[j][4] = diff[jj ] - diff[jj+4];
	1234	m2[j][5] = diff[jj+1] - diff[jj+5];
	1235	m2[j][6] = diff[jj+2] - diff[jj+6];
	1236	m2[j][7] = diff[jj+3] - diff[jj+7];
	1237
	1238	m1[j][0] = m2[j][0] + m2[j][2];
	1239	m1[j][1] = m2[j][1] + m2[j][3];
	1240	m1[j][2] = m2[j][0] - m2[j][2];
	1241	m1[j][3] = m2[j][1] - m2[j][3];
	1242	m1[j][4] = m2[j][4] + m2[j][6];
	1243	m1[j][5] = m2[j][5] + m2[j][7];
	1244	m1[j][6] = m2[j][4] - m2[j][6];
	1245	m1[j][7] = m2[j][5] - m2[j][7];
	1246
	1247	m2[j][0] = m1[j][0] + m1[j][1];
	1248	m2[j][1] = m1[j][0] - m1[j][1];
	1249	m2[j][2] = m1[j][2] + m1[j][3];
	1250	m2[j][3] = m1[j][2] - m1[j][3];
	1251	m2[j][4] = m1[j][4] + m1[j][5];
	1252	m2[j][5] = m1[j][4] - m1[j][5];
	1253	m2[j][6] = m1[j][6] + m1[j][7];
	1254	m2[j][7] = m1[j][6] - m1[j][7];
	1255	}
	1256
	1257	//vertical
	1258	for (i=0; i < 8; i++)
	1259	{
	1260	m3[0][i] = m2[0][i] + m2[4][i];
	1261	m3[1][i] = m2[1][i] + m2[5][i];
	1262	m3[2][i] = m2[2][i] + m2[6][i];
	1263	m3[3][i] = m2[3][i] + m2[7][i];
	1264	m3[4][i] = m2[0][i] - m2[4][i];
	1265	m3[5][i] = m2[1][i] - m2[5][i];
	1266	m3[6][i] = m2[2][i] - m2[6][i];
	1267	m3[7][i] = m2[3][i] - m2[7][i];
	1268
	1269	m1[0][i] = m3[0][i] + m3[2][i];
	1270	m1[1][i] = m3[1][i] + m3[3][i];
	1271	m1[2][i] = m3[0][i] - m3[2][i];
	1272	m1[3][i] = m3[1][i] - m3[3][i];
	1273	m1[4][i] = m3[4][i] + m3[6][i];
	1274	m1[5][i] = m3[5][i] + m3[7][i];
	1275	m1[6][i] = m3[4][i] - m3[6][i];
	1276	m1[7][i] = m3[5][i] - m3[7][i];
	1277
	1278	m2[0][i] = m1[0][i] + m1[1][i];
	1279	m2[1][i] = m1[0][i] - m1[1][i];
	1280	m2[2][i] = m1[2][i] + m1[3][i];
	1281	m2[3][i] = m1[2][i] - m1[3][i];
	1282	m2[4][i] = m1[4][i] + m1[5][i];
	1283	m2[5][i] = m1[4][i] - m1[5][i];
	1284	m2[6][i] = m1[6][i] + m1[7][i];
	1285	m2[7][i] = m1[6][i] - m1[7][i];
	1286	}
	1287
	1288	for (i = 0; i < 8; i++)
	1289	{
	1290	for (j = 0; j < 8; j++)
	1291	{
	1292	iSumHad += abs(m2[i][j]);
	1293	}
	1294	}
	1295	iSumHad -= abs(m2[0][0]);
	1296	iSumHad =(iSumHad+2)>>2;
	1297	return(iSumHad);
	1298	}
	1299
	1300	Int TEncCu::updateLCUDataISlice(TComDataCU* pcCU, Int LCUIdx, Int width, Int height)
	1301	{
	1302	Int xBl, yBl;
	1303	const Int iBlkSize = 8;
	1304
	1305	Pel* pOrgInit = pcCU->getPic()->getPicYuvOrg()->getLumaAddr(pcCU->getAddr(), 0);
	1306	Int iStrideOrig = pcCU->getPic()->getPicYuvOrg()->getStride();
	1307	Pel *pOrg;
	1308
	1309	Int iSumHad = 0;
	1310	for ( yBl=0; (yBl+iBlkSize)<=height; yBl+= iBlkSize)
	1311	{
	1312	for ( xBl=0; (xBl+iBlkSize)<=width; xBl+= iBlkSize)
	1313	{
	1314	pOrg = pOrgInit + iStrideOrig*yBl + xBl;
	1315	iSumHad += xCalcHADs8x8_ISlice(pOrg, iStrideOrig);
	1316	}
	1317	}
	1318	return(iSumHad);
	1319	}
	1320
	1321	/** check RD costs for a CU block encoded with merge
	1322	* \param rpcBestCU
	1323	* \param rpcTempCU
	1324	* \returns Void
	1325	*/
[540]	1326	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	1327	Void TEncCu::xCheckRDCostMerge2Nx2N( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, Bool *earlyDetectionSkipMode, Bool bUseSkip )
	1328	#else
[313]	1329	Void TEncCu::xCheckRDCostMerge2Nx2N( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, Bool *earlyDetectionSkipMode )
[540]	1330	#endif
[313]	1331	{
	1332	assert( rpcTempCU->getSlice()->getSliceType() != I_SLICE );
	1333	TComMvField cMvFieldNeighbours[ 2 * MRG_MAX_NUM_CANDS ]; // double length for mv of both lists
	1334	UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
	1335	Int numValidMergeCand = 0;
	1336
	1337	for( UInt ui = 0; ui < rpcTempCU->getSlice()->getMaxNumMergeCand(); ++ui )
	1338	{
	1339	uhInterDirNeighbours[ui] = 0;
	1340	}
	1341	UChar uhDepth = rpcTempCU->getDepth( 0 );
	1342	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
	1343	rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uhDepth );
	1344	rpcTempCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
	1345
	1346	Int mergeCandBuffer[MRG_MAX_NUM_CANDS];
	1347	for( UInt ui = 0; ui < numValidMergeCand; ++ui )
	1348	{
	1349	mergeCandBuffer[ui] = 0;
	1350	}
	1351
	1352	Bool bestIsSkip = false;
	1353
	1354	UInt iteration;
	1355	if ( rpcTempCU->isLosslessCoded(0))
	1356	{
	1357	iteration = 1;
	1358	}
	1359	else
	1360	{
	1361	iteration = 2;
	1362	}
	1363
[540]	1364	#if HIGHER_LAYER_IRAP_SKIP_FLAG
	1365	for( UInt uiNoResidual = bUseSkip?1:0; uiNoResidual < iteration; ++uiNoResidual )
	1366	#else
[313]	1367	for( UInt uiNoResidual = 0; uiNoResidual < iteration; ++uiNoResidual )
[540]	1368	#endif
[313]	1369	{
	1370	for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
	1371	{
	1372	#if REF_IDX_ME_ZEROMV
	1373	Bool bZeroMVILR = rpcTempCU->xCheckZeroMVILRMerge(uhInterDirNeighbours[uiMergeCand], cMvFieldNeighbours[0 + 2uiMergeCand], cMvFieldNeighbours[1 + 2uiMergeCand]);
	1374	if(bZeroMVILR)
	1375	{
	1376	#endif
[494]	1377	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	1378	if (!(rpcTempCU->isInterLayerReference(uhInterDirNeighbours[uiMergeCand], cMvFieldNeighbours[0 + 2uiMergeCand], cMvFieldNeighbours[1 + 2uiMergeCand]) && m_disableILP))
	1379	{
	1380	#endif
[313]	1381	if(!(uiNoResidual==1 && mergeCandBuffer[uiMergeCand]==1))
	1382	{
	1383	if( !(bestIsSkip && uiNoResidual == 0) )
	1384	{
	1385	// set MC parameters
	1386	rpcTempCU->setPredModeSubParts( MODE_INTER, 0, uhDepth ); // interprets depth relative to LCU level
	1387	rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uhDepth );
	1388	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
	1389	rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth ); // interprets depth relative to LCU level
	1390	rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth ); // interprets depth relative to LCU level
	1391	rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
	1392	rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
	1393	rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
	1394
	1395	// do MC
	1396	m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
	1397	// estimate residual and encode everything
	1398	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
	1399	m_ppcOrigYuv [uhDepth],
	1400	m_ppcPredYuvTemp[uhDepth],
	1401	m_ppcResiYuvTemp[uhDepth],
	1402	m_ppcResiYuvBest[uhDepth],
	1403	m_ppcRecoYuvTemp[uhDepth],
	1404	(uiNoResidual? true:false));
	1405
	1406
	1407	if ( uiNoResidual == 0 && rpcTempCU->getQtRootCbf(0) == 0 )
	1408	{
	1409	// If no residual when allowing for one, then set mark to not try case where residual is forced to 0
	1410	mergeCandBuffer[uiMergeCand] = 1;
	1411	}
	1412
	1413	rpcTempCU->setSkipFlagSubParts( rpcTempCU->getQtRootCbf(0) == 0, 0, uhDepth );
	1414	Int orgQP = rpcTempCU->getQP( 0 );
	1415	xCheckDQP( rpcTempCU );
	1416	xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
	1417	rpcTempCU->initEstData( uhDepth, orgQP );
	1418
	1419	if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
	1420	{
	1421	bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
	1422	}
	1423	}
[494]	1424	}
	1425	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	1426	}
	1427	#endif
[313]	1428	#if REF_IDX_ME_ZEROMV
[494]	1429	}
[313]	1430	#endif
	1431	}
	1432
	1433	if(uiNoResidual == 0 && m_pcEncCfg->getUseEarlySkipDetection())
	1434	{
	1435	if(rpcBestCU->getQtRootCbf( 0 ) == 0)
	1436	{
	1437	if( rpcBestCU->getMergeFlag( 0 ))
	1438	{
	1439	*earlyDetectionSkipMode = true;
	1440	}
	1441	else
	1442	{
	1443	Int absoulte_MV=0;
	1444	for ( UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx++ )
	1445	{
	1446	if ( rpcBestCU->getSlice()->getNumRefIdx( RefPicList( uiRefListIdx ) ) > 0 )
	1447	{
	1448	TComCUMvField* pcCUMvField = rpcBestCU->getCUMvField(RefPicList( uiRefListIdx ));
	1449	Int iHor = pcCUMvField->getMvd( 0 ).getAbsHor();
	1450	Int iVer = pcCUMvField->getMvd( 0 ).getAbsVer();
	1451	absoulte_MV+=iHor+iVer;
	1452	}
	1453	}
	1454
	1455	if(absoulte_MV == 0)
	1456	{
	1457	*earlyDetectionSkipMode = true;
	1458	}
	1459	}
	1460	}
	1461	}
	1462	}
	1463	}
	1464
	1465
	1466	#if AMP_MRG
	1467	Void TEncCu::xCheckRDCostInter( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize ePartSize, Bool bUseMRG)
	1468	#else
	1469	Void TEncCu::xCheckRDCostInter( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize ePartSize )
	1470	#endif
	1471	{
	1472	UChar uhDepth = rpcTempCU->getDepth( 0 );
	1473
	1474	rpcTempCU->setDepthSubParts( uhDepth, 0 );
	1475
	1476	rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
	1477
	1478	rpcTempCU->setPartSizeSubParts ( ePartSize, 0, uhDepth );
	1479	rpcTempCU->setPredModeSubParts ( MODE_INTER, 0, uhDepth );
	1480	rpcTempCU->setCUTransquantBypassSubParts ( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uhDepth );
	1481
	1482	#if AMP_MRG
	1483	rpcTempCU->setMergeAMP (true);
	1484	m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], false, bUseMRG );
	1485	#else
	1486	m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
	1487	#endif
	1488
	1489	#if AMP_MRG
	1490	if ( !rpcTempCU->getMergeAMP() )
	1491	{
	1492	return;
	1493	}
	1494	#endif
	1495
	1496	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false );
	1497	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
	1498
	1499	xCheckDQP( rpcTempCU );
	1500	xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
	1501	}
	1502
	1503	Void TEncCu::xCheckRDCostIntra( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize eSize )
	1504	{
	1505	UInt uiDepth = rpcTempCU->getDepth( 0 );
	1506
	1507	rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
	1508
	1509	rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
	1510	rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
	1511	rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uiDepth );
	1512
	1513	Bool bSeparateLumaChroma = true; // choose estimation mode
	1514	UInt uiPreCalcDistC = 0;
	1515	if( !bSeparateLumaChroma )
	1516	{
	1517	m_pcPredSearch->preestChromaPredMode( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth] );
	1518	}
	1519	m_pcPredSearch ->estIntraPredQT ( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC, bSeparateLumaChroma );
	1520
	1521	m_ppcRecoYuvTemp[uiDepth]->copyToPicLuma(rpcTempCU->getPic()->getPicYuvRec(), rpcTempCU->getAddr(), rpcTempCU->getZorderIdxInCU() );
	1522
	1523	m_pcPredSearch ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
	1524
	1525	m_pcEntropyCoder->resetBits();
	1526	if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	1527	{
	1528	m_pcEntropyCoder->encodeCUTransquantBypassFlag( rpcTempCU, 0, true );
	1529	}
	1530	m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0, true );
	1531	m_pcEntropyCoder->encodePredMode( rpcTempCU, 0, true );
	1532	m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
	1533	m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0, true );
	1534	m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
	1535
	1536	// Encode Coefficients
	1537	Bool bCodeDQP = getdQPFlag();
	1538	m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP );
	1539	setdQPFlag( bCodeDQP );
	1540
	1541	if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
	1542
	1543	rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
	1544	if(m_pcEncCfg->getUseSBACRD())
	1545	{
	1546	rpcTempCU->getTotalBins() = ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
	1547	}
	1548	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
	1549
	1550	xCheckDQP( rpcTempCU );
	1551	xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
	1552	}
	1553
	1554	/** Check R-D costs for a CU with PCM mode.
	1555	* \param rpcBestCU pointer to best mode CU data structure
	1556	* \param rpcTempCU pointer to testing mode CU data structure
	1557	* \returns Void
	1558	*
	1559	* \note Current PCM implementation encodes sample values in a lossless way. The distortion of PCM mode CUs are zero. PCM mode is selected if the best mode yields bits greater than that of PCM mode.
	1560	*/
	1561	Void TEncCu::xCheckIntraPCM( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU )
	1562	{
	1563	UInt uiDepth = rpcTempCU->getDepth( 0 );
	1564
	1565	rpcTempCU->setSkipFlagSubParts( false, 0, uiDepth );
	1566
	1567	rpcTempCU->setIPCMFlag(0, true);
	1568	rpcTempCU->setIPCMFlagSubParts (true, 0, rpcTempCU->getDepth(0));
	1569	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
	1570	rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
	1571	rpcTempCU->setTrIdxSubParts ( 0, 0, uiDepth );
	1572	rpcTempCU->setCUTransquantBypassSubParts( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uiDepth );
	1573
	1574	m_pcPredSearch->IPCMSearch( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth]);
	1575
	1576	if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
	1577
	1578	m_pcEntropyCoder->resetBits();
	1579	if ( rpcTempCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	1580	{
	1581	m_pcEntropyCoder->encodeCUTransquantBypassFlag( rpcTempCU, 0, true );
	1582	}
	1583	m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0, true );
	1584	m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0, true );
	1585	m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
	1586	m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
	1587
	1588	if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
	1589
	1590	rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
	1591	if(m_pcEncCfg->getUseSBACRD())
	1592	{
	1593	rpcTempCU->getTotalBins() = ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
	1594	}
	1595	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
	1596
	1597	xCheckDQP( rpcTempCU );
	1598	xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth );
	1599	}
	1600
	1601	/** check whether current try is the best with identifying the depth of current try
	1602	* \param rpcBestCU
	1603	* \param rpcTempCU
	1604	* \returns Void
	1605	*/
	1606	Void TEncCu::xCheckBestMode( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UInt uiDepth )
	1607	{
	1608	if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
	1609	{
	1610	TComYuv* pcYuv;
	1611	// Change Information data
	1612	TComDataCU* pcCU = rpcBestCU;
	1613	rpcBestCU = rpcTempCU;
	1614	rpcTempCU = pcCU;
	1615
	1616	// Change Prediction data
	1617	pcYuv = m_ppcPredYuvBest[uiDepth];
	1618	m_ppcPredYuvBest[uiDepth] = m_ppcPredYuvTemp[uiDepth];
	1619	m_ppcPredYuvTemp[uiDepth] = pcYuv;
	1620
	1621	// Change Reconstruction data
	1622	pcYuv = m_ppcRecoYuvBest[uiDepth];
	1623	m_ppcRecoYuvBest[uiDepth] = m_ppcRecoYuvTemp[uiDepth];
	1624	m_ppcRecoYuvTemp[uiDepth] = pcYuv;
	1625
	1626	pcYuv = NULL;
	1627	pcCU = NULL;
	1628
	1629	if( m_bUseSBACRD ) // store temp best CI for next CU coding
	1630	m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]);
	1631	}
	1632	}
	1633
	1634	Void TEncCu::xCheckDQP( TComDataCU* pcCU )
	1635	{
	1636	UInt uiDepth = pcCU->getDepth( 0 );
	1637
	1638	if( pcCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() )
	1639	{
	1640	if ( pcCU->getCbf( 0, TEXT_LUMA, 0 ) \|\| pcCU->getCbf( 0, TEXT_CHROMA_U, 0 ) \|\| pcCU->getCbf( 0, TEXT_CHROMA_V, 0 ) )
	1641	{
	1642	#if !RDO_WITHOUT_DQP_BITS
	1643	m_pcEntropyCoder->resetBits();
	1644	m_pcEntropyCoder->encodeQP( pcCU, 0, false );
	1645	pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
	1646	if(m_pcEncCfg->getUseSBACRD())
	1647	{
	1648	pcCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
	1649	}
	1650	pcCU->getTotalCost() = m_pcRdCost->calcRdCost( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
	1651	#endif
	1652	}
	1653	else
	1654	{
	1655	pcCU->setQPSubParts( pcCU->getRefQP( 0 ), 0, uiDepth ); // set QP to default QP
	1656	}
	1657	}
	1658	}
	1659
	1660	Void TEncCu::xCopyAMVPInfo (AMVPInfo* pSrc, AMVPInfo* pDst)
	1661	{
	1662	pDst->iN = pSrc->iN;
	1663	for (Int i = 0; i < pSrc->iN; i++)
	1664	{
	1665	pDst->m_acMvCand[i] = pSrc->m_acMvCand[i];
	1666	}
	1667	}
	1668	Void TEncCu::xCopyYuv2Pic(TComPic* rpcPic, UInt uiCUAddr, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSrcDepth, TComDataCU* pcCU, UInt uiLPelX, UInt uiTPelY )
	1669	{
	1670	UInt uiRPelX = uiLPelX + (g_uiMaxCUWidth>>uiDepth) - 1;
	1671	UInt uiBPelY = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
	1672	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
	1673	Bool bSliceStart = pcSlice->getSliceSegmentCurStartCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
	1674	pcSlice->getSliceSegmentCurStartCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
	1675	Bool bSliceEnd = pcSlice->getSliceSegmentCurEndCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
	1676	pcSlice->getSliceSegmentCurEndCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
[442]	1677	#if REPN_FORMAT_IN_VPS
	1678	if(!bSliceEnd && !bSliceStart && ( uiRPelX < pcSlice->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getPicHeightInLumaSamples() ) )
	1679	#else
[313]	1680	if(!bSliceEnd && !bSliceStart && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
[442]	1681	#endif
[313]	1682	{
	1683	UInt uiAbsPartIdxInRaster = g_auiZscanToRaster[uiAbsPartIdx];
	1684	UInt uiSrcBlkWidth = rpcPic->getNumPartInWidth() >> (uiSrcDepth);
	1685	UInt uiBlkWidth = rpcPic->getNumPartInWidth() >> (uiDepth);
	1686	UInt uiPartIdxX = ( ( uiAbsPartIdxInRaster % rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
	1687	UInt uiPartIdxY = ( ( uiAbsPartIdxInRaster / rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
	1688	UInt uiPartIdx = uiPartIdxY * ( uiSrcBlkWidth / uiBlkWidth ) + uiPartIdxX;
	1689	m_ppcRecoYuvBest[uiSrcDepth]->copyToPicYuv( rpcPic->getPicYuvRec (), uiCUAddr, uiAbsPartIdx, uiDepth - uiSrcDepth, uiPartIdx);
	1690	}
	1691	else
	1692	{
	1693	UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) )>>2;
	1694
	1695	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
	1696	{
	1697	UInt uiSubCULPelX = uiLPelX + ( g_uiMaxCUWidth >>(uiDepth+1) )*( uiPartUnitIdx & 1 );
	1698	UInt uiSubCUTPelY = uiTPelY + ( g_uiMaxCUHeight>>(uiDepth+1) )*( uiPartUnitIdx >> 1 );
	1699
	1700	Bool bInSlice = rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+uiQNumParts > pcSlice->getSliceSegmentCurStartCUAddr() &&
	1701	rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx < pcSlice->getSliceSegmentCurEndCUAddr();
[442]	1702	#if REPN_FORMAT_IN_VPS
	1703	if(bInSlice&&( uiSubCULPelX < pcSlice->getPicWidthInLumaSamples() ) && ( uiSubCUTPelY < pcSlice->getPicHeightInLumaSamples() ) )
	1704	#else
[313]	1705	if(bInSlice&&( uiSubCULPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiSubCUTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
[442]	1706	#endif
[313]	1707	{
	1708	xCopyYuv2Pic( rpcPic, uiCUAddr, uiAbsPartIdx, uiDepth+1, uiSrcDepth, pcCU, uiSubCULPelX, uiSubCUTPelY ); // Copy Yuv data to picture Yuv
	1709	}
	1710	}
	1711	}
	1712	}
	1713
	1714	Void TEncCu::xCopyYuv2Tmp( UInt uiPartUnitIdx, UInt uiNextDepth )
	1715	{
	1716	UInt uiCurrDepth = uiNextDepth - 1;
	1717	m_ppcRecoYuvBest[uiNextDepth]->copyToPartYuv( m_ppcRecoYuvTemp[uiCurrDepth], uiPartUnitIdx );
	1718	}
	1719
	1720	/** Function for filling the PCM buffer of a CU using its original sample array
	1721	* \param pcCU pointer to current CU
	1722	* \param pcOrgYuv pointer to original sample array
	1723	* \returns Void
	1724	*/
	1725	Void TEncCu::xFillPCMBuffer ( TComDataCU& pCU, TComYuv pOrgYuv )
	1726	{
	1727
	1728	UInt width = pCU->getWidth(0);
	1729	UInt height = pCU->getHeight(0);
	1730
	1731	Pel* pSrcY = pOrgYuv->getLumaAddr(0, width);
	1732	Pel* pDstY = pCU->getPCMSampleY();
	1733	UInt srcStride = pOrgYuv->getStride();
	1734
	1735	for(Int y = 0; y < height; y++ )
	1736	{
	1737	for(Int x = 0; x < width; x++ )
	1738	{
	1739	pDstY[x] = pSrcY[x];
	1740	}
	1741	pDstY += width;
	1742	pSrcY += srcStride;
	1743	}
	1744
	1745	Pel* pSrcCb = pOrgYuv->getCbAddr();
	1746	Pel* pSrcCr = pOrgYuv->getCrAddr();;
	1747
	1748	Pel* pDstCb = pCU->getPCMSampleCb();
	1749	Pel* pDstCr = pCU->getPCMSampleCr();;
	1750
	1751	UInt srcStrideC = pOrgYuv->getCStride();
	1752	UInt heightC = height >> 1;
	1753	UInt widthC = width >> 1;
	1754
	1755	for(Int y = 0; y < heightC; y++ )
	1756	{
	1757	for(Int x = 0; x < widthC; x++ )
	1758	{
	1759	pDstCb[x] = pSrcCb[x];
	1760	pDstCr[x] = pSrcCr[x];
	1761	}
	1762	pDstCb += widthC;
	1763	pDstCr += widthC;
	1764	pSrcCb += srcStrideC;
	1765	pSrcCr += srcStrideC;
	1766	}
	1767	}
	1768
	1769	#if ADAPTIVE_QP_SELECTION
	1770	/** Collect ARL statistics from one block
	1771	*/
	1772	Int TEncCu::xTuCollectARLStats(TCoeff* rpcCoeff, Int* rpcArlCoeff, Int NumCoeffInCU, Double* cSum, UInt* numSamples )
	1773	{
	1774	for( Int n = 0; n < NumCoeffInCU; n++ )
	1775	{
	1776	Int u = abs( rpcCoeff[ n ] );
	1777	Int absc = rpcArlCoeff[ n ];
	1778
	1779	if( u != 0 )
	1780	{
	1781	if( u < LEVEL_RANGE )
	1782	{
	1783	cSum[ u ] += ( Double )absc;
	1784	numSamples[ u ]++;
	1785	}
	1786	else
	1787	{
	1788	cSum[ LEVEL_RANGE ] += ( Double )absc - ( Double )( u << ARL_C_PRECISION );
	1789	numSamples[ LEVEL_RANGE ]++;
	1790	}
	1791	}
	1792	}
	1793
	1794	return 0;
	1795	}
	1796
[494]	1797	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	1798	Bool TEncCu::xCheckTileSetConstraint( TComDataCU*& rpcCU )
	1799	{
	1800	Bool disableILP = false;
	1801
	1802	if (rpcCU->getLayerId() == (m_pcEncCfg->getNumLayer() - 1) && m_pcEncCfg->getInterLayerConstrainedTileSetsSEIEnabled() && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(rpcCU->getAddr()) >= 0)
	1803	{
	1804	if (rpcCU->getPic()->getPicSym()->getTileSetType(rpcCU->getAddr()) == 2)
	1805	{
	1806	disableILP = true;
	1807	}
	1808	if (rpcCU->getPic()->getPicSym()->getTileSetType(rpcCU->getAddr()) == 1)
	1809	{
	1810	Int currCUaddr = rpcCU->getAddr();
	1811	Int frameWitdhInCU = rpcCU->getPic()->getPicSym()->getFrameWidthInCU();
	1812	Int frameHeightInCU = rpcCU->getPic()->getPicSym()->getFrameHeightInCU();
	1813	Bool leftCUExists = (currCUaddr % frameWitdhInCU) > 0;
	1814	Bool aboveCUExists = (currCUaddr / frameWitdhInCU) > 0;
	1815	Bool rightCUExists = (currCUaddr % frameWitdhInCU) < (frameWitdhInCU - 1);
	1816	Bool belowCUExists = (currCUaddr / frameWitdhInCU) < (frameHeightInCU - 1);
	1817	Int currTileSetIdx = rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr);
	1818	// Check if CU is at tile set boundary
	1819	if ( (leftCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr-1) != currTileSetIdx) \|\|
	1820	(leftCUExists && aboveCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr-frameWitdhInCU-1) != currTileSetIdx) \|\|
	1821	(aboveCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr-frameWitdhInCU) != currTileSetIdx) \|\|
	1822	(aboveCUExists && rightCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr-frameWitdhInCU+1) != currTileSetIdx) \|\|
	1823	(rightCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr+1) != currTileSetIdx) \|\|
	1824	(rightCUExists && belowCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr+frameWitdhInCU+1) != currTileSetIdx) \|\|
	1825	(belowCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr+frameWitdhInCU) != currTileSetIdx) \|\|
	1826	(belowCUExists && leftCUExists && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(currCUaddr+frameWitdhInCU-1) != currTileSetIdx) )
	1827	{
	1828	disableILP = true; // Disable ILP in tile set boundary CU
	1829	}
	1830	}
	1831	}
	1832
	1833	return disableILP;
	1834	}
	1835
	1836	Void TEncCu::xVerifyTileSetConstraint( TComDataCU*& rpcCU )
	1837	{
	1838	if (rpcCU->getLayerId() == (m_pcEncCfg->getNumLayer() - 1) && m_pcEncCfg->getInterLayerConstrainedTileSetsSEIEnabled() && rpcCU->getPic()->getPicSym()->getTileSetIdxMap(rpcCU->getAddr()) >= 0 &&
	1839	m_disableILP)
	1840	{
	1841	UInt numPartitions = rpcCU->getPic()->getNumPartInCU();
	1842	for (UInt i = 0; i < numPartitions; i++)
	1843	{
	1844	if (!rpcCU->isIntra(i))
	1845	{
	1846	for (UInt refList = 0; refList < 2; refList++)
	1847	{
	1848	if (rpcCU->getInterDir(i) & (1<<refList))
	1849	{
	1850	TComCUMvField *mvField = rpcCU->getCUMvField(RefPicList(refList));
	1851	if (mvField->getRefIdx(i) >= 0)
	1852	{
	1853	assert(!(rpcCU->getSlice()->getRefPic(RefPicList(refList), mvField->getRefIdx(i))->isILR(rpcCU->getLayerId())));
	1854	}
	1855	}
	1856	}
	1857	}
	1858	}
	1859	}
	1860	}
	1861	#endif
	1862
[313]	1863	/** Collect ARL statistics from one LCU
	1864	* \param pcCU
	1865	*/
	1866	Void TEncCu::xLcuCollectARLStats(TComDataCU* rpcCU )
	1867	{
	1868	Double cSum[ LEVEL_RANGE + 1 ]; //: the sum of DCT coefficients corresponding to datatype and quantization output
	1869	UInt numSamples[ LEVEL_RANGE + 1 ]; //: the number of coefficients corresponding to datatype and quantization output
	1870
	1871	TCoeff* pCoeffY = rpcCU->getCoeffY();
	1872	Int* pArlCoeffY = rpcCU->getArlCoeffY();
	1873
	1874	UInt uiMinCUWidth = g_uiMaxCUWidth >> g_uiMaxCUDepth;
	1875	UInt uiMinNumCoeffInCU = 1 << uiMinCUWidth;
	1876
	1877	memset( cSum, 0, sizeof( Double )*(LEVEL_RANGE+1) );
	1878	memset( numSamples, 0, sizeof( UInt )*(LEVEL_RANGE+1) );
	1879
	1880	// Collect stats to cSum[][] and numSamples[][]
	1881	for(Int i = 0; i < rpcCU->getTotalNumPart(); i ++ )
	1882	{
	1883	UInt uiTrIdx = rpcCU->getTransformIdx(i);
	1884
	1885	if(rpcCU->getPredictionMode(i) == MODE_INTER)
	1886	if( rpcCU->getCbf( i, TEXT_LUMA, uiTrIdx ) )
	1887	{
	1888	xTuCollectARLStats(pCoeffY, pArlCoeffY, uiMinNumCoeffInCU, cSum, numSamples);
	1889	}//Note that only InterY is processed. QP rounding is based on InterY data only.
	1890
	1891	pCoeffY += uiMinNumCoeffInCU;
	1892	pArlCoeffY += uiMinNumCoeffInCU;
	1893	}
	1894
	1895	for(Int u=1; u<LEVEL_RANGE;u++)
	1896	{
	1897	m_pcTrQuant->getSliceSumC()[u] += cSum[ u ] ;
	1898	m_pcTrQuant->getSliceNSamples()[u] += numSamples[ u ] ;
	1899	}
	1900	m_pcTrQuant->getSliceSumC()[LEVEL_RANGE] += cSum[ LEVEL_RANGE ] ;
	1901	m_pcTrQuant->getSliceNSamples()[LEVEL_RANGE] += numSamples[ LEVEL_RANGE ] ;
	1902	}
	1903	#endif
	1904
	1905	#if (ENCODER_FAST_MODE)
	1906	Void TEncCu::xCheckRDCostILRUni(TComDataCU &rpcBestCU, TComDataCU &rpcTempCU, UInt refLayerId)
	1907	{
	1908	UChar uhDepth = rpcTempCU->getDepth( 0 );
	1909	rpcTempCU->setDepthSubParts( uhDepth, 0 );
	1910	#if SKIP_FLAG
	1911	rpcTempCU->setSkipFlagSubParts( false, 0, uhDepth );
	1912	#endif
	1913	rpcTempCU->setPartSizeSubParts ( SIZE_2Nx2N, 0, uhDepth ); //2Nx2N
	1914	rpcTempCU->setPredModeSubParts ( MODE_INTER, 0, uhDepth );
	1915	rpcTempCU->setCUTransquantBypassSubParts ( m_pcEncCfg->getCUTransquantBypassFlagValue(), 0, uhDepth );
	1916	Bool exitILR = m_pcPredSearch->predInterSearchILRUni( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], refLayerId );
	1917	if(!exitILR)
	1918	{
	1919	return;
	1920	}
	1921	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcResiYuvBest[uhDepth], m_ppcRecoYuvTemp[uhDepth], false );
	1922	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
	1923	xCheckDQP( rpcTempCU );
	1924	xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
	1925	return;
	1926	}
	1927	#endif
	1928	//! \}

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

Download in other formats: