Context navigation

TEncCu.cpp @ 166

Visit:

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

Initial integration of VSP into HTM 4.0.1. The version used for JCT3V-B0102 at Shanghai meeting.

VC9 project/solution files updated. Other Visual C++ project/solution files are not updated.
Linux make file updated.

TODO

A second release is expected to include some bug fix and improvements on the interface, e.g. to move switches from macro definition to the configuration file.
A third release is expected after being integrated within HTM 5.x, which is to be used for CE1.h anchor.

Property svn:eol-style set to native

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

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 @ 166

Download in other formats: