Context navigation

TComRdCost.cpp @ 1200

Visit:

Last change on this file since 1200 was 1200, checked in by tech, 10 years ago

Update to HM-16.5.
Starting point for further re-activation of 3D-tools.

Includes:

active:

MV-HEVC
3D-HLS (apart from DLT)
VSO

inactive:

remaining 3D-HEVC tools.

Property svn:eol-style set to native

File size: 112.0 KB

Rev	Line
[5]	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
[1200]	4	* granted under this license.
[5]	5	*
[1200]	6	* Copyright (c) 2010-2015, ITU/ISO/IEC
[5]	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.
[56]	17	* * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
[5]	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	*/
[2]	33
	34	/** \file TComRdCost.cpp
	35	\brief RD cost computation class
	36	*/
	37
	38	#include <math.h>
	39	#include <assert.h>
[1200]	40	#include <limits>
[56]	41	#include "TComRom.h"
[2]	42	#include "TComRdCost.h"
[1200]	43	#if NH_3D
[2]	44	#include "TComDataCU.h"
[1200]	45	#include "TComRectangle.h"
[608]	46	#endif
[2]	47
[56]	48	//! \ingroup TLibCommon
	49	//! \{
[2]	50
[1200]	51	#if NH_3D_VSO
[608]	52	// SAIT_VSO_EST_A0033
[100]	53	Double TComRdCost::m_dDisparityCoeff = 1.0;
	54	#endif
[2]	55	TComRdCost::TComRdCost()
	56	{
	57	init();
	58	}
	59
	60	TComRdCost::~TComRdCost()
	61	{
	62	}
	63
	64	// Calculate RD functions
[1200]	65	#if NH_3D_VSO
[608]	66	Double TComRdCost::calcRdCost( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
	67	#else
[1200]	68	Double TComRdCost::calcRdCost( UInt uiBits, Distortion uiDistortion, Bool bFlag, DFunc eDFunc )
[608]	69	#endif
[2]	70	{
	71	Double dRdCost = 0.0;
	72	Double dLambda = 0.0;
[1200]	73
[2]	74	switch ( eDFunc )
	75	{
	76	case DF_SSE:
	77	assert(0);
	78	break;
	79	case DF_SAD:
[1200]	80	#if RExt__HIGH_BIT_DEPTH_SUPPORT
	81	dLambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
	82	#else
	83	dLambda = (Double)m_uiLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
	84	#endif
[2]	85	break;
	86	case DF_DEFAULT:
	87	dLambda = m_dLambda;
	88	break;
	89	case DF_SSE_FRAME:
	90	dLambda = m_dFrameLambda;
	91	break;
	92	default:
	93	assert (0);
	94	break;
	95	}
[1200]	96
	97	if (bFlag) //NOTE: this "bFlag" is never true
[2]	98	{
	99	// Intra8x8, Intra4x4 Block only...
[1200]	100	if (m_costMode != COST_STANDARD_LOSSY)
	101	{
	102	dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
	103	}
	104	else
	105	{
	106	dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
	107	}
[2]	108	}
	109	else
	110	{
	111	if (eDFunc == DF_SAD)
	112	{
[1200]	113	if (m_costMode != COST_STANDARD_LOSSY)
	114	{
	115	dRdCost = ((Double(uiDistortion) * 65536) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
	116	}
	117	else
	118	{
	119	dRdCost = floor(Double(uiDistortion) + (floor((Double(uiBits) * dLambda) + 0.5) / 65536.0));
	120	}
[2]	121	}
	122	else
	123	{
[1200]	124	if (m_costMode != COST_STANDARD_LOSSY)
	125	{
	126	dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
	127	}
	128	else
	129	{
	130	dRdCost = floor(Double(uiDistortion) + (Double(uiBits) * dLambda) + 0.5);
	131	}
[2]	132	}
	133	}
[1200]	134
[2]	135	return dRdCost;
	136	}
	137
[1200]	138	#if NH_3D_VSO
[608]	139	Double TComRdCost::calcRdCost64( UInt64 uiBits, Dist64 uiDistortion, Bool bFlag, DFunc eDFunc )
	140	#else
[2]	141	Double TComRdCost::calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag, DFunc eDFunc )
[608]	142	#endif
[2]	143	{
	144	Double dRdCost = 0.0;
	145	Double dLambda = 0.0;
[1200]	146
[2]	147	switch ( eDFunc )
	148	{
	149	case DF_SSE:
	150	assert(0);
	151	break;
	152	case DF_SAD:
[1200]	153	#if RExt__HIGH_BIT_DEPTH_SUPPORT
	154	dLambda = m_dLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
	155	#else
	156	dLambda = (Double)m_uiLambdaMotionSAD[0]; // 0 is valid, because for lossless blocks, the cost equation is modified to compensate.
	157	#endif
[2]	158	break;
	159	case DF_DEFAULT:
	160	dLambda = m_dLambda;
	161	break;
	162	case DF_SSE_FRAME:
	163	dLambda = m_dFrameLambda;
	164	break;
	165	default:
	166	assert (0);
	167	break;
	168	}
[1200]	169
	170	if (bFlag) //NOTE: this "bFlag" is never true
[2]	171	{
	172	// Intra8x8, Intra4x4 Block only...
[1200]	173	if (m_costMode != COST_STANDARD_LOSSY)
	174	{
	175	dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
	176	}
	177	else
	178	{
	179	dRdCost = (((Double)(Int64)uiDistortion) + ((Double)(Int64)uiBits * dLambda));
	180	}
[2]	181	}
	182	else
	183	{
	184	if (eDFunc == DF_SAD)
	185	{
[1200]	186	if (m_costMode != COST_STANDARD_LOSSY)
	187	{
	188	dRdCost = ((Double(uiDistortion) * 65536) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
	189	}
	190	else
	191	{
	192	dRdCost = floor(Double(uiDistortion) + (floor((Double(uiBits) * dLambda) + 0.5) / 65536.0));
	193	}
[2]	194	}
	195	else
	196	{
[1200]	197	if (m_costMode != COST_STANDARD_LOSSY)
	198	{
	199	dRdCost = (Double(uiDistortion) / dLambda) + Double(uiBits); // all lossless costs would have uiDistortion=0, and therefore this cost function can be used.
	200	}
	201	else
	202	{
	203	dRdCost = floor(Double(uiDistortion) + (Double(uiBits) * dLambda) + 0.5);
	204	}
[2]	205	}
	206	}
[1200]	207
[2]	208	return dRdCost;
	209	}
	210
[1200]	211	Void TComRdCost::setLambda( Double dLambda, const BitDepths &bitDepths )
[2]	212	{
	213	m_dLambda = dLambda;
	214	m_sqrtLambda = sqrt(m_dLambda);
[1200]	215	#if RExt__HIGH_BIT_DEPTH_SUPPORT
	216	m_dLambdaMotionSAD[0] = 65536.0 * m_sqrtLambda;
	217	m_dLambdaMotionSSE[0] = 65536.0 * m_dLambda;
	218	#if FULL_NBIT
	219	dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0));
	220	#else
	221	dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (bitDepths.recon[CHANNEL_TYPE_LUMA] - 8)) / 3.0));
	222	#endif
	223	m_dLambdaMotionSAD[1] = 65536.0 * sqrt(dLambda);
	224	m_dLambdaMotionSSE[1] = 65536.0 * dLambda;
	225	#else
	226	m_uiLambdaMotionSAD[0] = (UInt)floor(65536.0 * m_sqrtLambda);
	227	m_uiLambdaMotionSSE[0] = (UInt)floor(65536.0 * m_dLambda );
	228	#if FULL_NBIT
	229	dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0));
	230	#else
	231	dLambda = 0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (bitDepths.recon[CHANNEL_TYPE_LUMA] - 8)) / 3.0));
	232	#endif
	233	m_uiLambdaMotionSAD[1] = (UInt)floor(65536.0 * sqrt(dLambda));
	234	m_uiLambdaMotionSSE[1] = (UInt)floor(65536.0 * dLambda );
	235	#endif
[2]	236	}
	237
	238
	239	// Initalize Function Pointer by [eDFunc]
	240	Void TComRdCost::init()
	241	{
[1200]	242	m_afpDistortFunc[DF_DEFAULT] = NULL; // for DF_DEFAULT
[56]	243
[1200]	244	m_afpDistortFunc[DF_SSE ] = TComRdCost::xGetSSE;
	245	m_afpDistortFunc[DF_SSE4 ] = TComRdCost::xGetSSE4;
	246	m_afpDistortFunc[DF_SSE8 ] = TComRdCost::xGetSSE8;
	247	m_afpDistortFunc[DF_SSE16 ] = TComRdCost::xGetSSE16;
	248	m_afpDistortFunc[DF_SSE32 ] = TComRdCost::xGetSSE32;
	249	m_afpDistortFunc[DF_SSE64 ] = TComRdCost::xGetSSE64;
	250	m_afpDistortFunc[DF_SSE16N ] = TComRdCost::xGetSSE16N;
[608]	251
[1200]	252	m_afpDistortFunc[DF_SAD ] = TComRdCost::xGetSAD;
	253	m_afpDistortFunc[DF_SAD4 ] = TComRdCost::xGetSAD4;
	254	m_afpDistortFunc[DF_SAD8 ] = TComRdCost::xGetSAD8;
	255	m_afpDistortFunc[DF_SAD16 ] = TComRdCost::xGetSAD16;
	256	m_afpDistortFunc[DF_SAD32 ] = TComRdCost::xGetSAD32;
	257	m_afpDistortFunc[DF_SAD64 ] = TComRdCost::xGetSAD64;
	258	m_afpDistortFunc[DF_SAD16N ] = TComRdCost::xGetSAD16N;
	259
	260	m_afpDistortFunc[DF_SADS ] = TComRdCost::xGetSAD;
	261	m_afpDistortFunc[DF_SADS4 ] = TComRdCost::xGetSAD4;
	262	m_afpDistortFunc[DF_SADS8 ] = TComRdCost::xGetSAD8;
	263	m_afpDistortFunc[DF_SADS16 ] = TComRdCost::xGetSAD16;
	264	m_afpDistortFunc[DF_SADS32 ] = TComRdCost::xGetSAD32;
	265	m_afpDistortFunc[DF_SADS64 ] = TComRdCost::xGetSAD64;
	266	m_afpDistortFunc[DF_SADS16N] = TComRdCost::xGetSAD16N;
	267
	268	m_afpDistortFunc[DF_SAD12 ] = TComRdCost::xGetSAD12;
	269	m_afpDistortFunc[DF_SAD24 ] = TComRdCost::xGetSAD24;
	270	m_afpDistortFunc[DF_SAD48 ] = TComRdCost::xGetSAD48;
	271
	272	m_afpDistortFunc[DF_SADS12 ] = TComRdCost::xGetSAD12;
	273	m_afpDistortFunc[DF_SADS24 ] = TComRdCost::xGetSAD24;
	274	m_afpDistortFunc[DF_SADS48 ] = TComRdCost::xGetSAD48;
	275
	276	m_afpDistortFunc[DF_HADS ] = TComRdCost::xGetHADs;
	277	m_afpDistortFunc[DF_HADS4 ] = TComRdCost::xGetHADs;
	278	m_afpDistortFunc[DF_HADS8 ] = TComRdCost::xGetHADs;
	279	m_afpDistortFunc[DF_HADS16 ] = TComRdCost::xGetHADs;
	280	m_afpDistortFunc[DF_HADS32 ] = TComRdCost::xGetHADs;
	281	m_afpDistortFunc[DF_HADS64 ] = TComRdCost::xGetHADs;
	282	m_afpDistortFunc[DF_HADS16N] = TComRdCost::xGetHADs;
	283
	284	#if NH_3D_VSO
[608]	285	// SAIT_VSO_EST_A0033
[100]	286	m_afpDistortFunc[29] = TComRdCost::xGetVSD;
	287	m_afpDistortFunc[30] = TComRdCost::xGetVSD4;
	288	m_afpDistortFunc[31] = TComRdCost::xGetVSD8;
	289	m_afpDistortFunc[32] = TComRdCost::xGetVSD16;
	290	m_afpDistortFunc[33] = TComRdCost::xGetVSD32;
	291	m_afpDistortFunc[34] = TComRdCost::xGetVSD64;
	292	m_afpDistortFunc[35] = TComRdCost::xGetVSD16N;
	293	#endif
[1200]	294
	295	m_costMode = COST_STANDARD_LOSSY;
	296
	297	#if RExt__HIGH_BIT_DEPTH_SUPPORT
	298	m_dCost = 0;
	299	#else
	300	m_uiCost = 0;
[56]	301	#endif
[1200]	302	m_iCostScale = 0;
	303
	304	#if NH_3D_VSO
[2]	305	m_bUseVSO = false;
	306	m_uiVSOMode = 0;
	307	m_fpDistortFuncVSO = NULL;
	308	m_pcRenModel = NULL;
	309
[608]	310	// SAIT_VSO_EST_A0033
	311	m_bUseEstimatedVSD = false;
[2]	312	#endif
[833]	313	#if H_3D_DBBP
	314	m_bUseMask = false;
	315	#endif
[2]	316
	317	}
	318
[1200]	319	// Static member function
	320	UInt TComRdCost::xGetExpGolombNumberOfBits( Int iVal )
[2]	321	{
[1200]	322	assert(iVal != std::numeric_limits<Int>::min());
	323	UInt uiLength = 1;
	324	UInt uiTemp = ( iVal <= 0) ? (UInt(-iVal)<<1)+1: UInt(iVal<<1);
[2]	325
	326	while ( 1 != uiTemp )
	327	{
	328	uiTemp >>= 1;
	329	uiLength += 2;
	330	}
[1200]	331
[2]	332	return uiLength;
	333	}
	334
	335	Void TComRdCost::setDistParam( UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc, DistParam& rcDistParam )
	336	{
	337	// set Block Width / Height
	338	rcDistParam.iCols = uiBlkWidth;
	339	rcDistParam.iRows = uiBlkHeight;
	340	rcDistParam.DistFunc = m_afpDistortFunc[eDFunc + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
[1200]	341
[833]	342	#if H_3D_DBBP
	343	if( m_bUseMask )
	344	{
	345	if( eDFunc >= DF_SSE && eDFunc <= DF_SSE16N )
	346	{
	347	rcDistParam.DistFunc = TComRdCost::xGetMaskedSSE;
	348	}
	349	else if( eDFunc >= DF_SAD && eDFunc <= DF_SADS16N )
	350	{
	351	rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
	352	}
	353	else if( eDFunc >= DF_HADS && eDFunc <= DF_HADS16N )
	354	{
[1179]	355	rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
[833]	356	}
	357	else if( eDFunc >= DF_VSD && eDFunc <= DF_VSD16N )
	358	{
	359	rcDistParam.DistFunc = TComRdCost::xGetMaskedVSD;
	360	}
	361	else if( eDFunc >= DF_SAD12 && eDFunc <= DF_SADS48 )
	362	{
	363	rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
	364	}
	365	}
	366	#endif
[2]	367	// initialize
	368	rcDistParam.iSubShift = 0;
	369	}
	370
	371	// Setting the Distortion Parameter for Inter (ME)
	372	Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, DistParam& rcDistParam )
	373	{
	374	// set Original & Curr Pointer / Stride
	375	rcDistParam.pOrg = pcPatternKey->getROIY();
	376	rcDistParam.pCur = piRefY;
[1200]	377
[2]	378	rcDistParam.iStrideOrg = pcPatternKey->getPatternLStride();
	379	rcDistParam.iStrideCur = iRefStride;
[1200]	380
[2]	381	// set Block Width / Height
	382	rcDistParam.iCols = pcPatternKey->getROIYWidth();
	383	rcDistParam.iRows = pcPatternKey->getROIYHeight();
	384	rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
[1200]	385
[56]	386	if (rcDistParam.iCols == 12)
	387	{
[1200]	388	rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD12];
[56]	389	}
	390	else if (rcDistParam.iCols == 24)
	391	{
[1200]	392	rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD24];
[56]	393	}
	394	else if (rcDistParam.iCols == 48)
	395	{
[1200]	396	rcDistParam.DistFunc = m_afpDistortFunc[DF_SAD48];
[56]	397	}
[1200]	398
[833]	399	#if H_3D_DBBP
	400	if( m_bUseMask )
	401	{
	402	rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
	403	}
	404	#endif
[2]	405	// initialize
	406	rcDistParam.iSubShift = 0;
	407	}
	408
	409	// Setting the Distortion Parameter for Inter (subpel ME with step)
	410	Void TComRdCost::setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME )
	411	{
	412	// set Original & Curr Pointer / Stride
	413	rcDistParam.pOrg = pcPatternKey->getROIY();
	414	rcDistParam.pCur = piRefY;
[1200]	415
[2]	416	rcDistParam.iStrideOrg = pcPatternKey->getPatternLStride();
	417	rcDistParam.iStrideCur = iRefStride * iStep;
[1200]	418
[2]	419	// set Step for interpolated buffer
	420	rcDistParam.iStep = iStep;
[1200]	421
[2]	422	// set Block Width / Height
	423	rcDistParam.iCols = pcPatternKey->getROIYWidth();
	424	rcDistParam.iRows = pcPatternKey->getROIYHeight();
[1200]	425
[2]	426	// set distortion function
	427	if ( !bHADME )
	428	{
	429	rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
[56]	430	if (rcDistParam.iCols == 12)
	431	{
[1200]	432	rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS12];
[56]	433	}
	434	else if (rcDistParam.iCols == 24)
	435	{
[1200]	436	rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS24];
[56]	437	}
	438	else if (rcDistParam.iCols == 48)
	439	{
[1200]	440	rcDistParam.DistFunc = m_afpDistortFunc[DF_SADS48];
[56]	441	}
[2]	442	}
	443	else
	444	{
	445	rcDistParam.DistFunc = m_afpDistortFunc[DF_HADS + g_aucConvertToBit[ rcDistParam.iCols ] + 1 ];
	446	}
[1200]	447
[833]	448	#if H_3D_DBBP
	449	if( m_bUseMask )
	450	{
[1179]	451	rcDistParam.DistFunc = TComRdCost::xGetMaskedSAD;
[833]	452	}
	453	#endif
[2]	454	// initialize
	455	rcDistParam.iSubShift = 0;
	456	}
	457
[1200]	458	Void TComRdCost::setDistParam( DistParam& rcDP, Int bitDepth, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard )
[2]	459	{
	460	rcDP.pOrg = p1;
	461	rcDP.pCur = p2;
	462	rcDP.iStrideOrg = iStride1;
	463	rcDP.iStrideCur = iStride2;
	464	rcDP.iCols = iWidth;
	465	rcDP.iRows = iHeight;
	466	rcDP.iStep = 1;
	467	rcDP.iSubShift = 0;
[608]	468	rcDP.bitDepth = bitDepth;
[2]	469	rcDP.DistFunc = m_afpDistortFunc[ ( bHadamard ? DF_HADS : DF_SADS ) + g_aucConvertToBit[ iWidth ] + 1 ];
[833]	470	#if H_3D_DBBP
	471	if( m_bUseMask )
	472	{
[1179]	473	rcDP.DistFunc = TComRdCost::xGetMaskedSAD;
[833]	474	}
	475	#endif
[2]	476	}
	477
[1200]	478	Distortion TComRdCost::calcHAD( Int bitDepth, Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight )
[2]	479	{
[1200]	480	Distortion uiSum = 0;
[2]	481	Int x, y;
[1200]	482
[2]	483	if ( ( (iWidth % 8) == 0 ) && ( (iHeight % 8) == 0 ) )
	484	{
	485	for ( y=0; y<iHeight; y+= 8 )
	486	{
	487	for ( x=0; x<iWidth; x+= 8 )
	488	{
	489	uiSum += xCalcHADs8x8( &pi0[x], &pi1[x], iStride0, iStride1, 1 );
	490	}
	491	pi0 += iStride0*8;
	492	pi1 += iStride1*8;
	493	}
	494	}
[872]	495	else
[2]	496	{
[1200]	497	assert ( ( (iWidth % 4) == 0 ) && ( (iHeight % 4) == 0 ) );
	498
[2]	499	for ( y=0; y<iHeight; y+= 4 )
	500	{
	501	for ( x=0; x<iWidth; x+= 4 )
	502	{
	503	uiSum += xCalcHADs4x4( &pi0[x], &pi1[x], iStride0, iStride1, 1 );
	504	}
	505	pi0 += iStride0*4;
	506	pi1 += iStride1*4;
	507	}
	508	}
[608]	509
[1200]	510	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8) );
[2]	511	}
[608]	512
[655]	513	#if H_3D_FAST_DEPTH_INTRA
[608]	514
	515	UInt TComRdCost::calcVAR (Pel* pi0, Int stride, Int width, Int height, Int cuDepth)
	516	{
	517	Int temp = 0;
	518
	519	for (Int y = 0; y < height; y++)
	520	{
	521	for (Int x = 0; x < width; x++)
	522	{
	523	temp += pi0[ y * stride + x ];
	524	}
	525	}
	526
	527	Int cuMaxLog2Size = g_aucConvertToBit[g_uiMaxCUWidth]+2;
	528
	529	if ( width == 4 )
	530	{
	531	cuDepth = cuMaxLog2Size - 2;
	532	}
	533
	534	temp = temp >> (cuMaxLog2Size-cuDepth) * 2;
	535
	536	UInt sum = 0;
	537	for (Int y = 0; y < height; y++)
	538	{
	539	for (Int x = 0; x < width; x++)
	540	{
	541	sum += (pi0[ y * stride + x ] - temp ) * (pi0[ y * stride + x ] - temp );
	542	}
	543	}
	544	return (sum >> (cuMaxLog2Size-cuDepth)*2);
	545
[2]	546	}
	547	#endif
	548
[608]	549
[1200]	550	Distortion TComRdCost::getDistPart( Int bitDepth, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, const ComponentID compID, DFunc eDFunc )
[2]	551	{
	552	DistParam cDtParam;
	553	setDistParam( uiBlkWidth, uiBlkHeight, eDFunc, cDtParam );
	554	cDtParam.pOrg = piOrg;
	555	cDtParam.pCur = piCur;
	556	cDtParam.iStrideOrg = iOrgStride;
	557	cDtParam.iStrideCur = iCurStride;
	558	cDtParam.iStep = 1;
[56]	559
	560	cDtParam.bApplyWeight = false;
[1200]	561	cDtParam.compIdx = MAX_NUM_COMPONENT; // just for assert: to be sure it was set before use
	562	cDtParam.bitDepth = bitDepth;
[56]	563
[608]	564	#if H_3D_IC
	565	cDtParam.bUseIC = false;
	566	#endif
[655]	567	#if H_3D_INTER_SDC
[608]	568	cDtParam.bUseSDCMRSAD = false;
	569	#endif
[1200]	570
	571	if (isChroma(compID))
[56]	572	{
[1200]	573	return ((Distortion) (m_distortionWeight[compID] * cDtParam.DistFunc( &cDtParam )));
[56]	574	}
	575	else
	576	{
	577	return cDtParam.DistFunc( &cDtParam );
	578	}
[2]	579	}
[1200]	580	#if NH_3D_VSO
[608]	581	// SAIT_VSO_EST_A0033
[1200]	582	UInt TComRdCost::getDistPartVSD( TComDataCU* pcCU, UInt uiPartOffset, Int bitDepth, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bHAD, DFunc eDFunc )
[100]	583	{
	584	AOT( ( m_dDisparityCoeff <= 0 ) \|\| ( m_dDisparityCoeff > 10 ) );
[56]	585
[1200]	586	Pel* piVirRec = m_pcVideoRecPicYuv->getAddr( COMPONENT_Y, pcCU->getCtuRsAddr( ), pcCU->getZorderIdxInCtu()+uiPartOffset );
	587	Pel* piVirOrg = m_pcDepthPicYuv ->getAddr( COMPONENT_Y, pcCU->getCtuRsAddr( ), pcCU->getZorderIdxInCtu()+uiPartOffset );
	588	Int iVirStride = m_pcVideoRecPicYuv->getStride( COMPONENT_Y );
[608]	589
[100]	590	DistParam cDtParam;
	591	setDistParam( uiBlkWidth, uiBlkHeight, eDFunc, cDtParam );
	592	cDtParam.pOrg = piOrg;
	593	cDtParam.pCur = piCur;
	594	cDtParam.pVirRec = piVirRec;
	595	cDtParam.pVirOrg = piVirOrg;
	596	cDtParam.iStrideVir = iVirStride;
	597	cDtParam.iStrideOrg = iOrgStride;
	598	cDtParam.iStrideCur = iCurStride;
	599	cDtParam.iStep = 1;
	600
[1200]	601	cDtParam.bApplyWeight = false;
[100]	602
[1200]	603	cDtParam.bitDepth = bitDepth;
[884]	604
[608]	605	Dist dist = cDtParam.DistFunc( &cDtParam );
	606
	607	if ( m_bUseWVSO )
	608	{
	609	Int iDWeight = m_iDWeight * m_iDWeight;
	610	Int iVSOWeight = m_iVSDWeight * m_iVSDWeight;
	611	Dist distDepth;
	612
	613	if ( !bHAD )
	614	{
[1200]	615	distDepth = (Dist) getDistPart( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, COMPONENT_Y);
[608]	616	}
	617	else
	618	{
[1200]	619	distDepth = (Dist) calcHAD( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
[608]	620	}
	621
	622	dist = (Dist) (iDWeight * distDepth + iVSOWeight * dist ) / ( iDWeight + iVSOWeight);
	623	}
[655]	624
[608]	625	return (UInt) dist;
[100]	626	}
	627	#endif
	628
[872]	629	#if KWU_RC_MADPRED_E0227
[608]	630	UInt TComRdCost::getSADPart ( Int bitDepth, Pel* pelCur, Int curStride, Pel* pelOrg, Int orgStride, UInt width, UInt height )
	631	{
	632	UInt SAD = 0;
	633	Int shift = DISTORTION_PRECISION_ADJUSTMENT(bitDepth-8);
	634	for ( Int i=0; i<height; i++ )
	635	{
	636	for( Int j=0; j<width; j++ )
	637	{
	638	SAD += abs((pelCur[j] - pelOrg[j])) >> shift;
	639	}
	640	pelCur = pelCur + curStride;
	641	pelOrg = pelOrg + orgStride;
	642	}
	643	return SAD;
	644	}
	645	#endif
	646
	647	// ====================================================================================================================
	648	// Distortion functions
	649	// ====================================================================================================================
	650
[833]	651	#if H_3D_DBBP
[608]	652	// --------------------------------------------------------------------------------------------------------------------
[833]	653	// Masked distortion functions
	654	// --------------------------------------------------------------------------------------------------------------------
	655
	656	UInt TComRdCost::xGetMaskedSSE( DistParam* pcDtParam )
	657	{
	658	Pel* piOrg = pcDtParam->pOrg;
	659	Pel* piCur = pcDtParam->pCur;
	660	Int iRows = pcDtParam->iRows;
	661	Int iCols = pcDtParam->iCols;
	662	Int iStrideOrg = pcDtParam->iStrideOrg;
	663	Int iStrideCur = pcDtParam->iStrideCur;
	664
	665	UInt uiSum = 0;
	666
	667	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	668
	669	Int iTemp;
	670
	671	for( ; iRows != 0; iRows-- )
	672	{
	673	for (Int n = 0; n < iCols; n++ )
	674	{
	675	if( piOrg[n] != DBBP_INVALID_SHORT )
	676	{
	677	iTemp = piOrg[n ] - piCur[n ];
	678	uiSum += ( iTemp * iTemp ) >> uiShift;
	679	}
	680	}
	681	piOrg += iStrideOrg;
	682	piCur += iStrideCur;
	683	}
	684
	685	return ( uiSum );
	686	}
	687
	688	UInt TComRdCost::xGetMaskedSAD( DistParam* pcDtParam )
	689	{
	690
	691	AOF(!pcDtParam->bApplyWeight);
	692	#if H_3D_IC
	693	AOF(!pcDtParam->bUseIC);
	694	#endif
	695
	696	Pel* piOrg = pcDtParam->pOrg;
	697	Pel* piCur = pcDtParam->pCur;
	698	Int iRows = pcDtParam->iRows;
	699	Int iCols = pcDtParam->iCols;
	700	Int iStrideCur = pcDtParam->iStrideCur;
	701	Int iStrideOrg = pcDtParam->iStrideOrg;
	702
	703	UInt uiSum = 0;
	704
	705	for( ; iRows != 0; iRows-- )
	706	{
	707	for (Int n = 0; n < iCols; n++ )
	708	{
	709	if( piOrg[n] != DBBP_INVALID_SHORT )
	710	{
	711	uiSum += abs( piOrg[n] - piCur[n] );
	712	}
	713	}
	714	piOrg += iStrideOrg;
	715	piCur += iStrideCur;
	716	}
	717
	718	return uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8);
	719	}
	720
	721
	722	UInt TComRdCost::xGetMaskedVSD( DistParam* pcDtParam )
	723	{
	724	Pel* piOrg = pcDtParam->pOrg;
	725	Pel* piCur = pcDtParam->pCur;
	726	Pel* piVirRec = pcDtParam->pVirRec;
	727	Pel* piVirOrg = pcDtParam->pVirOrg;
	728	Int iRows = pcDtParam->iRows;
	729	Int iCols = pcDtParam->iCols;
	730	Int iStrideOrg = pcDtParam->iStrideOrg;
	731	Int iStrideCur = pcDtParam->iStrideCur;
	732	Int iStrideVir = pcDtParam->iStrideVir;
	733
	734	UInt uiSum = 0;
	735	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
	736
	737	Int dDM;
	738
	739	for ( Int y = 0 ; y < iRows ; y++ )
	740	{
	741	for (Int x = 0; x < iCols; x++ )
	742	{
	743	if( piOrg[x] != DBBP_INVALID_SHORT )
	744	{
	745	dDM = (Int) ( piOrg[x ] - piCur[x ] );
	746	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
	747	}
	748	}
	749	piOrg += iStrideOrg;
	750	piCur += iStrideCur;
	751	}
	752
	753	return ( uiSum );
	754	}
	755	#endif
	756	// --------------------------------------------------------------------------------------------------------------------
[608]	757	// SAD
	758	// --------------------------------------------------------------------------------------------------------------------
	759
[1200]	760	Distortion TComRdCost::xGetSAD( DistParam* pcDtParam )
[2]	761	{
[56]	762	if ( pcDtParam->bApplyWeight )
	763	{
[1200]	764	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[56]	765	}
[608]	766	#if H_3D_IC
	767	if( pcDtParam->bUseIC )
[189]	768	{
	769	return xGetSADic( pcDtParam );
	770	}
	771	#endif
[655]	772	#if H_3D_INTER_SDC
[608]	773	if( pcDtParam->bUseSDCMRSAD )
	774	{
	775	return xGetSADic( pcDtParam );
	776	}
	777	#endif
[1200]	778
	779	const Pel* piOrg = pcDtParam->pOrg;
	780	const Pel* piCur = pcDtParam->pCur;
[2]	781	Int iRows = pcDtParam->iRows;
	782	Int iCols = pcDtParam->iCols;
	783	Int iStrideCur = pcDtParam->iStrideCur;
	784	Int iStrideOrg = pcDtParam->iStrideOrg;
[1200]	785
	786	Distortion uiSum = 0;
	787
[2]	788	for( ; iRows != 0; iRows-- )
	789	{
	790	for (Int n = 0; n < iCols; n++ )
	791	{
[56]	792	uiSum += abs( piOrg[n] - piCur[n] );
[2]	793	}
	794	piOrg += iStrideOrg;
	795	piCur += iStrideCur;
	796	}
[1200]	797
	798	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	799	}
	800
[1200]	801	Distortion TComRdCost::xGetSAD4( DistParam* pcDtParam )
[2]	802	{
[1200]	803	if ( pcDtParam->bApplyWeight )
[2]	804	{
[1200]	805	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	806	}
[1200]	807
[608]	808	#if H_3D_IC
	809	if( pcDtParam->bUseIC )
[189]	810	{
	811	return xGetSAD4ic( pcDtParam );
	812	}
	813	#endif
[655]	814	#if H_3D_INTER_SDC
[608]	815	if( pcDtParam->bUseSDCMRSAD )
	816	{
	817	return xGetSAD4ic( pcDtParam );
	818	}
	819	#endif
[1200]	820
	821	const Pel* piOrg = pcDtParam->pOrg;
	822	const Pel* piCur = pcDtParam->pCur;
[2]	823	Int iRows = pcDtParam->iRows;
	824	Int iSubShift = pcDtParam->iSubShift;
	825	Int iSubStep = ( 1 << iSubShift );
	826	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	827	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	828
	829	Distortion uiSum = 0;
	830
[2]	831	for( ; iRows != 0; iRows-=iSubStep )
	832	{
[56]	833	uiSum += abs( piOrg[0] - piCur[0] );
	834	uiSum += abs( piOrg[1] - piCur[1] );
	835	uiSum += abs( piOrg[2] - piCur[2] );
	836	uiSum += abs( piOrg[3] - piCur[3] );
[1200]	837
[2]	838	piOrg += iStrideOrg;
	839	piCur += iStrideCur;
	840	}
[1200]	841
[2]	842	uiSum <<= iSubShift;
[1200]	843	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	844	}
	845
[1200]	846	Distortion TComRdCost::xGetSAD8( DistParam* pcDtParam )
[2]	847	{
[56]	848	if ( pcDtParam->bApplyWeight )
[2]	849	{
[1200]	850	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	851	}
[1200]	852
[608]	853	#if H_3D_IC
	854	if( pcDtParam->bUseIC )
[189]	855	{
	856	return xGetSAD8ic( pcDtParam );
	857	}
	858	#endif
[655]	859	#if H_3D_INTER_SDC
[608]	860	if( pcDtParam->bUseSDCMRSAD )
	861	{
	862	return xGetSAD8ic( pcDtParam );
	863	}
	864	#endif
[1200]	865
	866	const Pel* piOrg = pcDtParam->pOrg;
	867	const Pel* piCur = pcDtParam->pCur;
[56]	868	Int iRows = pcDtParam->iRows;
[2]	869	Int iSubShift = pcDtParam->iSubShift;
	870	Int iSubStep = ( 1 << iSubShift );
	871	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	872	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	873
	874	Distortion uiSum = 0;
	875
[2]	876	for( ; iRows != 0; iRows-=iSubStep )
	877	{
	878	uiSum += abs( piOrg[0] - piCur[0] );
	879	uiSum += abs( piOrg[1] - piCur[1] );
	880	uiSum += abs( piOrg[2] - piCur[2] );
	881	uiSum += abs( piOrg[3] - piCur[3] );
[56]	882	uiSum += abs( piOrg[4] - piCur[4] );
	883	uiSum += abs( piOrg[5] - piCur[5] );
	884	uiSum += abs( piOrg[6] - piCur[6] );
	885	uiSum += abs( piOrg[7] - piCur[7] );
[1200]	886
[2]	887	piOrg += iStrideOrg;
	888	piCur += iStrideCur;
	889	}
[1200]	890
[2]	891	uiSum <<= iSubShift;
[1200]	892	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	893	}
	894
[1200]	895	Distortion TComRdCost::xGetSAD16( DistParam* pcDtParam )
[2]	896	{
[56]	897	if ( pcDtParam->bApplyWeight )
[2]	898	{
[1200]	899	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	900	}
[1200]	901
[608]	902	#if H_3D_IC
	903	if( pcDtParam->bUseIC )
[189]	904	{
	905	return xGetSAD16ic( pcDtParam );
	906	}
	907	#endif
[655]	908	#if H_3D_INTER_SDC
[608]	909	if( pcDtParam->bUseSDCMRSAD )
	910	{
	911	return xGetSAD16ic( pcDtParam );
	912	}
	913	#endif
[1200]	914
	915	const Pel* piOrg = pcDtParam->pOrg;
	916	const Pel* piCur = pcDtParam->pCur;
[56]	917	Int iRows = pcDtParam->iRows;
[2]	918	Int iSubShift = pcDtParam->iSubShift;
	919	Int iSubStep = ( 1 << iSubShift );
	920	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	921	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	922
	923	Distortion uiSum = 0;
	924
[2]	925	for( ; iRows != 0; iRows-=iSubStep )
	926	{
	927	uiSum += abs( piOrg[0] - piCur[0] );
	928	uiSum += abs( piOrg[1] - piCur[1] );
	929	uiSum += abs( piOrg[2] - piCur[2] );
	930	uiSum += abs( piOrg[3] - piCur[3] );
	931	uiSum += abs( piOrg[4] - piCur[4] );
	932	uiSum += abs( piOrg[5] - piCur[5] );
	933	uiSum += abs( piOrg[6] - piCur[6] );
	934	uiSum += abs( piOrg[7] - piCur[7] );
[56]	935	uiSum += abs( piOrg[8] - piCur[8] );
	936	uiSum += abs( piOrg[9] - piCur[9] );
	937	uiSum += abs( piOrg[10] - piCur[10] );
	938	uiSum += abs( piOrg[11] - piCur[11] );
	939	uiSum += abs( piOrg[12] - piCur[12] );
	940	uiSum += abs( piOrg[13] - piCur[13] );
	941	uiSum += abs( piOrg[14] - piCur[14] );
	942	uiSum += abs( piOrg[15] - piCur[15] );
[1200]	943
[2]	944	piOrg += iStrideOrg;
	945	piCur += iStrideCur;
	946	}
[1200]	947
[2]	948	uiSum <<= iSubShift;
[1200]	949	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	950	}
	951
[1200]	952	Distortion TComRdCost::xGetSAD12( DistParam* pcDtParam )
[2]	953	{
[56]	954	if ( pcDtParam->bApplyWeight )
[2]	955	{
[1200]	956	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	957	}
[608]	958	#if H_3D_IC
	959	if( pcDtParam->bUseIC )
[189]	960	{
	961	return xGetSAD12ic( pcDtParam );
	962	}
	963	#endif
[655]	964	#if H_3D_INTER_SDC
[608]	965	if( pcDtParam->bUseSDCMRSAD )
	966	{
	967	return xGetSAD12ic( pcDtParam );
	968	}
	969	#endif
[1200]	970
	971	const Pel* piOrg = pcDtParam->pOrg;
	972	const Pel* piCur = pcDtParam->pCur;
[2]	973	Int iRows = pcDtParam->iRows;
	974	Int iSubShift = pcDtParam->iSubShift;
	975	Int iSubStep = ( 1 << iSubShift );
	976	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	977	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	978
	979	Distortion uiSum = 0;
	980
[2]	981	for( ; iRows != 0; iRows-=iSubStep )
	982	{
	983	uiSum += abs( piOrg[0] - piCur[0] );
	984	uiSum += abs( piOrg[1] - piCur[1] );
	985	uiSum += abs( piOrg[2] - piCur[2] );
	986	uiSum += abs( piOrg[3] - piCur[3] );
	987	uiSum += abs( piOrg[4] - piCur[4] );
	988	uiSum += abs( piOrg[5] - piCur[5] );
	989	uiSum += abs( piOrg[6] - piCur[6] );
	990	uiSum += abs( piOrg[7] - piCur[7] );
	991	uiSum += abs( piOrg[8] - piCur[8] );
	992	uiSum += abs( piOrg[9] - piCur[9] );
	993	uiSum += abs( piOrg[10] - piCur[10] );
	994	uiSum += abs( piOrg[11] - piCur[11] );
[1200]	995
[2]	996	piOrg += iStrideOrg;
	997	piCur += iStrideCur;
	998	}
[1200]	999
[2]	1000	uiSum <<= iSubShift;
[1200]	1001	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	1002	}
	1003
[1200]	1004	Distortion TComRdCost::xGetSAD16N( DistParam* pcDtParam )
[2]	1005	{
[608]	1006	#if H_3D_IC
	1007	if( pcDtParam->bUseIC )
[189]	1008	{
	1009	return xGetSAD16Nic( pcDtParam );
	1010	}
	1011	#endif
[655]	1012	#if H_3D_INTER_SDC
[608]	1013	if( pcDtParam->bUseSDCMRSAD )
	1014	{
	1015	return xGetSAD16Nic( pcDtParam );
	1016	}
	1017	#endif
[1200]	1018
	1019	const Pel* piOrg = pcDtParam->pOrg;
	1020	const Pel* piCur = pcDtParam->pCur;
[2]	1021	Int iRows = pcDtParam->iRows;
	1022	Int iCols = pcDtParam->iCols;
	1023	Int iSubShift = pcDtParam->iSubShift;
	1024	Int iSubStep = ( 1 << iSubShift );
	1025	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1026	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	1027
	1028	Distortion uiSum = 0;
	1029
[2]	1030	for( ; iRows != 0; iRows-=iSubStep )
	1031	{
	1032	for (Int n = 0; n < iCols; n+=16 )
	1033	{
	1034	uiSum += abs( piOrg[n+ 0] - piCur[n+ 0] );
	1035	uiSum += abs( piOrg[n+ 1] - piCur[n+ 1] );
	1036	uiSum += abs( piOrg[n+ 2] - piCur[n+ 2] );
	1037	uiSum += abs( piOrg[n+ 3] - piCur[n+ 3] );
	1038	uiSum += abs( piOrg[n+ 4] - piCur[n+ 4] );
	1039	uiSum += abs( piOrg[n+ 5] - piCur[n+ 5] );
	1040	uiSum += abs( piOrg[n+ 6] - piCur[n+ 6] );
	1041	uiSum += abs( piOrg[n+ 7] - piCur[n+ 7] );
	1042	uiSum += abs( piOrg[n+ 8] - piCur[n+ 8] );
	1043	uiSum += abs( piOrg[n+ 9] - piCur[n+ 9] );
	1044	uiSum += abs( piOrg[n+10] - piCur[n+10] );
	1045	uiSum += abs( piOrg[n+11] - piCur[n+11] );
	1046	uiSum += abs( piOrg[n+12] - piCur[n+12] );
	1047	uiSum += abs( piOrg[n+13] - piCur[n+13] );
	1048	uiSum += abs( piOrg[n+14] - piCur[n+14] );
	1049	uiSum += abs( piOrg[n+15] - piCur[n+15] );
	1050	}
	1051	piOrg += iStrideOrg;
	1052	piCur += iStrideCur;
	1053	}
[1200]	1054
[2]	1055	uiSum <<= iSubShift;
[1200]	1056	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	1057	}
	1058
[1200]	1059	Distortion TComRdCost::xGetSAD32( DistParam* pcDtParam )
[2]	1060	{
[56]	1061	if ( pcDtParam->bApplyWeight )
[2]	1062	{
[1200]	1063	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	1064	}
[1200]	1065
[608]	1066	#if H_3D_IC
	1067	if( pcDtParam->bUseIC )
[189]	1068	{
	1069	return xGetSAD32ic( pcDtParam );
	1070	}
	1071	#endif
[655]	1072	#if H_3D_INTER_SDC
[608]	1073	if( pcDtParam->bUseSDCMRSAD )
	1074	{
	1075	return xGetSAD32ic( pcDtParam );
	1076	}
	1077	#endif
[1200]	1078
	1079	const Pel* piOrg = pcDtParam->pOrg;
	1080	const Pel* piCur = pcDtParam->pCur;
[2]	1081	Int iRows = pcDtParam->iRows;
	1082	Int iSubShift = pcDtParam->iSubShift;
	1083	Int iSubStep = ( 1 << iSubShift );
	1084	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1085	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	1086
	1087	Distortion uiSum = 0;
	1088
[2]	1089	for( ; iRows != 0; iRows-=iSubStep )
	1090	{
	1091	uiSum += abs( piOrg[0] - piCur[0] );
	1092	uiSum += abs( piOrg[1] - piCur[1] );
	1093	uiSum += abs( piOrg[2] - piCur[2] );
	1094	uiSum += abs( piOrg[3] - piCur[3] );
	1095	uiSum += abs( piOrg[4] - piCur[4] );
	1096	uiSum += abs( piOrg[5] - piCur[5] );
	1097	uiSum += abs( piOrg[6] - piCur[6] );
	1098	uiSum += abs( piOrg[7] - piCur[7] );
	1099	uiSum += abs( piOrg[8] - piCur[8] );
	1100	uiSum += abs( piOrg[9] - piCur[9] );
	1101	uiSum += abs( piOrg[10] - piCur[10] );
	1102	uiSum += abs( piOrg[11] - piCur[11] );
	1103	uiSum += abs( piOrg[12] - piCur[12] );
	1104	uiSum += abs( piOrg[13] - piCur[13] );
	1105	uiSum += abs( piOrg[14] - piCur[14] );
	1106	uiSum += abs( piOrg[15] - piCur[15] );
	1107	uiSum += abs( piOrg[16] - piCur[16] );
	1108	uiSum += abs( piOrg[17] - piCur[17] );
	1109	uiSum += abs( piOrg[18] - piCur[18] );
	1110	uiSum += abs( piOrg[19] - piCur[19] );
	1111	uiSum += abs( piOrg[20] - piCur[20] );
	1112	uiSum += abs( piOrg[21] - piCur[21] );
	1113	uiSum += abs( piOrg[22] - piCur[22] );
	1114	uiSum += abs( piOrg[23] - piCur[23] );
	1115	uiSum += abs( piOrg[24] - piCur[24] );
	1116	uiSum += abs( piOrg[25] - piCur[25] );
	1117	uiSum += abs( piOrg[26] - piCur[26] );
	1118	uiSum += abs( piOrg[27] - piCur[27] );
	1119	uiSum += abs( piOrg[28] - piCur[28] );
	1120	uiSum += abs( piOrg[29] - piCur[29] );
	1121	uiSum += abs( piOrg[30] - piCur[30] );
	1122	uiSum += abs( piOrg[31] - piCur[31] );
[1200]	1123
[2]	1124	piOrg += iStrideOrg;
	1125	piCur += iStrideCur;
	1126	}
[1200]	1127
[2]	1128	uiSum <<= iSubShift;
[1200]	1129	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	1130	}
	1131
[1200]	1132	Distortion TComRdCost::xGetSAD24( DistParam* pcDtParam )
[56]	1133	{
	1134	if ( pcDtParam->bApplyWeight )
	1135	{
[1200]	1136	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[56]	1137	}
[1200]	1138
[608]	1139	#if H_3D_IC
	1140	if( pcDtParam->bUseIC )
[189]	1141	{
	1142	return xGetSAD24ic( pcDtParam );
	1143	}
	1144	#endif
[655]	1145	#if H_3D_INTER_SDC
[608]	1146	if( pcDtParam->bUseSDCMRSAD )
	1147	{
	1148	return xGetSAD24ic( pcDtParam );
	1149	}
	1150	#endif
[1200]	1151
	1152	const Pel* piOrg = pcDtParam->pOrg;
	1153	const Pel* piCur = pcDtParam->pCur;
[56]	1154	Int iRows = pcDtParam->iRows;
	1155	Int iSubShift = pcDtParam->iSubShift;
	1156	Int iSubStep = ( 1 << iSubShift );
	1157	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1158	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	1159
	1160	Distortion uiSum = 0;
	1161
[56]	1162	for( ; iRows != 0; iRows-=iSubStep )
	1163	{
	1164	uiSum += abs( piOrg[0] - piCur[0] );
	1165	uiSum += abs( piOrg[1] - piCur[1] );
	1166	uiSum += abs( piOrg[2] - piCur[2] );
	1167	uiSum += abs( piOrg[3] - piCur[3] );
	1168	uiSum += abs( piOrg[4] - piCur[4] );
	1169	uiSum += abs( piOrg[5] - piCur[5] );
	1170	uiSum += abs( piOrg[6] - piCur[6] );
	1171	uiSum += abs( piOrg[7] - piCur[7] );
	1172	uiSum += abs( piOrg[8] - piCur[8] );
	1173	uiSum += abs( piOrg[9] - piCur[9] );
	1174	uiSum += abs( piOrg[10] - piCur[10] );
	1175	uiSum += abs( piOrg[11] - piCur[11] );
	1176	uiSum += abs( piOrg[12] - piCur[12] );
	1177	uiSum += abs( piOrg[13] - piCur[13] );
	1178	uiSum += abs( piOrg[14] - piCur[14] );
	1179	uiSum += abs( piOrg[15] - piCur[15] );
	1180	uiSum += abs( piOrg[16] - piCur[16] );
	1181	uiSum += abs( piOrg[17] - piCur[17] );
	1182	uiSum += abs( piOrg[18] - piCur[18] );
	1183	uiSum += abs( piOrg[19] - piCur[19] );
	1184	uiSum += abs( piOrg[20] - piCur[20] );
	1185	uiSum += abs( piOrg[21] - piCur[21] );
	1186	uiSum += abs( piOrg[22] - piCur[22] );
	1187	uiSum += abs( piOrg[23] - piCur[23] );
[1200]	1188
[56]	1189	piOrg += iStrideOrg;
	1190	piCur += iStrideCur;
	1191	}
[1200]	1192
[56]	1193	uiSum <<= iSubShift;
[1200]	1194	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[56]	1195	}
	1196
[1200]	1197	Distortion TComRdCost::xGetSAD64( DistParam* pcDtParam )
[2]	1198	{
[56]	1199	if ( pcDtParam->bApplyWeight )
[2]	1200	{
[1200]	1201	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	1202	}
[1200]	1203
[608]	1204	#if H_3D_IC
	1205	if( pcDtParam->bUseIC )
[189]	1206	{
	1207	return xGetSAD64ic( pcDtParam );
	1208	}
	1209	#endif
[655]	1210	#if H_3D_INTER_SDC
[608]	1211	if( pcDtParam->bUseSDCMRSAD )
	1212	{
	1213	return xGetSAD64ic( pcDtParam );
	1214	}
	1215	#endif
[1200]	1216
	1217	const Pel* piOrg = pcDtParam->pOrg;
	1218	const Pel* piCur = pcDtParam->pCur;
[2]	1219	Int iRows = pcDtParam->iRows;
	1220	Int iSubShift = pcDtParam->iSubShift;
	1221	Int iSubStep = ( 1 << iSubShift );
	1222	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1223	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	1224
	1225	Distortion uiSum = 0;
	1226
[2]	1227	for( ; iRows != 0; iRows-=iSubStep )
	1228	{
	1229	uiSum += abs( piOrg[0] - piCur[0] );
	1230	uiSum += abs( piOrg[1] - piCur[1] );
	1231	uiSum += abs( piOrg[2] - piCur[2] );
	1232	uiSum += abs( piOrg[3] - piCur[3] );
	1233	uiSum += abs( piOrg[4] - piCur[4] );
	1234	uiSum += abs( piOrg[5] - piCur[5] );
	1235	uiSum += abs( piOrg[6] - piCur[6] );
	1236	uiSum += abs( piOrg[7] - piCur[7] );
	1237	uiSum += abs( piOrg[8] - piCur[8] );
	1238	uiSum += abs( piOrg[9] - piCur[9] );
	1239	uiSum += abs( piOrg[10] - piCur[10] );
	1240	uiSum += abs( piOrg[11] - piCur[11] );
	1241	uiSum += abs( piOrg[12] - piCur[12] );
	1242	uiSum += abs( piOrg[13] - piCur[13] );
	1243	uiSum += abs( piOrg[14] - piCur[14] );
	1244	uiSum += abs( piOrg[15] - piCur[15] );
	1245	uiSum += abs( piOrg[16] - piCur[16] );
	1246	uiSum += abs( piOrg[17] - piCur[17] );
	1247	uiSum += abs( piOrg[18] - piCur[18] );
	1248	uiSum += abs( piOrg[19] - piCur[19] );
	1249	uiSum += abs( piOrg[20] - piCur[20] );
	1250	uiSum += abs( piOrg[21] - piCur[21] );
	1251	uiSum += abs( piOrg[22] - piCur[22] );
	1252	uiSum += abs( piOrg[23] - piCur[23] );
	1253	uiSum += abs( piOrg[24] - piCur[24] );
	1254	uiSum += abs( piOrg[25] - piCur[25] );
	1255	uiSum += abs( piOrg[26] - piCur[26] );
	1256	uiSum += abs( piOrg[27] - piCur[27] );
	1257	uiSum += abs( piOrg[28] - piCur[28] );
	1258	uiSum += abs( piOrg[29] - piCur[29] );
	1259	uiSum += abs( piOrg[30] - piCur[30] );
	1260	uiSum += abs( piOrg[31] - piCur[31] );
	1261	uiSum += abs( piOrg[32] - piCur[32] );
	1262	uiSum += abs( piOrg[33] - piCur[33] );
	1263	uiSum += abs( piOrg[34] - piCur[34] );
	1264	uiSum += abs( piOrg[35] - piCur[35] );
	1265	uiSum += abs( piOrg[36] - piCur[36] );
	1266	uiSum += abs( piOrg[37] - piCur[37] );
	1267	uiSum += abs( piOrg[38] - piCur[38] );
	1268	uiSum += abs( piOrg[39] - piCur[39] );
	1269	uiSum += abs( piOrg[40] - piCur[40] );
	1270	uiSum += abs( piOrg[41] - piCur[41] );
	1271	uiSum += abs( piOrg[42] - piCur[42] );
	1272	uiSum += abs( piOrg[43] - piCur[43] );
	1273	uiSum += abs( piOrg[44] - piCur[44] );
	1274	uiSum += abs( piOrg[45] - piCur[45] );
	1275	uiSum += abs( piOrg[46] - piCur[46] );
	1276	uiSum += abs( piOrg[47] - piCur[47] );
	1277	uiSum += abs( piOrg[48] - piCur[48] );
	1278	uiSum += abs( piOrg[49] - piCur[49] );
	1279	uiSum += abs( piOrg[50] - piCur[50] );
	1280	uiSum += abs( piOrg[51] - piCur[51] );
	1281	uiSum += abs( piOrg[52] - piCur[52] );
	1282	uiSum += abs( piOrg[53] - piCur[53] );
	1283	uiSum += abs( piOrg[54] - piCur[54] );
	1284	uiSum += abs( piOrg[55] - piCur[55] );
	1285	uiSum += abs( piOrg[56] - piCur[56] );
	1286	uiSum += abs( piOrg[57] - piCur[57] );
	1287	uiSum += abs( piOrg[58] - piCur[58] );
	1288	uiSum += abs( piOrg[59] - piCur[59] );
	1289	uiSum += abs( piOrg[60] - piCur[60] );
	1290	uiSum += abs( piOrg[61] - piCur[61] );
	1291	uiSum += abs( piOrg[62] - piCur[62] );
	1292	uiSum += abs( piOrg[63] - piCur[63] );
[1200]	1293
[2]	1294	piOrg += iStrideOrg;
	1295	piCur += iStrideCur;
	1296	}
[1200]	1297
[2]	1298	uiSum <<= iSubShift;
[1200]	1299	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[2]	1300	}
	1301
[1200]	1302	Distortion TComRdCost::xGetSAD48( DistParam* pcDtParam )
[2]	1303	{
[56]	1304	if ( pcDtParam->bApplyWeight )
[2]	1305	{
[1200]	1306	return TComRdCostWeightPrediction::xGetSADw( pcDtParam );
[2]	1307	}
[608]	1308	#if H_3D_IC
	1309	if( pcDtParam->bUseIC )
[189]	1310	{
	1311	return xGetSAD48ic( pcDtParam );
	1312	}
	1313	#endif
[655]	1314	#if H_3D_INTER_SDC
[608]	1315	if( pcDtParam->bUseSDCMRSAD )
	1316	{
	1317	return xGetSAD48ic( pcDtParam );
	1318	}
	1319	#endif
[1200]	1320
	1321	const Pel* piOrg = pcDtParam->pOrg;
	1322	const Pel* piCur = pcDtParam->pCur;
[2]	1323	Int iRows = pcDtParam->iRows;
[56]	1324	Int iSubShift = pcDtParam->iSubShift;
	1325	Int iSubStep = ( 1 << iSubShift );
	1326	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1327	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[1200]	1328
	1329	Distortion uiSum = 0;
	1330
[56]	1331	for( ; iRows != 0; iRows-=iSubStep )
[2]	1332	{
[56]	1333	uiSum += abs( piOrg[0] - piCur[0] );
	1334	uiSum += abs( piOrg[1] - piCur[1] );
	1335	uiSum += abs( piOrg[2] - piCur[2] );
	1336	uiSum += abs( piOrg[3] - piCur[3] );
	1337	uiSum += abs( piOrg[4] - piCur[4] );
	1338	uiSum += abs( piOrg[5] - piCur[5] );
	1339	uiSum += abs( piOrg[6] - piCur[6] );
	1340	uiSum += abs( piOrg[7] - piCur[7] );
	1341	uiSum += abs( piOrg[8] - piCur[8] );
	1342	uiSum += abs( piOrg[9] - piCur[9] );
	1343	uiSum += abs( piOrg[10] - piCur[10] );
	1344	uiSum += abs( piOrg[11] - piCur[11] );
	1345	uiSum += abs( piOrg[12] - piCur[12] );
	1346	uiSum += abs( piOrg[13] - piCur[13] );
	1347	uiSum += abs( piOrg[14] - piCur[14] );
	1348	uiSum += abs( piOrg[15] - piCur[15] );
	1349	uiSum += abs( piOrg[16] - piCur[16] );
	1350	uiSum += abs( piOrg[17] - piCur[17] );
	1351	uiSum += abs( piOrg[18] - piCur[18] );
	1352	uiSum += abs( piOrg[19] - piCur[19] );
	1353	uiSum += abs( piOrg[20] - piCur[20] );
	1354	uiSum += abs( piOrg[21] - piCur[21] );
	1355	uiSum += abs( piOrg[22] - piCur[22] );
	1356	uiSum += abs( piOrg[23] - piCur[23] );
	1357	uiSum += abs( piOrg[24] - piCur[24] );
	1358	uiSum += abs( piOrg[25] - piCur[25] );
	1359	uiSum += abs( piOrg[26] - piCur[26] );
	1360	uiSum += abs( piOrg[27] - piCur[27] );
	1361	uiSum += abs( piOrg[28] - piCur[28] );
	1362	uiSum += abs( piOrg[29] - piCur[29] );
	1363	uiSum += abs( piOrg[30] - piCur[30] );
	1364	uiSum += abs( piOrg[31] - piCur[31] );
	1365	uiSum += abs( piOrg[32] - piCur[32] );
	1366	uiSum += abs( piOrg[33] - piCur[33] );
	1367	uiSum += abs( piOrg[34] - piCur[34] );
	1368	uiSum += abs( piOrg[35] - piCur[35] );
	1369	uiSum += abs( piOrg[36] - piCur[36] );
	1370	uiSum += abs( piOrg[37] - piCur[37] );
	1371	uiSum += abs( piOrg[38] - piCur[38] );
	1372	uiSum += abs( piOrg[39] - piCur[39] );
	1373	uiSum += abs( piOrg[40] - piCur[40] );
	1374	uiSum += abs( piOrg[41] - piCur[41] );
	1375	uiSum += abs( piOrg[42] - piCur[42] );
	1376	uiSum += abs( piOrg[43] - piCur[43] );
	1377	uiSum += abs( piOrg[44] - piCur[44] );
	1378	uiSum += abs( piOrg[45] - piCur[45] );
	1379	uiSum += abs( piOrg[46] - piCur[46] );
	1380	uiSum += abs( piOrg[47] - piCur[47] );
[1200]	1381
[2]	1382	piOrg += iStrideOrg;
	1383	piCur += iStrideCur;
	1384	}
[1200]	1385
[189]	1386	uiSum <<= iSubShift;
[1200]	1387	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[189]	1388	}
	1389
[1200]	1390
[655]	1391	#if H_3D_IC \|\| H_3D_INTER_SDC
[189]	1392	UInt TComRdCost::xGetSADic( DistParam* pcDtParam )
	1393	{
	1394	if ( pcDtParam->bApplyWeight )
	1395	{
	1396	return xGetSADw( pcDtParam );
	1397	}
	1398	Pel* piOrg = pcDtParam->pOrg;
	1399	Pel* piCur = pcDtParam->pCur;
	1400	Int iRows = pcDtParam->iRows;
	1401	Int iCols = pcDtParam->iCols;
	1402	Int iStrideCur = pcDtParam->iStrideCur;
	1403	Int iStrideOrg = pcDtParam->iStrideOrg;
[608]	1404
[189]	1405	UInt uiSum = 0;
[608]	1406
[189]	1407	Int iOrigAvg = 0, iCurAvg = 0;
	1408	Int iDeltaC;
	1409
	1410	for( ; iRows != 0; iRows-- )
	1411	{
	1412	for (Int n = 0; n < iCols; n++ )
	1413	{
	1414	iOrigAvg += piOrg[n];
	1415	iCurAvg += piCur[n];
	1416	}
	1417	piOrg += iStrideOrg;
	1418	piCur += iStrideCur;
	1419	}
	1420
	1421	piOrg = pcDtParam->pOrg;
	1422	piCur = pcDtParam->pCur;
	1423	iRows = pcDtParam->iRows;
	1424
	1425	iDeltaC = (iOrigAvg - iCurAvg)/iCols/iRows;
	1426
	1427	for( ; iRows != 0; iRows-- )
	1428	{
	1429	for (Int n = 0; n < iCols; n++ )
	1430	{
	1431	uiSum += abs( piOrg[n] - piCur[n] - iDeltaC );
	1432	}
	1433	piOrg += iStrideOrg;
	1434	piCur += iStrideCur;
	1435	}
	1436
[608]	1437	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	1438	}
	1439
	1440	UInt TComRdCost::xGetSAD4ic( DistParam* pcDtParam )
	1441	{
	1442	if ( pcDtParam->bApplyWeight )
	1443	{
	1444	return xGetSADw( pcDtParam );
	1445	}
	1446	Pel* piOrg = pcDtParam->pOrg;
	1447	Pel* piCur = pcDtParam->pCur;
	1448	Int iRows = pcDtParam->iRows;
	1449	Int iSubShift = pcDtParam->iSubShift;
	1450	Int iSubStep = ( 1 << iSubShift );
	1451	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1452	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1453
[189]	1454	UInt uiSum = 0;
[608]	1455
[189]	1456	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	1457	Int iDeltaC;
	1458
	1459	for( ; iRows != 0; iRows-=iSubStep )
	1460	{
	1461	iOrigAvg += piOrg[0];
	1462	iOrigAvg += piOrg[1];
	1463	iOrigAvg += piOrg[2];
	1464	iOrigAvg += piOrg[3];
	1465
	1466	iCurAvg += piCur[0];
	1467	iCurAvg += piCur[1];
	1468	iCurAvg += piCur[2];
	1469	iCurAvg += piCur[3];
	1470
	1471	piOrg += iStrideOrg;
	1472	piCur += iStrideCur;
	1473	uiRowCnt++;
	1474	}
	1475
	1476	piOrg = pcDtParam->pOrg;
	1477	piCur = pcDtParam->pCur;
	1478	iRows = pcDtParam->iRows;
	1479
	1480	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/4) : 0;
	1481
	1482	for( ; iRows != 0; iRows-=iSubStep )
	1483	{
	1484	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	1485	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	1486	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	1487	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	1488
	1489	piOrg += iStrideOrg;
	1490	piCur += iStrideCur;
	1491	}
[608]	1492
[56]	1493	uiSum <<= iSubShift;
[608]	1494	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[2]	1495	}
[189]	1496
	1497	UInt TComRdCost::xGetSAD8ic( DistParam* pcDtParam )
	1498	{
	1499	if ( pcDtParam->bApplyWeight )
	1500	{
	1501	return xGetSADw( pcDtParam );
	1502	}
	1503	Pel* piOrg = pcDtParam->pOrg;
	1504	Pel* piCur = pcDtParam->pCur;
	1505	Int iRows = pcDtParam->iRows;
	1506	Int iSubShift = pcDtParam->iSubShift;
	1507	Int iSubStep = ( 1 << iSubShift );
	1508	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1509	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1510
[189]	1511	UInt uiSum = 0;
[608]	1512
[189]	1513	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	1514	Int iDeltaC;
	1515
	1516	for( ; iRows != 0; iRows-=iSubStep )
	1517	{
	1518	iOrigAvg += piOrg[0];
	1519	iOrigAvg += piOrg[1];
	1520	iOrigAvg += piOrg[2];
	1521	iOrigAvg += piOrg[3];
	1522	iOrigAvg += piOrg[4];
	1523	iOrigAvg += piOrg[5];
	1524	iOrigAvg += piOrg[6];
	1525	iOrigAvg += piOrg[7];
	1526
	1527	iCurAvg += piCur[0];
	1528	iCurAvg += piCur[1];
	1529	iCurAvg += piCur[2];
	1530	iCurAvg += piCur[3];
	1531	iCurAvg += piCur[4];
	1532	iCurAvg += piCur[5];
	1533	iCurAvg += piCur[6];
	1534	iCurAvg += piCur[7];
	1535
	1536	piOrg += iStrideOrg;
	1537	piCur += iStrideCur;
	1538	uiRowCnt++;
	1539	}
	1540
	1541	piOrg = pcDtParam->pOrg;
	1542	piCur = pcDtParam->pCur;
	1543	iRows = pcDtParam->iRows;
	1544
	1545	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/8) : 0;
	1546
	1547	for( ; iRows != 0; iRows-=iSubStep )
	1548	{
	1549	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	1550	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	1551	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	1552	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	1553	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	1554	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	1555	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	1556	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	1557
	1558	piOrg += iStrideOrg;
	1559	piCur += iStrideCur;
	1560	}
[608]	1561
[189]	1562	uiSum <<= iSubShift;
[608]	1563	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	1564	}
	1565
	1566	UInt TComRdCost::xGetSAD16ic( DistParam* pcDtParam )
	1567	{
	1568	if ( pcDtParam->bApplyWeight )
	1569	{
	1570	return xGetSADw( pcDtParam );
	1571	}
	1572	Pel* piOrg = pcDtParam->pOrg;
	1573	Pel* piCur = pcDtParam->pCur;
	1574	Int iRows = pcDtParam->iRows;
	1575	Int iSubShift = pcDtParam->iSubShift;
	1576	Int iSubStep = ( 1 << iSubShift );
	1577	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1578	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1579
[189]	1580	UInt uiSum = 0;
[608]	1581
[189]	1582	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	1583	Int iDeltaC;
	1584
	1585	for( ; iRows != 0; iRows-=iSubStep )
	1586	{
	1587	iOrigAvg += piOrg[0];
	1588	iOrigAvg += piOrg[1];
	1589	iOrigAvg += piOrg[2];
	1590	iOrigAvg += piOrg[3];
	1591	iOrigAvg += piOrg[4];
	1592	iOrigAvg += piOrg[5];
	1593	iOrigAvg += piOrg[6];
	1594	iOrigAvg += piOrg[7];
	1595	iOrigAvg += piOrg[8];
	1596	iOrigAvg += piOrg[9];
	1597	iOrigAvg += piOrg[10];
	1598	iOrigAvg += piOrg[11];
	1599	iOrigAvg += piOrg[12];
	1600	iOrigAvg += piOrg[13];
	1601	iOrigAvg += piOrg[14];
	1602	iOrigAvg += piOrg[15];
	1603
	1604	iCurAvg += piCur[0];
	1605	iCurAvg += piCur[1];
	1606	iCurAvg += piCur[2];
	1607	iCurAvg += piCur[3];
	1608	iCurAvg += piCur[4];
	1609	iCurAvg += piCur[5];
	1610	iCurAvg += piCur[6];
	1611	iCurAvg += piCur[7];
	1612	iCurAvg += piCur[8];
	1613	iCurAvg += piCur[9];
	1614	iCurAvg += piCur[10];
	1615	iCurAvg += piCur[11];
	1616	iCurAvg += piCur[12];
	1617	iCurAvg += piCur[13];
	1618	iCurAvg += piCur[14];
	1619	iCurAvg += piCur[15];
	1620
	1621	piOrg += iStrideOrg;
	1622	piCur += iStrideCur;
	1623	uiRowCnt++;
	1624	}
	1625
	1626	piOrg = pcDtParam->pOrg;
	1627	piCur = pcDtParam->pCur;
	1628	iRows = pcDtParam->iRows;
	1629
	1630	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/16) : 0;
	1631
	1632	for( ; iRows != 0; iRows-=iSubStep )
	1633	{
	1634	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	1635	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	1636	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	1637	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	1638	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	1639	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	1640	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	1641	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	1642	uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
	1643	uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
	1644	uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
	1645	uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
	1646	uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
	1647	uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
	1648	uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
	1649	uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
	1650
	1651	piOrg += iStrideOrg;
	1652	piCur += iStrideCur;
	1653	}
[608]	1654
[189]	1655	uiSum <<= iSubShift;
[608]	1656	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	1657	}
	1658
	1659	UInt TComRdCost::xGetSAD12ic( DistParam* pcDtParam )
	1660	{
	1661	if ( pcDtParam->bApplyWeight )
	1662	{
	1663	return xGetSADw( pcDtParam );
	1664	}
	1665	Pel* piOrg = pcDtParam->pOrg;
	1666	Pel* piCur = pcDtParam->pCur;
	1667	Int iRows = pcDtParam->iRows;
	1668	Int iSubShift = pcDtParam->iSubShift;
	1669	Int iSubStep = ( 1 << iSubShift );
	1670	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1671	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1672
[189]	1673	UInt uiSum = 0;
[608]	1674
[189]	1675	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	1676	Int iDeltaC;
	1677
	1678	for( ; iRows != 0; iRows-=iSubStep )
	1679	{
	1680	iOrigAvg += piOrg[0];
	1681	iOrigAvg += piOrg[1];
	1682	iOrigAvg += piOrg[2];
	1683	iOrigAvg += piOrg[3];
	1684	iOrigAvg += piOrg[4];
	1685	iOrigAvg += piOrg[5];
	1686	iOrigAvg += piOrg[6];
	1687	iOrigAvg += piOrg[7];
	1688	iOrigAvg += piOrg[8];
	1689	iOrigAvg += piOrg[9];
	1690	iOrigAvg += piOrg[10];
	1691	iOrigAvg += piOrg[11];
	1692
	1693	iCurAvg += piCur[0];
	1694	iCurAvg += piCur[1];
	1695	iCurAvg += piCur[2];
	1696	iCurAvg += piCur[3];
	1697	iCurAvg += piCur[4];
	1698	iCurAvg += piCur[5];
	1699	iCurAvg += piCur[6];
	1700	iCurAvg += piCur[7];
	1701	iCurAvg += piCur[8];
	1702	iCurAvg += piCur[9];
	1703	iCurAvg += piCur[10];
	1704	iCurAvg += piCur[11];
	1705
	1706	piOrg += iStrideOrg;
	1707	piCur += iStrideCur;
	1708	uiRowCnt++;
	1709	}
	1710
	1711	piOrg = pcDtParam->pOrg;
	1712	piCur = pcDtParam->pCur;
	1713	iRows = pcDtParam->iRows;
	1714
	1715	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/12) : 0;
	1716
	1717	for( ; iRows != 0; iRows-=iSubStep )
	1718	{
	1719	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	1720	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	1721	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	1722	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	1723	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	1724	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	1725	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	1726	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	1727	uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
	1728	uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
	1729	uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
	1730	uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
	1731
	1732	piOrg += iStrideOrg;
	1733	piCur += iStrideCur;
	1734	}
[608]	1735
[189]	1736	uiSum <<= iSubShift;
[608]	1737	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	1738	}
[2]	1739
[1200]	1740
[189]	1741	UInt TComRdCost::xGetSAD16Nic( DistParam* pcDtParam )
	1742	{
	1743	Pel* piOrg = pcDtParam->pOrg;
	1744	Pel* piCur = pcDtParam->pCur;
	1745	Int iRows = pcDtParam->iRows;
	1746	Int iCols = pcDtParam->iCols;
	1747	Int iSubShift = pcDtParam->iSubShift;
	1748	Int iSubStep = ( 1 << iSubShift );
	1749	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1750	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1751
[189]	1752	UInt uiSum = 0;
	1753
	1754	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0, uiColCnt = (iCols-1)/16 + 1;
	1755	Int iDeltaC;
	1756
	1757	for( ; iRows != 0; iRows-=iSubStep )
	1758	{
	1759	for (Int n = 0; n < iCols; n+=16 )
	1760	{
	1761	iOrigAvg += piOrg[n + 0];
	1762	iOrigAvg += piOrg[n + 1];
	1763	iOrigAvg += piOrg[n + 2];
	1764	iOrigAvg += piOrg[n + 3];
	1765	iOrigAvg += piOrg[n + 4];
	1766	iOrigAvg += piOrg[n + 5];
	1767	iOrigAvg += piOrg[n + 6];
	1768	iOrigAvg += piOrg[n + 7];
	1769	iOrigAvg += piOrg[n + 8];
	1770	iOrigAvg += piOrg[n + 9];
	1771	iOrigAvg += piOrg[n + 10];
	1772	iOrigAvg += piOrg[n + 11];
	1773	iOrigAvg += piOrg[n + 12];
	1774	iOrigAvg += piOrg[n + 13];
	1775	iOrigAvg += piOrg[n + 14];
	1776	iOrigAvg += piOrg[n + 15];
	1777
	1778	iCurAvg += piCur[n + 0];
	1779	iCurAvg += piCur[n + 1];
	1780	iCurAvg += piCur[n + 2];
	1781	iCurAvg += piCur[n + 3];
	1782	iCurAvg += piCur[n + 4];
	1783	iCurAvg += piCur[n + 5];
	1784	iCurAvg += piCur[n + 6];
	1785	iCurAvg += piCur[n + 7];
	1786	iCurAvg += piCur[n + 8];
	1787	iCurAvg += piCur[n + 9];
	1788	iCurAvg += piCur[n + 10];
	1789	iCurAvg += piCur[n + 11];
	1790	iCurAvg += piCur[n + 12];
	1791	iCurAvg += piCur[n + 13];
	1792	iCurAvg += piCur[n + 14];
	1793	iCurAvg += piCur[n + 15];
	1794	}
	1795	piOrg += iStrideOrg;
	1796	piCur += iStrideCur;
	1797	uiRowCnt++;
	1798	}
	1799	piOrg = pcDtParam->pOrg;
	1800	piCur = pcDtParam->pCur;
	1801	iRows = pcDtParam->iRows;
	1802
	1803	iDeltaC = (uiRowCnt && uiColCnt) ? ((iOrigAvg - iCurAvg)/uiRowCnt/uiColCnt/16) : 0;
	1804
	1805	for( ; iRows != 0; iRows-=iSubStep )
	1806	{
	1807	for (Int n = 0; n < iCols; n+=16 )
	1808	{
	1809	uiSum += abs( piOrg[n+ 0] - piCur[n+ 0] - iDeltaC );
	1810	uiSum += abs( piOrg[n+ 1] - piCur[n+ 1] - iDeltaC );
	1811	uiSum += abs( piOrg[n+ 2] - piCur[n+ 2] - iDeltaC );
	1812	uiSum += abs( piOrg[n+ 3] - piCur[n+ 3] - iDeltaC );
	1813	uiSum += abs( piOrg[n+ 4] - piCur[n+ 4] - iDeltaC );
	1814	uiSum += abs( piOrg[n+ 5] - piCur[n+ 5] - iDeltaC );
	1815	uiSum += abs( piOrg[n+ 6] - piCur[n+ 6] - iDeltaC );
	1816	uiSum += abs( piOrg[n+ 7] - piCur[n+ 7] - iDeltaC );
	1817	uiSum += abs( piOrg[n+ 8] - piCur[n+ 8] - iDeltaC );
	1818	uiSum += abs( piOrg[n+ 9] - piCur[n+ 9] - iDeltaC );
	1819	uiSum += abs( piOrg[n+10] - piCur[n+10] - iDeltaC );
	1820	uiSum += abs( piOrg[n+11] - piCur[n+11] - iDeltaC );
	1821	uiSum += abs( piOrg[n+12] - piCur[n+12] - iDeltaC );
	1822	uiSum += abs( piOrg[n+13] - piCur[n+13] - iDeltaC );
	1823	uiSum += abs( piOrg[n+14] - piCur[n+14] - iDeltaC );
	1824	uiSum += abs( piOrg[n+15] - piCur[n+15] - iDeltaC );
	1825	}
	1826	piOrg += iStrideOrg;
	1827	piCur += iStrideCur;
	1828	}
[608]	1829
[189]	1830	uiSum <<= iSubShift;
[608]	1831	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	1832	}
	1833
	1834	UInt TComRdCost::xGetSAD32ic( DistParam* pcDtParam )
	1835	{
	1836	if ( pcDtParam->bApplyWeight )
	1837	{
	1838	return xGetSADw( pcDtParam );
	1839	}
	1840	Pel* piOrg = pcDtParam->pOrg;
	1841	Pel* piCur = pcDtParam->pCur;
	1842	Int iRows = pcDtParam->iRows;
	1843	Int iSubShift = pcDtParam->iSubShift;
	1844	Int iSubStep = ( 1 << iSubShift );
	1845	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1846	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1847
[189]	1848	UInt uiSum = 0;
[608]	1849
[189]	1850	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	1851	Int iDeltaC;
	1852
	1853	for( ; iRows != 0; iRows-=iSubStep )
	1854	{
	1855	iOrigAvg += piOrg[0];
	1856	iOrigAvg += piOrg[1];
	1857	iOrigAvg += piOrg[2];
	1858	iOrigAvg += piOrg[3];
	1859	iOrigAvg += piOrg[4];
	1860	iOrigAvg += piOrg[5];
	1861	iOrigAvg += piOrg[6];
	1862	iOrigAvg += piOrg[7];
	1863	iOrigAvg += piOrg[8];
	1864	iOrigAvg += piOrg[9];
	1865	iOrigAvg += piOrg[10];
	1866	iOrigAvg += piOrg[11];
	1867	iOrigAvg += piOrg[12];
	1868	iOrigAvg += piOrg[13];
	1869	iOrigAvg += piOrg[14];
	1870	iOrigAvg += piOrg[15];
	1871	iOrigAvg += piOrg[16];
	1872	iOrigAvg += piOrg[17];
	1873	iOrigAvg += piOrg[18];
	1874	iOrigAvg += piOrg[19];
	1875	iOrigAvg += piOrg[20];
	1876	iOrigAvg += piOrg[21];
	1877	iOrigAvg += piOrg[22];
	1878	iOrigAvg += piOrg[23];
	1879	iOrigAvg += piOrg[24];
	1880	iOrigAvg += piOrg[25];
	1881	iOrigAvg += piOrg[26];
	1882	iOrigAvg += piOrg[27];
	1883	iOrigAvg += piOrg[28];
	1884	iOrigAvg += piOrg[29];
	1885	iOrigAvg += piOrg[30];
	1886	iOrigAvg += piOrg[31];
	1887
	1888	iCurAvg += piCur[0];
	1889	iCurAvg += piCur[1];
	1890	iCurAvg += piCur[2];
	1891	iCurAvg += piCur[3];
	1892	iCurAvg += piCur[4];
	1893	iCurAvg += piCur[5];
	1894	iCurAvg += piCur[6];
	1895	iCurAvg += piCur[7];
	1896	iCurAvg += piCur[8];
	1897	iCurAvg += piCur[9];
	1898	iCurAvg += piCur[10];
	1899	iCurAvg += piCur[11];
	1900	iCurAvg += piCur[12];
	1901	iCurAvg += piCur[13];
	1902	iCurAvg += piCur[14];
	1903	iCurAvg += piCur[15];
	1904	iCurAvg += piCur[16];
	1905	iCurAvg += piCur[17];
	1906	iCurAvg += piCur[18];
	1907	iCurAvg += piCur[19];
	1908	iCurAvg += piCur[20];
	1909	iCurAvg += piCur[21];
	1910	iCurAvg += piCur[22];
	1911	iCurAvg += piCur[23];
	1912	iCurAvg += piCur[24];
	1913	iCurAvg += piCur[25];
	1914	iCurAvg += piCur[26];
	1915	iCurAvg += piCur[27];
	1916	iCurAvg += piCur[28];
	1917	iCurAvg += piCur[29];
	1918	iCurAvg += piCur[30];
	1919	iCurAvg += piCur[31];
	1920
	1921	piOrg += iStrideOrg;
	1922	piCur += iStrideCur;
	1923	uiRowCnt++;
	1924	}
	1925
	1926	piOrg = pcDtParam->pOrg;
	1927	piCur = pcDtParam->pCur;
	1928	iRows = pcDtParam->iRows;
	1929
	1930	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/32) : 0;
	1931
	1932	for( ; iRows != 0; iRows-=iSubStep )
	1933	{
	1934	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	1935	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	1936	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	1937	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	1938	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	1939	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	1940	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	1941	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	1942	uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
	1943	uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
	1944	uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
	1945	uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
	1946	uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
	1947	uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
	1948	uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
	1949	uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
	1950	uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
	1951	uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
	1952	uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
	1953	uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
	1954	uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
	1955	uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
	1956	uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
	1957	uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
	1958	uiSum += abs( piOrg[24] - piCur[24] - iDeltaC );
	1959	uiSum += abs( piOrg[25] - piCur[25] - iDeltaC );
	1960	uiSum += abs( piOrg[26] - piCur[26] - iDeltaC );
	1961	uiSum += abs( piOrg[27] - piCur[27] - iDeltaC );
	1962	uiSum += abs( piOrg[28] - piCur[28] - iDeltaC );
	1963	uiSum += abs( piOrg[29] - piCur[29] - iDeltaC );
	1964	uiSum += abs( piOrg[30] - piCur[30] - iDeltaC );
	1965	uiSum += abs( piOrg[31] - piCur[31] - iDeltaC );
	1966
	1967	piOrg += iStrideOrg;
	1968	piCur += iStrideCur;
	1969	}
[608]	1970
[189]	1971	uiSum <<= iSubShift;
[608]	1972	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	1973	}
	1974
[1200]	1975
[189]	1976	UInt TComRdCost::xGetSAD24ic( DistParam* pcDtParam )
	1977	{
	1978	if ( pcDtParam->bApplyWeight )
	1979	{
	1980	return xGetSADw( pcDtParam );
	1981	}
	1982	Pel* piOrg = pcDtParam->pOrg;
	1983	Pel* piCur = pcDtParam->pCur;
	1984	Int iRows = pcDtParam->iRows;
	1985	Int iSubShift = pcDtParam->iSubShift;
	1986	Int iSubStep = ( 1 << iSubShift );
	1987	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	1988	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	1989
[189]	1990	UInt uiSum = 0;
[608]	1991
[189]	1992	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	1993	Int iDeltaC;
	1994
	1995	for( ; iRows != 0; iRows-=iSubStep )
	1996	{
	1997	iOrigAvg += piOrg[0];
	1998	iOrigAvg += piOrg[1];
	1999	iOrigAvg += piOrg[2];
	2000	iOrigAvg += piOrg[3];
	2001	iOrigAvg += piOrg[4];
	2002	iOrigAvg += piOrg[5];
	2003	iOrigAvg += piOrg[6];
	2004	iOrigAvg += piOrg[7];
	2005	iOrigAvg += piOrg[8];
	2006	iOrigAvg += piOrg[9];
	2007	iOrigAvg += piOrg[10];
	2008	iOrigAvg += piOrg[11];
	2009	iOrigAvg += piOrg[12];
	2010	iOrigAvg += piOrg[13];
	2011	iOrigAvg += piOrg[14];
	2012	iOrigAvg += piOrg[15];
	2013	iOrigAvg += piOrg[16];
	2014	iOrigAvg += piOrg[17];
	2015	iOrigAvg += piOrg[18];
	2016	iOrigAvg += piOrg[19];
	2017	iOrigAvg += piOrg[20];
	2018	iOrigAvg += piOrg[21];
	2019	iOrigAvg += piOrg[22];
	2020	iOrigAvg += piOrg[23];
	2021
	2022	iCurAvg += piCur[0];
	2023	iCurAvg += piCur[1];
	2024	iCurAvg += piCur[2];
	2025	iCurAvg += piCur[3];
	2026	iCurAvg += piCur[4];
	2027	iCurAvg += piCur[5];
	2028	iCurAvg += piCur[6];
	2029	iCurAvg += piCur[7];
	2030	iCurAvg += piCur[8];
	2031	iCurAvg += piCur[9];
	2032	iCurAvg += piCur[10];
	2033	iCurAvg += piCur[11];
	2034	iCurAvg += piCur[12];
	2035	iCurAvg += piCur[13];
	2036	iCurAvg += piCur[14];
	2037	iCurAvg += piCur[15];
	2038	iCurAvg += piCur[16];
	2039	iCurAvg += piCur[17];
	2040	iCurAvg += piCur[18];
	2041	iCurAvg += piCur[19];
	2042	iCurAvg += piCur[20];
	2043	iCurAvg += piCur[21];
	2044	iCurAvg += piCur[22];
	2045	iCurAvg += piCur[23];
	2046
	2047	piOrg += iStrideOrg;
	2048	piCur += iStrideCur;
	2049	uiRowCnt++;
	2050	}
	2051
	2052	piOrg = pcDtParam->pOrg;
	2053	piCur = pcDtParam->pCur;
	2054	iRows = pcDtParam->iRows;
[608]	2055
[189]	2056	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/24) : 0;
	2057
	2058	for( ; iRows != 0; iRows-=iSubStep )
	2059	{
	2060	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	2061	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	2062	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	2063	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	2064	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	2065	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	2066	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	2067	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	2068	uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
	2069	uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
	2070	uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
	2071	uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
	2072	uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
	2073	uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
	2074	uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
	2075	uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
	2076	uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
	2077	uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
	2078	uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
	2079	uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
	2080	uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
	2081	uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
	2082	uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
	2083	uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
	2084
	2085	piOrg += iStrideOrg;
	2086	piCur += iStrideCur;
	2087	}
	2088
	2089	uiSum <<= iSubShift;
[608]	2090	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	2091	}
	2092
	2093	UInt TComRdCost::xGetSAD64ic( DistParam* pcDtParam )
	2094	{
	2095	if ( pcDtParam->bApplyWeight )
	2096	{
	2097	return xGetSADw( pcDtParam );
	2098	}
	2099	Pel* piOrg = pcDtParam->pOrg;
	2100	Pel* piCur = pcDtParam->pCur;
	2101	Int iRows = pcDtParam->iRows;
	2102	Int iSubShift = pcDtParam->iSubShift;
	2103	Int iSubStep = ( 1 << iSubShift );
	2104	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	2105	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	2106
[189]	2107	UInt uiSum = 0;
[608]	2108
[189]	2109	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	2110	Int iDeltaC;
	2111
	2112	for( ; iRows != 0; iRows-=iSubStep )
	2113	{
	2114	iOrigAvg += piOrg[0] ;
	2115	iOrigAvg += piOrg[1] ;
	2116	iOrigAvg += piOrg[2] ;
	2117	iOrigAvg += piOrg[3] ;
	2118	iOrigAvg += piOrg[4] ;
	2119	iOrigAvg += piOrg[5] ;
	2120	iOrigAvg += piOrg[6] ;
	2121	iOrigAvg += piOrg[7] ;
	2122	iOrigAvg += piOrg[8] ;
	2123	iOrigAvg += piOrg[9] ;
	2124	iOrigAvg += piOrg[10] ;
	2125	iOrigAvg += piOrg[11] ;
	2126	iOrigAvg += piOrg[12] ;
	2127	iOrigAvg += piOrg[13] ;
	2128	iOrigAvg += piOrg[14] ;
	2129	iOrigAvg += piOrg[15] ;
	2130	iOrigAvg += piOrg[16] ;
	2131	iOrigAvg += piOrg[17] ;
	2132	iOrigAvg += piOrg[18] ;
	2133	iOrigAvg += piOrg[19] ;
	2134	iOrigAvg += piOrg[20] ;
	2135	iOrigAvg += piOrg[21] ;
	2136	iOrigAvg += piOrg[22] ;
	2137	iOrigAvg += piOrg[23] ;
	2138	iOrigAvg += piOrg[24] ;
	2139	iOrigAvg += piOrg[25] ;
	2140	iOrigAvg += piOrg[26] ;
	2141	iOrigAvg += piOrg[27] ;
	2142	iOrigAvg += piOrg[28] ;
	2143	iOrigAvg += piOrg[29] ;
	2144	iOrigAvg += piOrg[30] ;
	2145	iOrigAvg += piOrg[31] ;
	2146	iOrigAvg += piOrg[32] ;
	2147	iOrigAvg += piOrg[33] ;
	2148	iOrigAvg += piOrg[34] ;
	2149	iOrigAvg += piOrg[35] ;
	2150	iOrigAvg += piOrg[36] ;
	2151	iOrigAvg += piOrg[37] ;
	2152	iOrigAvg += piOrg[38] ;
	2153	iOrigAvg += piOrg[39] ;
	2154	iOrigAvg += piOrg[40] ;
	2155	iOrigAvg += piOrg[41] ;
	2156	iOrigAvg += piOrg[42] ;
	2157	iOrigAvg += piOrg[43] ;
	2158	iOrigAvg += piOrg[44] ;
	2159	iOrigAvg += piOrg[45] ;
	2160	iOrigAvg += piOrg[46] ;
	2161	iOrigAvg += piOrg[47] ;
	2162	iOrigAvg += piOrg[48] ;
	2163	iOrigAvg += piOrg[49] ;
	2164	iOrigAvg += piOrg[50] ;
	2165	iOrigAvg += piOrg[51] ;
	2166	iOrigAvg += piOrg[52] ;
	2167	iOrigAvg += piOrg[53] ;
	2168	iOrigAvg += piOrg[54] ;
	2169	iOrigAvg += piOrg[55] ;
	2170	iOrigAvg += piOrg[56] ;
	2171	iOrigAvg += piOrg[57] ;
	2172	iOrigAvg += piOrg[58] ;
	2173	iOrigAvg += piOrg[59] ;
	2174	iOrigAvg += piOrg[60] ;
	2175	iOrigAvg += piOrg[61] ;
	2176	iOrigAvg += piOrg[62] ;
	2177	iOrigAvg += piOrg[63] ;
	2178
	2179	iCurAvg += piCur[0] ;
	2180	iCurAvg += piCur[1] ;
	2181	iCurAvg += piCur[2] ;
	2182	iCurAvg += piCur[3] ;
	2183	iCurAvg += piCur[4] ;
	2184	iCurAvg += piCur[5] ;
	2185	iCurAvg += piCur[6] ;
	2186	iCurAvg += piCur[7] ;
	2187	iCurAvg += piCur[8] ;
	2188	iCurAvg += piCur[9] ;
	2189	iCurAvg += piCur[10] ;
	2190	iCurAvg += piCur[11] ;
	2191	iCurAvg += piCur[12] ;
	2192	iCurAvg += piCur[13] ;
	2193	iCurAvg += piCur[14] ;
	2194	iCurAvg += piCur[15] ;
	2195	iCurAvg += piCur[16] ;
	2196	iCurAvg += piCur[17] ;
	2197	iCurAvg += piCur[18] ;
	2198	iCurAvg += piCur[19] ;
	2199	iCurAvg += piCur[20] ;
	2200	iCurAvg += piCur[21] ;
	2201	iCurAvg += piCur[22] ;
	2202	iCurAvg += piCur[23] ;
	2203	iCurAvg += piCur[24] ;
	2204	iCurAvg += piCur[25] ;
	2205	iCurAvg += piCur[26] ;
	2206	iCurAvg += piCur[27] ;
	2207	iCurAvg += piCur[28] ;
	2208	iCurAvg += piCur[29] ;
	2209	iCurAvg += piCur[30] ;
	2210	iCurAvg += piCur[31] ;
	2211	iCurAvg += piCur[32] ;
	2212	iCurAvg += piCur[33] ;
	2213	iCurAvg += piCur[34] ;
	2214	iCurAvg += piCur[35] ;
	2215	iCurAvg += piCur[36] ;
	2216	iCurAvg += piCur[37] ;
	2217	iCurAvg += piCur[38] ;
	2218	iCurAvg += piCur[39] ;
	2219	iCurAvg += piCur[40] ;
	2220	iCurAvg += piCur[41] ;
	2221	iCurAvg += piCur[42] ;
	2222	iCurAvg += piCur[43] ;
	2223	iCurAvg += piCur[44] ;
	2224	iCurAvg += piCur[45] ;
	2225	iCurAvg += piCur[46] ;
	2226	iCurAvg += piCur[47] ;
	2227	iCurAvg += piCur[48] ;
	2228	iCurAvg += piCur[49] ;
	2229	iCurAvg += piCur[50] ;
	2230	iCurAvg += piCur[51] ;
	2231	iCurAvg += piCur[52] ;
	2232	iCurAvg += piCur[53] ;
	2233	iCurAvg += piCur[54] ;
	2234	iCurAvg += piCur[55] ;
	2235	iCurAvg += piCur[56] ;
	2236	iCurAvg += piCur[57] ;
	2237	iCurAvg += piCur[58] ;
	2238	iCurAvg += piCur[59] ;
	2239	iCurAvg += piCur[60] ;
	2240	iCurAvg += piCur[61] ;
	2241	iCurAvg += piCur[62] ;
	2242	iCurAvg += piCur[63] ;
	2243
	2244	piOrg += iStrideOrg;
	2245	piCur += iStrideCur;
	2246	uiRowCnt++;
	2247	}
	2248
	2249	piOrg = pcDtParam->pOrg;
	2250	piCur = pcDtParam->pCur;
	2251	iRows = pcDtParam->iRows;
	2252
	2253	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/64) : 0;
	2254
	2255	for( ; iRows != 0; iRows-=iSubStep )
	2256	{
	2257	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	2258	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	2259	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	2260	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	2261	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	2262	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	2263	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	2264	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	2265	uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
	2266	uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
	2267	uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
	2268	uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
	2269	uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
	2270	uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
	2271	uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
	2272	uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
	2273	uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
	2274	uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
	2275	uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
	2276	uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
	2277	uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
	2278	uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
	2279	uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
	2280	uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
	2281	uiSum += abs( piOrg[24] - piCur[24] - iDeltaC );
	2282	uiSum += abs( piOrg[25] - piCur[25] - iDeltaC );
	2283	uiSum += abs( piOrg[26] - piCur[26] - iDeltaC );
	2284	uiSum += abs( piOrg[27] - piCur[27] - iDeltaC );
	2285	uiSum += abs( piOrg[28] - piCur[28] - iDeltaC );
	2286	uiSum += abs( piOrg[29] - piCur[29] - iDeltaC );
	2287	uiSum += abs( piOrg[30] - piCur[30] - iDeltaC );
	2288	uiSum += abs( piOrg[31] - piCur[31] - iDeltaC );
	2289	uiSum += abs( piOrg[32] - piCur[32] - iDeltaC );
	2290	uiSum += abs( piOrg[33] - piCur[33] - iDeltaC );
	2291	uiSum += abs( piOrg[34] - piCur[34] - iDeltaC );
	2292	uiSum += abs( piOrg[35] - piCur[35] - iDeltaC );
	2293	uiSum += abs( piOrg[36] - piCur[36] - iDeltaC );
	2294	uiSum += abs( piOrg[37] - piCur[37] - iDeltaC );
	2295	uiSum += abs( piOrg[38] - piCur[38] - iDeltaC );
	2296	uiSum += abs( piOrg[39] - piCur[39] - iDeltaC );
	2297	uiSum += abs( piOrg[40] - piCur[40] - iDeltaC );
	2298	uiSum += abs( piOrg[41] - piCur[41] - iDeltaC );
	2299	uiSum += abs( piOrg[42] - piCur[42] - iDeltaC );
	2300	uiSum += abs( piOrg[43] - piCur[43] - iDeltaC );
	2301	uiSum += abs( piOrg[44] - piCur[44] - iDeltaC );
	2302	uiSum += abs( piOrg[45] - piCur[45] - iDeltaC );
	2303	uiSum += abs( piOrg[46] - piCur[46] - iDeltaC );
	2304	uiSum += abs( piOrg[47] - piCur[47] - iDeltaC );
	2305	uiSum += abs( piOrg[48] - piCur[48] - iDeltaC );
	2306	uiSum += abs( piOrg[49] - piCur[49] - iDeltaC );
	2307	uiSum += abs( piOrg[50] - piCur[50] - iDeltaC );
	2308	uiSum += abs( piOrg[51] - piCur[51] - iDeltaC );
	2309	uiSum += abs( piOrg[52] - piCur[52] - iDeltaC );
	2310	uiSum += abs( piOrg[53] - piCur[53] - iDeltaC );
	2311	uiSum += abs( piOrg[54] - piCur[54] - iDeltaC );
	2312	uiSum += abs( piOrg[55] - piCur[55] - iDeltaC );
	2313	uiSum += abs( piOrg[56] - piCur[56] - iDeltaC );
	2314	uiSum += abs( piOrg[57] - piCur[57] - iDeltaC );
	2315	uiSum += abs( piOrg[58] - piCur[58] - iDeltaC );
	2316	uiSum += abs( piOrg[59] - piCur[59] - iDeltaC );
	2317	uiSum += abs( piOrg[60] - piCur[60] - iDeltaC );
	2318	uiSum += abs( piOrg[61] - piCur[61] - iDeltaC );
	2319	uiSum += abs( piOrg[62] - piCur[62] - iDeltaC );
	2320	uiSum += abs( piOrg[63] - piCur[63] - iDeltaC );
	2321
	2322	piOrg += iStrideOrg;
	2323	piCur += iStrideCur;
	2324	}
[608]	2325
[189]	2326	uiSum <<= iSubShift;
[608]	2327	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	2328	}
	2329
[1200]	2330
[189]	2331	UInt TComRdCost::xGetSAD48ic( DistParam* pcDtParam )
	2332	{
	2333	if ( pcDtParam->bApplyWeight )
	2334	{
	2335	return xGetSADw( pcDtParam );
	2336	}
[608]	2337
[189]	2338	Pel* piOrg = pcDtParam->pOrg;
	2339	Pel* piCur = pcDtParam->pCur;
	2340	Int iRows = pcDtParam->iRows;
	2341	Int iSubShift = pcDtParam->iSubShift;
	2342	Int iSubStep = ( 1 << iSubShift );
	2343	Int iStrideCur = pcDtParam->iStrideCur*iSubStep;
	2344	Int iStrideOrg = pcDtParam->iStrideOrg*iSubStep;
[608]	2345
[189]	2346	UInt uiSum = 0;
[608]	2347
[189]	2348	Int iOrigAvg = 0, iCurAvg = 0, uiRowCnt = 0;
	2349	Int iDeltaC;
	2350
	2351	for( ; iRows != 0; iRows-=iSubStep )
	2352	{
	2353	iOrigAvg += piOrg[0] ;
	2354	iOrigAvg += piOrg[1] ;
	2355	iOrigAvg += piOrg[2] ;
	2356	iOrigAvg += piOrg[3] ;
	2357	iOrigAvg += piOrg[4] ;
	2358	iOrigAvg += piOrg[5] ;
	2359	iOrigAvg += piOrg[6] ;
	2360	iOrigAvg += piOrg[7] ;
	2361	iOrigAvg += piOrg[8] ;
	2362	iOrigAvg += piOrg[9] ;
	2363	iOrigAvg += piOrg[10] ;
	2364	iOrigAvg += piOrg[11] ;
	2365	iOrigAvg += piOrg[12] ;
	2366	iOrigAvg += piOrg[13] ;
	2367	iOrigAvg += piOrg[14] ;
	2368	iOrigAvg += piOrg[15] ;
	2369	iOrigAvg += piOrg[16] ;
	2370	iOrigAvg += piOrg[17] ;
	2371	iOrigAvg += piOrg[18] ;
	2372	iOrigAvg += piOrg[19] ;
	2373	iOrigAvg += piOrg[20] ;
	2374	iOrigAvg += piOrg[21] ;
	2375	iOrigAvg += piOrg[22] ;
	2376	iOrigAvg += piOrg[23] ;
	2377	iOrigAvg += piOrg[24] ;
	2378	iOrigAvg += piOrg[25] ;
	2379	iOrigAvg += piOrg[26] ;
	2380	iOrigAvg += piOrg[27] ;
	2381	iOrigAvg += piOrg[28] ;
	2382	iOrigAvg += piOrg[29] ;
	2383	iOrigAvg += piOrg[30] ;
	2384	iOrigAvg += piOrg[31] ;
	2385	iOrigAvg += piOrg[32] ;
	2386	iOrigAvg += piOrg[33] ;
	2387	iOrigAvg += piOrg[34] ;
	2388	iOrigAvg += piOrg[35] ;
	2389	iOrigAvg += piOrg[36] ;
	2390	iOrigAvg += piOrg[37] ;
	2391	iOrigAvg += piOrg[38] ;
	2392	iOrigAvg += piOrg[39] ;
	2393	iOrigAvg += piOrg[40] ;
	2394	iOrigAvg += piOrg[41] ;
	2395	iOrigAvg += piOrg[42] ;
	2396	iOrigAvg += piOrg[43] ;
	2397	iOrigAvg += piOrg[44] ;
	2398	iOrigAvg += piOrg[45] ;
	2399	iOrigAvg += piOrg[46] ;
	2400	iOrigAvg += piOrg[47] ;
	2401
	2402	iCurAvg += piCur[0] ;
	2403	iCurAvg += piCur[1] ;
	2404	iCurAvg += piCur[2] ;
	2405	iCurAvg += piCur[3] ;
	2406	iCurAvg += piCur[4] ;
	2407	iCurAvg += piCur[5] ;
	2408	iCurAvg += piCur[6] ;
	2409	iCurAvg += piCur[7] ;
	2410	iCurAvg += piCur[8] ;
	2411	iCurAvg += piCur[9] ;
	2412	iCurAvg += piCur[10] ;
	2413	iCurAvg += piCur[11] ;
	2414	iCurAvg += piCur[12] ;
	2415	iCurAvg += piCur[13] ;
	2416	iCurAvg += piCur[14] ;
	2417	iCurAvg += piCur[15] ;
	2418	iCurAvg += piCur[16] ;
	2419	iCurAvg += piCur[17] ;
	2420	iCurAvg += piCur[18] ;
	2421	iCurAvg += piCur[19] ;
	2422	iCurAvg += piCur[20] ;
	2423	iCurAvg += piCur[21] ;
	2424	iCurAvg += piCur[22] ;
	2425	iCurAvg += piCur[23] ;
	2426	iCurAvg += piCur[24] ;
	2427	iCurAvg += piCur[25] ;
	2428	iCurAvg += piCur[26] ;
	2429	iCurAvg += piCur[27] ;
	2430	iCurAvg += piCur[28] ;
	2431	iCurAvg += piCur[29] ;
	2432	iCurAvg += piCur[30] ;
	2433	iCurAvg += piCur[31] ;
	2434	iCurAvg += piCur[32] ;
	2435	iCurAvg += piCur[33] ;
	2436	iCurAvg += piCur[34] ;
	2437	iCurAvg += piCur[35] ;
	2438	iCurAvg += piCur[36] ;
	2439	iCurAvg += piCur[37] ;
	2440	iCurAvg += piCur[38] ;
	2441	iCurAvg += piCur[39] ;
	2442	iCurAvg += piCur[40] ;
	2443	iCurAvg += piCur[41] ;
	2444	iCurAvg += piCur[42] ;
	2445	iCurAvg += piCur[43] ;
	2446	iCurAvg += piCur[44] ;
	2447	iCurAvg += piCur[45] ;
	2448	iCurAvg += piCur[46] ;
	2449	iCurAvg += piCur[47] ;
	2450
	2451	piOrg += iStrideOrg;
	2452	piCur += iStrideCur;
	2453	uiRowCnt++;
	2454	}
	2455
	2456	piOrg = pcDtParam->pOrg;
	2457	piCur = pcDtParam->pCur;
	2458	iRows = pcDtParam->iRows;
	2459
	2460	iDeltaC = uiRowCnt ? ((iOrigAvg - iCurAvg)/uiRowCnt/48) : 0;
	2461
	2462	for( ; iRows != 0; iRows-=iSubStep )
	2463	{
	2464	uiSum += abs( piOrg[0] - piCur[0] - iDeltaC );
	2465	uiSum += abs( piOrg[1] - piCur[1] - iDeltaC );
	2466	uiSum += abs( piOrg[2] - piCur[2] - iDeltaC );
	2467	uiSum += abs( piOrg[3] - piCur[3] - iDeltaC );
	2468	uiSum += abs( piOrg[4] - piCur[4] - iDeltaC );
	2469	uiSum += abs( piOrg[5] - piCur[5] - iDeltaC );
	2470	uiSum += abs( piOrg[6] - piCur[6] - iDeltaC );
	2471	uiSum += abs( piOrg[7] - piCur[7] - iDeltaC );
	2472	uiSum += abs( piOrg[8] - piCur[8] - iDeltaC );
	2473	uiSum += abs( piOrg[9] - piCur[9] - iDeltaC );
	2474	uiSum += abs( piOrg[10] - piCur[10] - iDeltaC );
	2475	uiSum += abs( piOrg[11] - piCur[11] - iDeltaC );
	2476	uiSum += abs( piOrg[12] - piCur[12] - iDeltaC );
	2477	uiSum += abs( piOrg[13] - piCur[13] - iDeltaC );
	2478	uiSum += abs( piOrg[14] - piCur[14] - iDeltaC );
	2479	uiSum += abs( piOrg[15] - piCur[15] - iDeltaC );
	2480	uiSum += abs( piOrg[16] - piCur[16] - iDeltaC );
	2481	uiSum += abs( piOrg[17] - piCur[17] - iDeltaC );
	2482	uiSum += abs( piOrg[18] - piCur[18] - iDeltaC );
	2483	uiSum += abs( piOrg[19] - piCur[19] - iDeltaC );
	2484	uiSum += abs( piOrg[20] - piCur[20] - iDeltaC );
	2485	uiSum += abs( piOrg[21] - piCur[21] - iDeltaC );
	2486	uiSum += abs( piOrg[22] - piCur[22] - iDeltaC );
	2487	uiSum += abs( piOrg[23] - piCur[23] - iDeltaC );
	2488	uiSum += abs( piOrg[24] - piCur[24] - iDeltaC );
	2489	uiSum += abs( piOrg[25] - piCur[25] - iDeltaC );
	2490	uiSum += abs( piOrg[26] - piCur[26] - iDeltaC );
	2491	uiSum += abs( piOrg[27] - piCur[27] - iDeltaC );
	2492	uiSum += abs( piOrg[28] - piCur[28] - iDeltaC );
	2493	uiSum += abs( piOrg[29] - piCur[29] - iDeltaC );
	2494	uiSum += abs( piOrg[30] - piCur[30] - iDeltaC );
	2495	uiSum += abs( piOrg[31] - piCur[31] - iDeltaC );
	2496	uiSum += abs( piOrg[32] - piCur[32] - iDeltaC );
	2497	uiSum += abs( piOrg[33] - piCur[33] - iDeltaC );
	2498	uiSum += abs( piOrg[34] - piCur[34] - iDeltaC );
	2499	uiSum += abs( piOrg[35] - piCur[35] - iDeltaC );
	2500	uiSum += abs( piOrg[36] - piCur[36] - iDeltaC );
	2501	uiSum += abs( piOrg[37] - piCur[37] - iDeltaC );
	2502	uiSum += abs( piOrg[38] - piCur[38] - iDeltaC );
	2503	uiSum += abs( piOrg[39] - piCur[39] - iDeltaC );
	2504	uiSum += abs( piOrg[40] - piCur[40] - iDeltaC );
	2505	uiSum += abs( piOrg[41] - piCur[41] - iDeltaC );
	2506	uiSum += abs( piOrg[42] - piCur[42] - iDeltaC );
	2507	uiSum += abs( piOrg[43] - piCur[43] - iDeltaC );
	2508	uiSum += abs( piOrg[44] - piCur[44] - iDeltaC );
	2509	uiSum += abs( piOrg[45] - piCur[45] - iDeltaC );
	2510	uiSum += abs( piOrg[46] - piCur[46] - iDeltaC );
	2511	uiSum += abs( piOrg[47] - piCur[47] - iDeltaC );
	2512
	2513	piOrg += iStrideOrg;
	2514	piCur += iStrideCur;
	2515	}
[608]	2516
[189]	2517	uiSum <<= iSubShift;
[608]	2518	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[189]	2519	}
	2520	#endif
[2]	2521	// --------------------------------------------------------------------------------------------------------------------
	2522	// SSE
	2523	// --------------------------------------------------------------------------------------------------------------------
	2524
[1200]	2525	Distortion TComRdCost::xGetSSE( DistParam* pcDtParam )
[2]	2526	{
[56]	2527	if ( pcDtParam->bApplyWeight )
[2]	2528	{
[1200]	2529	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2530	}
[1200]	2531	const Pel* piOrg = pcDtParam->pOrg;
	2532	const Pel* piCur = pcDtParam->pCur;
[2]	2533	Int iRows = pcDtParam->iRows;
	2534	Int iCols = pcDtParam->iCols;
	2535	Int iStrideOrg = pcDtParam->iStrideOrg;
	2536	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2537
	2538	Distortion uiSum = 0;
	2539	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2540
	2541	Intermediate_Int iTemp;
	2542
[2]	2543	for( ; iRows != 0; iRows-- )
	2544	{
	2545	for (Int n = 0; n < iCols; n++ )
	2546	{
[56]	2547	iTemp = piOrg[n ] - piCur[n ];
[1200]	2548	uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
[56]	2549	}
[2]	2550	piOrg += iStrideOrg;
	2551	piCur += iStrideCur;
	2552	}
[1200]	2553
[2]	2554	return ( uiSum );
	2555	}
	2556
[1200]	2557	Distortion TComRdCost::xGetSSE4( DistParam* pcDtParam )
[2]	2558	{
[56]	2559	if ( pcDtParam->bApplyWeight )
[2]	2560	{
	2561	assert( pcDtParam->iCols == 4 );
[1200]	2562	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2563	}
[1200]	2564	const Pel* piOrg = pcDtParam->pOrg;
	2565	const Pel* piCur = pcDtParam->pCur;
[2]	2566	Int iRows = pcDtParam->iRows;
	2567	Int iStrideOrg = pcDtParam->iStrideOrg;
	2568	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2569
	2570	Distortion uiSum = 0;
	2571	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2572
	2573	Intermediate_Int iTemp;
	2574
[2]	2575	for( ; iRows != 0; iRows-- )
	2576	{
[1200]	2577
	2578	iTemp = piOrg[0] - piCur[0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2579	iTemp = piOrg[1] - piCur[1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2580	iTemp = piOrg[2] - piCur[2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2581	iTemp = piOrg[3] - piCur[3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2582
[2]	2583	piOrg += iStrideOrg;
	2584	piCur += iStrideCur;
	2585	}
[1200]	2586
[2]	2587	return ( uiSum );
	2588	}
	2589
[1200]	2590	Distortion TComRdCost::xGetSSE8( DistParam* pcDtParam )
[2]	2591	{
[56]	2592	if ( pcDtParam->bApplyWeight )
[2]	2593	{
	2594	assert( pcDtParam->iCols == 8 );
[1200]	2595	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2596	}
[1200]	2597	const Pel* piOrg = pcDtParam->pOrg;
	2598	const Pel* piCur = pcDtParam->pCur;
[2]	2599	Int iRows = pcDtParam->iRows;
	2600	Int iStrideOrg = pcDtParam->iStrideOrg;
	2601	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2602
	2603	Distortion uiSum = 0;
	2604	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2605
	2606	Intermediate_Int iTemp;
	2607
[2]	2608	for( ; iRows != 0; iRows-- )
	2609	{
[1200]	2610	iTemp = piOrg[0] - piCur[0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2611	iTemp = piOrg[1] - piCur[1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2612	iTemp = piOrg[2] - piCur[2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2613	iTemp = piOrg[3] - piCur[3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2614	iTemp = piOrg[4] - piCur[4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2615	iTemp = piOrg[5] - piCur[5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2616	iTemp = piOrg[6] - piCur[6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2617	iTemp = piOrg[7] - piCur[7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2618
[2]	2619	piOrg += iStrideOrg;
	2620	piCur += iStrideCur;
	2621	}
[1200]	2622
[2]	2623	return ( uiSum );
	2624	}
	2625
[1200]	2626	Distortion TComRdCost::xGetSSE16( DistParam* pcDtParam )
[2]	2627	{
[56]	2628	if ( pcDtParam->bApplyWeight )
[2]	2629	{
	2630	assert( pcDtParam->iCols == 16 );
[1200]	2631	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2632	}
[1200]	2633	const Pel* piOrg = pcDtParam->pOrg;
	2634	const Pel* piCur = pcDtParam->pCur;
[2]	2635	Int iRows = pcDtParam->iRows;
	2636	Int iStrideOrg = pcDtParam->iStrideOrg;
	2637	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2638
	2639	Distortion uiSum = 0;
	2640	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2641
	2642	Intermediate_Int iTemp;
	2643
[2]	2644	for( ; iRows != 0; iRows-- )
	2645	{
[1200]	2646
	2647	iTemp = piOrg[ 0] - piCur[ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2648	iTemp = piOrg[ 1] - piCur[ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2649	iTemp = piOrg[ 2] - piCur[ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2650	iTemp = piOrg[ 3] - piCur[ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2651	iTemp = piOrg[ 4] - piCur[ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2652	iTemp = piOrg[ 5] - piCur[ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2653	iTemp = piOrg[ 6] - piCur[ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2654	iTemp = piOrg[ 7] - piCur[ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2655	iTemp = piOrg[ 8] - piCur[ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2656	iTemp = piOrg[ 9] - piCur[ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2657	iTemp = piOrg[10] - piCur[10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2658	iTemp = piOrg[11] - piCur[11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2659	iTemp = piOrg[12] - piCur[12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2660	iTemp = piOrg[13] - piCur[13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2661	iTemp = piOrg[14] - piCur[14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2662	iTemp = piOrg[15] - piCur[15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2663
[2]	2664	piOrg += iStrideOrg;
	2665	piCur += iStrideCur;
	2666	}
[1200]	2667
[2]	2668	return ( uiSum );
	2669	}
	2670
[1200]	2671	Distortion TComRdCost::xGetSSE16N( DistParam* pcDtParam )
[2]	2672	{
[56]	2673	if ( pcDtParam->bApplyWeight )
[2]	2674	{
[1200]	2675	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2676	}
[1200]	2677	const Pel* piOrg = pcDtParam->pOrg;
	2678	const Pel* piCur = pcDtParam->pCur;
[2]	2679	Int iRows = pcDtParam->iRows;
	2680	Int iCols = pcDtParam->iCols;
	2681	Int iStrideOrg = pcDtParam->iStrideOrg;
	2682	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2683
	2684	Distortion uiSum = 0;
	2685	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2686
	2687	Intermediate_Int iTemp;
	2688
[2]	2689	for( ; iRows != 0; iRows-- )
	2690	{
	2691	for (Int n = 0; n < iCols; n+=16 )
	2692	{
[1200]	2693
	2694	iTemp = piOrg[n+ 0] - piCur[n+ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2695	iTemp = piOrg[n+ 1] - piCur[n+ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2696	iTemp = piOrg[n+ 2] - piCur[n+ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2697	iTemp = piOrg[n+ 3] - piCur[n+ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2698	iTemp = piOrg[n+ 4] - piCur[n+ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2699	iTemp = piOrg[n+ 5] - piCur[n+ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2700	iTemp = piOrg[n+ 6] - piCur[n+ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2701	iTemp = piOrg[n+ 7] - piCur[n+ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2702	iTemp = piOrg[n+ 8] - piCur[n+ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2703	iTemp = piOrg[n+ 9] - piCur[n+ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2704	iTemp = piOrg[n+10] - piCur[n+10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2705	iTemp = piOrg[n+11] - piCur[n+11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2706	iTemp = piOrg[n+12] - piCur[n+12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2707	iTemp = piOrg[n+13] - piCur[n+13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2708	iTemp = piOrg[n+14] - piCur[n+14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2709	iTemp = piOrg[n+15] - piCur[n+15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2710
[2]	2711	}
	2712	piOrg += iStrideOrg;
	2713	piCur += iStrideCur;
	2714	}
[1200]	2715
[2]	2716	return ( uiSum );
	2717	}
	2718
[1200]	2719	Distortion TComRdCost::xGetSSE32( DistParam* pcDtParam )
[2]	2720	{
[56]	2721	if ( pcDtParam->bApplyWeight )
[2]	2722	{
	2723	assert( pcDtParam->iCols == 32 );
[1200]	2724	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2725	}
[1200]	2726	const Pel* piOrg = pcDtParam->pOrg;
	2727	const Pel* piCur = pcDtParam->pCur;
[2]	2728	Int iRows = pcDtParam->iRows;
	2729	Int iStrideOrg = pcDtParam->iStrideOrg;
	2730	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2731
	2732	Distortion uiSum = 0;
	2733	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2734
	2735	Intermediate_Int iTemp;
	2736
[2]	2737	for( ; iRows != 0; iRows-- )
	2738	{
[1200]	2739
	2740	iTemp = piOrg[ 0] - piCur[ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2741	iTemp = piOrg[ 1] - piCur[ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2742	iTemp = piOrg[ 2] - piCur[ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2743	iTemp = piOrg[ 3] - piCur[ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2744	iTemp = piOrg[ 4] - piCur[ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2745	iTemp = piOrg[ 5] - piCur[ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2746	iTemp = piOrg[ 6] - piCur[ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2747	iTemp = piOrg[ 7] - piCur[ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2748	iTemp = piOrg[ 8] - piCur[ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2749	iTemp = piOrg[ 9] - piCur[ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2750	iTemp = piOrg[10] - piCur[10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2751	iTemp = piOrg[11] - piCur[11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2752	iTemp = piOrg[12] - piCur[12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2753	iTemp = piOrg[13] - piCur[13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2754	iTemp = piOrg[14] - piCur[14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2755	iTemp = piOrg[15] - piCur[15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2756	iTemp = piOrg[16] - piCur[16]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2757	iTemp = piOrg[17] - piCur[17]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2758	iTemp = piOrg[18] - piCur[18]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2759	iTemp = piOrg[19] - piCur[19]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2760	iTemp = piOrg[20] - piCur[20]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2761	iTemp = piOrg[21] - piCur[21]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2762	iTemp = piOrg[22] - piCur[22]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2763	iTemp = piOrg[23] - piCur[23]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2764	iTemp = piOrg[24] - piCur[24]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2765	iTemp = piOrg[25] - piCur[25]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2766	iTemp = piOrg[26] - piCur[26]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2767	iTemp = piOrg[27] - piCur[27]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2768	iTemp = piOrg[28] - piCur[28]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2769	iTemp = piOrg[29] - piCur[29]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2770	iTemp = piOrg[30] - piCur[30]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2771	iTemp = piOrg[31] - piCur[31]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2772
[2]	2773	piOrg += iStrideOrg;
	2774	piCur += iStrideCur;
	2775	}
[1200]	2776
[2]	2777	return ( uiSum );
	2778	}
	2779
[1200]	2780	Distortion TComRdCost::xGetSSE64( DistParam* pcDtParam )
[2]	2781	{
[56]	2782	if ( pcDtParam->bApplyWeight )
[2]	2783	{
	2784	assert( pcDtParam->iCols == 64 );
[1200]	2785	return TComRdCostWeightPrediction::xGetSSEw( pcDtParam );
[2]	2786	}
[1200]	2787	const Pel* piOrg = pcDtParam->pOrg;
	2788	const Pel* piCur = pcDtParam->pCur;
[2]	2789	Int iRows = pcDtParam->iRows;
	2790	Int iStrideOrg = pcDtParam->iStrideOrg;
	2791	Int iStrideCur = pcDtParam->iStrideCur;
[1200]	2792
	2793	Distortion uiSum = 0;
	2794	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT((pcDtParam->bitDepth-8) << 1);
	2795
	2796	Intermediate_Int iTemp;
	2797
[2]	2798	for( ; iRows != 0; iRows-- )
	2799	{
[1200]	2800	iTemp = piOrg[ 0] - piCur[ 0]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2801	iTemp = piOrg[ 1] - piCur[ 1]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2802	iTemp = piOrg[ 2] - piCur[ 2]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2803	iTemp = piOrg[ 3] - piCur[ 3]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2804	iTemp = piOrg[ 4] - piCur[ 4]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2805	iTemp = piOrg[ 5] - piCur[ 5]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2806	iTemp = piOrg[ 6] - piCur[ 6]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2807	iTemp = piOrg[ 7] - piCur[ 7]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2808	iTemp = piOrg[ 8] - piCur[ 8]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2809	iTemp = piOrg[ 9] - piCur[ 9]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2810	iTemp = piOrg[10] - piCur[10]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2811	iTemp = piOrg[11] - piCur[11]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2812	iTemp = piOrg[12] - piCur[12]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2813	iTemp = piOrg[13] - piCur[13]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2814	iTemp = piOrg[14] - piCur[14]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2815	iTemp = piOrg[15] - piCur[15]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2816	iTemp = piOrg[16] - piCur[16]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2817	iTemp = piOrg[17] - piCur[17]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2818	iTemp = piOrg[18] - piCur[18]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2819	iTemp = piOrg[19] - piCur[19]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2820	iTemp = piOrg[20] - piCur[20]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2821	iTemp = piOrg[21] - piCur[21]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2822	iTemp = piOrg[22] - piCur[22]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2823	iTemp = piOrg[23] - piCur[23]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2824	iTemp = piOrg[24] - piCur[24]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2825	iTemp = piOrg[25] - piCur[25]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2826	iTemp = piOrg[26] - piCur[26]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2827	iTemp = piOrg[27] - piCur[27]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2828	iTemp = piOrg[28] - piCur[28]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2829	iTemp = piOrg[29] - piCur[29]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2830	iTemp = piOrg[30] - piCur[30]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2831	iTemp = piOrg[31] - piCur[31]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2832	iTemp = piOrg[32] - piCur[32]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2833	iTemp = piOrg[33] - piCur[33]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2834	iTemp = piOrg[34] - piCur[34]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2835	iTemp = piOrg[35] - piCur[35]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2836	iTemp = piOrg[36] - piCur[36]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2837	iTemp = piOrg[37] - piCur[37]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2838	iTemp = piOrg[38] - piCur[38]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2839	iTemp = piOrg[39] - piCur[39]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2840	iTemp = piOrg[40] - piCur[40]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2841	iTemp = piOrg[41] - piCur[41]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2842	iTemp = piOrg[42] - piCur[42]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2843	iTemp = piOrg[43] - piCur[43]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2844	iTemp = piOrg[44] - piCur[44]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2845	iTemp = piOrg[45] - piCur[45]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2846	iTemp = piOrg[46] - piCur[46]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2847	iTemp = piOrg[47] - piCur[47]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2848	iTemp = piOrg[48] - piCur[48]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2849	iTemp = piOrg[49] - piCur[49]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2850	iTemp = piOrg[50] - piCur[50]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2851	iTemp = piOrg[51] - piCur[51]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2852	iTemp = piOrg[52] - piCur[52]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2853	iTemp = piOrg[53] - piCur[53]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2854	iTemp = piOrg[54] - piCur[54]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2855	iTemp = piOrg[55] - piCur[55]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2856	iTemp = piOrg[56] - piCur[56]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2857	iTemp = piOrg[57] - piCur[57]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2858	iTemp = piOrg[58] - piCur[58]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2859	iTemp = piOrg[59] - piCur[59]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2860	iTemp = piOrg[60] - piCur[60]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2861	iTemp = piOrg[61] - piCur[61]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2862	iTemp = piOrg[62] - piCur[62]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2863	iTemp = piOrg[63] - piCur[63]; uiSum += Distortion(( iTemp * iTemp ) >> uiShift);
	2864
[2]	2865	piOrg += iStrideOrg;
	2866	piCur += iStrideCur;
	2867	}
[1200]	2868
[2]	2869	return ( uiSum );
	2870	}
[1200]	2871
	2872	#if NH_3D_VSO
[608]	2873	//SAIT_VSO_EST_A0033
[100]	2874	UInt TComRdCost::getVSDEstimate( Int dDM, Pel* pOrg, Int iOrgStride, Pel* pVirRec, Pel* pVirOrg, Int iVirStride, Int x, Int y )
[1200]	2875	{
	2876	// change to use bit depth from DistParam struct
	2877	Double dD = ( (Double) ( dDM >> ( ENC_INTERNAL_BIT_DEPTH - 8 ) ) ) * m_dDisparityCoeff;
[100]	2878
[1200]	2879	Double dDepthWeight = ( pOrg[x] >= ( (1<<(REN_BIT_DEPTH - 3)) + (1<<(REN_BIT_DEPTH - 2)) ) ? 4 : pOrg[x] > ((1<<REN_BIT_DEPTH) >> 4) ? (Float)(pOrg[x] - ((1<<REN_BIT_DEPTH) >> 4))/(Float)((1<<REN_BIT_DEPTH) >> 3) + 1 : 1.0 );
	2880
[833]	2881	Double dTemp = ( 0.5 * fabs(dD) * dDepthWeight * ( abs( (Int) pVirRec[ x+yiVirStride ] - (Int) pVirRec[ x-1+yiVirStride ] ) + abs( (Int) pVirRec[ x+yiVirStride ] - (Int) pVirRec[ x+1+yiVirStride ] ) ) );
[1196]	2882	Int iTemp = (Int) (((dTemp) < 0)? (Int)((dTemp) - 0.5) : (Int)((dTemp) + 0.5));
[100]	2883
	2884	return (UInt) ( (iTemp*iTemp)>>1 );
	2885	}
	2886
	2887	UInt TComRdCost::xGetVSD( DistParam* pcDtParam )
	2888	{
	2889	Pel* piOrg = pcDtParam->pOrg;
	2890	Pel* piCur = pcDtParam->pCur;
	2891	Pel* piVirRec = pcDtParam->pVirRec;
	2892	Pel* piVirOrg = pcDtParam->pVirOrg;
	2893	Int iRows = pcDtParam->iRows;
	2894	Int iCols = pcDtParam->iCols;
	2895	Int iStrideOrg = pcDtParam->iStrideOrg;
	2896	Int iStrideCur = pcDtParam->iStrideCur;
	2897	Int iStrideVir = pcDtParam->iStrideVir;
	2898
	2899	UInt uiSum = 0;
[608]	2900	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	2901
	2902	Int dDM;
	2903
	2904	for ( Int y = 0 ; y < iRows ; y++ )
	2905	{
	2906	for (Int x = 0; x < iCols; x++ )
	2907	{
	2908	dDM = (Int) ( piOrg[x ] - piCur[x ] );
	2909	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
	2910	}
	2911	piOrg += iStrideOrg;
	2912	piCur += iStrideCur;
	2913	}
	2914
	2915	return ( uiSum );
	2916	}
	2917
	2918	UInt TComRdCost::xGetVSD4( DistParam* pcDtParam )
	2919	{
	2920	Pel* piOrg = pcDtParam->pOrg;
	2921	Pel* piCur = pcDtParam->pCur;
	2922	Pel* piVirRec = pcDtParam->pVirRec;
	2923	Pel* piVirOrg = pcDtParam->pVirOrg;
	2924	Int iRows = pcDtParam->iRows;
	2925	Int iStrideOrg = pcDtParam->iStrideOrg;
	2926	Int iStrideCur = pcDtParam->iStrideCur;
	2927	Int iStrideVir = pcDtParam->iStrideVir;
	2928
	2929	UInt uiSum = 0;
[608]	2930	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	2931
	2932	Int dDM;
	2933
	2934	for ( Int y = 0 ; y < iRows ; y++ )
	2935	{
	2936	dDM = (Int) ( piOrg[0] - piCur[0] ); uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 0, y ) ) >> uiShift;
	2937	dDM = (Int) ( piOrg[1] - piCur[1] ); uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 1, y ) ) >> uiShift;
	2938	dDM = (Int) ( piOrg[2] - piCur[2] ); uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 2, y ) ) >> uiShift;
	2939	dDM = (Int) ( piOrg[3] - piCur[3] ); uiSum += ( getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, 3, y ) ) >> uiShift;
	2940
	2941	piOrg += iStrideOrg;
	2942	piCur += iStrideCur;
	2943	}
	2944
	2945	return ( uiSum );
	2946	}
	2947
	2948	UInt TComRdCost::xGetVSD8( DistParam* pcDtParam )
	2949	{
	2950	Pel* piOrg = pcDtParam->pOrg;
	2951	Pel* piCur = pcDtParam->pCur;
	2952	Pel* piVirRec = pcDtParam->pVirRec;
	2953	Pel* piVirOrg = pcDtParam->pVirOrg;
	2954	Int iRows = pcDtParam->iRows;
	2955	Int iStrideOrg = pcDtParam->iStrideOrg;
	2956	Int iStrideCur = pcDtParam->iStrideCur;
	2957	Int iStrideVir = pcDtParam->iStrideVir;
	2958
	2959	UInt uiSum = 0;
[608]	2960	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	2961
	2962	Int dDM;
	2963
	2964	for ( Int y = 0 ; y < iRows ; y++ )
	2965	{
	2966	for (Int x = 0; x < 8; x++ )
	2967	{
	2968	dDM = (Int) ( piOrg[x] - piCur[x] );
	2969	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
	2970	}
	2971	piOrg += iStrideOrg;
	2972	piCur += iStrideCur;
	2973	}
	2974
	2975	return ( uiSum );
	2976	}
	2977
	2978	UInt TComRdCost::xGetVSD16( DistParam* pcDtParam )
	2979	{
	2980	Pel* piOrg = pcDtParam->pOrg;
	2981	Pel* piCur = pcDtParam->pCur;
	2982	Pel* piVirRec = pcDtParam->pVirRec;
	2983	Pel* piVirOrg = pcDtParam->pVirOrg;
	2984	Int iRows = pcDtParam->iRows;
	2985	Int iStrideOrg = pcDtParam->iStrideOrg;
	2986	Int iStrideCur = pcDtParam->iStrideCur;
	2987	Int iStrideVir = pcDtParam->iStrideVir;
	2988
	2989	UInt uiSum = 0;
[608]	2990	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	2991
	2992	Int dDM;
	2993
	2994	for ( Int y = 0 ; y < iRows ; y++ )
	2995	{
	2996	for (Int x = 0; x < 16; x++ )
	2997	{
	2998	dDM = (Int) ( piOrg[x] - piCur[x] );
	2999	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
	3000	}
	3001	piOrg += iStrideOrg;
	3002	piCur += iStrideCur;
	3003	}
	3004
	3005	return ( uiSum );
	3006	}
	3007
	3008	UInt TComRdCost::xGetVSD16N( DistParam* pcDtParam )
	3009	{
	3010	Pel* piOrg = pcDtParam->pOrg;
	3011	Pel* piCur = pcDtParam->pCur;
	3012	Pel* piVirRec = pcDtParam->pVirRec;
	3013	Pel* piVirOrg = pcDtParam->pVirOrg;
	3014	Int iRows = pcDtParam->iRows;
	3015	Int iCols = pcDtParam->iCols;
	3016	Int iStrideOrg = pcDtParam->iStrideOrg;
	3017	Int iStrideCur = pcDtParam->iStrideCur;
	3018	Int iStrideVir = pcDtParam->iStrideVir;
	3019
	3020	UInt uiSum = 0;
[608]	3021	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	3022
	3023	Int dDM;
	3024
	3025	for ( Int y = 0 ; y < iRows ; y++ )
	3026	{
	3027	for (Int x = 0; x < iCols; x+=16 )
	3028	{
	3029	for ( Int k = 0 ; k < 16 ; k++ )
	3030	{
	3031	dDM = (Int) ( piOrg[x+k] - piCur[x+k] );
	3032	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x+k, y ) >> uiShift;
	3033	}
	3034	}
	3035	piOrg += iStrideOrg;
	3036	piCur += iStrideCur;
	3037	}
	3038
	3039	return ( uiSum );
	3040	}
	3041
	3042	UInt TComRdCost::xGetVSD32( DistParam* pcDtParam )
	3043	{
	3044	Pel* piOrg = pcDtParam->pOrg;
	3045	Pel* piCur = pcDtParam->pCur;
	3046	Pel* piVirRec = pcDtParam->pVirRec;
	3047	Pel* piVirOrg = pcDtParam->pVirOrg;
	3048	Int iRows = pcDtParam->iRows;
	3049	Int iStrideOrg = pcDtParam->iStrideOrg;
	3050	Int iStrideCur = pcDtParam->iStrideCur;
	3051	Int iStrideVir = pcDtParam->iStrideVir;
	3052
	3053	UInt uiSum = 0;
[608]	3054	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	3055
	3056	Int dDM;
	3057
	3058	for ( Int y = 0 ; y < iRows ; y++ )
	3059	{
	3060	for (Int x = 0; x < 32 ; x++ )
	3061	{
	3062	dDM = (Int) ( piOrg[x] - piCur[x] );
	3063	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
	3064	}
	3065	piOrg += iStrideOrg;
	3066	piCur += iStrideCur;
	3067	}
	3068
	3069	return ( uiSum );
	3070	}
	3071
	3072	UInt TComRdCost::xGetVSD64( DistParam* pcDtParam )
	3073	{
	3074	Pel* piOrg = pcDtParam->pOrg;
	3075	Pel* piCur = pcDtParam->pCur;
	3076	Pel* piVirRec = pcDtParam->pVirRec;
	3077	Pel* piVirOrg = pcDtParam->pVirOrg;
	3078	Int iRows = pcDtParam->iRows;
	3079	Int iStrideOrg = pcDtParam->iStrideOrg;
	3080	Int iStrideCur = pcDtParam->iStrideCur;
	3081	Int iStrideVir = pcDtParam->iStrideVir;
	3082
	3083	UInt uiSum = 0;
[608]	3084	UInt uiShift = DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8)<<1;
[100]	3085
	3086	Int dDM;
	3087
	3088	for ( Int y = 0 ; y < iRows ; y++ )
	3089	{
	3090	for (Int x = 0; x < 64; x++ )
	3091	{
	3092	dDM = (Int) ( piOrg[x] - piCur[x] );
	3093	uiSum += getVSDEstimate( dDM, piOrg, iStrideOrg, piVirRec, piVirOrg, iStrideVir, x, y ) >> uiShift;
	3094	}
	3095	piOrg += iStrideOrg;
	3096	piCur += iStrideCur;
	3097	}
	3098
	3099	return ( uiSum );
	3100	}
	3101
	3102	#endif
	3103
[2]	3104	// --------------------------------------------------------------------------------------------------------------------
	3105	// HADAMARD with step (used in fractional search)
	3106	// --------------------------------------------------------------------------------------------------------------------
	3107
[1200]	3108	Distortion TComRdCost::xCalcHADs2x2( Pel piOrg, Pel piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
[2]	3109	{
[1200]	3110	Distortion satd = 0;
	3111	TCoeff diff[4], m[4];
[56]	3112	assert( iStep == 1 );
	3113	diff[0] = piOrg[0 ] - piCur[0];
	3114	diff[1] = piOrg[1 ] - piCur[1];
	3115	diff[2] = piOrg[iStrideOrg ] - piCur[0 + iStrideCur];
	3116	diff[3] = piOrg[iStrideOrg + 1] - piCur[1 + iStrideCur];
[2]	3117	m[0] = diff[0] + diff[2];
	3118	m[1] = diff[1] + diff[3];
	3119	m[2] = diff[0] - diff[2];
	3120	m[3] = diff[1] - diff[3];
[1200]	3121
[2]	3122	satd += abs(m[0] + m[1]);
	3123	satd += abs(m[0] - m[1]);
	3124	satd += abs(m[2] + m[3]);
	3125	satd += abs(m[2] - m[3]);
[1200]	3126
[2]	3127	return satd;
	3128	}
	3129
[1200]	3130	Distortion TComRdCost::xCalcHADs4x4( Pel piOrg, Pel piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
[2]	3131	{
[1200]	3132	Int k;
	3133	Distortion satd = 0;
	3134	TCoeff diff[16], m[16], d[16];
	3135
[56]	3136	assert( iStep == 1 );
[2]	3137	for( k = 0; k < 16; k+=4 )
	3138	{
[56]	3139	diff[k+0] = piOrg[0] - piCur[0];
	3140	diff[k+1] = piOrg[1] - piCur[1];
	3141	diff[k+2] = piOrg[2] - piCur[2];
	3142	diff[k+3] = piOrg[3] - piCur[3];
[1200]	3143
[2]	3144	piCur += iStrideCur;
	3145	piOrg += iStrideOrg;
	3146	}
[1200]	3147
[2]	3148	/===== hadamard transform =====/
	3149	m[ 0] = diff[ 0] + diff[12];
	3150	m[ 1] = diff[ 1] + diff[13];
	3151	m[ 2] = diff[ 2] + diff[14];
	3152	m[ 3] = diff[ 3] + diff[15];
	3153	m[ 4] = diff[ 4] + diff[ 8];
	3154	m[ 5] = diff[ 5] + diff[ 9];
	3155	m[ 6] = diff[ 6] + diff[10];
	3156	m[ 7] = diff[ 7] + diff[11];
	3157	m[ 8] = diff[ 4] - diff[ 8];
	3158	m[ 9] = diff[ 5] - diff[ 9];
	3159	m[10] = diff[ 6] - diff[10];
	3160	m[11] = diff[ 7] - diff[11];
	3161	m[12] = diff[ 0] - diff[12];
	3162	m[13] = diff[ 1] - diff[13];
	3163	m[14] = diff[ 2] - diff[14];
	3164	m[15] = diff[ 3] - diff[15];
[1200]	3165
[2]	3166	d[ 0] = m[ 0] + m[ 4];
	3167	d[ 1] = m[ 1] + m[ 5];
	3168	d[ 2] = m[ 2] + m[ 6];
	3169	d[ 3] = m[ 3] + m[ 7];
	3170	d[ 4] = m[ 8] + m[12];
	3171	d[ 5] = m[ 9] + m[13];
	3172	d[ 6] = m[10] + m[14];
	3173	d[ 7] = m[11] + m[15];
	3174	d[ 8] = m[ 0] - m[ 4];
	3175	d[ 9] = m[ 1] - m[ 5];
	3176	d[10] = m[ 2] - m[ 6];
	3177	d[11] = m[ 3] - m[ 7];
	3178	d[12] = m[12] - m[ 8];
	3179	d[13] = m[13] - m[ 9];
	3180	d[14] = m[14] - m[10];
	3181	d[15] = m[15] - m[11];
[1200]	3182
[2]	3183	m[ 0] = d[ 0] + d[ 3];
	3184	m[ 1] = d[ 1] + d[ 2];
	3185	m[ 2] = d[ 1] - d[ 2];
	3186	m[ 3] = d[ 0] - d[ 3];
	3187	m[ 4] = d[ 4] + d[ 7];
	3188	m[ 5] = d[ 5] + d[ 6];
	3189	m[ 6] = d[ 5] - d[ 6];
	3190	m[ 7] = d[ 4] - d[ 7];
	3191	m[ 8] = d[ 8] + d[11];
	3192	m[ 9] = d[ 9] + d[10];
	3193	m[10] = d[ 9] - d[10];
	3194	m[11] = d[ 8] - d[11];
	3195	m[12] = d[12] + d[15];
	3196	m[13] = d[13] + d[14];
	3197	m[14] = d[13] - d[14];
	3198	m[15] = d[12] - d[15];
[1200]	3199
[2]	3200	d[ 0] = m[ 0] + m[ 1];
	3201	d[ 1] = m[ 0] - m[ 1];
	3202	d[ 2] = m[ 2] + m[ 3];
	3203	d[ 3] = m[ 3] - m[ 2];
	3204	d[ 4] = m[ 4] + m[ 5];
	3205	d[ 5] = m[ 4] - m[ 5];
	3206	d[ 6] = m[ 6] + m[ 7];
	3207	d[ 7] = m[ 7] - m[ 6];
	3208	d[ 8] = m[ 8] + m[ 9];
	3209	d[ 9] = m[ 8] - m[ 9];
	3210	d[10] = m[10] + m[11];
	3211	d[11] = m[11] - m[10];
	3212	d[12] = m[12] + m[13];
	3213	d[13] = m[12] - m[13];
	3214	d[14] = m[14] + m[15];
	3215	d[15] = m[15] - m[14];
[1200]	3216
[2]	3217	for (k=0; k<16; ++k)
	3218	{
	3219	satd += abs(d[k]);
	3220	}
	3221	satd = ((satd+1)>>1);
[1200]	3222
[2]	3223	return satd;
	3224	}
	3225
[1200]	3226	Distortion TComRdCost::xCalcHADs8x8( Pel piOrg, Pel piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
[2]	3227	{
[1200]	3228	Int k, i, j, jj;
	3229	Distortion sad = 0;
	3230	TCoeff diff[64], m1[8][8], m2[8][8], m3[8][8];
[56]	3231	assert( iStep == 1 );
	3232	for( k = 0; k < 64; k += 8 )
[2]	3233	{
[56]	3234	diff[k+0] = piOrg[0] - piCur[0];
	3235	diff[k+1] = piOrg[1] - piCur[1];
	3236	diff[k+2] = piOrg[2] - piCur[2];
	3237	diff[k+3] = piOrg[3] - piCur[3];
	3238	diff[k+4] = piOrg[4] - piCur[4];
	3239	diff[k+5] = piOrg[5] - piCur[5];
	3240	diff[k+6] = piOrg[6] - piCur[6];
	3241	diff[k+7] = piOrg[7] - piCur[7];
[1200]	3242
[2]	3243	piCur += iStrideCur;
	3244	piOrg += iStrideOrg;
	3245	}
[1200]	3246
[2]	3247	//horizontal
	3248	for (j=0; j < 8; j++)
	3249	{
	3250	jj = j << 3;
	3251	m2[j][0] = diff[jj ] + diff[jj+4];
	3252	m2[j][1] = diff[jj+1] + diff[jj+5];
	3253	m2[j][2] = diff[jj+2] + diff[jj+6];
	3254	m2[j][3] = diff[jj+3] + diff[jj+7];
	3255	m2[j][4] = diff[jj ] - diff[jj+4];
	3256	m2[j][5] = diff[jj+1] - diff[jj+5];
	3257	m2[j][6] = diff[jj+2] - diff[jj+6];
	3258	m2[j][7] = diff[jj+3] - diff[jj+7];
[1200]	3259
[2]	3260	m1[j][0] = m2[j][0] + m2[j][2];
	3261	m1[j][1] = m2[j][1] + m2[j][3];
	3262	m1[j][2] = m2[j][0] - m2[j][2];
	3263	m1[j][3] = m2[j][1] - m2[j][3];
	3264	m1[j][4] = m2[j][4] + m2[j][6];
	3265	m1[j][5] = m2[j][5] + m2[j][7];
	3266	m1[j][6] = m2[j][4] - m2[j][6];
	3267	m1[j][7] = m2[j][5] - m2[j][7];
[1200]	3268
[2]	3269	m2[j][0] = m1[j][0] + m1[j][1];
	3270	m2[j][1] = m1[j][0] - m1[j][1];
	3271	m2[j][2] = m1[j][2] + m1[j][3];
	3272	m2[j][3] = m1[j][2] - m1[j][3];
	3273	m2[j][4] = m1[j][4] + m1[j][5];
	3274	m2[j][5] = m1[j][4] - m1[j][5];
	3275	m2[j][6] = m1[j][6] + m1[j][7];
	3276	m2[j][7] = m1[j][6] - m1[j][7];
	3277	}
[1200]	3278
[2]	3279	//vertical
	3280	for (i=0; i < 8; i++)
	3281	{
	3282	m3[0][i] = m2[0][i] + m2[4][i];
	3283	m3[1][i] = m2[1][i] + m2[5][i];
	3284	m3[2][i] = m2[2][i] + m2[6][i];
	3285	m3[3][i] = m2[3][i] + m2[7][i];
	3286	m3[4][i] = m2[0][i] - m2[4][i];
	3287	m3[5][i] = m2[1][i] - m2[5][i];
	3288	m3[6][i] = m2[2][i] - m2[6][i];
	3289	m3[7][i] = m2[3][i] - m2[7][i];
[1200]	3290
[2]	3291	m1[0][i] = m3[0][i] + m3[2][i];
	3292	m1[1][i] = m3[1][i] + m3[3][i];
	3293	m1[2][i] = m3[0][i] - m3[2][i];
	3294	m1[3][i] = m3[1][i] - m3[3][i];
	3295	m1[4][i] = m3[4][i] + m3[6][i];
	3296	m1[5][i] = m3[5][i] + m3[7][i];
	3297	m1[6][i] = m3[4][i] - m3[6][i];
	3298	m1[7][i] = m3[5][i] - m3[7][i];
[1200]	3299
[2]	3300	m2[0][i] = m1[0][i] + m1[1][i];
	3301	m2[1][i] = m1[0][i] - m1[1][i];
	3302	m2[2][i] = m1[2][i] + m1[3][i];
	3303	m2[3][i] = m1[2][i] - m1[3][i];
	3304	m2[4][i] = m1[4][i] + m1[5][i];
	3305	m2[5][i] = m1[4][i] - m1[5][i];
	3306	m2[6][i] = m1[6][i] + m1[7][i];
	3307	m2[7][i] = m1[6][i] - m1[7][i];
	3308	}
[1200]	3309
[56]	3310	for (i = 0; i < 8; i++)
	3311	{
	3312	for (j = 0; j < 8; j++)
	3313	{
	3314	sad += abs(m2[i][j]);
	3315	}
	3316	}
[1200]	3317
[2]	3318	sad=((sad+2)>>2);
[1200]	3319
[2]	3320	return sad;
	3321	}
	3322
	3323
[1200]	3324	Distortion TComRdCost::xGetHADs( DistParam* pcDtParam )
[2]	3325	{
[56]	3326	if ( pcDtParam->bApplyWeight )
[2]	3327	{
[1200]	3328	return TComRdCostWeightPrediction::xGetHADsw( pcDtParam );
[2]	3329	}
[608]	3330	#if H_3D_IC
	3331	if( pcDtParam->bUseIC )
[189]	3332	{
	3333	return xGetHADsic( pcDtParam );
	3334	}
	3335	#endif
[655]	3336	#if H_3D_INTER_SDC
[608]	3337	if( pcDtParam->bUseSDCMRSAD )
	3338	{
	3339	return xGetHADsic( pcDtParam );
	3340	}
	3341	#endif
[1200]	3342
[2]	3343	Pel* piOrg = pcDtParam->pOrg;
	3344	Pel* piCur = pcDtParam->pCur;
	3345	Int iRows = pcDtParam->iRows;
	3346	Int iCols = pcDtParam->iCols;
	3347	Int iStrideCur = pcDtParam->iStrideCur;
	3348	Int iStrideOrg = pcDtParam->iStrideOrg;
	3349	Int iStep = pcDtParam->iStep;
[1200]	3350
[189]	3351	Int x, y;
[1200]	3352
	3353	Distortion uiSum = 0;
	3354
[189]	3355	if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
	3356	{
	3357	Int iOffsetOrg = iStrideOrg<<3;
	3358	Int iOffsetCur = iStrideCur<<3;
	3359	for ( y=0; y<iRows; y+= 8 )
	3360	{
	3361	for ( x=0; x<iCols; x+= 8 )
	3362	{
	3363	uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3364	}
	3365	piOrg += iOffsetOrg;
	3366	piCur += iOffsetCur;
	3367	}
	3368	}
	3369	else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
	3370	{
	3371	Int iOffsetOrg = iStrideOrg<<2;
	3372	Int iOffsetCur = iStrideCur<<2;
[1200]	3373
[189]	3374	for ( y=0; y<iRows; y+= 4 )
	3375	{
	3376	for ( x=0; x<iCols; x+= 4 )
	3377	{
	3378	uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3379	}
	3380	piOrg += iOffsetOrg;
	3381	piCur += iOffsetCur;
	3382	}
	3383	}
	3384	else if( ( iRows % 2 == 0) && (iCols % 2 == 0) )
	3385	{
	3386	Int iOffsetOrg = iStrideOrg<<1;
	3387	Int iOffsetCur = iStrideCur<<1;
	3388	for ( y=0; y<iRows; y+=2 )
	3389	{
	3390	for ( x=0; x<iCols; x+=2 )
	3391	{
	3392	uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3393	}
	3394	piOrg += iOffsetOrg;
	3395	piCur += iOffsetCur;
	3396	}
	3397	}
	3398	else
	3399	{
	3400	assert(false);
	3401	}
[1200]	3402
	3403	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT(pcDtParam->bitDepth-8) );
[189]	3404	}
	3405
[655]	3406	#if H_3D_IC \|\| H_3D_INTER_SDC
[189]	3407	UInt TComRdCost::xGetHADsic( DistParam* pcDtParam )
	3408	{
	3409	if ( pcDtParam->bApplyWeight )
	3410	{
	3411	return xGetHADsw( pcDtParam );
	3412	}
	3413	Pel* piOrg = pcDtParam->pOrg;
	3414	Pel* piCur = pcDtParam->pCur;
	3415	Int iRows = pcDtParam->iRows;
	3416	Int iCols = pcDtParam->iCols;
	3417	Int iStrideCur = pcDtParam->iStrideCur;
	3418	Int iStrideOrg = pcDtParam->iStrideOrg;
	3419	Int iStep = pcDtParam->iStep;
[608]	3420
[2]	3421	Int x, y;
[608]	3422
[2]	3423	UInt uiSum = 0;
[608]	3424
[189]	3425	Int iOrigAvg = 0, iCurAvg = 0;
	3426	Int iDeltaC;
	3427
	3428	for ( y=0; y<iRows; y++ )
	3429	{
	3430	for ( x=0; x<iCols; x++ )
	3431	{
	3432	iOrigAvg += piOrg[x];
	3433	iCurAvg += piCur[x];
	3434	}
	3435	piOrg += iStrideOrg;
	3436	piCur += iStrideCur;
	3437	}
	3438
	3439	piOrg = pcDtParam->pOrg;
	3440	piCur = pcDtParam->pCur;
	3441
	3442	iDeltaC = (iOrigAvg - iCurAvg)/iRows/iCols;
	3443
	3444	for ( y=0; y<iRows; y++ )
	3445	{
	3446	for ( x=0; x<iCols; x++ )
	3447	{
	3448	piOrg[x] -= iDeltaC;
	3449	}
	3450	piOrg += iStrideOrg;
	3451	}
	3452
	3453	piOrg = pcDtParam->pOrg;
	3454
[56]	3455	#if NS_HAD
	3456	if( ( ( iRows % 8 == 0) && (iCols % 8 == 0) && ( iRows == iCols ) ) \|\| ( ( iRows % 8 == 0 ) && (iCols % 8 == 0) && !pcDtParam->bUseNSHAD ) )
	3457	#else
[2]	3458	if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
[56]	3459	#endif
[2]	3460	{
	3461	Int iOffsetOrg = iStrideOrg<<3;
	3462	Int iOffsetCur = iStrideCur<<3;
	3463	for ( y=0; y<iRows; y+= 8 )
	3464	{
	3465	for ( x=0; x<iCols; x+= 8 )
	3466	{
	3467	uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3468	}
	3469	piOrg += iOffsetOrg;
	3470	piCur += iOffsetCur;
	3471	}
	3472	}
[56]	3473	#if NS_HAD
	3474	else if ( ( iCols > 8 ) && ( iCols > iRows ) && pcDtParam->bUseNSHAD )
	3475	{
	3476	Int iOffsetOrg = iStrideOrg<<2;
	3477	Int iOffsetCur = iStrideCur<<2;
	3478	for ( y=0; y<iRows; y+= 4 )
	3479	{
	3480	for ( x=0; x<iCols; x+= 16 )
	3481	{
	3482	uiSum += xCalcHADs16x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3483	}
	3484	piOrg += iOffsetOrg;
	3485	piCur += iOffsetCur;
	3486	}
	3487	}
	3488	else if ( ( iRows > 8 ) && ( iCols < iRows ) && pcDtParam->bUseNSHAD )
	3489	{
	3490	Int iOffsetOrg = iStrideOrg<<4;
	3491	Int iOffsetCur = iStrideCur<<4;
	3492	for ( y=0; y<iRows; y+= 16 )
	3493	{
	3494	for ( x=0; x<iCols; x+= 4 )
	3495	{
	3496	uiSum += xCalcHADs4x16( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3497	}
	3498	piOrg += iOffsetOrg;
	3499	piCur += iOffsetCur;
	3500	}
	3501	}
	3502	#endif
[2]	3503	else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
	3504	{
	3505	Int iOffsetOrg = iStrideOrg<<2;
	3506	Int iOffsetCur = iStrideCur<<2;
[608]	3507
[2]	3508	for ( y=0; y<iRows; y+= 4 )
	3509	{
	3510	for ( x=0; x<iCols; x+= 4 )
	3511	{
	3512	uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3513	}
	3514	piOrg += iOffsetOrg;
	3515	piCur += iOffsetCur;
	3516	}
	3517	}
	3518	else if( ( iRows % 2 == 0) && (iCols % 2 == 0) )
	3519	{
	3520	Int iOffsetOrg = iStrideOrg<<1;
	3521	Int iOffsetCur = iStrideCur<<1;
	3522	for ( y=0; y<iRows; y+=2 )
	3523	{
	3524	for ( x=0; x<iCols; x+=2 )
	3525	{
	3526	uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
	3527	}
	3528	piOrg += iOffsetOrg;
	3529	piCur += iOffsetCur;
	3530	}
	3531	}
	3532	else
	3533	{
[56]	3534	assert(false);
[2]	3535	}
[608]	3536
[189]	3537	piOrg = pcDtParam->pOrg;
	3538
	3539	for ( y=0; y<iRows; y++ )
	3540	{
	3541	for ( x=0; x<iCols; x++ )
	3542	{
	3543	piOrg[x] += iDeltaC;
	3544	}
	3545	piOrg += iStrideOrg;
	3546	}
	3547
[608]	3548	return ( uiSum >> DISTORTION_PRECISION_ADJUSTMENT( pcDtParam->bitDepth - 8 ) );
[2]	3549	}
[189]	3550	#endif
[1200]	3551	#if NH_3D_VSO
[2]	3552	Void TComRdCost::setLambdaVSO( Double dLambdaVSO )
	3553	{
	3554	m_dLambdaVSO = dLambdaVSO;
	3555	m_dSqrtLambdaVSO = sqrt(m_dLambdaVSO);
	3556	m_uiLambdaMotionSADVSO = (UInt)floor(65536.0 * m_dSqrtLambdaVSO);
	3557	m_uiLambdaMotionSSEVSO = (UInt)floor(65536.0 * m_dLambdaVSO );
	3558	}
[1200]	3559	#endif
	3560	#if NH_3D_VSO
[2]	3561	Dist TComRdCost::xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
	3562	{
	3563	AOT(bSAD);
[608]	3564	#if H_3D_VSO_EARLY_SKIP
[100]	3565	RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur, piOrg, iOrgStride);
	3566	#else
[2]	3567	RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur );
[100]	3568	#endif
[2]	3569
	3570	RMDist iDistMin = (RMDist) RDO_DIST_MIN;
	3571	iDistMin = m_bAllowNegDist ? RDO_DIST_MIN : 0;
	3572
[608]	3573	iDist = std::min( iDist, (RMDist) RDO_DIST_MAX);
	3574	iDist = std::max( iDist, iDistMin);
[2]	3575	return (Dist) iDist;
	3576	}
	3577
	3578
[1200]	3579	Dist TComRdCost::getDistPartVSO( TComDataCU* pcCU, UInt uiAbsPartIndex, Int bitDepth, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bHAD )
[2]	3580	{
	3581	assert( m_bUseVSO );
	3582	assert( this->m_fpDistortFuncVSO != 0 );
	3583
	3584	Int iPosX;
	3585	Int iPosY;
	3586
	3587	pcCU->getPosInPic( uiAbsPartIndex, iPosX, iPosY );
[608]	3588
	3589	Dist dist = (this->*m_fpDistortFuncVSO) ( iPosX, iPosY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, bHAD );
	3590
	3591	if ( m_bUseWVSO )
	3592	{
[1200]	3593	Int iDWeight = m_iDWeight * m_iDWeight ;
[608]	3594	Int iVSOWeight = m_iVSOWeight * m_iVSOWeight;
	3595	Dist distDepth;
	3596
	3597	if ( !bHAD )
	3598	{
[1200]	3599	distDepth = (Dist) getDistPart( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, COMPONENT_Y);
[608]	3600	}
	3601	else
	3602	{
[1200]	3603	distDepth = (Dist) calcHAD ( bitDepth, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight);
[608]	3604	}
	3605
	3606	dist = (Dist) (iDWeight * distDepth + iVSOWeight * dist ) / ( iDWeight + iVSOWeight);
	3607	}
	3608	return dist;
[2]	3609	};
	3610
	3611
	3612	Void TComRdCost::setVSOMode( UInt uiIn )
	3613	{
	3614	m_uiVSOMode = uiIn;
	3615	switch (m_uiVSOMode )
	3616	{
	3617	case 4:
	3618	m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode4;
	3619	break;
	3620	default:
	3621	assert(0);
	3622	break;
	3623	}
	3624	}
	3625
	3626
	3627	Double TComRdCost::calcRdCostVSO( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
	3628	{
[56]	3629	assert( m_bUseLambdaScaleVSO );
[2]	3630
	3631	Double dRdCost = 0.0;
[56]	3632	Double dLambda = 0.0;
[2]	3633
	3634	switch ( eDFunc )
	3635	{
	3636	case DF_SSE:
	3637	assert(0);
	3638	break;
	3639	case DF_SAD:
	3640	dLambda = (Double)m_uiLambdaMotionSADVSO;
	3641	break;
	3642	case DF_DEFAULT:
	3643	dLambda = m_dLambdaVSO;
	3644	break;
	3645	case DF_SSE_FRAME:
	3646	dLambda = m_dFrameLambdaVSO;
	3647	break;
	3648	default:
	3649	assert (0);
	3650	break;
	3651	}
	3652
	3653	if (bFlag)
	3654	{
	3655	// Intra8x8, Intra4x4 Block only...
[608]	3656	#if SEQUENCE_LEVEL_LOSSLESS
	3657	dRdCost = (Double)(uiBits);
	3658	#else
[2]	3659	dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
[608]	3660	#endif
[2]	3661	}
	3662	else
	3663	{
	3664	if (eDFunc == DF_SAD)
	3665	{
	3666	dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)>>16));
	3667	dRdCost = (Double)(Dist)floor(dRdCost);
	3668	}
	3669	else
	3670	{
[608]	3671	#if SEQUENCE_LEVEL_LOSSLESS
	3672	dRdCost = (Double)(uiBits);
	3673	#else
[2]	3674	dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)));
	3675	dRdCost = (Double)(Dist)floor(dRdCost);
[608]	3676	#endif
[2]	3677	}
	3678	}
	3679
	3680	return dRdCost;
	3681	}
	3682
[1200]	3683	Void TComRdCost::setRenModelData( const TComDataCU* pcCU, UInt uiAbsPartIndex, const TComYuv* pcYuv, const TComTURecurse* tuRecurseWithPU )
[2]	3684	{
[1200]	3685	const TComRectangle &puRect=tuRecurseWithPU->getRect(COMPONENT_Y);
	3686	const UInt uiCompWidth = puRect.width;
	3687	const UInt uiCompHeight = puRect.height;
	3688
	3689	const Pel* piSrc = pcYuv->getAddr( COMPONENT_Y, uiAbsPartIndex );
	3690	const UInt uiSrcStride = pcYuv->getStride( COMPONENT_Y);
	3691	setRenModelData( pcCU, uiAbsPartIndex, piSrc, uiSrcStride, uiCompWidth, uiCompHeight );
	3692	}
	3693
	3694	Void TComRdCost::setRenModelData( const TComDataCU* pcCU, UInt uiAbsPartIndex, const Pel* piData, Int iStride, Int iBlkWidth, Int iBlkHeight )
	3695	{
[2]	3696	UInt iBlkX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]];
	3697	UInt iBlkY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]];
	3698
	3699	Int iStartPosX = iBlkX + pcCU->getCUPelX();
	3700	Int iStartPosY = iBlkY + pcCU->getCUPelY();
	3701
	3702	m_pcRenModel->setData( iStartPosX, iStartPosY, iBlkWidth, iBlkHeight, iStride, piData );
	3703	}
	3704
	3705	Void TComRdCost::setAllowNegDist( Bool bAllowNegDist )
	3706	{
	3707	m_bAllowNegDist = bAllowNegDist;
	3708	}
	3709	#endif
	3710
[56]	3711	//! \}

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

JCT-3V 3D-HEVC

Context navigation

source: 3DVCSoftware/branches/HTM-14.1-update-dev0/source/Lib/TLibCommon/TComRdCost.cpp @ 1200

Download in other formats: