Context Navigation

Back to Ticket #70

Ticket #70: TComRdCost.cpp

File TComRdCost.cpp, 89.7 KB (added by anonymous, 14 years ago)
look for macro "ROUNDING_CONTROL_BIPRED_FIX"

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

Download in other formats:

Original Format

JVET HEVC

Context Navigation

Ticket #70: TComRdCost.cpp

Download in other formats: