Context navigation

source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibEncoder/TEncSearch.cpp @ 1175

Visit:

Last change on this file since 1175 was 1057, checked in by seregin, 10 years ago
revert back using layerIdx for m_ppcTEncTop, fix RefLayerId settings and related
Property svn:eol-style set to `native`
File size: 233.2 KB

Rev	Line
[313]	1	/* The copyright in this software is being made available under the BSD
	2	* License, included below. This software may be subject to other third party
	3	* and contributor rights, including patent rights, and no such rights are
[1029]	4	* granted under this license.
[313]	5	*
[595]	6	* Copyright (c) 2010-2014, ITU/ISO/IEC
[313]	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 TEncSearch.cpp
	35	\brief encoder search class
	36	*/
	37
	38	#include "TLibCommon/TypeDef.h"
	39	#include "TLibCommon/TComRom.h"
	40	#include "TLibCommon/TComMotionInfo.h"
	41	#include "TEncSearch.h"
[1029]	42	#include "TLibCommon/TComTU.h"
	43	#include "TLibCommon/Debug.h"
[313]	44	#include <math.h>
[1029]	45	#include <limits>
[313]	46
[1029]	47
[313]	48	//! \ingroup TLibEncoder
	49	//! \{
	50
	51	static const TComMv s_acMvRefineH[9] =
	52	{
	53	TComMv( 0, 0 ), // 0
	54	TComMv( 0, -1 ), // 1
	55	TComMv( 0, 1 ), // 2
	56	TComMv( -1, 0 ), // 3
	57	TComMv( 1, 0 ), // 4
	58	TComMv( -1, -1 ), // 5
	59	TComMv( 1, -1 ), // 6
	60	TComMv( -1, 1 ), // 7
	61	TComMv( 1, 1 ) // 8
	62	};
	63
	64	static const TComMv s_acMvRefineQ[9] =
	65	{
	66	TComMv( 0, 0 ), // 0
	67	TComMv( 0, -1 ), // 1
	68	TComMv( 0, 1 ), // 2
	69	TComMv( -1, -1 ), // 5
	70	TComMv( 1, -1 ), // 6
	71	TComMv( -1, 0 ), // 3
	72	TComMv( 1, 0 ), // 4
	73	TComMv( -1, 1 ), // 7
	74	TComMv( 1, 1 ) // 8
	75	};
	76
	77	static const UInt s_auiDFilter[9] =
	78	{
	79	0, 1, 0,
	80	2, 3, 2,
	81	0, 1, 0
	82	};
	83
[1029]	84	static Void offsetSubTUCBFs(TComTU &rTu, const ComponentID compID)
	85	{
	86	TComDataCU *pcCU = rTu.getCU();
	87	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	88	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU(compID);
	89	const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
	90
	91	//move the CBFs down a level and set the parent CBF
	92
	93	UChar subTUCBF[2];
	94	UChar combinedSubTUCBF = 0;
	95
	96	for (UInt subTU = 0; subTU < 2; subTU++)
	97	{
	98	const UInt subTUAbsPartIdx = uiAbsPartIdx + (subTU * partIdxesPerSubTU);
	99
	100	subTUCBF[subTU] = pcCU->getCbf(subTUAbsPartIdx, compID, uiTrDepth);
	101	combinedSubTUCBF \|= subTUCBF[subTU];
	102	}
	103
	104	for (UInt subTU = 0; subTU < 2; subTU++)
	105	{
	106	const UInt subTUAbsPartIdx = uiAbsPartIdx + (subTU * partIdxesPerSubTU);
	107	const UChar compositeCBF = (subTUCBF[subTU] << 1) \| combinedSubTUCBF;
	108
	109	pcCU->setCbfPartRange((compositeCBF << uiTrDepth), compID, subTUAbsPartIdx, partIdxesPerSubTU);
	110	}
	111	}
	112
	113
[313]	114	TEncSearch::TEncSearch()
	115	{
[1029]	116	for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
	117	{
	118	m_ppcQTTempCoeff[ch] = NULL;
	119	m_pcQTTempCoeff[ch] = NULL;
[313]	120	#if ADAPTIVE_QP_SELECTION
[1029]	121	m_ppcQTTempArlCoeff[ch] = NULL;
	122	m_pcQTTempArlCoeff[ch] = NULL;
[313]	123	#endif
[1029]	124	m_puhQTTempCbf[ch] = NULL;
	125	m_phQTTempCrossComponentPredictionAlpha[ch] = NULL;
	126	m_pSharedPredTransformSkip[ch] = NULL;
	127	m_pcQTTempTUCoeff[ch] = NULL;
[313]	128	#if ADAPTIVE_QP_SELECTION
[1029]	129	m_ppcQTTempTUArlCoeff[ch] = NULL;
[313]	130	#endif
[1029]	131	m_puhQTTempTransformSkipFlag[ch] = NULL;
	132	}
	133	m_puhQTTempTrIdx = NULL;
	134	m_pcQTTempTComYuv = NULL;
	135	m_pcEncCfg = NULL;
	136	m_pcEntropyCoder = NULL;
	137	m_pTempPel = NULL;
[313]	138	setWpScalingDistParam( NULL, -1, REF_PIC_LIST_X );
	139	}
	140
[1029]	141
	142
	143
[313]	144	TEncSearch::~TEncSearch()
	145	{
	146	if ( m_pTempPel )
	147	{
	148	delete [] m_pTempPel;
	149	m_pTempPel = NULL;
	150	}
[1029]	151
[313]	152	if ( m_pcEncCfg )
	153	{
	154	const UInt uiNumLayersAllocated = m_pcEncCfg->getQuadtreeTULog2MaxSize()-m_pcEncCfg->getQuadtreeTULog2MinSize()+1;
[1029]	155
	156	for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
[313]	157	{
[1029]	158	for (UInt layer = 0; layer < uiNumLayersAllocated; layer++)
	159	{
	160	delete[] m_ppcQTTempCoeff[ch][layer];
[313]	161	#if ADAPTIVE_QP_SELECTION
[1029]	162	delete[] m_ppcQTTempArlCoeff[ch][layer];
[313]	163	#endif
[1029]	164	}
	165	delete[] m_ppcQTTempCoeff[ch];
	166	delete[] m_pcQTTempCoeff[ch];
	167	delete[] m_puhQTTempCbf[ch];
	168	#if ADAPTIVE_QP_SELECTION
	169	delete[] m_ppcQTTempArlCoeff[ch];
	170	delete[] m_pcQTTempArlCoeff[ch];
	171	#endif
[313]	172	}
[1029]	173
	174	for( UInt layer = 0; layer < uiNumLayersAllocated; layer++ )
	175	{
	176	m_pcQTTempTComYuv[layer].destroy();
	177	}
[313]	178	}
[1029]	179
[313]	180	delete[] m_puhQTTempTrIdx;
	181	delete[] m_pcQTTempTComYuv;
[1029]	182
	183	for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
	184	{
	185	delete[] m_pSharedPredTransformSkip[ch];
	186	delete[] m_pcQTTempTUCoeff[ch];
[313]	187	#if ADAPTIVE_QP_SELECTION
[1029]	188	delete[] m_ppcQTTempTUArlCoeff[ch];
[313]	189	#endif
[1029]	190	delete[] m_phQTTempCrossComponentPredictionAlpha[ch];
	191	delete[] m_puhQTTempTransformSkipFlag[ch];
	192	}
[313]	193	m_pcQTTempTransformSkipTComYuv.destroy();
[1029]	194
[313]	195	m_tmpYuvPred.destroy();
	196	}
	197
[1029]	198
	199
	200
	201	Void TEncSearch::init(TEncCfg* pcEncCfg,
[313]	202	TComTrQuant* pcTrQuant,
	203	Int iSearchRange,
	204	Int bipredSearchRange,
	205	Int iFastSearch,
	206	Int iMaxDeltaQP,
	207	TEncEntropy* pcEntropyCoder,
	208	TComRdCost* pcRdCost,
	209	TEncSbac*** pppcRDSbacCoder,
	210	TEncSbac* pcRDGoOnSbacCoder
	211	)
	212	{
	213	m_pcEncCfg = pcEncCfg;
	214	m_pcTrQuant = pcTrQuant;
	215	m_iSearchRange = iSearchRange;
	216	m_bipredSearchRange = bipredSearchRange;
	217	m_iFastSearch = iFastSearch;
	218	m_iMaxDeltaQP = iMaxDeltaQP;
	219	m_pcEntropyCoder = pcEntropyCoder;
	220	m_pcRdCost = pcRdCost;
[1029]	221
[313]	222	m_pppcRDSbacCoder = pppcRDSbacCoder;
	223	m_pcRDGoOnSbacCoder = pcRDGoOnSbacCoder;
[1029]	224
	225	for (UInt iDir = 0; iDir < MAX_NUM_REF_LIST_ADAPT_SR; iDir++)
[313]	226	{
[1029]	227	for (UInt iRefIdx = 0; iRefIdx < MAX_IDX_ADAPT_SR; iRefIdx++)
[313]	228	{
	229	m_aaiAdaptSR[iDir][iRefIdx] = iSearchRange;
	230	}
	231	}
[1029]	232
[313]	233	m_puiDFilter = s_auiDFilter + 4;
[1029]	234
[313]	235	// initialize motion cost
	236	for( Int iNum = 0; iNum < AMVP_MAX_NUM_CANDS+1; iNum++)
	237	{
	238	for( Int iIdx = 0; iIdx < AMVP_MAX_NUM_CANDS; iIdx++)
	239	{
	240	if (iIdx < iNum)
	241	m_auiMVPIdxCost[iIdx][iNum] = xGetMvpIdxBits(iIdx, iNum);
	242	else
	243	m_auiMVPIdxCost[iIdx][iNum] = MAX_INT;
	244	}
	245	}
[1029]	246
	247	const ChromaFormat cform=pcEncCfg->getChromaFormatIdc();
	248	initTempBuff(cform);
	249
[313]	250	m_pTempPel = new Pel[g_uiMaxCUWidth*g_uiMaxCUHeight];
[1029]	251
[313]	252	const UInt uiNumLayersToAllocate = pcEncCfg->getQuadtreeTULog2MaxSize()-pcEncCfg->getQuadtreeTULog2MinSize()+1;
[1029]	253	const UInt uiNumPartitions = 1<<(g_uiMaxCUDepth<<1);
	254	for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
	255	{
	256	const UInt csx=::getComponentScaleX(ComponentID(ch), cform);
	257	const UInt csy=::getComponentScaleY(ComponentID(ch), cform);
	258	m_ppcQTTempCoeff[ch] = new TCoeff* [uiNumLayersToAllocate];
	259	m_pcQTTempCoeff[ch] = new TCoeff [(g_uiMaxCUWidth*g_uiMaxCUHeight)>>(csx+csy) ];
[313]	260	#if ADAPTIVE_QP_SELECTION
[1029]	261	m_ppcQTTempArlCoeff[ch] = new TCoeff*[uiNumLayersToAllocate];
	262	m_pcQTTempArlCoeff[ch] = new TCoeff [(g_uiMaxCUWidth*g_uiMaxCUHeight)>>(csx+csy) ];
[313]	263	#endif
[1029]	264	m_puhQTTempCbf[ch] = new UChar [uiNumPartitions];
	265
	266	for (UInt layer = 0; layer < uiNumLayersToAllocate; layer++)
	267	{
	268	m_ppcQTTempCoeff[ch][layer] = new TCoeff[(g_uiMaxCUWidth*g_uiMaxCUHeight)>>(csx+csy)];
	269	#if ADAPTIVE_QP_SELECTION
	270	m_ppcQTTempArlCoeff[ch][layer] = new TCoeff[(g_uiMaxCUWidth*g_uiMaxCUHeight)>>(csx+csy) ];
	271	#endif
	272	}
	273
	274	m_phQTTempCrossComponentPredictionAlpha[ch] = new Char [uiNumPartitions];
	275	m_pSharedPredTransformSkip[ch] = new Pel [MAX_CU_SIZE*MAX_CU_SIZE];
	276	m_pcQTTempTUCoeff[ch] = new TCoeff[MAX_CU_SIZE*MAX_CU_SIZE];
	277	#if ADAPTIVE_QP_SELECTION
	278	m_ppcQTTempTUArlCoeff[ch] = new TCoeff[MAX_CU_SIZE*MAX_CU_SIZE];
	279	#endif
	280	m_puhQTTempTransformSkipFlag[ch] = new UChar [uiNumPartitions];
	281	}
[313]	282	m_puhQTTempTrIdx = new UChar [uiNumPartitions];
	283	m_pcQTTempTComYuv = new TComYuv[uiNumLayersToAllocate];
	284	for( UInt ui = 0; ui < uiNumLayersToAllocate; ++ui )
	285	{
[1029]	286	m_pcQTTempTComYuv[ui].create( g_uiMaxCUWidth, g_uiMaxCUHeight, pcEncCfg->getChromaFormatIdc() );
[313]	287	}
[1029]	288	m_pcQTTempTransformSkipTComYuv.create( g_uiMaxCUWidth, g_uiMaxCUHeight, pcEncCfg->getChromaFormatIdc() );
	289	m_tmpYuvPred.create(MAX_CU_SIZE, MAX_CU_SIZE, pcEncCfg->getChromaFormatIdc());
[313]	290	}
	291
	292	#if FASTME_SMOOTHER_MV
	293	#define FIRSTSEARCHSTOP 1
	294	#else
	295	#define FIRSTSEARCHSTOP 0
	296	#endif
	297
	298	#define TZ_SEARCH_CONFIGURATION \
	299	const Int iRaster = 5; /* TZ soll von aussen ?ergeben werden */ \
	300	const Bool bTestOtherPredictedMV = 0; \
	301	const Bool bTestZeroVector = 1; \
	302	const Bool bTestZeroVectorStart = 0; \
	303	const Bool bTestZeroVectorStop = 0; \
	304	const Bool bFirstSearchDiamond = 1; /* 1 = xTZ8PointDiamondSearch 0 = xTZ8PointSquareSearch */ \
	305	const Bool bFirstSearchStop = FIRSTSEARCHSTOP; \
	306	const UInt uiFirstSearchRounds = 3; /* first search stop X rounds after best match (must be >=1) */ \
	307	const Bool bEnableRasterSearch = 1; \
	308	const Bool bAlwaysRasterSearch = 0; /* ===== 1: BETTER but factor 2 slower ===== */ \
	309	const Bool bRasterRefinementEnable = 0; /* enable either raster refinement or star refinement */ \
	310	const Bool bRasterRefinementDiamond = 0; /* 1 = xTZ8PointDiamondSearch 0 = xTZ8PointSquareSearch */ \
	311	const Bool bStarRefinementEnable = 1; /* enable either star refinement or raster refinement */ \
	312	const Bool bStarRefinementDiamond = 1; /* 1 = xTZ8PointDiamondSearch 0 = xTZ8PointSquareSearch */ \
	313	const Bool bStarRefinementStop = 0; \
	314	const UInt uiStarRefinementRounds = 2; /* star refinement stop X rounds after best match (must be >=1) */ \
	315
	316
[1029]	317	#define SEL_SEARCH_CONFIGURATION \
	318	const Bool bTestOtherPredictedMV = 1; \
	319	const Bool bTestZeroVector = 1; \
	320	const Bool bEnableRasterSearch = 1; \
	321	const Bool bAlwaysRasterSearch = 0; /* ===== 1: BETTER but factor 15x slower ===== */ \
	322	const Bool bStarRefinementEnable = 1; /* enable either star refinement or raster refinement */ \
	323	const Bool bStarRefinementDiamond = 1; /* 1 = xTZ8PointDiamondSearch 0 = xTZ8PointSquareSearch */ \
	324	const Bool bStarRefinementStop = 0; \
	325	const UInt uiStarRefinementRounds = 2; /* star refinement stop X rounds after best match (must be >=1) */ \
	326	const UInt uiSearchRange = m_iSearchRange; \
	327	const Int uiSearchRangeInitial = m_iSearchRange >> 2; \
	328	const Int uiSearchStep = 4; \
	329	const Int iMVDistThresh = 8; \
	330
	331
	332
[313]	333	__inline Void TEncSearch::xTZSearchHelp( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, const Int iSearchX, const Int iSearchY, const UChar ucPointNr, const UInt uiDistance )
	334	{
[1029]	335	Distortion uiSad = 0;
	336
[313]	337	Pel* piRefSrch;
[1029]	338
[313]	339	piRefSrch = rcStruct.piRefY + iSearchY * rcStruct.iYStride + iSearchX;
[1029]	340
[313]	341	//-- jclee for using the SAD function pointer
	342	m_pcRdCost->setDistParam( pcPatternKey, piRefSrch, rcStruct.iYStride, m_cDistParam );
[1029]	343
	344	if(m_pcEncCfg->getFastSearch() != SELECTIVE)
[313]	345	{
[1029]	346	// fast encoder decision: use subsampled SAD when rows > 8 for integer ME
	347	if ( m_pcEncCfg->getUseFastEnc() )
[313]	348	{
[1029]	349	if ( m_cDistParam.iRows > 8 )
	350	{
	351	m_cDistParam.iSubShift = 1;
	352	}
[313]	353	}
	354	}
	355
[1029]	356	setDistParamComp(COMPONENT_Y);
[313]	357
	358	// distortion
[1029]	359	m_cDistParam.bitDepth = g_bitDepth[CHANNEL_TYPE_LUMA];
	360	if(m_pcEncCfg->getFastSearch() == SELECTIVE)
[313]	361	{
[1029]	362	Int isubShift = 0;
	363	// motion cost
	364	UInt uiBitCost = m_pcRdCost->getCost( iSearchX, iSearchY );
	365
	366	if ( m_cDistParam.iRows > 32 )
	367	m_cDistParam.iSubShift = 4;
	368	else if ( m_cDistParam.iRows > 16 )
	369	m_cDistParam.iSubShift = 3;
	370	else if ( m_cDistParam.iRows > 8 )
	371	m_cDistParam.iSubShift = 2;
	372	else
	373	m_cDistParam.iSubShift = 1;
	374
	375	Distortion uiTempSad = m_cDistParam.DistFunc( &m_cDistParam );
	376	if((uiTempSad + uiBitCost) < rcStruct.uiBestSad)
	377	{
	378	uiSad += uiTempSad >> m_cDistParam.iSubShift;
	379	while(m_cDistParam.iSubShift > 0)
	380	{
	381	isubShift = m_cDistParam.iSubShift -1;
	382	m_cDistParam.pOrg = pcPatternKey->getROIY() + (pcPatternKey->getPatternLStride() << isubShift);
	383	m_cDistParam.pCur = piRefSrch + (rcStruct.iYStride << isubShift);
	384	uiTempSad = m_cDistParam.DistFunc( &m_cDistParam );
	385	uiSad += uiTempSad >> m_cDistParam.iSubShift;
	386	if(((uiSad << isubShift) + uiBitCost) > rcStruct.uiBestSad)
	387	break;
	388
	389	m_cDistParam.iSubShift--;
	390	}
	391
	392	if(m_cDistParam.iSubShift == 0)
	393	{
	394	uiSad += uiBitCost;
	395	if( uiSad < rcStruct.uiBestSad )
	396	{
	397	rcStruct.uiBestSad = uiSad;
	398	rcStruct.iBestX = iSearchX;
	399	rcStruct.iBestY = iSearchY;
	400	rcStruct.uiBestDistance = uiDistance;
	401	rcStruct.uiBestRound = 0;
	402	rcStruct.ucPointNr = ucPointNr;
	403	}
	404	}
	405	}
[313]	406	}
[1029]	407	else
	408	{
	409	uiSad = m_cDistParam.DistFunc( &m_cDistParam );
	410
	411	// motion cost
	412	uiSad += m_pcRdCost->getCost( iSearchX, iSearchY );
	413
	414	if( uiSad < rcStruct.uiBestSad )
	415	{
	416	rcStruct.uiBestSad = uiSad;
	417	rcStruct.iBestX = iSearchX;
	418	rcStruct.iBestY = iSearchY;
	419	rcStruct.uiBestDistance = uiDistance;
	420	rcStruct.uiBestRound = 0;
	421	rcStruct.ucPointNr = ucPointNr;
	422	}
	423	}
[313]	424	}
	425
[1029]	426
	427
	428
[313]	429	__inline Void TEncSearch::xTZ2PointSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB )
	430	{
	431	Int iSrchRngHorLeft = pcMvSrchRngLT->getHor();
	432	Int iSrchRngHorRight = pcMvSrchRngRB->getHor();
	433	Int iSrchRngVerTop = pcMvSrchRngLT->getVer();
	434	Int iSrchRngVerBottom = pcMvSrchRngRB->getVer();
[1029]	435
[313]	436	// 2 point search, // 1 2 3
	437	// check only the 2 untested points // 4 0 5
	438	// around the start point // 6 7 8
	439	Int iStartX = rcStruct.iBestX;
	440	Int iStartY = rcStruct.iBestY;
	441	switch( rcStruct.ucPointNr )
	442	{
	443	case 1:
	444	{
	445	if ( (iStartX - 1) >= iSrchRngHorLeft )
	446	{
	447	xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY, 0, 2 );
	448	}
	449	if ( (iStartY - 1) >= iSrchRngVerTop )
	450	{
	451	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY - 1, 0, 2 );
	452	}
	453	}
	454	break;
	455	case 2:
	456	{
	457	if ( (iStartY - 1) >= iSrchRngVerTop )
	458	{
	459	if ( (iStartX - 1) >= iSrchRngHorLeft )
	460	{
	461	xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY - 1, 0, 2 );
	462	}
	463	if ( (iStartX + 1) <= iSrchRngHorRight )
	464	{
	465	xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY - 1, 0, 2 );
	466	}
	467	}
	468	}
	469	break;
	470	case 3:
	471	{
	472	if ( (iStartY - 1) >= iSrchRngVerTop )
	473	{
	474	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY - 1, 0, 2 );
	475	}
	476	if ( (iStartX + 1) <= iSrchRngHorRight )
	477	{
	478	xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY, 0, 2 );
	479	}
	480	}
	481	break;
	482	case 4:
	483	{
	484	if ( (iStartX - 1) >= iSrchRngHorLeft )
	485	{
	486	if ( (iStartY + 1) <= iSrchRngVerBottom )
	487	{
	488	xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY + 1, 0, 2 );
	489	}
	490	if ( (iStartY - 1) >= iSrchRngVerTop )
	491	{
	492	xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY - 1, 0, 2 );
	493	}
	494	}
	495	}
	496	break;
	497	case 5:
	498	{
	499	if ( (iStartX + 1) <= iSrchRngHorRight )
	500	{
	501	if ( (iStartY - 1) >= iSrchRngVerTop )
	502	{
	503	xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY - 1, 0, 2 );
	504	}
	505	if ( (iStartY + 1) <= iSrchRngVerBottom )
	506	{
	507	xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY + 1, 0, 2 );
	508	}
	509	}
	510	}
	511	break;
	512	case 6:
	513	{
	514	if ( (iStartX - 1) >= iSrchRngHorLeft )
	515	{
	516	xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY , 0, 2 );
	517	}
	518	if ( (iStartY + 1) <= iSrchRngVerBottom )
	519	{
	520	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY + 1, 0, 2 );
	521	}
	522	}
	523	break;
	524	case 7:
	525	{
	526	if ( (iStartY + 1) <= iSrchRngVerBottom )
	527	{
	528	if ( (iStartX - 1) >= iSrchRngHorLeft )
	529	{
	530	xTZSearchHelp( pcPatternKey, rcStruct, iStartX - 1, iStartY + 1, 0, 2 );
	531	}
	532	if ( (iStartX + 1) <= iSrchRngHorRight )
	533	{
	534	xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY + 1, 0, 2 );
	535	}
	536	}
	537	}
	538	break;
	539	case 8:
	540	{
	541	if ( (iStartX + 1) <= iSrchRngHorRight )
	542	{
	543	xTZSearchHelp( pcPatternKey, rcStruct, iStartX + 1, iStartY, 0, 2 );
	544	}
	545	if ( (iStartY + 1) <= iSrchRngVerBottom )
	546	{
	547	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iStartY + 1, 0, 2 );
	548	}
	549	}
	550	break;
	551	default:
	552	{
	553	assert( false );
	554	}
	555	break;
	556	} // switch( rcStruct.ucPointNr )
	557	}
	558
[1029]	559
	560
	561
[313]	562	__inline Void TEncSearch::xTZ8PointSquareSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
	563	{
	564	Int iSrchRngHorLeft = pcMvSrchRngLT->getHor();
	565	Int iSrchRngHorRight = pcMvSrchRngRB->getHor();
	566	Int iSrchRngVerTop = pcMvSrchRngLT->getVer();
	567	Int iSrchRngVerBottom = pcMvSrchRngRB->getVer();
[1029]	568
[313]	569	// 8 point search, // 1 2 3
	570	// search around the start point // 4 0 5
	571	// with the required distance // 6 7 8
	572	assert( iDist != 0 );
	573	const Int iTop = iStartY - iDist;
	574	const Int iBottom = iStartY + iDist;
	575	const Int iLeft = iStartX - iDist;
	576	const Int iRight = iStartX + iDist;
	577	rcStruct.uiBestRound += 1;
[1029]	578
[313]	579	if ( iTop >= iSrchRngVerTop ) // check top
	580	{
	581	if ( iLeft >= iSrchRngHorLeft ) // check top left
	582	{
	583	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iTop, 1, iDist );
	584	}
	585	// top middle
	586	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
[1029]	587
[313]	588	if ( iRight <= iSrchRngHorRight ) // check top right
	589	{
	590	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iTop, 3, iDist );
	591	}
	592	} // check top
	593	if ( iLeft >= iSrchRngHorLeft ) // check middle left
	594	{
	595	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
	596	}
	597	if ( iRight <= iSrchRngHorRight ) // check middle right
	598	{
	599	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
	600	}
	601	if ( iBottom <= iSrchRngVerBottom ) // check bottom
	602	{
	603	if ( iLeft >= iSrchRngHorLeft ) // check bottom left
	604	{
	605	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iBottom, 6, iDist );
	606	}
	607	// check bottom middle
	608	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
[1029]	609
[313]	610	if ( iRight <= iSrchRngHorRight ) // check bottom right
	611	{
	612	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iBottom, 8, iDist );
	613	}
	614	} // check bottom
	615	}
	616
[1029]	617
	618
	619
[313]	620	__inline Void TEncSearch::xTZ8PointDiamondSearch( TComPattern* pcPatternKey, IntTZSearchStruct& rcStruct, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, const Int iStartX, const Int iStartY, const Int iDist )
	621	{
	622	Int iSrchRngHorLeft = pcMvSrchRngLT->getHor();
	623	Int iSrchRngHorRight = pcMvSrchRngRB->getHor();
	624	Int iSrchRngVerTop = pcMvSrchRngLT->getVer();
	625	Int iSrchRngVerBottom = pcMvSrchRngRB->getVer();
[1029]	626
[313]	627	// 8 point search, // 1 2 3
	628	// search around the start point // 4 0 5
	629	// with the required distance // 6 7 8
	630	assert ( iDist != 0 );
	631	const Int iTop = iStartY - iDist;
	632	const Int iBottom = iStartY + iDist;
	633	const Int iLeft = iStartX - iDist;
	634	const Int iRight = iStartX + iDist;
	635	rcStruct.uiBestRound += 1;
[1029]	636
[313]	637	if ( iDist == 1 ) // iDist == 1
	638	{
	639	if ( iTop >= iSrchRngVerTop ) // check top
	640	{
	641	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
	642	}
	643	if ( iLeft >= iSrchRngHorLeft ) // check middle left
	644	{
	645	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
	646	}
	647	if ( iRight <= iSrchRngHorRight ) // check middle right
	648	{
	649	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
	650	}
	651	if ( iBottom <= iSrchRngVerBottom ) // check bottom
	652	{
	653	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
	654	}
	655	}
	656	else // if (iDist != 1)
	657	{
	658	if ( iDist <= 8 )
	659	{
	660	const Int iTop_2 = iStartY - (iDist>>1);
	661	const Int iBottom_2 = iStartY + (iDist>>1);
	662	const Int iLeft_2 = iStartX - (iDist>>1);
	663	const Int iRight_2 = iStartX + (iDist>>1);
[1029]	664
[313]	665	if ( iTop >= iSrchRngVerTop && iLeft >= iSrchRngHorLeft &&
	666	iRight <= iSrchRngHorRight && iBottom <= iSrchRngVerBottom ) // check border
	667	{
	668	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
	669	xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2, iTop_2, 1, iDist>>1 );
	670	xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iTop_2, 3, iDist>>1 );
	671	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
	672	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
	673	xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2, iBottom_2, 6, iDist>>1 );
	674	xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iBottom_2, 8, iDist>>1 );
	675	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
	676	}
	677	else // check border
	678	{
	679	if ( iTop >= iSrchRngVerTop ) // check top
	680	{
	681	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 2, iDist );
	682	}
	683	if ( iTop_2 >= iSrchRngVerTop ) // check half top
	684	{
	685	if ( iLeft_2 >= iSrchRngHorLeft ) // check half left
	686	{
	687	xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2, iTop_2, 1, (iDist>>1) );
	688	}
	689	if ( iRight_2 <= iSrchRngHorRight ) // check half right
	690	{
	691	xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iTop_2, 3, (iDist>>1) );
	692	}
	693	} // check half top
	694	if ( iLeft >= iSrchRngHorLeft ) // check left
	695	{
	696	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 4, iDist );
	697	}
	698	if ( iRight <= iSrchRngHorRight ) // check right
	699	{
	700	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 5, iDist );
	701	}
	702	if ( iBottom_2 <= iSrchRngVerBottom ) // check half bottom
	703	{
	704	if ( iLeft_2 >= iSrchRngHorLeft ) // check half left
	705	{
	706	xTZSearchHelp( pcPatternKey, rcStruct, iLeft_2, iBottom_2, 6, (iDist>>1) );
	707	}
	708	if ( iRight_2 <= iSrchRngHorRight ) // check half right
	709	{
	710	xTZSearchHelp( pcPatternKey, rcStruct, iRight_2, iBottom_2, 8, (iDist>>1) );
	711	}
	712	} // check half bottom
	713	if ( iBottom <= iSrchRngVerBottom ) // check bottom
	714	{
	715	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 7, iDist );
	716	}
	717	} // check border
	718	}
	719	else // iDist > 8
	720	{
	721	if ( iTop >= iSrchRngVerTop && iLeft >= iSrchRngHorLeft &&
	722	iRight <= iSrchRngHorRight && iBottom <= iSrchRngVerBottom ) // check border
	723	{
	724	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 0, iDist );
	725	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 0, iDist );
	726	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 0, iDist );
	727	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 0, iDist );
	728	for ( Int index = 1; index < 4; index++ )
	729	{
	730	Int iPosYT = iTop + ((iDist>>2) * index);
	731	Int iPosYB = iBottom - ((iDist>>2) * index);
	732	Int iPosXL = iStartX - ((iDist>>2) * index);
	733	Int iPosXR = iStartX + ((iDist>>2) * index);
	734	xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYT, 0, iDist );
	735	xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYT, 0, iDist );
	736	xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYB, 0, iDist );
	737	xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYB, 0, iDist );
	738	}
	739	}
	740	else // check border
	741	{
	742	if ( iTop >= iSrchRngVerTop ) // check top
	743	{
	744	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iTop, 0, iDist );
	745	}
	746	if ( iLeft >= iSrchRngHorLeft ) // check left
	747	{
	748	xTZSearchHelp( pcPatternKey, rcStruct, iLeft, iStartY, 0, iDist );
	749	}
	750	if ( iRight <= iSrchRngHorRight ) // check right
	751	{
	752	xTZSearchHelp( pcPatternKey, rcStruct, iRight, iStartY, 0, iDist );
	753	}
	754	if ( iBottom <= iSrchRngVerBottom ) // check bottom
	755	{
	756	xTZSearchHelp( pcPatternKey, rcStruct, iStartX, iBottom, 0, iDist );
	757	}
	758	for ( Int index = 1; index < 4; index++ )
	759	{
	760	Int iPosYT = iTop + ((iDist>>2) * index);
	761	Int iPosYB = iBottom - ((iDist>>2) * index);
	762	Int iPosXL = iStartX - ((iDist>>2) * index);
	763	Int iPosXR = iStartX + ((iDist>>2) * index);
[1029]	764
[313]	765	if ( iPosYT >= iSrchRngVerTop ) // check top
	766	{
	767	if ( iPosXL >= iSrchRngHorLeft ) // check left
	768	{
	769	xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYT, 0, iDist );
	770	}
	771	if ( iPosXR <= iSrchRngHorRight ) // check right
	772	{
	773	xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYT, 0, iDist );
	774	}
	775	} // check top
	776	if ( iPosYB <= iSrchRngVerBottom ) // check bottom
	777	{
	778	if ( iPosXL >= iSrchRngHorLeft ) // check left
	779	{
	780	xTZSearchHelp( pcPatternKey, rcStruct, iPosXL, iPosYB, 0, iDist );
	781	}
	782	if ( iPosXR <= iSrchRngHorRight ) // check right
	783	{
	784	xTZSearchHelp( pcPatternKey, rcStruct, iPosXR, iPosYB, 0, iDist );
	785	}
	786	} // check bottom
	787	} // for ...
	788	} // check border
	789	} // iDist <= 8
	790	} // iDist == 1
	791	}
	792
[1029]	793
	794
	795
	796
[313]	797	//<--
	798
[1029]	799	Distortion TEncSearch::xPatternRefinement( TComPattern* pcPatternKey,
	800	TComMv baseRefMv,
	801	Int iFrac, TComMv& rcMvFrac,
	802	Bool bAllowUseOfHadamard
	803	)
[313]	804	{
[1029]	805	Distortion uiDist;
	806	Distortion uiDistBest = std::numeric_limits<Distortion>::max();
	807	UInt uiDirecBest = 0;
	808
[313]	809	Pel* piRefPos;
[1029]	810	Int iRefStride = m_filteredBlock[0][0].getStride(COMPONENT_Y);
	811
	812	m_pcRdCost->setDistParam( pcPatternKey, m_filteredBlock[0][0].getAddr(COMPONENT_Y), iRefStride, 1, m_cDistParam, m_pcEncCfg->getUseHADME() && bAllowUseOfHadamard );
	813
[313]	814	const TComMv* pcMvRefine = (iFrac == 2 ? s_acMvRefineH : s_acMvRefineQ);
[1029]	815
[313]	816	for (UInt i = 0; i < 9; i++)
	817	{
	818	TComMv cMvTest = pcMvRefine[i];
	819	cMvTest += baseRefMv;
[1029]	820
[313]	821	Int horVal = cMvTest.getHor() * iFrac;
	822	Int verVal = cMvTest.getVer() * iFrac;
[1029]	823	piRefPos = m_filteredBlock[ verVal & 3 ][ horVal & 3 ].getAddr(COMPONENT_Y);
[313]	824	if ( horVal == 2 && ( verVal & 1 ) == 0 )
[540]	825	{
[313]	826	piRefPos += 1;
[540]	827	}
[313]	828	if ( ( horVal & 1 ) == 0 && verVal == 2 )
[540]	829	{
[313]	830	piRefPos += iRefStride;
[540]	831	}
[313]	832	cMvTest = pcMvRefine[i];
	833	cMvTest += rcMvFrac;
	834
[1029]	835	setDistParamComp(COMPONENT_Y);
[313]	836
	837	m_cDistParam.pCur = piRefPos;
[1029]	838	m_cDistParam.bitDepth = g_bitDepth[CHANNEL_TYPE_LUMA];
[313]	839	uiDist = m_cDistParam.DistFunc( &m_cDistParam );
	840	uiDist += m_pcRdCost->getCost( cMvTest.getHor(), cMvTest.getVer() );
[1029]	841
[313]	842	if ( uiDist < uiDistBest )
	843	{
	844	uiDistBest = uiDist;
	845	uiDirecBest = i;
	846	}
	847	}
[1029]	848
[313]	849	rcMvFrac = pcMvRefine[uiDirecBest];
[1029]	850
[313]	851	return uiDistBest;
	852	}
	853
[1029]	854
	855
[313]	856	Void
[1029]	857	TEncSearch::xEncSubdivCbfQT(TComTU &rTu,
[313]	858	Bool bLuma,
	859	Bool bChroma )
	860	{
[1029]	861	TComDataCU* pcCU=rTu.getCU();
	862	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	863	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	864	const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	865	const UInt uiSubdiv = ( uiTrMode > uiTrDepth ? 1 : 0 );
	866	const UInt uiLog2LumaTrafoSize = rTu.GetLog2LumaTrSize();
[313]	867
[1029]	868	if( pcCU->isIntra(0) && pcCU->getPartitionSize(0) == SIZE_NxN && uiTrDepth == 0 )
[313]	869	{
[540]	870	assert( uiSubdiv );
	871	}
[1029]	872	else if( uiLog2LumaTrafoSize > pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() )
[540]	873	{
	874	assert( uiSubdiv );
	875	}
[1029]	876	else if( uiLog2LumaTrafoSize == pcCU->getSlice()->getSPS()->getQuadtreeTULog2MinSize() )
[540]	877	{
	878	assert( !uiSubdiv );
	879	}
[1029]	880	else if( uiLog2LumaTrafoSize == pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
[540]	881	{
	882	assert( !uiSubdiv );
	883	}
	884	else
	885	{
[1029]	886	assert( uiLog2LumaTrafoSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
[540]	887	if( bLuma )
[313]	888	{
[1029]	889	m_pcEntropyCoder->encodeTransformSubdivFlag( uiSubdiv, 5 - uiLog2LumaTrafoSize );
[313]	890	}
	891	}
[1029]	892
[313]	893	if ( bChroma )
	894	{
[1029]	895	const UInt numberValidComponents = getNumberValidComponents(rTu.GetChromaFormat());
	896	for (UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
[313]	897	{
[1029]	898	const ComponentID compID=ComponentID(ch);
	899	if( rTu.ProcessingAllQuadrants(compID) && (uiTrDepth==0 \|\| pcCU->getCbf( uiAbsPartIdx, compID, uiTrDepth-1 ) ))
	900	m_pcEntropyCoder->encodeQtCbf(rTu, compID, (uiSubdiv == 0));
[313]	901	}
	902	}
	903
	904	if( uiSubdiv )
	905	{
[1029]	906	TComTURecurse tuRecurse(rTu, false);
	907	do
[313]	908	{
[1029]	909	xEncSubdivCbfQT( tuRecurse, bLuma, bChroma );
	910	} while (tuRecurse.nextSection(rTu));
[313]	911	}
[1029]	912	else
[313]	913	{
[1029]	914	//===== Cbfs =====
	915	if( bLuma )
	916	{
	917	m_pcEntropyCoder->encodeQtCbf( rTu, COMPONENT_Y, true );
	918	}
[313]	919	}
	920	}
	921
[1029]	922
	923
	924
[313]	925	Void
[1029]	926	TEncSearch::xEncCoeffQT(TComTU &rTu,
	927	const ComponentID component,
[313]	928	Bool bRealCoeff )
	929	{
[1029]	930	TComDataCU* pcCU=rTu.getCU();
	931	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	932	const UInt uiTrDepth=rTu.GetTransformDepthRel();
	933
	934	const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	935	const UInt uiSubdiv = ( uiTrMode > uiTrDepth ? 1 : 0 );
	936
[313]	937	if( uiSubdiv )
	938	{
[1029]	939	TComTURecurse tuRecurseChild(rTu, false);
	940	do
	941	{
	942	xEncCoeffQT( tuRecurseChild, component, bRealCoeff );
	943	} while (tuRecurseChild.nextSection(rTu) );
[313]	944	}
[1029]	945	else if (rTu.ProcessComponentSection(component))
[313]	946	{
[1029]	947	//===== coefficients =====
	948	const UInt uiLog2TrafoSize = rTu.GetLog2LumaTrSize();
	949	UInt uiCoeffOffset = rTu.getCoefficientOffset(component);
	950	UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrafoSize;
	951	TCoeff* pcCoeff = bRealCoeff ? pcCU->getCoeff(component) : m_ppcQTTempCoeff[component][uiQTLayer];
	952
	953	if (isChroma(component) && (pcCU->getCbf( rTu.GetAbsPartIdxTU(), COMPONENT_Y, uiTrMode ) != 0) && pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction() )
[313]	954	{
[1029]	955	m_pcEntropyCoder->encodeCrossComponentPrediction( rTu, component );
[313]	956	}
[1029]	957
	958	m_pcEntropyCoder->encodeCoeffNxN( rTu, pcCoeff+uiCoeffOffset, component );
[313]	959	}
	960	}
	961
	962
[1029]	963
	964
[313]	965	Void
	966	TEncSearch::xEncIntraHeader( TComDataCU* pcCU,
	967	UInt uiTrDepth,
	968	UInt uiAbsPartIdx,
	969	Bool bLuma,
	970	Bool bChroma )
	971	{
	972	if( bLuma )
	973	{
	974	// CU header
	975	if( uiAbsPartIdx == 0 )
	976	{
	977	if( !pcCU->getSlice()->isIntra() )
	978	{
	979	if (pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	980	{
	981	m_pcEntropyCoder->encodeCUTransquantBypassFlag( pcCU, 0, true );
	982	}
	983	m_pcEntropyCoder->encodeSkipFlag( pcCU, 0, true );
	984	m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
	985	}
	986	m_pcEntropyCoder ->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
	987
	988	if (pcCU->isIntra(0) && pcCU->getPartitionSize(0) == SIZE_2Nx2N )
	989	{
	990	m_pcEntropyCoder->encodeIPCMInfo( pcCU, 0, true );
	991
	992	if ( pcCU->getIPCMFlag (0))
	993	{
	994	return;
	995	}
	996	}
	997	}
	998	// luma prediction mode
	999	if( pcCU->getPartitionSize(0) == SIZE_2Nx2N )
	1000	{
[1029]	1001	if (uiAbsPartIdx==0)
[313]	1002	{
	1003	m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, 0 );
	1004	}
	1005	}
	1006	else
	1007	{
	1008	UInt uiQNumParts = pcCU->getTotalNumPart() >> 2;
[1029]	1009	if (uiTrDepth>0 && (uiAbsPartIdx%uiQNumParts)==0) m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiAbsPartIdx );
[313]	1010	}
	1011	}
[1029]	1012
[313]	1013	if( bChroma )
	1014	{
[1029]	1015	if( pcCU->getPartitionSize(0) == SIZE_2Nx2N \|\| !enable4ChromaPUsInIntraNxNCU(pcCU->getPic()->getChromaFormat()))
[313]	1016	{
[1029]	1017	if(uiAbsPartIdx==0)
	1018	{
	1019	m_pcEntropyCoder->encodeIntraDirModeChroma ( pcCU, uiAbsPartIdx );
	1020	}
[313]	1021	}
[1029]	1022	else
	1023	{
	1024	UInt uiQNumParts = pcCU->getTotalNumPart() >> 2;
	1025	assert(uiTrDepth>0);
	1026	if ((uiAbsPartIdx%uiQNumParts)==0)
	1027	{
	1028	m_pcEntropyCoder->encodeIntraDirModeChroma ( pcCU, uiAbsPartIdx );
	1029	}
	1030	}
[313]	1031	}
	1032	}
	1033
	1034
[1029]	1035
	1036
[313]	1037	UInt
[1029]	1038	TEncSearch::xGetIntraBitsQT(TComTU &rTu,
[313]	1039	Bool bLuma,
	1040	Bool bChroma,
	1041	Bool bRealCoeff /* just for test */ )
	1042	{
[1029]	1043	TComDataCU* pcCU=rTu.getCU();
	1044	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	1045	const UInt uiTrDepth=rTu.GetTransformDepthRel();
[313]	1046	m_pcEntropyCoder->resetBits();
	1047	xEncIntraHeader ( pcCU, uiTrDepth, uiAbsPartIdx, bLuma, bChroma );
[1029]	1048	xEncSubdivCbfQT ( rTu, bLuma, bChroma );
	1049
[313]	1050	if( bLuma )
	1051	{
[1029]	1052	xEncCoeffQT ( rTu, COMPONENT_Y, bRealCoeff );
[313]	1053	}
	1054	if( bChroma )
	1055	{
[1029]	1056	xEncCoeffQT ( rTu, COMPONENT_Cb, bRealCoeff );
	1057	xEncCoeffQT ( rTu, COMPONENT_Cr, bRealCoeff );
[313]	1058	}
	1059	UInt uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
[1029]	1060
[313]	1061	return uiBits;
	1062	}
	1063
[1029]	1064	UInt TEncSearch::xGetIntraBitsQTChroma(TComTU &rTu,
	1065	ComponentID compID,
	1066	Bool bRealCoeff /* just for test */ )
[313]	1067	{
	1068	m_pcEntropyCoder->resetBits();
[1029]	1069	xEncCoeffQT ( rTu, compID, bRealCoeff );
[313]	1070	UInt uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	1071	return uiBits;
	1072	}
	1073
[1029]	1074	Void TEncSearch::xIntraCodingTUBlock( TComYuv* pcOrgYuv,
	1075	TComYuv* pcPredYuv,
	1076	TComYuv* pcResiYuv,
	1077	Pel resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
	1078	const Bool checkCrossCPrediction,
	1079	Distortion& ruiDist,
	1080	const ComponentID compID,
	1081	TComTU& rTu
	1082	DEBUG_STRING_FN_DECLARE(sDebug)
	1083	,Int default0Save1Load2
	1084	)
[313]	1085	{
[1029]	1086	if (!rTu.ProcessComponentSection(compID)) return;
	1087	const Bool bIsLuma = isLuma(compID);
	1088	const TComRectangle &rect= rTu.getRect(compID);
	1089	TComDataCU *pcCU=rTu.getCU();
	1090	const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
	1091
	1092	const UInt uiTrDepth=rTu.GetTransformDepthRelAdj(compID);
	1093	const UInt uiFullDepth = rTu.GetTransformDepthTotal();
	1094	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	1095	const ChromaFormat chFmt = pcOrgYuv->getChromaFormat();
	1096	const ChannelType chType = toChannelType(compID);
	1097
	1098	const UInt uiWidth = rect.width;
	1099	const UInt uiHeight = rect.height;
	1100	const UInt uiStride = pcOrgYuv ->getStride (compID);
	1101	Pel* piOrg = pcOrgYuv ->getAddr( compID, uiAbsPartIdx );
	1102	Pel* piPred = pcPredYuv->getAddr( compID, uiAbsPartIdx );
	1103	Pel* piResi = pcResiYuv->getAddr( compID, uiAbsPartIdx );
	1104	Pel* piReco = pcPredYuv->getAddr( compID, uiAbsPartIdx );
	1105	const UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
	1106	Pel* piRecQt = m_pcQTTempTComYuv[ uiQTLayer ].getAddr( compID, uiAbsPartIdx );
	1107	const UInt uiRecQtStride = m_pcQTTempTComYuv[ uiQTLayer ].getStride(compID);
	1108	const UInt uiZOrder = pcCU->getZorderIdxInCtu() + uiAbsPartIdx;
	1109	Pel* piRecIPred = pcCU->getPic()->getPicYuvRec()->getAddr( compID, pcCU->getCtuRsAddr(), uiZOrder );
	1110	UInt uiRecIPredStride = pcCU->getPic()->getPicYuvRec()->getStride ( compID );
	1111	TCoeff* pcCoeff = m_ppcQTTempCoeff[compID][uiQTLayer] + rTu.getCoefficientOffset(compID);
	1112	Bool useTransformSkip = pcCU->getTransformSkip(uiAbsPartIdx, compID);
	1113
[313]	1114	#if ADAPTIVE_QP_SELECTION
[1029]	1115	TCoeff* pcArlCoeff = m_ppcQTTempArlCoeff[compID][ uiQTLayer ] + rTu.getCoefficientOffset(compID);
[313]	1116	#endif
[1029]	1117
	1118	const UInt uiChPredMode = pcCU->getIntraDir( chType, uiAbsPartIdx );
	1119	const UInt uiChCodedMode = (uiChPredMode==DM_CHROMA_IDX && !bIsLuma) ? pcCU->getIntraDir(CHANNEL_TYPE_LUMA, getChromasCorrespondingPULumaIdx(uiAbsPartIdx, chFmt)) : uiChPredMode;
	1120	const UInt uiChFinalMode = ((chFmt == CHROMA_422) && !bIsLuma) ? g_chroma422IntraAngleMappingTable[uiChCodedMode] : uiChCodedMode;
	1121
	1122	const Int blkX = g_auiRasterToPelX[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
	1123	const Int blkY = g_auiRasterToPelY[ g_auiZscanToRaster[ uiAbsPartIdx ] ];
	1124	const Int bufferOffset = blkX + (blkY * MAX_CU_SIZE);
	1125	Pel *const encoderLumaResidual = resiLuma[RESIDUAL_ENCODER_SIDE ] + bufferOffset;
	1126	Pel *const reconstructedLumaResidual = resiLuma[RESIDUAL_RECONSTRUCTED] + bufferOffset;
	1127	const Bool bUseCrossCPrediction = isChroma(compID) && (uiChPredMode == DM_CHROMA_IDX) && checkCrossCPrediction;
	1128	const Bool bUseReconstructedResidualForEstimate = m_pcEncCfg->getUseReconBasedCrossCPredictionEstimate();
	1129	Pel *const lumaResidualForEstimate = bUseReconstructedResidualForEstimate ? reconstructedLumaResidual : encoderLumaResidual;
	1130
	1131	#ifdef DEBUG_STRING
	1132	const Int debugPredModeMask=DebugStringGetPredModeMask(MODE_INTRA);
	1133	#endif
	1134
[313]	1135	//===== init availability pattern =====
	1136	Bool bAboveAvail = false;
	1137	Bool bLeftAvail = false;
[1029]	1138
	1139	DEBUG_STRING_NEW(sTemp)
	1140
	1141	#ifndef DEBUG_STRING
	1142	if( default0Save1Load2 != 2 )
	1143	#endif
[313]	1144	{
[1029]	1145	const Bool bUseFilteredPredictions=TComPrediction::filteringIntraReferenceSamples(compID, uiChFinalMode, uiWidth, uiHeight, chFmt, pcCU->getSlice()->getSPS()->getDisableIntraReferenceSmoothing());
	1146
	1147	initAdiPatternChType( rTu, bAboveAvail, bLeftAvail, compID, bUseFilteredPredictions DEBUG_STRING_PASS_INTO(sDebug) );
	1148
[313]	1149	//===== get prediction signal =====
[1029]	1150	predIntraAng( compID, uiChFinalMode, piOrg, uiStride, piPred, uiStride, rTu, bAboveAvail, bLeftAvail, bUseFilteredPredictions );
	1151
	1152	// save prediction
	1153	if( default0Save1Load2 == 1 )
[313]	1154	{
	1155	Pel* pPred = piPred;
[1029]	1156	Pel* pPredBuf = m_pSharedPredTransformSkip[compID];
[313]	1157	Int k = 0;
	1158	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1159	{
	1160	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1161	{
	1162	pPredBuf[ k ++ ] = pPred[ uiX ];
	1163	}
	1164	pPred += uiStride;
	1165	}
	1166	}
	1167	}
[1029]	1168	#ifndef DEBUG_STRING
	1169	else
[313]	1170	{
	1171	// load prediction
	1172	Pel* pPred = piPred;
[1029]	1173	Pel* pPredBuf = m_pSharedPredTransformSkip[compID];
[313]	1174	Int k = 0;
	1175	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1176	{
	1177	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1178	{
	1179	pPred[ uiX ] = pPredBuf[ k ++ ];
	1180	}
	1181	pPred += uiStride;
	1182	}
	1183	}
[1029]	1184	#endif
	1185
[313]	1186	//===== get residual signal =====
	1187	{
	1188	// get residual
	1189	Pel* pOrg = piOrg;
	1190	Pel* pPred = piPred;
	1191	Pel* pResi = piResi;
[1029]	1192
[313]	1193	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1194	{
	1195	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1196	{
	1197	pResi[ uiX ] = pOrg[ uiX ] - pPred[ uiX ];
	1198	}
[1029]	1199
[313]	1200	pOrg += uiStride;
	1201	pResi += uiStride;
	1202	pPred += uiStride;
	1203	}
	1204	}
[1029]	1205
	1206	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
	1207	{
	1208	if (bUseCrossCPrediction)
	1209	{
	1210	if (xCalcCrossComponentPredictionAlpha( rTu, compID, lumaResidualForEstimate, piResi, uiWidth, uiHeight, MAX_CU_SIZE, uiStride ) == 0) return;
	1211	TComTrQuant::crossComponentPrediction ( rTu, compID, reconstructedLumaResidual, piResi, piResi, uiWidth, uiHeight, MAX_CU_SIZE, uiStride, uiStride, false );
	1212	}
	1213	else if (isLuma(compID) && !bUseReconstructedResidualForEstimate)
	1214	{
	1215	xStoreCrossComponentPredictionResult( encoderLumaResidual, piResi, rTu, 0, 0, MAX_CU_SIZE, uiStride );
	1216	}
	1217	}
	1218
[313]	1219	//===== transform and quantization =====
	1220	//--- init rate estimation arrays for RDOQ ---
[1029]	1221	if( useTransformSkip ? m_pcEncCfg->getUseRDOQTS() : m_pcEncCfg->getUseRDOQ() )
[313]	1222	{
[1029]	1223	m_pcEntropyCoder->estimateBit( m_pcTrQuant->m_pcEstBitsSbac, uiWidth, uiHeight, chType );
[313]	1224	}
[1029]	1225
[313]	1226	//--- transform and quantization ---
[1029]	1227	TCoeff uiAbsSum = 0;
	1228	if (bIsLuma)
	1229	{
	1230	pcCU ->setTrIdxSubParts ( uiTrDepth, uiAbsPartIdx, uiFullDepth );
	1231	}
[313]	1232
[1029]	1233	const QpParam cQP(*pcCU, compID);
[313]	1234
[1029]	1235	#if RDOQ_CHROMA_LAMBDA
	1236	m_pcTrQuant->selectLambda (compID);
[313]	1237	#endif
	1238
[1029]	1239	m_pcTrQuant->transformNxN ( rTu, compID, piResi, uiStride, pcCoeff,
[313]	1240	#if ADAPTIVE_QP_SELECTION
[1029]	1241	pcArlCoeff,
[313]	1242	#endif
[1029]	1243	uiAbsSum, cQP
	1244	);
	1245
[313]	1246	//--- inverse transform ---
[1029]	1247
	1248	#ifdef DEBUG_STRING
	1249	if ( (uiAbsSum > 0) \|\| (DebugOptionList::DebugString_InvTran.getInt()&debugPredModeMask) )
	1250	#else
	1251	if ( uiAbsSum > 0 )
	1252	#endif
[313]	1253	{
[1029]	1254	m_pcTrQuant->invTransformNxN ( rTu, compID, piResi, uiStride, pcCoeff, cQP DEBUG_STRING_PASS_INTO_OPTIONAL(&sDebug, (DebugOptionList::DebugString_InvTran.getInt()&debugPredModeMask)) );
[313]	1255	}
	1256	else
	1257	{
	1258	Pel* pResi = piResi;
	1259	memset( pcCoeff, 0, sizeof( TCoeff ) * uiWidth * uiHeight );
	1260	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1261	{
	1262	memset( pResi, 0, sizeof( Pel ) * uiWidth );
	1263	pResi += uiStride;
	1264	}
	1265	}
[1029]	1266
	1267
[313]	1268	//===== reconstruction =====
	1269	{
	1270	Pel* pPred = piPred;
	1271	Pel* pResi = piResi;
	1272	Pel* pReco = piReco;
	1273	Pel* pRecQt = piRecQt;
	1274	Pel* pRecIPred = piRecIPred;
[1029]	1275	const UInt clipbd=g_bitDepth[chType];
	1276
	1277	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
[313]	1278	{
[1029]	1279	if (bUseCrossCPrediction)
[313]	1280	{
[1029]	1281	TComTrQuant::crossComponentPrediction( rTu, compID, reconstructedLumaResidual, piResi, piResi, uiWidth, uiHeight, MAX_CU_SIZE, uiStride, uiStride, true );
[313]	1282	}
[1029]	1283	else if (isLuma(compID))
	1284	{
	1285	xStoreCrossComponentPredictionResult( reconstructedLumaResidual, piResi, rTu, 0, 0, MAX_CU_SIZE, uiStride );
	1286	}
[313]	1287	}
	1288
[1029]	1289	#ifdef DEBUG_STRING
	1290	std::stringstream ss(stringstream::out);
	1291	const Bool bDebugPred=((DebugOptionList::DebugString_Pred.getInt()&debugPredModeMask) && DEBUG_STRING_CHANNEL_CONDITION(compID));
	1292	const Bool bDebugResi=((DebugOptionList::DebugString_Resi.getInt()&debugPredModeMask) && DEBUG_STRING_CHANNEL_CONDITION(compID));
	1293	const Bool bDebugReco=((DebugOptionList::DebugString_Reco.getInt()&debugPredModeMask) && DEBUG_STRING_CHANNEL_CONDITION(compID));
[313]	1294
[1029]	1295	if (bDebugPred \|\| bDebugResi \|\| bDebugReco)
[313]	1296	{
[1029]	1297	ss << "###: " << "CompID: " << compID << " pred mode (ch/fin): " << uiChPredMode << "/" << uiChFinalMode << " absPartIdx: " << rTu.GetAbsPartIdxTU() << "\n";
[313]	1298	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1299	{
[1029]	1300	ss << "###: ";
	1301	if (bDebugPred)
	1302	{
	1303	ss << " - pred: ";
	1304	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1305	{
	1306	ss << pPred[ uiX ] << ", ";
	1307	}
	1308	}
	1309	if (bDebugResi) ss << " - resi: ";
[313]	1310	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1311	{
[1029]	1312	if (bDebugResi) ss << pResi[ uiX ] << ", ";
	1313	pReco [ uiX ] = Pel(ClipBD<Int>( Int(pPred[uiX]) + Int(pResi[uiX]), clipbd ));
	1314	pRecQt [ uiX ] = pReco[ uiX ];
	1315	pRecIPred[ uiX ] = pReco[ uiX ];
[313]	1316	}
[1029]	1317	if (bDebugReco)
	1318	{
	1319	ss << " - reco: ";
	1320	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1321	{
	1322	ss << pReco[ uiX ] << ", ";
	1323	}
	1324	}
	1325	pPred += uiStride;
	1326	pResi += uiStride;
	1327	pReco += uiStride;
	1328	pRecQt += uiRecQtStride;
	1329	pRecIPred += uiRecIPredStride;
	1330	ss << "\n";
[313]	1331	}
[1029]	1332	DEBUG_STRING_APPEND(sDebug, ss.str())
[313]	1333	}
	1334	else
[1029]	1335	#endif
[313]	1336	{
	1337
	1338	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1339	{
[1029]	1340	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1341	{
	1342	pReco [ uiX ] = Pel(ClipBD<Int>( Int(pPred[uiX]) + Int(pResi[uiX]), clipbd ));
	1343	pRecQt [ uiX ] = pReco[ uiX ];
	1344	pRecIPred[ uiX ] = pReco[ uiX ];
	1345	}
	1346	pPred += uiStride;
	1347	pResi += uiStride;
	1348	pReco += uiStride;
	1349	pRecQt += uiRecQtStride;
	1350	pRecIPred += uiRecIPredStride;
[313]	1351	}
	1352	}
	1353	}
[1029]	1354
[313]	1355	//===== update distortion =====
[1029]	1356	ruiDist += m_pcRdCost->getDistPart( g_bitDepth[chType], piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight, compID );
[313]	1357	}
	1358
	1359
	1360
[1029]	1361
	1362
	1363	Void
	1364	TEncSearch::xRecurIntraCodingQT(Bool bLumaOnly,
	1365	TComYuv* pcOrgYuv,
	1366	TComYuv* pcPredYuv,
	1367	TComYuv* pcResiYuv,
	1368	Pel resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
	1369	Distortion& ruiDistY,
	1370	Distortion& ruiDistC,
[313]	1371	#if HHI_RQT_INTRA_SPEEDUP
[1029]	1372	Bool bCheckFirst,
[313]	1373	#endif
[1029]	1374	Double& dRDCost,
	1375	TComTU& rTu
	1376	DEBUG_STRING_FN_DECLARE(sDebug))
[313]	1377	{
[1029]	1378	TComDataCU *pcCU = rTu.getCU();
	1379	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	1380	const UInt uiFullDepth = rTu.GetTransformDepthTotal();
	1381	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	1382	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	1383	Bool bCheckFull = ( uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() );
	1384	Bool bCheckSplit = ( uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
	1385	const UInt numValidComp = (bLumaOnly) ? 1 : pcOrgYuv->getNumberValidComponents();
	1386
	1387	Pel resiLumaSplit [NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE];
	1388	Pel resiLumaSingle[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE];
	1389
	1390	Bool bMaintainResidual[NUMBER_OF_STORED_RESIDUAL_TYPES];
	1391	for (UInt residualTypeIndex = 0; residualTypeIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; residualTypeIndex++)
	1392	{
	1393	bMaintainResidual[residualTypeIndex] = true; //assume true unless specified otherwise
	1394	}
	1395
	1396	bMaintainResidual[RESIDUAL_ENCODER_SIDE] = !(m_pcEncCfg->getUseReconBasedCrossCPredictionEstimate());
	1397
[313]	1398	#if HHI_RQT_INTRA_SPEEDUP
	1399	Int maxTuSize = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
	1400	Int isIntraSlice = (pcCU->getSlice()->getSliceType() == I_SLICE);
	1401	// don't check split if TU size is less or equal to max TU size
	1402	Bool noSplitIntraMaxTuSize = bCheckFull;
	1403	if(m_pcEncCfg->getRDpenalty() && ! isIntraSlice)
	1404	{
	1405	// in addition don't check split if TU size is less or equal to 16x16 TU size for non-intra slice
	1406	noSplitIntraMaxTuSize = ( uiLog2TrSize <= min(maxTuSize,4) );
	1407
[1029]	1408	// if maximum RD-penalty don't check TU size 32x32
[313]	1409	if(m_pcEncCfg->getRDpenalty()==2)
	1410	{
	1411	bCheckFull = ( uiLog2TrSize <= min(maxTuSize,4));
	1412	}
	1413	}
	1414	if( bCheckFirst && noSplitIntraMaxTuSize )
[1029]	1415
[313]	1416	{
	1417	bCheckSplit = false;
	1418	}
	1419	#else
	1420	Int maxTuSize = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
	1421	Int isIntraSlice = (pcCU->getSlice()->getSliceType() == I_SLICE);
[1029]	1422	// if maximum RD-penalty don't check TU size 32x32
[313]	1423	if((m_pcEncCfg->getRDpenalty()==2) && !isIntraSlice)
	1424	{
	1425	bCheckFull = ( uiLog2TrSize <= min(maxTuSize,4));
	1426	}
	1427	#endif
[1029]	1428	Double dSingleCost = MAX_DOUBLE;
	1429	Distortion uiSingleDist[MAX_NUM_CHANNEL_TYPE] = {0,0};
	1430	UInt uiSingleCbf[MAX_NUM_COMPONENT] = {0,0,0};
	1431	Bool checkTransformSkip = pcCU->getSlice()->getPPS()->getUseTransformSkip();
	1432	Int bestModeId[MAX_NUM_COMPONENT] = { 0, 0, 0};
	1433	checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(COMPONENT_Y), pcCU->getSlice()->getPPS()->getTransformSkipLog2MaxSize());
	1434	checkTransformSkip &= (!pcCU->getCUTransquantBypass(0));
	1435
[313]	1436	if ( m_pcEncCfg->getUseTransformSkipFast() )
	1437	{
	1438	checkTransformSkip &= (pcCU->getPartitionSize(uiAbsPartIdx)==SIZE_NxN);
	1439	}
[1029]	1440
[313]	1441	if( bCheckFull )
	1442	{
	1443	if(checkTransformSkip == true)
	1444	{
	1445	//----- store original entropy coding status -----
[595]	1446	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
	1447
[1029]	1448	Distortion singleDistTmp[MAX_NUM_CHANNEL_TYPE] = { 0, 0 };
	1449	UInt singleCbfTmp[MAX_NUM_COMPONENT] = { 0, 0, 0 };
	1450	Double singleCostTmp = 0;
	1451	Int firstCheckId = 0;
[313]	1452
	1453	for(Int modeId = firstCheckId; modeId < 2; modeId ++)
	1454	{
[1029]	1455	DEBUG_STRING_NEW(sModeString)
	1456	Int default0Save1Load2 = 0;
	1457	singleDistTmp[0]=singleDistTmp[1]=0;
[313]	1458	if(modeId == firstCheckId)
	1459	{
	1460	default0Save1Load2 = 1;
	1461	}
	1462	else
	1463	{
	1464	default0Save1Load2 = 2;
	1465	}
[1029]	1466
	1467	for(UInt ch=COMPONENT_Y; ch<numValidComp; ch++)
[313]	1468	{
[1029]	1469	const ComponentID compID = ComponentID(ch);
	1470	if (rTu.ProcessComponentSection(compID))
[313]	1471	{
[1029]	1472	const UInt totalAdjustedDepthChan = rTu.GetTransformDepthTotalAdj(compID);
	1473	pcCU->setTransformSkipSubParts ( modeId, compID, uiAbsPartIdx, totalAdjustedDepthChan );
	1474
	1475	xIntraCodingTUBlock( pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaSingle, false, singleDistTmp[toChannelType(compID)], compID, rTu DEBUG_STRING_PASS_INTO(sModeString), default0Save1Load2 );
[313]	1476	}
[1029]	1477	singleCbfTmp[compID] = pcCU->getCbf( uiAbsPartIdx, compID, uiTrDepth );
[313]	1478	}
	1479	//----- determine rate and r-d cost -----
[1029]	1480	if(modeId == 1 && singleCbfTmp[COMPONENT_Y] == 0)
[313]	1481	{
	1482	//In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
[1029]	1483	singleCostTmp = MAX_DOUBLE;
[313]	1484	}
	1485	else
	1486	{
[1029]	1487	UInt uiSingleBits = xGetIntraBitsQT( rTu, true, !bLumaOnly, false );
	1488	singleCostTmp = m_pcRdCost->calcRdCost( uiSingleBits, singleDistTmp[CHANNEL_TYPE_LUMA] + singleDistTmp[CHANNEL_TYPE_CHROMA] );
[313]	1489	}
	1490	if(singleCostTmp < dSingleCost)
	1491	{
[1029]	1492	DEBUG_STRING_SWAP(sDebug, sModeString)
[313]	1493	dSingleCost = singleCostTmp;
[1029]	1494	uiSingleDist[CHANNEL_TYPE_LUMA] = singleDistTmp[CHANNEL_TYPE_LUMA];
	1495	uiSingleDist[CHANNEL_TYPE_CHROMA] = singleDistTmp[CHANNEL_TYPE_CHROMA];
	1496	for (UInt ch=0; ch<MAX_NUM_COMPONENT; ch++)
	1497	uiSingleCbf[ch] = singleCbfTmp[ch];
	1498
	1499	bestModeId[COMPONENT_Y] = modeId;
	1500	if(bestModeId[COMPONENT_Y] == firstCheckId)
[313]	1501	{
[1029]	1502	xStoreIntraResultQT(COMPONENT_Y, bLumaOnly?COMPONENT_Y:COMPONENT_Cr, rTu );
[595]	1503	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
[313]	1504	}
[1029]	1505
	1506	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
	1507	{
	1508	const Int xOffset = rTu.getRect( COMPONENT_Y ).x0;
	1509	const Int yOffset = rTu.getRect( COMPONENT_Y ).y0;
	1510	for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
	1511	{
	1512	if (bMaintainResidual[storedResidualIndex])
	1513	{
	1514	xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaSingle[storedResidualIndex], rTu, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE);
	1515	}
	1516	}
	1517	}
[313]	1518	}
[1029]	1519	if (modeId == firstCheckId)
[313]	1520	{
	1521	m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
	1522	}
	1523	}
	1524
[1029]	1525	for(UInt ch=COMPONENT_Y; ch<numValidComp; ch++)
	1526	{
	1527	const ComponentID compID=ComponentID(ch);
	1528	if (rTu.ProcessComponentSection(compID))
	1529	{
	1530	const UInt totalAdjustedDepthChan = rTu.GetTransformDepthTotalAdj(compID);
	1531	pcCU ->setTransformSkipSubParts ( bestModeId[COMPONENT_Y], compID, uiAbsPartIdx, totalAdjustedDepthChan );
	1532	}
	1533	}
[313]	1534
[1029]	1535	if(bestModeId[COMPONENT_Y] == firstCheckId)
[313]	1536	{
[1029]	1537	xLoadIntraResultQT(COMPONENT_Y, bLumaOnly?COMPONENT_Y:COMPONENT_Cr, rTu );
	1538	for(UInt ch=COMPONENT_Y; ch< numValidComp; ch++)
[313]	1539	{
[1029]	1540	const ComponentID compID=ComponentID(ch);
	1541	if (rTu.ProcessComponentSection(compID))
	1542	pcCU->setCbfSubParts ( uiSingleCbf[compID] << uiTrDepth, compID, uiAbsPartIdx, rTu.GetTransformDepthTotalAdj(compID) );
[313]	1543	}
[1029]	1544
[595]	1545	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
[1029]	1546	}
[313]	1547
	1548	if( !bLumaOnly )
	1549	{
[1029]	1550	bestModeId[COMPONENT_Cb] = bestModeId[COMPONENT_Cr] = bestModeId[COMPONENT_Y];
	1551	if (rTu.ProcessComponentSection(COMPONENT_Cb) && bestModeId[COMPONENT_Y] == 1)
[313]	1552	{
	1553	//In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
[1029]	1554	for (UInt ch=COMPONENT_Cb; ch<numValidComp; ch++)
[313]	1555	{
[1029]	1556	if (uiSingleCbf[ch] == 0)
	1557	{
	1558	const ComponentID compID=ComponentID(ch);
	1559	const UInt totalAdjustedDepthChan = rTu.GetTransformDepthTotalAdj(compID);
	1560	pcCU ->setTransformSkipSubParts ( 0, compID, uiAbsPartIdx, totalAdjustedDepthChan);
	1561	bestModeId[ch] = 0;
	1562	}
[313]	1563	}
	1564	}
	1565	}
	1566	}
	1567	else
	1568	{
	1569	//----- store original entropy coding status -----
[595]	1570	if( bCheckSplit )
[313]	1571	{
	1572	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
	1573	}
[1029]	1574	//----- code luma/chroma block with given intra prediction mode and store Cbf-----
[313]	1575	dSingleCost = 0.0;
[1029]	1576	for (UInt ch=COMPONENT_Y; ch<numValidComp; ch++)
[313]	1577	{
[1029]	1578	const ComponentID compID = ComponentID(ch);
	1579
	1580	if (rTu.ProcessComponentSection(compID))
	1581	{
	1582	const UInt totalAdjustedDepthChan = rTu.GetTransformDepthTotalAdj(compID);
	1583	pcCU ->setTransformSkipSubParts ( 0, compID, uiAbsPartIdx, totalAdjustedDepthChan );
	1584	}
	1585
	1586	xIntraCodingTUBlock( pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaSingle, false, uiSingleDist[toChannelType(compID)], compID, rTu DEBUG_STRING_PASS_INTO(sDebug));
	1587
[313]	1588	if( bCheckSplit )
	1589	{
[1029]	1590	uiSingleCbf[compID] = pcCU->getCbf( uiAbsPartIdx, compID, uiTrDepth );
[313]	1591	}
	1592	}
	1593	//----- determine rate and r-d cost -----
[1029]	1594	UInt uiSingleBits = xGetIntraBitsQT( rTu, true, !bLumaOnly, false );
	1595
[313]	1596	if(m_pcEncCfg->getRDpenalty() && (uiLog2TrSize==5) && !isIntraSlice)
	1597	{
[1029]	1598	uiSingleBits=uiSingleBits*4;
[313]	1599	}
[1029]	1600
	1601	dSingleCost = m_pcRdCost->calcRdCost( uiSingleBits, uiSingleDist[CHANNEL_TYPE_LUMA] + uiSingleDist[CHANNEL_TYPE_CHROMA] );
	1602
	1603	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
	1604	{
	1605	const Int xOffset = rTu.getRect( COMPONENT_Y ).x0;
	1606	const Int yOffset = rTu.getRect( COMPONENT_Y ).y0;
	1607	for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
	1608	{
	1609	if (bMaintainResidual[storedResidualIndex])
	1610	{
	1611	xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaSingle[storedResidualIndex], rTu, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE);
	1612	}
	1613	}
	1614	}
[313]	1615	}
	1616	}
[1029]	1617
[313]	1618	if( bCheckSplit )
	1619	{
	1620	//----- store full entropy coding status, load original entropy coding status -----
[595]	1621	if( bCheckFull )
[313]	1622	{
[595]	1623	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_TEST ] );
	1624	m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
[313]	1625	}
[595]	1626	else
	1627	{
	1628	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
	1629	}
[313]	1630	//----- code splitted block -----
[1029]	1631	Double dSplitCost = 0.0;
	1632	Distortion uiSplitDist[MAX_NUM_CHANNEL_TYPE] = {0,0};
	1633	UInt uiSplitCbf[MAX_NUM_COMPONENT] = {0,0,0};
[313]	1634
[1029]	1635	TComTURecurse tuRecurseChild(rTu, false);
	1636	DEBUG_STRING_NEW(sSplit)
	1637	do
[313]	1638	{
[1029]	1639	DEBUG_STRING_NEW(sChild)
[313]	1640	#if HHI_RQT_INTRA_SPEEDUP
[1029]	1641	xRecurIntraCodingQT( bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaSplit, uiSplitDist[0], uiSplitDist[1], bCheckFirst, dSplitCost, tuRecurseChild DEBUG_STRING_PASS_INTO(sChild) );
[313]	1642	#else
[1029]	1643	xRecurIntraCodingQT( bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaSplit, uiSplitDist[0], uiSplitDist[1], dSplitCost, tuRecurseChild DEBUG_STRING_PASS_INTO(sChild) );
[313]	1644	#endif
[1029]	1645	DEBUG_STRING_APPEND(sSplit, sChild)
	1646	for(UInt ch=0; ch<numValidComp; ch++)
[313]	1647	{
[1029]	1648	uiSplitCbf[ch] \|= pcCU->getCbf( tuRecurseChild.GetAbsPartIdxTU(), ComponentID(ch), tuRecurseChild.GetTransformDepthRel() );
[313]	1649	}
[1029]	1650	} while (tuRecurseChild.nextSection(rTu) );
[313]	1651
[1029]	1652	UInt uiPartsDiv = rTu.GetAbsPartIdxNumParts();
	1653	for(UInt ch=COMPONENT_Y; ch<numValidComp; ch++)
[313]	1654	{
[1029]	1655	if (uiSplitCbf[ch])
[313]	1656	{
[1029]	1657	const UInt flag=1<<uiTrDepth;
	1658	const ComponentID compID=ComponentID(ch);
	1659	UChar *pBase=pcCU->getCbf( compID );
	1660	for( UInt uiOffs = 0; uiOffs < uiPartsDiv; uiOffs++ )
	1661	{
	1662	pBase[ uiAbsPartIdx + uiOffs ] \|= flag;
	1663	}
[313]	1664	}
	1665	}
	1666	//----- restore context states -----
[595]	1667	m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
[1029]	1668
	1669	//----- determine rate and r-d cost -----
	1670	UInt uiSplitBits = xGetIntraBitsQT( rTu, true, !bLumaOnly, false );
	1671	dSplitCost = m_pcRdCost->calcRdCost( uiSplitBits, uiSplitDist[CHANNEL_TYPE_LUMA] + uiSplitDist[CHANNEL_TYPE_CHROMA] );
[595]	1672
[313]	1673	//===== compare and set best =====
	1674	if( dSplitCost < dSingleCost )
	1675	{
	1676	//--- update cost ---
[1029]	1677	DEBUG_STRING_SWAP(sSplit, sDebug)
	1678	ruiDistY += uiSplitDist[CHANNEL_TYPE_LUMA];
	1679	ruiDistC += uiSplitDist[CHANNEL_TYPE_CHROMA];
[313]	1680	dRDCost += dSplitCost;
[1029]	1681
	1682	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
	1683	{
	1684	const Int xOffset = rTu.getRect( COMPONENT_Y ).x0;
	1685	const Int yOffset = rTu.getRect( COMPONENT_Y ).y0;
	1686	for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
	1687	{
	1688	if (bMaintainResidual[storedResidualIndex])
	1689	{
	1690	xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaSplit[storedResidualIndex], rTu, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE);
	1691	}
	1692	}
	1693	}
	1694
[313]	1695	return;
	1696	}
[1029]	1697
[313]	1698	//----- set entropy coding status -----
[595]	1699	m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_TEST ] );
	1700
[313]	1701	//--- set transform index and Cbf values ---
	1702	pcCU->setTrIdxSubParts( uiTrDepth, uiAbsPartIdx, uiFullDepth );
[1029]	1703	for(UInt ch=0; ch<numValidComp; ch++)
[313]	1704	{
[1029]	1705	const ComponentID compID=ComponentID(ch);
	1706	const TComRectangle &tuRect=rTu.getRect(compID);
	1707	const UInt totalAdjustedDepthChan = rTu.GetTransformDepthTotalAdj(compID);
	1708	pcCU->setCbfSubParts ( uiSingleCbf[compID] << uiTrDepth, compID, uiAbsPartIdx, totalAdjustedDepthChan );
	1709	pcCU ->setTransformSkipSubParts ( bestModeId[compID], compID, uiAbsPartIdx, totalAdjustedDepthChan );
	1710
	1711	//--- set reconstruction for next intra prediction blocks ---
	1712	const UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
	1713	const UInt uiZOrder = pcCU->getZorderIdxInCtu() + uiAbsPartIdx;
	1714	const UInt uiWidth = tuRect.width;
	1715	const UInt uiHeight = tuRect.height;
	1716	Pel* piSrc = m_pcQTTempTComYuv[ uiQTLayer ].getAddr( compID, uiAbsPartIdx );
	1717	UInt uiSrcStride = m_pcQTTempTComYuv[ uiQTLayer ].getStride ( compID );
	1718	Pel* piDes = pcCU->getPic()->getPicYuvRec()->getAddr( compID, pcCU->getCtuRsAddr(), uiZOrder );
	1719	UInt uiDesStride = pcCU->getPic()->getPicYuvRec()->getStride ( compID );
	1720
[313]	1721	for( UInt uiY = 0; uiY < uiHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
	1722	{
	1723	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1724	{
	1725	piDes[ uiX ] = piSrc[ uiX ];
	1726	}
	1727	}
	1728	}
	1729	}
[1029]	1730	ruiDistY += uiSingleDist[CHANNEL_TYPE_LUMA];
	1731	ruiDistC += uiSingleDist[CHANNEL_TYPE_CHROMA];
[313]	1732	dRDCost += dSingleCost;
	1733	}
	1734
	1735
	1736	Void
[1029]	1737	TEncSearch::xSetIntraResultQT(Bool bLumaOnly,
	1738	TComYuv* pcRecoYuv,
	1739	TComTU &rTu)
[313]	1740	{
[1029]	1741	TComDataCU *pcCU = rTu.getCU();
	1742	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	1743	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
[313]	1744	UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	1745	if( uiTrMode == uiTrDepth )
	1746	{
[1029]	1747	UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
[313]	1748	UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
[1029]	1749
	1750	Bool bSkipChroma = !rTu.ProcessChannelSection(CHANNEL_TYPE_CHROMA);
	1751
[313]	1752	//===== copy transform coefficients =====
[1029]	1753
	1754	const UInt numChannelsToProcess = (bLumaOnly \|\| bSkipChroma) ? 1 : ::getNumberValidComponents(pcCU->getPic()->getChromaFormat());
	1755	for (UInt ch=0; ch<numChannelsToProcess; ch++)
[313]	1756	{
[1029]	1757	const ComponentID compID = ComponentID(ch);
	1758	const TComRectangle &tuRect=rTu.getRect(compID);
	1759	const UInt coeffOffset = rTu.getCoefficientOffset(compID);
	1760	const UInt numCoeffInBlock = tuRect.width * tuRect.height;
	1761
	1762	if (numCoeffInBlock!=0)
	1763	{
	1764	const TCoeff* srcCoeff = m_ppcQTTempCoeff[compID][uiQTLayer] + coeffOffset;
	1765	TCoeff* destCoeff = pcCU->getCoeff(compID) + coeffOffset;
	1766	::memcpy( destCoeff, srcCoeff, sizeof(TCoeff)*numCoeffInBlock );
[313]	1767	#if ADAPTIVE_QP_SELECTION
[1029]	1768	const TCoeff* srcArlCoeff = m_ppcQTTempArlCoeff[compID][ uiQTLayer ] + coeffOffset;
	1769	TCoeff* destArlCoeff = pcCU->getArlCoeff (compID) + coeffOffset;
	1770	::memcpy( destArlCoeff, srcArlCoeff, sizeof( TCoeff ) * numCoeffInBlock );
[313]	1771	#endif
[1029]	1772	m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartComponent( compID, pcRecoYuv, uiAbsPartIdx, tuRect.width, tuRect.height );
	1773	}
	1774	} // End of channel loop
	1775
[313]	1776	}
	1777	else
	1778	{
[1029]	1779	TComTURecurse tuRecurseChild(rTu, false);
	1780	do
[313]	1781	{
[1029]	1782	xSetIntraResultQT( bLumaOnly, pcRecoYuv, tuRecurseChild );
	1783	} while (tuRecurseChild.nextSection(rTu));
[313]	1784	}
	1785	}
	1786
[1029]	1787
[313]	1788	Void
[1029]	1789	TEncSearch::xStoreIntraResultQT(const ComponentID first,
	1790	const ComponentID lastIncl,
	1791	TComTU &rTu )
[313]	1792	{
[1029]	1793	TComDataCU *pcCU=rTu.getCU();
	1794	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	1795	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	1796	const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	1797	if ( first==COMPONENT_Y \|\| uiTrMode == uiTrDepth )
[313]	1798	{
[1029]	1799	assert(uiTrMode == uiTrDepth);
	1800	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	1801	const UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
[313]	1802
	1803
[1029]	1804	for(UInt compID_=first; compID_<=lastIncl; compID_++)
	1805	{
	1806	ComponentID compID=ComponentID(compID_);
	1807	if (rTu.ProcessComponentSection(compID))
	1808	{
	1809	const TComRectangle &tuRect=rTu.getRect(compID);
[313]	1810
[1029]	1811	//===== copy transform coefficients =====
	1812	const UInt uiNumCoeff = tuRect.width * tuRect.height;
	1813	TCoeff* pcCoeffSrc = m_ppcQTTempCoeff[compID] [ uiQTLayer ] + rTu.getCoefficientOffset(compID);
	1814	TCoeff* pcCoeffDst = m_pcQTTempTUCoeff[compID];
[313]	1815
[1029]	1816	::memcpy( pcCoeffDst, pcCoeffSrc, sizeof( TCoeff ) * uiNumCoeff );
[313]	1817	#if ADAPTIVE_QP_SELECTION
[1029]	1818	TCoeff* pcArlCoeffSrc = m_ppcQTTempArlCoeff[compID] [ uiQTLayer ] + rTu.getCoefficientOffset(compID);
	1819	TCoeff* pcArlCoeffDst = m_ppcQTTempTUArlCoeff[compID];
	1820	::memcpy( pcArlCoeffDst, pcArlCoeffSrc, sizeof( TCoeff ) * uiNumCoeff );
[313]	1821	#endif
[1029]	1822	//===== copy reconstruction =====
	1823	m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartComponent( compID, &m_pcQTTempTransformSkipTComYuv, uiAbsPartIdx, tuRect.width, tuRect.height );
[313]	1824	}
	1825	}
	1826	}
	1827	}
	1828
[1029]	1829
[313]	1830	Void
[1029]	1831	TEncSearch::xLoadIntraResultQT(const ComponentID first,
	1832	const ComponentID lastIncl,
	1833	TComTU &rTu)
[313]	1834	{
[1029]	1835	TComDataCU *pcCU=rTu.getCU();
	1836	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	1837	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	1838	const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	1839	if ( first==COMPONENT_Y \|\| uiTrMode == uiTrDepth )
[313]	1840	{
[1029]	1841	assert(uiTrMode == uiTrDepth);
	1842	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	1843	const UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
	1844	const UInt uiZOrder = pcCU->getZorderIdxInCtu() + uiAbsPartIdx;
[313]	1845
[1029]	1846	for(UInt compID_=first; compID_<=lastIncl; compID_++)
[313]	1847	{
[1029]	1848	ComponentID compID=ComponentID(compID_);
	1849	if (rTu.ProcessComponentSection(compID))
[313]	1850	{
[1029]	1851	const TComRectangle &tuRect=rTu.getRect(compID);
[313]	1852
[1029]	1853	//===== copy transform coefficients =====
	1854	const UInt uiNumCoeff = tuRect.width * tuRect.height;
	1855	TCoeff* pcCoeffDst = m_ppcQTTempCoeff[compID] [ uiQTLayer ] + rTu.getCoefficientOffset(compID);
	1856	TCoeff* pcCoeffSrc = m_pcQTTempTUCoeff[compID];
[313]	1857
[1029]	1858	::memcpy( pcCoeffDst, pcCoeffSrc, sizeof( TCoeff ) * uiNumCoeff );
	1859	#if ADAPTIVE_QP_SELECTION
	1860	TCoeff* pcArlCoeffDst = m_ppcQTTempArlCoeff[compID] [ uiQTLayer ] + rTu.getCoefficientOffset(compID);
	1861	TCoeff* pcArlCoeffSrc = m_ppcQTTempTUArlCoeff[compID];
	1862	::memcpy( pcArlCoeffDst, pcArlCoeffSrc, sizeof( TCoeff ) * uiNumCoeff );
[313]	1863	#endif
[1029]	1864	//===== copy reconstruction =====
	1865	m_pcQTTempTransformSkipTComYuv.copyPartToPartComponent( compID, &m_pcQTTempTComYuv[ uiQTLayer ], uiAbsPartIdx, tuRect.width, tuRect.height );
	1866
	1867	Pel* piRecIPred = pcCU->getPic()->getPicYuvRec()->getAddr( compID, pcCU->getCtuRsAddr(), uiZOrder );
	1868	UInt uiRecIPredStride = pcCU->getPic()->getPicYuvRec()->getStride (compID);
	1869	Pel* piRecQt = m_pcQTTempTComYuv[ uiQTLayer ].getAddr( compID, uiAbsPartIdx );
	1870	UInt uiRecQtStride = m_pcQTTempTComYuv[ uiQTLayer ].getStride (compID);
	1871	UInt uiWidth = tuRect.width;
	1872	UInt uiHeight = tuRect.height;
	1873	Pel* pRecQt = piRecQt;
	1874	Pel* pRecIPred = piRecIPred;
	1875	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
	1876	{
	1877	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
	1878	{
	1879	pRecIPred[ uiX ] = pRecQt [ uiX ];
	1880	}
	1881	pRecQt += uiRecQtStride;
	1882	pRecIPred += uiRecIPredStride;
	1883	}
	1884	}
[313]	1885	}
	1886	}
	1887	}
	1888
	1889	Void
[1029]	1890	TEncSearch::xStoreCrossComponentPredictionResult( Pel *pResiDst,
	1891	const Pel *pResiSrc,
	1892	TComTU &rTu,
	1893	const Int xOffset,
	1894	const Int yOffset,
	1895	const Int strideDst,
	1896	const Int strideSrc )
[313]	1897	{
[1029]	1898	const Pel pSrc = pResiSrc + yOffset strideSrc + xOffset;
	1899	Pel pDst = pResiDst + yOffset strideDst + xOffset;
	1900
	1901	for( Int y = 0; y < rTu.getRect( COMPONENT_Y ).height; y++ )
[313]	1902	{
[1029]	1903	::memcpy( pDst, pSrc, sizeof(Pel) * rTu.getRect( COMPONENT_Y ).width );
	1904	pDst += strideDst;
	1905	pSrc += strideSrc;
	1906	}
	1907	}
[313]	1908
[1029]	1909	Char
	1910	TEncSearch::xCalcCrossComponentPredictionAlpha( TComTU &rTu,
	1911	const ComponentID compID,
	1912	const Pel* piResiL,
	1913	const Pel* piResiC,
	1914	const Int width,
	1915	const Int height,
	1916	const Int strideL,
	1917	const Int strideC )
	1918	{
	1919	const Pel *pResiL = piResiL;
	1920	const Pel *pResiC = piResiC;
[313]	1921
[1029]	1922	TComDataCU *pCU = rTu.getCU();
	1923	const Int absPartIdx = rTu.GetAbsPartIdxTU( compID );
	1924	const Int diffBitDepth = pCU->getSlice()->getSPS()->getDifferentialLumaChromaBitDepth();
[313]	1925
[1029]	1926	Char alpha = 0;
	1927	Int SSxy = 0;
	1928	Int SSxx = 0;
	1929
	1930	for( UInt uiY = 0; uiY < height; uiY++ )
	1931	{
	1932	for( UInt uiX = 0; uiX < width; uiX++ )
[313]	1933	{
[1029]	1934	const Pel scaledResiL = rightShift( pResiL[ uiX ], diffBitDepth );
	1935	SSxy += ( scaledResiL * pResiC[ uiX ] );
	1936	SSxx += ( scaledResiL * scaledResiL );
[313]	1937	}
	1938
[1029]	1939	pResiL += strideL;
	1940	pResiC += strideC;
	1941	}
[313]	1942
[1029]	1943	if( SSxx != 0 )
	1944	{
	1945	Double dAlpha = SSxy / Double( SSxx );
	1946	alpha = Char(Clip3<Int>(-16, 16, (Int)(dAlpha * 16)));
[313]	1947
[1029]	1948	static const Char alphaQuant[17] = {0, 1, 1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8};
	1949
	1950	alpha = (alpha < 0) ? -alphaQuant[Int(-alpha)] : alphaQuant[Int(alpha)];
[313]	1951	}
[1029]	1952	pCU->setCrossComponentPredictionAlphaPartRange( alpha, compID, absPartIdx, rTu.GetAbsPartIdxNumParts( compID ) );
	1953
	1954	return alpha;
[313]	1955	}
	1956
[1029]	1957	Void
	1958	TEncSearch::xRecurIntraChromaCodingQT(TComYuv* pcOrgYuv,
	1959	TComYuv* pcPredYuv,
	1960	TComYuv* pcResiYuv,
	1961	Pel resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
	1962	Distortion& ruiDist,
	1963	TComTU& rTu
	1964	DEBUG_STRING_FN_DECLARE(sDebug))
[313]	1965	{
[1029]	1966	TComDataCU *pcCU = rTu.getCU();
	1967	const UInt uiTrDepth = rTu.GetTransformDepthRel();
	1968	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	1969	const ChromaFormat format = rTu.GetChromaFormat();
	1970	UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	1971	const UInt numberValidComponents = getNumberValidComponents(format);
	1972
[313]	1973	if( uiTrMode == uiTrDepth )
	1974	{
[1029]	1975	if (!rTu.ProcessChannelSection(CHANNEL_TYPE_CHROMA)) return;
	1976
	1977	const UInt uiFullDepth = rTu.GetTransformDepthTotal();
	1978
[313]	1979	Bool checkTransformSkip = pcCU->getSlice()->getPPS()->getUseTransformSkip();
[1029]	1980	checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(COMPONENT_Cb), pcCU->getSlice()->getPPS()->getTransformSkipLog2MaxSize());
[313]	1981
[1029]	1982	if ( m_pcEncCfg->getUseTransformSkipFast() )
[313]	1983	{
[1029]	1984	checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(COMPONENT_Y), pcCU->getSlice()->getPPS()->getTransformSkipLog2MaxSize());
[313]	1985
	1986	if (checkTransformSkip)
	1987	{
	1988	Int nbLumaSkip = 0;
[1029]	1989	const UInt maxAbsPartIdxSub=uiAbsPartIdx + (rTu.ProcessingAllQuadrants(COMPONENT_Cb)?1:4);
	1990	for(UInt absPartIdxSub = uiAbsPartIdx; absPartIdxSub < maxAbsPartIdxSub; absPartIdxSub ++)
[313]	1991	{
[1029]	1992	nbLumaSkip += pcCU->getTransformSkip(absPartIdxSub, COMPONENT_Y);
[313]	1993	}
	1994	checkTransformSkip &= (nbLumaSkip > 0);
	1995	}
	1996	}
	1997
[1029]	1998
	1999	for (UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
[313]	2000	{
[1029]	2001	const ComponentID compID = ComponentID(ch);
	2002	DEBUG_STRING_NEW(sDebugBestMode)
[313]	2003
[1029]	2004	//use RDO to decide whether Cr/Cb takes TS
	2005	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[uiFullDepth][CI_QT_TRAFO_ROOT] );
	2006
	2007	const Bool splitIntoSubTUs = rTu.getRect(compID).width != rTu.getRect(compID).height;
	2008
	2009	TComTURecurse TUIterator(rTu, false, (splitIntoSubTUs ? TComTU::VERTICAL_SPLIT : TComTU::DONT_SPLIT), true, compID);
	2010
	2011	const UInt partIdxesPerSubTU = TUIterator.GetAbsPartIdxNumParts(compID);
	2012
	2013	do
	2014	{
	2015	const UInt subTUAbsPartIdx = TUIterator.GetAbsPartIdxTU(compID);
	2016
	2017	Double dSingleCost = MAX_DOUBLE;
	2018	Int bestModeId = 0;
	2019	Distortion singleDistC = 0;
	2020	UInt singleCbfC = 0;
	2021	Distortion singleDistCTmp = 0;
	2022	Double singleCostTmp = 0;
	2023	UInt singleCbfCTmp = 0;
	2024	Char bestCrossCPredictionAlpha = 0;
	2025	Int bestTransformSkipMode = 0;
	2026
	2027	const Bool checkCrossComponentPrediction = (pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, subTUAbsPartIdx) == DM_CHROMA_IDX)
	2028	&& pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction()
	2029	&& (pcCU->getCbf(subTUAbsPartIdx, COMPONENT_Y, uiTrDepth) != 0);
	2030
	2031	const Int crossCPredictionModesToTest = checkCrossComponentPrediction ? 2 : 1;
	2032	const Int transformSkipModesToTest = checkTransformSkip ? 2 : 1;
	2033	const Int totalModesToTest = crossCPredictionModesToTest * transformSkipModesToTest;
	2034	Int currModeId = 0;
	2035	Int default0Save1Load2 = 0;
	2036
	2037	for(Int transformSkipModeId = 0; transformSkipModeId < transformSkipModesToTest; transformSkipModeId++)
[313]	2038	{
[1029]	2039	for(Int crossCPredictionModeId = 0; crossCPredictionModeId < crossCPredictionModesToTest; crossCPredictionModeId++)
	2040	{
	2041	pcCU->setCrossComponentPredictionAlphaPartRange(0, compID, subTUAbsPartIdx, partIdxesPerSubTU);
	2042	DEBUG_STRING_NEW(sDebugMode)
	2043	pcCU->setTransformSkipPartRange( transformSkipModeId, compID, subTUAbsPartIdx, partIdxesPerSubTU );
	2044	currModeId++;
[313]	2045
[1029]	2046	const Bool isOneMode = (totalModesToTest == 1);
	2047	const Bool isLastMode = (currModeId == totalModesToTest); // currModeId is indexed from 1
[313]	2048
[1029]	2049	if (isOneMode)
[313]	2050	{
[1029]	2051	default0Save1Load2 = 0;
[313]	2052	}
[1029]	2053	else if (!isOneMode && (transformSkipModeId == 0) && (crossCPredictionModeId == 0))
	2054	{
	2055	default0Save1Load2 = 1; //save prediction on first mode
	2056	}
[313]	2057	else
	2058	{
[1029]	2059	default0Save1Load2 = 2; //load it on subsequent modes
[313]	2060	}
[1029]	2061
[313]	2062	singleDistCTmp = 0;
[1029]	2063
	2064	xIntraCodingTUBlock( pcOrgYuv, pcPredYuv, pcResiYuv, resiLuma, (crossCPredictionModeId != 0), singleDistCTmp, compID, TUIterator DEBUG_STRING_PASS_INTO(sDebugMode), default0Save1Load2);
	2065	singleCbfCTmp = pcCU->getCbf( subTUAbsPartIdx, compID, uiTrDepth);
	2066
	2067	if ( ((crossCPredictionModeId == 1) && (pcCU->getCrossComponentPredictionAlpha(subTUAbsPartIdx, compID) == 0))
	2068	\|\| ((transformSkipModeId == 1) && (singleCbfCTmp == 0))) //In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
[313]	2069	{
	2070	singleCostTmp = MAX_DOUBLE;
	2071	}
[1029]	2072	else if (!isOneMode)
[313]	2073	{
[1029]	2074	UInt bitsTmp = xGetIntraBitsQTChroma( TUIterator, compID, false );
[313]	2075	singleCostTmp = m_pcRdCost->calcRdCost( bitsTmp, singleDistCTmp);
	2076	}
	2077
	2078	if(singleCostTmp < dSingleCost)
	2079	{
[1029]	2080	DEBUG_STRING_SWAP(sDebugBestMode, sDebugMode)
	2081	dSingleCost = singleCostTmp;
	2082	singleDistC = singleDistCTmp;
	2083	bestCrossCPredictionAlpha = (crossCPredictionModeId != 0) ? pcCU->getCrossComponentPredictionAlpha(subTUAbsPartIdx, compID) : 0;
	2084	bestTransformSkipMode = transformSkipModeId;
	2085	bestModeId = currModeId;
	2086	singleCbfC = singleCbfCTmp;
	2087
	2088	if (!isOneMode && !isLastMode)
	2089	{
	2090	xStoreIntraResultQT(compID, compID, TUIterator);
	2091	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
	2092	}
[313]	2093	}
[1029]	2094
	2095	if (!isOneMode && !isLastMode)
	2096	{
	2097	m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
	2098	}
[313]	2099	}
	2100	}
[1029]	2101
	2102	if(bestModeId < totalModesToTest)
[595]	2103	{
[1029]	2104	xLoadIntraResultQT(compID, compID, TUIterator);
	2105	pcCU->setCbfPartRange( singleCbfC << uiTrDepth, compID, subTUAbsPartIdx, partIdxesPerSubTU );
	2106
[595]	2107	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
	2108	}
[1029]	2109
	2110	DEBUG_STRING_APPEND(sDebug, sDebugBestMode)
	2111	pcCU ->setTransformSkipPartRange ( bestTransformSkipMode, compID, subTUAbsPartIdx, partIdxesPerSubTU );
	2112	pcCU ->setCrossComponentPredictionAlphaPartRange( bestCrossCPredictionAlpha, compID, subTUAbsPartIdx, partIdxesPerSubTU );
[595]	2113	ruiDist += singleDistC;
	2114	}
[1029]	2115	while (TUIterator.nextSection(rTu));
	2116
	2117	if (splitIntoSubTUs) offsetSubTUCBFs(rTu, compID);
[313]	2118	}
	2119	}
	2120	else
	2121	{
[1029]	2122	UInt uiSplitCbf[MAX_NUM_COMPONENT] = {0,0,0};
	2123
	2124	TComTURecurse tuRecurseChild(rTu, false);
	2125	const UInt uiTrDepthChild = tuRecurseChild.GetTransformDepthRel();
	2126	do
[313]	2127	{
[1029]	2128	DEBUG_STRING_NEW(sChild)
	2129
	2130	xRecurIntraChromaCodingQT( pcOrgYuv, pcPredYuv, pcResiYuv, resiLuma, ruiDist, tuRecurseChild DEBUG_STRING_PASS_INTO(sChild) );
	2131
	2132	DEBUG_STRING_APPEND(sDebug, sChild)
	2133	const UInt uiAbsPartIdxSub=tuRecurseChild.GetAbsPartIdxTU();
	2134
	2135	for(UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
	2136	{
	2137	uiSplitCbf[ch] \|= pcCU->getCbf( uiAbsPartIdxSub, ComponentID(ch), uiTrDepthChild );
	2138	}
	2139	} while ( tuRecurseChild.nextSection(rTu) );
	2140
	2141
	2142	UInt uiPartsDiv = rTu.GetAbsPartIdxNumParts();
	2143	for(UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
[313]	2144	{
[1029]	2145	if (uiSplitCbf[ch])
	2146	{
	2147	const UInt flag=1<<uiTrDepth;
	2148	ComponentID compID=ComponentID(ch);
	2149	UChar *pBase=pcCU->getCbf( compID );
	2150	for( UInt uiOffs = 0; uiOffs < uiPartsDiv; uiOffs++ )
	2151	{
	2152	pBase[ uiAbsPartIdx + uiOffs ] \|= flag;
	2153	}
	2154	}
[313]	2155	}
	2156	}
	2157	}
	2158
[1029]	2159
	2160
	2161
[313]	2162	Void
[1029]	2163	TEncSearch::xSetIntraResultChromaQT(TComYuv* pcRecoYuv, TComTU &rTu)
[313]	2164	{
[1029]	2165	if (!rTu.ProcessChannelSection(CHANNEL_TYPE_CHROMA)) return;
	2166	TComDataCU *pcCU=rTu.getCU();
	2167	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	2168	const UInt uiTrDepth = rTu.GetTransformDepthRel();
[313]	2169	UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
	2170	if( uiTrMode == uiTrDepth )
	2171	{
[1029]	2172	UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
[313]	2173	UInt uiQTLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
[1029]	2174
[313]	2175	//===== copy transform coefficients =====
[1029]	2176	const TComRectangle &tuRectCb=rTu.getRect(COMPONENT_Cb);
	2177	UInt uiNumCoeffC = tuRectCb.widthtuRectCb.height;//( pcCU->getSlice()->getSPS()->getMaxCUWidth() pcCU->getSlice()->getSPS()->getMaxCUHeight() ) >> ( uiFullDepth << 1 );
	2178	const UInt offset = rTu.getCoefficientOffset(COMPONENT_Cb);
	2179
	2180	const UInt numberValidComponents = getNumberValidComponents(rTu.GetChromaFormat());
	2181	for (UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
[313]	2182	{
[1029]	2183	const ComponentID component = ComponentID(ch);
	2184	const TCoeff* src = m_ppcQTTempCoeff[component][uiQTLayer] + offset;//(uiNumCoeffIncC*uiAbsPartIdx);
	2185	TCoeff* dest = pcCU->getCoeff(component) + offset;//(uiNumCoeffIncC*uiAbsPartIdx);
	2186	::memcpy( dest, src, sizeof(TCoeff)*uiNumCoeffC );
	2187	#if ADAPTIVE_QP_SELECTION
	2188	TCoeff* pcArlCoeffSrc = m_ppcQTTempArlCoeff[component][ uiQTLayer ] + offset;//( uiNumCoeffIncC * uiAbsPartIdx );
	2189	TCoeff* pcArlCoeffDst = pcCU->getArlCoeff(component) + offset;//( uiNumCoeffIncC * uiAbsPartIdx );
	2190	::memcpy( pcArlCoeffDst, pcArlCoeffSrc, sizeof( TCoeff ) * uiNumCoeffC );
	2191	#endif
[313]	2192	}
[1029]	2193
[313]	2194	//===== copy reconstruction =====
[1029]	2195
	2196	m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartComponent( COMPONENT_Cb, pcRecoYuv, uiAbsPartIdx, tuRectCb.width, tuRectCb.height );
	2197	m_pcQTTempTComYuv[ uiQTLayer ].copyPartToPartComponent( COMPONENT_Cr, pcRecoYuv, uiAbsPartIdx, tuRectCb.width, tuRectCb.height );
[313]	2198	}
	2199	else
	2200	{
[1029]	2201	TComTURecurse tuRecurseChild(rTu, false);
	2202	do
[313]	2203	{
[1029]	2204	xSetIntraResultChromaQT( pcRecoYuv, tuRecurseChild );
	2205	} while (tuRecurseChild.nextSection(rTu));
[313]	2206	}
	2207	}
	2208
	2209
[1029]	2210
	2211	Void
	2212	TEncSearch::preestChromaPredMode( TComDataCU* pcCU,
	2213	TComYuv* pcOrgYuv,
[313]	2214	TComYuv* pcPredYuv )
	2215	{
[1029]	2216
	2217	//===== loop over partitions =====
	2218	const UInt uiInitTrDepth = pcCU->getPartitionSize(0) != SIZE_2Nx2N && enable4ChromaPUsInIntraNxNCU(pcOrgYuv->getChromaFormat()) ? 1 : 0;
	2219	TComTURecurse tuRecurseCU(pcCU, 0);
	2220	TComTURecurse tuRecurseWithPU(tuRecurseCU, false, (uiInitTrDepth==0)?TComTU::DONT_SPLIT : TComTU::QUAD_SPLIT);
	2221	const ChromaFormat chFmt = tuRecurseWithPU.GetChromaFormat();
	2222	Bool bFilterEnabled=filterIntraReferenceSamples(CHANNEL_TYPE_CHROMA, chFmt, pcCU->getSlice()->getSPS()->getDisableIntraReferenceSmoothing());
	2223
	2224	do
[313]	2225	{
[1029]	2226	if (tuRecurseWithPU.ProcessChannelSection(CHANNEL_TYPE_CHROMA))
[313]	2227	{
[1029]	2228	const TComRectangle &rect=tuRecurseWithPU.getRect(COMPONENT_Cb);
	2229	const UInt uiWidth = rect.width;
	2230	const UInt uiHeight = rect.height;
	2231	const UInt partIdx = tuRecurseWithPU.GetAbsPartIdxCU();
	2232	const UInt uiStride = pcOrgYuv ->getStride(COMPONENT_Cb);
	2233	Pel* piOrgU = pcOrgYuv ->getAddr ( COMPONENT_Cb, partIdx ); //TODO: Change this into an array and loop over chroma components below
	2234	Pel* piOrgV = pcOrgYuv ->getAddr ( COMPONENT_Cr, partIdx );
	2235	Pel* piPredU = pcPredYuv->getAddr ( COMPONENT_Cb, partIdx );
	2236	Pel* piPredV = pcPredYuv->getAddr ( COMPONENT_Cr, partIdx );
	2237
	2238	//===== init pattern =====
	2239	Bool bAboveAvail = false;
	2240	Bool bLeftAvail = false;
	2241	DEBUG_STRING_NEW(sTemp)
	2242	initAdiPatternChType( tuRecurseWithPU, bAboveAvail, bLeftAvail, COMPONENT_Cb, bFilterEnabled DEBUG_STRING_PASS_INTO(sTemp) );
	2243	initAdiPatternChType( tuRecurseWithPU, bAboveAvail, bLeftAvail, COMPONENT_Cr, bFilterEnabled DEBUG_STRING_PASS_INTO(sTemp) );
	2244
	2245	//===== get best prediction modes (using SAD) =====
	2246	UInt uiMinMode = 0;
	2247	UInt uiMaxMode = 4;
	2248	UInt uiBestMode = MAX_UINT;
	2249	Distortion uiMinSAD = std::numeric_limits<Distortion>::max();
	2250	const UInt mappedModeTable[4] = {PLANAR_IDX,DC_IDX,HOR_IDX,VER_IDX};
	2251
	2252	DistParam distParamU, distParamV;
	2253	const Bool bUseHadamard=pcCU->getCUTransquantBypass(0) == 0;
	2254	m_pcRdCost->setDistParam(distParamU, g_bitDepth[CHANNEL_TYPE_CHROMA], piOrgU, uiStride, piPredU, uiStride, uiWidth, uiHeight, bUseHadamard);
	2255	m_pcRdCost->setDistParam(distParamV, g_bitDepth[CHANNEL_TYPE_CHROMA], piOrgV, uiStride, piPredV, uiStride, uiWidth, uiHeight, bUseHadamard);
	2256	distParamU.bApplyWeight = false;
	2257	distParamV.bApplyWeight = false;
	2258
	2259	for( UInt uiMode_ = uiMinMode; uiMode_ < uiMaxMode; uiMode_++ )
	2260	{
	2261	UInt uiMode=mappedModeTable[uiMode_];
	2262	//--- get prediction ---
	2263	const Bool bUseFilter=TComPrediction::filteringIntraReferenceSamples(COMPONENT_Cb, uiMode, uiWidth, uiHeight, chFmt, pcCU->getSlice()->getSPS()->getDisableIntraReferenceSmoothing());
	2264
	2265	predIntraAng( COMPONENT_Cb, uiMode, piOrgU, uiStride, piPredU, uiStride, tuRecurseCU, bAboveAvail, bLeftAvail, bUseFilter );
	2266	predIntraAng( COMPONENT_Cr, uiMode, piOrgV, uiStride, piPredV, uiStride, tuRecurseCU, bAboveAvail, bLeftAvail, bUseFilter );
	2267
	2268	//--- get SAD ---
	2269	Distortion uiSAD = distParamU.DistFunc(&distParamU);
	2270	uiSAD += distParamV.DistFunc(&distParamV);
	2271	//--- check ---
	2272	if( uiSAD < uiMinSAD )
	2273	{
	2274	uiMinSAD = uiSAD;
	2275	uiBestMode = uiMode;
	2276	}
	2277	}
	2278
	2279	//===== set chroma pred mode =====
	2280	pcCU->setIntraDirSubParts( CHANNEL_TYPE_CHROMA, uiBestMode, partIdx, tuRecurseWithPU.getCUDepth() + uiInitTrDepth );
[313]	2281	}
[1029]	2282	} while (tuRecurseWithPU.nextSection(tuRecurseCU));
[313]	2283	}
	2284
[1029]	2285
	2286
	2287
	2288	Void
	2289	TEncSearch::estIntraPredQT(TComDataCU* pcCU,
	2290	TComYuv* pcOrgYuv,
	2291	TComYuv* pcPredYuv,
	2292	TComYuv* pcResiYuv,
[313]	2293	TComYuv* pcRecoYuv,
[1029]	2294	Pel resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
	2295	Distortion& ruiDistC,
	2296	Bool bLumaOnly
	2297	DEBUG_STRING_FN_DECLARE(sDebug))
[313]	2298	{
[1029]	2299	const UInt uiDepth = pcCU->getDepth(0);
	2300	const UInt uiInitTrDepth = pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1;
	2301	const UInt uiInitTrDepthC = pcCU->getPartitionSize(0) != SIZE_2Nx2N && enable4ChromaPUsInIntraNxNCU(pcOrgYuv->getChromaFormat()) ? 1 : 0;
	2302	const UInt uiNumPU = 1<<(2*uiInitTrDepth);
	2303	const UInt uiQNumParts = pcCU->getTotalNumPart() >> 2;
	2304	const UInt uiWidthBit = pcCU->getIntraSizeIdx(0);
	2305	const ChromaFormat chFmt = pcCU->getPic()->getChromaFormat();
	2306	const UInt numberValidComponents = getNumberValidComponents(chFmt);
	2307	Distortion uiOverallDistY = 0;
	2308	Distortion uiOverallDistC = 0;
	2309	UInt CandNum;
	2310	Double CandCostList[ FAST_UDI_MAX_RDMODE_NUM ];
	2311	Pel resiLumaPU[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE];
	2312
	2313	Bool bMaintainResidual[NUMBER_OF_STORED_RESIDUAL_TYPES];
	2314	for (UInt residualTypeIndex = 0; residualTypeIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; residualTypeIndex++)
	2315	{
	2316	bMaintainResidual[residualTypeIndex] = true; //assume true unless specified otherwise
	2317	}
	2318
	2319	bMaintainResidual[RESIDUAL_ENCODER_SIDE] = !(m_pcEncCfg->getUseReconBasedCrossCPredictionEstimate());
	2320
	2321	// Lambda calculation at equivalent Qp of 4 is recommended because at that Qp, the quantisation divisor is 1.
	2322	#if FULL_NBIT
	2323	const Double sqrtLambdaForFirstPass= (m_pcEncCfg->getCostMode()==COST_MIXED_LOSSLESS_LOSSY_CODING && pcCU->getCUTransquantBypass(0)) ?
	2324	sqrt(0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0)))
	2325	: m_pcRdCost->getSqrtLambda();
	2326	#else
	2327	const Double sqrtLambdaForFirstPass= (m_pcEncCfg->getCostMode()==COST_MIXED_LOSSLESS_LOSSY_CODING && pcCU->getCUTransquantBypass(0)) ?
	2328	sqrt(0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (g_bitDepth[CHANNEL_TYPE_LUMA] - 8)) / 3.0)))
	2329	: m_pcRdCost->getSqrtLambda();
	2330	#endif
	2331
[313]	2332	//===== set QP and clear Cbf =====
	2333	if ( pcCU->getSlice()->getPPS()->getUseDQP() == true)
	2334	{
	2335	pcCU->setQPSubParts( pcCU->getQP(0), 0, uiDepth );
	2336	}
	2337	else
	2338	{
	2339	pcCU->setQPSubParts( pcCU->getSlice()->getSliceQp(), 0, uiDepth );
	2340	}
[1029]	2341
[313]	2342	//===== loop over partitions =====
[1029]	2343	TComTURecurse tuRecurseCU(pcCU, 0);
	2344	TComTURecurse tuRecurseWithPU(tuRecurseCU, false, (uiInitTrDepth==0)?TComTU::DONT_SPLIT : TComTU::QUAD_SPLIT);
	2345
	2346	do
[313]	2347	{
[1029]	2348	const UInt uiPartOffset=tuRecurseWithPU.GetAbsPartIdxTU();
	2349	// for( UInt uiPU = 0, uiPartOffset=0; uiPU < uiNumPU; uiPU++, uiPartOffset += uiQNumParts )
	2350	//{
[313]	2351	//===== init pattern for luma prediction =====
	2352	Bool bAboveAvail = false;
	2353	Bool bLeftAvail = false;
[1029]	2354	DEBUG_STRING_NEW(sTemp2)
	2355
[313]	2356	//===== determine set of modes to be tested (using prediction signal only) =====
	2357	Int numModesAvailable = 35; //total number of Intra modes
	2358	UInt uiRdModeList[FAST_UDI_MAX_RDMODE_NUM];
	2359	Int numModesForFullRD = g_aucIntraModeNumFast[ uiWidthBit ];
[1029]	2360
	2361	if (tuRecurseWithPU.ProcessComponentSection(COMPONENT_Y))
	2362	initAdiPatternChType( tuRecurseWithPU, bAboveAvail, bLeftAvail, COMPONENT_Y, true DEBUG_STRING_PASS_INTO(sTemp2) );
	2363
[313]	2364	Bool doFastSearch = (numModesForFullRD != numModesAvailable);
	2365	if (doFastSearch)
	2366	{
	2367	assert(numModesForFullRD < numModesAvailable);
	2368	#if FAST_INTRA_SHVC
	2369	Int uiPreds[3] = {-1, -1, -1};
	2370	Int iMode = -1;
	2371	Bool skipFastHAD = false;
[1029]	2372	Int numCand = pcCU->getIntraDirPredictor( uiPartOffset, uiPreds, COMPONENT_Y, &iMode );
[313]	2373
[1029]	2374	if( m_pcEncCfg->getUseFastIntraScalable() && pcCU->getLayerId() > 0 )
[313]	2375	{
[1029]	2376	numModesAvailable = pcCU->reduceSetOfIntraModes(uiPartOffset, uiPreds, iMode );
	2377	if( numModesForFullRD > numModesAvailable ) //fast HAD can be skipped
[313]	2378	{
[1029]	2379	skipFastHAD = true;
	2380	numModesForFullRD = numModesAvailable;
	2381	for( Int i=0; i < numModesForFullRD; i++ )
[313]	2382	{
[1029]	2383	uiRdModeList[ i ] = g_reducedSetIntraModes[ i ];
[313]	2384	}
	2385	}
	2386	}
	2387	#endif
	2388
	2389	for( Int i=0; i < numModesForFullRD; i++ )
	2390	{
	2391	CandCostList[ i ] = MAX_DOUBLE;
	2392	}
	2393	CandNum = 0;
[1029]	2394
	2395	const TComRectangle &puRect=tuRecurseWithPU.getRect(COMPONENT_Y);
	2396	const UInt uiAbsPartIdx=tuRecurseWithPU.GetAbsPartIdxTU();
	2397
	2398	Pel* piOrg = pcOrgYuv ->getAddr( COMPONENT_Y, uiAbsPartIdx );
	2399	Pel* piPred = pcPredYuv->getAddr( COMPONENT_Y, uiAbsPartIdx );
	2400	UInt uiStride = pcPredYuv->getStride( COMPONENT_Y );
	2401	DistParam distParam;
	2402	const Bool bUseHadamard=pcCU->getCUTransquantBypass(0) == 0;
	2403	m_pcRdCost->setDistParam(distParam, g_bitDepth[CHANNEL_TYPE_LUMA], piOrg, uiStride, piPred, uiStride, puRect.width, puRect.height, bUseHadamard);
	2404	distParam.bApplyWeight = false;
[313]	2405	for( Int modeIdx = 0; modeIdx < numModesAvailable; modeIdx++ )
	2406	{
[1029]	2407	UInt uiMode = modeIdx;
	2408	Distortion uiSad = 0;
[313]	2409	#if FAST_INTRA_SHVC
	2410	if ( m_pcEncCfg->getUseFastIntraScalable() )
	2411	{
	2412	if( skipFastHAD )//indicates that fast HAD can be skipped
[1029]	2413	{
[313]	2414	break;
[1029]	2415	}
[313]	2416	uiMode = ( iMode==0 ) ? g_reducedSetIntraModes[modeIdx] : uiMode; //(iMode=0) indicates reduced set of modes
	2417	}
	2418	#endif
	2419
[1029]	2420	const Bool bUseFilter=TComPrediction::filteringIntraReferenceSamples(COMPONENT_Y, uiMode, puRect.width, puRect.height, chFmt, pcCU->getSlice()->getSPS()->getDisableIntraReferenceSmoothing());
	2421
	2422	predIntraAng( COMPONENT_Y, uiMode, piOrg, uiStride, piPred, uiStride, tuRecurseWithPU, bAboveAvail, bLeftAvail, bUseFilter, TComPrediction::UseDPCMForFirstPassIntraEstimation(tuRecurseWithPU, uiMode) );
	2423
[313]	2424	// use hadamard transform here
[1029]	2425	uiSad+=distParam.DistFunc(&distParam);
	2426
	2427	UInt iModeBits = 0;
	2428
	2429	// NB xModeBitsIntra will not affect the mode for chroma that may have already been pre-estimated.
	2430	iModeBits+=xModeBitsIntra( pcCU, uiMode, uiPartOffset, uiDepth, uiInitTrDepth, CHANNEL_TYPE_LUMA );
	2431
	2432	Double cost = (Double)uiSad + (Double)iModeBits * sqrtLambdaForFirstPass;
	2433
	2434	#ifdef DEBUG_INTRA_SEARCH_COSTS
	2435	std::cout << "1st pass mode " << uiMode << " SAD = " << uiSad << ", mode bits = " << iModeBits << ", cost = " << cost << "\n";
	2436	#endif
	2437
[313]	2438	CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
	2439	}
[1029]	2440
[313]	2441	#if FAST_UDI_USE_MPM
	2442	#if FAST_INTRA_SHVC == 0
[1029]	2443	Int uiPreds[NUM_MOST_PROBABLE_MODES] = {-1, -1, -1};
	2444
[313]	2445	Int iMode = -1;
[1029]	2446	Int numCand = pcCU->getIntraDirPredictor( uiPartOffset, uiPreds, COMPONENT_Y, &iMode );
[313]	2447	#endif
	2448	if( iMode >= 0 )
	2449	{
	2450	numCand = iMode;
	2451	}
[1029]	2452
[313]	2453	for( Int j=0; j < numCand; j++)
	2454	{
	2455	Bool mostProbableModeIncluded = false;
	2456	Int mostProbableMode = uiPreds[j];
[1029]	2457
[313]	2458	for( Int i=0; i < numModesForFullRD; i++)
	2459	{
	2460	mostProbableModeIncluded \|= (mostProbableMode == uiRdModeList[i]);
	2461	}
	2462	if (!mostProbableModeIncluded)
	2463	{
	2464	uiRdModeList[numModesForFullRD++] = mostProbableMode;
	2465	}
	2466	}
	2467	#endif // FAST_UDI_USE_MPM
	2468	}
	2469	else
	2470	{
	2471	for( Int i=0; i < numModesForFullRD; i++)
	2472	{
	2473	uiRdModeList[i] = i;
	2474	}
	2475	}
[1029]	2476
[313]	2477	//===== check modes (using r-d costs) =====
	2478	#if HHI_RQT_INTRA_SPEEDUP_MOD
	2479	UInt uiSecondBestMode = MAX_UINT;
	2480	Double dSecondBestPUCost = MAX_DOUBLE;
	2481	#endif
[1029]	2482	DEBUG_STRING_NEW(sPU)
	2483	UInt uiBestPUMode = 0;
	2484	Distortion uiBestPUDistY = 0;
	2485	Distortion uiBestPUDistC = 0;
	2486	Double dBestPUCost = MAX_DOUBLE;
	2487
	2488	#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
	2489	UInt max=numModesForFullRD;
	2490
	2491	if (DebugOptionList::ForceLumaMode.isSet()) max=0; // we are forcing a direction, so don't bother with mode check
	2492	for ( UInt uiMode = 0; uiMode < max; uiMode++)
	2493	#else
[313]	2494	for( UInt uiMode = 0; uiMode < numModesForFullRD; uiMode++ )
[1029]	2495	#endif
[313]	2496	{
	2497	// set luma prediction mode
	2498	UInt uiOrgMode = uiRdModeList[uiMode];
[1029]	2499
	2500	pcCU->setIntraDirSubParts ( CHANNEL_TYPE_LUMA, uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
	2501
	2502	DEBUG_STRING_NEW(sMode)
[313]	2503	// set context models
[595]	2504	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
[1029]	2505
[313]	2506	// determine residual for partition
[1029]	2507	Distortion uiPUDistY = 0;
	2508	Distortion uiPUDistC = 0;
	2509	Double dPUCost = 0.0;
[313]	2510	#if HHI_RQT_INTRA_SPEEDUP
[1029]	2511	xRecurIntraCodingQT( bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaPU, uiPUDistY, uiPUDistC, true, dPUCost, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sMode) );
[313]	2512	#else
[1029]	2513	xRecurIntraCodingQT( bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaPU, uiPUDistY, uiPUDistC, dPUCost, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sMode) );
[313]	2514	#endif
[1029]	2515
	2516	#ifdef DEBUG_INTRA_SEARCH_COSTS
	2517	std::cout << "2nd pass [luma,chroma] mode [" << Int(pcCU->getIntraDir(CHANNEL_TYPE_LUMA, uiPartOffset)) << "," << Int(pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, uiPartOffset)) << "] cost = " << dPUCost << "\n";
	2518	#endif
	2519
[313]	2520	// check r-d cost
	2521	if( dPUCost < dBestPUCost )
	2522	{
[1029]	2523	DEBUG_STRING_SWAP(sPU, sMode)
[313]	2524	#if HHI_RQT_INTRA_SPEEDUP_MOD
	2525	uiSecondBestMode = uiBestPUMode;
	2526	dSecondBestPUCost = dBestPUCost;
	2527	#endif
	2528	uiBestPUMode = uiOrgMode;
	2529	uiBestPUDistY = uiPUDistY;
	2530	uiBestPUDistC = uiPUDistC;
	2531	dBestPUCost = dPUCost;
[1029]	2532
	2533	xSetIntraResultQT( bLumaOnly, pcRecoYuv, tuRecurseWithPU );
	2534
	2535	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
	2536	{
	2537	const Int xOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).x0;
	2538	const Int yOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).y0;
	2539	for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
	2540	{
	2541	if (bMaintainResidual[storedResidualIndex])
	2542	{
	2543	xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaPU[storedResidualIndex], tuRecurseWithPU, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE );
	2544	}
	2545	}
	2546	}
	2547
	2548	UInt uiQPartNum = tuRecurseWithPU.GetAbsPartIdxNumParts();
	2549
[313]	2550	::memcpy( m_puhQTTempTrIdx, pcCU->getTransformIdx() + uiPartOffset, uiQPartNum * sizeof( UChar ) );
[1029]	2551	for (UInt component = 0; component < numberValidComponents; component++)
	2552	{
	2553	const ComponentID compID = ComponentID(component);
	2554	::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
	2555	::memcpy( m_puhQTTempTransformSkipFlag[compID], pcCU->getTransformSkip(compID) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
	2556	}
[313]	2557	}
	2558	#if HHI_RQT_INTRA_SPEEDUP_MOD
	2559	else if( dPUCost < dSecondBestPUCost )
	2560	{
	2561	uiSecondBestMode = uiOrgMode;
	2562	dSecondBestPUCost = dPUCost;
	2563	}
	2564	#endif
	2565	} // Mode loop
[1029]	2566
[313]	2567	#if HHI_RQT_INTRA_SPEEDUP
	2568	#if HHI_RQT_INTRA_SPEEDUP_MOD
	2569	for( UInt ui =0; ui < 2; ++ui )
	2570	#endif
	2571	{
	2572	#if HHI_RQT_INTRA_SPEEDUP_MOD
	2573	UInt uiOrgMode = ui ? uiSecondBestMode : uiBestPUMode;
	2574	if( uiOrgMode == MAX_UINT )
	2575	{
	2576	break;
	2577	}
	2578	#else
	2579	UInt uiOrgMode = uiBestPUMode;
	2580	#endif
[1029]	2581
	2582	#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
	2583	if (DebugOptionList::ForceLumaMode.isSet())
	2584	uiOrgMode = DebugOptionList::ForceLumaMode.getInt();
	2585	#endif
	2586
	2587	pcCU->setIntraDirSubParts ( CHANNEL_TYPE_LUMA, uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
	2588	DEBUG_STRING_NEW(sModeTree)
	2589
[313]	2590	// set context models
[595]	2591	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );
[1029]	2592
[313]	2593	// determine residual for partition
[1029]	2594	Distortion uiPUDistY = 0;
	2595	Distortion uiPUDistC = 0;
	2596	Double dPUCost = 0.0;
	2597
	2598	xRecurIntraCodingQT( bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaPU, uiPUDistY, uiPUDistC, false, dPUCost, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sModeTree));
	2599
[313]	2600	// check r-d cost
	2601	if( dPUCost < dBestPUCost )
	2602	{
[1029]	2603	DEBUG_STRING_SWAP(sPU, sModeTree)
[313]	2604	uiBestPUMode = uiOrgMode;
	2605	uiBestPUDistY = uiPUDistY;
	2606	uiBestPUDistC = uiPUDistC;
	2607	dBestPUCost = dPUCost;
[1029]	2608
	2609	xSetIntraResultQT( bLumaOnly, pcRecoYuv, tuRecurseWithPU );
	2610
	2611	if (pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction())
	2612	{
	2613	const Int xOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).x0;
	2614	const Int yOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).y0;
	2615	for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
	2616	{
	2617	if (bMaintainResidual[storedResidualIndex])
	2618	{
	2619	xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaPU[storedResidualIndex], tuRecurseWithPU, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE );
	2620	}
	2621	}
	2622	}
	2623
	2624	const UInt uiQPartNum = tuRecurseWithPU.GetAbsPartIdxNumParts();
[313]	2625	::memcpy( m_puhQTTempTrIdx, pcCU->getTransformIdx() + uiPartOffset, uiQPartNum * sizeof( UChar ) );
[1029]	2626
	2627	for (UInt component = 0; component < numberValidComponents; component++)
	2628	{
	2629	const ComponentID compID = ComponentID(component);
	2630	::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
	2631	::memcpy( m_puhQTTempTransformSkipFlag[compID], pcCU->getTransformSkip(compID) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
	2632	}
[313]	2633	}
	2634	} // Mode loop
	2635	#endif
[1029]	2636
	2637	DEBUG_STRING_APPEND(sDebug, sPU)
	2638
[313]	2639	//--- update overall distortion ---
	2640	uiOverallDistY += uiBestPUDistY;
	2641	uiOverallDistC += uiBestPUDistC;
[1029]	2642
[313]	2643	//--- update transform index and cbf ---
[1029]	2644	const UInt uiQPartNum = tuRecurseWithPU.GetAbsPartIdxNumParts();
[313]	2645	::memcpy( pcCU->getTransformIdx() + uiPartOffset, m_puhQTTempTrIdx, uiQPartNum * sizeof( UChar ) );
[1029]	2646	for (UInt component = 0; component < numberValidComponents; component++)
	2647	{
	2648	const ComponentID compID = ComponentID(component);
	2649	::memcpy( pcCU->getCbf( compID ) + uiPartOffset, m_puhQTTempCbf[compID], uiQPartNum * sizeof( UChar ) );
	2650	::memcpy( pcCU->getTransformSkip( compID ) + uiPartOffset, m_puhQTTempTransformSkipFlag[compID ], uiQPartNum * sizeof( UChar ) );
	2651	}
	2652
[313]	2653	//--- set reconstruction for next intra prediction blocks ---
[1029]	2654	if( !tuRecurseWithPU.IsLastSection() )
[313]	2655	{
[1029]	2656	const Bool bSkipChroma = tuRecurseWithPU.ProcessChannelSection(CHANNEL_TYPE_CHROMA);
	2657
	2658	const UInt numChannelToProcess = (bLumaOnly \|\| bSkipChroma) ? 1 : getNumberValidComponents(pcCU->getPic()->getChromaFormat());
	2659
	2660	for (UInt ch=0; ch<numChannelToProcess; ch++)
[313]	2661	{
[1029]	2662	const ComponentID compID = ComponentID(ch);
	2663	const TComRectangle &puRect=tuRecurseWithPU.getRect(compID);
	2664	const UInt uiCompWidth = puRect.width;
	2665	const UInt uiCompHeight = puRect.height;
	2666
	2667	const UInt uiZOrder = pcCU->getZorderIdxInCtu() + uiPartOffset;
	2668	Pel* piDes = pcCU->getPic()->getPicYuvRec()->getAddr( compID, pcCU->getCtuRsAddr(), uiZOrder );
	2669	const UInt uiDesStride = pcCU->getPic()->getPicYuvRec()->getStride( compID);
	2670	const Pel* piSrc = pcRecoYuv->getAddr( compID, uiPartOffset );
	2671	const UInt uiSrcStride = pcRecoYuv->getStride( compID);
	2672
[313]	2673	for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
	2674	{
	2675	for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
	2676	{
	2677	piDes[ uiX ] = piSrc[ uiX ];
	2678	}
	2679	}
	2680	}
	2681	}
[1029]	2682
[313]	2683	//=== update PU data ====
[1029]	2684	pcCU->setIntraDirSubParts ( CHANNEL_TYPE_LUMA, uiBestPUMode, uiPartOffset, uiDepth + uiInitTrDepth );
	2685	if (!bLumaOnly && getChromasCorrespondingPULumaIdx(uiPartOffset, chFmt)==uiPartOffset)
	2686	{
	2687	UInt chromaDir=pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, getChromasCorrespondingPULumaIdx(uiPartOffset, chFmt));
	2688	if (chromaDir == uiBestPUMode && tuRecurseWithPU.ProcessChannelSection(CHANNEL_TYPE_CHROMA))
	2689	{
	2690	pcCU->setIntraDirSubParts ( CHANNEL_TYPE_CHROMA, DM_CHROMA_IDX, getChromasCorrespondingPULumaIdx(uiPartOffset, chFmt), uiDepth + uiInitTrDepthC );
	2691	}
	2692	}
	2693	//pcCU->copyToPic ( uiDepth, uiPU, uiInitTrDepth ); // Unnecessary copy?
	2694	} while (tuRecurseWithPU.nextSection(tuRecurseCU));
	2695
	2696
[313]	2697	if( uiNumPU > 1 )
	2698	{ // set Cbf for all blocks
	2699	UInt uiCombCbfY = 0;
	2700	UInt uiCombCbfU = 0;
	2701	UInt uiCombCbfV = 0;
	2702	UInt uiPartIdx = 0;
	2703	for( UInt uiPart = 0; uiPart < 4; uiPart++, uiPartIdx += uiQNumParts )
	2704	{
[1029]	2705	uiCombCbfY \|= pcCU->getCbf( uiPartIdx, COMPONENT_Y, 1 );
	2706	uiCombCbfU \|= pcCU->getCbf( uiPartIdx, COMPONENT_Cb, 1 );
	2707	uiCombCbfV \|= pcCU->getCbf( uiPartIdx, COMPONENT_Cr, 1 );
[313]	2708	}
	2709	for( UInt uiOffs = 0; uiOffs < 4 * uiQNumParts; uiOffs++ )
	2710	{
[1029]	2711	pcCU->getCbf( COMPONENT_Y )[ uiOffs ] \|= uiCombCbfY;
	2712	pcCU->getCbf( COMPONENT_Cb )[ uiOffs ] \|= uiCombCbfU;
	2713	pcCU->getCbf( COMPONENT_Cr )[ uiOffs ] \|= uiCombCbfV;
[313]	2714	}
	2715	}
[1029]	2716
[313]	2717	//===== reset context models =====
[595]	2718	m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
[1029]	2719
[313]	2720	//===== set distortion (rate and r-d costs are determined later) =====
	2721	ruiDistC = uiOverallDistC;
	2722	pcCU->getTotalDistortion() = uiOverallDistY + uiOverallDistC;
	2723	}
	2724
	2725
	2726
[1029]	2727
	2728	Void
	2729	TEncSearch::estIntraPredChromaQT(TComDataCU* pcCU,
	2730	TComYuv* pcOrgYuv,
	2731	TComYuv* pcPredYuv,
	2732	TComYuv* pcResiYuv,
[313]	2733	TComYuv* pcRecoYuv,
[1029]	2734	Pel resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
	2735	Distortion uiPreCalcDistC
	2736	DEBUG_STRING_FN_DECLARE(sDebug))
[313]	2737	{
[1029]	2738	pcCU->getTotalDistortion () -= uiPreCalcDistC;
[313]	2739
[1029]	2740	//const UInt uiDepthCU = pcCU->getDepth(0);
	2741	const UInt uiInitTrDepth = pcCU->getPartitionSize(0) != SIZE_2Nx2N && enable4ChromaPUsInIntraNxNCU(pcOrgYuv->getChromaFormat()) ? 1 : 0;
	2742	// const UInt uiNumPU = 1<<(2*uiInitTrDepth);
	2743
	2744	TComTURecurse tuRecurseCU(pcCU, 0);
	2745	TComTURecurse tuRecurseWithPU(tuRecurseCU, false, (uiInitTrDepth==0)?TComTU::DONT_SPLIT : TComTU::QUAD_SPLIT);
	2746	const UInt uiQNumParts = tuRecurseWithPU.GetAbsPartIdxNumParts();
	2747	const UInt uiDepthCU=tuRecurseWithPU.getCUDepth();
	2748	const UInt numberValidComponents = pcCU->getPic()->getNumberValidComponents();
	2749
	2750	do
[313]	2751	{
[1029]	2752	UInt uiBestMode = 0;
	2753	Distortion uiBestDist = 0;
	2754	Double dBestCost = MAX_DOUBLE;
	2755
	2756	//----- init mode list -----
	2757	if (tuRecurseWithPU.ProcessChannelSection(CHANNEL_TYPE_CHROMA))
[313]	2758	{
[1029]	2759	UInt uiModeList[FAST_UDI_MAX_RDMODE_NUM];
	2760	const UInt uiQPartNum = uiQNumParts;
	2761	const UInt uiPartOffset = tuRecurseWithPU.GetAbsPartIdxTU();
	2762	{
	2763	UInt uiMinMode = 0;
	2764	UInt uiMaxMode = NUM_CHROMA_MODE;
	2765
	2766	//----- check chroma modes -----
	2767	pcCU->getAllowedChromaDir( uiPartOffset, uiModeList );
	2768
	2769	#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
	2770	if (DebugOptionList::ForceChromaMode.isSet())
	2771	{
	2772	uiMinMode=DebugOptionList::ForceChromaMode.getInt();
	2773	if (uiModeList[uiMinMode]==34) uiMinMode=4; // if the fixed mode has been renumbered because DM_CHROMA covers it, use DM_CHROMA.
	2774	uiMaxMode=uiMinMode+1;
	2775	}
	2776	#endif
	2777
	2778	DEBUG_STRING_NEW(sPU)
	2779
	2780	for( UInt uiMode = uiMinMode; uiMode < uiMaxMode; uiMode++ )
	2781	{
	2782	//----- restore context models -----
	2783	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepthCU][CI_CURR_BEST] );
	2784
	2785	DEBUG_STRING_NEW(sMode)
	2786	//----- chroma coding -----
	2787	Distortion uiDist = 0;
	2788	pcCU->setIntraDirSubParts ( CHANNEL_TYPE_CHROMA, uiModeList[uiMode], uiPartOffset, uiDepthCU+uiInitTrDepth );
	2789	xRecurIntraChromaCodingQT ( pcOrgYuv, pcPredYuv, pcResiYuv, resiLuma, uiDist, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sMode) );
	2790
	2791	if( pcCU->getSlice()->getPPS()->getUseTransformSkip() )
	2792	{
	2793	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepthCU][CI_CURR_BEST] );
	2794	}
	2795
	2796	UInt uiBits = xGetIntraBitsQT( tuRecurseWithPU, false, true, false );
	2797	Double dCost = m_pcRdCost->calcRdCost( uiBits, uiDist );
	2798
	2799	//----- compare -----
	2800	if( dCost < dBestCost )
	2801	{
	2802	DEBUG_STRING_SWAP(sPU, sMode);
	2803	dBestCost = dCost;
	2804	uiBestDist = uiDist;
	2805	uiBestMode = uiModeList[uiMode];
	2806
	2807	xSetIntraResultChromaQT( pcRecoYuv, tuRecurseWithPU );
	2808	for (UInt componentIndex = COMPONENT_Cb; componentIndex < numberValidComponents; componentIndex++)
	2809	{
	2810	const ComponentID compID = ComponentID(componentIndex);
	2811	::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID )+uiPartOffset, uiQPartNum * sizeof( UChar ) );
	2812	::memcpy( m_puhQTTempTransformSkipFlag[compID], pcCU->getTransformSkip( compID )+uiPartOffset, uiQPartNum * sizeof( UChar ) );
	2813	::memcpy( m_phQTTempCrossComponentPredictionAlpha[compID], pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, uiQPartNum * sizeof( Char ) );
	2814	}
	2815	}
	2816	}
	2817
	2818	DEBUG_STRING_APPEND(sDebug, sPU)
	2819
	2820	//----- set data -----
	2821	for (UInt componentIndex = COMPONENT_Cb; componentIndex < numberValidComponents; componentIndex++)
	2822	{
	2823	const ComponentID compID = ComponentID(componentIndex);
	2824	::memcpy( pcCU->getCbf( compID )+uiPartOffset, m_puhQTTempCbf[compID], uiQPartNum * sizeof( UChar ) );
	2825	::memcpy( pcCU->getTransformSkip( compID )+uiPartOffset, m_puhQTTempTransformSkipFlag[compID], uiQPartNum * sizeof( UChar ) );
	2826	::memcpy( pcCU->getCrossComponentPredictionAlpha(compID)+uiPartOffset, m_phQTTempCrossComponentPredictionAlpha[compID], uiQPartNum * sizeof( Char ) );
	2827	}
	2828	}
	2829
	2830	if( ! tuRecurseWithPU.IsLastSection() )
	2831	{
	2832	for (UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
	2833	{
	2834	const ComponentID compID = ComponentID(ch);
	2835	const TComRectangle &tuRect = tuRecurseWithPU.getRect(compID);
	2836	const UInt uiCompWidth = tuRect.width;
	2837	const UInt uiCompHeight = tuRect.height;
	2838	const UInt uiZOrder = pcCU->getZorderIdxInCtu() + tuRecurseWithPU.GetAbsPartIdxTU();
	2839	Pel* piDes = pcCU->getPic()->getPicYuvRec()->getAddr( compID, pcCU->getCtuRsAddr(), uiZOrder );
	2840	const UInt uiDesStride = pcCU->getPic()->getPicYuvRec()->getStride( compID);
	2841	const Pel* piSrc = pcRecoYuv->getAddr( compID, uiPartOffset );
	2842	const UInt uiSrcStride = pcRecoYuv->getStride( compID);
	2843
	2844	for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
	2845	{
	2846	for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
	2847	{
	2848	piDes[ uiX ] = piSrc[ uiX ];
	2849	}
	2850	}
	2851	}
	2852	}
	2853
	2854	pcCU->setIntraDirSubParts( CHANNEL_TYPE_CHROMA, uiBestMode, uiPartOffset, uiDepthCU+uiInitTrDepth );
	2855	pcCU->getTotalDistortion () += uiBestDist;
[313]	2856	}
[1029]	2857
	2858	} while (tuRecurseWithPU.nextSection(tuRecurseCU));
	2859
	2860	//----- restore context models -----
	2861
	2862	if( uiInitTrDepth != 0 )
	2863	{ // set Cbf for all blocks
	2864	UInt uiCombCbfU = 0;
	2865	UInt uiCombCbfV = 0;
	2866	UInt uiPartIdx = 0;
	2867	for( UInt uiPart = 0; uiPart < 4; uiPart++, uiPartIdx += uiQNumParts )
[313]	2868	{
[1029]	2869	uiCombCbfU \|= pcCU->getCbf( uiPartIdx, COMPONENT_Cb, 1 );
	2870	uiCombCbfV \|= pcCU->getCbf( uiPartIdx, COMPONENT_Cr, 1 );
[313]	2871	}
[1029]	2872	for( UInt uiOffs = 0; uiOffs < 4 * uiQNumParts; uiOffs++ )
	2873	{
	2874	pcCU->getCbf( COMPONENT_Cb )[ uiOffs ] \|= uiCombCbfU;
	2875	pcCU->getCbf( COMPONENT_Cr )[ uiOffs ] \|= uiCombCbfV;
	2876	}
[313]	2877	}
[1029]	2878
	2879	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepthCU][CI_CURR_BEST] );
[313]	2880	}
	2881
[1029]	2882
	2883
	2884
[313]	2885	/** Function for encoding and reconstructing luma/chroma samples of a PCM mode CU.
	2886	* \param pcCU pointer to current CU
	2887	* \param uiAbsPartIdx part index
	2888	* \param piOrg pointer to original sample arrays
	2889	* \param piPCM pointer to PCM code arrays
	2890	* \param piPred pointer to prediction signal arrays
	2891	* \param piResi pointer to residual signal arrays
	2892	* \param piReco pointer to reconstructed sample arrays
	2893	* \param uiStride stride of the original/prediction/residual sample arrays
	2894	* \param uiWidth block width
	2895	* \param uiHeight block height
	2896	* \param ttText texture component type
	2897	* \returns Void
	2898	*/
[1029]	2899	Void TEncSearch::xEncPCM (TComDataCU* pcCU, UInt uiAbsPartIdx, Pel* pOrg, Pel* pPCM, Pel* pPred, Pel* pResi, Pel* pReco, UInt uiStride, UInt uiWidth, UInt uiHeight, const ComponentID compID )
[313]	2900	{
[1029]	2901	const UInt uiReconStride = pcCU->getPic()->getPicYuvRec()->getStride(compID);
	2902	const UInt uiPCMBitDepth = pcCU->getSlice()->getSPS()->getPCMBitDepth(toChannelType(compID));
	2903	Pel* pRecoPic = pcCU->getPic()->getPicYuvRec()->getAddr(compID, pcCU->getCtuRsAddr(), pcCU->getZorderIdxInCtu()+uiAbsPartIdx);
[313]	2904
[1029]	2905	const Int pcmShiftRight=(g_bitDepth[toChannelType(compID)] - Int(uiPCMBitDepth));
[313]	2906
[1029]	2907	assert(pcmShiftRight >= 0);
[313]	2908
[1029]	2909	for( UInt uiY = 0; uiY < uiHeight; uiY++ )
[313]	2910	{
[1029]	2911	for( UInt uiX = 0; uiX < uiWidth; uiX++ )
[313]	2912	{
[1029]	2913	// Reset pred and residual
[313]	2914	pPred[uiX] = 0;
	2915	pResi[uiX] = 0;
[1029]	2916	// Encode
	2917	pPCM[uiX] = (pOrg[uiX]>>pcmShiftRight);
	2918	// Reconstruction
	2919	pReco [uiX] = (pPCM[uiX]<<(pcmShiftRight));
	2920	pRecoPic[uiX] = pReco[uiX];
[313]	2921	}
	2922	pPred += uiStride;
	2923	pResi += uiStride;
	2924	pPCM += uiWidth;
	2925	pOrg += uiStride;
	2926	pReco += uiStride;
	2927	pRecoPic += uiReconStride;
	2928	}
	2929	}
	2930
[1029]	2931
[313]	2932	/** Function for PCM mode estimation.
	2933	* \param pcCU
	2934	* \param pcOrgYuv
	2935	* \param rpcPredYuv
	2936	* \param rpcResiYuv
	2937	* \param rpcRecoYuv
	2938	* \returns Void
	2939	*/
[1029]	2940	Void TEncSearch::IPCMSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, TComYuv* pcResiYuv, TComYuv* pcRecoYuv )
[313]	2941	{
[1029]	2942	UInt uiDepth = pcCU->getDepth(0);
	2943	const UInt uiDistortion = 0;
	2944	UInt uiBits;
[313]	2945
	2946	Double dCost;
	2947
[1029]	2948	for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
	2949	{
	2950	const ComponentID compID = ComponentID(ch);
	2951	const UInt width = pcCU->getWidth(0) >> pcCU->getPic()->getComponentScaleX(compID);
	2952	const UInt height = pcCU->getHeight(0) >> pcCU->getPic()->getComponentScaleY(compID);
	2953	const UInt stride = pcPredYuv->getStride(compID);
[313]	2954
[1029]	2955	Pel * pOrig = pcOrgYuv->getAddr (compID, 0, width);
	2956	Pel * pResi = pcResiYuv->getAddr(compID, 0, width);
	2957	Pel * pPred = pcPredYuv->getAddr(compID, 0, width);
	2958	Pel * pReco = pcRecoYuv->getAddr(compID, 0, width);
	2959	Pel * pPCM = pcCU->getPCMSample (compID);
[313]	2960
[1029]	2961	xEncPCM ( pcCU, 0, pOrig, pPCM, pPred, pResi, pReco, stride, width, height, compID );
[313]	2962
[1029]	2963	}
[313]	2964
	2965	m_pcEntropyCoder->resetBits();
[1029]	2966	xEncIntraHeader ( pcCU, uiDepth, 0, true, false);
[313]	2967	uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	2968
	2969	dCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
	2970
[595]	2971	m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);
[313]	2972
	2973	pcCU->getTotalBits() = uiBits;
	2974	pcCU->getTotalCost() = dCost;
	2975	pcCU->getTotalDistortion() = uiDistortion;
	2976
	2977	pcCU->copyToPic(uiDepth, 0, 0);
	2978	}
	2979
[1029]	2980
	2981
	2982
	2983	Void TEncSearch::xGetInterPredictionError( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, Distortion& ruiErr, Bool /bHadamard/ )
[313]	2984	{
	2985	motionCompensation( pcCU, &m_tmpYuvPred, REF_PIC_LIST_X, iPartIdx );
	2986
	2987	UInt uiAbsPartIdx = 0;
	2988	Int iWidth = 0;
	2989	Int iHeight = 0;
	2990	pcCU->getPartIndexAndSize( iPartIdx, uiAbsPartIdx, iWidth, iHeight );
	2991
	2992	DistParam cDistParam;
	2993
	2994	cDistParam.bApplyWeight = false;
	2995
[1029]	2996
	2997	m_pcRdCost->setDistParam( cDistParam, g_bitDepth[CHANNEL_TYPE_LUMA],
	2998	pcYuvOrg->getAddr( COMPONENT_Y, uiAbsPartIdx ), pcYuvOrg->getStride(COMPONENT_Y),
	2999	m_tmpYuvPred .getAddr( COMPONENT_Y, uiAbsPartIdx ), m_tmpYuvPred.getStride(COMPONENT_Y),
	3000	iWidth, iHeight, m_pcEncCfg->getUseHADME() && (pcCU->getCUTransquantBypass(iPartIdx) == 0) );
	3001
[313]	3002	ruiErr = cDistParam.DistFunc( &cDistParam );
	3003	}
	3004
	3005	/** estimation of best merge coding
	3006	* \param pcCU
	3007	* \param pcYuvOrg
	3008	* \param iPUIdx
	3009	* \param uiInterDir
	3010	* \param pacMvField
	3011	* \param uiMergeIndex
	3012	* \param ruiCost
	3013	* \param ruiBits
	3014	* \param puhNeighCands
[1029]	3015	* \param bValid
[313]	3016	* \returns Void
	3017	*/
[1029]	3018	Void TEncSearch::xMergeEstimation( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPUIdx, UInt& uiInterDir, TComMvField* pacMvField, UInt& uiMergeIndex, Distortion& ruiCost, TComMvField* cMvFieldNeighbours, UChar* uhInterDirNeighbours, Int& numValidMergeCand )
[313]	3019	{
	3020	UInt uiAbsPartIdx = 0;
	3021	Int iWidth = 0;
[1029]	3022	Int iHeight = 0;
[313]	3023
	3024	pcCU->getPartIndexAndSize( iPUIdx, uiAbsPartIdx, iWidth, iHeight );
	3025	UInt uiDepth = pcCU->getDepth( uiAbsPartIdx );
[1029]	3026
[313]	3027	PartSize partSize = pcCU->getPartitionSize( 0 );
	3028	if ( pcCU->getSlice()->getPPS()->getLog2ParallelMergeLevelMinus2() && partSize != SIZE_2Nx2N && pcCU->getWidth( 0 ) <= 8 )
	3029	{
	3030	pcCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uiDepth );
	3031	if ( iPUIdx == 0 )
	3032	{
	3033	pcCU->getInterMergeCandidates( 0, 0, cMvFieldNeighbours,uhInterDirNeighbours, numValidMergeCand );
	3034	}
	3035	pcCU->setPartSizeSubParts( partSize, 0, uiDepth );
	3036	}
	3037	else
	3038	{
	3039	pcCU->getInterMergeCandidates( uiAbsPartIdx, iPUIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
	3040	}
[1029]	3041
[313]	3042	xRestrictBipredMergeCand( pcCU, iPUIdx, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand );
	3043
[1029]	3044	ruiCost = std::numeric_limits<Distortion>::max();
[313]	3045	for( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )
	3046	{
	3047	#if REF_IDX_ME_ZEROMV
	3048	Bool bZeroMVILR = pcCU->xCheckZeroMVILRMerge(uhInterDirNeighbours[uiMergeCand], cMvFieldNeighbours[0 + 2uiMergeCand], cMvFieldNeighbours[1 + 2uiMergeCand]);
	3049	if(bZeroMVILR)
	3050	{
	3051	#endif
[494]	3052	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	3053	if (!(pcCU->isInterLayerReference(uhInterDirNeighbours[uiMergeCand], cMvFieldNeighbours[0 + 2uiMergeCand], cMvFieldNeighbours[1 + 2uiMergeCand]) && m_disableILP))
	3054	{
	3055	#endif
[1029]	3056	Distortion uiCostCand = std::numeric_limits<Distortion>::max();
	3057	UInt uiBitsCand = 0;
[313]	3058
[1029]	3059	PartSize ePartSize = pcCU->getPartitionSize( 0 );
[313]	3060
[1029]	3061	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( cMvFieldNeighbours[0 + 2*uiMergeCand], ePartSize, uiAbsPartIdx, 0, iPUIdx );
	3062	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( cMvFieldNeighbours[1 + 2*uiMergeCand], ePartSize, uiAbsPartIdx, 0, iPUIdx );
	3063
	3064	xGetInterPredictionError( pcCU, pcYuvOrg, iPUIdx, uiCostCand, m_pcEncCfg->getUseHADME() );
	3065	uiBitsCand = uiMergeCand + 1;
	3066	if (uiMergeCand == m_pcEncCfg->getMaxNumMergeCand() -1)
	3067	{
	3068	uiBitsCand--;
	3069	}
	3070	uiCostCand = uiCostCand + m_pcRdCost->getCost( uiBitsCand );
	3071	if ( uiCostCand < ruiCost )
	3072	{
	3073	ruiCost = uiCostCand;
	3074	pacMvField[0] = cMvFieldNeighbours[0 + 2*uiMergeCand];
	3075	pacMvField[1] = cMvFieldNeighbours[1 + 2*uiMergeCand];
	3076	uiInterDir = uhInterDirNeighbours[uiMergeCand];
	3077	uiMergeIndex = uiMergeCand;
	3078	}
[494]	3079	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
	3080	}
	3081	#endif
[313]	3082	#if REF_IDX_ME_ZEROMV
	3083	}
	3084	#endif
	3085	}
	3086	}
	3087
	3088	/** convert bi-pred merge candidates to uni-pred
	3089	* \param pcCU
	3090	* \param puIdx
	3091	* \param mvFieldNeighbours
	3092	* \param interDirNeighbours
	3093	* \param numValidMergeCand
	3094	* \returns Void
	3095	*/
	3096	Void TEncSearch::xRestrictBipredMergeCand( TComDataCU* pcCU, UInt puIdx, TComMvField* mvFieldNeighbours, UChar* interDirNeighbours, Int numValidMergeCand )
	3097	{
	3098	if ( pcCU->isBipredRestriction(puIdx) )
	3099	{
	3100	for( UInt mergeCand = 0; mergeCand < numValidMergeCand; ++mergeCand )
	3101	{
	3102	if ( interDirNeighbours[mergeCand] == 3 )
	3103	{
	3104	interDirNeighbours[mergeCand] = 1;
	3105	mvFieldNeighbours[(mergeCand << 1) + 1].setMvField(TComMv(0,0), -1);
	3106	}
	3107	}
	3108	}
	3109	}
	3110
	3111	/** search of the best candidate for inter prediction
	3112	* \param pcCU
	3113	* \param pcOrgYuv
	3114	* \param rpcPredYuv
	3115	* \param rpcResiYuv
	3116	* \param rpcRecoYuv
	3117	* \param bUseRes
	3118	* \returns Void
	3119	*/
[815]	3120	#if SVC_EXTENSION
[313]	3121	#if AMP_MRG
[1029]	3122	Bool TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, TComYuv* pcResiYuv, TComYuv* pcRecoYuv DEBUG_STRING_FN_DECLARE(sDebug), Bool bUseRes, Bool bUseMRG )
[815]	3123	#else
[1029]	3124	Bool TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, TComYuv* pcResiYuv, TComYuv* pcRecoYuv, Bool bUseRes )
[815]	3125	#endif
	3126	#else
	3127	#if AMP_MRG
[1029]	3128	Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, TComYuv* pcResiYuv, TComYuv* pcRecoYuv DEBUG_STRING_FN_DECLARE(sDebug), Bool bUseRes, Bool bUseMRG )
[313]	3129	#else
[1029]	3130	Void TEncSearch::predInterSearch( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, TComYuv* pcResiYuv, TComYuv* pcRecoYuv, Bool bUseRes )
[313]	3131	#endif
[815]	3132	#endif
[313]	3133	{
[1029]	3134	for(UInt i=0; i<NUM_REF_PIC_LIST_01; i++)
	3135	{
	3136	m_acYuvPred[i].clear();
	3137	}
[313]	3138	m_cYuvPredTemp.clear();
[1029]	3139	pcPredYuv->clear();
	3140
[313]	3141	if ( !bUseRes )
	3142	{
[1029]	3143	pcResiYuv->clear();
[313]	3144	}
	3145
[1029]	3146	pcRecoYuv->clear();
[313]	3147
[1029]	3148	TComMv cMvSrchRngLT;
	3149	TComMv cMvSrchRngRB;
[313]	3150
[1029]	3151	TComMv cMvZero;
	3152	TComMv TempMv; //kolya
	3153
	3154	TComMv cMv[2];
	3155	TComMv cMvBi[2];
	3156	TComMv cMvTemp[2][33];
	3157
	3158	Int iNumPart = pcCU->getNumPartitions();
	3159	Int iNumPredDir = pcCU->getSlice()->isInterP() ? 1 : 2;
	3160
	3161	TComMv cMvPred[2][33];
	3162
	3163	TComMv cMvPredBi[2][33];
	3164	Int aaiMvpIdxBi[2][33];
	3165
	3166	Int aaiMvpIdx[2][33];
	3167	Int aaiMvpNum[2][33];
	3168
	3169	AMVPInfo aacAMVPInfo[2][33];
	3170
	3171	Int iRefIdx[2]={0,0}; //If un-initialized, may cause SEGV in bi-directional prediction iterative stage.
	3172	Int iRefIdxBi[2];
	3173
	3174	UInt uiPartAddr;
	3175	Int iRoiWidth, iRoiHeight;
	3176
	3177	UInt uiMbBits[3] = {1, 1, 0};
	3178
	3179	UInt uiLastMode = 0;
	3180	Int iRefStart, iRefEnd;
	3181
	3182	PartSize ePartSize = pcCU->getPartitionSize( 0 );
	3183
	3184	Int bestBiPRefIdxL1 = 0;
	3185	Int bestBiPMvpL1 = 0;
	3186	Distortion biPDistTemp = std::numeric_limits<Distortion>::max();
	3187
[313]	3188	TComMvField cMvFieldNeighbours[MRG_MAX_NUM_CANDS << 1]; // double length for mv of both lists
	3189	UChar uhInterDirNeighbours[MRG_MAX_NUM_CANDS];
	3190	Int numValidMergeCand = 0 ;
	3191
	3192	for ( Int iPartIdx = 0; iPartIdx < iNumPart; iPartIdx++ )
	3193	{
[1029]	3194	Distortion uiCost[2] = { std::numeric_limits<Distortion>::max(), std::numeric_limits<Distortion>::max() };
	3195	Distortion uiCostBi = std::numeric_limits<Distortion>::max();
	3196	Distortion uiCostTemp;
[313]	3197
[1029]	3198	UInt uiBits[3];
	3199	UInt uiBitsTemp;
	3200	Distortion bestBiPDist = std::numeric_limits<Distortion>::max();
	3201
	3202	Distortion uiCostTempL0[MAX_NUM_REF];
[540]	3203	for (Int iNumRef=0; iNumRef < MAX_NUM_REF; iNumRef++)
	3204	{
[1029]	3205	uiCostTempL0[iNumRef] = std::numeric_limits<Distortion>::max();
[540]	3206	}
[1029]	3207	UInt uiBitsTempL0[MAX_NUM_REF];
[313]	3208
[1029]	3209	TComMv mvValidList1;
	3210	Int refIdxValidList1 = 0;
	3211	UInt bitsValidList1 = MAX_UINT;
	3212	Distortion costValidList1 = std::numeric_limits<Distortion>::max();
[313]	3213
	3214	xGetBlkBits( ePartSize, pcCU->getSlice()->isInterP(), iPartIdx, uiLastMode, uiMbBits);
[1029]	3215
[313]	3216	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
[1029]	3217
[313]	3218	#if AMP_MRG
	3219	Bool bTestNormalMC = true;
[1029]	3220
[313]	3221	if ( bUseMRG && pcCU->getWidth( 0 ) > 8 && iNumPart == 2 )
	3222	{
	3223	bTestNormalMC = false;
	3224	}
[1029]	3225
[313]	3226	if (bTestNormalMC)
	3227	{
	3228	#endif
	3229
[815]	3230	#if SVC_EXTENSION
	3231	Bool doneUniPred = false;
	3232	#endif
	3233
[313]	3234	// Uni-directional prediction
	3235	for ( Int iRefList = 0; iRefList < iNumPredDir; iRefList++ )
	3236	{
	3237	RefPicList eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
[1029]	3238
[313]	3239	for ( Int iRefIdxTemp = 0; iRefIdxTemp < pcCU->getSlice()->getNumRefIdx(eRefPicList); iRefIdxTemp++ )
	3240	{
[815]	3241	#if SVC_EXTENSION
	3242	TComPic* pcPic = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxTemp );
	3243
	3244	// motion search only for the ILRP with sample prediction type
[1057]	3245	if( pcPic->isILR( pcCU->getLayerId() ) && !pcCU->getSlice()->getVPS()->isSamplePredictionType( pcCU->getLayerIdx(), pcPic->getLayerIdx() ) )
[815]	3246	{
	3247	continue;
	3248	}
	3249
[442]	3250	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
[815]	3251	if( pcPic->isILR(pcCU->getLayerId()) && m_disableILP )
[442]	3252	{
	3253	continue;
	3254	}
	3255	#endif
[1029]	3256	#if ENCODER_FAST_MODE
[313]	3257	if( pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N) )
	3258	{
	3259	continue;
	3260	}
	3261	#endif
[815]	3262	doneUniPred = true;
	3263	#endif
[313]	3264
	3265	uiBitsTemp = uiMbBits[iRefList];
	3266	if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 )
	3267	{
	3268	uiBitsTemp += iRefIdxTemp+1;
	3269	if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
	3270	}
[1029]	3271
[313]	3272	xEstimateMvPredAMVP( pcCU, pcOrgYuv, iPartIdx, eRefPicList, iRefIdxTemp, cMvPred[iRefList][iRefIdxTemp], false, &biPDistTemp);
[1029]	3273
[313]	3274	aaiMvpIdx[iRefList][iRefIdxTemp] = pcCU->getMVPIdx(eRefPicList, uiPartAddr);
	3275	aaiMvpNum[iRefList][iRefIdxTemp] = pcCU->getMVPNum(eRefPicList, uiPartAddr);
[1029]	3276
[313]	3277	if(pcCU->getSlice()->getMvdL1ZeroFlag() && iRefList==1 && biPDistTemp < bestBiPDist)
	3278	{
	3279	#if REF_IDX_ME_ZEROMV
	3280	Bool bZeroMVILR = pcCU->xCheckZeroMVILRMvdL1Zero(iRefList, iRefIdxTemp, aaiMvpIdx[iRefList][iRefIdxTemp]);
	3281	if(bZeroMVILR)
	3282	{
	3283	#endif
	3284	bestBiPDist = biPDistTemp;
	3285	bestBiPMvpL1 = aaiMvpIdx[iRefList][iRefIdxTemp];
	3286	bestBiPRefIdxL1 = iRefIdxTemp;
	3287	#if REF_IDX_ME_ZEROMV
	3288	}
	3289	#endif
	3290	}
	3291
	3292	uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
	3293
	3294	#if GPB_SIMPLE_UNI
	3295	if ( iRefList == 1 ) // list 1
	3296	{
	3297	if ( pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) >= 0 )
	3298	{
	3299	cMvTemp[1][iRefIdxTemp] = cMvTemp[0][pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
	3300	uiCostTemp = uiCostTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )];
	3301	/first subtract the bit-rate part of the cost of the other list/
	3302	uiCostTemp -= m_pcRdCost->getCost( uiBitsTempL0[pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp )] );
	3303	/correct the bit-rate part of the current ref/
	3304	m_pcRdCost->setPredictor ( cMvPred[iRefList][iRefIdxTemp] );
	3305	uiBitsTemp += m_pcRdCost->getBits( cMvTemp[1][iRefIdxTemp].getHor(), cMvTemp[1][iRefIdxTemp].getVer() );
	3306	/calculate the correct cost/
	3307	uiCostTemp += m_pcRdCost->getCost( uiBitsTemp );
	3308	}
	3309	else
	3310	{
	3311	xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
	3312	}
	3313	}
	3314	else
	3315	{
	3316	xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
	3317	}
	3318	#else
	3319	xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
	3320	#endif
	3321	xCopyAMVPInfo(pcCU->getCUMvField(eRefPicList)->getAMVPInfo(), &aacAMVPInfo[iRefList][iRefIdxTemp]); // must always be done ( also when AMVP_MODE = AM_NONE )
	3322	xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
	3323
	3324	if ( iRefList == 0 )
	3325	{
	3326	uiCostTempL0[iRefIdxTemp] = uiCostTemp;
	3327	uiBitsTempL0[iRefIdxTemp] = uiBitsTemp;
	3328	}
	3329	if ( uiCostTemp < uiCost[iRefList] )
	3330	{
	3331	uiCost[iRefList] = uiCostTemp;
	3332	uiBits[iRefList] = uiBitsTemp; // storing for bi-prediction
	3333
	3334	// set motion
	3335	cMv[iRefList] = cMvTemp[iRefList][iRefIdxTemp];
	3336	iRefIdx[iRefList] = iRefIdxTemp;
	3337	}
	3338
	3339	if ( iRefList == 1 && uiCostTemp < costValidList1 && pcCU->getSlice()->getList1IdxToList0Idx( iRefIdxTemp ) < 0 )
	3340	{
	3341	costValidList1 = uiCostTemp;
	3342	bitsValidList1 = uiBitsTemp;
	3343
	3344	// set motion
	3345	mvValidList1 = cMvTemp[iRefList][iRefIdxTemp];
	3346	refIdxValidList1 = iRefIdxTemp;
	3347	}
	3348	}
	3349	}
[815]	3350
	3351	#if SVC_EXTENSION
	3352	if( pcCU->getLayerId() && !doneUniPred )
	3353	{
	3354	// there is no valid reference pictures for inter prediction
	3355	return false;
	3356	}
	3357	#endif
	3358
[313]	3359	// Bi-directional prediction
	3360	#if REF_IDX_ME_ZEROMV
	3361	if ( (pcCU->getSlice()->isInterB()) && (pcCU->isBipredRestriction(iPartIdx) == false) && !(pcCU->getSlice()->getMvdL1ZeroFlag() && bestBiPDist == MAX_INT) )
	3362	#else
	3363	if ( (pcCU->getSlice()->isInterB()) && (pcCU->isBipredRestriction(iPartIdx) == false) )
	3364	#endif
	3365	{
[1029]	3366
[313]	3367	cMvBi[0] = cMv[0]; cMvBi[1] = cMv[1];
	3368	iRefIdxBi[0] = iRefIdx[0]; iRefIdxBi[1] = iRefIdx[1];
[1029]	3369
[313]	3370	::memcpy(cMvPredBi, cMvPred, sizeof(cMvPred));
	3371	::memcpy(aaiMvpIdxBi, aaiMvpIdx, sizeof(aaiMvpIdx));
[1029]	3372
[313]	3373	UInt uiMotBits[2];
	3374
	3375	if(pcCU->getSlice()->getMvdL1ZeroFlag())
	3376	{
	3377	xCopyAMVPInfo(&aacAMVPInfo[1][bestBiPRefIdxL1], pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
	3378	pcCU->setMVPIdxSubParts( bestBiPMvpL1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3379	aaiMvpIdxBi[1][bestBiPRefIdxL1] = bestBiPMvpL1;
	3380	cMvPredBi[1][bestBiPRefIdxL1] = pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo()->m_acMvCand[bestBiPMvpL1];
	3381
	3382	cMvBi[1] = cMvPredBi[1][bestBiPRefIdxL1];
	3383	iRefIdxBi[1] = bestBiPRefIdxL1;
	3384	pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMv( cMvBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
	3385	pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllRefIdx( iRefIdxBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3386	TComYuv* pcYuvPred = &m_acYuvPred[REF_PIC_LIST_1];
[313]	3387	motionCompensation( pcCU, pcYuvPred, REF_PIC_LIST_1, iPartIdx );
	3388
	3389	uiMotBits[0] = uiBits[0] - uiMbBits[0];
	3390	uiMotBits[1] = uiMbBits[1];
	3391
	3392	if ( pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1) > 1 )
	3393	{
	3394	uiMotBits[1] += bestBiPRefIdxL1+1;
	3395	if ( bestBiPRefIdxL1 == pcCU->getSlice()->getNumRefIdx(REF_PIC_LIST_1)-1 ) uiMotBits[1]--;
	3396	}
	3397
	3398	uiMotBits[1] += m_auiMVPIdxCost[aaiMvpIdxBi[1][bestBiPRefIdxL1]][AMVP_MAX_NUM_CANDS];
	3399
	3400	uiBits[2] = uiMbBits[2] + uiMotBits[0] + uiMotBits[1];
	3401
	3402	cMvTemp[1][bestBiPRefIdxL1] = cMvBi[1];
	3403	}
	3404	else
	3405	{
	3406	uiMotBits[0] = uiBits[0] - uiMbBits[0];
	3407	uiMotBits[1] = uiBits[1] - uiMbBits[1];
	3408	uiBits[2] = uiMbBits[2] + uiMotBits[0] + uiMotBits[1];
	3409	}
	3410
	3411	// 4-times iteration (default)
	3412	Int iNumIter = 4;
[1029]	3413
[313]	3414	// fast encoder setting: only one iteration
	3415	if ( m_pcEncCfg->getUseFastEnc() \|\| pcCU->getSlice()->getMvdL1ZeroFlag())
	3416	{
	3417	iNumIter = 1;
	3418	}
[1029]	3419
[313]	3420	for ( Int iIter = 0; iIter < iNumIter; iIter++ )
	3421	{
	3422	Int iRefList = iIter % 2;
[1029]	3423
[313]	3424	if ( m_pcEncCfg->getUseFastEnc() )
	3425	{
	3426	if( uiCost[0] <= uiCost[1] )
	3427	{
	3428	iRefList = 1;
	3429	}
	3430	else
	3431	{
	3432	iRefList = 0;
	3433	}
	3434	}
	3435	else if ( iIter == 0 )
	3436	{
	3437	iRefList = 0;
	3438	}
	3439	if ( iIter == 0 && !pcCU->getSlice()->getMvdL1ZeroFlag())
	3440	{
	3441	pcCU->getCUMvField(RefPicList(1-iRefList))->setAllMv( cMv[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
	3442	pcCU->getCUMvField(RefPicList(1-iRefList))->setAllRefIdx( iRefIdx[1-iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
	3443	TComYuv* pcYuvPred = &m_acYuvPred[1-iRefList];
	3444	motionCompensation ( pcCU, pcYuvPred, RefPicList(1-iRefList), iPartIdx );
	3445	}
[1029]	3446
[313]	3447	RefPicList eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
	3448
	3449	if(pcCU->getSlice()->getMvdL1ZeroFlag())
	3450	{
	3451	iRefList = 0;
	3452	eRefPicList = REF_PIC_LIST_0;
	3453	}
	3454
	3455	Bool bChanged = false;
	3456
[1029]	3457	#if ENCODER_FAST_MODE
[313]	3458	Bool testIter = true;
	3459	TComPic* pcPic = pcCU->getSlice()->getRefPic( RefPicList(1 - iRefList), iRefIdxBi[1 - iRefList] );
	3460	if(pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N))
	3461	{
	3462	testIter = false; //the fixed part is ILR, skip this iteration
	3463	}
[442]	3464	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
[494]	3465	if (pcPic->isILR(pcCU->getLayerId()) && m_disableILP)
[442]	3466	{
	3467	testIter = false;
	3468	}
	3469	#endif
[313]	3470	if(testIter)
	3471	{
	3472	#endif
	3473	iRefStart = 0;
	3474	iRefEnd = pcCU->getSlice()->getNumRefIdx(eRefPicList)-1;
[1029]	3475
[313]	3476	for ( Int iRefIdxTemp = iRefStart; iRefIdxTemp <= iRefEnd; iRefIdxTemp++ )
	3477	{
[1029]	3478	#if ENCODER_FAST_MODE
[313]	3479	Bool testRefIdx = true;
[815]	3480	pcPic = pcCU->getSlice()->getRefPic( RefPicList(iRefList) , iRefIdxTemp );
	3481
	3482	// motion search only for the ILRP with sample prediction type
[1057]	3483	if( pcPic->isILR( pcCU->getLayerId() ) && !pcCU->getSlice()->getVPS()->isSamplePredictionType( pcCU->getLayerIdx(), pcPic->getLayerIdx() ) )
[815]	3484	{
	3485	continue;
	3486	}
	3487
[313]	3488	if(pcPic->isILR(pcCU->getLayerId()) && (ePartSize == SIZE_2Nx2N))
	3489	{
	3490	testRefIdx = false; //the refined part is ILR, skip this reference pic
	3491	}
[442]	3492	#if N0383_IL_CONSTRAINED_TILE_SETS_SEI
[494]	3493	if (pcPic->isILR(pcCU->getLayerId()) && m_disableILP)
[442]	3494	{
	3495	testRefIdx = false;
	3496	}
	3497	#endif
[313]	3498	if(testRefIdx)
	3499	{
	3500	#endif
	3501	uiBitsTemp = uiMbBits[2] + uiMotBits[1-iRefList];
	3502	if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 )
	3503	{
	3504	uiBitsTemp += iRefIdxTemp+1;
	3505	if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
	3506	}
	3507	uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdxBi[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
	3508	// call ME
	3509	xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPredBi[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp, true );
[1029]	3510
[313]	3511	xCopyAMVPInfo(&aacAMVPInfo[iRefList][iRefIdxTemp], pcCU->getCUMvField(eRefPicList)->getAMVPInfo());
	3512	xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPredBi[iRefList][iRefIdxTemp], aaiMvpIdxBi[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
	3513
	3514	if ( uiCostTemp < uiCostBi )
	3515	{
	3516	bChanged = true;
[1029]	3517
[313]	3518	cMvBi[iRefList] = cMvTemp[iRefList][iRefIdxTemp];
	3519	iRefIdxBi[iRefList] = iRefIdxTemp;
[1029]	3520
[313]	3521	uiCostBi = uiCostTemp;
	3522	uiMotBits[iRefList] = uiBitsTemp - uiMbBits[2] - uiMotBits[1-iRefList];
	3523	uiBits[2] = uiBitsTemp;
[1029]	3524
[313]	3525	if(iNumIter!=1)
	3526	{
	3527	// Set motion
	3528	pcCU->getCUMvField( eRefPicList )->setAllMv( cMvBi[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
	3529	pcCU->getCUMvField( eRefPicList )->setAllRefIdx( iRefIdxBi[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
	3530
	3531	TComYuv* pcYuvPred = &m_acYuvPred[iRefList];
	3532	motionCompensation( pcCU, pcYuvPred, eRefPicList, iPartIdx );
	3533	}
	3534	}
	3535	#if (ENCODER_FAST_MODE)
	3536	}
	3537	#endif
	3538	}
	3539	#if (ENCODER_FAST_MODE)
	3540	} // for loop-iRefIdxTemp
	3541	#endif
	3542
	3543	if ( !bChanged )
	3544	{
	3545	if ( uiCostBi <= uiCost[0] && uiCostBi <= uiCost[1] )
	3546	{
	3547	xCopyAMVPInfo(&aacAMVPInfo[0][iRefIdxBi[0]], pcCU->getCUMvField(REF_PIC_LIST_0)->getAMVPInfo());
	3548	xCheckBestMVP(pcCU, REF_PIC_LIST_0, cMvBi[0], cMvPredBi[0][iRefIdxBi[0]], aaiMvpIdxBi[0][iRefIdxBi[0]], uiBits[2], uiCostBi);
	3549	if(!pcCU->getSlice()->getMvdL1ZeroFlag())
	3550	{
	3551	xCopyAMVPInfo(&aacAMVPInfo[1][iRefIdxBi[1]], pcCU->getCUMvField(REF_PIC_LIST_1)->getAMVPInfo());
	3552	xCheckBestMVP(pcCU, REF_PIC_LIST_1, cMvBi[1], cMvPredBi[1][iRefIdxBi[1]], aaiMvpIdxBi[1][iRefIdxBi[1]], uiBits[2], uiCostBi);
	3553	}
	3554	}
	3555	break;
	3556	}
	3557	} // for loop-iter
	3558	} // if (B_SLICE)
	3559
	3560	#if AMP_MRG
	3561	} //end if bTestNormalMC
	3562	#endif
	3563	// Clear Motion Field
	3564	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx );
	3565	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx );
	3566	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd ( cMvZero, ePartSize, uiPartAddr, 0, iPartIdx );
	3567	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd ( cMvZero, ePartSize, uiPartAddr, 0, iPartIdx );
	3568
	3569	pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3570	pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3571	pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3572	pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
[1029]	3573
[313]	3574	UInt uiMEBits = 0;
	3575	// Set Motion Field_
	3576	cMv[1] = mvValidList1;
	3577	iRefIdx[1] = refIdxValidList1;
	3578	uiBits[1] = bitsValidList1;
	3579	uiCost[1] = costValidList1;
[1029]	3580
[313]	3581	#if AMP_MRG
	3582	if (bTestNormalMC)
	3583	{
	3584	#endif
	3585	if ( uiCostBi <= uiCost[0] && uiCostBi <= uiCost[1])
	3586	{
	3587	uiLastMode = 2;
[540]	3588	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv( cMvBi[0], ePartSize, uiPartAddr, 0, iPartIdx );
	3589	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdxBi[0], ePartSize, uiPartAddr, 0, iPartIdx );
	3590	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv( cMvBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
	3591	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdxBi[1], ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3592
[540]	3593	TempMv = cMvBi[0] - cMvPredBi[0][iRefIdxBi[0]];
	3594	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd ( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3595
[540]	3596	TempMv = cMvBi[1] - cMvPredBi[1][iRefIdxBi[1]];
	3597	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd ( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3598
[313]	3599	pcCU->setInterDirSubParts( 3, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
[1029]	3600
[313]	3601	pcCU->setMVPIdxSubParts( aaiMvpIdxBi[0][iRefIdxBi[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3602	pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdxBi[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3603	pcCU->setMVPIdxSubParts( aaiMvpIdxBi[1][iRefIdxBi[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3604	pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdxBi[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3605
	3606	uiMEBits = uiBits[2];
	3607	}
	3608	else if ( uiCost[0] <= uiCost[1] )
	3609	{
	3610	uiLastMode = 0;
[540]	3611	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv( cMv[0], ePartSize, uiPartAddr, 0, iPartIdx );
	3612	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdx[0], ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3613
[540]	3614	TempMv = cMv[0] - cMvPred[0][iRefIdx[0]];
	3615	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd ( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3616
[313]	3617	pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
[1029]	3618
[313]	3619	pcCU->setMVPIdxSubParts( aaiMvpIdx[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3620	pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3621
	3622	uiMEBits = uiBits[0];
	3623	}
	3624	else
	3625	{
	3626	uiLastMode = 1;
[540]	3627	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv( cMv[1], ePartSize, uiPartAddr, 0, iPartIdx );
	3628	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdx[1], ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3629
[540]	3630	TempMv = cMv[1] - cMvPred[1][iRefIdx[1]];
	3631	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd ( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
[1029]	3632
[313]	3633	pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
[1029]	3634
[313]	3635	pcCU->setMVPIdxSubParts( aaiMvpIdx[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3636	pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3637
	3638	uiMEBits = uiBits[1];
	3639	}
	3640	#if AMP_MRG
	3641	} // end if bTestNormalMC
	3642	#endif
	3643
	3644	if ( pcCU->getPartitionSize( uiPartAddr ) != SIZE_2Nx2N )
	3645	{
[1029]	3646	UInt uiMRGInterDir = 0;
[313]	3647	TComMvField cMRGMvField[2];
	3648	UInt uiMRGIndex = 0;
	3649
	3650	UInt uiMEInterDir = 0;
	3651	TComMvField cMEMvField[2];
	3652
[1029]	3653	m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
	3654
[313]	3655	#if AMP_MRG
	3656	// calculate ME cost
[1029]	3657	Distortion uiMEError = std::numeric_limits<Distortion>::max();
	3658	Distortion uiMECost = std::numeric_limits<Distortion>::max();
[313]	3659
	3660	if (bTestNormalMC)
	3661	{
	3662	xGetInterPredictionError( pcCU, pcOrgYuv, iPartIdx, uiMEError, m_pcEncCfg->getUseHADME() );
	3663	uiMECost = uiMEError + m_pcRdCost->getCost( uiMEBits );
	3664	}
	3665	#else
	3666	// calculate ME cost
[1029]	3667	Distortion uiMEError = std::numeric_limits<Distortion>::max();
[313]	3668	xGetInterPredictionError( pcCU, pcOrgYuv, iPartIdx, uiMEError, m_pcEncCfg->getUseHADME() );
[1029]	3669	Distortion uiMECost = uiMEError + m_pcRdCost->getCost( uiMEBits );
	3670	#endif
[313]	3671	// save ME result.
	3672	uiMEInterDir = pcCU->getInterDir( uiPartAddr );
	3673	pcCU->getMvField( pcCU, uiPartAddr, REF_PIC_LIST_0, cMEMvField[0] );
	3674	pcCU->getMvField( pcCU, uiPartAddr, REF_PIC_LIST_1, cMEMvField[1] );
	3675
	3676	// find Merge result
[1029]	3677	Distortion uiMRGCost = std::numeric_limits<Distortion>::max();
	3678
[313]	3679	xMergeEstimation( pcCU, pcOrgYuv, iPartIdx, uiMRGInterDir, cMRGMvField, uiMRGIndex, uiMRGCost, cMvFieldNeighbours, uhInterDirNeighbours, numValidMergeCand);
[1029]	3680
[313]	3681	if ( uiMRGCost < uiMECost )
	3682	{
	3683	// set Merge result
	3684	pcCU->setMergeFlagSubParts ( true, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
	3685	pcCU->setMergeIndexSubParts( uiMRGIndex, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
	3686	pcCU->setInterDirSubParts ( uiMRGInterDir, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
[540]	3687	pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMRGMvField[0], ePartSize, uiPartAddr, 0, iPartIdx );
	3688	pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMRGMvField[1], ePartSize, uiPartAddr, 0, iPartIdx );
[313]	3689
	3690	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd ( cMvZero, ePartSize, uiPartAddr, 0, iPartIdx );
	3691	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd ( cMvZero, ePartSize, uiPartAddr, 0, iPartIdx );
	3692
	3693	pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3694	pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3695	pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3696	pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	3697	}
	3698	else
	3699	{
	3700	// set ME result
	3701	pcCU->setMergeFlagSubParts( false, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
	3702	pcCU->setInterDirSubParts ( uiMEInterDir, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
[540]	3703	pcCU->getCUMvField( REF_PIC_LIST_0 )->setAllMvField( cMEMvField[0], ePartSize, uiPartAddr, 0, iPartIdx );
	3704	pcCU->getCUMvField( REF_PIC_LIST_1 )->setAllMvField( cMEMvField[1], ePartSize, uiPartAddr, 0, iPartIdx );
[313]	3705	}
	3706	}
	3707
	3708	// MC
[1029]	3709	motionCompensation ( pcCU, pcPredYuv, REF_PIC_LIST_X, iPartIdx );
	3710
[313]	3711	} // end of for ( Int iPartIdx = 0; iPartIdx < iNumPart; iPartIdx++ )
	3712
	3713	setWpScalingDistParam( pcCU, -1, REF_PIC_LIST_X );
	3714
[815]	3715	#if SVC_EXTENSION
	3716	return true;
	3717	#else
[313]	3718	return;
[815]	3719	#endif
[313]	3720	}
	3721
[1029]	3722
[313]	3723	// AMVP
[1029]	3724	Void TEncSearch::xEstimateMvPredAMVP( TComDataCU* pcCU, TComYuv* pcOrgYuv, UInt uiPartIdx, RefPicList eRefPicList, Int iRefIdx, TComMv& rcMvPred, Bool bFilled, Distortion* puiDistBiP )
[313]	3725	{
[1029]	3726	AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
	3727
	3728	TComMv cBestMv;
	3729	Int iBestIdx = 0;
	3730	TComMv cZeroMv;
	3731	TComMv cMvPred;
	3732	Distortion uiBestCost = std::numeric_limits<Distortion>::max();
	3733	UInt uiPartAddr = 0;
	3734	Int iRoiWidth, iRoiHeight;
	3735	Int i;
	3736
[313]	3737	pcCU->getPartIndexAndSize( uiPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
	3738	// Fill the MV Candidates
	3739	if (!bFilled)
	3740	{
	3741	pcCU->fillMvpCand( uiPartIdx, uiPartAddr, eRefPicList, iRefIdx, pcAMVPInfo );
	3742	}
[1029]	3743
[313]	3744	// initialize Mvp index & Mvp
	3745	iBestIdx = 0;
	3746	cBestMv = pcAMVPInfo->m_acMvCand[0];
	3747	if (pcAMVPInfo->iN <= 1)
	3748	{
	3749	rcMvPred = cBestMv;
[1029]	3750
[313]	3751	pcCU->setMVPIdxSubParts( iBestIdx, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
	3752	pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
	3753
	3754	if(pcCU->getSlice()->getMvdL1ZeroFlag() && eRefPicList==REF_PIC_LIST_1)
	3755	{
	3756	(*puiDistBiP) = xGetTemplateCost( pcCU, uiPartIdx, uiPartAddr, pcOrgYuv, &m_cYuvPredTemp, rcMvPred, 0, AMVP_MAX_NUM_CANDS, eRefPicList, iRefIdx, iRoiWidth, iRoiHeight);
	3757	}
	3758	return;
	3759	}
[1029]	3760
[313]	3761	if (bFilled)
	3762	{
	3763	assert(pcCU->getMVPIdx(eRefPicList,uiPartAddr) >= 0);
	3764	rcMvPred = pcAMVPInfo->m_acMvCand[pcCU->getMVPIdx(eRefPicList,uiPartAddr)];
	3765	return;
	3766	}
[1029]	3767
[313]	3768	m_cYuvPredTemp.clear();
	3769	//-- Check Minimum Cost.
	3770	for ( i = 0 ; i < pcAMVPInfo->iN; i++)
	3771	{
[1029]	3772	Distortion uiTmpCost;
[313]	3773	uiTmpCost = xGetTemplateCost( pcCU, uiPartIdx, uiPartAddr, pcOrgYuv, &m_cYuvPredTemp, pcAMVPInfo->m_acMvCand[i], i, AMVP_MAX_NUM_CANDS, eRefPicList, iRefIdx, iRoiWidth, iRoiHeight);
	3774	if ( uiBestCost > uiTmpCost )
	3775	{
	3776	uiBestCost = uiTmpCost;
	3777	cBestMv = pcAMVPInfo->m_acMvCand[i];
	3778	iBestIdx = i;
	3779	(*puiDistBiP) = uiTmpCost;
	3780	}
	3781	}
	3782
	3783	m_cYuvPredTemp.clear();
[1029]	3784
[313]	3785	// Setting Best MVP
	3786	rcMvPred = cBestMv;
	3787	pcCU->setMVPIdxSubParts( iBestIdx, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
	3788	pcCU->setMVPNumSubParts( pcAMVPInfo->iN, eRefPicList, uiPartAddr, uiPartIdx, pcCU->getDepth(uiPartAddr));
	3789	return;
	3790	}
	3791
	3792	UInt TEncSearch::xGetMvpIdxBits(Int iIdx, Int iNum)
	3793	{
	3794	assert(iIdx >= 0 && iNum >= 0 && iIdx < iNum);
[1029]	3795
[313]	3796	if (iNum == 1)
[540]	3797	{
[313]	3798	return 0;
[540]	3799	}
[1029]	3800
[313]	3801	UInt uiLength = 1;
	3802	Int iTemp = iIdx;
	3803	if ( iTemp == 0 )
	3804	{
	3805	return uiLength;
	3806	}
[1029]	3807
[313]	3808	Bool bCodeLast = ( iNum-1 > iTemp );
[1029]	3809
[313]	3810	uiLength += (iTemp-1);
[1029]	3811
[313]	3812	if( bCodeLast )
	3813	{
	3814	uiLength++;
	3815	}
[1029]	3816
[313]	3817	return uiLength;
	3818	}
	3819
	3820	Void TEncSearch::xGetBlkBits( PartSize eCUMode, Bool bPSlice, Int iPartIdx, UInt uiLastMode, UInt uiBlkBit[3])
	3821	{
	3822	if ( eCUMode == SIZE_2Nx2N )
	3823	{
	3824	uiBlkBit[0] = (! bPSlice) ? 3 : 1;
	3825	uiBlkBit[1] = 3;
	3826	uiBlkBit[2] = 5;
	3827	}
	3828	else if ( (eCUMode == SIZE_2NxN \|\| eCUMode == SIZE_2NxnU) \|\| eCUMode == SIZE_2NxnD )
	3829	{
	3830	UInt aauiMbBits[2][3][3] = { { {0,0,3}, {0,0,0}, {0,0,0} } , { {5,7,7}, {7,5,7}, {9-3,9-3,9-3} } };
	3831	if ( bPSlice )
	3832	{
	3833	uiBlkBit[0] = 3;
	3834	uiBlkBit[1] = 0;
	3835	uiBlkBit[2] = 0;
	3836	}
	3837	else
	3838	{
	3839	::memcpy( uiBlkBit, aauiMbBits[iPartIdx][uiLastMode], 3*sizeof(UInt) );
	3840	}
	3841	}
	3842	else if ( (eCUMode == SIZE_Nx2N \|\| eCUMode == SIZE_nLx2N) \|\| eCUMode == SIZE_nRx2N )
	3843	{
	3844	UInt aauiMbBits[2][3][3] = { { {0,2,3}, {0,0,0}, {0,0,0} } , { {5,7,7}, {7-2,7-2,9-2}, {9-3,9-3,9-3} } };
	3845	if ( bPSlice )
	3846	{
	3847	uiBlkBit[0] = 3;
	3848	uiBlkBit[1] = 0;
	3849	uiBlkBit[2] = 0;
	3850	}
	3851	else
	3852	{
	3853	::memcpy( uiBlkBit, aauiMbBits[iPartIdx][uiLastMode], 3*sizeof(UInt) );
	3854	}
	3855	}
	3856	else if ( eCUMode == SIZE_NxN )
	3857	{
	3858	uiBlkBit[0] = (! bPSlice) ? 3 : 1;
	3859	uiBlkBit[1] = 3;
	3860	uiBlkBit[2] = 5;
	3861	}
	3862	else
	3863	{
	3864	printf("Wrong!\n");
	3865	assert( 0 );
	3866	}
	3867	}
	3868
	3869	Void TEncSearch::xCopyAMVPInfo (AMVPInfo* pSrc, AMVPInfo* pDst)
	3870	{
	3871	pDst->iN = pSrc->iN;
	3872	for (Int i = 0; i < pSrc->iN; i++)
	3873	{
	3874	pDst->m_acMvCand[i] = pSrc->m_acMvCand[i];
	3875	}
	3876	}
	3877
[1029]	3878	Void TEncSearch::xCheckBestMVP ( TComDataCU* pcCU, RefPicList eRefPicList, TComMv cMv, TComMv& rcMvPred, Int& riMVPIdx, UInt& ruiBits, Distortion& ruiCost )
[313]	3879	{
	3880	AMVPInfo* pcAMVPInfo = pcCU->getCUMvField(eRefPicList)->getAMVPInfo();
[1029]	3881
[313]	3882	assert(pcAMVPInfo->m_acMvCand[riMVPIdx] == rcMvPred);
[1029]	3883
[313]	3884	if (pcAMVPInfo->iN < 2) return;
[1029]	3885
	3886	m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(0) );
[313]	3887	m_pcRdCost->setCostScale ( 0 );
[1029]	3888
[313]	3889	Int iBestMVPIdx = riMVPIdx;
[1029]	3890
[313]	3891	m_pcRdCost->setPredictor( rcMvPred );
	3892	Int iOrgMvBits = m_pcRdCost->getBits(cMv.getHor(), cMv.getVer());
	3893	iOrgMvBits += m_auiMVPIdxCost[riMVPIdx][AMVP_MAX_NUM_CANDS];
	3894	Int iBestMvBits = iOrgMvBits;
[1029]	3895
[313]	3896	for (Int iMVPIdx = 0; iMVPIdx < pcAMVPInfo->iN; iMVPIdx++)
	3897	{
	3898	if (iMVPIdx == riMVPIdx) continue;
[1029]	3899
[313]	3900	m_pcRdCost->setPredictor( pcAMVPInfo->m_acMvCand[iMVPIdx] );
[1029]	3901
[313]	3902	Int iMvBits = m_pcRdCost->getBits(cMv.getHor(), cMv.getVer());
	3903	iMvBits += m_auiMVPIdxCost[iMVPIdx][AMVP_MAX_NUM_CANDS];
[1029]	3904
[313]	3905	if (iMvBits < iBestMvBits)
	3906	{
	3907	iBestMvBits = iMvBits;
	3908	iBestMVPIdx = iMVPIdx;
	3909	}
	3910	}
[1029]	3911
[313]	3912	if (iBestMVPIdx != riMVPIdx) //if changed
	3913	{
	3914	rcMvPred = pcAMVPInfo->m_acMvCand[iBestMVPIdx];
[1029]	3915
[313]	3916	riMVPIdx = iBestMVPIdx;
	3917	UInt uiOrgBits = ruiBits;
	3918	ruiBits = uiOrgBits - iOrgMvBits + iBestMvBits;
	3919	ruiCost = (ruiCost - m_pcRdCost->getCost( uiOrgBits )) + m_pcRdCost->getCost( ruiBits );
	3920	}
	3921	}
	3922
[1029]	3923
	3924	Distortion TEncSearch::xGetTemplateCost( TComDataCU* pcCU,
	3925	UInt uiPartIdx,
	3926	UInt uiPartAddr,
	3927	TComYuv* pcOrgYuv,
	3928	TComYuv* pcTemplateCand,
	3929	TComMv cMvCand,
	3930	Int iMVPIdx,
	3931	Int iMVPNum,
	3932	RefPicList eRefPicList,
	3933	Int iRefIdx,
	3934	Int iSizeX,
	3935	Int iSizeY
	3936	)
[313]	3937	{
[1029]	3938	Distortion uiCost = std::numeric_limits<Distortion>::max();
	3939
[313]	3940	TComPicYuv* pcPicYuvRef = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdx )->getPicYuvRec();
[1029]	3941
[313]	3942	pcCU->clipMv( cMvCand );
	3943
	3944	// prediction pattern
[494]	3945	#if O0194_WEIGHTED_PREDICTION_CGS
	3946	// Bug Fix (It did not check WP for BSlices)
	3947	if ( pcCU->getSlice()->getPPS()->getUseWP())
	3948	#else
[313]	3949	if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType()==P_SLICE )
[494]	3950	#endif
[313]	3951	{
[1029]	3952	xPredInterBlk( COMPONENT_Y, pcCU, pcPicYuvRef, uiPartAddr, &cMvCand, iSizeX, iSizeY, pcTemplateCand, true );
[313]	3953	}
	3954	else
	3955	{
[1029]	3956	xPredInterBlk( COMPONENT_Y, pcCU, pcPicYuvRef, uiPartAddr, &cMvCand, iSizeX, iSizeY, pcTemplateCand, false );
[313]	3957	}
	3958
[494]	3959	#if O0194_WEIGHTED_PREDICTION_CGS
	3960	if ( pcCU->getSlice()->getPPS()->getUseWP())
	3961	///< Bug Fix (It did not check WP for BSlices)
	3962	#else
[313]	3963	if ( pcCU->getSlice()->getPPS()->getUseWP() && pcCU->getSlice()->getSliceType()==P_SLICE )
[494]	3964	#endif
[313]	3965	{
	3966	xWeightedPredictionUni( pcCU, pcTemplateCand, uiPartAddr, iSizeX, iSizeY, eRefPicList, pcTemplateCand, iRefIdx );
	3967	}
	3968
	3969	// calc distortion
[1029]	3970
	3971	uiCost = m_pcRdCost->getDistPart( g_bitDepth[CHANNEL_TYPE_LUMA], pcTemplateCand->getAddr(COMPONENT_Y, uiPartAddr), pcTemplateCand->getStride(COMPONENT_Y), pcOrgYuv->getAddr(COMPONENT_Y, uiPartAddr), pcOrgYuv->getStride(COMPONENT_Y), iSizeX, iSizeY, COMPONENT_Y, DF_SAD );
[313]	3972	uiCost = (UInt) m_pcRdCost->calcRdCost( m_auiMVPIdxCost[iMVPIdx][iMVPNum], uiCost, false, DF_SAD );
	3973	return uiCost;
	3974	}
	3975
[1029]	3976
	3977
	3978
	3979	Void TEncSearch::xMotionEstimation( TComDataCU* pcCU, TComYuv* pcYuvOrg, Int iPartIdx, RefPicList eRefPicList, TComMv* pcMvPred, Int iRefIdxPred, TComMv& rcMv, UInt& ruiBits, Distortion& ruiCost, Bool bBi )
[313]	3980	{
	3981	UInt uiPartAddr;
	3982	Int iRoiWidth;
	3983	Int iRoiHeight;
[1029]	3984
[313]	3985	TComMv cMvHalf, cMvQter;
	3986	TComMv cMvSrchRngLT;
	3987	TComMv cMvSrchRngRB;
[1029]	3988
[313]	3989	TComYuv* pcYuv = pcYuvOrg;
[1029]	3990
	3991	assert(eRefPicList < MAX_NUM_REF_LIST_ADAPT_SR && iRefIdxPred<Int(MAX_IDX_ADAPT_SR));
[313]	3992	m_iSearchRange = m_aaiAdaptSR[eRefPicList][iRefIdxPred];
[1029]	3993
[313]	3994	Int iSrchRng = ( bBi ? m_bipredSearchRange : m_iSearchRange );
[1029]	3995	TComPattern tmpPattern;
	3996	TComPattern* pcPatternKey = &tmpPattern;
	3997
[313]	3998	Double fWeight = 1.0;
[1029]	3999
[313]	4000	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
[1029]	4001
[313]	4002	if ( bBi )
	4003	{
	4004	TComYuv* pcYuvOther = &m_acYuvPred[1-(Int)eRefPicList];
	4005	pcYuv = &m_cYuvPredTemp;
[1029]	4006
[313]	4007	pcYuvOrg->copyPartToPartYuv( pcYuv, uiPartAddr, iRoiWidth, iRoiHeight );
[1029]	4008
[313]	4009	pcYuv->removeHighFreq( pcYuvOther, uiPartAddr, iRoiWidth, iRoiHeight );
[1029]	4010
[313]	4011	fWeight = 0.5;
	4012	}
[1029]	4013
[313]	4014	// Search key pattern initialization
[1029]	4015	pcPatternKey->initPattern( pcYuv->getAddr ( COMPONENT_Y, uiPartAddr ),
	4016	iRoiWidth,
	4017	iRoiHeight,
	4018	pcYuv->getStride(COMPONENT_Y) );
	4019
	4020	Pel* piRefY = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->getPicYuvRec()->getAddr( COMPONENT_Y, pcCU->getCtuRsAddr(), pcCU->getZorderIdxInCtu() + uiPartAddr );
	4021	Int iRefStride = pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->getPicYuvRec()->getStride(COMPONENT_Y);
	4022
[313]	4023	TComMv cMvPred = *pcMvPred;
[1029]	4024
[313]	4025	if ( bBi ) xSetSearchRange ( pcCU, rcMv , iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
	4026	else xSetSearchRange ( pcCU, cMvPred, iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
[1029]	4027
	4028	m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
	4029
[313]	4030	m_pcRdCost->setPredictor ( *pcMvPred );
	4031	m_pcRdCost->setCostScale ( 2 );
	4032
	4033	setWpScalingDistParam( pcCU, iRefIdxPred, eRefPicList );
	4034	// Do integer search
	4035	#if REF_IDX_ME_ZEROMV
	4036	if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR(pcCU->getLayerId())) //ILR reference pic
	4037	{
	4038	rcMv.setZero(); //use Mv(0, 0) for integer ME
	4039	}
	4040	else //non ILR reference pic
	4041	{
[1029]	4042	#endif
	4043
[313]	4044	if ( !m_iFastSearch \|\| bBi )
	4045	{
	4046	xPatternSearch ( pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost );
	4047	}
	4048	else
	4049	{
	4050	rcMv = *pcMvPred;
[1029]	4051	const TComMv *pIntegerMv2Nx2NPred=0;
	4052	if (pcCU->getPartitionSize(0) != SIZE_2Nx2N \|\| pcCU->getDepth(0) != 0)
	4053	{
	4054	pIntegerMv2Nx2NPred = &(m_integerMv2Nx2N[eRefPicList][iRefIdxPred]);
	4055	}
	4056	xPatternSearchFast ( pcCU, pcPatternKey, piRefY, iRefStride, &cMvSrchRngLT, &cMvSrchRngRB, rcMv, ruiCost, pIntegerMv2Nx2NPred );
	4057	if (pcCU->getPartitionSize(0) == SIZE_2Nx2N)
	4058	{
	4059	m_integerMv2Nx2N[eRefPicList][iRefIdxPred] = rcMv;
	4060	}
[313]	4061	}
[1029]	4062	#if REF_IDX_ME_ZEROMV
	4063	}
[313]	4064	#endif
	4065
[1029]	4066	m_pcRdCost->getMotionCost( true, 0, pcCU->getCUTransquantBypass(uiPartAddr) );
[313]	4067	m_pcRdCost->setCostScale ( 1 );
[540]	4068
[1029]	4069	const Bool bIsLosslessCoded = pcCU->getCUTransquantBypass(uiPartAddr) != 0;
	4070
[540]	4071	#if REF_IDX_ME_ZEROMV
	4072	if( pcCU->getSlice()->getRefPic( eRefPicList, iRefIdxPred )->isILR(pcCU->getLayerId())) //ILR reference pic
[313]	4073	{
[1029]	4074	xPatternSearchFracDIFMv0( pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost );
[540]	4075	}
	4076	else //non ILR reference pic
[313]	4077	#endif
[1029]	4078	xPatternSearchFracDIF( bIsLosslessCoded, pcPatternKey, piRefY, iRefStride, &rcMv, cMvHalf, cMvQter, ruiCost ,bBi );
[540]	4079
[313]	4080	m_pcRdCost->setCostScale( 0 );
	4081	rcMv <<= 2;
	4082	rcMv += (cMvHalf <<= 1);
	4083	rcMv += cMvQter;
[1029]	4084
[313]	4085	UInt uiMvBits = m_pcRdCost->getBits( rcMv.getHor(), rcMv.getVer() );
[1029]	4086
[313]	4087	ruiBits += uiMvBits;
[1029]	4088	ruiCost = (Distortion)( floor( fWeight * ( (Double)ruiCost - (Double)m_pcRdCost->getCost( uiMvBits ) ) ) + (Double)m_pcRdCost->getCost( ruiBits ) );
[313]	4089	}
	4090
	4091
[1029]	4092
	4093
[313]	4094	Void TEncSearch::xSetSearchRange ( TComDataCU* pcCU, TComMv& cMvPred, Int iSrchRng, TComMv& rcMvSrchRngLT, TComMv& rcMvSrchRngRB )
	4095	{
	4096	Int iMvShift = 2;
	4097	TComMv cTmpMvPred = cMvPred;
	4098	pcCU->clipMv( cTmpMvPred );
	4099
	4100	rcMvSrchRngLT.setHor( cTmpMvPred.getHor() - (iSrchRng << iMvShift) );
	4101	rcMvSrchRngLT.setVer( cTmpMvPred.getVer() - (iSrchRng << iMvShift) );
[1029]	4102
[313]	4103	rcMvSrchRngRB.setHor( cTmpMvPred.getHor() + (iSrchRng << iMvShift) );
	4104	rcMvSrchRngRB.setVer( cTmpMvPred.getVer() + (iSrchRng << iMvShift) );
	4105	pcCU->clipMv ( rcMvSrchRngLT );
	4106	pcCU->clipMv ( rcMvSrchRngRB );
[1029]	4107
[313]	4108	rcMvSrchRngLT >>= iMvShift;
	4109	rcMvSrchRngRB >>= iMvShift;
	4110	}
	4111
[1029]	4112
	4113
	4114
	4115	Void TEncSearch::xPatternSearch( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, TComMv* pcMvSrchRngLT, TComMv* pcMvSrchRngRB, TComMv& rcMv, Distortion& ruiSAD )
[313]	4116	{
	4117	Int iSrchRngHorLeft = pcMvSrchRngLT->getHor();
	4118	Int iSrchRngHorRight = pcMvSrchRngRB->getHor();
	4119	Int iSrchRngVerTop = pcMvSrchRngLT->getVer();
	4120	Int iSrchRngVerBottom = pcMvSrchRngRB->getVer();
[1029]	4121
	4122	Distortion uiSad;
	4123	Distortion uiSadBest = std::numeric_limits<Distortion>::max();
	4124	Int iBestX = 0;
	4125	Int iBestY = 0;
	4126
[313]	4127	Pel* piRefSrch;
[1029]	4128
[313]	4129	//-- jclee for using the SAD function pointer
	4130	m_pcRdCost->setDistParam( pcPatternKey, piRefY, iRefStride, m_cDistParam );
[1029]	4131
[313]	4132	// fast encoder decision: use subsampled SAD for integer ME
	4133	if ( m_pcEncCfg->getUseFastEnc() )
	4134	{
	4135	if ( m_cDistParam.iRows > 8 )
	4136	{
	4137	m_cDistParam.iSubShift = 1;
	4138	}
	4139	}
[1029]	4140
[313]	4141	piRefY += (iSrchRngVerTop * iRefStride);
	4142	for ( Int y = iSrchRngVerTop; y <= iSrchRngVerBottom; y++ )
	4143	{
	4144	for ( Int x = iSrchRngHorLeft; x <= iSrchRngHorRight; x++ )
	4145	{
	4146	// find min. distortion position
	4147	piRefSrch = piRefY + x;
	4148	m_cDistParam.pCur = piRefSrch;
	4149
[1029]	4150	setDistParamComp(COMPONENT_Y);
[313]	4151
[1029]	4152	m_cDistParam.bitDepth = g_bitDepth[CHANNEL_TYPE_LUMA];
[313]	4153	uiSad = m_cDistParam.DistFunc( &m_cDistParam );
[1029]	4154
[313]	4155	// motion cost
	4156	uiSad += m_pcRdCost->getCost( x, y );
[1029]	4157
[313]	4158	if ( uiSad < uiSadBest )
	4159	{
	4160	uiSadBest = uiSad;
	4161	iBestX = x;
	4162	iBestY = y;
	4163	}
	4164	}
	4165	piRefY += iRefStride;
	4166	}
[1029]	4167
[313]	4168	rcMv.set( iBestX, iBestY );
[1029]	4169
[313]	4170	ruiSAD = uiSadBest - m_pcRdCost->getCost( iBestX, iBestY );
	4171	return;
	4172	}
	4173
[1029]	4174
	4175
	4176	Void TEncSearch::xPatternSearchFast( TComDataCU* pcCU,
	4177	TComPattern* pcPatternKey,
	4178	Pel* piRefY,
	4179	Int iRefStride,
	4180	TComMv* pcMvSrchRngLT,
	4181	TComMv* pcMvSrchRngRB,
	4182	TComMv &rcMv,
	4183	Distortion &ruiSAD,
	4184	const TComMv* pIntegerMv2Nx2NPred )
[313]	4185	{
[1029]	4186	assert (MD_LEFT < NUM_MV_PREDICTORS);
	4187	pcCU->getMvPredLeft ( m_acMvPredictors[MD_LEFT] );
	4188	assert (MD_ABOVE < NUM_MV_PREDICTORS);
	4189	pcCU->getMvPredAbove ( m_acMvPredictors[MD_ABOVE] );
	4190	assert (MD_ABOVE_RIGHT < NUM_MV_PREDICTORS);
	4191	pcCU->getMvPredAboveRight ( m_acMvPredictors[MD_ABOVE_RIGHT] );
	4192
[313]	4193	switch ( m_iFastSearch )
	4194	{
	4195	case 1:
[1029]	4196	xTZSearch( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD, pIntegerMv2Nx2NPred );
[313]	4197	break;
[1029]	4198
	4199	case 2:
	4200	xTZSearchSelective( pcCU, pcPatternKey, piRefY, iRefStride, pcMvSrchRngLT, pcMvSrchRngRB, rcMv, ruiSAD, pIntegerMv2Nx2NPred );
	4201	break;
[313]	4202	default:
	4203	break;
	4204	}
	4205	}
	4206
[1029]	4207
	4208
	4209
	4210	Void TEncSearch::xTZSearch( TComDataCU* pcCU,
	4211	TComPattern* pcPatternKey,
	4212	Pel* piRefY,
	4213	Int iRefStride,
	4214	TComMv* pcMvSrchRngLT,
	4215	TComMv* pcMvSrchRngRB,
	4216	TComMv &rcMv,
	4217	Distortion &ruiSAD,
	4218	const TComMv* pIntegerMv2Nx2NPred )
[313]	4219	{
	4220	Int iSrchRngHorLeft = pcMvSrchRngLT->getHor();
	4221	Int iSrchRngHorRight = pcMvSrchRngRB->getHor();
	4222	Int iSrchRngVerTop = pcMvSrchRngLT->getVer();
	4223	Int iSrchRngVerBottom = pcMvSrchRngRB->getVer();
[1029]	4224
[313]	4225	TZ_SEARCH_CONFIGURATION
[1029]	4226
[313]	4227	UInt uiSearchRange = m_iSearchRange;
	4228	pcCU->clipMv( rcMv );
	4229	rcMv >>= 2;
	4230	// init TZSearchStruct
	4231	IntTZSearchStruct cStruct;
	4232	cStruct.iYStride = iRefStride;
	4233	cStruct.piRefY = piRefY;
	4234	cStruct.uiBestSad = MAX_UINT;
[1029]	4235
[313]	4236	// set rcMv (Median predictor) as start point and as best point
	4237	xTZSearchHelp( pcPatternKey, cStruct, rcMv.getHor(), rcMv.getVer(), 0, 0 );
[1029]	4238
[313]	4239	// test whether one of PRED_A, PRED_B, PRED_C MV is better start point than Median predictor
	4240	if ( bTestOtherPredictedMV )
	4241	{
[1029]	4242	for ( UInt index = 0; index < NUM_MV_PREDICTORS; index++ )
[313]	4243	{
	4244	TComMv cMv = m_acMvPredictors[index];
	4245	pcCU->clipMv( cMv );
	4246	cMv >>= 2;
	4247	xTZSearchHelp( pcPatternKey, cStruct, cMv.getHor(), cMv.getVer(), 0, 0 );
	4248	}
	4249	}
[1029]	4250
[313]	4251	// test whether zero Mv is better start point than Median predictor
	4252	if ( bTestZeroVector )
	4253	{
	4254	xTZSearchHelp( pcPatternKey, cStruct, 0, 0, 0, 0 );
	4255	}
[1029]	4256
	4257	if (pIntegerMv2Nx2NPred != 0)
	4258	{
	4259	TComMv integerMv2Nx2NPred = *pIntegerMv2Nx2NPred;
	4260	integerMv2Nx2NPred <<= 2;
	4261	pcCU->clipMv( integerMv2Nx2NPred );
	4262	integerMv2Nx2NPred >>= 2;
	4263	xTZSearchHelp(pcPatternKey, cStruct, integerMv2Nx2NPred.getHor(), integerMv2Nx2NPred.getVer(), 0, 0);
	4264
	4265	// reset search range
	4266	TComMv cMvSrchRngLT;
	4267	TComMv cMvSrchRngRB;
	4268	Int iSrchRng = m_iSearchRange;
	4269	TComMv currBestMv(cStruct.iBestX, cStruct.iBestY );
	4270	currBestMv <<= 2;
	4271	xSetSearchRange( pcCU, currBestMv, iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
	4272	iSrchRngHorLeft = cMvSrchRngLT.getHor();
	4273	iSrchRngHorRight = cMvSrchRngRB.getHor();
	4274	iSrchRngVerTop = cMvSrchRngLT.getVer();
	4275	iSrchRngVerBottom = cMvSrchRngRB.getVer();
	4276	}
	4277
[313]	4278	// start search
	4279	Int iDist = 0;
	4280	Int iStartX = cStruct.iBestX;
	4281	Int iStartY = cStruct.iBestY;
[1029]	4282
[313]	4283	// first search
	4284	for ( iDist = 1; iDist <= (Int)uiSearchRange; iDist*=2 )
	4285	{
	4286	if ( bFirstSearchDiamond == 1 )
	4287	{
	4288	xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4289	}
	4290	else
	4291	{
	4292	xTZ8PointSquareSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4293	}
[1029]	4294
[313]	4295	if ( bFirstSearchStop && ( cStruct.uiBestRound >= uiFirstSearchRounds ) ) // stop criterion
	4296	{
	4297	break;
	4298	}
	4299	}
[1029]	4300
[313]	4301	// test whether zero Mv is a better start point than Median predictor
	4302	if ( bTestZeroVectorStart && ((cStruct.iBestX != 0) \|\| (cStruct.iBestY != 0)) )
	4303	{
	4304	xTZSearchHelp( pcPatternKey, cStruct, 0, 0, 0, 0 );
	4305	if ( (cStruct.iBestX == 0) && (cStruct.iBestY == 0) )
	4306	{
	4307	// test its neighborhood
	4308	for ( iDist = 1; iDist <= (Int)uiSearchRange; iDist*=2 )
	4309	{
	4310	xTZ8PointDiamondSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, 0, 0, iDist );
	4311	if ( bTestZeroVectorStop && (cStruct.uiBestRound > 0) ) // stop criterion
	4312	{
	4313	break;
	4314	}
	4315	}
	4316	}
	4317	}
[1029]	4318
[313]	4319	// calculate only 2 missing points instead 8 points if cStruct.uiBestDistance == 1
	4320	if ( cStruct.uiBestDistance == 1 )
	4321	{
	4322	cStruct.uiBestDistance = 0;
	4323	xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
	4324	}
[1029]	4325
[313]	4326	// raster search if distance is too big
	4327	if ( bEnableRasterSearch && ( ((Int)(cStruct.uiBestDistance) > iRaster) \|\| bAlwaysRasterSearch ) )
	4328	{
	4329	cStruct.uiBestDistance = iRaster;
	4330	for ( iStartY = iSrchRngVerTop; iStartY <= iSrchRngVerBottom; iStartY += iRaster )
	4331	{
	4332	for ( iStartX = iSrchRngHorLeft; iStartX <= iSrchRngHorRight; iStartX += iRaster )
	4333	{
	4334	xTZSearchHelp( pcPatternKey, cStruct, iStartX, iStartY, 0, iRaster );
	4335	}
	4336	}
	4337	}
[1029]	4338
[313]	4339	// raster refinement
	4340	if ( bRasterRefinementEnable && cStruct.uiBestDistance > 0 )
	4341	{
	4342	while ( cStruct.uiBestDistance > 0 )
	4343	{
	4344	iStartX = cStruct.iBestX;
	4345	iStartY = cStruct.iBestY;
	4346	if ( cStruct.uiBestDistance > 1 )
	4347	{
	4348	iDist = cStruct.uiBestDistance >>= 1;
	4349	if ( bRasterRefinementDiamond == 1 )
	4350	{
	4351	xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4352	}
	4353	else
	4354	{
	4355	xTZ8PointSquareSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4356	}
	4357	}
[1029]	4358
[313]	4359	// calculate only 2 missing points instead 8 points if cStruct.uiBestDistance == 1
	4360	if ( cStruct.uiBestDistance == 1 )
	4361	{
	4362	cStruct.uiBestDistance = 0;
	4363	if ( cStruct.ucPointNr != 0 )
	4364	{
	4365	xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
	4366	}
	4367	}
	4368	}
	4369	}
[1029]	4370
[313]	4371	// start refinement
	4372	if ( bStarRefinementEnable && cStruct.uiBestDistance > 0 )
	4373	{
	4374	while ( cStruct.uiBestDistance > 0 )
	4375	{
	4376	iStartX = cStruct.iBestX;
	4377	iStartY = cStruct.iBestY;
	4378	cStruct.uiBestDistance = 0;
	4379	cStruct.ucPointNr = 0;
	4380	for ( iDist = 1; iDist < (Int)uiSearchRange + 1; iDist*=2 )
	4381	{
	4382	if ( bStarRefinementDiamond == 1 )
	4383	{
	4384	xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4385	}
	4386	else
	4387	{
	4388	xTZ8PointSquareSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4389	}
	4390	if ( bStarRefinementStop && (cStruct.uiBestRound >= uiStarRefinementRounds) ) // stop criterion
	4391	{
	4392	break;
	4393	}
	4394	}
[1029]	4395
[313]	4396	// calculate only 2 missing points instead 8 points if cStrukt.uiBestDistance == 1
	4397	if ( cStruct.uiBestDistance == 1 )
	4398	{
	4399	cStruct.uiBestDistance = 0;
	4400	if ( cStruct.ucPointNr != 0 )
	4401	{
	4402	xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
	4403	}
	4404	}
	4405	}
	4406	}
[1029]	4407
[313]	4408	// write out best match
	4409	rcMv.set( cStruct.iBestX, cStruct.iBestY );
	4410	ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCost( cStruct.iBestX, cStruct.iBestY );
	4411	}
	4412
[1029]	4413
	4414	Void TEncSearch::xTZSearchSelective( TComDataCU* pcCU,
	4415	TComPattern* pcPatternKey,
	4416	Pel* piRefY,
	4417	Int iRefStride,
	4418	TComMv* pcMvSrchRngLT,
	4419	TComMv* pcMvSrchRngRB,
	4420	TComMv &rcMv,
	4421	Distortion &ruiSAD,
	4422	const TComMv* pIntegerMv2Nx2NPred )
	4423	{
	4424	SEL_SEARCH_CONFIGURATION
	4425
	4426	Int iSrchRngHorLeft = pcMvSrchRngLT->getHor();
	4427	Int iSrchRngHorRight = pcMvSrchRngRB->getHor();
	4428	Int iSrchRngVerTop = pcMvSrchRngLT->getVer();
	4429	Int iSrchRngVerBottom = pcMvSrchRngRB->getVer();
	4430	Int iFirstSrchRngHorLeft = 0;
	4431	Int iFirstSrchRngHorRight = 0;
	4432	Int iFirstSrchRngVerTop = 0;
	4433	Int iFirstSrchRngVerBottom = 0;
	4434	Int iStartX = 0;
	4435	Int iStartY = 0;
	4436	Int iBestX = 0;
	4437	Int iBestY = 0;
	4438	Int iDist = 0;
	4439
	4440	pcCU->clipMv( rcMv );
	4441	rcMv >>= 2;
	4442	// init TZSearchStruct
	4443	IntTZSearchStruct cStruct;
	4444	cStruct.iYStride = iRefStride;
	4445	cStruct.piRefY = piRefY;
	4446	cStruct.uiBestSad = MAX_UINT;
	4447	cStruct.iBestX = 0;
	4448	cStruct.iBestY = 0;
	4449
	4450
	4451	// set rcMv (Median predictor) as start point and as best point
	4452	xTZSearchHelp( pcPatternKey, cStruct, rcMv.getHor(), rcMv.getVer(), 0, 0 );
	4453
	4454	// test whether one of PRED_A, PRED_B, PRED_C MV is better start point than Median predictor
	4455	if ( bTestOtherPredictedMV )
	4456	{
	4457	for ( UInt index = 0; index < NUM_MV_PREDICTORS; index++ )
	4458	{
	4459	TComMv cMv = m_acMvPredictors[index];
	4460	pcCU->clipMv( cMv );
	4461	cMv >>= 2;
	4462	xTZSearchHelp( pcPatternKey, cStruct, cMv.getHor(), cMv.getVer(), 0, 0 );
	4463	}
	4464	}
	4465
	4466	// test whether zero Mv is better start point than Median predictor
	4467	if ( bTestZeroVector )
	4468	{
	4469	xTZSearchHelp( pcPatternKey, cStruct, 0, 0, 0, 0 );
	4470	}
	4471
	4472	if ( pIntegerMv2Nx2NPred != 0 )
	4473	{
	4474	TComMv integerMv2Nx2NPred = *pIntegerMv2Nx2NPred;
	4475	integerMv2Nx2NPred <<= 2;
	4476	pcCU->clipMv( integerMv2Nx2NPred );
	4477	integerMv2Nx2NPred >>= 2;
	4478	xTZSearchHelp(pcPatternKey, cStruct, integerMv2Nx2NPred.getHor(), integerMv2Nx2NPred.getVer(), 0, 0);
	4479
	4480	// reset search range
	4481	TComMv cMvSrchRngLT;
	4482	TComMv cMvSrchRngRB;
	4483	Int iSrchRng = m_iSearchRange;
	4484	TComMv currBestMv(cStruct.iBestX, cStruct.iBestY );
	4485	currBestMv <<= 2;
	4486	xSetSearchRange( pcCU, currBestMv, iSrchRng, cMvSrchRngLT, cMvSrchRngRB );
	4487	iSrchRngHorLeft = cMvSrchRngLT.getHor();
	4488	iSrchRngHorRight = cMvSrchRngRB.getHor();
	4489	iSrchRngVerTop = cMvSrchRngLT.getVer();
	4490	iSrchRngVerBottom = cMvSrchRngRB.getVer();
	4491	}
	4492
	4493	// Initial search
	4494	iBestX = cStruct.iBestX;
	4495	iBestY = cStruct.iBestY;
	4496	iFirstSrchRngHorLeft = ((iBestX - uiSearchRangeInitial) > iSrchRngHorLeft) ? (iBestX - uiSearchRangeInitial) : iSrchRngHorLeft;
	4497	iFirstSrchRngVerTop = ((iBestY - uiSearchRangeInitial) > iSrchRngVerTop) ? (iBestY - uiSearchRangeInitial) : iSrchRngVerTop;
	4498	iFirstSrchRngHorRight = ((iBestX + uiSearchRangeInitial) < iSrchRngHorRight) ? (iBestX + uiSearchRangeInitial) : iSrchRngHorRight;
	4499	iFirstSrchRngVerBottom = ((iBestY + uiSearchRangeInitial) < iSrchRngVerBottom) ? (iBestY + uiSearchRangeInitial) : iSrchRngVerBottom;
	4500
	4501	for ( iStartY = iFirstSrchRngVerTop; iStartY <= iFirstSrchRngVerBottom; iStartY += uiSearchStep )
	4502	{
	4503	for ( iStartX = iFirstSrchRngHorLeft; iStartX <= iFirstSrchRngHorRight; iStartX += uiSearchStep )
	4504	{
	4505	xTZSearchHelp( pcPatternKey, cStruct, iStartX, iStartY, 0, 0 );
	4506	xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, 1 );
	4507	xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, 2 );
	4508	}
	4509	}
	4510
	4511	Int iMaxMVDistToPred = (abs(cStruct.iBestX - iBestX) > iMVDistThresh \|\| abs(cStruct.iBestY - iBestY) > iMVDistThresh);
	4512
	4513	//full search with early exit if MV is distant from predictors
	4514	if ( bEnableRasterSearch && (iMaxMVDistToPred \|\| bAlwaysRasterSearch) )
	4515	{
	4516	for ( iStartY = iSrchRngVerTop; iStartY <= iSrchRngVerBottom; iStartY += 1 )
	4517	{
	4518	for ( iStartX = iSrchRngHorLeft; iStartX <= iSrchRngHorRight; iStartX += 1 )
	4519	{
	4520	xTZSearchHelp( pcPatternKey, cStruct, iStartX, iStartY, 0, 1 );
	4521	}
	4522	}
	4523	}
	4524	//Smaller MV, refine around predictor
	4525	else if ( bStarRefinementEnable && cStruct.uiBestDistance > 0 )
	4526	{
	4527	// start refinement
	4528	while ( cStruct.uiBestDistance > 0 )
	4529	{
	4530	iStartX = cStruct.iBestX;
	4531	iStartY = cStruct.iBestY;
	4532	cStruct.uiBestDistance = 0;
	4533	cStruct.ucPointNr = 0;
	4534	for ( iDist = 1; iDist < (Int)uiSearchRange + 1; iDist*=2 )
	4535	{
	4536	if ( bStarRefinementDiamond == 1 )
	4537	{
	4538	xTZ8PointDiamondSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4539	}
	4540	else
	4541	{
	4542	xTZ8PointSquareSearch ( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB, iStartX, iStartY, iDist );
	4543	}
	4544	if ( bStarRefinementStop && (cStruct.uiBestRound >= uiStarRefinementRounds) ) // stop criterion
	4545	{
	4546	break;
	4547	}
	4548	}
	4549
	4550	// calculate only 2 missing points instead 8 points if cStrukt.uiBestDistance == 1
	4551	if ( cStruct.uiBestDistance == 1 )
	4552	{
	4553	cStruct.uiBestDistance = 0;
	4554	if ( cStruct.ucPointNr != 0 )
	4555	{
	4556	xTZ2PointSearch( pcPatternKey, cStruct, pcMvSrchRngLT, pcMvSrchRngRB );
	4557	}
	4558	}
	4559	}
	4560	}
	4561
	4562	// write out best match
	4563	rcMv.set( cStruct.iBestX, cStruct.iBestY );
	4564	ruiSAD = cStruct.uiBestSad - m_pcRdCost->getCost( cStruct.iBestX, cStruct.iBestY );
	4565
	4566	}
	4567
	4568
	4569	Void TEncSearch::xPatternSearchFracDIF(
	4570	Bool bIsLosslessCoded,
[313]	4571	TComPattern* pcPatternKey,
[1029]	4572	Pel* piRefY,
	4573	Int iRefStride,
	4574	TComMv* pcMvInt,
	4575	TComMv& rcMvHalf,
	4576	TComMv& rcMvQter,
	4577	Distortion& ruiCost,
	4578	Bool biPred
	4579	)
[313]	4580	{
	4581	// Reference pattern initialization (integer scale)
	4582	TComPattern cPatternRoi;
	4583	Int iOffset = pcMvInt->getHor() + pcMvInt->getVer() * iRefStride;
[1029]	4584	cPatternRoi.initPattern(piRefY + iOffset,
[313]	4585	pcPatternKey->getROIYWidth(),
	4586	pcPatternKey->getROIYHeight(),
[1029]	4587	iRefStride );
	4588
[313]	4589	// Half-pel refinement
	4590	xExtDIFUpSamplingH ( &cPatternRoi, biPred );
[1029]	4591
[313]	4592	rcMvHalf = *pcMvInt; rcMvHalf <<= 1; // for mv-cost
	4593	TComMv baseRefMv(0, 0);
[1029]	4594	ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 2, rcMvHalf, !bIsLosslessCoded );
	4595
[313]	4596	m_pcRdCost->setCostScale( 0 );
[1029]	4597
[313]	4598	xExtDIFUpSamplingQ ( &cPatternRoi, rcMvHalf, biPred );
	4599	baseRefMv = rcMvHalf;
	4600	baseRefMv <<= 1;
[1029]	4601
[313]	4602	rcMvQter = *pcMvInt; rcMvQter <<= 1; // for mv-cost
	4603	rcMvQter += rcMvHalf; rcMvQter <<= 1;
[1029]	4604	ruiCost = xPatternRefinement( pcPatternKey, baseRefMv, 1, rcMvQter, !bIsLosslessCoded );
[313]	4605	}
	4606
[1029]	4607
[313]	4608	/** encode residual and calculate rate-distortion for a CU block
	4609	* \param pcCU
	4610	* \param pcYuvOrg
	4611	* \param pcYuvPred
	4612	* \param rpcYuvResi
	4613	* \param rpcYuvResiBest
	4614	* \param rpcYuvRec
	4615	* \param bSkipRes
	4616	* \returns Void
	4617	*/
[1029]	4618	Void TEncSearch::encodeResAndCalcRdInterCU( TComDataCU* pcCU, TComYuv* pcYuvOrg, TComYuv* pcYuvPred,
	4619	TComYuv* pcYuvResi, TComYuv* pcYuvResiBest, TComYuv* pcYuvRec,
	4620	Bool bSkipRes DEBUG_STRING_FN_DECLARE(sDebug) )
[313]	4621	{
	4622	if ( pcCU->isIntra(0) )
	4623	{
	4624	return;
	4625	}
[1029]	4626
	4627	Bool bHighPass = pcCU->getSlice()->getDepth() ? true : false;
	4628	UInt uiBits = 0, uiBitsBest = 0;
	4629	Distortion uiDistortion = 0, uiDistortionBest = 0;
	4630
	4631	UInt uiWidth = pcCU->getWidth ( 0 );
	4632	UInt uiHeight = pcCU->getHeight( 0 );
	4633
[313]	4634	// No residual coding : SKIP mode
	4635	if ( bSkipRes )
	4636	{
	4637	pcCU->setSkipFlagSubParts( true, 0, pcCU->getDepth(0) );
	4638
[1029]	4639	pcYuvResi->clear();
[313]	4640
[1029]	4641	pcYuvPred->copyToPartYuv( pcYuvRec, 0 );
	4642
	4643	for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
	4644	{
	4645	const ComponentID compID=ComponentID(ch);
	4646	const UInt csx=pcYuvOrg->getComponentScaleX(compID);
	4647	const UInt csy=pcYuvOrg->getComponentScaleY(compID);
	4648	uiDistortion += m_pcRdCost->getDistPart( g_bitDepth[toChannelType(compID)], pcYuvRec->getAddr(compID), pcYuvRec->getStride(compID), pcYuvOrg->getAddr(compID),
	4649	pcYuvOrg->getStride(compID), uiWidth >> csx, uiHeight >> csy, compID);
	4650	}
	4651
[595]	4652	m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST]);
[313]	4653	m_pcEntropyCoder->resetBits();
[1029]	4654
[313]	4655	if (pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	4656	{
	4657	m_pcEntropyCoder->encodeCUTransquantBypassFlag(pcCU, 0, true);
	4658	}
[1029]	4659
[313]	4660	m_pcEntropyCoder->encodeSkipFlag(pcCU, 0, true);
	4661	m_pcEntropyCoder->encodeMergeIndex( pcCU, 0, true );
[1029]	4662
[313]	4663	uiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	4664	pcCU->getTotalBits() = uiBits;
	4665	pcCU->getTotalDistortion() = uiDistortion;
	4666	pcCU->getTotalCost() = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
[1029]	4667
[595]	4668	m_pcRDGoOnSbacCoder->store(m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_TEMP_BEST]);
[1029]	4669
	4670	static const UInt cbfZero[MAX_NUM_COMPONENT]={0,0,0};
	4671	pcCU->setCbfSubParts( cbfZero, 0, pcCU->getDepth( 0 ) );
[313]	4672	pcCU->setTrIdxSubParts( 0, 0, pcCU->getDepth(0) );
[1029]	4673
	4674	#ifdef DEBUG_STRING
	4675	pcYuvResiBest->clear(); // Clear the residual image, if we didn't code it.
	4676	for(UInt i=0; i<MAX_NUM_COMPONENT+1; i++)
	4677	{
	4678	sDebug+=debug_reorder_data_inter_token[i];
	4679	}
	4680	#endif
	4681
[313]	4682	return;
	4683	}
[1029]	4684
[313]	4685	// Residual coding.
[1029]	4686	Int qp;
	4687	Int qpBest = 0;
	4688	Int qpMin;
	4689	Int qpMax;
[313]	4690	Double dCost, dCostBest = MAX_DOUBLE;
[1029]	4691
[313]	4692	UInt uiTrLevel = 0;
	4693	if( (pcCU->getWidth(0) > pcCU->getSlice()->getSPS()->getMaxTrSize()) )
	4694	{
	4695	while( pcCU->getWidth(0) > (pcCU->getSlice()->getSPS()->getMaxTrSize()<<uiTrLevel) ) uiTrLevel++;
	4696	}
[1029]	4697
[442]	4698	#if REPN_FORMAT_IN_VPS
	4699	qpMin = bHighPass ? Clip3( -pcCU->getSlice()->getQpBDOffsetY(), MAX_QP, pcCU->getQP(0) - m_iMaxDeltaQP ) : pcCU->getQP( 0 );
	4700	qpMax = bHighPass ? Clip3( -pcCU->getSlice()->getQpBDOffsetY(), MAX_QP, pcCU->getQP(0) + m_iMaxDeltaQP ) : pcCU->getQP( 0 );
	4701	#else
[1029]	4702	qpMin = bHighPass ? Clip3( -pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, pcCU->getQP(0) - m_iMaxDeltaQP ) : pcCU->getQP( 0 );
	4703	qpMax = bHighPass ? Clip3( -pcCU->getSlice()->getSPS()->getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, pcCU->getQP(0) + m_iMaxDeltaQP ) : pcCU->getQP( 0 );
[442]	4704	#endif
[313]	4705
[1029]	4706	pcYuvResi->subtract( pcYuvOrg, pcYuvPred, 0, uiWidth );
[313]	4707
[1029]	4708	TComTURecurse tuLevel0(pcCU, 0);
	4709
[313]	4710	for ( qp = qpMin; qp <= qpMax; qp++ )
	4711	{
	4712	dCost = 0.;
	4713	uiBits = 0;
	4714	uiDistortion = 0;
[1029]	4715
[595]	4716	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_CURR_BEST ] );
[1029]	4717
	4718	Distortion uiZeroDistortion = 0;
	4719
	4720	xEstimateResidualQT( pcYuvResi, dCost, uiBits, uiDistortion, &uiZeroDistortion, tuLevel0 DEBUG_STRING_PASS_INTO(sDebug) );
	4721
	4722	// -------------------------------------------------------
	4723	// set the coefficients in the pcCU, and also calculates the residual data.
	4724	// If a block full of 0's is efficient, then just use 0's.
	4725	// The costs at this point do not include header bits.
	4726
[313]	4727	m_pcEntropyCoder->resetBits();
	4728	m_pcEntropyCoder->encodeQtRootCbfZero( pcCU );
	4729	UInt zeroResiBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	4730	Double dZeroCost = m_pcRdCost->calcRdCost( zeroResiBits, uiZeroDistortion );
[1029]	4731
[313]	4732	if(pcCU->isLosslessCoded( 0 ))
[1029]	4733	{
[313]	4734	dZeroCost = dCost + 1;
	4735	}
[1029]	4736
[313]	4737	if ( dZeroCost < dCost )
	4738	{
[1029]	4739	if ( dZeroCost < dCost )
	4740	{
	4741	dCost = dZeroCost;
	4742	}
[313]	4743	uiDistortion = uiZeroDistortion;
[1029]	4744
	4745	const UInt uiQPartNum = tuLevel0.GetAbsPartIdxNumParts();
	4746	::memset( pcCU->getTransformIdx() , 0, uiQPartNum * sizeof(UChar) );
	4747	for (UInt ch=0; ch < pcCU->getPic()->getNumberValidComponents(); ch++)
	4748	{
	4749	const ComponentID component = ComponentID(ch);
	4750	const UInt componentShift = pcCU->getPic()->getComponentScaleX(component) + pcCU->getPic()->getComponentScaleY(component);
	4751	::memset( pcCU->getCbf( component ) , 0, uiQPartNum * sizeof(UChar) );
	4752	::memset( pcCU->getCoeff(component), 0, (uiWidthuiHeightsizeof(TCoeff))>>componentShift );
	4753	::memset( pcCU->getCrossComponentPredictionAlpha(component), 0, ( uiQPartNum * sizeof(Char) ) );
	4754	}
	4755	static const UInt useTS[MAX_NUM_COMPONENT]={0,0,0};
	4756	pcCU->setTransformSkipSubParts ( useTS, 0, pcCU->getDepth(0) );
	4757	#ifdef DEBUG_STRING
	4758	sDebug.clear();
	4759	for(UInt i=0; i<MAX_NUM_COMPONENT+1; i++)
	4760	{
	4761	sDebug+=debug_reorder_data_inter_token[i];
	4762	}
	4763	#endif
[313]	4764	}
	4765	else
	4766	{
[1029]	4767	xSetResidualQTData( NULL, false, tuLevel0); // Call first time to set coefficients.
[313]	4768	}
[1029]	4769
[595]	4770	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[pcCU->getDepth(0)][CI_CURR_BEST] );
[1029]	4771
[313]	4772	uiBits = 0;
[1029]	4773	xAddSymbolBitsInter( pcCU, 0, 0, uiBits );
	4774	// we've now encoded the pcCU, and so have a valid bit cost
	4775
	4776
[313]	4777	Double dExactCost = m_pcRdCost->calcRdCost( uiBits, uiDistortion );
	4778	dCost = dExactCost;
[1029]	4779
	4780	// Is our new cost better?
[313]	4781	if ( dCost < dCostBest )
	4782	{
	4783	if ( !pcCU->getQtRootCbf( 0 ) )
	4784	{
[1029]	4785	pcYuvResiBest->clear(); // Clear the residual image, if we didn't code it.
[313]	4786	}
	4787	else
	4788	{
[1029]	4789	xSetResidualQTData( pcYuvResiBest, true, tuLevel0 ); // else set the residual image data pcYUVResiBest from the various temp images.
[313]	4790	}
[1029]	4791
[313]	4792	if( qpMin != qpMax && qp != qpMax )
	4793	{
[1029]	4794	const UInt uiQPartNum = tuLevel0.GetAbsPartIdxNumParts();
[313]	4795	::memcpy( m_puhQTTempTrIdx, pcCU->getTransformIdx(), uiQPartNum * sizeof(UChar) );
[1029]	4796	for(UInt i=0; i<pcCU->getPic()->getNumberValidComponents(); i++)
	4797	{
	4798	const ComponentID compID=ComponentID(i);
	4799	const UInt csr = pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID);
	4800	::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID ), uiQPartNum * sizeof(UChar) );
	4801	::memcpy( m_pcQTTempCoeff[compID], pcCU->getCoeff(compID), uiWidth * uiHeight * sizeof( TCoeff ) >> csr );
[313]	4802	#if ADAPTIVE_QP_SELECTION
[1029]	4803	::memcpy( m_pcQTTempArlCoeff[compID], pcCU->getArlCoeff(compID), uiWidth * uiHeight * sizeof( TCoeff )>> csr );
[313]	4804	#endif
[1029]	4805	::memcpy( m_puhQTTempTransformSkipFlag[compID], pcCU->getTransformSkip(compID), uiQPartNum * sizeof( UChar ) );
	4806	::memcpy( m_phQTTempCrossComponentPredictionAlpha[compID], pcCU->getCrossComponentPredictionAlpha(compID), uiQPartNum * sizeof(Char) );
	4807	}
[313]	4808	}
	4809	uiBitsBest = uiBits;
	4810	uiDistortionBest = uiDistortion;
	4811	dCostBest = dCost;
	4812	qpBest = qp;
[1029]	4813
[595]	4814	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_TEMP_BEST ] );
[313]	4815	}
	4816	}
[1029]	4817
[313]	4818	assert ( dCostBest != MAX_DOUBLE );
[1029]	4819
[313]	4820	if( qpMin != qpMax && qpBest != qpMax )
	4821	{
[595]	4822	assert( 0 ); // check
	4823	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ pcCU->getDepth( 0 ) ][ CI_TEMP_BEST ] );
	4824
[1029]	4825	// copy best cbf and trIdx to pcCU
	4826	const UInt uiQPartNum = tuLevel0.GetAbsPartIdxNumParts();
[313]	4827	::memcpy( pcCU->getTransformIdx(), m_puhQTTempTrIdx, uiQPartNum * sizeof(UChar) );
[1029]	4828	for(UInt i=0; i<pcCU->getPic()->getNumberValidComponents(); i++)
	4829	{
	4830	const ComponentID compID=ComponentID(i);
	4831	const UInt csr = pcCU->getPic()->getComponentScaleX(compID) + pcCU->getPic()->getComponentScaleY(compID);
	4832	::memcpy( pcCU->getCbf( compID ), m_puhQTTempCbf[compID], uiQPartNum * sizeof(UChar) );
	4833	::memcpy( pcCU->getCoeff(compID), m_pcQTTempCoeff[compID], uiWidth * uiHeight * sizeof( TCoeff ) >> csr );
[313]	4834	#if ADAPTIVE_QP_SELECTION
[1029]	4835	::memcpy( pcCU->getArlCoeff(compID), m_pcQTTempArlCoeff[compID], uiWidth * uiHeight * sizeof( TCoeff ) >> csr );
[313]	4836	#endif
[1029]	4837	::memcpy( pcCU->getTransformSkip(compID), m_puhQTTempTransformSkipFlag[compID], uiQPartNum * sizeof( UChar ) );
	4838	::memcpy( pcCU->getCrossComponentPredictionAlpha(compID), m_phQTTempCrossComponentPredictionAlpha[compID], uiQPartNum * sizeof( Char ) );
	4839	}
[313]	4840	}
[1029]	4841	pcYuvRec->addClip ( pcYuvPred, pcYuvResiBest, 0, uiWidth );
	4842
[313]	4843	// update with clipped distortion and cost (qp estimation loop uses unclipped values)
[1029]	4844
	4845	uiDistortionBest = 0;
	4846	for(UInt ch=0; ch<pcYuvRec->getNumberValidComponents(); ch++)
	4847	{
	4848	const ComponentID compID=ComponentID(ch);
	4849	uiDistortionBest += m_pcRdCost->getDistPart( g_bitDepth[toChannelType(compID)], pcYuvRec->getAddr(compID ), pcYuvRec->getStride(compID ), pcYuvOrg->getAddr(compID ), pcYuvOrg->getStride(compID), uiWidth >> pcYuvOrg->getComponentScaleX(compID), uiHeight >> pcYuvOrg->getComponentScaleY(compID), compID);
	4850	}
[313]	4851	dCostBest = m_pcRdCost->calcRdCost( uiBitsBest, uiDistortionBest );
[1029]	4852
[313]	4853	pcCU->getTotalBits() = uiBitsBest;
	4854	pcCU->getTotalDistortion() = uiDistortionBest;
	4855	pcCU->getTotalCost() = dCostBest;
[1029]	4856
[313]	4857	if ( pcCU->isSkipped(0) )
	4858	{
[1029]	4859	static const UInt cbfZero[MAX_NUM_COMPONENT]={0,0,0};
	4860	pcCU->setCbfSubParts( cbfZero, 0, pcCU->getDepth( 0 ) );
[313]	4861	}
[1029]	4862
[313]	4863	pcCU->setQPSubParts( qpBest, 0, pcCU->getDepth(0) );
	4864	}
	4865
[1029]	4866
	4867
	4868	Void TEncSearch::xEstimateResidualQT( TComYuv *pcResi,
	4869	Double &rdCost,
	4870	UInt &ruiBits,
	4871	Distortion &ruiDist,
	4872	Distortion *puiZeroDist,
	4873	TComTU &rTu
	4874	DEBUG_STRING_FN_DECLARE(sDebug) )
[313]	4875	{
[1029]	4876	TComDataCU *pcCU = rTu.getCU();
	4877	const UInt uiAbsPartIdx = rTu.GetAbsPartIdxTU();
	4878	const UInt uiDepth = rTu.GetTransformDepthTotal();
	4879	const UInt uiTrMode = rTu.GetTransformDepthRel();
	4880	const UInt subTUDepth = uiTrMode + 1;
	4881	const UInt numValidComp = pcCU->getPic()->getNumberValidComponents();
	4882	DEBUG_STRING_NEW(sSingleStringComp[MAX_NUM_COMPONENT])
	4883
[313]	4884	assert( pcCU->getDepth( 0 ) == pcCU->getDepth( uiAbsPartIdx ) );
[1029]	4885	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	4886
	4887	UInt SplitFlag = ((pcCU->getSlice()->getSPS()->getQuadtreeTUMaxDepthInter() == 1) && pcCU->isInter(uiAbsPartIdx) && ( pcCU->getPartitionSize(uiAbsPartIdx) != SIZE_2Nx2N ));
	4888	#ifdef DEBUG_STRING
	4889	const Int debugPredModeMask = DebugStringGetPredModeMask(pcCU->getPredictionMode(uiAbsPartIdx));
	4890	#endif
	4891
[313]	4892	Bool bCheckFull;
[1029]	4893
[313]	4894	if ( SplitFlag && uiDepth == pcCU->getDepth(uiAbsPartIdx) && ( uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) ) )
[540]	4895	{
[1029]	4896	bCheckFull = false;
[540]	4897	}
[313]	4898	else
[540]	4899	{
[1029]	4900	bCheckFull = ( uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() );
[540]	4901	}
[313]	4902
	4903	const Bool bCheckSplit = ( uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );
[1029]	4904
[313]	4905	assert( bCheckFull \|\| bCheckSplit );
[1029]	4906
[313]	4907	// code full block
[1029]	4908	Double dSingleCost = MAX_DOUBLE;
	4909	UInt uiSingleBits = 0;
	4910	Distortion uiSingleDistComp [MAX_NUM_COMPONENT][2/0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU/] = {{0,0},{0,0},{0,0}};
	4911	Distortion uiSingleDist = 0;
	4912	TCoeff uiAbsSum [MAX_NUM_COMPONENT][2/0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU/] = {{0,0},{0,0},{0,0}};
	4913	UInt uiBestTransformMode [MAX_NUM_COMPONENT][2/0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU/] = {{0,0},{0,0},{0,0}};
	4914	// Stores the best explicit RDPCM mode for a TU encoded without split
	4915	UInt bestExplicitRdpcmModeUnSplit[MAX_NUM_COMPONENT][2/0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU/] = {{3,3}, {3,3}, {3,3}};
	4916	Char bestCrossCPredictionAlpha [MAX_NUM_COMPONENT][2/0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU/] = {{0,0},{0,0},{0,0}};
[313]	4917
[595]	4918	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
[1029]	4919
[313]	4920	if( bCheckFull )
	4921	{
[1029]	4922	Double minCost[MAX_NUM_COMPONENT][2/0 = top (or whole TU for non-4:2:2) sub-TU, 1 = bottom sub-TU/];
	4923	Bool checkTransformSkip[MAX_NUM_COMPONENT];
	4924	pcCU->setTrIdxSubParts( uiTrMode, uiAbsPartIdx, uiDepth );
[313]	4925
[1029]	4926	m_pcEntropyCoder->resetBits();
[313]	4927
[1029]	4928	memset( m_pTempPel, 0, sizeof( Pel ) * rTu.getRect(COMPONENT_Y).width * rTu.getRect(COMPONENT_Y).height ); // not necessary needed for inside of recursion (only at the beginning)
[313]	4929
[1029]	4930	const UInt uiQTTempAccessLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
	4931	TCoeff *pcCoeffCurr[MAX_NUM_COMPONENT];
	4932	#if ADAPTIVE_QP_SELECTION
	4933	TCoeff *pcArlCoeffCurr[MAX_NUM_COMPONENT];
	4934	#endif
[313]	4935
[1029]	4936	for(UInt i=0; i<numValidComp; i++)
[313]	4937	{
[1029]	4938	minCost[i][0] = MAX_DOUBLE;
	4939	minCost[i][1] = MAX_DOUBLE;
[313]	4940	}
	4941
[1029]	4942	Pel crossCPredictedResidualBuffer[ MAX_TU_SIZE * MAX_TU_SIZE ];
[313]	4943
[1029]	4944	for(UInt i=0; i<numValidComp; i++)
	4945	{
	4946	checkTransformSkip[i]=false;
	4947	const ComponentID compID=ComponentID(i);
	4948	pcCoeffCurr[compID] = m_ppcQTTempCoeff[compID][uiQTTempAccessLayer] + rTu.getCoefficientOffset(compID);
[313]	4949	#if ADAPTIVE_QP_SELECTION
[1029]	4950	pcArlCoeffCurr[compID] = m_ppcQTTempArlCoeff[compID ][uiQTTempAccessLayer] + rTu.getCoefficientOffset(compID);
[313]	4951	#endif
	4952
[1029]	4953	if(rTu.ProcessComponentSection(compID))
	4954	{
	4955	const QpParam cQP(*pcCU, compID);
[313]	4956
[1029]	4957	checkTransformSkip[compID] = pcCU->getSlice()->getPPS()->getUseTransformSkip() &&
	4958	TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(compID), pcCU->getSlice()->getPPS()->getTransformSkipLog2MaxSize()) &&
	4959	(!pcCU->isLosslessCoded(0));
[540]	4960
[1029]	4961	const Bool splitIntoSubTUs = rTu.getRect(compID).width != rTu.getRect(compID).height;
[313]	4962
[1029]	4963	TComTURecurse TUIterator(rTu, false, (splitIntoSubTUs ? TComTU::VERTICAL_SPLIT : TComTU::DONT_SPLIT), true, compID);
[540]	4964
[1029]	4965	const UInt partIdxesPerSubTU = TUIterator.GetAbsPartIdxNumParts(compID);
[313]	4966
[1029]	4967	do
	4968	{
	4969	const UInt subTUIndex = TUIterator.GetSectionNumber();
	4970	const UInt subTUAbsPartIdx = TUIterator.GetAbsPartIdxTU(compID);
	4971	const TComRectangle &tuCompRect = TUIterator.getRect(compID);
	4972	const UInt subTUBufferOffset = tuCompRect.width * tuCompRect.height * subTUIndex;
[313]	4973
[1029]	4974	TCoeff *currentCoefficients = pcCoeffCurr[compID] + subTUBufferOffset;
	4975	#if ADAPTIVE_QP_SELECTION
	4976	TCoeff *currentARLCoefficients = pcArlCoeffCurr[compID] + subTUBufferOffset;
[442]	4977	#endif
[1029]	4978	const Bool isCrossCPredictionAvailable = isChroma(compID)
	4979	&& pcCU->getSlice()->getPPS()->getUseCrossComponentPrediction()
	4980	&& (pcCU->getCbf(subTUAbsPartIdx, COMPONENT_Y, uiTrMode) != 0);
[313]	4981
[1029]	4982	Char preCalcAlpha = 0;
	4983	const Pel *pLumaResi = m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix( COMPONENT_Y, rTu.getRect( COMPONENT_Y ).x0, rTu.getRect( COMPONENT_Y ).y0 );
	4984
	4985	if (isCrossCPredictionAvailable)
[313]	4986	{
[1029]	4987	const Bool bUseReconstructedResidualForEstimate = m_pcEncCfg->getUseReconBasedCrossCPredictionEstimate();
	4988	const Pel *const lumaResidualForEstimate = bUseReconstructedResidualForEstimate ? pLumaResi : pcResi->getAddrPix(COMPONENT_Y, tuCompRect.x0, tuCompRect.y0);
	4989	const UInt lumaResidualStrideForEstimate = bUseReconstructedResidualForEstimate ? m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(COMPONENT_Y) : pcResi->getStride(COMPONENT_Y);
	4990
	4991	preCalcAlpha = xCalcCrossComponentPredictionAlpha(TUIterator,
	4992	compID,
	4993	lumaResidualForEstimate,
	4994	pcResi->getAddrPix(compID, tuCompRect.x0, tuCompRect.y0),
	4995	tuCompRect.width,
	4996	tuCompRect.height,
	4997	lumaResidualStrideForEstimate,
	4998	pcResi->getStride(compID));
[313]	4999	}
	5000
[1029]	5001	const Int transformSkipModesToTest = checkTransformSkip[compID] ? 2 : 1;
	5002	const Int crossCPredictionModesToTest = (preCalcAlpha != 0) ? 2 : 1; // preCalcAlpha cannot be anything other than 0 if isCrossCPredictionAvailable is false
[313]	5003
[1029]	5004	const Bool isOneMode = (crossCPredictionModesToTest == 1) && (transformSkipModesToTest == 1);
[313]	5005
[1029]	5006	for (Int transformSkipModeId = 0; transformSkipModeId < transformSkipModesToTest; transformSkipModeId++)
[313]	5007	{
[1029]	5008	pcCU->setTransformSkipPartRange(transformSkipModeId, compID, subTUAbsPartIdx, partIdxesPerSubTU);
[313]	5009
[1029]	5010	for (Int crossCPredictionModeId = 0; crossCPredictionModeId < crossCPredictionModesToTest; crossCPredictionModeId++)
[313]	5011	{
[1029]	5012	const Bool isFirstMode = (transformSkipModeId == 0) && (crossCPredictionModeId == 0);
	5013	const Bool bUseCrossCPrediction = crossCPredictionModeId != 0;
[313]	5014
[1029]	5015	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
	5016	m_pcEntropyCoder->resetBits();
[313]	5017
[1029]	5018	pcCU->setTransformSkipPartRange(transformSkipModeId, compID, subTUAbsPartIdx, partIdxesPerSubTU);
	5019	pcCU->setCrossComponentPredictionAlphaPartRange((bUseCrossCPrediction ? preCalcAlpha : 0), compID, subTUAbsPartIdx, partIdxesPerSubTU );
[313]	5020
[1029]	5021	if ((compID != COMPONENT_Cr) && ((transformSkipModeId == 1) ? m_pcEncCfg->getUseRDOQTS() : m_pcEncCfg->getUseRDOQ()))
	5022	{
	5023	m_pcEntropyCoder->estimateBit(m_pcTrQuant->m_pcEstBitsSbac, tuCompRect.width, tuCompRect.height, toChannelType(compID));
	5024	}
	5025
	5026	#if RDOQ_CHROMA_LAMBDA
	5027	m_pcTrQuant->selectLambda(compID);
[313]	5028	#endif
	5029
[1029]	5030	Pel *pcResiCurrComp = m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix(compID, tuCompRect.x0, tuCompRect.y0);
	5031	UInt resiStride = m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID);
[313]	5032
[1029]	5033	TCoeff bestCoeffComp [MAX_TU_SIZE*MAX_TU_SIZE];
	5034	Pel bestResiComp [MAX_TU_SIZE*MAX_TU_SIZE];
[313]	5035
[1029]	5036	#if ADAPTIVE_QP_SELECTION
	5037	TCoeff bestArlCoeffComp[MAX_TU_SIZE*MAX_TU_SIZE];
[442]	5038	#endif
[1029]	5039	TCoeff currAbsSum = 0;
	5040	UInt currCompBits = 0;
	5041	Distortion currCompDist = 0;
	5042	Double currCompCost = 0;
	5043	UInt nonCoeffBits = 0;
	5044	Distortion nonCoeffDist = 0;
	5045	Double nonCoeffCost = 0;
[313]	5046
[1029]	5047	if(!isOneMode && !isFirstMode)
	5048	{
	5049	memcpy(bestCoeffComp, currentCoefficients, (sizeof(TCoeff) * tuCompRect.width * tuCompRect.height));
[313]	5050	#if ADAPTIVE_QP_SELECTION
[1029]	5051	memcpy(bestArlCoeffComp, currentARLCoefficients, (sizeof(TCoeff) * tuCompRect.width * tuCompRect.height));
[442]	5052	#endif
[1029]	5053	for(Int y = 0; y < tuCompRect.height; y++)
	5054	{
	5055	memcpy(&bestResiComp[y * tuCompRect.width], (pcResiCurrComp + (y * resiStride)), (sizeof(Pel) * tuCompRect.width));
	5056	}
	5057	}
[313]	5058
[1029]	5059	if (bUseCrossCPrediction)
	5060	{
	5061	TComTrQuant::crossComponentPrediction(TUIterator,
	5062	compID,
	5063	pLumaResi,
	5064	pcResi->getAddrPix(compID, tuCompRect.x0, tuCompRect.y0),
	5065	crossCPredictedResidualBuffer,
	5066	tuCompRect.width,
	5067	tuCompRect.height,
	5068	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(COMPONENT_Y),
	5069	pcResi->getStride(compID),
	5070	tuCompRect.width,
	5071	false);
[313]	5072
[1029]	5073	m_pcTrQuant->transformNxN(TUIterator, compID, crossCPredictedResidualBuffer, tuCompRect.width, currentCoefficients,
[313]	5074	#if ADAPTIVE_QP_SELECTION
[1029]	5075	currentARLCoefficients,
[313]	5076	#endif
[1029]	5077	currAbsSum, cQP);
	5078	}
	5079	else
	5080	{
	5081	m_pcTrQuant->transformNxN(TUIterator, compID, pcResi->getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 ), pcResi->getStride(compID), currentCoefficients,
	5082	#if ADAPTIVE_QP_SELECTION
	5083	currentARLCoefficients,
	5084	#endif
	5085	currAbsSum, cQP);
	5086	}
[313]	5087
[1029]	5088	if(isFirstMode \|\| (currAbsSum == 0))
	5089	{
	5090	if (bUseCrossCPrediction)
	5091	{
	5092	TComTrQuant::crossComponentPrediction(TUIterator,
	5093	compID,
	5094	pLumaResi,
	5095	m_pTempPel,
	5096	m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix(compID, tuCompRect.x0, tuCompRect.y0),
	5097	tuCompRect.width,
	5098	tuCompRect.height,
	5099	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(COMPONENT_Y),
	5100	tuCompRect.width,
	5101	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID),
	5102	true);
[313]	5103
[1029]	5104	nonCoeffDist = m_pcRdCost->getDistPart( g_bitDepth[toChannelType(compID)], m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 ),
	5105	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride( compID ), pcResi->getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 ),
	5106	pcResi->getStride(compID), tuCompRect.width, tuCompRect.height, compID); // initialized with zero residual destortion
	5107	}
	5108	else
	5109	{
	5110	nonCoeffDist = m_pcRdCost->getDistPart( g_bitDepth[toChannelType(compID)], m_pTempPel, tuCompRect.width, pcResi->getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 ),
	5111	pcResi->getStride(compID), tuCompRect.width, tuCompRect.height, compID); // initialized with zero residual destortion
	5112	}
[313]	5113
[1029]	5114	m_pcEntropyCoder->encodeQtCbfZero( TUIterator, toChannelType(compID) );
[313]	5115
[1029]	5116	if ( isCrossCPredictionAvailable )
	5117	{
	5118	m_pcEntropyCoder->encodeCrossComponentPrediction( TUIterator, compID );
	5119	}
[313]	5120
[1029]	5121	nonCoeffBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	5122	nonCoeffCost = m_pcRdCost->calcRdCost( nonCoeffBits, nonCoeffDist );
	5123	}
[313]	5124
[1029]	5125	if((puiZeroDist != NULL) && isFirstMode)
	5126	{
	5127	*puiZeroDist += nonCoeffDist; // initialized with zero residual destortion
	5128	}
[313]	5129
[1029]	5130	DEBUG_STRING_NEW(sSingleStringTest)
[313]	5131
[1029]	5132	if( currAbsSum > 0 ) //if non-zero coefficients are present, a residual needs to be derived for further prediction
	5133	{
	5134	if (isFirstMode)
	5135	{
	5136	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
	5137	m_pcEntropyCoder->resetBits();
	5138	}
[313]	5139
[1029]	5140	m_pcEntropyCoder->encodeQtCbf( TUIterator, compID, true );
[313]	5141
[1029]	5142	if (isCrossCPredictionAvailable)
	5143	{
	5144	m_pcEntropyCoder->encodeCrossComponentPrediction( TUIterator, compID );
	5145	}
[313]	5146
[1029]	5147	m_pcEntropyCoder->encodeCoeffNxN( TUIterator, currentCoefficients, compID );
	5148	currCompBits = m_pcEntropyCoder->getNumberOfWrittenBits();
[313]	5149
[1029]	5150	pcResiCurrComp = m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 );
[313]	5151
[1029]	5152	m_pcTrQuant->invTransformNxN( TUIterator, compID, pcResiCurrComp, m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID), currentCoefficients, cQP DEBUG_STRING_PASS_INTO_OPTIONAL(&sSingleStringTest, (DebugOptionList::DebugString_InvTran.getInt()&debugPredModeMask)) );
[313]	5153
[1029]	5154	if (bUseCrossCPrediction)
	5155	{
	5156	TComTrQuant::crossComponentPrediction(TUIterator,
	5157	compID,
	5158	pLumaResi,
	5159	m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix(compID, tuCompRect.x0, tuCompRect.y0),
	5160	m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix(compID, tuCompRect.x0, tuCompRect.y0),
	5161	tuCompRect.width,
	5162	tuCompRect.height,
	5163	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(COMPONENT_Y),
	5164	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID ),
	5165	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID ),
	5166	true);
	5167	}
[313]	5168
[1029]	5169	currCompDist = m_pcRdCost->getDistPart( g_bitDepth[toChannelType(compID)], m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 ),
	5170	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID),
	5171	pcResi->getAddrPix( compID, tuCompRect.x0, tuCompRect.y0 ),
	5172	pcResi->getStride(compID),
	5173	tuCompRect.width, tuCompRect.height, compID);
[313]	5174
[1029]	5175	currCompCost = m_pcRdCost->calcRdCost(currCompBits, currCompDist);
	5176
	5177	if (pcCU->isLosslessCoded(0)) nonCoeffCost = MAX_DOUBLE;
	5178	}
	5179	else if ((transformSkipModeId == 1) && !bUseCrossCPrediction)
	5180	{
	5181	currCompCost = MAX_DOUBLE;
	5182	}
	5183	else
	5184	{
	5185	currCompBits = nonCoeffBits;
	5186	currCompDist = nonCoeffDist;
	5187	currCompCost = nonCoeffCost;
	5188	}
[313]	5189
[1029]	5190	// evaluate
	5191	if ((currCompCost < minCost[compID][subTUIndex]) \|\| ((transformSkipModeId == 1) && (currCompCost == minCost[compID][subTUIndex])))
	5192	{
	5193	bestExplicitRdpcmModeUnSplit[compID][subTUIndex] = pcCU->getExplicitRdpcmMode(compID, subTUAbsPartIdx);
[313]	5194
[1029]	5195	if(isFirstMode) //check for forced null
	5196	{
	5197	if((nonCoeffCost < currCompCost) \|\| (currAbsSum == 0))
	5198	{
	5199	memset(currentCoefficients, 0, (sizeof(TCoeff) * tuCompRect.width * tuCompRect.height));
[313]	5200
[1029]	5201	currAbsSum = 0;
	5202	currCompBits = nonCoeffBits;
	5203	currCompDist = nonCoeffDist;
	5204	currCompCost = nonCoeffCost;
	5205	}
	5206	}
[313]	5207
[1029]	5208	#ifdef DEBUG_STRING
	5209	if (currAbsSum > 0)
	5210	{
	5211	DEBUG_STRING_SWAP(sSingleStringComp[compID], sSingleStringTest)
	5212	}
	5213	else
	5214	{
	5215	sSingleStringComp[compID].clear();
	5216	}
	5217	#endif
[313]	5218
[1029]	5219	uiAbsSum [compID][subTUIndex] = currAbsSum;
	5220	uiSingleDistComp [compID][subTUIndex] = currCompDist;
	5221	minCost [compID][subTUIndex] = currCompCost;
	5222	uiBestTransformMode [compID][subTUIndex] = transformSkipModeId;
	5223	bestCrossCPredictionAlpha[compID][subTUIndex] = (crossCPredictionModeId == 1) ? pcCU->getCrossComponentPredictionAlpha(subTUAbsPartIdx, compID) : 0;
[313]	5224
[1029]	5225	if (uiAbsSum[compID][subTUIndex] == 0)
	5226	{
	5227	if (bUseCrossCPrediction)
	5228	{
	5229	TComTrQuant::crossComponentPrediction(TUIterator,
	5230	compID,
	5231	pLumaResi,
	5232	m_pTempPel,
	5233	m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix(compID, tuCompRect.x0, tuCompRect.y0),
	5234	tuCompRect.width,
	5235	tuCompRect.height,
	5236	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(COMPONENT_Y),
	5237	tuCompRect.width,
	5238	m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID),
	5239	true);
	5240	}
	5241	else
	5242	{
	5243	pcResiCurrComp = m_pcQTTempTComYuv[uiQTTempAccessLayer].getAddrPix(compID, tuCompRect.x0, tuCompRect.y0);
	5244	const UInt uiStride = m_pcQTTempTComYuv[uiQTTempAccessLayer].getStride(compID);
	5245	for(UInt uiY = 0; uiY < tuCompRect.height; uiY++)
	5246	{
	5247	memset(pcResiCurrComp, 0, (sizeof(Pel) * tuCompRect.width));
	5248	pcResiCurrComp += uiStride;
	5249	}
	5250	}
	5251	}
	5252	}
	5253	else
	5254	{
	5255	// reset
	5256	memcpy(currentCoefficients, bestCoeffComp, (sizeof(TCoeff) * tuCompRect.width * tuCompRect.height));
[313]	5257	#if ADAPTIVE_QP_SELECTION
[1029]	5258	memcpy(currentARLCoefficients, bestArlCoeffComp, (sizeof(TCoeff) * tuCompRect.width * tuCompRect.height));
[313]	5259	#endif
[1029]	5260	for (Int y = 0; y < tuCompRect.height; y++)
	5261	{
	5262	memcpy((pcResiCurrComp + (y * resiStride)), &bestResiComp[y * tuCompRect.width], (sizeof(Pel) * tuCompRect.width));
	5263	}
	5264	}
	5265	}
	5266	}
[313]	5267
[1029]	5268	pcCU->setExplicitRdpcmModePartRange ( bestExplicitRdpcmModeUnSplit[compID][subTUIndex], compID, subTUAbsPartIdx, partIdxesPerSubTU);
	5269	pcCU->setTransformSkipPartRange ( uiBestTransformMode [compID][subTUIndex], compID, subTUAbsPartIdx, partIdxesPerSubTU );
	5270	pcCU->setCbfPartRange ((((uiAbsSum [compID][subTUIndex] > 0) ? 1 : 0) << uiTrMode), compID, subTUAbsPartIdx, partIdxesPerSubTU );
	5271	pcCU->setCrossComponentPredictionAlphaPartRange( bestCrossCPredictionAlpha [compID][subTUIndex], compID, subTUAbsPartIdx, partIdxesPerSubTU );
	5272	} //end of sub-TU loop
	5273	while (TUIterator.nextSection(rTu));
	5274	} // processing section
	5275	} // component loop
[313]	5276
[1029]	5277	for(UInt ch = 0; ch < numValidComp; ch++)
	5278	{
	5279	const ComponentID compID = ComponentID(ch);
	5280	if (rTu.ProcessComponentSection(compID) && (rTu.getRect(compID).width != rTu.getRect(compID).height))
[313]	5281	{
[1029]	5282	offsetSubTUCBFs(rTu, compID); //the CBFs up to now have been defined for two sub-TUs - shift them down a level and replace with the parent level CBF
[313]	5283	}
	5284	}
	5285
[595]	5286	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
[313]	5287	m_pcEntropyCoder->resetBits();
	5288
[540]	5289	if( uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
[313]	5290	{
[540]	5291	m_pcEntropyCoder->encodeTransformSubdivFlag( 0, 5 - uiLog2TrSize );
[313]	5292	}
	5293
[1029]	5294	for(UInt ch = 0; ch < numValidComp; ch++)
[313]	5295	{
[1029]	5296	const UInt chOrderChange = ((ch + 1) == numValidComp) ? 0 : (ch + 1);
	5297	const ComponentID compID=ComponentID(chOrderChange);
	5298	if( rTu.ProcessComponentSection(compID) )
	5299	{
	5300	m_pcEntropyCoder->encodeQtCbf( rTu, compID, true );
	5301	}
[313]	5302	}
	5303
[1029]	5304	for(UInt ch = 0; ch < numValidComp; ch++)
	5305	{
	5306	const ComponentID compID=ComponentID(ch);
	5307	if (rTu.ProcessComponentSection(compID))
	5308	{
	5309	if(isChroma(compID) && (uiAbsSum[COMPONENT_Y][0] != 0))
	5310	{
	5311	m_pcEntropyCoder->encodeCrossComponentPrediction( rTu, compID );
	5312	}
[540]	5313
[1029]	5314	m_pcEntropyCoder->encodeCoeffNxN( rTu, pcCoeffCurr[compID], compID );
	5315	for (UInt subTUIndex = 0; subTUIndex < 2; subTUIndex++) uiSingleDist += uiSingleDistComp[compID][subTUIndex];
	5316	}
[313]	5317	}
	5318
	5319	uiSingleBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	5320
	5321	dSingleCost = m_pcRdCost->calcRdCost( uiSingleBits, uiSingleDist );
[1029]	5322	} // check full
	5323
[313]	5324	// code sub-blocks
	5325	if( bCheckSplit )
	5326	{
[595]	5327	if( bCheckFull )
[313]	5328	{
	5329	m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
	5330	m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
	5331	}
[1029]	5332	Distortion uiSubdivDist = 0;
	5333	UInt uiSubdivBits = 0;
	5334	Double dSubdivCost = 0.0;
	5335
	5336	//save the non-split CBFs in case we need to restore them later
	5337
	5338	UInt bestCBF [MAX_NUM_COMPONENT];
	5339	UInt bestsubTUCBF[MAX_NUM_COMPONENT][2];
	5340	for(UInt ch = 0; ch < numValidComp; ch++)
[313]	5341	{
[1029]	5342	const ComponentID compID=ComponentID(ch);
	5343
	5344	if (rTu.ProcessComponentSection(compID))
	5345	{
	5346	bestCBF[compID] = pcCU->getCbf(uiAbsPartIdx, compID, uiTrMode);
	5347
	5348	const TComRectangle &tuCompRect = rTu.getRect(compID);
	5349	if (tuCompRect.width != tuCompRect.height)
	5350	{
	5351	const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> 1;
	5352
	5353	for (UInt subTU = 0; subTU < 2; subTU++)
	5354	bestsubTUCBF[compID][subTU] = pcCU->getCbf ((uiAbsPartIdx + (subTU * partIdxesPerSubTU)), compID, subTUDepth);
	5355	}
	5356	}
[313]	5357	}
[1029]	5358
	5359
	5360	TComTURecurse tuRecurseChild(rTu, false);
	5361	const UInt uiQPartNumSubdiv = tuRecurseChild.GetAbsPartIdxNumParts();
	5362
	5363	DEBUG_STRING_NEW(sSplitString[MAX_NUM_COMPONENT])
	5364
	5365	do
[313]	5366	{
[1029]	5367	DEBUG_STRING_NEW(childString)
	5368	xEstimateResidualQT( pcResi, dSubdivCost, uiSubdivBits, uiSubdivDist, bCheckFull ? NULL : puiZeroDist, tuRecurseChild DEBUG_STRING_PASS_INTO(childString));
	5369	#ifdef DEBUG_STRING
	5370	// split the string by component and append to the relevant output (because decoder decodes in channel order, whereas this search searches by TU-order)
	5371	std::size_t lastPos=0;
	5372	const std::size_t endStrng=childString.find(debug_reorder_data_inter_token[MAX_NUM_COMPONENT], lastPos);
	5373	for(UInt ch = 0; ch < numValidComp; ch++)
	5374	{
	5375	if (lastPos!=std::string::npos && childString.find(debug_reorder_data_inter_token[ch], lastPos)==lastPos) lastPos+=strlen(debug_reorder_data_inter_token[ch]); // skip leading string
	5376	std::size_t pos=childString.find(debug_reorder_data_inter_token[ch+1], lastPos);
	5377	if (pos!=std::string::npos && pos>endStrng) lastPos=endStrng;
	5378	sSplitString[ch]+=childString.substr(lastPos, (pos==std::string::npos)? std::string::npos : (pos-lastPos) );
	5379	lastPos=pos;
	5380	}
	5381	#endif
[313]	5382	}
[1029]	5383	while ( tuRecurseChild.nextSection(rTu) ) ;
	5384
	5385	UInt uiCbfAny=0;
	5386	for(UInt ch = 0; ch < numValidComp; ch++)
[313]	5387	{
[1029]	5388	UInt uiYUVCbf = 0;
	5389	for( UInt ui = 0; ui < 4; ++ui )
	5390	{
	5391	uiYUVCbf \|= pcCU->getCbf( uiAbsPartIdx + ui * uiQPartNumSubdiv, ComponentID(ch), uiTrMode + 1 );
	5392	}
	5393	UChar *pBase=pcCU->getCbf( ComponentID(ch) );
	5394	const UInt flags=uiYUVCbf << uiTrMode;
	5395	for( UInt ui = 0; ui < 4 * uiQPartNumSubdiv; ++ui )
	5396	{
	5397	pBase[uiAbsPartIdx + ui] \|= flags;
	5398	}
	5399	uiCbfAny\|=uiYUVCbf;
[313]	5400	}
[1029]	5401
[595]	5402	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_ROOT ] );
[313]	5403	m_pcEntropyCoder->resetBits();
[540]	5404
[1029]	5405	// when compID isn't a channel, code Cbfs:
	5406	xEncodeResidualQT( MAX_NUM_COMPONENT, rTu );
	5407	for(UInt ch = 0; ch < numValidComp; ch++)
	5408	{
	5409	xEncodeResidualQT( ComponentID(ch), rTu );
	5410	}
	5411
[313]	5412	uiSubdivBits = m_pcEntropyCoder->getNumberOfWrittenBits();
	5413	dSubdivCost = m_pcRdCost->calcRdCost( uiSubdivBits, uiSubdivDist );
[1029]	5414
	5415	if (!bCheckFull \|\| (uiCbfAny && (dSubdivCost < dSingleCost)))
[313]	5416	{
[1029]	5417	rdCost += dSubdivCost;
	5418	ruiBits += uiSubdivBits;
	5419	ruiDist += uiSubdivDist;
	5420	#ifdef DEBUG_STRING
	5421	for(UInt ch = 0; ch < numValidComp; ch++)
[313]	5422	{
[1029]	5423	DEBUG_STRING_APPEND(sDebug, debug_reorder_data_inter_token[ch])
	5424	DEBUG_STRING_APPEND(sDebug, sSplitString[ch])
[313]	5425	}
[1029]	5426	#endif
[313]	5427	}
[1029]	5428	else
[313]	5429	{
[1029]	5430	rdCost += dSingleCost;
	5431	ruiBits += uiSingleBits;
	5432	ruiDist += uiSingleDist;
	5433
	5434	//restore state to unsplit
	5435
	5436	pcCU->setTrIdxSubParts( uiTrMode, uiAbsPartIdx, uiDepth );
	5437
	5438	for(UInt ch = 0; ch < numValidComp; ch++)
	5439	{
	5440	const ComponentID compID=ComponentID(ch);
	5441
	5442	DEBUG_STRING_APPEND(sDebug, debug_reorder_data_inter_token[ch])
	5443	if (rTu.ProcessComponentSection(compID))
	5444	{
	5445	DEBUG_STRING_APPEND(sDebug, sSingleStringComp[compID])
	5446
	5447	const Bool splitIntoSubTUs = rTu.getRect(compID).width != rTu.getRect(compID).height;
	5448	const UInt numberOfSections = splitIntoSubTUs ? 2 : 1;
	5449	const UInt partIdxesPerSubTU = rTu.GetAbsPartIdxNumParts(compID) >> (splitIntoSubTUs ? 1 : 0);
	5450
	5451	for (UInt subTUIndex = 0; subTUIndex < numberOfSections; subTUIndex++)
	5452	{
	5453	const UInt uisubTUPartIdx = uiAbsPartIdx + (subTUIndex * partIdxesPerSubTU);
	5454
	5455	if (splitIntoSubTUs)
	5456	{
	5457	const UChar combinedCBF = (bestsubTUCBF[compID][subTUIndex] << subTUDepth) \| (bestCBF[compID] << uiTrMode);
	5458	pcCU->setCbfPartRange(combinedCBF, compID, uisubTUPartIdx, partIdxesPerSubTU);
	5459	}
	5460	else
	5461	{
	5462	pcCU->setCbfPartRange((bestCBF[compID] << uiTrMode), compID, uisubTUPartIdx, partIdxesPerSubTU);
	5463	}
	5464
	5465	pcCU->setCrossComponentPredictionAlphaPartRange(bestCrossCPredictionAlpha[compID][subTUIndex], compID, uisubTUPartIdx, partIdxesPerSubTU);
	5466	pcCU->setTransformSkipPartRange(uiBestTransformMode[compID][subTUIndex], compID, uisubTUPartIdx, partIdxesPerSubTU);
	5467	pcCU->setExplicitRdpcmModePartRange(bestExplicitRdpcmModeUnSplit[compID][subTUIndex], compID, uisubTUPartIdx, partIdxesPerSubTU);
	5468	}
	5469	}
	5470	}
	5471
	5472	m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiDepth ][ CI_QT_TRAFO_TEST ] );
[313]	5473	}
	5474	}
[1029]	5475	else
[313]	5476	{
[1029]	5477	rdCost += dSingleCost;
	5478	ruiBits += uiSingleBits;
	5479	ruiDist += uiSingleDist;
	5480	#ifdef DEBUG_STRING
	5481	for(UInt ch = 0; ch < numValidComp; ch++)
	5482	{
	5483	const ComponentID compID=ComponentID(ch);
	5484	DEBUG_STRING_APPEND(sDebug, debug_reorder_data_inter_token[compID])
	5485
	5486	if (rTu.ProcessComponentSection(compID))
	5487	{
	5488	DEBUG_STRING_APPEND(sDebug, sSingleStringComp[compID])
	5489	}
	5490	}
	5491	#endif
[313]	5492	}
[1029]	5493	DEBUG_STRING_APPEND(sDebug, debug_reorder_data_inter_token[MAX_NUM_COMPONENT])
[313]	5494	}
	5495
[1029]	5496
	5497
	5498	Void TEncSearch::xEncodeResidualQT( const ComponentID compID, TComTU &rTu )
[313]	5499	{
[1029]	5500	TComDataCU* pcCU=rTu.getCU();
	5501	const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
	5502	const UInt uiCurrTrMode = rTu.GetTransformDepthRel();
[313]	5503	assert( pcCU->getDepth( 0 ) == pcCU->getDepth( uiAbsPartIdx ) );
	5504	const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
[1029]	5505
[313]	5506	const Bool bSubdiv = uiCurrTrMode != uiTrMode;
	5507
[1029]	5508	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	5509
	5510	if (compID==MAX_NUM_COMPONENT) // we are not processing a channel, instead we always recurse and code the CBFs
[313]	5511	{
[1029]	5512	if( uiLog2TrSize <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() && uiLog2TrSize > pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) )
	5513	{
	5514	m_pcEntropyCoder->encodeTransformSubdivFlag( bSubdiv, 5 - uiLog2TrSize );
	5515	}
[313]	5516
[1029]	5517	assert( !pcCU->isIntra(uiAbsPartIdx) );
	5518
	5519	const Bool bFirstCbfOfCU = uiCurrTrMode == 0;
	5520
	5521	for (UInt ch=COMPONENT_Cb; ch<pcCU->getPic()->getNumberValidComponents(); ch++)
[313]	5522	{
[1029]	5523	const ComponentID compIdInner=ComponentID(ch);
	5524	if( bFirstCbfOfCU \|\| rTu.ProcessingAllQuadrants(compIdInner) )
[313]	5525	{
[1029]	5526	if( bFirstCbfOfCU \|\| pcCU->getCbf( uiAbsPartIdx, compIdInner, uiCurrTrMode - 1 ) )
[313]	5527	{
[1029]	5528	m_pcEntropyCoder->encodeQtCbf( rTu, compIdInner, !bSubdiv );
[313]	5529	}
	5530	}
[1029]	5531	else
[313]	5532	{
[1029]	5533	assert( pcCU->getCbf( uiAbsPartIdx, compIdInner, uiCurrTrMode ) == pcCU->getCbf( uiAbsPartIdx, compIdInner, uiCurrTrMode - 1 ) );
[313]	5534	}
	5535	}
[1029]	5536
	5537	if (!bSubdiv)
	5538	{
	5539	m_pcEntropyCoder->encodeQtCbf( rTu, COMPONENT_Y, true );
	5540	}
	5541	}
	5542
[313]	5543	if( !bSubdiv )
	5544	{
[1029]	5545	if (compID != MAX_NUM_COMPONENT) // we have already coded the CBFs, so now we code coefficients
[313]	5546	{
[1029]	5547	if (rTu.ProcessComponentSection(compID))
[313]	5548	{
[1029]	5549	if (isChroma(compID) && (pcCU->getCbf(uiAbsPartIdx, COMPONENT_Y, uiTrMode) != 0))
[313]	5550	{
[1029]	5551	m_pcEntropyCoder->encodeCrossComponentPrediction(rTu, compID);
[313]	5552	}
[1029]	5553
	5554	if (pcCU->getCbf(uiAbsPartIdx, compID, uiTrMode) != 0)
[313]	5555	{
[1029]	5556	const UInt uiQTTempAccessLayer = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
	5557	TCoeff *pcCoeffCurr = m_ppcQTTempCoeff[compID][uiQTTempAccessLayer] + rTu.getCoefficientOffset(compID);
	5558	m_pcEntropyCoder->encodeCoeffNxN( rTu, pcCoeffCurr, compID );
[313]	5559	}
	5560	}
	5561	}
	5562	}
	5563	else
	5564	{
[1029]	5565	if( compID==MAX_NUM_COMPONENT \|\| pcCU->getCbf( uiAbsPartIdx, compID, uiCurrTrMode ) )
[313]	5566	{
[1029]	5567	TComTURecurse tuRecurseChild(rTu, false);
	5568	do
[313]	5569	{
[1029]	5570	xEncodeResidualQT( compID, tuRecurseChild );
	5571	} while (tuRecurseChild.nextSection(rTu));
[313]	5572	}
	5573	}
	5574	}
	5575
[1029]	5576
	5577
	5578
	5579	Void TEncSearch::xSetResidualQTData( TComYuv* pcResi, Bool bSpatial, TComTU &rTu )
[313]	5580	{
[1029]	5581	TComDataCU* pcCU=rTu.getCU();
	5582	const UInt uiCurrTrMode=rTu.GetTransformDepthRel();
	5583	const UInt uiAbsPartIdx=rTu.GetAbsPartIdxTU();
[313]	5584	assert( pcCU->getDepth( 0 ) == pcCU->getDepth( uiAbsPartIdx ) );
	5585	const UInt uiTrMode = pcCU->getTransformIdx( uiAbsPartIdx );
[1029]	5586	TComSPS *sps=pcCU->getSlice()->getSPS();
[313]	5587
	5588	if( uiCurrTrMode == uiTrMode )
	5589	{
[1029]	5590	const UInt uiLog2TrSize = rTu.GetLog2LumaTrSize();
	5591	const UInt uiQTTempAccessLayer = sps->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
[313]	5592
[1029]	5593	if( bSpatial )
[313]	5594	{
[1029]	5595	// Data to be copied is in the spatial domain, i.e., inverse-transformed.
[313]	5596
[1029]	5597	for(UInt i=0; i<pcResi->getNumberValidComponents(); i++)
[313]	5598	{
[1029]	5599	const ComponentID compID=ComponentID(i);
	5600	if (rTu.ProcessComponentSection(compID))
	5601	{
	5602	const TComRectangle &rectCompTU(rTu.getRect(compID));
	5603	m_pcQTTempTComYuv[uiQTTempAccessLayer].copyPartToPartComponentMxN ( compID, pcResi, rectCompTU );
	5604	}
[313]	5605	}
	5606	}
	5607	else
	5608	{
[1029]	5609	for (UInt ch=0; ch < getNumberValidComponents(sps->getChromaFormatIdc()); ch++)
[313]	5610	{
[1029]	5611	const ComponentID compID = ComponentID(ch);
	5612	if (rTu.ProcessComponentSection(compID))
	5613	{
	5614	const TComRectangle &rectCompTU(rTu.getRect(compID));
	5615	const UInt numCoeffInBlock = rectCompTU.width * rectCompTU.height;
	5616	const UInt offset = rTu.getCoefficientOffset(compID);
	5617	TCoeff* dest = pcCU->getCoeff(compID) + offset;
	5618	const TCoeff* src = m_ppcQTTempCoeff[compID][uiQTTempAccessLayer] + offset;
	5619	::memcpy( dest, src, sizeof(TCoeff)*numCoeffInBlock );
	5620
[313]	5621	#if ADAPTIVE_QP_SELECTION
[1029]	5622	TCoeff* pcArlCoeffSrc = m_ppcQTTempArlCoeff[compID][uiQTTempAccessLayer] + offset;
	5623	TCoeff* pcArlCoeffDst = pcCU->getArlCoeff(compID) + offset;
	5624	::memcpy( pcArlCoeffDst, pcArlCoeffSrc, sizeof( TCoeff ) * numCoeffInBlock );
[313]	5625	#endif
[1029]	5626	}
[313]	5627	}
	5628	}
	5629	}
	5630	else
	5631	{
[1029]	5632
	5633	TComTURecurse tuRecurseChild(rTu, false);
	5634	do
[313]	5635	{
[1029]	5636	xSetResidualQTData( pcResi, bSpatial, tuRecurseChild );
	5637	} while (tuRecurseChild.nextSection(rTu));
[313]	5638	}
	5639	}
	5640
[1029]	5641
	5642
	5643
	5644	UInt TEncSearch::xModeBitsIntra( TComDataCU* pcCU, UInt uiMode, UInt uiPartOffset, UInt uiDepth, UInt uiInitTrDepth, const ChannelType chType )
[313]	5645	{
[595]	5646	// Reload only contexts required for coding intra mode information
[1029]	5647	m_pcRDGoOnSbacCoder->loadIntraDirMode( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST], chType );
	5648
	5649	// Temporarily set the intra dir being tested, and only
	5650	// for absPartIdx, since encodeIntraDirModeLuma/Chroma only use
	5651	// the entry at absPartIdx.
	5652
	5653	UChar &rIntraDirVal=pcCU->getIntraDir( chType )[uiPartOffset];
	5654	UChar origVal=rIntraDirVal;
	5655	rIntraDirVal = uiMode;
	5656	//pcCU->setIntraDirSubParts ( chType, uiMode, uiPartOffset, uiDepth + uiInitTrDepth );
	5657
[313]	5658	m_pcEntropyCoder->resetBits();
[1029]	5659	if (isLuma(chType))
	5660	m_pcEntropyCoder->encodeIntraDirModeLuma ( pcCU, uiPartOffset);
	5661	else
	5662	m_pcEntropyCoder->encodeIntraDirModeChroma ( pcCU, uiPartOffset);
	5663
	5664	rIntraDirVal = origVal; // restore
	5665
[313]	5666	return m_pcEntropyCoder->getNumberOfWrittenBits();
	5667	}
	5668
[1029]	5669
	5670
	5671
[313]	5672	UInt TEncSearch::xUpdateCandList( UInt uiMode, Double uiCost, UInt uiFastCandNum, UInt * CandModeList, Double * CandCostList )
	5673	{
	5674	UInt i;
	5675	UInt shift=0;
[1029]	5676
[313]	5677	while ( shift<uiFastCandNum && uiCost<CandCostList[ uiFastCandNum-1-shift ] ) shift++;
[1029]	5678
[313]	5679	if( shift!=0 )
	5680	{
	5681	for(i=1; i<shift; i++)
	5682	{
	5683	CandModeList[ uiFastCandNum-i ] = CandModeList[ uiFastCandNum-1-i ];
	5684	CandCostList[ uiFastCandNum-i ] = CandCostList[ uiFastCandNum-1-i ];
	5685	}
	5686	CandModeList[ uiFastCandNum-shift ] = uiMode;
	5687	CandCostList[ uiFastCandNum-shift ] = uiCost;
	5688	return 1;
	5689	}
[1029]	5690
[313]	5691	return 0;
	5692	}
	5693
[1029]	5694
	5695
	5696
	5697
[313]	5698	/** add inter-prediction syntax elements for a CU block
	5699	* \param pcCU
	5700	* \param uiQp
	5701	* \param uiTrMode
	5702	* \param ruiBits
	5703	* \returns Void
	5704	*/
[1029]	5705	Void TEncSearch::xAddSymbolBitsInter( TComDataCU* pcCU, UInt uiQp, UInt uiTrMode, UInt& ruiBits )
[313]	5706	{
	5707	if(pcCU->getMergeFlag( 0 ) && pcCU->getPartitionSize( 0 ) == SIZE_2Nx2N && !pcCU->getQtRootCbf( 0 ))
	5708	{
	5709	pcCU->setSkipFlagSubParts( true, 0, pcCU->getDepth(0) );
	5710
	5711	m_pcEntropyCoder->resetBits();
	5712	if(pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	5713	{
	5714	m_pcEntropyCoder->encodeCUTransquantBypassFlag(pcCU, 0, true);
	5715	}
	5716	m_pcEntropyCoder->encodeSkipFlag(pcCU, 0, true);
	5717	m_pcEntropyCoder->encodeMergeIndex(pcCU, 0, true);
[1029]	5718
[313]	5719	ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
	5720	}
	5721	else
	5722	{
	5723	m_pcEntropyCoder->resetBits();
[1029]	5724
[313]	5725	if(pcCU->getSlice()->getPPS()->getTransquantBypassEnableFlag())
	5726	{
	5727	m_pcEntropyCoder->encodeCUTransquantBypassFlag(pcCU, 0, true);
	5728	}
[1029]	5729
[313]	5730	m_pcEntropyCoder->encodeSkipFlag ( pcCU, 0, true );
	5731	m_pcEntropyCoder->encodePredMode( pcCU, 0, true );
	5732	m_pcEntropyCoder->encodePartSize( pcCU, 0, pcCU->getDepth(0), true );
[1029]	5733	m_pcEntropyCoder->encodePredInfo( pcCU, 0 );
	5734
	5735	Bool codeDeltaQp = false;
	5736	Bool codeChromaQpAdj = false;
	5737	m_pcEntropyCoder->encodeCoeff ( pcCU, 0, pcCU->getDepth(0), codeDeltaQp, codeChromaQpAdj );
	5738
[313]	5739	ruiBits += m_pcEntropyCoder->getNumberOfWrittenBits();
	5740	}
	5741	}
	5742
[1029]	5743
	5744
	5745
	5746
[313]	5747	/**
	5748	* \brief Generate half-sample interpolated block
	5749	*
	5750	* \param pattern Reference picture ROI
	5751	* \param biPred Flag indicating whether block is for biprediction
	5752	*/
	5753	Void TEncSearch::xExtDIFUpSamplingH( TComPattern* pattern, Bool biPred )
	5754	{
	5755	Int width = pattern->getROIYWidth();
	5756	Int height = pattern->getROIYHeight();
	5757	Int srcStride = pattern->getPatternLStride();
[1029]	5758
	5759	Int intStride = m_filteredBlockTmp[0].getStride(COMPONENT_Y);
	5760	Int dstStride = m_filteredBlock[0][0].getStride(COMPONENT_Y);
	5761	Pel *intPtr;
	5762	Pel *dstPtr;
[313]	5763	Int filterSize = NTAPS_LUMA;
	5764	Int halfFilterSize = (filterSize>>1);
	5765	Pel srcPtr = pattern->getROIY() - halfFilterSizesrcStride - 1;
[1029]	5766
	5767	const ChromaFormat chFmt = m_filteredBlock[0][0].getChromaFormat();
	5768
	5769	m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, m_filteredBlockTmp[0].getAddr(COMPONENT_Y), intStride, width+1, height+filterSize, 0, false, chFmt);
	5770	m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, m_filteredBlockTmp[2].getAddr(COMPONENT_Y), intStride, width+1, height+filterSize, 2, false, chFmt);
	5771
	5772	intPtr = m_filteredBlockTmp[0].getAddr(COMPONENT_Y) + halfFilterSize * intStride + 1;
	5773	dstPtr = m_filteredBlock[0][0].getAddr(COMPONENT_Y);
	5774	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width+0, height+0, 0, false, true, chFmt);
	5775
	5776	intPtr = m_filteredBlockTmp[0].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride + 1;
	5777	dstPtr = m_filteredBlock[2][0].getAddr(COMPONENT_Y);
	5778	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width+0, height+1, 2, false, true, chFmt);
	5779
	5780	intPtr = m_filteredBlockTmp[2].getAddr(COMPONENT_Y) + halfFilterSize * intStride;
	5781	dstPtr = m_filteredBlock[0][2].getAddr(COMPONENT_Y);
	5782	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width+1, height+0, 0, false, true, chFmt);
	5783
	5784	intPtr = m_filteredBlockTmp[2].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5785	dstPtr = m_filteredBlock[2][2].getAddr(COMPONENT_Y);
	5786	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width+1, height+1, 2, false, true, chFmt);
[313]	5787	}
	5788
[1029]	5789
	5790
	5791
	5792
[313]	5793	/**
	5794	* \brief Generate quarter-sample interpolated blocks
	5795	*
	5796	* \param pattern Reference picture ROI
	5797	* \param halfPelRef Half-pel mv
	5798	* \param biPred Flag indicating whether block is for biprediction
	5799	*/
	5800	Void TEncSearch::xExtDIFUpSamplingQ( TComPattern* pattern, TComMv halfPelRef, Bool biPred )
	5801	{
	5802	Int width = pattern->getROIYWidth();
	5803	Int height = pattern->getROIYHeight();
	5804	Int srcStride = pattern->getPatternLStride();
[1029]	5805
[313]	5806	Pel *srcPtr;
[1029]	5807	Int intStride = m_filteredBlockTmp[0].getStride(COMPONENT_Y);
	5808	Int dstStride = m_filteredBlock[0][0].getStride(COMPONENT_Y);
	5809	Pel *intPtr;
	5810	Pel *dstPtr;
[313]	5811	Int filterSize = NTAPS_LUMA;
[1029]	5812
[313]	5813	Int halfFilterSize = (filterSize>>1);
	5814
	5815	Int extHeight = (halfPelRef.getVer() == 0) ? height + filterSize : height + filterSize-1;
[1029]	5816
	5817	const ChromaFormat chFmt = m_filteredBlock[0][0].getChromaFormat();
	5818
[313]	5819	// Horizontal filter 1/4
	5820	srcPtr = pattern->getROIY() - halfFilterSize * srcStride - 1;
[1029]	5821	intPtr = m_filteredBlockTmp[1].getAddr(COMPONENT_Y);
[313]	5822	if (halfPelRef.getVer() > 0)
	5823	{
	5824	srcPtr += srcStride;
	5825	}
	5826	if (halfPelRef.getHor() >= 0)
	5827	{
	5828	srcPtr += 1;
	5829	}
[1029]	5830	m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, intPtr, intStride, width, extHeight, 1, false, chFmt);
	5831
[313]	5832	// Horizontal filter 3/4
	5833	srcPtr = pattern->getROIY() - halfFilterSize*srcStride - 1;
[1029]	5834	intPtr = m_filteredBlockTmp[3].getAddr(COMPONENT_Y);
[313]	5835	if (halfPelRef.getVer() > 0)
	5836	{
	5837	srcPtr += srcStride;
	5838	}
	5839	if (halfPelRef.getHor() > 0)
	5840	{
	5841	srcPtr += 1;
	5842	}
[1029]	5843	m_if.filterHor(COMPONENT_Y, srcPtr, srcStride, intPtr, intStride, width, extHeight, 3, false, chFmt);
	5844
[313]	5845	// Generate @ 1,1
[1029]	5846	intPtr = m_filteredBlockTmp[1].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5847	dstPtr = m_filteredBlock[1][1].getAddr(COMPONENT_Y);
[313]	5848	if (halfPelRef.getVer() == 0)
	5849	{
	5850	intPtr += intStride;
	5851	}
[1029]	5852	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true, chFmt);
	5853
[313]	5854	// Generate @ 3,1
[1029]	5855	intPtr = m_filteredBlockTmp[1].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5856	dstPtr = m_filteredBlock[3][1].getAddr(COMPONENT_Y);
	5857	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true, chFmt);
	5858
[313]	5859	if (halfPelRef.getVer() != 0)
	5860	{
	5861	// Generate @ 2,1
[1029]	5862	intPtr = m_filteredBlockTmp[1].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5863	dstPtr = m_filteredBlock[2][1].getAddr(COMPONENT_Y);
[313]	5864	if (halfPelRef.getVer() == 0)
	5865	{
	5866	intPtr += intStride;
	5867	}
[1029]	5868	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 2, false, true, chFmt);
	5869
[313]	5870	// Generate @ 2,3
[1029]	5871	intPtr = m_filteredBlockTmp[3].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5872	dstPtr = m_filteredBlock[2][3].getAddr(COMPONENT_Y);
[313]	5873	if (halfPelRef.getVer() == 0)
	5874	{
	5875	intPtr += intStride;
	5876	}
[1029]	5877	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 2, false, true, chFmt);
[313]	5878	}
	5879	else
	5880	{
	5881	// Generate @ 0,1
[1029]	5882	intPtr = m_filteredBlockTmp[1].getAddr(COMPONENT_Y) + halfFilterSize * intStride;
	5883	dstPtr = m_filteredBlock[0][1].getAddr(COMPONENT_Y);
	5884	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 0, false, true, chFmt);
	5885
[313]	5886	// Generate @ 0,3
[1029]	5887	intPtr = m_filteredBlockTmp[3].getAddr(COMPONENT_Y) + halfFilterSize * intStride;
	5888	dstPtr = m_filteredBlock[0][3].getAddr(COMPONENT_Y);
	5889	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 0, false, true, chFmt);
[313]	5890	}
[1029]	5891
[313]	5892	if (halfPelRef.getHor() != 0)
	5893	{
	5894	// Generate @ 1,2
[1029]	5895	intPtr = m_filteredBlockTmp[2].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5896	dstPtr = m_filteredBlock[1][2].getAddr(COMPONENT_Y);
[313]	5897	if (halfPelRef.getHor() > 0)
	5898	{
	5899	intPtr += 1;
	5900	}
	5901	if (halfPelRef.getVer() >= 0)
	5902	{
	5903	intPtr += intStride;
	5904	}
[1029]	5905	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true, chFmt);
	5906
[313]	5907	// Generate @ 3,2
[1029]	5908	intPtr = m_filteredBlockTmp[2].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5909	dstPtr = m_filteredBlock[3][2].getAddr(COMPONENT_Y);
[313]	5910	if (halfPelRef.getHor() > 0)
	5911	{
	5912	intPtr += 1;
	5913	}
	5914	if (halfPelRef.getVer() > 0)
	5915	{
	5916	intPtr += intStride;
	5917	}
[1029]	5918	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true, chFmt);
[313]	5919	}
	5920	else
	5921	{
	5922	// Generate @ 1,0
[1029]	5923	intPtr = m_filteredBlockTmp[0].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride + 1;
	5924	dstPtr = m_filteredBlock[1][0].getAddr(COMPONENT_Y);
[313]	5925	if (halfPelRef.getVer() >= 0)
	5926	{
	5927	intPtr += intStride;
	5928	}
[1029]	5929	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true, chFmt);
	5930
[313]	5931	// Generate @ 3,0
[1029]	5932	intPtr = m_filteredBlockTmp[0].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride + 1;
	5933	dstPtr = m_filteredBlock[3][0].getAddr(COMPONENT_Y);
[313]	5934	if (halfPelRef.getVer() > 0)
	5935	{
	5936	intPtr += intStride;
	5937	}
[1029]	5938	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true, chFmt);
[313]	5939	}
[1029]	5940
[313]	5941	// Generate @ 1,3
[1029]	5942	intPtr = m_filteredBlockTmp[3].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5943	dstPtr = m_filteredBlock[1][3].getAddr(COMPONENT_Y);
[313]	5944	if (halfPelRef.getVer() == 0)
	5945	{
	5946	intPtr += intStride;
	5947	}
[1029]	5948	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 1, false, true, chFmt);
	5949
[313]	5950	// Generate @ 3,3
[1029]	5951	intPtr = m_filteredBlockTmp[3].getAddr(COMPONENT_Y) + (halfFilterSize-1) * intStride;
	5952	dstPtr = m_filteredBlock[3][3].getAddr(COMPONENT_Y);
	5953	m_if.filterVer(COMPONENT_Y, intPtr, intStride, dstPtr, dstStride, width, height, 3, false, true, chFmt);
[313]	5954	}
	5955
[1029]	5956
	5957
	5958
	5959
[313]	5960	/** set wp tables
	5961	* \param TComDataCU* pcCU
	5962	* \param iRefIdx
	5963	* \param eRefPicListCur
	5964	* \returns Void
	5965	*/
	5966	Void TEncSearch::setWpScalingDistParam( TComDataCU* pcCU, Int iRefIdx, RefPicList eRefPicListCur )
	5967	{
	5968	if ( iRefIdx<0 )
	5969	{
	5970	m_cDistParam.bApplyWeight = false;
	5971	return;
	5972	}
	5973
	5974	TComSlice *pcSlice = pcCU->getSlice();
	5975	TComPPS *pps = pcCU->getSlice()->getPPS();
[1029]	5976	WPScalingParam wp0 , wp1;
	5977
[313]	5978	m_cDistParam.bApplyWeight = ( pcSlice->getSliceType()==P_SLICE && pps->getUseWP() ) \|\| ( pcSlice->getSliceType()==B_SLICE && pps->getWPBiPred() ) ;
[1029]	5979
[313]	5980	if ( !m_cDistParam.bApplyWeight ) return;
	5981
	5982	Int iRefIdx0 = ( eRefPicListCur == REF_PIC_LIST_0 ) ? iRefIdx : (-1);
	5983	Int iRefIdx1 = ( eRefPicListCur == REF_PIC_LIST_1 ) ? iRefIdx : (-1);
	5984
	5985	getWpScaling( pcCU, iRefIdx0, iRefIdx1, wp0 , wp1 );
	5986
	5987	if ( iRefIdx0 < 0 ) wp0 = NULL;
	5988	if ( iRefIdx1 < 0 ) wp1 = NULL;
	5989
	5990	m_cDistParam.wpCur = NULL;
	5991
	5992	if ( eRefPicListCur == REF_PIC_LIST_0 )
	5993	{
	5994	m_cDistParam.wpCur = wp0;
	5995	}
	5996	else
	5997	{
	5998	m_cDistParam.wpCur = wp1;
	5999	}
	6000	}
	6001
[595]	6002	#if SVC_EXTENSION
[313]	6003	#if REF_IDX_ME_ZEROMV
[1029]	6004	Void TEncSearch::xPatternSearchFracDIFMv0( TComPattern* pcPatternKey,
	6005	Pel* piRefY,
	6006	Int iRefStride,
	6007	TComMv* pcMvInt,
	6008	TComMv& rcMvHalf,
	6009	TComMv& rcMvQter,
	6010	UInt& ruiCost )
[313]	6011	{
	6012	assert(pcMvInt->getHor() == 0 && pcMvInt->getVer() == 0);
	6013	Int iOffset = pcMvInt->getHor() + pcMvInt->getVer() * iRefStride;
	6014	m_pcRdCost->setDistParam( pcPatternKey, piRefY + iOffset, iRefStride, 1, m_cDistParam, m_pcEncCfg->getUseHADME() );
	6015	m_pcRdCost->setCostScale ( 2 );
[1029]	6016	setDistParamComp(COMPONENT_Y);
[313]	6017	ruiCost = m_cDistParam.DistFunc( &m_cDistParam ); //SATD
	6018	ruiCost += m_pcRdCost->getCost( pcMvInt->getHor(), pcMvInt->getVer() ); //SATD rdCost
	6019	rcMvHalf.setZero();
	6020	rcMvQter.setZero();
	6021	}
	6022	#endif
	6023
	6024	#if ENCODER_FAST_MODE
	6025	Bool TEncSearch::predInterSearchILRUni( TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv& rpcPredYuv, TComYuv& rpcResiYuv, TComYuv*& rpcRecoYuv, UInt refLayerId )
	6026	{
[815]	6027	rpcPredYuv->clear();
	6028	rpcRecoYuv->clear();
[313]	6029
[815]	6030	Int iNumPredDir = pcCU->getSlice()->isInterP() ? 1 : 2;
[313]	6031
[815]	6032	TComMv cMv[2];
	6033	TComMv cMvPred[2][33];
	6034	TComMv cMvTemp[2][33];
	6035	TComMv TempMv;
[313]	6036
[815]	6037	Int iRefIdx[2]={0,0};
[313]	6038
[815]	6039	Int aaiMvpIdx[2][33];
	6040	Int aaiMvpNum[2][33];
[313]	6041
[815]	6042	UInt uiMbBits[3] = {1, 1, 0};
	6043	UInt uiLastMode = 0;
[313]	6044
[815]	6045	UInt uiCost[2] = { MAX_UINT, MAX_UINT }; //uni, rdCost
	6046	UInt uiCostTemp;
	6047	UInt biPDistTemp = MAX_INT;
	6048	UInt uiBitsTemp;
[313]	6049
[815]	6050	PartSize ePartSize = pcCU->getPartitionSize( 0 ); //2Nx2N
	6051	Int iPartIdx = 0; //one PU in CU
	6052	UInt uiPartAddr;
	6053	Int iRoiWidth, iRoiHeight;
	6054	Bool bILRSearched = false;
[313]	6055
[815]	6056	xGetBlkBits( ePartSize, pcCU->getSlice()->isInterP(), iPartIdx, uiLastMode, uiMbBits);
	6057	pcCU->getPartIndexAndSize( iPartIdx, uiPartAddr, iRoiWidth, iRoiHeight );
[313]	6058
[815]	6059	for( Int iRefList = 0; iRefList < iNumPredDir; iRefList++) //list
	6060	{
	6061	if(bILRSearched)
[313]	6062	{
[815]	6063	continue;
	6064	}
[313]	6065
[815]	6066	RefPicList eRefPicList = ( iRefList ? REF_PIC_LIST_1 : REF_PIC_LIST_0 );
[313]	6067
[815]	6068	Int iRefIdxTemp = -1;
	6069	Bool foundILR = false;
[313]	6070
[815]	6071	for( Int refIdx = 0; refIdx < pcCU->getSlice()->getNumRefIdx(eRefPicList); refIdx++ )
	6072	{
	6073	TComPic* refPic = pcCU->getSlice()->getRefPic(eRefPicList, refIdx);
[313]	6074
[815]	6075	// ILRP has to be for the sample prediction type
[1057]	6076	if( refPic->isILR(pcCU->getLayerId()) && refPic->getLayerId() == refLayerId && pcCU->getSlice()->getVPS()->isSamplePredictionType( pcCU->getLayerIdx(), pcCU->getSlice()->getVPS()->getLayerIdxInVps(refLayerId) ) )
[815]	6077	{
	6078	iRefIdxTemp = refIdx;
	6079	foundILR = true;
	6080	bILRSearched = true;
	6081	break;
	6082	}
	6083	}
[313]	6084
[815]	6085	if(!foundILR) //no ILR in eRefPiclist
	6086	{
	6087	continue;
	6088	}
[313]	6089
[815]	6090	uiBitsTemp = uiMbBits[iRefList];
	6091	if ( pcCU->getSlice()->getNumRefIdx(eRefPicList) > 1 )
	6092	{
	6093	uiBitsTemp += iRefIdxTemp+1;
	6094	if ( iRefIdxTemp == pcCU->getSlice()->getNumRefIdx(eRefPicList)-1 ) uiBitsTemp--;
	6095	}
[313]	6096
[815]	6097	xEstimateMvPredAMVP( pcCU, pcOrgYuv, iPartIdx, eRefPicList, iRefIdxTemp, cMvPred[iRefList][iRefIdxTemp], false, &biPDistTemp);
	6098	aaiMvpIdx[iRefList][iRefIdxTemp] = pcCU->getMVPIdx(eRefPicList, uiPartAddr);
	6099	aaiMvpNum[iRefList][iRefIdxTemp] = pcCU->getMVPNum(eRefPicList, uiPartAddr);
[313]	6100
[815]	6101	uiBitsTemp += m_auiMVPIdxCost[aaiMvpIdx[iRefList][iRefIdxTemp]][AMVP_MAX_NUM_CANDS];
[313]	6102
[815]	6103	xMotionEstimation ( pcCU, pcOrgYuv, iPartIdx, eRefPicList, &cMvPred[iRefList][iRefIdxTemp], iRefIdxTemp, cMvTemp[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp );
	6104	xCheckBestMVP(pcCU, eRefPicList, cMvTemp[iRefList][iRefIdxTemp], cMvPred[iRefList][iRefIdxTemp], aaiMvpIdx[iRefList][iRefIdxTemp], uiBitsTemp, uiCostTemp);
[313]	6105
[815]	6106	if( uiCostTemp < uiCost[iRefList] )
	6107	{
	6108	uiCost[iRefList] = uiCostTemp;
[313]	6109
[815]	6110	cMv[iRefList] = cMvTemp[iRefList][iRefIdxTemp];
	6111	iRefIdx[iRefList] = iRefIdxTemp;
[313]	6112
[815]	6113	pcCU->getCUMvField(eRefPicList)->setAllMv( cMv[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
	6114	pcCU->getCUMvField(eRefPicList)->setAllRefIdx( iRefIdx[iRefList], ePartSize, uiPartAddr, 0, iPartIdx );
[313]	6115	}
[815]	6116	}
[313]	6117
[815]	6118	if( uiCost[0] == MAX_UINT && uiCost[1] == MAX_UINT ) //no ILR in both list0 and list1
	6119	{
	6120	return false;
	6121	}
[313]	6122
[815]	6123	// Clear Motion Field
	6124	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx );
	6125	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvField( TComMvField(), ePartSize, uiPartAddr, 0, iPartIdx );
	6126	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd ( TComMv(), ePartSize, uiPartAddr, 0, iPartIdx );
	6127	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd ( TComMv(), ePartSize, uiPartAddr, 0, iPartIdx );
[313]	6128
[815]	6129	pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6130	pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6131	pcCU->setMVPIdxSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6132	pcCU->setMVPNumSubParts( -1, REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
[313]	6133
[815]	6134	if( uiCost[0] <= uiCost[1] ) //list0 ILR
	6135	{
	6136	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMv ( cMv[0], ePartSize, uiPartAddr, 0, iPartIdx );
	6137	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllRefIdx( iRefIdx[0], ePartSize, uiPartAddr, 0, iPartIdx );
[313]	6138
[815]	6139	TempMv = cMv[0] - cMvPred[0][iRefIdx[0]];
	6140	pcCU->getCUMvField(REF_PIC_LIST_0)->setAllMvd( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
[313]	6141
[815]	6142	pcCU->setInterDirSubParts( 1, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
[313]	6143
[815]	6144	pcCU->setMVPIdxSubParts( aaiMvpIdx[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6145	pcCU->setMVPNumSubParts( aaiMvpNum[0][iRefIdx[0]], REF_PIC_LIST_0, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6146	}
	6147	else if( uiCost[1] < uiCost[0] ) //list1 ILR
	6148	{
	6149	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMv ( cMv[1], ePartSize, uiPartAddr, 0, iPartIdx );
	6150	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllRefIdx( iRefIdx[1], ePartSize, uiPartAddr, 0, iPartIdx );
[313]	6151
[815]	6152	TempMv = cMv[1] - cMvPred[1][iRefIdx[1]];
	6153	pcCU->getCUMvField(REF_PIC_LIST_1)->setAllMvd( TempMv, ePartSize, uiPartAddr, 0, iPartIdx );
[313]	6154
[815]	6155	pcCU->setInterDirSubParts( 2, uiPartAddr, iPartIdx, pcCU->getDepth(0) );
[313]	6156
[815]	6157	pcCU->setMVPIdxSubParts( aaiMvpIdx[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6158	pcCU->setMVPNumSubParts( aaiMvpNum[1][iRefIdx[1]], REF_PIC_LIST_1, uiPartAddr, iPartIdx, pcCU->getDepth(uiPartAddr));
	6159	}
	6160	else
	6161	{
	6162	assert(0);
	6163	}
[313]	6164
[815]	6165	pcCU->setMergeFlagSubParts( false, uiPartAddr, iPartIdx, pcCU->getDepth( uiPartAddr ) );
[313]	6166
[815]	6167	motionCompensation ( pcCU, rpcPredYuv, REF_PIC_LIST_X, iPartIdx );
	6168	setWpScalingDistParam( pcCU, -1, REF_PIC_LIST_X );
	6169
	6170	return true;
[313]	6171	}
	6172	#endif
[595]	6173	#endif //SVC_EXTENSION
[313]	6174
	6175	//! \}

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

Download in other formats: