Context navigation

source: 3DVCSoftware/tags/0.2r1/source/Lib/TLibCommon/TComRdCost.cpp @ 255

Visit:

Last change on this file since 255 was 5, checked in by hhi, 13 years ago
Clean version with cfg-files
Property svn:eol-style set to `native`
File size: 197.1 KB

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