source: 3DVCSoftware/branches/HTM-13.1-dev0/source/Lib/TLibCommon/TComRdCost.cpp @ 1177

Last change on this file since 1177 was 1175, checked in by tech, 10 years ago

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