source: 3DVCSoftware/branches/HTM-DEV-2.0-dev3-SCU-Hisilicon/source/Lib/TLibCommon/TComRdCost.cpp @ 573

Last change on this file since 573 was 573, checked in by hisilicon-htm, 11 years ago

JCT3V-E0238: Fast Intra Prediction Mode Selection for Intra Depth Map Coding

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