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

Last change on this file since 622 was 622, checked in by tech, 11 years ago

Merged 8.0-dev0@621 (MV-HEVC 5 HLS).

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