Context navigation

TEncCu.cpp @ 213

Visit:

Last change on this file since 213 was 213, checked in by mitsubishi-htm, 12 years ago

A final release, as planned

Migrate to HTM 5.1
For VC project files, only VC9 file is updated
To be used as an additional anchor for CE1.h for 3rd JCTVC meeting at Geneva

Property svn:eol-style set to native

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

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-4.0.1-VSP-dev0/source/Lib/TLibEncoder/TEncCu.cpp @ 213

Download in other formats: