source: 3DVCSoftware/branches/HTM-9.3-dev1-RWTH/source/Lib/TLibCommon/TComRdCost.cpp @ 816

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