source: 3DVCSoftware/branches/HTM-DEV-0.3-dev2/source/Lib/TLibCommon/TComRdCost.cpp @ 504

Last change on this file since 504 was 504, checked in by zhang, 11 years ago

Merge Dev2.a to Dev2 and simulation results updated

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