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

Last change on this file since 1405 was 1405, checked in by tech, 8 years ago

Merged HTM-16.1-dev@1404.

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