source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComRdCost.cpp @ 2

Last change on this file since 2 was 2, checked in by hhi, 13 years ago

inital import

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