source: 3DVCSoftware/branches/HTM-DEV-2.0-dev2-LG/source/Lib/TLibCommon/TComRdCost.cpp @ 591

Last change on this file since 591 was 591, checked in by lg, 12 years ago

Three bug fixed.

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