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

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

Merged 8.1-Cleanup@654

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