Context navigation

TEncCu.cpp @ 984

Visit:

Last change on this file since 984 was 399, checked in by samsung-htm, 12 years ago
D0112 integration
Property svn:eol-style set to `native`
File size: 107.9 KB

Line
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-2012, 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	#if QC_ARP_D0177
67	m_ppcWeightedTempCU = new TComDataCU*[m_uhTotalDepth-1];
68	#endif
69	m_ppcPredYuvBest = new TComYuv*[m_uhTotalDepth-1];
70	m_ppcResiYuvBest = new TComYuv*[m_uhTotalDepth-1];
71	m_ppcRecoYuvBest = new TComYuv*[m_uhTotalDepth-1];
72	m_ppcPredYuvTemp = new TComYuv*[m_uhTotalDepth-1];
73	m_ppcResiYuvTemp = new TComYuv*[m_uhTotalDepth-1];
74	m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
75	m_ppcOrigYuv = new TComYuv*[m_uhTotalDepth-1];
76	#if H3D_IVRP
77	m_ppcResPredTmp = new TComYuv*[m_uhTotalDepth-1];
78	#endif
79
80	#if HHI_MPI
81	m_puhDepthSaved = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
82	m_puhWidthSaved = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
83	m_puhHeightSaved = new UChar[1ll<<( ( m_uhTotalDepth - 1 )<<1 )];
84	#endif
85
86	UInt uiNumPartitions;
87	for( i=0 ; i<m_uhTotalDepth-1 ; i++)
88	{
89	uiNumPartitions = 1<<( ( m_uhTotalDepth - i - 1 )<<1 );
90	UInt uiWidth = uiMaxWidth >> i;
91	UInt uiHeight = uiMaxHeight >> i;
92
93	m_ppcBestCU[i] = new TComDataCU; m_ppcBestCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
94	m_ppcTempCU[i] = new TComDataCU; m_ppcTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
95	#if QC_ARP_D0177
96	m_ppcWeightedTempCU[i] = new TComDataCU; m_ppcWeightedTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false, uiMaxWidth >> (m_uhTotalDepth - 1) );
97	#endif
98	m_ppcPredYuvBest[i] = new TComYuv; m_ppcPredYuvBest[i]->create(uiWidth, uiHeight);
99	m_ppcResiYuvBest[i] = new TComYuv; m_ppcResiYuvBest[i]->create(uiWidth, uiHeight);
100	m_ppcRecoYuvBest[i] = new TComYuv; m_ppcRecoYuvBest[i]->create(uiWidth, uiHeight);
101
102	m_ppcPredYuvTemp[i] = new TComYuv; m_ppcPredYuvTemp[i]->create(uiWidth, uiHeight);
103	m_ppcResiYuvTemp[i] = new TComYuv; m_ppcResiYuvTemp[i]->create(uiWidth, uiHeight);
104	m_ppcRecoYuvTemp[i] = new TComYuv; m_ppcRecoYuvTemp[i]->create(uiWidth, uiHeight);
105
106	m_ppcOrigYuv [i] = new TComYuv; m_ppcOrigYuv [i]->create(uiWidth, uiHeight);
107	#if H3D_IVRP
108	m_ppcResPredTmp [i] = new TComYuv; m_ppcResPredTmp [i]->create(uiWidth, uiHeight);
109	#endif
110	}
111
112	m_bEncodeDQP = false;
113	m_checkBurstIPCMFlag = false;
114
115	// initialize partition order.
116	UInt* piTmp = &g_auiZscanToRaster[0];
117	initZscanToRaster( m_uhTotalDepth, 1, 0, piTmp);
118	initRasterToZscan( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
119
120	// initialize conversion matrix from partition index to pel
121	initRasterToPelXY( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
122	initMotionReferIdx ( uiMaxWidth, uiMaxHeight, m_uhTotalDepth );
123	}
124
125	Void TEncCu::destroy()
126	{
127	Int i;
128
129	#if HHI_MPI
130	delete[] m_puhDepthSaved; m_puhDepthSaved = NULL;
131	delete[] m_puhWidthSaved; m_puhWidthSaved = NULL;
132	delete[] m_puhHeightSaved; m_puhHeightSaved = NULL;
133	#endif
134	for( i=0 ; i<m_uhTotalDepth-1 ; i++)
135	{
136	if(m_ppcBestCU[i])
137	{
138	m_ppcBestCU[i]->destroy(); delete m_ppcBestCU[i]; m_ppcBestCU[i] = NULL;
139	}
140	if(m_ppcTempCU[i])
141	{
142	m_ppcTempCU[i]->destroy(); delete m_ppcTempCU[i]; m_ppcTempCU[i] = NULL;
143	}
144	if(m_ppcPredYuvBest[i])
145	{
146	m_ppcPredYuvBest[i]->destroy(); delete m_ppcPredYuvBest[i]; m_ppcPredYuvBest[i] = NULL;
147	}
148	if(m_ppcResiYuvBest[i])
149	{
150	m_ppcResiYuvBest[i]->destroy(); delete m_ppcResiYuvBest[i]; m_ppcResiYuvBest[i] = NULL;
151	}
152	if(m_ppcRecoYuvBest[i])
153	{
154	m_ppcRecoYuvBest[i]->destroy(); delete m_ppcRecoYuvBest[i]; m_ppcRecoYuvBest[i] = NULL;
155	}
156	if(m_ppcPredYuvTemp[i])
157	{
158	m_ppcPredYuvTemp[i]->destroy(); delete m_ppcPredYuvTemp[i]; m_ppcPredYuvTemp[i] = NULL;
159	}
160	if(m_ppcResiYuvTemp[i])
161	{
162	m_ppcResiYuvTemp[i]->destroy(); delete m_ppcResiYuvTemp[i]; m_ppcResiYuvTemp[i] = NULL;
163	}
164	if(m_ppcRecoYuvTemp[i])
165	{
166	m_ppcRecoYuvTemp[i]->destroy(); delete m_ppcRecoYuvTemp[i]; m_ppcRecoYuvTemp[i] = NULL;
167	}
168	if(m_ppcOrigYuv[i])
169	{
170	m_ppcOrigYuv[i]->destroy(); delete m_ppcOrigYuv[i]; m_ppcOrigYuv[i] = NULL;
171	}
172	#if H3D_IVRP
173	if(m_ppcResPredTmp[i])
174	{
175	m_ppcResPredTmp [i]->destroy(); delete m_ppcResPredTmp[i]; m_ppcResPredTmp[i] = NULL;
176	}
177	#endif
178	#if QC_ARP_D0177
179	if(m_ppcWeightedTempCU[i])
180	{
181	m_ppcWeightedTempCU[i]->destroy(); delete m_ppcWeightedTempCU[i]; m_ppcWeightedTempCU[i] = NULL;
182	}
183	#endif
184	}
185	if(m_ppcBestCU)
186	{
187	delete [] m_ppcBestCU;
188	m_ppcBestCU = NULL;
189	}
190	if(m_ppcTempCU)
191	{
192	delete [] m_ppcTempCU;
193	m_ppcTempCU = NULL;
194	}
195
196	if(m_ppcPredYuvBest)
197	{
198	delete [] m_ppcPredYuvBest;
199	m_ppcPredYuvBest = NULL;
200	}
201	if(m_ppcResiYuvBest)
202	{
203	delete [] m_ppcResiYuvBest;
204	m_ppcResiYuvBest = NULL;
205	}
206	if(m_ppcRecoYuvBest)
207	{
208	delete [] m_ppcRecoYuvBest;
209	m_ppcRecoYuvBest = NULL;
210	}
211	if(m_ppcPredYuvTemp)
212	{
213	delete [] m_ppcPredYuvTemp;
214	m_ppcPredYuvTemp = NULL;
215	}
216	if(m_ppcResiYuvTemp)
217	{
218	delete [] m_ppcResiYuvTemp;
219	m_ppcResiYuvTemp = NULL;
220	}
221	if(m_ppcRecoYuvTemp)
222	{
223	delete [] m_ppcRecoYuvTemp;
224	m_ppcRecoYuvTemp = NULL;
225	}
226	if(m_ppcOrigYuv)
227	{
228	delete [] m_ppcOrigYuv;
229	m_ppcOrigYuv = NULL;
230	}
231	#if H3D_IVRP
232	if(m_ppcResPredTmp)
233	{
234	delete [] m_ppcResPredTmp;
235	m_ppcResPredTmp = NULL;
236	}
237	#endif
238	}
239
240	/** \param pcEncTop pointer of encoder class
241	*/
242	Void TEncCu::init( TEncTop* pcEncTop )
243	{
244	m_pcEncCfg = pcEncTop;
245	m_pcPredSearch = pcEncTop->getPredSearch();
246	m_pcTrQuant = pcEncTop->getTrQuant();
247	m_pcBitCounter = pcEncTop->getBitCounter();
248	m_pcRdCost = pcEncTop->getRdCost();
249
250	m_pcEntropyCoder = pcEncTop->getEntropyCoder();
251	m_pcCavlcCoder = pcEncTop->getCavlcCoder();
252	m_pcSbacCoder = pcEncTop->getSbacCoder();
253	m_pcBinCABAC = pcEncTop->getBinCABAC();
254
255	m_pppcRDSbacCoder = pcEncTop->getRDSbacCoder();
256	m_pcRDGoOnSbacCoder = pcEncTop->getRDGoOnSbacCoder();
257
258	m_bUseSBACRD = pcEncTop->getUseSBACRD();
259	}
260
261	// ====================================================================================================================
262	// Public member functions
263	// ====================================================================================================================
264
265	/** \param rpcCU pointer of CU data class
266	*/
267	Void TEncCu::compressCU( TComDataCU*& rpcCU )
268	{
269	// initialize CU data
270	m_ppcBestCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
271	m_ppcTempCU[0]->initCU( rpcCU->getPic(), rpcCU->getAddr() );
272
273	// analysis of CU
274	xCompressCU( m_ppcBestCU[0], m_ppcTempCU[0], 0 );
275
276	#if ADAPTIVE_QP_SELECTION
277	if( m_pcEncCfg->getUseAdaptQpSelect() )
278	{
279	if(rpcCU->getSlice()->getSliceType()!=I_SLICE) //IIII
280	{
281	xLcuCollectARLStats( rpcCU);
282	}
283	}
284	#endif
285	}
286	/** \param pcCU pointer of CU data class, bForceTerminate when set to true terminates slice (default is false).
287	*/
288	Void TEncCu::encodeCU ( TComDataCU* pcCU, Bool bForceTerminate )
289	{
290	if ( pcCU->getSlice()->getPPS()->getUseDQP() )
291	{
292	setdQPFlag(true);
293	}
294
295	TComPic* pcPic = pcCU->getPic();
296	Bool checkBurstIPCMFlag = (pcPic->getSlice(0)->getSPS()->getUsePCM())? true : false;
297
298	setCheckBurstIPCMFlag( checkBurstIPCMFlag );
299
300	pcCU->setNumSucIPCM(0);
301	pcCU->setLastCUSucIPCMFlag(false);
302
303	// Encode CU data
304	xEncodeCU( pcCU, 0, 0 );
305
306	bool bTerminateSlice = bForceTerminate;
307	UInt uiCUAddr = pcCU->getAddr();
308	/* If at the end of an LCU line but not at the end of a substream, perform CABAC flush */
309	if (!bTerminateSlice && pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
310	{
311	Int iNumSubstreams = pcCU->getSlice()->getPPS()->getNumSubstreams();
312	UInt uiWidthInLCUs = pcCU->getPic()->getPicSym()->getFrameWidthInCU();
313	UInt uiCol = uiCUAddr % uiWidthInLCUs;
314	UInt uiLin = uiCUAddr / uiWidthInLCUs;
315	UInt uiTileStartLCU = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getFirstCUAddr();
316	UInt uiTileLCUX = uiTileStartLCU % uiWidthInLCUs;
317	UInt uiTileLCUY = uiTileStartLCU / uiWidthInLCUs;
318	UInt uiTileWidth = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getTileWidth();
319	UInt uiTileHeight = pcCU->getPic()->getPicSym()->getTComTile(pcCU->getPic()->getPicSym()->getTileIdxMap(uiCUAddr))->getTileHeight();
320	Int iNumSubstreamsPerTile = iNumSubstreams;
321	if (pcCU->getSlice()->getPPS()->getNumSubstreams() > 1)
322	{
323	iNumSubstreamsPerTile /= pcCU->getPic()->getPicSym()->getNumTiles();
324	}
325	if ((uiCol == uiTileLCUX+uiTileWidth-1) && (uiLin+iNumSubstreamsPerTile < uiTileLCUY+uiTileHeight))
326	{
327	m_pcEntropyCoder->encodeFlush();
328	}
329	}
330	}
331
332	// ====================================================================================================================
333	// Protected member functions
334	// ====================================================================================================================
335	/** Derive small set of test modes for AMP encoder speed-up
336	*\param rpcBestCU
337	*\param eParentPartSize
338	*\param bTestAMP_Hor
339	*\param bTestAMP_Ver
340	*\param bTestMergeAMP_Hor
341	*\param bTestMergeAMP_Ver
342	*\returns Void
343	*/
344	#if AMP_ENC_SPEEDUP
345	#if AMP_MRG
346	Void TEncCu::deriveTestModeAMP (TComDataCU *&rpcBestCU, PartSize eParentPartSize, Bool &bTestAMP_Hor, Bool &bTestAMP_Ver, Bool &bTestMergeAMP_Hor, Bool &bTestMergeAMP_Ver)
347	#else
348	Void TEncCu::deriveTestModeAMP (TComDataCU *&rpcBestCU, PartSize eParentPartSize, Bool &bTestAMP_Hor, Bool &bTestAMP_Ver)
349	#endif
350	{
351	if ( rpcBestCU->getPartitionSize(0) == SIZE_2NxN )
352	{
353	bTestAMP_Hor = true;
354	}
355	else if ( rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
356	{
357	bTestAMP_Ver = true;
358	}
359	else if ( rpcBestCU->getPartitionSize(0) == SIZE_2Nx2N && rpcBestCU->getMergeFlag(0) == false && rpcBestCU->isSkipped(0) == false )
360	{
361	bTestAMP_Hor = true;
362	bTestAMP_Ver = true;
363	}
364
365	#if AMP_MRG
366	//! Utilizing the partition size of parent PU
367	if ( eParentPartSize >= SIZE_2NxnU && eParentPartSize <= SIZE_nRx2N )
368	{
369	bTestMergeAMP_Hor = true;
370	bTestMergeAMP_Ver = true;
371	}
372
373	if ( eParentPartSize == SIZE_NONE ) //! if parent is intra
374	{
375	if ( rpcBestCU->getPartitionSize(0) == SIZE_2NxN )
376	{
377	bTestMergeAMP_Hor = true;
378	}
379	else if ( rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
380	{
381	bTestMergeAMP_Ver = true;
382	}
383	}
384
385	if ( rpcBestCU->getPartitionSize(0) == SIZE_2Nx2N && rpcBestCU->isSkipped(0) == false )
386	{
387	bTestMergeAMP_Hor = true;
388	bTestMergeAMP_Ver = true;
389	}
390
391	if ( rpcBestCU->getWidth(0) == 64 )
392	{
393	bTestAMP_Hor = false;
394	bTestAMP_Ver = false;
395	}
396	#else
397	//! Utilizing the partition size of parent PU
398	if ( eParentPartSize >= SIZE_2NxnU && eParentPartSize <= SIZE_nRx2N )
399	{
400	bTestAMP_Hor = true;
401	bTestAMP_Ver = true;
402	}
403
404	if ( eParentPartSize == SIZE_2Nx2N )
405	{
406	bTestAMP_Hor = false;
407	bTestAMP_Ver = false;
408	}
409	#endif
410	}
411	#endif
412
413	// ====================================================================================================================
414	// Protected member functions
415	// ====================================================================================================================
416	/** Compress a CU block recursively with enabling sub-LCU-level delta QP
417	*\param rpcBestCU
418	*\param rpcTempCU
419	*\param uiDepth
420	*\returns Void
421	*
422	*- for loop of QP value to compress the current CU with all possible QP
423	*/
424	#if AMP_ENC_SPEEDUP
425	Void TEncCu::xCompressCU( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UInt uiDepth, PartSize eParentPartSize )
426	#else
427	Void TEncCu::xCompressCU( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UInt uiDepth )
428	#endif
429	{
430	TComPic* pcPic = rpcBestCU->getPic();
431
432	#if H3D_QTL
433	TComSPS *sps = pcPic->getSlice(0)->getSPS();
434	TComPic *pcTexture = rpcBestCU->getSlice()->getTexturePic();
435
436	Bool depthMapDetect = (pcTexture != NULL);
437	Bool bIntraSliceDetect = (rpcBestCU->getSlice()->getSliceType() == I_SLICE);
438
439	Bool rapPic = (rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA);
440
441	Bool bTry2NxN = true;
442	Bool bTryNx2N = true;
443	#endif
444
445	// get Original YUV data from picture
446	m_ppcOrigYuv[uiDepth]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
447
448	// variables for fast encoder decision
449	Bool bEarlySkip = false;
450	Bool bTrySplit = true;
451	Double fRD_Skip = MAX_DOUBLE;
452
453	// variable for Early CU determination
454	Bool bSubBranch = true;
455
456	// variable for Cbf fast mode PU decision
457	Bool doNotBlockPu = true;
458
459	Bool bTrySplitDQP = true;
460
461	static Double afCost [ MAX_CU_DEPTH ];
462	static Int aiNum [ MAX_CU_DEPTH ];
463
464	if ( rpcBestCU->getAddr() == 0 )
465	{
466	::memset( afCost, 0, sizeof( afCost ) );
467	::memset( aiNum, 0, sizeof( aiNum ) );
468	}
469
470	Bool bBoundary = false;
471	UInt uiLPelX = rpcBestCU->getCUPelX();
472	UInt uiRPelX = uiLPelX + rpcBestCU->getWidth(0) - 1;
473	UInt uiTPelY = rpcBestCU->getCUPelY();
474	UInt uiBPelY = uiTPelY + rpcBestCU->getHeight(0) - 1;
475
476	#if LGE_ILLUCOMP_B0045
477	Bool bICEnabled = (
478	#if !LGE_ILLUCOMP_DEPTH_C0046
479	!rpcTempCU->getSlice()->getIsDepth() &&
480	#endif
481	rpcTempCU->getSlice()->getViewId());
482
483	bICEnabled = bICEnabled && rpcTempCU->getSlice()->getApplyIC();
484	#endif
485
486	#if HHI_INTERVIEW_SKIP
487	Bool bFullyRenderedSec = true ;
488	if( m_pcEncCfg->getInterViewSkip() )
489	{
490	Pel* pUsedSamples ;
491	UInt uiStride ;
492	pUsedSamples = pcPic->getUsedPelsMap()->getLumaAddr( rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
493	uiStride = pcPic->getUsedPelsMap()->getStride();
494
495	for ( Int y=0; y<m_ppcOrigYuv[uiDepth]->getHeight(); y++)
496	{
497	for ( Int x=0; x<m_ppcOrigYuv[uiDepth]->getWidth(); x++)
498	{
499	if( pUsedSamples[x] !=0 )
500	{
501	bFullyRenderedSec = false ;
502	break ;
503	}
504	}
505	if ( !bFullyRenderedSec )
506	{
507	break;
508	}
509	pUsedSamples += uiStride ;
510	}
511	}
512	else
513	{
514	bFullyRenderedSec = false ;
515	}
516
517	#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
518	if( bFullyRenderedSec )
519	{
520	m_pcRdCost->setLambdaScale( m_pcEncCfg->getInterViewSkipLambdaScale() );
521	}
522	else
523	{
524	m_pcRdCost->setLambdaScale( 1 );
525	}
526	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
527	#endif
528
529	#endif
530	Int iBaseQP = xComputeQP( rpcBestCU, uiDepth );
531	Int iMinQP;
532	Int iMaxQP;
533	#if LOSSLESS_CODING
534	Bool isAddLowestQP = false;
535	Int lowestQP = -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY();
536	#endif
537
538	if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
539	{
540	Int idQP = m_pcEncCfg->getMaxDeltaQP();
541	iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
542	iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
543	#if LOSSLESS_CODING
544	if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
545	{
546	isAddLowestQP = true;
547	iMinQP = iMinQP - 1;
548
549	}
550	#endif
551	}
552	else
553	{
554	iMinQP = rpcTempCU->getQP(0);
555	iMaxQP = rpcTempCU->getQP(0);
556	}
557
558	// If slice start or slice end is within this cu...
559	TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
560	Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getEntropySliceCurStartCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart();
561	Bool bSliceEnd = (pcSlice->getEntropySliceCurEndCUAddr()>rpcTempCU->getSCUAddr()&&pcSlice->getEntropySliceCurEndCUAddr()<rpcTempCU->getSCUAddr()+rpcTempCU->getTotalNumPart());
562	Bool bInsidePicture = ( uiRPelX < rpcBestCU->getSlice()->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < rpcBestCU->getSlice()->getSPS()->getPicHeightInLumaSamples() );
563	// We need to split, so don't try these modes.
564	if(!bSliceEnd && !bSliceStart && bInsidePicture )
565	{
566	for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
567	{
568	#if LOSSLESS_CODING
569	if (isAddLowestQP && (iQP == iMinQP))
570	{
571	iQP = lowestQP;
572	}
573	#endif
574	// variables for fast encoder decision
575	bEarlySkip = false;
576	bTrySplit = true;
577	fRD_Skip = MAX_DOUBLE;
578
579	rpcTempCU->initEstData( uiDepth, iQP );
580
581	#if H3D_QTL
582	//logic for setting bTrySplit using the partition information that is stored of the texture colocated CU
583
584	if(depthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
585	{
586	TComDataCU* pcTextureCU = pcTexture->getCU( rpcBestCU->getAddr() ); //Corresponding texture LCU
587	UInt uiCUIdx = rpcBestCU->getZorderIdxInCU();
588	assert(pcTextureCU->getDepth(uiCUIdx) >= uiDepth); //Depth cannot be more partitionned than the texture.
589	if (pcTextureCU->getDepth(uiCUIdx) > uiDepth \|\| pcTextureCU->getPartitionSize(uiCUIdx) == SIZE_NxN) //Texture was split.
590	{
591	bTrySplit = true;
592	bTryNx2N = true;
593	bTry2NxN = true;
594	}
595	else
596	{
597	bTrySplit = false;
598	bTryNx2N = false;
599	bTry2NxN = false;
600	}
601	}
602	#endif
603	#if QC_CU_NBDV_D0181
604	DisInfo DvInfo;
605	DvInfo.bDV = false;
606	if( rpcTempCU->getSlice()->getSliceType() != I_SLICE )
607	{
608	#if QC_ARP_D0177
609	if(( rpcTempCU->getSlice()->getSPS()->getMultiviewMvPredMode() \|\| rpcTempCU->getSlice()->getSPS()->getUseAdvRP()) && rpcTempCU->getSlice()->getViewId())
610	#else
611	if(( rpcTempCU->getSlice()->getSPS()->getMultiviewMvPredMode() \|\| rpcTempCU->getSlice()->getSPS()->getMultiviewResPredMode()) && rpcTempCU->getSlice()->getViewId())
612	#endif
613	{
614	PartSize ePartTemp = rpcTempCU->getPartitionSize(0);
615	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
616	#if MERL_VSP_C0152
617	DvInfo.bDV = rpcTempCU->getDisMvpCandNBDV(0, 0, &DvInfo, false, true);
618	#else
619	DvInfo.bDV = rpcTempCU->getDisMvpCandNBDV(0, 0, &DvInfo, false);
620	#endif
621	rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
622	rpcBestCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
623	rpcTempCU->setPartSizeSubParts( ePartTemp, 0, uiDepth );
624	}
625	if(DvInfo.bDV==false)
626	{
627	DvInfo.iN=1;
628	#if !SEC_DEFAULT_DV_D0112
629	DvInfo.m_acMvCand[0].setHor(0);
630	DvInfo.m_acMvCand[0].setVer(0);
631	DvInfo.m_aVIdxCan[0] = 0;
632	#endif
633	rpcTempCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
634	rpcBestCU->setDvInfoSubParts(DvInfo, 0, uiDepth);
635	}
636	}
637	#endif
638	// do inter modes, SKIP and 2Nx2N
639	if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
640	{
641	#if H3D_IVRP
642	#if QC_ARP_D0177
643	Bool bResPredAvailable = false;
644	Bool bResPredAllowed = (!rpcBestCU->getSlice()->getSPS()->isDepth () );
645	bResPredAllowed = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId () );
646	if( bResPredAllowed )
647	{
648	bResPredAvailable = rpcBestCU->getResidualSamples( 0, true, m_ppcResPredTmp[uiDepth] );
649	}
650	for( UInt uiResPrdId = 0; uiResPrdId < (rpcBestCU->getSlice()->getSPS()->getUseAdvRP()? 1: ( bResPredAvailable ? 2 : 1 )); uiResPrdId++ )
651	#else
652	Bool bResPredAvailable = false;
653	UInt uiResPrdId = 0;
654	#endif
655	{
656	Bool bResPredFlag = ( uiResPrdId > 0 );
657	#if LGE_ILLUCOMP_B0045
658	for(UInt uiICId = 0; uiICId < (bICEnabled ? 2 : 1); uiICId++)
659	{
660	Bool bICFlag = (uiICId ? true : false);
661	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
662	#endif
663	#endif
664	#if H3D_IVRP
665	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
666	#endif
667	// SKIP
668	#if HHI_INTERVIEW_SKIP
669	xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU, bFullyRenderedSec );
670	#else
671	xCheckRDCostMerge2Nx2N( rpcBestCU, rpcTempCU );
672	#endif
673	rpcTempCU->initEstData( uiDepth, iQP );
674
675	// fast encoder decision for early skip
676	if ( m_pcEncCfg->getUseFastEnc() )
677	{
678	Int iIdx = g_aucConvertToBit[ rpcBestCU->getWidth(0) ];
679	if ( aiNum [ iIdx ] > 5 && fRD_Skip < EARLY_SKIP_THRES*afCost[ iIdx ]/aiNum[ iIdx ] )
680	{
681	bEarlySkip = true;
682	bTrySplit = false;
683	}
684	}
685	#if LGE_ILLUCOMP_B0045
686	if(bICFlag && rpcBestCU->getMergeFlag(0) && !rpcBestCU->getICFlag(0))
687	{
688	bICEnabled = false;
689	break;
690	}
691	#endif
692	// 2Nx2N, NxN
693	if ( !bEarlySkip )
694	{
695	#if H3D_IVRP
696	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
697	#endif
698	#if LGE_ILLUCOMP_B0045
699	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
700	#endif
701	#if HHI_INTERVIEW_SKIP
702	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N, bFullyRenderedSec );
703
704	#else
705	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
706	#endif
707	rpcTempCU->initEstData( uiDepth, iQP );
708	if(m_pcEncCfg->getUseCbfFastMode())
709	{
710	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
711	}
712	}
713	#if LGE_ILLUCOMP_B0045
714	}
715	#endif
716	#if H3D_IVRP
717	} // uiResPrdId
718	#endif
719	} // != I_SLICE
720
721	#if LGE_ILLUCOMP_B0045
722	bICEnabled = rpcBestCU->getICFlag(0);
723	#endif
724
725	#if H3D_QTL
726
727	if(depthMapDetect && !bIntraSliceDetect && !rapPic && sps->getUseQTLPC())
728	{
729	bTrySplitDQP = bTrySplit;
730	}
731	else
732	{
733	#endif
734	if( (g_uiMaxCUWidth>>uiDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
735	{
736	if(iQP == iBaseQP)
737	{
738	bTrySplitDQP = bTrySplit;
739	}
740	}
741	else
742	{
743	bTrySplitDQP = bTrySplit;
744	}
745	#if H3D_QTL
746	}
747	#endif
748
749	#if LOSSLESS_CODING
750	if (isAddLowestQP && (iQP == lowestQP))
751	{
752	iQP = iMinQP;
753	}
754	#endif
755	} // end for iMinQP to iMaxQP
756
757
758	for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
759	{
760	#if LOSSLESS_CODING
761	if (isAddLowestQP && (iQP == iMinQP))
762	{
763	iQP = lowestQP;
764	}
765	#endif
766	rpcTempCU->initEstData( uiDepth, iQP );
767
768	// do inter modes, NxN, 2NxN, and Nx2N
769	if( rpcBestCU->getSlice()->getSliceType() != I_SLICE )
770	{
771	#if H3D_IVRP
772	#if QC_ARP_D0177
773	Bool bResPredAvailable = false;
774	Bool bResPredAllowed = (!rpcBestCU->getSlice()->getSPS()->isDepth () );
775	bResPredAllowed = bResPredAllowed && ( rpcBestCU->getSlice()->getSPS()->getViewId () );
776	if( bResPredAllowed )
777	{
778	bResPredAvailable = rpcBestCU->getResidualSamples( 0, true, m_ppcResPredTmp[uiDepth] );
779	}
780	for( UInt uiResPrdId = 0; uiResPrdId < (rpcBestCU->getSlice()->getSPS()->getUseAdvRP()? 1: ( bResPredAvailable ? 2 : 1 )); uiResPrdId++ )
781	#else
782	Bool bResPredAvailable = false;
783	UInt uiResPrdId = 0;
784	#endif
785	{
786	Bool bResPredFlag = ( uiResPrdId > 0 );
787	#if LGE_ILLUCOMP_B0045
788	for(UInt uiICId = 0; uiICId < (bICEnabled ? 2 : 1); uiICId++)
789	{
790	Bool bICFlag = (uiICId ? true : false);
791	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
792	#endif
793	#endif
794	// 2Nx2N, NxN
795	if ( !bEarlySkip )
796	{
797
798	if(!( rpcBestCU->getSlice()->getSPS()->getDisInter4x4() && (rpcBestCU->getWidth(0)==8) && (rpcBestCU->getHeight(0)==8) ))
799	{
800	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth && doNotBlockPu)
801	{
802	#if H3D_QTL //try InterNxN
803	if(bTrySplit)
804	{
805	#endif
806	#if H3D_IVRP
807	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
808	#endif
809	#if HHI_INTERVIEW_SKIP
810	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN, bFullyRenderedSec );
811	#else
812	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_NxN );
813	#endif
814	rpcTempCU->initEstData( uiDepth, iQP );
815	#if H3D_QTL
816	}
817	#endif
818	}
819	}
820	}
821
822	{ // 2NxN, Nx2N
823	#if H3D_QTL //try Nx2N
824	if(bTryNx2N)
825	{
826	#endif
827	if(doNotBlockPu)
828	{
829	#if H3D_IVRP
830	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
831	#endif
832	#if LGE_ILLUCOMP_B0045
833	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
834	#endif
835	#if HHI_INTERVIEW_SKIP
836	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N, bFullyRenderedSec );
837	#else
838	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_Nx2N );
839	#endif
840	rpcTempCU->initEstData( uiDepth, iQP );
841	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_Nx2N )
842	{
843	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
844	}
845	}
846	#if H3D_QTL
847	}
848	#endif
849
850	#if H3D_QTL //try 2NxN
851	if(bTry2NxN)
852	{
853	#endif
854	if(doNotBlockPu)
855	{
856	#if H3D_IVRP
857	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
858	#endif
859	#if LGE_ILLUCOMP_B0045
860	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
861	#endif
862	#if HHI_INTERVIEW_SKIP
863	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxN, bFullyRenderedSec );
864	#else
865	xCheckRDCostInter ( rpcBestCU, rpcTempCU, SIZE_2NxN );
866	#endif
867	rpcTempCU->initEstData( uiDepth, iQP );
868	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxN)
869	{
870	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
871	}
872	}
873	#if H3D_QTL
874	}
875	#endif
876	}
877
878	#if 1
879	//! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
880	if( pcPic->getSlice(0)->getSPS()->getAMPAcc(uiDepth) )
881	{
882	#if AMP_ENC_SPEEDUP
883	Bool bTestAMP_Hor = false, bTestAMP_Ver = false;
884
885	#if AMP_MRG
886	Bool bTestMergeAMP_Hor = false, bTestMergeAMP_Ver = false;
887
888	deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver, bTestMergeAMP_Hor, bTestMergeAMP_Ver);
889	#else
890	deriveTestModeAMP (rpcBestCU, eParentPartSize, bTestAMP_Hor, bTestAMP_Ver);
891	#endif
892
893	//! Do horizontal AMP
894	if ( bTestAMP_Hor )
895	{
896	#if H3D_QTL //try 2NxnU & 2NxnD
897	if(bTry2NxN)
898	{
899	#endif
900	if(doNotBlockPu)
901	{
902	#if H3D_IVRP
903	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
904	#endif
905	#if LGE_ILLUCOMP_B0045
906	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
907	#endif
908	#if HHI_INTERVIEW_SKIP
909	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
910	#else
911	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
912	#endif
913	rpcTempCU->initEstData( uiDepth, iQP );
914	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
915	{
916	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
917	}
918	}
919	if(doNotBlockPu)
920	{
921	#if H3D_IVRP
922	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
923	#endif
924	#if LGE_ILLUCOMP_B0045
925	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
926	#endif
927	#if HHI_INTERVIEW_SKIP
928	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
929	#else
930	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
931	#endif
932	rpcTempCU->initEstData( uiDepth, iQP );
933	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
934	{
935	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
936	}
937	}
938	#if H3D_QTL
939	}
940	#endif
941	}
942	#if AMP_MRG
943	else if ( bTestMergeAMP_Hor )
944	{
945	#if H3D_QTL //try 2NxnU & 2NxnD Merge
946	if(bTry2NxN)
947	{
948	#endif
949	if(doNotBlockPu)
950	{
951	#if H3D_IVRP
952	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
953	#endif
954	#if LGE_ILLUCOMP_B0045
955	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
956	#endif
957	#if HHI_INTERVIEW_SKIP
958	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec, true );
959	#else
960	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, true );
961	#endif
962	rpcTempCU->initEstData( uiDepth, iQP );
963	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnU )
964	{
965	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
966	}
967	}
968	if(doNotBlockPu)
969	{
970	#if H3D_IVRP
971	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
972	#endif
973	#if LGE_ILLUCOMP_B0045
974	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
975	#endif
976	#if HHI_INTERVIEW_SKIP
977	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec, true );
978	#else
979	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, true );
980	#endif
981	rpcTempCU->initEstData( uiDepth, iQP );
982	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_2NxnD )
983	{
984	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
985	}
986	}
987	#if H3D_QTL
988	}
989	#endif
990	}
991	#endif
992
993	//! Do horizontal AMP
994	if ( bTestAMP_Ver )
995	{
996	#if H3D_QTL //try nLx2N & nRx2N
997	if(bTryNx2N)
998	{
999	#endif
1000	if(doNotBlockPu)
1001	{
1002	#if H3D_IVRP
1003	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1004	#endif
1005	#if LGE_ILLUCOMP_B0045
1006	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
1007	#endif
1008	#if HHI_INTERVIEW_SKIP
1009	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
1010	#else
1011	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
1012	#endif
1013	rpcTempCU->initEstData( uiDepth, iQP );
1014	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
1015	{
1016	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1017	}
1018	}
1019	if(doNotBlockPu)
1020	{
1021	#if H3D_IVRP
1022	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1023	#endif
1024	#if LGE_ILLUCOMP_B0045
1025	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
1026	#endif
1027	#if HHI_INTERVIEW_SKIP
1028	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
1029	#else
1030	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
1031	#endif
1032	rpcTempCU->initEstData( uiDepth, iQP );
1033	}
1034	#if H3D_QTL
1035	}
1036	#endif
1037	}
1038	#if AMP_MRG
1039	else if ( bTestMergeAMP_Ver )
1040	{
1041	#if H3D_QTL //try nLx2N & nRx2N (Merge)
1042	if(bTryNx2N)
1043	{
1044	#endif
1045	if(doNotBlockPu)
1046	{
1047	#if H3D_IVRP
1048	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1049	#endif
1050	#if LGE_ILLUCOMP_B0045
1051	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
1052	#endif
1053	#if HHI_INTERVIEW_SKIP
1054	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec, true );
1055	#else
1056	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, true );
1057	#endif
1058	rpcTempCU->initEstData( uiDepth, iQP );
1059	if(m_pcEncCfg->getUseCbfFastMode() && rpcBestCU->getPartitionSize(0) == SIZE_nLx2N )
1060	{
1061	doNotBlockPu = rpcBestCU->getQtRootCbf( 0 ) != 0;
1062	}
1063	}
1064	if(doNotBlockPu)
1065	{
1066	#if H3D_IVRP
1067	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1068	#endif
1069	#if LGE_ILLUCOMP_B0045
1070	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
1071	#endif
1072	#if HHI_INTERVIEW_SKIP
1073	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec, true );
1074	#else
1075	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, true );
1076	#endif
1077	rpcTempCU->initEstData( uiDepth, iQP );
1078	}
1079	#if H3D_QTL
1080	}
1081	#endif
1082	}
1083	#endif
1084
1085	#else
1086	#if H3D_IVRP
1087	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1088	#endif
1089	#if HHI_INTERVIEW_SKIP
1090	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU, bFullyRenderedSec );
1091	#else
1092	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnU );
1093	#endif
1094	rpcTempCU->initEstData( uiDepth, iQP );
1095	#if H3D_IVRP
1096	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1097	#endif
1098	#if HHI_INTERVIEW_SKIP
1099	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD, bFullyRenderedSec );
1100	#else
1101	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_2NxnD );
1102	#endif
1103	rpcTempCU->initEstData( uiDepth, iQP );
1104	#if H3D_IVRP
1105	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1106	#endif
1107	#if HHI_INTERVIEW_SKIP
1108	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N, bFullyRenderedSec );
1109	#else
1110	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nLx2N );
1111	#endif
1112	rpcTempCU->initEstData( uiDepth, iQP );
1113	#if H3D_IVRP
1114	rpcTempCU->setResPredIndicator( bResPredAvailable, bResPredFlag );
1115	#endif
1116	#if HHI_INTERVIEW_SKIP
1117	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N, bFullyRenderedSec );
1118	#else
1119	xCheckRDCostInter( rpcBestCU, rpcTempCU, SIZE_nRx2N );
1120	#endif
1121	rpcTempCU->initEstData( uiDepth, iQP );
1122
1123	#endif
1124	} //! Try AMP (SIZE_2NxnU, SIZE_2NxnD, SIZE_nLx2N, SIZE_nRx2N)
1125	#endif
1126	#if LGE_ILLUCOMP_B0045
1127	}
1128	#endif
1129	#if H3D_IVRP
1130	} // uiResPrdId
1131	#endif
1132	} // != I_SLICE
1133
1134	// initialize PCM flag
1135	rpcTempCU->setIPCMFlag( 0, false);
1136	rpcTempCU->setIPCMFlagSubParts ( false, 0, uiDepth); //SUB_LCU_DQP
1137
1138	// do normal intra modes
1139	if ( !bEarlySkip
1140	#if HHI_DEPTH_INTRA_SEARCH_RAU_C0160
1141	\|\| ((rpcBestCU->getSlice()->getIsDepth() == true) && (rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1142	#endif
1143	)
1144	{
1145	// speedup for inter frames
1146	#if HHI_INTERVIEW_SKIP
1147	if( ( rpcBestCU->getSlice()->getSliceType() == I_SLICE \|\|
1148	rpcBestCU->getCbf( 0, TEXT_LUMA ) != 0 \|\|
1149	rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0 \|\|
1150	rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0
1151	#if HHI_DEPTH_INTRA_SEARCH_RAU_C0160
1152	\|\| ((rpcBestCU->getSlice()->getIsDepth() == true) && (rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1153	#endif
1154	) && !bFullyRenderedSec ) // avoid very complex intra if it is unlikely
1155	#else
1156	if( rpcBestCU->getSlice()->getSliceType() == I_SLICE \|\|
1157	rpcBestCU->getCbf( 0, TEXT_LUMA ) != 0 \|\|
1158	rpcBestCU->getCbf( 0, TEXT_CHROMA_U ) != 0 \|\|
1159	rpcBestCU->getCbf( 0, TEXT_CHROMA_V ) != 0
1160	#if HHI_DEPTH_INTRA_SEARCH_RAU_C0160
1161	\|\| ((rpcBestCU->getSlice()->getIsDepth() == true) && (rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_IDR \|\| rpcBestCU->getSlice()->getNalUnitType() == NAL_UNIT_CODED_SLICE_CRA))
1162	#endif
1163	) // avoid very complex intra if it is unlikely
1164	#endif
1165	{
1166	#if LGE_ILLUCOMP_B0045
1167	rpcTempCU->setICFlagSubParts(false, 0, 0, uiDepth);
1168	#endif
1169	xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_2Nx2N );
1170	rpcTempCU->initEstData( uiDepth, iQP );
1171	if( uiDepth == g_uiMaxCUDepth - g_uiAddCUDepth )
1172	{
1173	#if H3D_QTL //Try IntraNxN
1174	if(bTrySplit)
1175	{
1176	#endif
1177	if( rpcTempCU->getWidth(0) > ( 1 << rpcTempCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() ) )
1178	{
1179	#if LGE_ILLUCOMP_B0045
1180	rpcTempCU->setICFlagSubParts(false, 0, 0, uiDepth);
1181	#endif
1182	xCheckRDCostIntra( rpcBestCU, rpcTempCU, SIZE_NxN );
1183	rpcTempCU->initEstData( uiDepth, iQP );
1184	}
1185	#if H3D_QTL
1186	}
1187	#endif
1188	}
1189	}
1190	}
1191
1192	// test PCM
1193	if(pcPic->getSlice(0)->getSPS()->getUsePCM()
1194	&& rpcTempCU->getWidth(0) <= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MaxSize())
1195	&& rpcTempCU->getWidth(0) >= (1<<pcPic->getSlice(0)->getSPS()->getPCMLog2MinSize()) )
1196	{
1197	UInt uiRawBits = (g_uiBitDepth * rpcBestCU->getWidth(0) * rpcBestCU->getHeight(0) * 3 / 2);
1198	UInt uiBestBits = rpcBestCU->getTotalBits();
1199	#if HHI_VSO
1200	Double dRDCostTemp = m_pcRdCost->getUseVSO() ? m_pcRdCost->calcRdCostVSO(uiRawBits, 0) : m_pcRdCost->calcRdCost(uiRawBits, 0);
1201	if((uiBestBits > uiRawBits) \|\| (rpcBestCU->getTotalCost() > dRDCostTemp ))
1202	#else
1203	if((uiBestBits > uiRawBits) \|\| (rpcBestCU->getTotalCost() > m_pcRdCost->calcRdCost(uiRawBits, 0)))
1204	#endif
1205	{
1206	#if LGE_ILLUCOMP_B0045
1207	rpcTempCU->setICFlagSubParts(false, 0, 0, uiDepth);
1208	#endif
1209	xCheckIntraPCM (rpcBestCU, rpcTempCU);
1210	rpcTempCU->initEstData( uiDepth, iQP );
1211	}
1212	}
1213	#if HHI_MPI
1214	if( rpcBestCU->getSlice()->getSPS()->getUseMVI() && rpcBestCU->getSlice()->getSliceType() != I_SLICE )
1215	{
1216	#if LGE_ILLUCOMP_DEPTH_C0046
1217	for(UInt uiICId = 0; uiICId < (bICEnabled ? 2 : 1); uiICId++)
1218	{
1219	Bool bICFlag = (uiICId ? true : false);
1220	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
1221	#endif
1222	xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, false, false );
1223	rpcTempCU->initEstData( uiDepth, iQP );
1224	#if FIX_ILLUCOMP_DEPTH
1225	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uiDepth);
1226	#endif
1227	xCheckRDCostMvInheritance( rpcBestCU, rpcTempCU, uiDepth, true, false );
1228	rpcTempCU->initEstData( uiDepth, iQP );
1229	#if LGE_ILLUCOMP_DEPTH_C0046
1230	}
1231	#endif
1232	}
1233	#endif
1234	#if LOSSLESS_CODING
1235	if (isAddLowestQP && (iQP == lowestQP))
1236	{
1237	iQP = iMinQP;
1238	}
1239	#endif
1240	}
1241
1242	m_pcEntropyCoder->resetBits();
1243	m_pcEntropyCoder->encodeSplitFlag( rpcBestCU, 0, uiDepth, true );
1244	rpcBestCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
1245	if(m_pcEncCfg->getUseSBACRD())
1246	{
1247	rpcBestCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
1248	}
1249
1250	#if HHI_VSO
1251	if ( m_pcRdCost->getUseVSO() )
1252	{
1253	rpcBestCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
1254	}
1255	else
1256	#endif
1257	{
1258	rpcBestCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcBestCU->getTotalBits(), rpcBestCU->getTotalDistortion() );
1259	}
1260
1261	// accumulate statistics for early skip
1262	if ( m_pcEncCfg->getUseFastEnc() )
1263	{
1264	if ( rpcBestCU->isSkipped(0) )
1265	{
1266	Int iIdx = g_aucConvertToBit[ rpcBestCU->getWidth(0) ];
1267	afCost[ iIdx ] += rpcBestCU->getTotalCost();
1268	aiNum [ iIdx ] ++;
1269	}
1270	}
1271
1272	// Early CU determination
1273	if( m_pcEncCfg->getUseEarlyCU() && ((*rpcBestCU->getPredictionMode()) == 0) )
1274	{
1275	bSubBranch = false;
1276	}
1277	else
1278	{
1279	bSubBranch = true;
1280	}
1281	#if HHI_INTERVIEW_SKIP
1282	rpcBestCU->setRenderableSubParts(bFullyRenderedSec,0,rpcBestCU->getDepth( 0 )) ;
1283	#endif
1284	}
1285	else if(!(bSliceEnd && bInsidePicture))
1286	{
1287	bBoundary = true;
1288	}
1289
1290	#if LOSSLESS_CODING
1291	// copy orginal YUV samples to PCM buffer
1292	if( rpcBestCU->isLosslessCoded(0) && (rpcBestCU->getIPCMFlag(0) == false))
1293	{
1294	xFillPCMBuffer(rpcBestCU, m_ppcOrigYuv[uiDepth]);
1295	}
1296	#endif
1297	if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
1298	{
1299	Int idQP = m_pcEncCfg->getMaxDeltaQP();
1300	iMinQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP-idQP );
1301	iMaxQP = Clip3( -rpcTempCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQP+idQP );
1302	#if LOSSLESS_CODING
1303	if ( (rpcTempCU->getSlice()->getSPS()->getUseLossless()) && (lowestQP < iMinQP) && rpcTempCU->getSlice()->getPPS()->getUseDQP() )
1304	{
1305	isAddLowestQP = true;
1306	iMinQP = iMinQP - 1;
1307	}
1308	#endif
1309	}
1310	else if( (g_uiMaxCUWidth>>uiDepth) > rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
1311	{
1312	iMinQP = iBaseQP;
1313	iMaxQP = iBaseQP;
1314	}
1315	else
1316	{
1317	Int iStartQP;
1318	if( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) == pcSlice->getEntropySliceCurStartCUAddr())
1319	{
1320	iStartQP = rpcTempCU->getQP(0);
1321	}
1322	else
1323	{
1324	UInt uiCurSliceStartPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
1325	iStartQP = rpcTempCU->getQP(uiCurSliceStartPartIdx);
1326	}
1327	iMinQP = iStartQP;
1328	iMaxQP = iStartQP;
1329	}
1330
1331	for (Int iQP=iMinQP; iQP<=iMaxQP; iQP++)
1332	{
1333	#if LOSSLESS_CODING
1334	if (isAddLowestQP && (iQP == iMinQP))
1335	{
1336	iQP = lowestQP;
1337	}
1338	#endif
1339	rpcTempCU->initEstData( uiDepth, iQP );
1340
1341	// further split
1342	if( bSubBranch && bTrySplitDQP && uiDepth < g_uiMaxCUDepth - g_uiAddCUDepth )
1343	{
1344	#if HHI_VSO
1345	// reset Model
1346	if( m_pcRdCost->getUseRenModel() )
1347	{
1348	UInt uiWidth = m_ppcOrigYuv[uiDepth]->getWidth ( );
1349	UInt uiHeight = m_ppcOrigYuv[uiDepth]->getHeight( );
1350	Pel* piSrc = m_ppcOrigYuv[uiDepth]->getLumaAddr( 0 );
1351	UInt uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride();
1352	m_pcRdCost->setRenModelData( m_ppcBestCU[uiDepth], 0, piSrc, uiSrcStride, uiWidth, uiHeight );
1353	}
1354	#endif
1355	UChar uhNextDepth = uiDepth+1;
1356	TComDataCU* pcSubBestPartCU = m_ppcBestCU[uhNextDepth];
1357	TComDataCU* pcSubTempPartCU = m_ppcTempCU[uhNextDepth];
1358
1359	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
1360	{
1361	pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP ); // clear sub partition datas or init.
1362	pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP ); // clear sub partition datas or init.
1363
1364	Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getEntropySliceCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getEntropySliceCurEndCUAddr();
1365	if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
1366	{
1367	if( m_bUseSBACRD )
1368	{
1369	if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
1370	{
1371	m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
1372	}
1373	else
1374	{
1375	m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
1376	}
1377	}
1378
1379	#if AMP_ENC_SPEEDUP
1380	if ( rpcBestCU->isIntra(0) )
1381	{
1382	xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, SIZE_NONE );
1383	}
1384	else
1385	{
1386	xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth, rpcBestCU->getPartitionSize(0) );
1387	}
1388	#else
1389	xCompressCU( pcSubBestPartCU, pcSubTempPartCU, uhNextDepth );
1390	#endif
1391
1392	rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth ); // Keep best part data to current temporary data.
1393	xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
1394
1395	#if HHI_VSO
1396	#endif
1397	}
1398	else if (bInSlice)
1399	{
1400	pcSubBestPartCU->copyToPic( uhNextDepth );
1401	rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
1402	}
1403	}
1404
1405	if( !bBoundary )
1406	{
1407	m_pcEntropyCoder->resetBits();
1408	m_pcEntropyCoder->encodeSplitFlag( rpcTempCU, 0, uiDepth, true );
1409
1410	rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // split bits
1411	if(m_pcEncCfg->getUseSBACRD())
1412	{
1413	rpcTempCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
1414	}
1415	}
1416	#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
1417	if( bFullyRenderedSec )
1418	{
1419	m_pcRdCost->setLambdaScale( m_pcEncCfg->getInterViewSkipLambdaScale() );
1420	}
1421	else
1422	{
1423	m_pcRdCost->setLambdaScale( 1 );
1424	}
1425	#endif
1426
1427	#if HHI_VSO
1428	if ( m_pcRdCost->getUseVSO() )
1429	{
1430	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1431	}
1432	else
1433	#endif
1434	{
1435	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1436	}
1437
1438	if( (g_uiMaxCUWidth>>uiDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
1439	{
1440	Bool bHasRedisual = false;
1441	for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
1442	{
1443	if( ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getEntropySliceCurStartCUAddr() ) &&
1444	( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) \|\| rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) \|\| rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
1445	{
1446	bHasRedisual = true;
1447	break;
1448	}
1449	}
1450
1451	UInt uiTargetPartIdx;
1452	if ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getEntropySliceCurStartCUAddr() )
1453	{
1454	uiTargetPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
1455	}
1456	else
1457	{
1458	uiTargetPartIdx = 0;
1459	}
1460	if ( bHasRedisual )
1461	{
1462	#if !RDO_WITHOUT_DQP_BITS
1463	m_pcEntropyCoder->resetBits();
1464	m_pcEntropyCoder->encodeQP( rpcTempCU, uiTargetPartIdx, false );
1465	rpcTempCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
1466	if(m_pcEncCfg->getUseSBACRD())
1467	{
1468	rpcTempCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
1469	}
1470	#if HHI_VSO
1471	if ( m_pcRdCost->getUseLambdaScaleVSO())
1472	{
1473	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1474	}
1475	else
1476	#endif
1477	{
1478	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
1479	}
1480	#endif
1481	}
1482	else
1483	{
1484	#if LOSSLESS_CODING
1485	if (((rpcTempCU->getQP(uiTargetPartIdx) != rpcTempCU->getRefQP(uiTargetPartIdx)) ) && (rpcTempCU->getSlice()->getSPS()->getUseLossless()))
1486	{
1487	rpcTempCU->getTotalCost() = MAX_DOUBLE;
1488	}
1489	#endif
1490	rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uiDepth ); // set QP to default QP
1491	}
1492	}
1493
1494	if( m_bUseSBACRD )
1495	{
1496	m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
1497	}
1498	Bool bEntropyLimit=false;
1499	Bool bSliceLimit=false;
1500	bSliceLimit=rpcBestCU->getSlice()->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE&&(rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getSliceArgument()<<3);
1501	if(rpcBestCU->getSlice()->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&m_pcEncCfg->getUseSBACRD())
1502	{
1503	if(rpcBestCU->getTotalBins()>rpcBestCU->getSlice()->getEntropySliceArgument())
1504	{
1505	bEntropyLimit=true;
1506	}
1507	}
1508	else if(rpcBestCU->getSlice()->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE)
1509	{
1510	if(rpcBestCU->getTotalBits()>rpcBestCU->getSlice()->getEntropySliceArgument())
1511	{
1512	bEntropyLimit=true;
1513	}
1514	}
1515	if(rpcBestCU->getDepth(0)>=rpcBestCU->getSlice()->getPPS()->getSliceGranularity())
1516	{
1517	bSliceLimit=false;
1518	bEntropyLimit=false;
1519	}
1520	if(bSliceLimit\|\|bEntropyLimit)
1521	{
1522	rpcBestCU->getTotalCost()=rpcTempCU->getTotalCost()+1;
1523	}
1524	xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth); // RD compare current larger prediction
1525	} // with sub partitioned prediction.
1526	#if LOSSLESS_CODING
1527	if (isAddLowestQP && (iQP == lowestQP))
1528	{
1529	iQP = iMinQP;
1530	}
1531	#endif
1532	} // SPLIT- QP Loop
1533
1534	#if HHI_VSO
1535	if( m_pcRdCost->getUseRenModel() )
1536	{
1537	UInt uiWidth = m_ppcRecoYuvBest[uiDepth]->getWidth ( );
1538	UInt uiHeight = m_ppcRecoYuvBest[uiDepth]->getHeight ( );
1539	Pel* piSrc = m_ppcRecoYuvBest[uiDepth]->getLumaAddr( 0 );
1540	UInt uiSrcStride = m_ppcRecoYuvBest[uiDepth]->getStride ( );
1541	m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
1542	}
1543	#endif
1544
1545	rpcBestCU->copyToPic(uiDepth); // Copy Best data to Picture for next partition prediction.
1546
1547	xCopyYuv2Pic( rpcBestCU->getPic(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU(), uiDepth, uiDepth, rpcBestCU, uiLPelX, uiTPelY ); // Copy Yuv data to picture Yuv
1548	if( bBoundary \|\|(bSliceEnd && bInsidePicture))
1549	{
1550	return;
1551	}
1552
1553	// Assert if Best prediction mode is NONE
1554	// Selected mode's RD-cost must be not MAX_DOUBLE.
1555	assert( rpcBestCU->getPartitionSize ( 0 ) != SIZE_NONE );
1556	assert( rpcBestCU->getPredictionMode( 0 ) != MODE_NONE );
1557	assert( rpcBestCU->getTotalCost ( ) != MAX_DOUBLE );
1558	}
1559
1560	/** finish encoding a cu and handle end-of-slice conditions
1561	* \param pcCU
1562	* \param uiAbsPartIdx
1563	* \param uiDepth
1564	* \returns Void
1565	*/
1566	Void TEncCu::finishCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1567	{
1568	TComPic* pcPic = pcCU->getPic();
1569	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
1570
1571	//Calculate end address
1572	UInt uiCUAddr = pcCU->getSCUAddr()+uiAbsPartIdx;
1573
1574	UInt uiInternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) % pcPic->getNumPartInCU();
1575	UInt uiExternalAddress = pcPic->getPicSym()->getPicSCUAddr(pcSlice->getEntropySliceCurEndCUAddr()-1) / pcPic->getNumPartInCU();
1576	UInt uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1577	UInt uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1578	UInt uiWidth = pcSlice->getSPS()->getPicWidthInLumaSamples();
1579	UInt uiHeight = pcSlice->getSPS()->getPicHeightInLumaSamples();
1580	while(uiPosX>=uiWidth\|\|uiPosY>=uiHeight)
1581	{
1582	uiInternalAddress--;
1583	uiPosX = ( uiExternalAddress % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth+ g_auiRasterToPelX[ g_auiZscanToRaster[uiInternalAddress] ];
1584	uiPosY = ( uiExternalAddress / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight+ g_auiRasterToPelY[ g_auiZscanToRaster[uiInternalAddress] ];
1585	}
1586	uiInternalAddress++;
1587	if(uiInternalAddress==pcCU->getPic()->getNumPartInCU())
1588	{
1589	uiInternalAddress = 0;
1590	uiExternalAddress = pcPic->getPicSym()->getCUOrderMap(pcPic->getPicSym()->getInverseCUOrderMap(uiExternalAddress)+1);
1591	}
1592	UInt uiRealEndAddress = pcPic->getPicSym()->getPicSCUEncOrder(uiExternalAddress*pcPic->getNumPartInCU()+uiInternalAddress);
1593
1594	// Encode slice finish
1595	Bool bTerminateSlice = false;
1596	if (uiCUAddr+(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)) == uiRealEndAddress)
1597	{
1598	bTerminateSlice = true;
1599	}
1600	UInt uiGranularityWidth = g_uiMaxCUWidth>>(pcSlice->getPPS()->getSliceGranularity());
1601	uiPosX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
1602	uiPosY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
1603	Bool granularityBoundary=((uiPosX+pcCU->getWidth(uiAbsPartIdx))%uiGranularityWidth==0\|\|(uiPosX+pcCU->getWidth(uiAbsPartIdx)==uiWidth))
1604	&&((uiPosY+pcCU->getHeight(uiAbsPartIdx))%uiGranularityWidth==0\|\|(uiPosY+pcCU->getHeight(uiAbsPartIdx)==uiHeight));
1605
1606	if(granularityBoundary && (!(pcCU->getIPCMFlag(uiAbsPartIdx) && ( pcCU->getNumSucIPCM() > 1 ))))
1607	{
1608	// The 1-terminating bit is added to all streams, so don't add it here when it's 1.
1609	if (!bTerminateSlice)
1610	m_pcEntropyCoder->encodeTerminatingBit( bTerminateSlice ? 1 : 0 );
1611	}
1612
1613	Int numberOfWrittenBits = 0;
1614	if (m_pcBitCounter)
1615	{
1616	numberOfWrittenBits = m_pcEntropyCoder->getNumberOfWrittenBits();
1617	}
1618
1619	// Calculate slice end IF this CU puts us over slice bit size.
1620	unsigned iGranularitySize = pcCU->getPic()->getNumPartInCU()>>(pcSlice->getPPS()->getSliceGranularity()<<1);
1621	int iGranularityEnd = ((pcCU->getSCUAddr()+uiAbsPartIdx)/iGranularitySize)*iGranularitySize;
1622	if(iGranularityEnd<=pcSlice->getEntropySliceCurStartCUAddr())
1623	{
1624	iGranularityEnd+=max(iGranularitySize,(pcCU->getPic()->getNumPartInCU()>>(uiDepth<<1)));
1625	}
1626	// Set slice end parameter
1627	if(pcSlice->getSliceMode()==AD_HOC_SLICES_FIXED_NUMBER_OF_BYTES_IN_SLICE&&!pcSlice->getFinalized()&&pcSlice->getSliceBits()+numberOfWrittenBits>pcSlice->getSliceArgument()<<3)
1628	{
1629	pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
1630	pcSlice->setSliceCurEndCUAddr(iGranularityEnd);
1631	return;
1632	}
1633	// Set entropy slice end parameter
1634	if(m_pcEncCfg->getUseSBACRD())
1635	{
1636	TEncBinCABAC pppcRDSbacCoder = (TEncBinCABAC ) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
1637	UInt uiBinsCoded = pppcRDSbacCoder->getBinsCoded();
1638	if(pcSlice->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&!pcSlice->getFinalized()&&pcSlice->getEntropySliceCounter()+uiBinsCoded>pcSlice->getEntropySliceArgument())
1639	{
1640	pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
1641	return;
1642	}
1643	}
1644	else
1645	{
1646	if(pcSlice->getEntropySliceMode()==SHARP_MULTIPLE_CONSTRAINT_BASED_ENTROPY_SLICE&&!pcSlice->getFinalized()&&pcSlice->getEntropySliceCounter()+numberOfWrittenBits>pcSlice->getEntropySliceArgument())
1647	{
1648	pcSlice->setEntropySliceCurEndCUAddr(iGranularityEnd);
1649	return;
1650	}
1651	}
1652	if(granularityBoundary)
1653	{
1654	pcSlice->setSliceBits( (UInt)(pcSlice->getSliceBits() + numberOfWrittenBits) );
1655	if(m_pcEncCfg->getUseSBACRD())
1656	{
1657	TEncBinCABAC pppcRDSbacCoder = (TEncBinCABAC ) m_pppcRDSbacCoder[0][CI_CURR_BEST]->getEncBinIf();
1658	pcSlice->setEntropySliceCounter(pcSlice->getEntropySliceCounter()+pppcRDSbacCoder->getBinsCoded());
1659	pppcRDSbacCoder->setBinsCoded( 0 );
1660	}
1661	else
1662	{
1663	pcSlice->setEntropySliceCounter(pcSlice->getEntropySliceCounter()+numberOfWrittenBits);
1664	}
1665	if (m_pcBitCounter)
1666	{
1667	m_pcEntropyCoder->resetBits();
1668	}
1669	}
1670	}
1671
1672	/** Compute QP for each CU
1673	* \param pcCU Target CU
1674	* \param uiDepth CU depth
1675	* \returns quantization parameter
1676	*/
1677	Int TEncCu::xComputeQP( TComDataCU* pcCU, UInt uiDepth )
1678	{
1679	Int iBaseQp = pcCU->getSlice()->getSliceQp();
1680	Int iQpOffset = 0;
1681	if ( m_pcEncCfg->getUseAdaptiveQP() )
1682	{
1683	TEncPic* pcEPic = dynamic_cast<TEncPic*>( pcCU->getPic() );
1684	UInt uiAQDepth = min( uiDepth, pcEPic->getMaxAQDepth()-1 );
1685	TEncPicQPAdaptationLayer* pcAQLayer = pcEPic->getAQLayer( uiAQDepth );
1686	UInt uiAQUPosX = pcCU->getCUPelX() / pcAQLayer->getAQPartWidth();
1687	UInt uiAQUPosY = pcCU->getCUPelY() / pcAQLayer->getAQPartHeight();
1688	UInt uiAQUStride = pcAQLayer->getAQPartStride();
1689	TEncQPAdaptationUnit* acAQU = pcAQLayer->getQPAdaptationUnit();
1690
1691	Double dMaxQScale = pow(2.0, m_pcEncCfg->getQPAdaptationRange()/6.0);
1692	Double dAvgAct = pcAQLayer->getAvgActivity();
1693	Double dCUAct = acAQU[uiAQUPosY * uiAQUStride + uiAQUPosX].getActivity();
1694	Double dNormAct = (dMaxQScaledCUAct + dAvgAct) / (dCUAct + dMaxQScaledAvgAct);
1695	Double dQpOffset = log(dNormAct) / log(2.0) * 6.0;
1696	iQpOffset = Int(floor( dQpOffset + 0.49999 ));
1697	}
1698	return Clip3(-pcCU->getSlice()->getSPS()->getQpBDOffsetY(), MAX_QP, iBaseQp+iQpOffset );
1699	}
1700
1701	/** encode a CU block recursively
1702	* \param pcCU
1703	* \param uiAbsPartIdx
1704	* \param uiDepth
1705	* \returns Void
1706	*/
1707	Void TEncCu::xEncodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
1708	{
1709	TComPic* pcPic = pcCU->getPic();
1710
1711	Bool bBoundary = false;
1712	UInt uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
1713	UInt uiRPelX = uiLPelX + (g_uiMaxCUWidth>>uiDepth) - 1;
1714	UInt uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
1715	UInt uiBPelY = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
1716
1717	if( getCheckBurstIPCMFlag() )
1718	{
1719	pcCU->setLastCUSucIPCMFlag( checkLastCUSucIPCM( pcCU, uiAbsPartIdx ));
1720	pcCU->setNumSucIPCM( countNumSucIPCM ( pcCU, uiAbsPartIdx ) );
1721	}
1722
1723	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
1724	// If slice start is within this cu...
1725	Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr() > pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
1726	pcSlice->getEntropySliceCurStartCUAddr() < pcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcPic->getNumPartInCU() >> (uiDepth<<1) );
1727	// We need to split, so don't try these modes.
1728	if(!bSliceStart&&( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
1729	{
1730	#if HHI_MPI
1731	if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 \|\| uiDepth < pcCU->getTextureModeDepth( uiAbsPartIdx ) )
1732	{
1733	#endif
1734
1735	m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
1736
1737	#if HHI_MPI
1738	}
1739	#endif
1740	}
1741	else
1742	{
1743	bBoundary = true;
1744	}
1745
1746	#if HHI_MPI
1747	if( uiDepth == pcCU->getTextureModeDepth( uiAbsPartIdx ) )
1748	{
1749	xSaveDepthWidthHeight( pcCU );
1750	pcCU->setSizeSubParts( g_uiMaxCUWidth>>uiDepth, g_uiMaxCUHeight>>uiDepth, uiAbsPartIdx, uiDepth );
1751	pcCU->setDepthSubParts( uiDepth, uiAbsPartIdx );
1752
1753	if( ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
1754	{
1755	m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );
1756	}
1757
1758	if( !pcCU->getSlice()->isIntra() )
1759	{
1760	m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
1761	}
1762
1763	if( pcCU->isSkipped( uiAbsPartIdx ) )
1764	{
1765	m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
1766	#if LGE_ILLUCOMP_DEPTH_C0046
1767	m_pcEntropyCoder->encodeICFlag ( pcCU, uiAbsPartIdx, false, uiDepth );
1768	#endif
1769	finishCU(pcCU,uiAbsPartIdx,uiDepth);
1770	xRestoreDepthWidthHeight( pcCU );
1771	return;
1772	}
1773
1774	m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
1775
1776	m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
1777
1778	// prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
1779	m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
1780	#if LGE_ILLUCOMP_DEPTH_C0046
1781	m_pcEntropyCoder->encodeICFlag ( pcCU, uiAbsPartIdx, false, uiDepth );
1782	#endif
1783	xRestoreDepthWidthHeight( pcCU );
1784	}
1785	#endif
1786
1787	if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < (g_uiMaxCUDepth-g_uiAddCUDepth) ) ) \|\| bBoundary )
1788	{
1789	UInt uiQNumParts = ( pcPic->getNumPartInCU() >> (uiDepth<<1) )>>2;
1790	if( (g_uiMaxCUWidth>>uiDepth) == pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
1791	{
1792	setdQPFlag(true);
1793	}
1794	pcCU->setNumSucIPCM(0);
1795	pcCU->setLastCUSucIPCMFlag(false);
1796	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
1797	{
1798	uiLPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
1799	uiTPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
1800	Bool bInSlice = pcCU->getSCUAddr()+uiAbsPartIdx+uiQNumParts>pcSlice->getEntropySliceCurStartCUAddr()&&pcCU->getSCUAddr()+uiAbsPartIdx<pcSlice->getEntropySliceCurEndCUAddr();
1801	if(bInSlice&&( uiLPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
1802	{
1803	xEncodeCU( pcCU, uiAbsPartIdx, uiDepth+1 );
1804	}
1805	}
1806	return;
1807	}
1808
1809	if( (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() && pcCU->getSlice()->getPPS()->getUseDQP())
1810	{
1811	setdQPFlag(true);
1812	}
1813	#if HHI_MPI
1814	if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
1815	{
1816	#endif
1817	if( !pcCU->getSlice()->isIntra() )
1818	{
1819	m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );
1820	}
1821	#if HHI_MPI
1822	}
1823	#endif
1824
1825	if( pcCU->isSkipped( uiAbsPartIdx ) )
1826	{
1827	m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx, 0 );
1828	#if LGE_ILLUCOMP_B0045
1829	m_pcEntropyCoder->encodeICFlag ( pcCU, uiAbsPartIdx
1830	#if LGE_ILLUCOMP_DEPTH_C0046
1831	, false, uiDepth
1832	#endif
1833	);
1834	#endif
1835	#if QC_ARP_D0177
1836	m_pcEntropyCoder->encodeARPW( pcCU , uiAbsPartIdx, 0, uiDepth);
1837	#endif
1838	finishCU(pcCU,uiAbsPartIdx,uiDepth);
1839	return;
1840	}
1841	#if HHI_MPI
1842	if( pcCU->getTextureModeDepth( uiAbsPartIdx ) == -1 )
1843	{
1844	#endif
1845	m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );
1846
1847	m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
1848
1849	if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
1850	{
1851	m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );
1852
1853	if(pcCU->getIPCMFlag(uiAbsPartIdx))
1854	{
1855	// Encode slice finish
1856	finishCU(pcCU,uiAbsPartIdx,uiDepth);
1857	return;
1858	}
1859	}
1860
1861	// prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
1862	m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );
1863	#if LGE_ILLUCOMP_B0045
1864	m_pcEntropyCoder->encodeICFlag ( pcCU, uiAbsPartIdx
1865	#if LGE_ILLUCOMP_DEPTH_C0046
1866	,false, uiDepth
1867	#endif
1868	);
1869	#endif
1870	#if HHI_MPI
1871	}
1872	#endif
1873
1874	// Encode Coefficients
1875	Bool bCodeDQP = getdQPFlag();
1876	m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, pcCU->getWidth (uiAbsPartIdx), pcCU->getHeight(uiAbsPartIdx), bCodeDQP );
1877	setdQPFlag( bCodeDQP );
1878
1879	// --- write terminating bit ---
1880	finishCU(pcCU,uiAbsPartIdx,uiDepth);
1881	}
1882
1883	/** check RD costs for a CU block encoded with merge
1884	* \param rpcBestCU
1885	* \param rpcTempCU
1886	* \returns Void
1887	*/
1888	#if HHI_INTERVIEW_SKIP
1889	Void TEncCu::xCheckRDCostMerge2Nx2N( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, Bool bSkipRes )
1890	#else
1891	Void TEncCu::xCheckRDCostMerge2Nx2N( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU )
1892	#endif
1893	{
1894	assert( rpcTempCU->getSlice()->getSliceType() != I_SLICE );
1895	#if H3D_IVMP
1896	TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS_MEM << 1]; // double length for mv of both lists
1897	UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS_MEM];
1898	#else
1899	TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
1900	UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
1901	#endif
1902	Int numValidMergeCand = 0;
1903
1904	#if QC_ARP_D0177
1905	Bool bResPrdAvail = rpcTempCU->getResPredAvail( 0 );
1906	Bool bResPrdFlag = rpcTempCU->getResPredFlag ( 0 );
1907	#endif
1908	#if LGE_ILLUCOMP_B0045
1909	Bool bICFlag = rpcTempCU->getICFlag(0);
1910	#endif
1911
1912	#if H3D_IVMP
1913	for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS_MEM; ++ui )
1914	#else
1915	for( UInt ui = 0; ui < MRG_MAX_NUM_CANDS; ++ui )
1916	#endif
1917	{
1918	uhInterDirNeighbours[ui] = 0;
1919	}
1920	UChar uhDepth = rpcTempCU->getDepth( 0 );
1921
1922	#if HHI_VSO
1923	if( m_pcRdCost->getUseRenModel() )
1924	{
1925	UInt uiWidth = m_ppcOrigYuv[uhDepth]->getWidth ( );
1926	UInt uiHeight = m_ppcOrigYuv[uhDepth]->getHeight( );
1927	Pel* piSrc = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
1928	UInt uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
1929	m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
1930	}
1931	#endif
1932
1933	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
1934	#if MERL_VSP_C0152
1935	Int iVSPIndexTrue[3] = {-1, -1, -1};
1936	rpcTempCU->getInterMergeCandidates( 0, 0, uhDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand, iVSPIndexTrue );
1937	#else
1938	rpcTempCU->getInterMergeCandidates( 0, 0, uhDepth, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
1939	#endif
1940	#if H3D_IVRP & !QC_ARP_D0177
1941	Bool bResPredAvail = rpcTempCU->getResPredAvail(0);
1942	#endif
1943
1944	Bool bestIsSkip = false;
1945	#if QC_ARP_D0177
1946	Int nGRPW = rpcTempCU->getSlice()->getARPStepNum() - 1;
1947	if(nGRPW < 0 \|\| !bResPrdAvail )
1948	nGRPW = 0;
1949	for( ; nGRPW >= 0 ; nGRPW-- )
1950	{
1951	#endif
1952	for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
1953	{
1954	{
1955	TComYuv* pcPredYuvTemp = NULL;
1956	#if LOSSLESS_CODING
1957	UInt iteration;
1958	if ( rpcTempCU->isLosslessCoded(0))
1959	{
1960	iteration = 1;
1961	}
1962	else
1963	{
1964	iteration = 2;
1965	}
1966
1967	#if HHI_INTERVIEW_SKIP
1968	for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < iteration; ++uiNoResidual )
1969	#else
1970	for( UInt uiNoResidual = 0; uiNoResidual < iteration; ++uiNoResidual )
1971	#endif
1972	#else
1973	#if HHI_INTERVIEW_SKIP
1974	for( UInt uiNoResidual = (bSkipRes ? 1:0); uiNoResidual < 2; ++uiNoResidual )
1975	#else
1976	for( UInt uiNoResidual = 0; uiNoResidual < 2; ++uiNoResidual )
1977	#endif
1978	#endif
1979	{
1980	if( !(bestIsSkip && uiNoResidual == 0) )
1981	{
1982	// set MC parameters
1983	rpcTempCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth ); // interprets depth relative to LCU level
1984	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth ); // interprets depth relative to LCU level
1985	#if QC_ARP_D0177
1986	if(rpcTempCU->getSlice()->getSPS()->getUseAdvRP())
1987	rpcTempCU->setARPWSubParts( ( UChar )nGRPW , 0 , uhDepth );
1988	#endif
1989	rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth ); // interprets depth relative to LCU level
1990	rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth ); // interprets depth relative to LCU level
1991	#if MERL_VSP_C0152
1992	{
1993	Int iVSPIdx = 0;
1994	Int numVSPIdx;
1995	numVSPIdx = 3;
1996	for (Int i = 0; i < numVSPIdx; i++)
1997	{
1998	if (iVSPIndexTrue[i] == uiMergeCand)
1999	{
2000	iVSPIdx = i+1;
2001	break;
2002	}
2003	}
2004	rpcTempCU->setVSPIndexSubParts( iVSPIdx, 0, 0, uhDepth );
2005	}
2006	#endif
2007	rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth ); // interprets depth relative to LCU level
2008	rpcTempCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
2009	rpcTempCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], SIZE_2Nx2N, 0, 0 ); // interprets depth relative to rpcTempCU level
2010
2011	#if H3D_IVRP
2012	#if !QC_ARP_D0177
2013	rpcTempCU->setResPredAvailSubParts(bResPredAvail, 0, 0, uhDepth);
2014	#else
2015	rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
2016	rpcTempCU->setResPredFlagSubParts ( bResPrdFlag, 0, 0, uhDepth );
2017	#endif
2018	#endif
2019	#if LGE_ILLUCOMP_B0045
2020	rpcTempCU->setICFlagSubParts(bICFlag, 0, 0, uhDepth);
2021	#endif
2022	#if QC_ARP_D0177
2023	if(rpcTempCU->getSlice()->getSPS()->getUseAdvRP())
2024	{
2025	bool bSignalflag[2] = {true, true};
2026	for(UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx ++ )
2027	{
2028	Int iRefIdx = cMvFieldNeighbours[uiRefListIdx + 2*uiMergeCand].getRefIdx();
2029	RefPicList eRefList = uiRefListIdx ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
2030	if(iRefIdx < 0 \|\| rpcTempCU->getSlice()->getPOC() == rpcTempCU->getSlice()->getRefPOC(eRefList, iRefIdx))
2031	bSignalflag[uiRefListIdx] = false;
2032	}
2033	if(!bSignalflag[0]&& !bSignalflag[1])
2034	{
2035	rpcTempCU->setARPWSubParts( 0 , 0 , uhDepth );
2036	}
2037	}
2038	#endif
2039	// do MC
2040	#if HHI_INTERVIEW_SKIP
2041	if ( (uiNoResidual == 0) \|\| bSkipRes )
2042	#else
2043	if ( uiNoResidual == 0 )
2044	#endif
2045	{
2046	#if MERL_VSP_C0152
2047	m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth], rpcTempCU->getZorderIdxInCU() );
2048	#else
2049	m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
2050	#endif
2051	#if H3D_IVRP & !QC_ARP_D0177
2052	if (uiMergeCand == 0 && rpcTempCU->getResPredAvail(0))
2053	{
2054	m_pcPredSearch->residualPrediction(rpcTempCU, m_ppcPredYuvTemp[uhDepth], m_ppcResPredTmp [uhDepth]);
2055	}
2056	#endif
2057	// save pred adress
2058	pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
2059
2060	}
2061	else
2062	{
2063	if( bestIsSkip)
2064	{
2065	#if MERL_VSP_C0152
2066	m_pcPredSearch->motionCompensation( rpcTempCU, m_ppcPredYuvTemp[uhDepth], rpcTempCU->getZorderIdxInCU() );
2067	#else
2068	m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
2069	#endif
2070	#if H3D_IVRP & !QC_ARP_D0177
2071	if (uiMergeCand == 0 && rpcTempCU->getResPredAvail(0))
2072	{
2073	m_pcPredSearch->residualPrediction(rpcTempCU, m_ppcPredYuvTemp[uhDepth], m_ppcResPredTmp [uhDepth]);
2074	}
2075	#endif
2076	// save pred adress
2077	pcPredYuvTemp = m_ppcPredYuvTemp[uhDepth];
2078	}
2079	else
2080	{
2081	if ( pcPredYuvTemp != m_ppcPredYuvTemp[uhDepth])
2082	{
2083	//adress changes take best (old temp)
2084	pcPredYuvTemp = m_ppcPredYuvBest[uhDepth];
2085	}
2086	}
2087	}
2088	#if HHI_VSO
2089	if( m_pcRdCost->getUseRenModel() )
2090	{ //Reset
2091	UInt uiWidth = m_ppcOrigYuv[uhDepth]->getWidth ();
2092	UInt uiHeight = m_ppcOrigYuv[uhDepth]->getHeight ();
2093	Pel* piSrc = m_ppcOrigYuv[uhDepth]->getLumaAddr ();
2094	UInt uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride ();
2095	m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2096	}
2097	#endif
2098	// estimate residual and encode everything
2099	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2100	m_ppcOrigYuv [uhDepth],
2101	pcPredYuvTemp,
2102	m_ppcResiYuvTemp[uhDepth],
2103	m_ppcResiYuvBest[uhDepth],
2104	m_ppcRecoYuvTemp[uhDepth],
2105	#if H3D_IVRP
2106	m_ppcResPredTmp [uhDepth],
2107	#endif
2108	(uiNoResidual? true:false) );
2109	Bool bQtRootCbf = rpcTempCU->getQtRootCbf(0) == 1;
2110
2111	Int orgQP = rpcTempCU->getQP( 0 );
2112	xCheckDQP( rpcTempCU );
2113	xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
2114	rpcTempCU->initEstData( uhDepth, orgQP );
2115
2116	if( m_pcEncCfg->getUseFastDecisionForMerge() && !bestIsSkip )
2117	{
2118	bestIsSkip = rpcBestCU->getQtRootCbf(0) == 0;
2119	}
2120
2121	if (!bQtRootCbf)
2122	break;
2123	}
2124	}
2125	}
2126	}
2127	#if QC_ARP_D0177
2128	}
2129	#endif
2130	}
2131
2132	#if AMP_MRG
2133	#if HHI_INTERVIEW_SKIP
2134	Void TEncCu::xCheckRDCostInter( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize ePartSize, Bool bSkipRes, Bool bUseMRG)
2135	#else
2136	Void TEncCu::xCheckRDCostInter( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize ePartSize, Bool bUseMRG)
2137	#endif
2138	#else
2139	#if HHI_INTERVIEW_SKIP
2140	Void TEncCu::xCheckRDCostInter( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize ePartSize, Bool bSkipRes)
2141	#else
2142	Void TEncCu::xCheckRDCostInter( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize ePartSize )
2143	#endif
2144	#endif
2145	{
2146	UChar uhDepth = rpcTempCU->getDepth( 0 );
2147	#if QC_ARP_D0177
2148	Bool bFirstTime = true;
2149	Int nARPWMax = rpcTempCU->getSlice()->getARPStepNum() - 1;
2150	if(nARPWMax < 0 \|\| !rpcTempCU->getResPredAvail( 0 ) )
2151	nARPWMax = 0;
2152	if( ePartSize != SIZE_2Nx2N)
2153	nARPWMax = 0;
2154	Int nARPWStart = 0 , nARPWStep = 1;
2155	for( Int nCount = 0 , nGRPW = nARPWStart ; nCount <= nARPWMax ; nCount++ , nGRPW += nARPWStep )
2156	{
2157	if( bFirstTime == false && rpcTempCU->getSlice()->getSPS()->getUseAdvRP() )
2158	rpcTempCU->initEstData( rpcTempCU->getDepth(0), rpcTempCU->getQP(0) );
2159	#endif
2160	#if HHI_VSO
2161	if( m_pcRdCost->getUseRenModel() )
2162	{
2163	UInt uiWidth = m_ppcOrigYuv[uhDepth]->getWidth ( );
2164	UInt uiHeight = m_ppcOrigYuv[uhDepth]->getHeight( );
2165	Pel* piSrc = m_ppcOrigYuv[uhDepth]->getLumaAddr( );
2166	UInt uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride();
2167	m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2168	}
2169	#endif
2170
2171	rpcTempCU->setDepthSubParts( uhDepth, 0 );
2172
2173	#if H3D_IVRP
2174	Bool bResPrdAvail = rpcTempCU->getResPredAvail( 0 );
2175	Bool bResPrdFlag = rpcTempCU->getResPredFlag ( 0 );
2176	#endif
2177
2178	rpcTempCU->setPartSizeSubParts ( ePartSize, 0, uhDepth );
2179
2180	#if H3D_IVRP
2181	rpcTempCU->setResPredAvailSubParts( bResPrdAvail, 0, 0, uhDepth );
2182	rpcTempCU->setResPredFlagSubParts ( bResPrdFlag, 0, 0, uhDepth );
2183	#endif
2184	rpcTempCU->setPredModeSubParts ( MODE_INTER, 0, uhDepth );
2185
2186	#if QC_ARP_D0177
2187	if(rpcTempCU->getSlice()->getSPS()->getUseAdvRP())
2188	rpcTempCU->setARPWSubParts( ( UChar )nGRPW , 0 , uhDepth );
2189	#endif
2190	#if QC_ARP_D0177
2191	if( bFirstTime == false && rpcTempCU->getSlice()->getSPS()->getUseAdvRP())
2192	{
2193	assert(!rpcTempCU->getSlice()->getSPS()->isDepth());
2194	rpcTempCU->copyPartFrom( m_ppcWeightedTempCU[uhDepth] , 0 , uhDepth, true );
2195	rpcTempCU->setARPWSubParts( ( UChar )nGRPW , 0 , uhDepth );
2196	#if MERL_VSP_C0152
2197	m_pcPredSearch->motionCompensation( rpcTempCU , m_ppcPredYuvTemp[uhDepth], 0);
2198	#else
2199	m_pcPredSearch->motionCompensation( rpcTempCU , m_ppcPredYuvTemp[uhDepth] );
2200	#endif
2201	if(rpcTempCU->getPartitionSize(0)==SIZE_2Nx2N)
2202	{
2203	bool bSignalflag[2] = {true, true};
2204	for(UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx ++ )
2205	{
2206	RefPicList eRefList = uiRefListIdx ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
2207	Int iRefIdx = rpcTempCU->getCUMvField(eRefList)->getRefIdx(0);
2208	if(iRefIdx < 0 \|\| rpcTempCU->getSlice()->getPOC() == rpcTempCU->getSlice()->getRefPOC(eRefList, iRefIdx))
2209	bSignalflag[uiRefListIdx] = false;
2210	}
2211	if(!bSignalflag[0]&& !bSignalflag[1])
2212	rpcTempCU->setARPWSubParts( 0 , 0 , uhDepth );
2213	}
2214	}
2215	else
2216	{
2217	bFirstTime = false;
2218	#endif
2219	#if AMP_MRG
2220	rpcTempCU->setMergeAMP (true);
2221	#if HHI_INTERVIEW_SKIP
2222	m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes, bUseMRG );
2223	#else
2224	m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], false, bUseMRG );
2225	#endif
2226	#else
2227	#if HHI_INTERVIEW_SKIP
2228	m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth], bSkipRes );
2229	#else
2230	m_pcPredSearch->predInterSearch ( rpcTempCU, m_ppcOrigYuv[uhDepth], m_ppcPredYuvTemp[uhDepth], m_ppcResiYuvTemp[uhDepth], m_ppcRecoYuvTemp[uhDepth] );
2231	#endif
2232	#endif
2233	#if QC_ARP_D0177
2234	if(rpcTempCU->getSlice()->getSPS()->getUseAdvRP())
2235	{
2236	m_ppcWeightedTempCU[uhDepth]->copyPartFrom( rpcTempCU , 0 , uhDepth );
2237	if(rpcTempCU->getSlice()->getSPS()->getUseAdvRP() && rpcTempCU->getPartitionSize(0)==SIZE_2Nx2N)
2238	{
2239	bool bSignalflag[2] = {true, true};
2240	for(UInt uiRefListIdx = 0; uiRefListIdx < 2; uiRefListIdx ++ )
2241	{
2242	RefPicList eRefList = uiRefListIdx ? REF_PIC_LIST_1 : REF_PIC_LIST_0;
2243	Int iRefIdx = rpcTempCU->getCUMvField(eRefList)->getRefIdx(0);
2244	if(iRefIdx < 0 \|\| rpcTempCU->getSlice()->getPOC() == rpcTempCU->getSlice()->getRefPOC(eRefList, iRefIdx))
2245	bSignalflag[uiRefListIdx] = false;
2246	}
2247	if(!bSignalflag[0]&& !bSignalflag[1])
2248	rpcTempCU->setARPWSubParts( 0 , 0 , uhDepth );
2249	}
2250	}
2251	}
2252	#endif
2253
2254	#if AMP_MRG
2255	if ( !rpcTempCU->getMergeAMP() )
2256	{
2257	#if QC_ARP_D0177
2258	if(rpcTempCU->getSlice()->getSPS()->getUseAdvRP())
2259	continue;
2260	else
2261	#endif
2262	return;
2263	}
2264	#endif
2265
2266	#if HHI_INTERVIEW_SKIP
2267	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2268	m_ppcOrigYuv[uhDepth],
2269	m_ppcPredYuvTemp[uhDepth],
2270	m_ppcResiYuvTemp[uhDepth],
2271	m_ppcResiYuvBest[uhDepth],
2272	m_ppcRecoYuvTemp[uhDepth],
2273	#if H3D_IVRP
2274	m_ppcResPredTmp [uhDepth],
2275	#endif
2276	bSkipRes );
2277	#else
2278	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2279	m_ppcOrigYuv[uhDepth],
2280	m_ppcPredYuvTemp[uhDepth],
2281	m_ppcResiYuvTemp[uhDepth],
2282	m_ppcResiYuvBest[uhDepth],
2283	m_ppcRecoYuvTemp[uhDepth],
2284	#if H3D_IVRP
2285	m_ppcResPredTmp [uhDepth],
2286	#endif
2287	false );
2288	#endif
2289	#if HHI_VSO
2290	if( m_pcRdCost->getUseLambdaScaleVSO() )
2291	{
2292	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2293	}
2294	else
2295	#endif
2296	{
2297	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2298	}
2299
2300	xCheckDQP( rpcTempCU );
2301	xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
2302	#if QC_ARP_D0177
2303	}
2304	#endif
2305	}
2306
2307	Void TEncCu::xCheckRDCostIntra( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, PartSize eSize )
2308	{
2309	UInt uiDepth = rpcTempCU->getDepth( 0 );
2310
2311	#if HHI_VSO
2312	if( m_pcRdCost->getUseRenModel() )
2313	{
2314	UInt uiWidth = m_ppcOrigYuv[uiDepth]->getWidth ();
2315	UInt uiHeight = m_ppcOrigYuv[uiDepth]->getHeight ();
2316	Pel* piSrc = m_ppcOrigYuv[uiDepth]->getLumaAddr();
2317	UInt uiSrcStride = m_ppcOrigYuv[uiDepth]->getStride ();
2318	m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2319	}
2320	#endif
2321
2322	rpcTempCU->setPartSizeSubParts( eSize, 0, uiDepth );
2323	rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
2324
2325	Bool bSeparateLumaChroma = true; // choose estimation mode
2326	Dist uiPreCalcDistC = 0;
2327	if( !bSeparateLumaChroma )
2328	{
2329	m_pcPredSearch->preestChromaPredMode( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth] );
2330	}
2331	m_pcPredSearch ->estIntraPredQT ( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC, bSeparateLumaChroma );
2332
2333	m_ppcRecoYuvTemp[uiDepth]->copyToPicLuma(rpcTempCU->getPic()->getPicYuvRec(), rpcTempCU->getAddr(), rpcTempCU->getZorderIdxInCU() );
2334
2335	#if RWTH_SDC_DLT_B0036
2336	if( !rpcTempCU->getSDCFlag( 0 ) )
2337	#endif
2338	m_pcPredSearch ->estIntraPredChromaQT( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth], uiPreCalcDistC );
2339
2340	m_pcEntropyCoder->resetBits();
2341	m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0, true );
2342	m_pcEntropyCoder->encodePredMode( rpcTempCU, 0, true );
2343	m_pcEntropyCoder->encodePartSize( rpcTempCU, 0, uiDepth, true );
2344	m_pcEntropyCoder->encodePredInfo( rpcTempCU, 0, true );
2345	m_pcEntropyCoder->encodeIPCMInfo(rpcTempCU, 0, true );
2346
2347	// Encode Coefficients
2348	Bool bCodeDQP = getdQPFlag();
2349	m_pcEntropyCoder->encodeCoeff( rpcTempCU, 0, uiDepth, rpcTempCU->getWidth (0), rpcTempCU->getHeight(0), bCodeDQP );
2350	setdQPFlag( bCodeDQP );
2351
2352	if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
2353
2354	rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
2355	if(m_pcEncCfg->getUseSBACRD())
2356	{
2357	rpcTempCU->getTotalBins() = ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
2358	}
2359	#if HHI_VSO
2360	if( m_pcRdCost->getUseLambdaScaleVSO())
2361	{
2362	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2363	}
2364	else
2365	#endif
2366	{
2367	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2368	}
2369
2370	xCheckDQP( rpcTempCU );
2371	xCheckBestMode(rpcBestCU, rpcTempCU, uiDepth);
2372	}
2373
2374	/** Check R-D costs for a CU with PCM mode.
2375	* \param rpcBestCU pointer to best mode CU data structure
2376	* \param rpcTempCU pointer to testing mode CU data structure
2377	* \returns Void
2378	*
2379	* \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.
2380	*/
2381	Void TEncCu::xCheckIntraPCM( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU )
2382	{
2383	UInt uiDepth = rpcTempCU->getDepth( 0 );
2384
2385	rpcTempCU->setIPCMFlag(0, true);
2386	rpcTempCU->setIPCMFlagSubParts (true, 0, rpcTempCU->getDepth(0));
2387	rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
2388	rpcTempCU->setPredModeSubParts( MODE_INTRA, 0, uiDepth );
2389
2390	m_pcPredSearch->IPCMSearch( rpcTempCU, m_ppcOrigYuv[uiDepth], m_ppcPredYuvTemp[uiDepth], m_ppcResiYuvTemp[uiDepth], m_ppcRecoYuvTemp[uiDepth]);
2391
2392	if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
2393
2394	m_pcEntropyCoder->resetBits();
2395	m_pcEntropyCoder->encodeSkipFlag ( rpcTempCU, 0, true );
2396	m_pcEntropyCoder->encodePredMode ( rpcTempCU, 0, true );
2397	m_pcEntropyCoder->encodePartSize ( rpcTempCU, 0, uiDepth, true );
2398	m_pcEntropyCoder->encodeIPCMInfo ( rpcTempCU, 0, true );
2399
2400	if( m_bUseSBACRD ) m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]);
2401
2402	rpcTempCU->getTotalBits() = m_pcEntropyCoder->getNumberOfWrittenBits();
2403	if(m_pcEncCfg->getUseSBACRD())
2404	{
2405	rpcTempCU->getTotalBins() = ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
2406	}
2407	#if HHI_VSO
2408	if ( m_pcRdCost->getUseVSO() )
2409	{
2410	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2411	}
2412	else
2413	#endif
2414	{
2415	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2416	}
2417
2418	xCheckDQP( rpcTempCU );
2419	xCheckBestMode( rpcBestCU, rpcTempCU, uiDepth );
2420	}
2421
2422	// check whether current try is the best
2423	Void TEncCu::xCheckBestMode( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU )
2424	{
2425	if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
2426	{
2427	TComYuv* pcYuv;
2428	UChar uhDepth = rpcBestCU->getDepth(0);
2429
2430	// Change Information data
2431	TComDataCU* pcCU = rpcBestCU;
2432	rpcBestCU = rpcTempCU;
2433	rpcTempCU = pcCU;
2434
2435	// Change Prediction data
2436	pcYuv = m_ppcPredYuvBest[uhDepth];
2437	m_ppcPredYuvBest[uhDepth] = m_ppcPredYuvTemp[uhDepth];
2438	m_ppcPredYuvTemp[uhDepth] = pcYuv;
2439
2440	// Change Reconstruction data
2441	pcYuv = m_ppcRecoYuvBest[uhDepth];
2442	m_ppcRecoYuvBest[uhDepth] = m_ppcRecoYuvTemp[uhDepth];
2443	m_ppcRecoYuvTemp[uhDepth] = pcYuv;
2444
2445	pcYuv = NULL;
2446	pcCU = NULL;
2447
2448	if( m_bUseSBACRD ) // store temp best CI for next CU coding
2449	m_pppcRDSbacCoder[uhDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uhDepth][CI_NEXT_BEST]);
2450	}
2451	}
2452
2453	/** check whether current try is the best with identifying the depth of current try
2454	* \param rpcBestCU
2455	* \param rpcTempCU
2456	* \returns Void
2457	*/
2458	Void TEncCu::xCheckBestMode( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UInt uiDepth )
2459	{
2460	if( rpcTempCU->getTotalCost() < rpcBestCU->getTotalCost() )
2461	{
2462	TComYuv* pcYuv;
2463	// Change Information data
2464	TComDataCU* pcCU = rpcBestCU;
2465	rpcBestCU = rpcTempCU;
2466	rpcTempCU = pcCU;
2467
2468	// Change Prediction data
2469	pcYuv = m_ppcPredYuvBest[uiDepth];
2470	m_ppcPredYuvBest[uiDepth] = m_ppcPredYuvTemp[uiDepth];
2471	m_ppcPredYuvTemp[uiDepth] = pcYuv;
2472
2473	// Change Reconstruction data
2474	pcYuv = m_ppcRecoYuvBest[uiDepth];
2475	m_ppcRecoYuvBest[uiDepth] = m_ppcRecoYuvTemp[uiDepth];
2476	m_ppcRecoYuvTemp[uiDepth] = pcYuv;
2477
2478	pcYuv = NULL;
2479	pcCU = NULL;
2480
2481	if( m_bUseSBACRD ) // store temp best CI for next CU coding
2482	m_pppcRDSbacCoder[uiDepth][CI_TEMP_BEST]->store(m_pppcRDSbacCoder[uiDepth][CI_NEXT_BEST]);
2483	}
2484	}
2485
2486	Void TEncCu::xCheckDQP( TComDataCU* pcCU )
2487	{
2488	UInt uiDepth = pcCU->getDepth( 0 );
2489
2490	if( pcCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uiDepth) >= pcCU->getSlice()->getPPS()->getMinCuDQPSize() )
2491	{
2492	if ( pcCU->getCbf( 0, TEXT_LUMA, 0 ) \|\| pcCU->getCbf( 0, TEXT_CHROMA_U, 0 ) \|\| pcCU->getCbf( 0, TEXT_CHROMA_V, 0 ) )
2493	{
2494	#if !RDO_WITHOUT_DQP_BITS
2495	m_pcEntropyCoder->resetBits();
2496	m_pcEntropyCoder->encodeQP( pcCU, 0, false );
2497	pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits(); // dQP bits
2498	if(m_pcEncCfg->getUseSBACRD())
2499	{
2500	pcCU->getTotalBins() += ((TEncBinCABAC )((TEncSbac)m_pcEntropyCoder->m_pcEntropyCoderIf)->getEncBinIf())->getBinsCoded();
2501	}
2502
2503	// GT: Change here??
2504	#if HHI_VSO
2505	if ( m_pcRdCost->getUseVSO() )
2506	{
2507	pcCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
2508	}
2509	else
2510	#endif
2511	{
2512	pcCU->getTotalCost() = m_pcRdCost->calcRdCost( pcCU->getTotalBits(), pcCU->getTotalDistortion() );
2513	}
2514	#endif
2515	}
2516	else
2517	{
2518	#if LOSSLESS_CODING
2519	if (( ( pcCU->getRefQP( 0 ) != pcCU->getQP( 0 )) ) && (pcCU->getSlice()->getSPS()->getUseLossless()))
2520	{
2521	pcCU->getTotalCost() = MAX_DOUBLE;
2522	}
2523	#endif
2524	pcCU->setQPSubParts( pcCU->getRefQP( 0 ), 0, uiDepth ); // set QP to default QP
2525	}
2526	}
2527	}
2528
2529	/** Check whether the last CU shares the same root as the current CU and is IPCM or not.
2530	* \param pcCU
2531	* \param uiCurAbsPartIdx
2532	* \returns Bool
2533	*/
2534	Bool TEncCu::checkLastCUSucIPCM( TComDataCU* pcCU, UInt uiCurAbsPartIdx )
2535	{
2536	Bool lastCUSucIPCMFlag = false;
2537
2538	UInt curDepth = pcCU->getDepth(uiCurAbsPartIdx);
2539	UInt shift = ((pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx())->getSPS()->getMaxCUDepth() - curDepth)<<1);
2540	UInt startPartUnitIdx = ((uiCurAbsPartIdx&(0x03<<shift))>>shift);
2541
2542	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2543	if( pcSlice->getEntropySliceCurStartCUAddr() == ( pcCU->getSCUAddr() + uiCurAbsPartIdx ) )
2544	{
2545	return false;
2546	}
2547
2548	if(curDepth > 0 && startPartUnitIdx > 0)
2549	{
2550	Int lastValidPartIdx = pcCU->getLastValidPartIdx((Int) uiCurAbsPartIdx );
2551
2552	if( lastValidPartIdx >= 0 )
2553	{
2554	if(( pcCU->getSliceStartCU( uiCurAbsPartIdx ) == pcCU->getSliceStartCU( (UInt) lastValidPartIdx ))
2555	&&
2556	( pcCU->getDepth( uiCurAbsPartIdx ) == pcCU->getDepth( (UInt) lastValidPartIdx ))
2557	&&
2558	pcCU->getIPCMFlag( (UInt) lastValidPartIdx ) )
2559	{
2560	lastCUSucIPCMFlag = true;
2561	}
2562	}
2563	}
2564
2565	return lastCUSucIPCMFlag;
2566	}
2567
2568	/** Count the number of successive IPCM CUs sharing the same root.
2569	* \param pcCU
2570	* \param uiCurAbsPartIdx
2571	* \returns Int
2572	*/
2573	Int TEncCu::countNumSucIPCM ( TComDataCU* pcCU, UInt uiCurAbsPartIdx )
2574	{
2575	Int numSucIPCM = 0;
2576	UInt CurDepth = pcCU->getDepth(uiCurAbsPartIdx);
2577
2578	if( pcCU->getIPCMFlag(uiCurAbsPartIdx) )
2579	{
2580	if(CurDepth == 0)
2581	{
2582	numSucIPCM = 1;
2583	}
2584	else
2585	{
2586	TComPic* pcPic = pcCU->getPic();
2587	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2588	UInt qNumParts = ( pcPic->getNumPartInCU() >> ((CurDepth-1)<<1) )>>2;
2589
2590	Bool continueFlag = true;
2591	UInt absPartIdx = uiCurAbsPartIdx;
2592	UInt shift = ((pcSlice->getSPS()->getMaxCUDepth() - CurDepth)<<1);
2593	UInt startPartUnitIdx = ((uiCurAbsPartIdx&(0x03<<shift))>>shift);
2594
2595	for ( UInt partUnitIdx = startPartUnitIdx; partUnitIdx < 4 && continueFlag; partUnitIdx++, absPartIdx+=qNumParts )
2596	{
2597	UInt lPelX = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[absPartIdx] ];
2598	UInt tPelY = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[absPartIdx] ];
2599	Bool inSliceFlag = ( pcCU->getSCUAddr()+absPartIdx+qNumParts>pcSlice->getEntropySliceCurStartCUAddr() ) && ( pcCU->getSCUAddr()+absPartIdx < pcSlice->getEntropySliceCurEndCUAddr());
2600
2601	if( inSliceFlag && ( lPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( tPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2602	{
2603	UInt uiDepth = pcCU->getDepth(absPartIdx);
2604
2605	if( ( CurDepth == uiDepth) && pcCU->getIPCMFlag( absPartIdx ) )
2606	{
2607	numSucIPCM++;
2608	}
2609	else
2610	{
2611	continueFlag = false;
2612	}
2613	}
2614	}
2615	}
2616	}
2617
2618	return numSucIPCM;
2619	}
2620
2621	Void TEncCu::xCopyAMVPInfo (AMVPInfo* pSrc, AMVPInfo* pDst)
2622	{
2623	pDst->iN = pSrc->iN;
2624	for (Int i = 0; i < pSrc->iN; i++)
2625	{
2626	pDst->m_acMvCand[i] = pSrc->m_acMvCand[i];
2627	}
2628	}
2629	Void TEncCu::xCopyYuv2Pic(TComPic* rpcPic, UInt uiCUAddr, UInt uiAbsPartIdx, UInt uiDepth, UInt uiSrcDepth, TComDataCU* pcCU, UInt uiLPelX, UInt uiTPelY )
2630	{
2631	UInt uiRPelX = uiLPelX + (g_uiMaxCUWidth>>uiDepth) - 1;
2632	UInt uiBPelY = uiTPelY + (g_uiMaxCUHeight>>uiDepth) - 1;
2633	TComSlice * pcSlice = pcCU->getPic()->getSlice(pcCU->getPic()->getCurrSliceIdx());
2634	Bool bSliceStart = pcSlice->getEntropySliceCurStartCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
2635	pcSlice->getEntropySliceCurStartCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
2636	Bool bSliceEnd = pcSlice->getEntropySliceCurEndCUAddr() > rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx &&
2637	pcSlice->getEntropySliceCurEndCUAddr() < rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) );
2638	if(!bSliceEnd && !bSliceStart && ( uiRPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiBPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2639	{
2640	UInt uiAbsPartIdxInRaster = g_auiZscanToRaster[uiAbsPartIdx];
2641	UInt uiSrcBlkWidth = rpcPic->getNumPartInWidth() >> (uiSrcDepth);
2642	UInt uiBlkWidth = rpcPic->getNumPartInWidth() >> (uiDepth);
2643	UInt uiPartIdxX = ( ( uiAbsPartIdxInRaster % rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
2644	UInt uiPartIdxY = ( ( uiAbsPartIdxInRaster / rpcPic->getNumPartInWidth() ) % uiSrcBlkWidth) / uiBlkWidth;
2645	UInt uiPartIdx = uiPartIdxY * ( uiSrcBlkWidth / uiBlkWidth ) + uiPartIdxX;
2646	m_ppcRecoYuvBest[uiSrcDepth]->copyToPicYuv( rpcPic->getPicYuvRec (), uiCUAddr, uiAbsPartIdx, uiDepth - uiSrcDepth, uiPartIdx);
2647	}
2648	else
2649	{
2650	UInt uiQNumParts = ( pcCU->getPic()->getNumPartInCU() >> (uiDepth<<1) )>>2;
2651
2652	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )
2653	{
2654	UInt uiSubCULPelX = uiLPelX + ( g_uiMaxCUWidth >>(uiDepth+1) )*( uiPartUnitIdx & 1 );
2655	UInt uiSubCUTPelY = uiTPelY + ( g_uiMaxCUHeight>>(uiDepth+1) )*( uiPartUnitIdx >> 1 );
2656
2657	Bool bInSlice = rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx+uiQNumParts > pcSlice->getEntropySliceCurStartCUAddr() &&
2658	rpcPic->getPicSym()->getInverseCUOrderMap(pcCU->getAddr())*pcCU->getPic()->getNumPartInCU()+uiAbsPartIdx < pcSlice->getEntropySliceCurEndCUAddr();
2659	if(bInSlice&&( uiSubCULPelX < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( uiSubCUTPelY < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2660	{
2661	xCopyYuv2Pic( rpcPic, uiCUAddr, uiAbsPartIdx, uiDepth+1, uiSrcDepth, pcCU, uiSubCULPelX, uiSubCUTPelY ); // Copy Yuv data to picture Yuv
2662	}
2663	}
2664	}
2665	}
2666
2667	Void TEncCu::xCopyYuv2Tmp( UInt uiPartUnitIdx, UInt uiNextDepth )
2668	{
2669	UInt uiCurrDepth = uiNextDepth - 1;
2670	m_ppcRecoYuvBest[uiNextDepth]->copyToPartYuv( m_ppcRecoYuvTemp[uiCurrDepth], uiPartUnitIdx );
2671	}
2672
2673	#if LOSSLESS_CODING
2674	/** Function for filling the PCM buffer of a CU using its original sample array
2675	* \param pcCU pointer to current CU
2676	* \param pcOrgYuv pointer to original sample array
2677	* \returns Void
2678	*/
2679	Void TEncCu::xFillPCMBuffer ( TComDataCU& pCU, TComYuv pOrgYuv )
2680	{
2681
2682	UInt width = pCU->getWidth(0);
2683	UInt height = pCU->getHeight(0);
2684
2685	Pel* pSrcY = pOrgYuv->getLumaAddr(0, width);
2686	Pel* pDstY = pCU->getPCMSampleY();
2687	UInt srcStride = pOrgYuv->getStride();
2688
2689	for(Int y = 0; y < height; y++ )
2690	{
2691	for(Int x = 0; x < width; x++ )
2692	{
2693	pDstY[x] = pSrcY[x];
2694	}
2695	pDstY += width;
2696	pSrcY += srcStride;
2697	}
2698
2699	Pel* pSrcCb = pOrgYuv->getCbAddr();
2700	Pel* pSrcCr = pOrgYuv->getCrAddr();;
2701
2702	Pel* pDstCb = pCU->getPCMSampleCb();
2703	Pel* pDstCr = pCU->getPCMSampleCr();;
2704
2705	UInt srcStrideC = pOrgYuv->getCStride();
2706	UInt heightC = height >> 1;
2707	UInt widthC = width >> 1;
2708
2709	for(Int y = 0; y < heightC; y++ )
2710	{
2711	for(Int x = 0; x < widthC; x++ )
2712	{
2713	pDstCb[x] = pSrcCb[x];
2714	pDstCr[x] = pSrcCr[x];
2715	}
2716	pDstCb += widthC;
2717	pDstCr += widthC;
2718	pSrcCb += srcStrideC;
2719	pSrcCr += srcStrideC;
2720	}
2721	}
2722	#endif
2723
2724	#if ADAPTIVE_QP_SELECTION
2725	/** Collect ARL statistics from one block
2726	*/
2727	Int TEncCu::xTuCollectARLStats(TCoeff* rpcCoeff, Int* rpcArlCoeff, Int NumCoeffInCU, Double* cSum, UInt* numSamples )
2728	{
2729	for( Int n = 0; n < NumCoeffInCU; n++ )
2730	{
2731	Int u = abs( rpcCoeff[ n ] );
2732	Int absc = rpcArlCoeff[ n ];
2733
2734	if( u != 0 )
2735	{
2736	if( u < LEVEL_RANGE )
2737	{
2738	cSum[ u ] += ( Double )absc;
2739	numSamples[ u ]++;
2740	}
2741	else
2742	{
2743	cSum[ LEVEL_RANGE ] += ( Double )absc - ( Double )( u << ARL_C_PRECISION );
2744	numSamples[ LEVEL_RANGE ]++;
2745	}
2746	}
2747	}
2748
2749	return 0;
2750	}
2751
2752	/** Collect ARL statistics from one LCU
2753	* \param pcCU
2754	*/
2755	Void TEncCu::xLcuCollectARLStats(TComDataCU* rpcCU )
2756	{
2757	Double cSum[ LEVEL_RANGE + 1 ]; //: the sum of DCT coefficients corresponding to datatype and quantization output
2758	UInt numSamples[ LEVEL_RANGE + 1 ]; //: the number of coefficients corresponding to datatype and quantization output
2759
2760	TCoeff* pCoeffY = rpcCU->getCoeffY();
2761	Int* pArlCoeffY = rpcCU->getArlCoeffY();
2762
2763	UInt uiMinCUWidth = g_uiMaxCUWidth >> g_uiMaxCUDepth;
2764	UInt uiMinNumCoeffInCU = 1 << uiMinCUWidth;
2765
2766	memset( cSum, 0, sizeof( Double )*(LEVEL_RANGE+1) );
2767	memset( numSamples, 0, sizeof( UInt )*(LEVEL_RANGE+1) );
2768
2769	// Collect stats to cSum[][] and numSamples[][]
2770	for(Int i = 0; i < rpcCU->getTotalNumPart(); i ++ )
2771	{
2772	UInt uiTrIdx = rpcCU->getTransformIdx(i);
2773
2774	if(rpcCU->getPredictionMode(i) == MODE_INTER)
2775	if( rpcCU->getCbf( i, TEXT_LUMA, uiTrIdx ) )
2776	{
2777	xTuCollectARLStats(pCoeffY, pArlCoeffY, uiMinNumCoeffInCU, cSum, numSamples);
2778	}//Note that only InterY is processed. QP rounding is based on InterY data only.
2779
2780	pCoeffY += uiMinNumCoeffInCU;
2781	pArlCoeffY += uiMinNumCoeffInCU;
2782	}
2783
2784	for(Int u=1; u<LEVEL_RANGE;u++)
2785	{
2786	m_pcTrQuant->getSliceSumC()[u] += cSum[ u ] ;
2787	m_pcTrQuant->getSliceNSamples()[u] += numSamples[ u ] ;
2788	}
2789	m_pcTrQuant->getSliceSumC()[LEVEL_RANGE] += cSum[ LEVEL_RANGE ] ;
2790	m_pcTrQuant->getSliceNSamples()[LEVEL_RANGE] += numSamples[ LEVEL_RANGE ] ;
2791	}
2792	#endif
2793
2794	#if HHI_MPI
2795	Void TEncCu::xCheckRDCostMvInheritance( TComDataCU& rpcBestCU, TComDataCU& rpcTempCU, UChar uhTextureModeDepth, Bool bSkipResidual, Bool bRecursiveCall )
2796	{
2797	assert( rpcTempCU->getSlice()->getIsDepth() );
2798	TComDataCU *pcTextureCU = rpcTempCU->getSlice()->getTexturePic()->getCU( rpcTempCU->getAddr() );
2799
2800	const UChar uhDepth = rpcTempCU->getDepth( 0 );
2801	const Int iQP = rpcTempCU->getQP( 0 );
2802	assert( bRecursiveCall == ( uhDepth != uhTextureModeDepth ) );
2803
2804	#if !MTK_UNCONSTRAINED_MVI_B0083
2805	if( uhDepth == uhTextureModeDepth )
2806	{
2807	for( UInt ui = 0; ui < rpcTempCU->getTotalNumPart(); ui++ )
2808	{
2809	if( pcTextureCU->isIntra( rpcTempCU->getZorderIdxInCU() + ui ) )
2810	{
2811	return;
2812	}
2813	}
2814	}
2815	#endif
2816
2817	#if HHI_VSO
2818	if( m_pcRdCost->getUseRenModel() && !bRecursiveCall)
2819	{
2820	UInt uiWidth = m_ppcOrigYuv[uhDepth]->getWidth ();
2821	UInt uiHeight = m_ppcOrigYuv[uhDepth]->getHeight ();
2822	Pel* piSrc = m_ppcOrigYuv[uhDepth]->getLumaAddr();
2823	UInt uiSrcStride = m_ppcOrigYuv[uhDepth]->getStride ();
2824	m_pcRdCost->setRenModelData( rpcTempCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2825	}
2826	#endif
2827
2828	Bool bSplit = uhDepth < pcTextureCU->getDepth( rpcTempCU->getZorderIdxInCU() );
2829	if( bSplit )
2830	{
2831	const UChar uhNextDepth = uhDepth+1;
2832	TComDataCU* pcSubBestPartCU = m_ppcBestCU[uhNextDepth];
2833	TComDataCU* pcSubTempPartCU = m_ppcTempCU[uhNextDepth];
2834
2835	for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++ )
2836	{
2837	pcSubBestPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP ); // clear sub partition datas or init.
2838	pcSubTempPartCU->initSubCU( rpcTempCU, uiPartUnitIdx, uhNextDepth, iQP ); // clear sub partition datas or init.
2839
2840	TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
2841	Bool bInSlice = pcSubBestPartCU->getSCUAddr()+pcSubBestPartCU->getTotalNumPart()>pcSlice->getEntropySliceCurStartCUAddr()&&pcSubBestPartCU->getSCUAddr()<pcSlice->getEntropySliceCurEndCUAddr();
2842	if(bInSlice && ( pcSubBestPartCU->getCUPelX() < pcSlice->getSPS()->getPicWidthInLumaSamples() ) && ( pcSubBestPartCU->getCUPelY() < pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
2843	{
2844	if( m_bUseSBACRD )
2845	{
2846	if ( 0 == uiPartUnitIdx) //initialize RD with previous depth buffer
2847	{
2848	m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhDepth][CI_CURR_BEST]);
2849	}
2850	else
2851	{
2852	m_pppcRDSbacCoder[uhNextDepth][CI_CURR_BEST]->load(m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]);
2853	}
2854	}
2855
2856	xCheckRDCostMvInheritance( pcSubBestPartCU, pcSubTempPartCU, uhTextureModeDepth, bSkipResidual, true );
2857
2858	rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth ); // Keep best part data to current temporary data.
2859	xCopyYuv2Tmp( pcSubBestPartCU->getTotalNumPart()*uiPartUnitIdx, uhNextDepth );
2860	}
2861	else if (bInSlice)
2862	{
2863	pcSubBestPartCU->copyToPic( uhNextDepth );
2864	rpcTempCU->copyPartFrom( pcSubBestPartCU, uiPartUnitIdx, uhNextDepth );
2865	}
2866	}
2867
2868	if( uhDepth == uhTextureModeDepth )
2869	{
2870	xAddMVISignallingBits( rpcTempCU );
2871	}
2872
2873	// DQP stuff
2874	{
2875	if( (g_uiMaxCUWidth>>uhDepth) == rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() && rpcTempCU->getSlice()->getPPS()->getUseDQP())
2876	{
2877	TComPic *pcPic = rpcTempCU->getPic();
2878	TComSlice *pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());
2879	Bool bHasRedisual = false;
2880	for( UInt uiBlkIdx = 0; uiBlkIdx < rpcTempCU->getTotalNumPart(); uiBlkIdx ++)
2881	{
2882	if( ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(uiBlkIdx+rpcTempCU->getZorderIdxInCU()) == rpcTempCU->getSlice()->getEntropySliceCurStartCUAddr() ) &&
2883	( rpcTempCU->getCbf( uiBlkIdx, TEXT_LUMA ) \|\| rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_U ) \|\| rpcTempCU->getCbf( uiBlkIdx, TEXT_CHROMA_V ) ) )
2884	{
2885	bHasRedisual = true;
2886	break;
2887	}
2888	}
2889
2890	UInt uiTargetPartIdx;
2891	if ( pcPic->getCU( rpcTempCU->getAddr() )->getEntropySliceStartCU(rpcTempCU->getZorderIdxInCU()) != pcSlice->getEntropySliceCurStartCUAddr() )
2892	{
2893	uiTargetPartIdx = pcSlice->getEntropySliceCurStartCUAddr() % pcPic->getNumPartInCU() - rpcTempCU->getZorderIdxInCU();
2894	}
2895	else
2896	{
2897	uiTargetPartIdx = 0;
2898	}
2899	if ( ! bHasRedisual )
2900	{
2901	#if LOSSLESS_CODING
2902	if (((rpcTempCU->getQP(uiTargetPartIdx) != rpcTempCU->getRefQP(uiTargetPartIdx)) ) && (rpcTempCU->getSlice()->getSPS()->getUseLossless()))
2903	{
2904	rpcTempCU->getTotalCost() = MAX_DOUBLE;
2905	}
2906	#endif
2907	rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( uiTargetPartIdx ), 0, uhDepth ); // set QP to default QP
2908	}
2909	}
2910	}
2911
2912	if( m_bUseSBACRD )
2913	{
2914	m_pppcRDSbacCoder[uhNextDepth][CI_NEXT_BEST]->store(m_pppcRDSbacCoder[uhDepth][CI_TEMP_BEST]);
2915	}
2916	}
2917	else
2918	{
2919	rpcTempCU->setTextureModeDepthSubParts( uhTextureModeDepth, 0, uhDepth );
2920	rpcTempCU->copyTextureMotionDataFrom( pcTextureCU, uhDepth, rpcTempCU->getZorderIdxInCU() );
2921	#if FIX_MPI_B0065
2922	UInt uiAbsPartIdx = rpcTempCU->getZorderIdxInCU();
2923	if( rpcTempCU->getDepth(0) > pcTextureCU->getDepth(uiAbsPartIdx))
2924	{
2925	rpcTempCU->setPartSizeSubParts( SIZE_NxN, 0, uhDepth );
2926	}
2927	else
2928	{
2929	PartSize partSize = pcTextureCU->getPartitionSize(uiAbsPartIdx);
2930	rpcTempCU->setPartSizeSubParts( partSize, 0, uhDepth );
2931	}
2932	#else
2933	rpcTempCU->setPartSizeSubParts( SIZE_NxN, 0, uhDepth );
2934	#endif
2935	for( UInt ui = 0; ui < rpcTempCU->getTotalNumPart(); ui++ )
2936	{
2937	assert( rpcTempCU->getInterDir( ui ) != 0 );
2938	assert( rpcTempCU->getPredictionMode( ui ) != MODE_NONE );
2939	#if MERL_VSP_C0152
2940	Int vspIdx = pcTextureCU->getVSPIndex( rpcTempCU->getZorderIdxInCU() + ui);
2941	rpcTempCU->setVSPIndex( ui , vspIdx);
2942	#endif
2943	}
2944
2945	rpcTempCU->setPredModeSubParts( bSkipResidual ? MODE_SKIP : MODE_INTER, 0, uhDepth );
2946	#if MERL_VSP_C0152
2947	m_pcPredSearch->motionCompensation( rpcTempCU, m_ppcPredYuvTemp[uhDepth], rpcTempCU->getZorderIdxInCU() );
2948	#else
2949	m_pcPredSearch->motionCompensation( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );
2950	#endif
2951	// get Original YUV data from picture
2952	m_ppcOrigYuv[uhDepth]->copyFromPicYuv( rpcBestCU->getPic()->getPicYuvOrg(), rpcBestCU->getAddr(), rpcBestCU->getZorderIdxInCU() );
2953	m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
2954	m_ppcOrigYuv[uhDepth],
2955	m_ppcPredYuvTemp[uhDepth],
2956	m_ppcResiYuvTemp[uhDepth],
2957	m_ppcResiYuvBest[uhDepth],
2958	m_ppcRecoYuvTemp[uhDepth],
2959	#if H3D_IVRP
2960	m_ppcResPredTmp [uhDepth],
2961	#endif
2962	bSkipResidual );
2963
2964	if( uhDepth == uhTextureModeDepth )
2965	{
2966	xAddMVISignallingBits( rpcTempCU );
2967	}
2968	xCheckDQP( rpcTempCU );
2969	}
2970
2971	#if HHI_VSO
2972	if( m_pcRdCost->getUseLambdaScaleVSO() )
2973	{
2974	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCostVSO( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2975	}
2976	else
2977	#endif
2978	{
2979	rpcTempCU->getTotalCost() = m_pcRdCost->calcRdCost( rpcTempCU->getTotalBits(), rpcTempCU->getTotalDistortion() );
2980	}
2981
2982	if( rpcTempCU->getPredictionMode( 0 ) == MODE_SKIP && uhDepth == uhTextureModeDepth )
2983	{
2984	if( rpcTempCU->getSlice()->getPPS()->getUseDQP() && (g_uiMaxCUWidth>>uhDepth) >= rpcTempCU->getSlice()->getPPS()->getMinCuDQPSize() )
2985	rpcTempCU->setQPSubParts( rpcTempCU->getRefQP( 0 ), 0, uhDepth ); // set QP to default QP
2986	}
2987	xCheckBestMode( rpcBestCU, rpcTempCU, uhDepth );
2988	rpcBestCU->copyToPic(uhDepth); // Copy Best data to Picture for next partition prediction.
2989
2990	#if HHI_VSO
2991	if( !bSplit && bRecursiveCall && m_pcRdCost->getUseRenModel() )
2992	{
2993	UInt uiWidth = m_ppcRecoYuvBest[uhDepth]->getWidth ( );
2994	UInt uiHeight = m_ppcRecoYuvBest[uhDepth]->getHeight ( );
2995	UInt uiSrcStride = m_ppcRecoYuvBest[uhDepth]->getStride ( );
2996	Pel* piSrc = m_ppcRecoYuvBest[uhDepth]->getLumaAddr( 0 );
2997	m_pcRdCost->setRenModelData( rpcBestCU, 0, piSrc, uiSrcStride, uiWidth, uiHeight );
2998	}
2999	#endif
3000	}
3001
3002	Void TEncCu::xAddMVISignallingBits( TComDataCU* pcCU )
3003	{
3004	const UChar uhDepth = pcCU->getTextureModeDepth( 0 );
3005	m_pcEntropyCoder->resetBits();
3006	xSaveDepthWidthHeight( pcCU );
3007	pcCU->setSizeSubParts( g_uiMaxCUWidth>>uhDepth, g_uiMaxCUHeight>>uhDepth, 0, uhDepth );
3008	pcCU->setDepthSubParts( uhDepth, 0 );
3009	pcCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth );
3010	pcCU->setMergeFlagSubParts( true, 0, 0, uhDepth );
3011	pcCU->setMergeIndexSubParts( HHI_MPI_MERGE_POS, 0, 0, uhDepth );
3012
3013	// check for skip mode
3014	{
3015	Bool bAllZero = true;
3016	for( UInt ui = 0; ui < pcCU->getTotalNumPart(); ui++ )
3017	{
3018	if( pcCU->getCbf( ui, TEXT_LUMA ) \|\| pcCU->getCbf( ui, TEXT_CHROMA_U ) \|\| pcCU->getCbf( ui, TEXT_CHROMA_V ) )
3019	{
3020	bAllZero = false;
3021	break;
3022	}
3023	}
3024	if( bAllZero )
3025	pcCU->setPredModeSubParts( MODE_SKIP, 0, uhDepth );
3026	}
3027
3028
3029	m_pcEntropyCoder->encodeSplitFlag( pcCU, 0, uhDepth, true );
3030	m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
3031
3032	if( pcCU->isSkipped( 0 ) )
3033	{
3034	m_pcEntropyCoder->encodeMergeIndex( pcCU, 0, 0, true );
3035	#if LGE_ILLUCOMP_B0045
3036	m_pcEntropyCoder->encodeICFlag( pcCU, 0, true
3037	#if LGE_ILLUCOMP_DEPTH_C0046
3038	, uhDepth
3039	#endif
3040	);
3041	#endif
3042	}
3043	else
3044	{
3045	m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
3046	m_pcEntropyCoder->encodePartSize( pcCU, 0, uhDepth, true );
3047	// prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
3048	m_pcEntropyCoder->encodePredInfo( pcCU, 0, true );
3049	#if LGE_ILLUCOMP_B0045
3050	m_pcEntropyCoder->encodeICFlag( pcCU, 0, true
3051	#if LGE_ILLUCOMP_DEPTH_C0046
3052	, uhDepth
3053	#endif
3054	);
3055	#endif
3056	}
3057	xRestoreDepthWidthHeight( pcCU );
3058
3059	pcCU->getTotalBits() += m_pcEntropyCoder->getNumberOfWrittenBits();
3060	}
3061
3062	Void TEncCu::xSaveDepthWidthHeight( TComDataCU* pcCU )
3063	{
3064	const Int iSizeInUchar = sizeof( UChar ) * pcCU->getTotalNumPart();
3065	memcpy( m_puhDepthSaved, pcCU->getDepth(), iSizeInUchar );
3066	memcpy( m_puhWidthSaved, pcCU->getWidth(), iSizeInUchar );
3067	memcpy( m_puhHeightSaved, pcCU->getHeight(), iSizeInUchar );
3068	}
3069
3070	Void TEncCu::xRestoreDepthWidthHeight( TComDataCU* pcCU )
3071	{
3072	const Int iSizeInUchar = sizeof( UChar ) * pcCU->getTotalNumPart();
3073	memcpy( pcCU->getDepth(), m_puhDepthSaved, iSizeInUchar );
3074	memcpy( pcCU->getWidth(), m_puhWidthSaved, iSizeInUchar );
3075	memcpy( pcCU->getHeight(), m_puhHeightSaved, iSizeInUchar );
3076	}
3077	#endif
3078
3079	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-6.2-dev2-Samsung/source/Lib/TLibEncoder/TEncCu.cpp @ 984

Download in other formats: