source: 3DVCSoftware/trunk/source/Lib/TLibCommon/TComRdCost.h @ 5

Last change on this file since 5 was 5, checked in by hhi, 12 years ago

Clean version with cfg-files

  • Property svn:eol-style set to native
File size: 15.7 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2011, 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 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.h
35    \brief    RD cost computation classes (header)
36*/
37
38#ifndef __TCOMRDCOST__
39#define __TCOMRDCOST__
40
41
42#include "CommonDef.h"
43#include "TComMVDRefData.h"
44#include "TComDataCU.h"
45#include "TComPattern.h"
46#include "TComMv.h"
47#ifdef WEIGHT_PRED
48  #include "TComSlice.h"
49  #include "TComRdCostWeightPrediction.h"
50#endif
51#include "TComYuv.h"
52#include "TComMVDRefData.h"
53#include "../TLibRenderer/TRenModel.h"
54
55class DistParam;
56class TComPattern;
57class TComRdCost;
58
59// ====================================================================================================================
60// Type definition
61// ====================================================================================================================
62
63// for function pointer
64typedef UInt (*FpDistFunc) (DistParam*);
65
66//GT VSO
67typedef Dist (TComRdCost::*FpDistFuncVSO) ( Int, Int, Pel*, Int, Pel*, Int, UInt, UInt, Bool );
68//GT VSO end
69
70#ifdef ROUNDING_CONTROL_BIPRED
71typedef UInt (*FpDistFuncRnd) (DistParam*, Pel*, Bool);
72#endif
73
74// ====================================================================================================================
75// Class definition
76// ====================================================================================================================
77
78/// distortion parameter class
79class DistParam
80{
81public:
82  Pel*  pOrg;
83  Pel*  pCur;
84  Int   iStrideOrg;
85  Int   iStrideCur;
86  Int   iRows;
87  Int   iCols;
88  Int   iStep;
89  FpDistFunc DistFunc;
90#ifdef ROUNDING_CONTROL_BIPRED
91  FpDistFuncRnd DistFuncRnd;
92#endif
93#if HHI_INTERVIEW_SKIP
94  Pel*  pUsed;
95  Int   iStrideUsed;
96#endif
97
98#ifdef WEIGHT_PRED
99  Bool            applyWeight;      // whether weithed prediction is used or not
100  wpScalingParam  *wpCur, *wpRef;   // weithed prediction scaling parameters for ref0 (or ref1) and ref1 (resp. ref0)
101  UInt            uiComp;           // uiComp = 0 (luma Y), 1 (chroma U), 2 (chroma V)
102#endif
103
104  // (vertical) subsampling shift (for reducing complexity)
105  // - 0 = no subsampling, 1 = even rows, 2 = every 4th, etc.
106  Int   iSubShift;
107
108  DistParam()
109  {
110    pOrg = NULL;
111    pCur = NULL;
112    iStrideOrg = 0;
113    iStrideCur = 0;
114    iRows = 0;
115    iCols = 0;
116    iStep = 1;
117    DistFunc = NULL;
118#ifdef ROUNDING_CONTROL_BIPRED
119    DistFuncRnd = NULL;
120#endif
121    iSubShift = 0;
122#if HHI_INTERVIEW_SKIP
123    pUsed       = 0;
124    iStrideUsed = 0;
125#endif
126  }
127};
128
129/// RD cost computation class
130class TComRdCost
131#ifdef WEIGHT_PRED
132  : public TComRdCostWeightPrediction
133#endif
134{
135private:
136  // for distortion
137  Int                     m_iBlkWidth;
138  Int                     m_iBlkHeight;
139
140  FpDistFunc              m_afpDistortFunc[33]; // [eDFunc]
141#ifdef ROUNDING_CONTROL_BIPRED
142  FpDistFuncRnd           m_afpDistortFuncRnd[33];
143#endif
144
145  Double                  m_dLambda;
146  Double                  m_sqrtLambda;
147  UInt                    m_uiLambdaMotionSAD;
148  UInt                    m_uiLambdaMotionSSE;
149  Double                  m_dFrameLambda;
150
151#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
152  Double                  m_dLambdaScale ;
153#endif
154  // for motion cost
155  UInt*                   m_puiComponentCostOriginP;
156  UInt*                   m_puiComponentCost;
157  UInt*                   m_puiVerCost;
158  UInt*                   m_puiHorCost;
159  UInt                    m_uiCost;
160  Int                     m_iCostScale;
161  Int                     m_iSearchLimit;
162
163  Bool                    m_bUseMultiviewReg;
164  UInt                    m_uiLambdaMVReg;
165  UInt                    m_uiLambdaMVRegSAD;
166  UInt                    m_uiLambdaMVRegSSE;
167  UInt*                   m_puiMultiviewRegCostHorOrgP;
168  UInt*                   m_puiMultiviewRegCostVerOrgP;
169  UInt*                   m_puiMultiviewRegCostHor;
170  UInt*                   m_puiMultiviewRegCostVer;
171  UInt*                   m_puiHorRegCost;
172  UInt*                   m_puiVerRegCost;
173  TComMv                  m_cMultiviewOrgMvPred;
174
175public:
176  TComRdCost();
177  virtual ~TComRdCost();
178
179  Double  calcRdCost  ( UInt   uiBits, Dist   uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
180  Double  calcRdCost64( UInt64 uiBits, UInt64 uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
181
182  Void    setLambda      ( Double dLambda );
183#if HHI_INTER_VIEW_MOTION_PRED
184  Void    setLambdaMVReg ( Double dLambda );
185#endif
186  Void    setFrameLambda ( Double dLambda ) { m_dFrameLambda = dLambda; }
187
188#if HHI_INTERVIEW_SKIP_LAMBDA_SCALE
189  Void   setLambdaScale  ( Double dLambdaScale) { m_dLambdaScale = dLambdaScale; }
190  Double   getLambdaScale  ( ) { return m_dLambdaScale ; }
191#endif
192  Double  getSqrtLambda ()   { return m_sqrtLambda; }
193
194  // Distortion Functions
195  Void    init();
196
197  Void    setDistParam( UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc, DistParam& rcDistParam );
198  Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride,            DistParam& rcDistParam );
199  Void    setDistParam( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME=false );
200  Void    setDistParam( DistParam& rcDP, Pel* p1, Int iStride1, Pel* p2, Int iStride2, Int iWidth, Int iHeight, Bool bHadamard = false );
201
202#ifdef ROUNDING_CONTROL_BIPRED
203  Void    setDistParam_Bi( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride,            DistParam& rcDistParam );
204  Void    setDistParam_Bi( TComPattern* pcPatternKey, Pel* piRefY, Int iRefStride, Int iStep, DistParam& rcDistParam, Bool bHADME=false );
205#endif
206
207  UInt    calcHAD         ( Pel* pi0, Int iStride0, Pel* pi1, Int iStride1, Int iWidth, Int iHeight );
208
209  // for motion cost
210  Void    initRateDistortionModel( Int iSubPelSearchLimit );
211  Void    xUninit();
212  UInt    xGetComponentBits( Int iVal );
213  Void    getMotionCost( Bool bSad, Int iAdd )
214  {
215    m_uiCost        = ( bSad ? m_uiLambdaMotionSAD + iAdd : m_uiLambdaMotionSSE + iAdd );
216    m_uiLambdaMVReg = ( bSad ? m_uiLambdaMVRegSAD         : m_uiLambdaMVRegSSE         );
217  }
218  Void    setPredictor( TComMv& rcMv )
219  {
220    m_puiHorCost = m_puiComponentCost - rcMv.getHor();
221    m_puiVerCost = m_puiComponentCost - rcMv.getVer();
222  }
223  Void    setCostScale( Int iCostScale )    { m_iCostScale = iCostScale; }
224  __inline UInt getCost( Int x, Int y )
225  {
226    return (( m_uiCost * (m_puiHorCost[ x * (1<<m_iCostScale) ] + m_puiVerCost[ y * (1<<m_iCostScale) ]) ) >> 16);
227  }
228  UInt    getCost( UInt b )                 { return ( m_uiCost * b ) >> 16; }
229  UInt    getBits( Int x, Int y )           { return m_puiHorCost[ x * (1<<m_iCostScale)] + m_puiVerCost[ y * (1<<m_iCostScale) ]; }
230
231  Void    setMultiviewReg( TComMv* pcMv )
232  {
233    if( pcMv )
234    {
235      m_bUseMultiviewReg    = true;
236      m_puiHorRegCost       = m_puiMultiviewRegCostHor - pcMv->getHor();
237      m_puiVerRegCost       = m_puiMultiviewRegCostVer - pcMv->getVer();
238      m_cMultiviewOrgMvPred = *pcMv;
239    }
240    else
241    {
242      m_bUseMultiviewReg    = false;
243      m_puiHorRegCost       = 0;
244      m_puiVerRegCost       = 0;
245      m_cMultiviewOrgMvPred.set( 0, 0 );
246    }
247  }
248  __inline Bool     useMultiviewReg      () { return m_bUseMultiviewReg; }
249  __inline TComMv&  getMultiviewOrgMvPred() { return m_cMultiviewOrgMvPred; }
250  __inline UInt     getMultiviewRegCost  ( Int x, Int y )
251  {
252    return ( ( m_uiLambdaMVReg * ( m_puiHorRegCost[ x * ( 1 << m_iCostScale ) ] + m_puiVerRegCost[ y * ( 1 << m_iCostScale ) ] ) ) >> 16 );
253  }
254
255private:
256
257  static UInt xGetSSE           ( DistParam* pcDtParam );
258  static UInt xGetSSE4          ( DistParam* pcDtParam );
259  static UInt xGetSSE8          ( DistParam* pcDtParam );
260  static UInt xGetSSE16         ( DistParam* pcDtParam );
261  static UInt xGetSSE32         ( DistParam* pcDtParam );
262  static UInt xGetSSE64         ( DistParam* pcDtParam );
263  static UInt xGetSSE16N        ( DistParam* pcDtParam );
264
265  static UInt xGetSAD           ( DistParam* pcDtParam );
266  static UInt xGetSAD4          ( DistParam* pcDtParam );
267  static UInt xGetSAD8          ( DistParam* pcDtParam );
268  static UInt xGetSAD16         ( DistParam* pcDtParam );
269  static UInt xGetSAD32         ( DistParam* pcDtParam );
270  static UInt xGetSAD64         ( DistParam* pcDtParam );
271  static UInt xGetSAD16N        ( DistParam* pcDtParam );
272
273  static UInt xGetSADs          ( DistParam* pcDtParam );
274  static UInt xGetSADs4         ( DistParam* pcDtParam );
275  static UInt xGetSADs8         ( DistParam* pcDtParam );
276  static UInt xGetSADs16        ( DistParam* pcDtParam );
277  static UInt xGetSADs32        ( DistParam* pcDtParam );
278  static UInt xGetSADs64        ( DistParam* pcDtParam );
279  static UInt xGetSADs16N       ( DistParam* pcDtParam );
280
281  static UInt xGetHADs4         ( DistParam* pcDtParam );
282  static UInt xGetHADs8         ( DistParam* pcDtParam );
283  static UInt xGetHADs          ( DistParam* pcDtParam );
284  static UInt xCalcHADs2x2      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
285  static UInt xCalcHADs4x4      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
286  static UInt xCalcHADs8x8      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep );
287
288#ifdef ROUNDING_CONTROL_BIPRED
289
290  static UInt xGetSSE           ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
291  static UInt xGetSSE4          ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
292  static UInt xGetSSE8          ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
293  static UInt xGetSSE16         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
294  static UInt xGetSSE32         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
295  static UInt xGetSSE64         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
296  static UInt xGetSSE16N        ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
297
298  static UInt xGetSAD           ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
299  static UInt xGetSAD4          ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
300  static UInt xGetSAD8          ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
301  static UInt xGetSAD16         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
302  static UInt xGetSAD32         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
303  static UInt xGetSAD64         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
304  static UInt xGetSAD16N        ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
305
306  static UInt xGetSADs          ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
307  static UInt xGetSADs4         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
308  static UInt xGetSADs8         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
309  static UInt xGetSADs16        ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
310  static UInt xGetSADs32        ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
311  static UInt xGetSADs64        ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
312  static UInt xGetSADs16N       ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
313
314  static UInt xGetHADs4         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
315  static UInt xGetHADs8         ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
316  static UInt xGetHADs          ( DistParam* pcDtParam, Pel* pRefY, Bool bRound );
317  static UInt xCalcHADs2x2      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep, Pel* pRefY, Int refYStride, Bool bRound );
318  static UInt xCalcHADs4x4      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep, Pel* pRefY, Int refYStride, Bool bRound );
319  static UInt xCalcHADs8x8      ( Pel *piOrg, Pel *piCurr, Int iStrideOrg, Int iStrideCur, Int iStep, Pel* pRefY, Int refYStride, Bool bRound );
320
321#endif
322
323public:
324#if HHI_INTERVIEW_SKIP
325  UInt   getDistPart( Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, Pel* piUsed, Int iUsedStride, UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc = DF_SSE );
326#endif
327  UInt   getDistPart( Pel* piCur, Int iCurStride,  Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, DFunc eDFunc = DF_SSE );
328
329#if HHI_VSO
330private:
331  Double                  m_dLambdaVSO;
332  Double                  m_dSqrtLambdaVSO;
333  UInt                    m_uiLambdaMotionSADVSO;
334  UInt                    m_uiLambdaMotionSSEVSO;
335  Double                  m_dFrameLambdaVSO;
336
337#if HHI_VSO_DIST_INT
338  Bool                    m_bAllowNegDist;
339#endif
340
341  TComPicYuv *            m_pcVideoPicYuv;
342  TComPicYuv**            m_apRefPics;
343  Int      ***            m_paaiShiftLUTs;
344  UInt                    m_uiNumberRefPics;
345  Bool                    m_bUseVSO;
346  Bool                    m_bUseLambdaScaleVSO;
347  UInt                    m_uiVSOMode;
348
349  FpDistFuncVSO m_fpDistortFuncVSO;
350  TRenModel*              m_pcRenModel;
351public:
352
353  Void    setRenModel       ( TRenModel* pcRenModel ) { m_pcRenModel = pcRenModel; }
354  Void    setRenModelData   ( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piData, Int iStride, Int iBlkWidth, Int iBlkHeight );
355  Void    setLambdaVSO      ( Double dLambda );
356  Void    setFrameLambdaVSO ( Double dLambda ) { m_dFrameLambdaVSO = dLambda; };
357
358  Void    setRefDataFromMVDInfo( TComMVDRefData* pRefInfo );
359
360  Void    setUseVSO ( Bool bIn )         { m_bUseVSO = bIn; };
361  Bool    getUseVSO ( )                  { return m_bUseVSO;};
362
363  Bool    getUseRenModel ( )             { return (m_bUseVSO && m_uiVSOMode == 4); };
364  Void    setUseLambdaScaleVSO(bool bIn) { m_bUseLambdaScaleVSO = bIn; };
365  Bool    getUseLambdaScaleVSO( )        { return m_bUseLambdaScaleVSO; };
366
367  Void    setVSOMode( UInt uiIn);
368  UInt    getVSOMode( )                  { return m_uiVSOMode; }
369
370#if HHI_VSO_DIST_INT
371  Void    setAllowNegDist ( Bool bAllowNegDist );
372#endif
373
374
375  Double  getSqrtLambdaVSO ()   { return m_dSqrtLambdaVSO; }
376  Double  getLambdaVSO ()       { return m_dLambdaVSO; }
377
378  Dist    getDistVS( TComDataCU* pcCU, UInt uiAbsPartIndex, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD, UInt uiPlane );
379  Double calcRdCostVSO( UInt   uiBits, Dist   uiDistortion, Bool bFlag = false, DFunc eDFunc = DF_DEFAULT );
380
381private:
382  Dist xGetDistVSOMode4( Int iStartPosX, Int iStartPosY, Pel* piCur, Int iCurStride, Pel* piOrg, Int iOrgStride, UInt uiBlkWidth, UInt uiBlkHeight, Bool bSAD );
383
384#endif // HHI_VSO
385
386};// END CLASS DEFINITION TComRdCost
387
388
389#endif // __TCOMRDCOST__
390
Note: See TracBrowser for help on using the repository browser.