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

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

Merged HTM-DEV-0.3-dev1 Rev. 520.

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