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[n  ]+iOffset)>>iShift) - ((piCur[n  ]+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[n  ] - piCur[n  ];
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[n  ] - piCur[n  ];
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] - piCur[4]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3499      if( piUsed[5] ) { iTemp = piOrg[5] - piCur[5]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3500      if( piUsed[6] ) { iTemp = piOrg[6] - piCur[6]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3501      if( piUsed[7] ) { iTemp = piOrg[7] - piCur[7]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3502
3503      piOrg  += iStrideOrg;
3504      piCur  += iStrideCur;
3505      piUsed += iStrideUsed;
3506    }
3507  }
3508  else
3509  {
3510#endif
3511  for( ; iRows != 0; iRows-- )
3512  {
3513    iTemp = piOrg[0] - piCur[0]; uiSum += ( iTemp * iTemp ) >> uiShift;
3514    iTemp = piOrg[1] - piCur[1]; uiSum += ( iTemp * iTemp ) >> uiShift;
3515    iTemp = piOrg[2] - piCur[2]; uiSum += ( iTemp * iTemp ) >> uiShift;
3516    iTemp = piOrg[3] - piCur[3]; uiSum += ( iTemp * iTemp ) >> uiShift;
3517    iTemp = piOrg[4] - piCur[4]; uiSum += ( iTemp * iTemp ) >> uiShift;
3518    iTemp = piOrg[5] - piCur[5]; uiSum += ( iTemp * iTemp ) >> uiShift;
3519    iTemp = piOrg[6] - piCur[6]; uiSum += ( iTemp * iTemp ) >> uiShift;
3520    iTemp = piOrg[7] - piCur[7]; uiSum += ( iTemp * iTemp ) >> uiShift;
3521   
3522    piOrg += iStrideOrg;
3523    piCur += iStrideCur;
3524  }
3525#if SB_INTERVIEW_SKIP
3526  }
3527#endif
3528 
3529  return ( uiSum );
3530}
3531
3532UInt TComRdCost::xGetSSE16( DistParam* pcDtParam )
3533{
3534#ifdef WEIGHT_PRED
3535  if ( pcDtParam->applyWeight )
3536  {
3537    assert( pcDtParam->iCols == 16 );
3538    return xGetSSEw( pcDtParam );
3539  }
3540#endif
3541  Pel* piOrg   = pcDtParam->pOrg;
3542  Pel* piCur   = pcDtParam->pCur;
3543  Int  iRows   = pcDtParam->iRows;
3544  Int  iStrideOrg = pcDtParam->iStrideOrg;
3545  Int  iStrideCur = pcDtParam->iStrideCur;
3546 
3547  UInt uiSum = 0;
3548  UInt uiShift = g_uiBitIncrement<<1;
3549 
3550  Int  iTemp;
3551 
3552#if SB_INTERVIEW_SKIP
3553  if( pcDtParam->pUsed )
3554  {
3555    Pel*  piUsed      = pcDtParam->pUsed;
3556    Int   iStrideUsed = pcDtParam->iStrideUsed;
3557    for( ; iRows != 0; iRows-- )
3558    {
3559      if( piUsed[ 0] ) { iTemp = piOrg[ 0] - piCur[ 0]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3560      if( piUsed[ 1] ) { iTemp = piOrg[ 1] - piCur[ 1]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3561      if( piUsed[ 2] ) { iTemp = piOrg[ 2] - piCur[ 2]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3562      if( piUsed[ 3] ) { iTemp = piOrg[ 3] - piCur[ 3]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3563      if( piUsed[ 4] ) { iTemp = piOrg[ 4] - piCur[ 4]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3564      if( piUsed[ 5] ) { iTemp = piOrg[ 5] - piCur[ 5]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3565      if( piUsed[ 6] ) { iTemp = piOrg[ 6] - piCur[ 6]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3566      if( piUsed[ 7] ) { iTemp = piOrg[ 7] - piCur[ 7]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3567      if( piUsed[ 8] ) { iTemp = piOrg[ 8] - piCur[ 8]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3568      if( piUsed[ 9] ) { iTemp = piOrg[ 9] - piCur[ 9]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3569      if( piUsed[10] ) { iTemp = piOrg[10] - piCur[10]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3570      if( piUsed[11] ) { iTemp = piOrg[11] - piCur[11]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3571      if( piUsed[12] ) { iTemp = piOrg[12] - piCur[12]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3572      if( piUsed[13] ) { iTemp = piOrg[13] - piCur[13]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3573      if( piUsed[14] ) { iTemp = piOrg[14] - piCur[14]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3574      if( piUsed[15] ) { iTemp = piOrg[15] - piCur[15]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3575
3576      piOrg  += iStrideOrg;
3577      piCur  += iStrideCur;
3578      piUsed += iStrideUsed;
3579    }
3580  }
3581  else
3582  {
3583#endif
3584  for( ; iRows != 0; iRows-- )
3585  {
3586   
3587    iTemp = piOrg[ 0] - piCur[ 0]; uiSum += ( iTemp * iTemp ) >> uiShift;
3588    iTemp = piOrg[ 1] - piCur[ 1]; uiSum += ( iTemp * iTemp ) >> uiShift;
3589    iTemp = piOrg[ 2] - piCur[ 2]; uiSum += ( iTemp * iTemp ) >> uiShift;
3590    iTemp = piOrg[ 3] - piCur[ 3]; uiSum += ( iTemp * iTemp ) >> uiShift;
3591    iTemp = piOrg[ 4] - piCur[ 4]; uiSum += ( iTemp * iTemp ) >> uiShift;
3592    iTemp = piOrg[ 5] - piCur[ 5]; uiSum += ( iTemp * iTemp ) >> uiShift;
3593    iTemp = piOrg[ 6] - piCur[ 6]; uiSum += ( iTemp * iTemp ) >> uiShift;
3594    iTemp = piOrg[ 7] - piCur[ 7]; uiSum += ( iTemp * iTemp ) >> uiShift;
3595    iTemp = piOrg[ 8] - piCur[ 8]; uiSum += ( iTemp * iTemp ) >> uiShift;
3596    iTemp = piOrg[ 9] - piCur[ 9]; uiSum += ( iTemp * iTemp ) >> uiShift;
3597    iTemp = piOrg[10] - piCur[10]; uiSum += ( iTemp * iTemp ) >> uiShift;
3598    iTemp = piOrg[11] - piCur[11]; uiSum += ( iTemp * iTemp ) >> uiShift;
3599    iTemp = piOrg[12] - piCur[12]; uiSum += ( iTemp * iTemp ) >> uiShift;
3600    iTemp = piOrg[13] - piCur[13]; uiSum += ( iTemp * iTemp ) >> uiShift;
3601    iTemp = piOrg[14] - piCur[14]; uiSum += ( iTemp * iTemp ) >> uiShift;
3602    iTemp = piOrg[15] - piCur[15]; uiSum += ( iTemp * iTemp ) >> uiShift;
3603   
3604    piOrg += iStrideOrg;
3605    piCur += iStrideCur;
3606  }
3607#if SB_INTERVIEW_SKIP
3608  }
3609#endif
3610 
3611  return ( uiSum );
3612}
3613
3614UInt TComRdCost::xGetSSE16N( DistParam* pcDtParam )
3615{
3616#ifdef WEIGHT_PRED
3617  if ( pcDtParam->applyWeight )
3618  {
3619    return xGetSSEw( pcDtParam );
3620  }
3621#endif
3622  Pel* piOrg   = pcDtParam->pOrg;
3623  Pel* piCur   = pcDtParam->pCur;
3624  Int  iRows   = pcDtParam->iRows;
3625  Int  iCols   = pcDtParam->iCols;
3626  Int  iStrideOrg = pcDtParam->iStrideOrg;
3627  Int  iStrideCur = pcDtParam->iStrideCur;
3628 
3629  UInt uiSum = 0;
3630  UInt uiShift = g_uiBitIncrement<<1;
3631  Int  iTemp;
3632 
3633#if SB_INTERVIEW_SKIP
3634  if( pcDtParam->pUsed )
3635  {
3636    Pel*  piUsed      = pcDtParam->pUsed;
3637    Int   iStrideUsed = pcDtParam->iStrideUsed;
3638    for( ; iRows != 0; iRows-- )
3639    {
3640      for (Int n = 0; n < iCols; n+=16 )
3641      {
3642        if( piUsed[n+ 0] ) { iTemp = piOrg[n+ 0] - piCur[n+ 0]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3643        if( piUsed[n+ 1] ) { iTemp = piOrg[n+ 1] - piCur[n+ 1]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3644        if( piUsed[n+ 2] ) { iTemp = piOrg[n+ 2] - piCur[n+ 2]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3645        if( piUsed[n+ 3] ) { iTemp = piOrg[n+ 3] - piCur[n+ 3]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3646        if( piUsed[n+ 4] ) { iTemp = piOrg[n+ 4] - piCur[n+ 4]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3647        if( piUsed[n+ 5] ) { iTemp = piOrg[n+ 5] - piCur[n+ 5]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3648        if( piUsed[n+ 6] ) { iTemp = piOrg[n+ 6] - piCur[n+ 6]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3649        if( piUsed[n+ 7] ) { iTemp = piOrg[n+ 7] - piCur[n+ 7]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3650        if( piUsed[n+ 8] ) { iTemp = piOrg[n+ 8] - piCur[n+ 8]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3651        if( piUsed[n+ 9] ) { iTemp = piOrg[n+ 9] - piCur[n+ 9]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3652        if( piUsed[n+10] ) { iTemp = piOrg[n+10] - piCur[n+10]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3653        if( piUsed[n+11] ) { iTemp = piOrg[n+11] - piCur[n+11]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3654        if( piUsed[n+12] ) { iTemp = piOrg[n+12] - piCur[n+12]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3655        if( piUsed[n+13] ) { iTemp = piOrg[n+13] - piCur[n+13]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3656        if( piUsed[n+14] ) { iTemp = piOrg[n+14] - piCur[n+14]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3657        if( piUsed[n+15] ) { iTemp = piOrg[n+15] - piCur[n+15]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3658      }
3659      piOrg  += iStrideOrg;
3660      piCur  += iStrideCur;
3661      piUsed += iStrideUsed;
3662    }
3663  }
3664  else
3665  {
3666#endif
3667  for( ; iRows != 0; iRows-- )
3668  {
3669    for (Int n = 0; n < iCols; n+=16 )
3670    {
3671     
3672      iTemp = piOrg[n+ 0] - piCur[n+ 0]; uiSum += ( iTemp * iTemp ) >> uiShift;
3673      iTemp = piOrg[n+ 1] - piCur[n+ 1]; uiSum += ( iTemp * iTemp ) >> uiShift;
3674      iTemp = piOrg[n+ 2] - piCur[n+ 2]; uiSum += ( iTemp * iTemp ) >> uiShift;
3675      iTemp = piOrg[n+ 3] - piCur[n+ 3]; uiSum += ( iTemp * iTemp ) >> uiShift;
3676      iTemp = piOrg[n+ 4] - piCur[n+ 4]; uiSum += ( iTemp * iTemp ) >> uiShift;
3677      iTemp = piOrg[n+ 5] - piCur[n+ 5]; uiSum += ( iTemp * iTemp ) >> uiShift;
3678      iTemp = piOrg[n+ 6] - piCur[n+ 6]; uiSum += ( iTemp * iTemp ) >> uiShift;
3679      iTemp = piOrg[n+ 7] - piCur[n+ 7]; uiSum += ( iTemp * iTemp ) >> uiShift;
3680      iTemp = piOrg[n+ 8] - piCur[n+ 8]; uiSum += ( iTemp * iTemp ) >> uiShift;
3681      iTemp = piOrg[n+ 9] - piCur[n+ 9]; uiSum += ( iTemp * iTemp ) >> uiShift;
3682      iTemp = piOrg[n+10] - piCur[n+10]; uiSum += ( iTemp * iTemp ) >> uiShift;
3683      iTemp = piOrg[n+11] - piCur[n+11]; uiSum += ( iTemp * iTemp ) >> uiShift;
3684      iTemp = piOrg[n+12] - piCur[n+12]; uiSum += ( iTemp * iTemp ) >> uiShift;
3685      iTemp = piOrg[n+13] - piCur[n+13]; uiSum += ( iTemp * iTemp ) >> uiShift;
3686      iTemp = piOrg[n+14] - piCur[n+14]; uiSum += ( iTemp * iTemp ) >> uiShift;
3687      iTemp = piOrg[n+15] - piCur[n+15]; uiSum += ( iTemp * iTemp ) >> uiShift;
3688     
3689    }
3690    piOrg += iStrideOrg;
3691    piCur += iStrideCur;
3692  }
3693#if SB_INTERVIEW_SKIP
3694  }
3695#endif
3696 
3697  return ( uiSum );
3698}
3699
3700UInt TComRdCost::xGetSSE32( DistParam* pcDtParam )
3701{
3702#ifdef WEIGHT_PRED
3703  if ( pcDtParam->applyWeight )
3704  {
3705    assert( pcDtParam->iCols == 32 );
3706    return xGetSSEw( pcDtParam );
3707  }
3708#endif
3709  Pel* piOrg   = pcDtParam->pOrg;
3710  Pel* piCur   = pcDtParam->pCur;
3711  Int  iRows   = pcDtParam->iRows;
3712  Int  iStrideOrg = pcDtParam->iStrideOrg;
3713  Int  iStrideCur = pcDtParam->iStrideCur;
3714 
3715  UInt uiSum = 0;
3716  UInt uiShift = g_uiBitIncrement<<1;
3717  Int  iTemp;
3718 
3719#if SB_INTERVIEW_SKIP
3720  if( pcDtParam->pUsed )
3721  {
3722    Pel*  piUsed      = pcDtParam->pUsed;
3723    Int   iStrideUsed = pcDtParam->iStrideUsed;
3724    for( ; iRows != 0; iRows-- )
3725    {
3726      if( piUsed[ 0] ) { iTemp = piOrg[ 0] - piCur[ 0]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3727      if( piUsed[ 1] ) { iTemp = piOrg[ 1] - piCur[ 1]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3728      if( piUsed[ 2] ) { iTemp = piOrg[ 2] - piCur[ 2]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3729      if( piUsed[ 3] ) { iTemp = piOrg[ 3] - piCur[ 3]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3730      if( piUsed[ 4] ) { iTemp = piOrg[ 4] - piCur[ 4]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3731      if( piUsed[ 5] ) { iTemp = piOrg[ 5] - piCur[ 5]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3732      if( piUsed[ 6] ) { iTemp = piOrg[ 6] - piCur[ 6]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3733      if( piUsed[ 7] ) { iTemp = piOrg[ 7] - piCur[ 7]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3734      if( piUsed[ 8] ) { iTemp = piOrg[ 8] - piCur[ 8]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3735      if( piUsed[ 9] ) { iTemp = piOrg[ 9] - piCur[ 9]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3736      if( piUsed[10] ) { iTemp = piOrg[10] - piCur[10]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3737      if( piUsed[11] ) { iTemp = piOrg[11] - piCur[11]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3738      if( piUsed[12] ) { iTemp = piOrg[12] - piCur[12]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3739      if( piUsed[13] ) { iTemp = piOrg[13] - piCur[13]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3740      if( piUsed[14] ) { iTemp = piOrg[14] - piCur[14]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3741      if( piUsed[15] ) { iTemp = piOrg[15] - piCur[15]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3742      if( piUsed[16] ) { iTemp = piOrg[16] - piCur[16]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3743      if( piUsed[17] ) { iTemp = piOrg[17] - piCur[17]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3744      if( piUsed[18] ) { iTemp = piOrg[18] - piCur[18]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3745      if( piUsed[19] ) { iTemp = piOrg[19] - piCur[19]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3746      if( piUsed[20] ) { iTemp = piOrg[20] - piCur[20]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3747      if( piUsed[21] ) { iTemp = piOrg[21] - piCur[21]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3748      if( piUsed[22] ) { iTemp = piOrg[22] - piCur[22]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3749      if( piUsed[23] ) { iTemp = piOrg[23] - piCur[23]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3750      if( piUsed[24] ) { iTemp = piOrg[24] - piCur[24]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3751      if( piUsed[25] ) { iTemp = piOrg[25] - piCur[25]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3752      if( piUsed[26] ) { iTemp = piOrg[26] - piCur[26]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3753      if( piUsed[27] ) { iTemp = piOrg[27] - piCur[27]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3754      if( piUsed[28] ) { iTemp = piOrg[28] - piCur[28]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3755      if( piUsed[29] ) { iTemp = piOrg[29] - piCur[29]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3756      if( piUsed[30] ) { iTemp = piOrg[30] - piCur[30]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3757      if( piUsed[31] ) { iTemp = piOrg[31] - piCur[31]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3758
3759      piOrg  += iStrideOrg;
3760      piCur  += iStrideCur;
3761      piUsed += iStrideUsed;
3762    }
3763  }
3764  else
3765  {
3766#endif
3767  for( ; iRows != 0; iRows-- )
3768  {
3769   
3770    iTemp = piOrg[ 0] - piCur[ 0]; uiSum += ( iTemp * iTemp ) >> uiShift;
3771    iTemp = piOrg[ 1] - piCur[ 1]; uiSum += ( iTemp * iTemp ) >> uiShift;
3772    iTemp = piOrg[ 2] - piCur[ 2]; uiSum += ( iTemp * iTemp ) >> uiShift;
3773    iTemp = piOrg[ 3] - piCur[ 3]; uiSum += ( iTemp * iTemp ) >> uiShift;
3774    iTemp = piOrg[ 4] - piCur[ 4]; uiSum += ( iTemp * iTemp ) >> uiShift;
3775    iTemp = piOrg[ 5] - piCur[ 5]; uiSum += ( iTemp * iTemp ) >> uiShift;
3776    iTemp = piOrg[ 6] - piCur[ 6]; uiSum += ( iTemp * iTemp ) >> uiShift;
3777    iTemp = piOrg[ 7] - piCur[ 7]; uiSum += ( iTemp * iTemp ) >> uiShift;
3778    iTemp = piOrg[ 8] - piCur[ 8]; uiSum += ( iTemp * iTemp ) >> uiShift;
3779    iTemp = piOrg[ 9] - piCur[ 9]; uiSum += ( iTemp * iTemp ) >> uiShift;
3780    iTemp = piOrg[10] - piCur[10]; uiSum += ( iTemp * iTemp ) >> uiShift;
3781    iTemp = piOrg[11] - piCur[11]; uiSum += ( iTemp * iTemp ) >> uiShift;
3782    iTemp = piOrg[12] - piCur[12]; uiSum += ( iTemp * iTemp ) >> uiShift;
3783    iTemp = piOrg[13] - piCur[13]; uiSum += ( iTemp * iTemp ) >> uiShift;
3784    iTemp = piOrg[14] - piCur[14]; uiSum += ( iTemp * iTemp ) >> uiShift;
3785    iTemp = piOrg[15] - piCur[15]; uiSum += ( iTemp * iTemp ) >> uiShift;
3786    iTemp = piOrg[16] - piCur[16]; uiSum += ( iTemp * iTemp ) >> uiShift;
3787    iTemp = piOrg[17] - piCur[17]; uiSum += ( iTemp * iTemp ) >> uiShift;
3788    iTemp = piOrg[18] - piCur[18]; uiSum += ( iTemp * iTemp ) >> uiShift;
3789    iTemp = piOrg[19] - piCur[19]; uiSum += ( iTemp * iTemp ) >> uiShift;
3790    iTemp = piOrg[20] - piCur[20]; uiSum += ( iTemp * iTemp ) >> uiShift;
3791    iTemp = piOrg[21] - piCur[21]; uiSum += ( iTemp * iTemp ) >> uiShift;
3792    iTemp = piOrg[22] - piCur[22]; uiSum += ( iTemp * iTemp ) >> uiShift;
3793    iTemp = piOrg[23] - piCur[23]; uiSum += ( iTemp * iTemp ) >> uiShift;
3794    iTemp = piOrg[24] - piCur[24]; uiSum += ( iTemp * iTemp ) >> uiShift;
3795    iTemp = piOrg[25] - piCur[25]; uiSum += ( iTemp * iTemp ) >> uiShift;
3796    iTemp = piOrg[26] - piCur[26]; uiSum += ( iTemp * iTemp ) >> uiShift;
3797    iTemp = piOrg[27] - piCur[27]; uiSum += ( iTemp * iTemp ) >> uiShift;
3798    iTemp = piOrg[28] - piCur[28]; uiSum += ( iTemp * iTemp ) >> uiShift;
3799    iTemp = piOrg[29] - piCur[29]; uiSum += ( iTemp * iTemp ) >> uiShift;
3800    iTemp = piOrg[30] - piCur[30]; uiSum += ( iTemp * iTemp ) >> uiShift;
3801    iTemp = piOrg[31] - piCur[31]; uiSum += ( iTemp * iTemp ) >> uiShift;
3802   
3803    piOrg += iStrideOrg;
3804    piCur += iStrideCur;
3805  }
3806#if SB_INTERVIEW_SKIP
3807  }
3808#endif
3809 
3810  return ( uiSum );
3811}
3812
3813UInt TComRdCost::xGetSSE64( DistParam* pcDtParam )
3814{
3815#ifdef WEIGHT_PRED
3816  if ( pcDtParam->applyWeight )
3817  {
3818    assert( pcDtParam->iCols == 64 );
3819    return xGetSSEw( pcDtParam );
3820  }
3821#endif
3822  Pel* piOrg   = pcDtParam->pOrg;
3823  Pel* piCur   = pcDtParam->pCur;
3824  Int  iRows   = pcDtParam->iRows;
3825  Int  iStrideOrg = pcDtParam->iStrideOrg;
3826  Int  iStrideCur = pcDtParam->iStrideCur;
3827 
3828  UInt uiSum = 0;
3829  UInt uiShift = g_uiBitIncrement<<1;
3830  Int  iTemp;
3831 
3832#if SB_INTERVIEW_SKIP
3833  if( pcDtParam->pUsed )
3834  {
3835    Pel*  piUsed      = pcDtParam->pUsed;
3836    Int   iStrideUsed = pcDtParam->iStrideUsed;
3837    for( ; iRows != 0; iRows-- )
3838    {
3839      if( piUsed[ 0] ) { iTemp = piOrg[ 0] - piCur[ 0]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3840      if( piUsed[ 1] ) { iTemp = piOrg[ 1] - piCur[ 1]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3841      if( piUsed[ 2] ) { iTemp = piOrg[ 2] - piCur[ 2]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3842      if( piUsed[ 3] ) { iTemp = piOrg[ 3] - piCur[ 3]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3843      if( piUsed[ 4] ) { iTemp = piOrg[ 4] - piCur[ 4]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3844      if( piUsed[ 5] ) { iTemp = piOrg[ 5] - piCur[ 5]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3845      if( piUsed[ 6] ) { iTemp = piOrg[ 6] - piCur[ 6]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3846      if( piUsed[ 7] ) { iTemp = piOrg[ 7] - piCur[ 7]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3847      if( piUsed[ 8] ) { iTemp = piOrg[ 8] - piCur[ 8]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3848      if( piUsed[ 9] ) { iTemp = piOrg[ 9] - piCur[ 9]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3849      if( piUsed[10] ) { iTemp = piOrg[10] - piCur[10]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3850      if( piUsed[11] ) { iTemp = piOrg[11] - piCur[11]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3851      if( piUsed[12] ) { iTemp = piOrg[12] - piCur[12]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3852      if( piUsed[13] ) { iTemp = piOrg[13] - piCur[13]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3853      if( piUsed[14] ) { iTemp = piOrg[14] - piCur[14]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3854      if( piUsed[15] ) { iTemp = piOrg[15] - piCur[15]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3855      if( piUsed[16] ) { iTemp = piOrg[16] - piCur[16]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3856      if( piUsed[17] ) { iTemp = piOrg[17] - piCur[17]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3857      if( piUsed[18] ) { iTemp = piOrg[18] - piCur[18]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3858      if( piUsed[19] ) { iTemp = piOrg[19] - piCur[19]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3859      if( piUsed[20] ) { iTemp = piOrg[20] - piCur[20]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3860      if( piUsed[21] ) { iTemp = piOrg[21] - piCur[21]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3861      if( piUsed[22] ) { iTemp = piOrg[22] - piCur[22]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3862      if( piUsed[23] ) { iTemp = piOrg[23] - piCur[23]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3863      if( piUsed[24] ) { iTemp = piOrg[24] - piCur[24]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3864      if( piUsed[25] ) { iTemp = piOrg[25] - piCur[25]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3865      if( piUsed[26] ) { iTemp = piOrg[26] - piCur[26]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3866      if( piUsed[27] ) { iTemp = piOrg[27] - piCur[27]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3867      if( piUsed[28] ) { iTemp = piOrg[28] - piCur[28]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3868      if( piUsed[29] ) { iTemp = piOrg[29] - piCur[29]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3869      if( piUsed[30] ) { iTemp = piOrg[30] - piCur[30]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3870      if( piUsed[31] ) { iTemp = piOrg[31] - piCur[31]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3871      if( piUsed[32] ) { iTemp = piOrg[32] - piCur[32]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3872      if( piUsed[33] ) { iTemp = piOrg[33] - piCur[33]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3873      if( piUsed[34] ) { iTemp = piOrg[34] - piCur[34]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3874      if( piUsed[35] ) { iTemp = piOrg[35] - piCur[35]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3875      if( piUsed[36] ) { iTemp = piOrg[36] - piCur[36]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3876      if( piUsed[37] ) { iTemp = piOrg[37] - piCur[37]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3877      if( piUsed[38] ) { iTemp = piOrg[38] - piCur[38]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3878      if( piUsed[39] ) { iTemp = piOrg[39] - piCur[39]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3879      if( piUsed[40] ) { iTemp = piOrg[40] - piCur[40]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3880      if( piUsed[41] ) { iTemp = piOrg[41] - piCur[41]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3881      if( piUsed[42] ) { iTemp = piOrg[42] - piCur[42]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3882      if( piUsed[43] ) { iTemp = piOrg[43] - piCur[43]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3883      if( piUsed[44] ) { iTemp = piOrg[44] - piCur[44]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3884      if( piUsed[45] ) { iTemp = piOrg[45] - piCur[45]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3885      if( piUsed[46] ) { iTemp = piOrg[46] - piCur[46]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3886      if( piUsed[47] ) { iTemp = piOrg[47] - piCur[47]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3887      if( piUsed[48] ) { iTemp = piOrg[48] - piCur[48]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3888      if( piUsed[49] ) { iTemp = piOrg[49] - piCur[49]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3889      if( piUsed[50] ) { iTemp = piOrg[50] - piCur[50]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3890      if( piUsed[51] ) { iTemp = piOrg[51] - piCur[51]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3891      if( piUsed[52] ) { iTemp = piOrg[52] - piCur[52]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3892      if( piUsed[53] ) { iTemp = piOrg[53] - piCur[53]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3893      if( piUsed[54] ) { iTemp = piOrg[54] - piCur[54]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3894      if( piUsed[55] ) { iTemp = piOrg[55] - piCur[55]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3895      if( piUsed[56] ) { iTemp = piOrg[56] - piCur[56]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3896      if( piUsed[57] ) { iTemp = piOrg[57] - piCur[57]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3897      if( piUsed[58] ) { iTemp = piOrg[58] - piCur[58]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3898      if( piUsed[59] ) { iTemp = piOrg[59] - piCur[59]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3899      if( piUsed[60] ) { iTemp = piOrg[60] - piCur[60]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3900      if( piUsed[61] ) { iTemp = piOrg[61] - piCur[61]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3901      if( piUsed[62] ) { iTemp = piOrg[62] - piCur[62]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3902      if( piUsed[63] ) { iTemp = piOrg[63] - piCur[63]; uiSum += ( iTemp * iTemp ) >> uiShift; }
3903
3904      piOrg  += iStrideOrg;
3905      piCur  += iStrideCur;
3906      piUsed += iStrideUsed;
3907    }
3908  }
3909  else
3910  {
3911#endif
3912  for( ; iRows != 0; iRows-- )
3913  {
3914    iTemp = piOrg[ 0] - piCur[ 0]; uiSum += ( iTemp * iTemp ) >> uiShift;
3915    iTemp = piOrg[ 1] - piCur[ 1]; uiSum += ( iTemp * iTemp ) >> uiShift;
3916    iTemp = piOrg[ 2] - piCur[ 2]; uiSum += ( iTemp * iTemp ) >> uiShift;
3917    iTemp = piOrg[ 3] - piCur[ 3]; uiSum += ( iTemp * iTemp ) >> uiShift;
3918    iTemp = piOrg[ 4] - piCur[ 4]; uiSum += ( iTemp * iTemp ) >> uiShift;
3919    iTemp = piOrg[ 5] - piCur[ 5]; uiSum += ( iTemp * iTemp ) >> uiShift;
3920    iTemp = piOrg[ 6] - piCur[ 6]; uiSum += ( iTemp * iTemp ) >> uiShift;
3921    iTemp = piOrg[ 7] - piCur[ 7]; uiSum += ( iTemp * iTemp ) >> uiShift;
3922    iTemp = piOrg[ 8] - piCur[ 8]; uiSum += ( iTemp * iTemp ) >> uiShift;
3923    iTemp = piOrg[ 9] - piCur[ 9]; uiSum += ( iTemp * iTemp ) >> uiShift;
3924    iTemp = piOrg[10] - piCur[10]; uiSum += ( iTemp * iTemp ) >> uiShift;
3925    iTemp = piOrg[11] - piCur[11]; uiSum += ( iTemp * iTemp ) >> uiShift;
3926    iTemp = piOrg[12] - piCur[12]; uiSum += ( iTemp * iTemp ) >> uiShift;
3927    iTemp = piOrg[13] - piCur[13]; uiSum += ( iTemp * iTemp ) >> uiShift;
3928    iTemp = piOrg[14] - piCur[14]; uiSum += ( iTemp * iTemp ) >> uiShift;
3929    iTemp = piOrg[15] - piCur[15]; uiSum += ( iTemp * iTemp ) >> uiShift;
3930    iTemp = piOrg[16] - piCur[16]; uiSum += ( iTemp * iTemp ) >> uiShift;
3931    iTemp = piOrg[17] - piCur[17]; uiSum += ( iTemp * iTemp ) >> uiShift;
3932    iTemp = piOrg[18] - piCur[18]; uiSum += ( iTemp * iTemp ) >> uiShift;
3933    iTemp = piOrg[19] - piCur[19]; uiSum += ( iTemp * iTemp ) >> uiShift;
3934    iTemp = piOrg[20] - piCur[20]; uiSum += ( iTemp * iTemp ) >> uiShift;
3935    iTemp = piOrg[21] - piCur[21]; uiSum += ( iTemp * iTemp ) >> uiShift;
3936    iTemp = piOrg[22] - piCur[22]; uiSum += ( iTemp * iTemp ) >> uiShift;
3937    iTemp = piOrg[23] - piCur[23]; uiSum += ( iTemp * iTemp ) >> uiShift;
3938    iTemp = piOrg[24] - piCur[24]; uiSum += ( iTemp * iTemp ) >> uiShift;
3939    iTemp = piOrg[25] - piCur[25]; uiSum += ( iTemp * iTemp ) >> uiShift;
3940    iTemp = piOrg[26] - piCur[26]; uiSum += ( iTemp * iTemp ) >> uiShift;
3941    iTemp = piOrg[27] - piCur[27]; uiSum += ( iTemp * iTemp ) >> uiShift;
3942    iTemp = piOrg[28] - piCur[28]; uiSum += ( iTemp * iTemp ) >> uiShift;
3943    iTemp = piOrg[29] - piCur[29]; uiSum += ( iTemp * iTemp ) >> uiShift;
3944    iTemp = piOrg[30] - piCur[30]; uiSum += ( iTemp * iTemp ) >> uiShift;
3945    iTemp = piOrg[31] - piCur[31]; uiSum += ( iTemp * iTemp ) >> uiShift;
3946    iTemp = piOrg[32] - piCur[32]; uiSum += ( iTemp * iTemp ) >> uiShift;
3947    iTemp = piOrg[33] - piCur[33]; uiSum += ( iTemp * iTemp ) >> uiShift;
3948    iTemp = piOrg[34] - piCur[34]; uiSum += ( iTemp * iTemp ) >> uiShift;
3949    iTemp = piOrg[35] - piCur[35]; uiSum += ( iTemp * iTemp ) >> uiShift;
3950    iTemp = piOrg[36] - piCur[36]; uiSum += ( iTemp * iTemp ) >> uiShift;
3951    iTemp = piOrg[37] - piCur[37]; uiSum += ( iTemp * iTemp ) >> uiShift;
3952    iTemp = piOrg[38] - piCur[38]; uiSum += ( iTemp * iTemp ) >> uiShift;
3953    iTemp = piOrg[39] - piCur[39]; uiSum += ( iTemp * iTemp ) >> uiShift;
3954    iTemp = piOrg[40] - piCur[40]; uiSum += ( iTemp * iTemp ) >> uiShift;
3955    iTemp = piOrg[41] - piCur[41]; uiSum += ( iTemp * iTemp ) >> uiShift;
3956    iTemp = piOrg[42] - piCur[42]; uiSum += ( iTemp * iTemp ) >> uiShift;
3957    iTemp = piOrg[43] - piCur[43]; uiSum += ( iTemp * iTemp ) >> uiShift;
3958    iTemp = piOrg[44] - piCur[44]; uiSum += ( iTemp * iTemp ) >> uiShift;
3959    iTemp = piOrg[45] - piCur[45]; uiSum += ( iTemp * iTemp ) >> uiShift;
3960    iTemp = piOrg[46] - piCur[46]; uiSum += ( iTemp * iTemp ) >> uiShift;
3961    iTemp = piOrg[47] - piCur[47]; uiSum += ( iTemp * iTemp ) >> uiShift;
3962    iTemp = piOrg[48] - piCur[48]; uiSum += ( iTemp * iTemp ) >> uiShift;
3963    iTemp = piOrg[49] - piCur[49]; uiSum += ( iTemp * iTemp ) >> uiShift;
3964    iTemp = piOrg[50] - piCur[50]; uiSum += ( iTemp * iTemp ) >> uiShift;
3965    iTemp = piOrg[51] - piCur[51]; uiSum += ( iTemp * iTemp ) >> uiShift;
3966    iTemp = piOrg[52] - piCur[52]; uiSum += ( iTemp * iTemp ) >> uiShift;
3967    iTemp = piOrg[53] - piCur[53]; uiSum += ( iTemp * iTemp ) >> uiShift;
3968    iTemp = piOrg[54] - piCur[54]; uiSum += ( iTemp * iTemp ) >> uiShift;
3969    iTemp = piOrg[55] - piCur[55]; uiSum += ( iTemp * iTemp ) >> uiShift;
3970    iTemp = piOrg[56] - piCur[56]; uiSum += ( iTemp * iTemp ) >> uiShift;
3971    iTemp = piOrg[57] - piCur[57]; uiSum += ( iTemp * iTemp ) >> uiShift;
3972    iTemp = piOrg[58] - piCur[58]; uiSum += ( iTemp * iTemp ) >> uiShift;
3973    iTemp = piOrg[59] - piCur[59]; uiSum += ( iTemp * iTemp ) >> uiShift;
3974    iTemp = piOrg[60] - piCur[60]; uiSum += ( iTemp * iTemp ) >> uiShift;
3975    iTemp = piOrg[61] - piCur[61]; uiSum += ( iTemp * iTemp ) >> uiShift;
3976    iTemp = piOrg[62] - piCur[62]; uiSum += ( iTemp * iTemp ) >> uiShift;
3977    iTemp = piOrg[63] - piCur[63]; uiSum += ( iTemp * iTemp ) >> uiShift;
3978   
3979    piOrg += iStrideOrg;
3980    piCur += iStrideCur;
3981  }
3982#if SB_INTERVIEW_SKIP
3983  }
3984#endif
3985 
3986  return ( uiSum );
3987}
3988#endif
3989
3990// --------------------------------------------------------------------------------------------------------------------
3991// HADAMARD with step (used in fractional search)
3992// --------------------------------------------------------------------------------------------------------------------
3993
3994#ifdef ROUNDING_CONTROL_BIPRED
3995
3996UInt TComRdCost::xCalcHADs2x2( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep, Pel* pRefY, Int refYStride, Bool bRound )
3997{
3998  Int satd = 0, diff[4], m[4];
3999  Pel pred;
4000 
4001  pred = ( (piCur[0] + pRefY[0] + bRound) >> 1);
4002  diff[0] = (piOrg[0             ] - pred) << 1;
4003  pred = ( (piCur[iStep] + pRefY[1] + bRound) >> 1);
4004  diff[1] = (piOrg[1             ] - pred) << 1;
4005  pred = ( (piCur[iStrideCur] + pRefY[refYStride] + bRound) >> 1);
4006  diff[2] = (piOrg[iStrideOrg    ] - pred) << 1;
4007  pred = ( (piCur[iStep + iStrideCur] + pRefY[refYStride + 1] + bRound) >> 1);
4008  diff[3] = (piOrg[iStrideOrg + 1] - pred) << 1;
4009 
4010  m[0] = diff[0] + diff[2];
4011  m[1] = diff[1] + diff[3];
4012  m[2] = diff[0] - diff[2];
4013  m[3] = diff[1] - diff[3];
4014 
4015  satd += abs(m[0] + m[1]);
4016  satd += abs(m[0] - m[1]);
4017  satd += abs(m[2] + m[3]);
4018  satd += abs(m[2] - m[3]);
4019 
4020  return satd;
4021}
4022
4023UInt TComRdCost::xCalcHADs4x4( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep, Pel* pRefY, Int refYStride, Bool bRound )
4024{
4025  Int k, satd = 0, diff[16], m[16], d[16];
4026  Pel pred;
4027  Pel* piRef = pRefY;
4028 
4029  for( k = 0; k < 16; k+=4 )
4030  {
4031    pred = ( (piCur[0*iStep] + piRef[0] + bRound) >> 1);
4032    diff[k+0] = (piOrg[0] - pred) << 1;
4033    pred = ( (piCur[1*iStep] + piRef[1] + bRound) >> 1);
4034    diff[k+1] = (piOrg[1] - pred) << 1;
4035    pred = ( (piCur[2*iStep] + piRef[2] + bRound) >> 1);
4036    diff[k+2] = (piOrg[2] - pred) << 1;
4037    pred = ( (piCur[3*iStep] + piRef[3] + bRound) >> 1);
4038    diff[k+3] = (piOrg[3] - pred) << 1;
4039
4040    piCur += iStrideCur;
4041    piOrg += iStrideOrg;
4042    piRef += refYStride;
4043  }
4044 
4045  /*===== hadamard transform =====*/
4046  m[ 0] = diff[ 0] + diff[12];
4047  m[ 1] = diff[ 1] + diff[13];
4048  m[ 2] = diff[ 2] + diff[14];
4049  m[ 3] = diff[ 3] + diff[15];
4050  m[ 4] = diff[ 4] + diff[ 8];
4051  m[ 5] = diff[ 5] + diff[ 9];
4052  m[ 6] = diff[ 6] + diff[10];
4053  m[ 7] = diff[ 7] + diff[11];
4054  m[ 8] = diff[ 4] - diff[ 8];
4055  m[ 9] = diff[ 5] - diff[ 9];
4056  m[10] = diff[ 6] - diff[10];
4057  m[11] = diff[ 7] - diff[11];
4058  m[12] = diff[ 0] - diff[12];
4059  m[13] = diff[ 1] - diff[13];
4060  m[14] = diff[ 2] - diff[14];
4061  m[15] = diff[ 3] - diff[15];
4062 
4063  d[ 0] = m[ 0] + m[ 4];
4064  d[ 1] = m[ 1] + m[ 5];
4065  d[ 2] = m[ 2] + m[ 6];
4066  d[ 3] = m[ 3] + m[ 7];
4067  d[ 4] = m[ 8] + m[12];
4068  d[ 5] = m[ 9] + m[13];
4069  d[ 6] = m[10] + m[14];
4070  d[ 7] = m[11] + m[15];
4071  d[ 8] = m[ 0] - m[ 4];
4072  d[ 9] = m[ 1] - m[ 5];
4073  d[10] = m[ 2] - m[ 6];
4074  d[11] = m[ 3] - m[ 7];
4075  d[12] = m[12] - m[ 8];
4076  d[13] = m[13] - m[ 9];
4077  d[14] = m[14] - m[10];
4078  d[15] = m[15] - m[11];
4079 
4080  m[ 0] = d[ 0] + d[ 3];
4081  m[ 1] = d[ 1] + d[ 2];
4082  m[ 2] = d[ 1] - d[ 2];
4083  m[ 3] = d[ 0] - d[ 3];
4084  m[ 4] = d[ 4] + d[ 7];
4085  m[ 5] = d[ 5] + d[ 6];
4086  m[ 6] = d[ 5] - d[ 6];
4087  m[ 7] = d[ 4] - d[ 7];
4088  m[ 8] = d[ 8] + d[11];
4089  m[ 9] = d[ 9] + d[10];
4090  m[10] = d[ 9] - d[10];
4091  m[11] = d[ 8] - d[11];
4092  m[12] = d[12] + d[15];
4093  m[13] = d[13] + d[14];
4094  m[14] = d[13] - d[14];
4095  m[15] = d[12] - d[15];
4096 
4097  d[ 0] = m[ 0] + m[ 1];
4098  d[ 1] = m[ 0] - m[ 1];
4099  d[ 2] = m[ 2] + m[ 3];
4100  d[ 3] = m[ 3] - m[ 2];
4101  d[ 4] = m[ 4] + m[ 5];
4102  d[ 5] = m[ 4] - m[ 5];
4103  d[ 6] = m[ 6] + m[ 7];
4104  d[ 7] = m[ 7] - m[ 6];
4105  d[ 8] = m[ 8] + m[ 9];
4106  d[ 9] = m[ 8] - m[ 9];
4107  d[10] = m[10] + m[11];
4108  d[11] = m[11] - m[10];
4109  d[12] = m[12] + m[13];
4110  d[13] = m[12] - m[13];
4111  d[14] = m[14] + m[15];
4112  d[15] = m[15] - m[14];
4113 
4114  for (k=0; k<16; ++k)
4115  {
4116    satd += abs(d[k]);
4117  }
4118  satd = ((satd+1)>>1);
4119 
4120  return satd;
4121}
4122
4123UInt TComRdCost::xCalcHADs8x8( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep, Pel* pRefY, Int refYStride, Bool bRound )
4124{
4125  Int k, i, j, jj, sad=0;
4126  Int diff[64], m1[8][8], m2[8][8], m3[8][8];
4127  Pel pred;
4128  Pel* piRef = pRefY;
4129  Int iStep2 = iStep<<1;
4130  Int iStep3 = iStep2 + iStep;
4131  Int iStep4 = iStep3 + iStep;
4132  Int iStep5 = iStep4 + iStep;
4133  Int iStep6 = iStep5 + iStep;
4134  Int iStep7 = iStep6 + iStep;
4135 
4136  for( k = 0; k < 64; k+=8 )
4137  {
4138    pred = ( (piCur[0     ] + piRef[0] + bRound) >> 1 );  diff[k  ] = (piOrg[0] - pred) << 1;
4139    pred = ( (piCur[iStep ] + piRef[1] + bRound) >> 1 );  diff[k+1] = (piOrg[1] - pred) << 1;
4140    pred = ( (piCur[iStep2] + piRef[2] + bRound) >> 1 );  diff[k+2] = (piOrg[2] - pred) << 1;
4141    pred = ( (piCur[iStep3] + piRef[3] + bRound) >> 1 );  diff[k+3] = (piOrg[3] - pred) << 1;
4142    pred = ( (piCur[iStep4] + piRef[4] + bRound) >> 1 );  diff[k+4] = (piOrg[4] - pred) << 1;
4143    pred = ( (piCur[iStep5] + piRef[5] + bRound) >> 1 );  diff[k+5] = (piOrg[5] - pred) << 1;
4144    pred = ( (piCur[iStep6] + piRef[6] + bRound) >> 1 );  diff[k+6] = (piOrg[6] - pred) << 1;
4145    pred = ( (piCur[iStep7] + piRef[7] + bRound) >> 1 );  diff[k+7] = (piOrg[7] - pred) << 1;
4146    piCur += iStrideCur;
4147    piOrg += iStrideOrg;
4148    piRef += refYStride;
4149  }
4150  //horizontal
4151  for (j=0; j < 8; j++)
4152  {
4153    jj = j << 3;
4154    m2[j][0] = diff[jj  ] + diff[jj+4];
4155    m2[j][1] = diff[jj+1] + diff[jj+5];
4156    m2[j][2] = diff[jj+2] + diff[jj+6];
4157    m2[j][3] = diff[jj+3] + diff[jj+7];
4158    m2[j][4] = diff[jj  ] - diff[jj+4];
4159    m2[j][5] = diff[jj+1] - diff[jj+5];
4160    m2[j][6] = diff[jj+2] - diff[jj+6];
4161    m2[j][7] = diff[jj+3] - diff[jj+7];
4162   
4163    m1[j][0] = m2[j][0] + m2[j][2];
4164    m1[j][1] = m2[j][1] + m2[j][3];
4165    m1[j][2] = m2[j][0] - m2[j][2];
4166    m1[j][3] = m2[j][1] - m2[j][3];
4167    m1[j][4] = m2[j][4] + m2[j][6];
4168    m1[j][5] = m2[j][5] + m2[j][7];
4169    m1[j][6] = m2[j][4] - m2[j][6];
4170    m1[j][7] = m2[j][5] - m2[j][7];
4171   
4172    m2[j][0] = m1[j][0] + m1[j][1];
4173    m2[j][1] = m1[j][0] - m1[j][1];
4174    m2[j][2] = m1[j][2] + m1[j][3];
4175    m2[j][3] = m1[j][2] - m1[j][3];
4176    m2[j][4] = m1[j][4] + m1[j][5];
4177    m2[j][5] = m1[j][4] - m1[j][5];
4178    m2[j][6] = m1[j][6] + m1[j][7];
4179    m2[j][7] = m1[j][6] - m1[j][7];
4180  }
4181 
4182  //vertical
4183  for (i=0; i < 8; i++)
4184  {
4185    m3[0][i] = m2[0][i] + m2[4][i];
4186    m3[1][i] = m2[1][i] + m2[5][i];
4187    m3[2][i] = m2[2][i] + m2[6][i];
4188    m3[3][i] = m2[3][i] + m2[7][i];
4189    m3[4][i] = m2[0][i] - m2[4][i];
4190    m3[5][i] = m2[1][i] - m2[5][i];
4191    m3[6][i] = m2[2][i] - m2[6][i];
4192    m3[7][i] = m2[3][i] - m2[7][i];
4193   
4194    m1[0][i] = m3[0][i] + m3[2][i];
4195    m1[1][i] = m3[1][i] + m3[3][i];
4196    m1[2][i] = m3[0][i] - m3[2][i];
4197    m1[3][i] = m3[1][i] - m3[3][i];
4198    m1[4][i] = m3[4][i] + m3[6][i];
4199    m1[5][i] = m3[5][i] + m3[7][i];
4200    m1[6][i] = m3[4][i] - m3[6][i];
4201    m1[7][i] = m3[5][i] - m3[7][i];
4202   
4203    m2[0][i] = m1[0][i] + m1[1][i];
4204    m2[1][i] = m1[0][i] - m1[1][i];
4205    m2[2][i] = m1[2][i] + m1[3][i];
4206    m2[3][i] = m1[2][i] - m1[3][i];
4207    m2[4][i] = m1[4][i] + m1[5][i];
4208    m2[5][i] = m1[4][i] - m1[5][i];
4209    m2[6][i] = m1[6][i] + m1[7][i];
4210    m2[7][i] = m1[6][i] - m1[7][i];
4211  }
4212  for (j=0; j < 8; j++)
4213    for (i=0; i < 8; i++)
4214      sad += (abs(m2[j][i]));
4215 
4216  sad=((sad+2)>>2);
4217 
4218  return sad;
4219}
4220
4221UInt TComRdCost::xGetHADs4( DistParam* pcDtParam, Pel* pRefY, Bool bRound )
4222{
4223  Pel* piOrg   = pcDtParam->pOrg;
4224  Pel* piCur   = pcDtParam->pCur;
4225  Pel* piRef   = pRefY;
4226  Int  iRows   = pcDtParam->iRows;
4227  Int  iStrideCur = pcDtParam->iStrideCur;
4228  Int  iStrideOrg = pcDtParam->iStrideOrg;
4229  Int  iStep  = pcDtParam->iStep;
4230  Int  y;
4231  Int  iOffsetOrg = iStrideOrg<<2;
4232  Int  iOffsetCur = iStrideCur<<2;
4233 
4234  UInt uiSum = 0;
4235 
4236  for ( y=0; y<iRows; y+= 4 )
4237  {
4238    uiSum += xCalcHADs4x4( piOrg, piCur, iStrideOrg, iStrideCur, iStep, piRef, pcDtParam->iCols, bRound );
4239    piOrg += iOffsetOrg;
4240    piCur += iOffsetCur;
4241    piRef += (pcDtParam->iCols << 2);
4242  }
4243 
4244  return ( uiSum >> g_uiBitIncrement );
4245}
4246
4247UInt TComRdCost::xGetHADs8( DistParam* pcDtParam, Pel* pRefY, Bool bRound )
4248{
4249  Pel* piOrg   = pcDtParam->pOrg;
4250  Pel* piCur   = pcDtParam->pCur;
4251  Pel* piRef   = pRefY;
4252  Int  iRows   = pcDtParam->iRows;
4253  Int  iStrideCur = pcDtParam->iStrideCur;
4254  Int  iStrideOrg = pcDtParam->iStrideOrg;
4255  Int  iStep  = pcDtParam->iStep;
4256  Int  y;
4257 
4258  UInt uiSum = 0;
4259 
4260  if ( iRows == 4 ) // 8x4 case
4261  {
4262    uiSum += xCalcHADs4x4( piOrg+0, piCur        , iStrideOrg, iStrideCur, iStep, piRef, pcDtParam->iCols, bRound );
4263    uiSum += xCalcHADs4x4( piOrg+4, piCur+4*iStep, iStrideOrg, iStrideCur, iStep, piRef+4, pcDtParam->iCols, bRound );
4264  }
4265  else
4266  {
4267    Int  iOffsetOrg = iStrideOrg<<3;
4268    Int  iOffsetCur = iStrideCur<<3;
4269    for ( y=0; y<iRows; y+= 8 )
4270    {
4271      uiSum += xCalcHADs8x8( piOrg, piCur, iStrideOrg, iStrideCur, iStep, piRef, pcDtParam->iCols, bRound );
4272      piOrg += iOffsetOrg;
4273      piCur += iOffsetCur;
4274      piRef += (pcDtParam->iCols << 3);
4275    }
4276  }
4277 
4278  return ( uiSum >> g_uiBitIncrement );
4279}
4280
4281UInt TComRdCost::xGetHADs( DistParam* pcDtParam, Pel* pRefY, Bool bRound )
4282{
4283  Pel* piOrg   = pcDtParam->pOrg;
4284  Pel* piCur   = pcDtParam->pCur;
4285  Pel* piRef   = pRefY;
4286  Int  iRows   = pcDtParam->iRows;
4287  Int  iCols   = pcDtParam->iCols;
4288  Int  iStrideCur = pcDtParam->iStrideCur;
4289  Int  iStrideOrg = pcDtParam->iStrideOrg;
4290  Int  iStep  = pcDtParam->iStep;
4291 
4292  Int  x, y;
4293 
4294  UInt uiSum = 0;
4295 
4296  if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
4297  {
4298    Int  iOffsetOrg = iStrideOrg<<3;
4299    Int  iOffsetCur = iStrideCur<<3;
4300    for ( y=0; y<iRows; y+= 8 )
4301    {
4302      for ( x=0; x<iCols; x+= 8 )  // do HAD over 8xiCols pixels
4303      {
4304        uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep, &piRef[x], iCols, bRound );
4305      }
4306      piOrg += iOffsetOrg;
4307      piCur += iOffsetCur;
4308      piRef += (iCols << 3);
4309    }
4310  }
4311  else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
4312  {
4313    Int  iOffsetOrg = iStrideOrg<<2;
4314    Int  iOffsetCur = iStrideCur<<2;
4315   
4316    for ( y=0; y<iRows; y+= 4 )
4317    {
4318      for ( x=0; x<iCols; x+= 4 ) // do HAD over 4xiCols pixels
4319      {
4320        uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep, &piRef[x], iCols, bRound );
4321      }
4322      piOrg += iOffsetOrg;
4323      piCur += iOffsetCur;
4324      piRef += (iCols << 2);
4325    }
4326  }
4327  else
4328  {
4329    for ( y=0; y<iRows; y+=2 )
4330    {
4331      for ( x=0; x<iCols; x+=2 )// do HAD over 2xiCols pixels
4332      {
4333        uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep, &piRef[x], iCols, bRound );
4334      }
4335      piOrg += iStrideOrg;  // should this be (iStrideOrg << 1) ?
4336      piCur += iStrideCur;
4337      piRef += iCols;
4338    }
4339  }
4340 
4341  return ( uiSum >> g_uiBitIncrement );
4342}
4343
4344#endif
4345
4346UInt TComRdCost::xCalcHADs2x2( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
4347{
4348  Int satd = 0, diff[4], m[4];
4349  diff[0] = piOrg[0             ] - piCur[0*iStep];
4350  diff[1] = piOrg[1             ] - piCur[1*iStep];
4351  diff[2] = piOrg[iStrideOrg    ] - piCur[0*iStep + iStrideCur];
4352  diff[3] = piOrg[iStrideOrg + 1] - piCur[1*iStep + iStrideCur];
4353 
4354  m[0] = diff[0] + diff[2];
4355  m[1] = diff[1] + diff[3];
4356  m[2] = diff[0] - diff[2];
4357  m[3] = diff[1] - diff[3];
4358 
4359  satd += abs(m[0] + m[1]);
4360  satd += abs(m[0] - m[1]);
4361  satd += abs(m[2] + m[3]);
4362  satd += abs(m[2] - m[3]);
4363 
4364  return satd;
4365}
4366
4367UInt TComRdCost::xCalcHADs4x4( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
4368{
4369  Int k, satd = 0, diff[16], m[16], d[16];
4370 
4371  for( k = 0; k < 16; k+=4 )
4372  {
4373    diff[k+0] = piOrg[0] - piCur[0*iStep];
4374    diff[k+1] = piOrg[1] - piCur[1*iStep];
4375    diff[k+2] = piOrg[2] - piCur[2*iStep];
4376    diff[k+3] = piOrg[3] - piCur[3*iStep];
4377   
4378    piCur += iStrideCur;
4379    piOrg += iStrideOrg;
4380  }
4381 
4382  /*===== hadamard transform =====*/
4383  m[ 0] = diff[ 0] + diff[12];
4384  m[ 1] = diff[ 1] + diff[13];
4385  m[ 2] = diff[ 2] + diff[14];
4386  m[ 3] = diff[ 3] + diff[15];
4387  m[ 4] = diff[ 4] + diff[ 8];
4388  m[ 5] = diff[ 5] + diff[ 9];
4389  m[ 6] = diff[ 6] + diff[10];
4390  m[ 7] = diff[ 7] + diff[11];
4391  m[ 8] = diff[ 4] - diff[ 8];
4392  m[ 9] = diff[ 5] - diff[ 9];
4393  m[10] = diff[ 6] - diff[10];
4394  m[11] = diff[ 7] - diff[11];
4395  m[12] = diff[ 0] - diff[12];
4396  m[13] = diff[ 1] - diff[13];
4397  m[14] = diff[ 2] - diff[14];
4398  m[15] = diff[ 3] - diff[15];
4399 
4400  d[ 0] = m[ 0] + m[ 4];
4401  d[ 1] = m[ 1] + m[ 5];
4402  d[ 2] = m[ 2] + m[ 6];
4403  d[ 3] = m[ 3] + m[ 7];
4404  d[ 4] = m[ 8] + m[12];
4405  d[ 5] = m[ 9] + m[13];
4406  d[ 6] = m[10] + m[14];
4407  d[ 7] = m[11] + m[15];
4408  d[ 8] = m[ 0] - m[ 4];
4409  d[ 9] = m[ 1] - m[ 5];
4410  d[10] = m[ 2] - m[ 6];
4411  d[11] = m[ 3] - m[ 7];
4412  d[12] = m[12] - m[ 8];
4413  d[13] = m[13] - m[ 9];
4414  d[14] = m[14] - m[10];
4415  d[15] = m[15] - m[11];
4416 
4417  m[ 0] = d[ 0] + d[ 3];
4418  m[ 1] = d[ 1] + d[ 2];
4419  m[ 2] = d[ 1] - d[ 2];
4420  m[ 3] = d[ 0] - d[ 3];
4421  m[ 4] = d[ 4] + d[ 7];
4422  m[ 5] = d[ 5] + d[ 6];
4423  m[ 6] = d[ 5] - d[ 6];
4424  m[ 7] = d[ 4] - d[ 7];
4425  m[ 8] = d[ 8] + d[11];
4426  m[ 9] = d[ 9] + d[10];
4427  m[10] = d[ 9] - d[10];
4428  m[11] = d[ 8] - d[11];
4429  m[12] = d[12] + d[15];
4430  m[13] = d[13] + d[14];
4431  m[14] = d[13] - d[14];
4432  m[15] = d[12] - d[15];
4433 
4434  d[ 0] = m[ 0] + m[ 1];
4435  d[ 1] = m[ 0] - m[ 1];
4436  d[ 2] = m[ 2] + m[ 3];
4437  d[ 3] = m[ 3] - m[ 2];
4438  d[ 4] = m[ 4] + m[ 5];
4439  d[ 5] = m[ 4] - m[ 5];
4440  d[ 6] = m[ 6] + m[ 7];
4441  d[ 7] = m[ 7] - m[ 6];
4442  d[ 8] = m[ 8] + m[ 9];
4443  d[ 9] = m[ 8] - m[ 9];
4444  d[10] = m[10] + m[11];
4445  d[11] = m[11] - m[10];
4446  d[12] = m[12] + m[13];
4447  d[13] = m[12] - m[13];
4448  d[14] = m[14] + m[15];
4449  d[15] = m[15] - m[14];
4450 
4451  for (k=0; k<16; ++k)
4452  {
4453    satd += abs(d[k]);
4454  }
4455  satd = ((satd+1)>>1);
4456 
4457  return satd;
4458}
4459
4460UInt TComRdCost::xCalcHADs8x8( Pel *piOrg, Pel *piCur, Int iStrideOrg, Int iStrideCur, Int iStep )
4461{
4462  Int k, i, j, jj, sad=0;
4463  Int diff[64], m1[8][8], m2[8][8], m3[8][8];
4464  Int iStep2 = iStep<<1;
4465  Int iStep3 = iStep2 + iStep;
4466  Int iStep4 = iStep3 + iStep;
4467  Int iStep5 = iStep4 + iStep;
4468  Int iStep6 = iStep5 + iStep;
4469  Int iStep7 = iStep6 + iStep;
4470 
4471  for( k = 0; k < 64; k+=8 )
4472  {
4473    diff[k+0] = piOrg[0] - piCur[     0];
4474    diff[k+1] = piOrg[1] - piCur[iStep ];
4475    diff[k+2] = piOrg[2] - piCur[iStep2];
4476    diff[k+3] = piOrg[3] - piCur[iStep3];
4477    diff[k+4] = piOrg[4] - piCur[iStep4];
4478    diff[k+5] = piOrg[5] - piCur[iStep5];
4479    diff[k+6] = piOrg[6] - piCur[iStep6];
4480    diff[k+7] = piOrg[7] - piCur[iStep7];
4481   
4482    piCur += iStrideCur;
4483    piOrg += iStrideOrg;
4484  }
4485 
4486  //horizontal
4487  for (j=0; j < 8; j++)
4488  {
4489    jj = j << 3;
4490    m2[j][0] = diff[jj  ] + diff[jj+4];
4491    m2[j][1] = diff[jj+1] + diff[jj+5];
4492    m2[j][2] = diff[jj+2] + diff[jj+6];
4493    m2[j][3] = diff[jj+3] + diff[jj+7];
4494    m2[j][4] = diff[jj  ] - diff[jj+4];
4495    m2[j][5] = diff[jj+1] - diff[jj+5];
4496    m2[j][6] = diff[jj+2] - diff[jj+6];
4497    m2[j][7] = diff[jj+3] - diff[jj+7];
4498   
4499    m1[j][0] = m2[j][0] + m2[j][2];
4500    m1[j][1] = m2[j][1] + m2[j][3];
4501    m1[j][2] = m2[j][0] - m2[j][2];
4502    m1[j][3] = m2[j][1] - m2[j][3];
4503    m1[j][4] = m2[j][4] + m2[j][6];
4504    m1[j][5] = m2[j][5] + m2[j][7];
4505    m1[j][6] = m2[j][4] - m2[j][6];
4506    m1[j][7] = m2[j][5] - m2[j][7];
4507   
4508    m2[j][0] = m1[j][0] + m1[j][1];
4509    m2[j][1] = m1[j][0] - m1[j][1];
4510    m2[j][2] = m1[j][2] + m1[j][3];
4511    m2[j][3] = m1[j][2] - m1[j][3];
4512    m2[j][4] = m1[j][4] + m1[j][5];
4513    m2[j][5] = m1[j][4] - m1[j][5];
4514    m2[j][6] = m1[j][6] + m1[j][7];
4515    m2[j][7] = m1[j][6] - m1[j][7];
4516  }
4517 
4518  //vertical
4519  for (i=0; i < 8; i++)
4520  {
4521    m3[0][i] = m2[0][i] + m2[4][i];
4522    m3[1][i] = m2[1][i] + m2[5][i];
4523    m3[2][i] = m2[2][i] + m2[6][i];
4524    m3[3][i] = m2[3][i] + m2[7][i];
4525    m3[4][i] = m2[0][i] - m2[4][i];
4526    m3[5][i] = m2[1][i] - m2[5][i];
4527    m3[6][i] = m2[2][i] - m2[6][i];
4528    m3[7][i] = m2[3][i] - m2[7][i];
4529   
4530    m1[0][i] = m3[0][i] + m3[2][i];
4531    m1[1][i] = m3[1][i] + m3[3][i];
4532    m1[2][i] = m3[0][i] - m3[2][i];
4533    m1[3][i] = m3[1][i] - m3[3][i];
4534    m1[4][i] = m3[4][i] + m3[6][i];
4535    m1[5][i] = m3[5][i] + m3[7][i];
4536    m1[6][i] = m3[4][i] - m3[6][i];
4537    m1[7][i] = m3[5][i] - m3[7][i];
4538   
4539    m2[0][i] = m1[0][i] + m1[1][i];
4540    m2[1][i] = m1[0][i] - m1[1][i];
4541    m2[2][i] = m1[2][i] + m1[3][i];
4542    m2[3][i] = m1[2][i] - m1[3][i];
4543    m2[4][i] = m1[4][i] + m1[5][i];
4544    m2[5][i] = m1[4][i] - m1[5][i];
4545    m2[6][i] = m1[6][i] + m1[7][i];
4546    m2[7][i] = m1[6][i] - m1[7][i];
4547  }
4548 
4549  for (j=0; j < 8; j++)
4550  {
4551    for (i=0; i < 8; i++)
4552      sad += (abs(m2[j][i]));
4553  }
4554 
4555  sad=((sad+2)>>2);
4556 
4557  return sad;
4558}
4559
4560UInt TComRdCost::xGetHADs4( DistParam* pcDtParam )
4561{
4562#ifdef WEIGHT_PRED
4563  if ( pcDtParam->applyWeight )
4564  {
4565    return xGetHADs4w( pcDtParam );
4566  }
4567#endif
4568  Pel* piOrg   = pcDtParam->pOrg;
4569  Pel* piCur   = pcDtParam->pCur;
4570  Int  iRows   = pcDtParam->iRows;
4571  Int  iStrideCur = pcDtParam->iStrideCur;
4572  Int  iStrideOrg = pcDtParam->iStrideOrg;
4573  Int  iStep  = pcDtParam->iStep;
4574  Int  y;
4575  Int  iOffsetOrg = iStrideOrg<<2;
4576  Int  iOffsetCur = iStrideCur<<2;
4577 
4578  UInt uiSum = 0;
4579 
4580  for ( y=0; y<iRows; y+= 4 )
4581  {
4582    uiSum += xCalcHADs4x4( piOrg, piCur, iStrideOrg, iStrideCur, iStep );
4583    piOrg += iOffsetOrg;
4584    piCur += iOffsetCur;
4585  }
4586 
4587  return ( uiSum >> g_uiBitIncrement );
4588}
4589
4590UInt TComRdCost::xGetHADs8( DistParam* pcDtParam )
4591{
4592#ifdef WEIGHT_PRED
4593  if ( pcDtParam->applyWeight )
4594  {
4595    return xGetHADs8w( pcDtParam );
4596  }
4597#endif
4598  Pel* piOrg   = pcDtParam->pOrg;
4599  Pel* piCur   = pcDtParam->pCur;
4600  Int  iRows   = pcDtParam->iRows;
4601  Int  iStrideCur = pcDtParam->iStrideCur;
4602  Int  iStrideOrg = pcDtParam->iStrideOrg;
4603  Int  iStep  = pcDtParam->iStep;
4604  Int  y;
4605 
4606  UInt uiSum = 0;
4607 
4608  if ( iRows == 4 )
4609  {
4610    uiSum += xCalcHADs4x4( piOrg+0, piCur        , iStrideOrg, iStrideCur, iStep );
4611    uiSum += xCalcHADs4x4( piOrg+4, piCur+4*iStep, iStrideOrg, iStrideCur, iStep );
4612  }
4613  else
4614  {
4615    Int  iOffsetOrg = iStrideOrg<<3;
4616    Int  iOffsetCur = iStrideCur<<3;
4617    for ( y=0; y<iRows; y+= 8 )
4618    {
4619      uiSum += xCalcHADs8x8( piOrg, piCur, iStrideOrg, iStrideCur, iStep );
4620      piOrg += iOffsetOrg;
4621      piCur += iOffsetCur;
4622    }
4623  }
4624 
4625  return ( uiSum >> g_uiBitIncrement );
4626}
4627
4628UInt TComRdCost::xGetHADs( DistParam* pcDtParam )
4629{
4630#ifdef WEIGHT_PRED
4631  if ( pcDtParam->applyWeight )
4632  {
4633    return xGetHADsw( pcDtParam );
4634  }
4635#endif
4636  Pel* piOrg   = pcDtParam->pOrg;
4637  Pel* piCur   = pcDtParam->pCur;
4638  Int  iRows   = pcDtParam->iRows;
4639  Int  iCols   = pcDtParam->iCols;
4640  Int  iStrideCur = pcDtParam->iStrideCur;
4641  Int  iStrideOrg = pcDtParam->iStrideOrg;
4642  Int  iStep  = pcDtParam->iStep;
4643 
4644  Int  x, y;
4645 
4646  UInt uiSum = 0;
4647 
4648  if( ( iRows % 8 == 0) && (iCols % 8 == 0) )
4649  {
4650    Int  iOffsetOrg = iStrideOrg<<3;
4651    Int  iOffsetCur = iStrideCur<<3;
4652    for ( y=0; y<iRows; y+= 8 )
4653    {
4654      for ( x=0; x<iCols; x+= 8 )
4655      {
4656        uiSum += xCalcHADs8x8( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
4657      }
4658      piOrg += iOffsetOrg;
4659      piCur += iOffsetCur;
4660    }
4661  }
4662  else if( ( iRows % 4 == 0) && (iCols % 4 == 0) )
4663  {
4664    Int  iOffsetOrg = iStrideOrg<<2;
4665    Int  iOffsetCur = iStrideCur<<2;
4666   
4667    for ( y=0; y<iRows; y+= 4 )
4668    {
4669      for ( x=0; x<iCols; x+= 4 )
4670      {
4671        uiSum += xCalcHADs4x4( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
4672      }
4673      piOrg += iOffsetOrg;
4674      piCur += iOffsetCur;
4675    }
4676  }
4677#ifdef DCM_RDCOST_TEMP_FIX //Temporary fix since row size can be 1 or 3 for chroma (such a case does not occur under current encoder settings)
4678  else if( ( iRows % 2 == 0) && (iCols % 2 == 0) )
4679  {
4680    Int  iOffsetOrg = iStrideOrg<<1;
4681    Int  iOffsetCur = iStrideCur<<1;
4682#else
4683  else
4684  {
4685#endif
4686    for ( y=0; y<iRows; y+=2 )
4687    {
4688      for ( x=0; x<iCols; x+=2 )
4689      {
4690        uiSum += xCalcHADs2x2( &piOrg[x], &piCur[x*iStep], iStrideOrg, iStrideCur, iStep );
4691      }
4692#ifdef DCM_RDCOST_TEMP_FIX //Temporary fix since we need to increment by 2*iStride instead of iStride
4693      piOrg += iOffsetOrg;
4694      piCur += iOffsetCur;
4695#else
4696      piOrg += iStrideOrg;
4697      piCur += iStrideCur;
4698#endif
4699    }
4700  }
4701#ifdef DCM_RDCOST_TEMP_FIX //Temporary fix to return MAX_UINT until this case is properly handled
4702  else
4703  {
4704    printf("xGetHADs not supported for this dimension. Skipping computation of HAD and returning MAX_UINT\n");
4705    return (MAX_UINT);
4706  }
4707#endif
4708 
4709  return ( uiSum >> g_uiBitIncrement );
4710}
4711
4712
4713//GT VSO
4714
4715Void TComRdCost::setLambdaVSO( Double dLambdaVSO )
4716{
4717  m_dLambdaVSO           = dLambdaVSO;
4718  m_dSqrtLambdaVSO       = sqrt(m_dLambdaVSO); 
4719  m_uiLambdaMotionSADVSO = (UInt)floor(65536.0 *       m_dSqrtLambdaVSO);
4720  m_uiLambdaMotionSSEVSO = (UInt)floor(65536.0 *       m_dLambdaVSO    );
4721}
4722
4723Dist TComRdCost::xGetDistVSOMode1( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
4724{ 
4725 
4726  assert( m_uiVSOMode == 1 );     
4727  UInt uiShift = g_uiBitIncrement << 1; 
4728
4729  UInt uiPlane = 0; 
4730
4731  Int iRefWidth = m_pcVideoPicYuv->getWidth(); 
4732  Int iStrideOrgVid; 
4733  UInt uiErr = 0; 
4734
4735  if (uiPlane > 0)
4736  {
4737    iStartPosX = iStartPosX >> 1; 
4738    iStartPosY = iStartPosY >> 1; 
4739    iRefWidth  = iRefWidth  >> 1; 
4740    iStrideOrgVid = m_pcVideoPicYuv ->getCStride();
4741  }
4742  else 
4743  {
4744    iStrideOrgVid = m_pcVideoPicYuv ->getStride();
4745  }
4746 
4747  UInt uiReferenceNumber  = 0; 
4748  for (UInt uiReference = 0; uiReference < 3; uiReference+=2 )
4749  {
4750    if ( m_paaiShiftLUTs[uiReference] == 0 )
4751      continue; 
4752
4753    uiReferenceNumber++; 
4754   
4755    Pel* piOrgVid; 
4756
4757    if (uiPlane == 0)
4758    {     
4759      piOrgVid = m_pcVideoPicYuv ->getLumaAddr();     
4760    }
4761    else
4762    {
4763      if (uiPlane == 1)
4764      {       
4765        piOrgVid = m_pcVideoPicYuv ->getCbAddr();
4766      } 
4767      else
4768      {       
4769        piOrgVid = m_pcVideoPicYuv ->getCrAddr();
4770      }     
4771    }
4772   
4773    piOrgVid += iStartPosY * iStrideOrgVid;
4774
4775    for ( Int iY = 0; iY < uiBlkHeight; iY++ )
4776    {
4777      Int iPos = iStartPosX;
4778
4779      for  (Int iX = 0; iX < uiBlkWidth; iX++ ) 
4780      {
4781        Int iTargetPos;       
4782
4783        assert( RemoveBitIncrement(piCur[iX]) >= 0 && RemoveBitIncrement(piCur[iX]) <= 256);         
4784        assert( RemoveBitIncrement(piOrg[iX]) >= 0 && RemoveBitIncrement(piOrg[iX]) <= 256);         
4785
4786        iTargetPos = iPos - m_paaiShiftLUTs[uiReference][0][RemoveBitIncrement(piCur[iX])] + m_paaiShiftLUTs[uiReference][0][RemoveBitIncrement(piOrg[iX])];         
4787        iTargetPos = iTargetPos >  0         ? iTargetPos  : 0; 
4788        iTargetPos = iTargetPos <  iRefWidth ? iTargetPos  : iRefWidth-1; 
4789        Int iDiff = piOrgVid[iTargetPos] - piOrgVid[iPos]; 
4790
4791        if ( bSAD )
4792        {
4793          uiErr     += abs(iDiff);         
4794        }
4795        else
4796        {
4797          uiErr     += ((iDiff * iDiff) >> uiShift );         
4798        }
4799
4800        iPos++; 
4801      }
4802
4803      piOrgVid   += iStrideOrgVid;       
4804
4805      piCur      += iCurStride;                 
4806      piOrg      += iOrgStride; 
4807
4808    } 
4809    piCur        -= iCurStride * uiBlkHeight;                   
4810    piOrg        -= iOrgStride * uiBlkHeight; 
4811  }
4812
4813  if ( bSAD )
4814  {
4815    uiErr = uiErr >> g_uiBitIncrement; 
4816  }
4817
4818  return ( uiErr + ( uiReferenceNumber >> 1 )) / uiReferenceNumber; 
4819}
4820
4821Dist TComRdCost::xGetDistVSOMode2( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
4822{ 
4823  assert( m_uiVSOMode == 2 );     
4824  UInt uiShift = g_uiBitIncrement << 1; 
4825  UInt uiPlane = 0; 
4826
4827  Int iRefWidth = m_pcVideoPicYuv->getWidth(); 
4828  Int iStrideOrgVid; 
4829 
4830  UInt uiErr = 0; 
4831
4832  if (uiPlane > 0)
4833  {
4834    iStartPosX = iStartPosX >> 1; 
4835    iStartPosY = iStartPosY >> 1; 
4836    iRefWidth  = iRefWidth  >> 1; 
4837    iStrideOrgVid = m_pcVideoPicYuv ->getCStride();
4838  }
4839  else 
4840  {
4841    iStrideOrgVid = m_pcVideoPicYuv ->getStride();
4842  }
4843
4844  for (UInt uiRefPic = 0; uiRefPic < m_uiNumberRefPics; uiRefPic++ )
4845  {
4846    Pel* piRefVid; 
4847    Pel* piOrgVid; 
4848    Int  iStrideRefVid;         
4849
4850    if (uiPlane == 0)
4851    {
4852      piRefVid = m_apRefPics[uiRefPic]->getLumaAddr();
4853      piOrgVid = m_pcVideoPicYuv ->getLumaAddr();
4854      iStrideRefVid = m_apRefPics[uiRefPic]->getStride(); 
4855    }
4856    else
4857    {
4858      if (uiPlane == 1)
4859      {
4860        piRefVid = m_apRefPics[uiRefPic]->getCbAddr();
4861        piOrgVid = m_pcVideoPicYuv ->getCbAddr();
4862      } 
4863      else
4864      {
4865        piRefVid = m_apRefPics[uiRefPic]->getCrAddr();
4866        piOrgVid = m_pcVideoPicYuv ->getCrAddr();
4867      }
4868      iStrideRefVid = m_apRefPics[uiRefPic]->getCStride();     
4869    }
4870
4871    piRefVid += iStartPosY * iStrideRefVid;
4872    piOrgVid += iStartPosY * iStrideOrgVid;
4873
4874    for  (Int iY = 0; iY < uiBlkHeight; iY++ ) 
4875    {
4876      Int iPos = iStartPosX;
4877
4878      for  (Int iX = 0; iX < uiBlkWidth; iX++ ) 
4879      { 
4880        int iTargetPos; 
4881
4882        AOF( RemoveBitIncrement(piCur[iX]) >= 0 && RemoveBitIncrement(piCur[iX]) <= 255);         
4883        iTargetPos = iPos - m_paaiShiftLUTs[uiRefPic][0][RemoveBitIncrement(piCur[iX])]; 
4884        iTargetPos = iTargetPos >  0         ? iTargetPos  : 0; 
4885        iTargetPos = iTargetPos <  iRefWidth ? iTargetPos  : iRefWidth-1; 
4886
4887        Int iDiff = piRefVid[iTargetPos] - piOrgVid[iPos]; 
4888
4889        if ( bSAD )
4890        {
4891          uiErr     += abs(iDiff);         
4892        }
4893        else
4894        {
4895          uiErr     += ((iDiff * iDiff) >> uiShift );         
4896        }
4897
4898        iPos++; 
4899      }
4900
4901      piRefVid   += iStrideRefVid;
4902      piOrgVid   += iStrideOrgVid;       
4903    } 
4904    piCur        -= iCurStride * uiBlkHeight;                   
4905    piOrg        -= iOrgStride * uiBlkHeight; 
4906  }
4907
4908  if ( bSAD )
4909  {
4910    uiErr = uiErr >> g_uiBitIncrement; 
4911  }
4912
4913
4914  return ( uiErr + (m_uiNumberRefPics >> 1)) / m_uiNumberRefPics; 
4915}
4916
4917Dist TComRdCost::xGetDistVSOMode3( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
4918{
4919  assert( m_uiVSOMode == 3 );     
4920  UInt uiShift = g_uiBitIncrement << 1; 
4921
4922  UInt uiPlane = 0; 
4923
4924  Int iRefWidth = m_pcVideoPicYuv->getWidth(); 
4925  Int iStrideOrgVid; 
4926
4927  UInt uiErr = 0; 
4928
4929  if (uiPlane > 0)
4930  {
4931    iStartPosX = iStartPosX >> 1; 
4932    iStartPosY = iStartPosY >> 1;
4933    iRefWidth  = iRefWidth  >> 1;
4934    iStrideOrgVid = m_pcVideoPicYuv ->getCStride();
4935  }
4936  else 
4937  {
4938    iStrideOrgVid = m_pcVideoPicYuv ->getStride();
4939  }
4940
4941  for (UInt uiRefPicNum = 0; uiRefPicNum < m_uiNumberRefPics; uiRefPicNum++ )
4942  {
4943    Pel* piRefVid; 
4944    Pel* piOrgVid; 
4945    Int  iStrideRefVid;         
4946
4947    if (uiPlane == 0)
4948    {
4949      piRefVid = m_apRefPics[uiRefPicNum]->getLumaAddr();
4950      piOrgVid = m_pcVideoPicYuv ->getLumaAddr();
4951      iStrideRefVid = m_apRefPics[uiRefPicNum]->getStride(); 
4952    }
4953    else
4954    {
4955      if (uiPlane == 1)
4956      {
4957        piRefVid = m_apRefPics[uiRefPicNum]->getCbAddr();
4958        piOrgVid = m_pcVideoPicYuv ->getCbAddr();
4959      } 
4960      else
4961      {
4962        piRefVid = m_apRefPics[uiRefPicNum]->getCrAddr();
4963        piOrgVid = m_pcVideoPicYuv ->getCrAddr();
4964      }
4965      iStrideRefVid = m_apRefPics[uiRefPicNum]->getCStride();     
4966    }
4967
4968
4969    piRefVid += iStartPosY * iStrideRefVid;
4970    piOrgVid += iStartPosY * iStrideOrgVid;
4971
4972    for ( Int iY = 0; iY < uiBlkHeight; iY++ )
4973    {
4974      Int iPos = iStartPosX;
4975
4976      for  (Int iX = 0; iX < uiBlkWidth; iX++ ) 
4977      { 
4978        int iTargetPos; 
4979
4980
4981        assert( RemoveBitIncrement(piCur[iX]) >= 0 && RemoveBitIncrement(piCur[iX]) <= 256 );
4982        iTargetPos = iPos - m_paaiShiftLUTs[uiRefPicNum][0][RemoveBitIncrement(piCur[iX])]; 
4983        iTargetPos = iTargetPos >  0         ? iTargetPos : 0; 
4984        iTargetPos = iTargetPos <  iRefWidth ? iTargetPos : iRefWidth-1; 
4985
4986        int iSourcePos; 
4987
4988        assert( RemoveBitIncrement(piOrg[iX]) >= 0 && RemoveBitIncrement(piOrg[iX]) <= 256 );
4989        iSourcePos = iPos - m_paaiShiftLUTs[uiRefPicNum][0][RemoveBitIncrement(piOrg[iX])]; 
4990        iSourcePos = iSourcePos >  0         ? iSourcePos : 0; 
4991        iSourcePos = iSourcePos <  iRefWidth ? iSourcePos : iRefWidth-1; 
4992
4993        Int iDiff = piRefVid[iTargetPos] - piRefVid[iSourcePos]; 
4994
4995        if ( bSAD )
4996        {
4997            uiErr     += abs(iDiff);         
4998        }
4999        else
5000        {
5001          uiErr     += ((iDiff * iDiff)  >> uiShift) ;         
5002        }   
5003        iPos++; 
5004      }
5005
5006      piRefVid   += iStrideRefVid;
5007      piOrgVid   += iStrideOrgVid;       
5008
5009      piCur      += iCurStride;                 
5010      piOrg      += iOrgStride; 
5011    } 
5012    piCur        -= iCurStride * uiBlkHeight;                   
5013    piOrg        -= iOrgStride * uiBlkHeight; 
5014  }
5015
5016  if ( bSAD )
5017  {
5018    uiErr = uiErr >> g_uiBitIncrement; 
5019  }
5020  UInt uiNumRef = Max( 1, m_uiNumberRefPics );
5021  return ( uiErr + (uiNumRef >> 1) ) / uiNumRef; 
5022}
5023
5024
5025
5026
5027#if GERHARD_VQM_XCHECK
5028UInt TComRdCost::xGetDistXCheck(  Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
5029{
5030  UInt uiShift = g_uiBitIncrement << 1; 
5031
5032  UInt uiPlane = 0; 
5033  UInt uiErr = 0; 
5034  Int iStrideOrgVid = m_pcVideoPicYuv ->getStride();
5035
5036  Pel* piRefOrg = m_pcVideoPicYuv->getLumaAddr() + iStartPosX + iStrideOrgVid * iStartPosY;
5037
5038  for ( Int iY = 0; iY < uiBlkHeight; iY++ )
5039  {
5040    for  (Int iX = 0; iX < uiBlkWidth; iX++ ) 
5041    {   
5042      Int iDiff;
5043      if (uiPlane != 0)
5044      {     
5045       
5046        iDiff = piCur[iX] - piOrg[iX]; 
5047      }
5048      else
5049      {
5050 //     assert( piOrg[iX] == piRefOrg[iX] );
5051        iDiff = piCur[iX] - piRefOrg[iX]; 
5052      }
5053     
5054
5055      if ( bSAD )
5056      {
5057        uiErr     += abs(iDiff);         
5058      }
5059      else
5060      {
5061        uiErr     += ((iDiff * iDiff)  >> uiShift) ;         
5062      }               
5063    }
5064    piRefOrg   += iStrideOrgVid; 
5065    piCur      += iCurStride; 
5066    piOrg      += iOrgStride; 
5067  } 
5068
5069  if ( bSAD )     
5070  {
5071    uiErr >>= g_uiBitIncrement; 
5072  }
5073  return uiErr; 
5074}
5075 
5076
5077#endif
5078
5079Dist TComRdCost::xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD )
5080{ 
5081  AOT(bSAD); 
5082  RMDist iDist = m_pcRenModel->getDist( iStartPosX, iStartPosY, (Int) uiBlkWidth, (Int) uiBlkHeight, iCurStride, piCur ); 
5083
5084  RMDist iDistMin = (RMDist) RDO_DIST_MIN; 
5085#if RDO_DIST_INT
5086  iDistMin = m_bAllowNegDist ? RDO_DIST_MIN : 0; 
5087#endif
5088 
5089  iDist = Min( iDist, (RMDist) RDO_DIST_MAX);
5090  iDist = Max( iDist, iDistMin);
5091  return (Dist) iDist;
5092}
5093
5094
5095Dist TComRdCost::getDistVS( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD, UInt uiPlane )
5096{ 
5097  assert( m_bUseVSO ); 
5098  assert( this->m_fpDistortFuncVSO != 0 );
5099
5100  Int iPosX;
5101  Int iPosY; 
5102 
5103  pcCU->getPosInPic( uiAbsPartIndex, iPosX, iPosY ); 
5104  return (this->*m_fpDistortFuncVSO) ( iPosX, iPosY, piCur, iCurStride, piOrg, iOrgStride, uiBlkWidth, uiBlkHeight, bSAD ); 
5105}; 
5106
5107Void  TComRdCost::setRefDataFromMVDInfo( TComMVDRefData* pRefInfo )
5108{
5109  if ( m_apRefPics != NULL )
5110  {
5111    delete[] m_apRefPics;
5112    m_apRefPics = NULL;
5113  }; 
5114
5115  if ( m_paaiShiftLUTs != NULL )
5116  { // Delete only first dimension, other dimension are not create in this class
5117    delete[] m_paaiShiftLUTs; 
5118    m_paaiShiftLUTs = NULL;
5119  }; 
5120
5121
5122  m_uiNumberRefPics = ( m_uiVSOMode == 1 ) ? 3 : pRefInfo->getNumOfRefViews();
5123  m_apRefPics     = new TComPicYuv*[ m_uiNumberRefPics ];
5124  m_paaiShiftLUTs = new Int**[ m_uiNumberRefPics ];
5125
5126  if ( m_uiVSOMode == 1 )
5127  {
5128    pRefInfo->getRefPicYuvAndLUTMode1(m_apRefPics, m_paaiShiftLUTs); 
5129  }
5130  else
5131  {
5132    pRefInfo->getRefPicYuvAndLUT(m_apRefPics, m_paaiShiftLUTs); 
5133  }
5134 
5135
5136  m_pcVideoPicYuv = pRefInfo->getPicYuvVideo();
5137
5138#if GERHARD_VQM_XCHECK
5139  m_pcVideoPicYuv = pRefInfo->getPicYuvOrgDepth(CURRVIEW);
5140#endif
5141
5142}
5143
5144Void TComRdCost::setVSOMode( UInt uiIn )
5145{
5146  m_uiVSOMode = uiIn;
5147  switch (m_uiVSOMode )
5148  {
5149  case   1:
5150    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode1;
5151    break;
5152  case   2:
5153    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode2;
5154    break;
5155  case   3:
5156    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode3;
5157    break;
5158  case   4:
5159    m_fpDistortFuncVSO = &TComRdCost::xGetDistVSOMode4;
5160    break;
5161  default:
5162    assert(0); 
5163    break; 
5164  }
5165#if GERHARD_VQM_XCHECK
5166  m_fpDistortFuncVSO = &TComRdCost::xGetDistXCheck; 
5167#endif
5168}
5169
5170
5171Double TComRdCost::calcRdCostVSO( UInt uiBits, Dist uiDistortion, Bool bFlag, DFunc eDFunc )
5172{
5173  assert( m_bUseLambdaScaleVSO ); 
5174
5175  Double dRdCost = 0.0;
5176  Double dLambda = 0.0;
5177
5178  switch ( eDFunc )
5179  {
5180  case DF_SSE:
5181    assert(0);
5182    break;
5183  case DF_SAD:
5184    dLambda = (Double)m_uiLambdaMotionSADVSO;
5185    break;
5186  case DF_DEFAULT:
5187    dLambda =         m_dLambdaVSO;
5188    break;
5189  case DF_SSE_FRAME:
5190    dLambda =         m_dFrameLambdaVSO;
5191    break;
5192  default:
5193    assert (0);
5194    break;
5195  }
5196
5197  if (bFlag)
5198  {
5199    // Intra8x8, Intra4x4 Block only...
5200    dRdCost = (((Double)uiDistortion) + ((Double)uiBits * dLambda));
5201  }
5202  else
5203  {
5204    if (eDFunc == DF_SAD)
5205    {
5206      dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)>>16));
5207      dRdCost = (Double)(Dist)floor(dRdCost);
5208    }
5209    else
5210    {
5211      dRdCost = ((Double)uiDistortion + (Double)((Int)(uiBits * dLambda+.5)));
5212      dRdCost = (Double)(Dist)floor(dRdCost);
5213    }
5214  }
5215
5216  return dRdCost;
5217}
5218
5219Void TComRdCost::setRenModelData( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piData, Int iStride, Int iBlkWidth, Int iBlkHeight )
5220{
5221  UInt iBlkX = g_auiRasterToPelX[g_auiZscanToRaster[uiAbsPartIndex]];
5222  UInt iBlkY = g_auiRasterToPelY[g_auiZscanToRaster[uiAbsPartIndex]];
5223
5224  Int iStartPosX = iBlkX + pcCU->getCUPelX();
5225  Int iStartPosY = iBlkY + pcCU->getCUPelY();
5226
5227  m_pcRenModel->setData( iStartPosX, iStartPosY, iBlkWidth, iBlkHeight, iStride, piData );
5228}
5229
5230#if RDO_DIST_INT
5231Void TComRdCost::setAllowNegDist( Bool bAllowNegDist )
5232{
5233  m_bAllowNegDist = bAllowNegDist;
5234}
5235#endif
5236
5237//GT VSO end
Note: See TracBrowser for help on using the repository browser.