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

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

Clean version with cfg-files

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