Context navigation

source: 3DVCSoftware/branches/HTM-4.0-Orange/source/Lib/TLibEncoder/TEncCu.cpp @ 114

Visit:

Last change on this file since 114 was 114, checked in by orange, 12 years ago
joelb.jung@… jct3v-a0044
Property svn:eol-style set to `native`
File size: 110.4 KB

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

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

Download in other formats: