source: 3DVCSoftware/branches/HTM-15.1-dev0/source/Lib/TLibCommon/TComCodingStatistics.h @ 1327

Last change on this file since 1327 was 1321, checked in by tech, 9 years ago

Merged 15.0-dev0@1320.
  • Property svn:eol-style set to native
File size: 18.0 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#ifndef __TCOMCODINGSTATISTICS__
35#define __TCOMCODINGSTATISTICS__
36
37#include "CommonDef.h"
38#include <stdio.h>
39#include <string>
40#include <map>
41#include <math.h>
42#include "TComChromaFormat.h"
43
44static const Int64 TCOMCODINGSTATISTICS_ENTROPYSCALE=32768;
45
46
47enum TComCodingStatisticsType
48{
49  STATS__NAL_UNIT_TOTAL_BODY,// This is a special case and is not included in the total sums.
50  STATS__NAL_UNIT_PACKING,
51  STATS__EMULATION_PREVENTION_3_BYTES,
52  STATS__NAL_UNIT_HEADER_BITS,
53  STATS__CABAC_INITIALISATION,
54  STATS__CABAC_BITS__TQ_BYPASS_FLAG,
55  STATS__CABAC_BITS__SKIP_FLAG,
56  STATS__CABAC_BITS__MERGE_FLAG,
57  STATS__CABAC_BITS__MERGE_INDEX,
58  STATS__CABAC_BITS__MVP_IDX,
59  STATS__CABAC_BITS__SPLIT_FLAG,
60  STATS__CABAC_BITS__PART_SIZE,
61  STATS__CABAC_BITS__PRED_MODE,
62  STATS__CABAC_BITS__INTRA_DIR_ANG,
63  STATS__CABAC_BITS__INTER_DIR,
64  STATS__CABAC_BITS__REF_FRM_IDX,
65  STATS__CABAC_BITS__MVD,
66  STATS__CABAC_BITS__MVD_EP,
67  STATS__CABAC_BITS__TRANSFORM_SUBDIV_FLAG,
68  STATS__CABAC_BITS__QT_ROOT_CBF,
69  STATS__CABAC_BITS__DELTA_QP_EP,
70  STATS__CABAC_BITS__CHROMA_QP_ADJUSTMENT,
71  STATS__CABAC_BITS__QT_CBF,
72  STATS__CABAC_BITS__CROSS_COMPONENT_PREDICTION,
73  STATS__CABAC_BITS__TRANSFORM_SKIP_FLAGS,
74
75  STATS__CABAC_BITS__LAST_SIG_X_Y,
76  STATS__CABAC_BITS__SIG_COEFF_GROUP_FLAG,
77  STATS__CABAC_BITS__SIG_COEFF_MAP_FLAG,
78  STATS__CABAC_BITS__GT1_FLAG,
79  STATS__CABAC_BITS__GT2_FLAG,
80  STATS__CABAC_BITS__SIGN_BIT,
81  STATS__CABAC_BITS__ESCAPE_BITS,
82
83#if NH_3D_DBBP
84  STATS__CABAC_BITS__DBBP_FLAG,
85#endif
86#if NH_3D_ARP
87  STATS__CABAC_BITS__ARP_FLAG,
88#endif
89  STATS__CABAC_BITS__SAO,
90  STATS__CABAC_TRM_BITS,
91  STATS__CABAC_FIXED_BITS,
92  STATS__CABAC_PCM_ALIGN_BITS,
93  STATS__CABAC_PCM_CODE_BITS,
94  STATS__BYTE_ALIGNMENT_BITS,
95  STATS__TRAILING_BITS,
96  STATS__EXPLICIT_RDPCM_BITS,
97  STATS__CABAC_EP_BIT_ALIGNMENT,
98  STATS__CABAC_BITS__ALIGNED_SIGN_BIT,
99  STATS__CABAC_BITS__ALIGNED_ESCAPE_BITS,
100
101#if NH_3D_IC
102  STATS__CABAC_BITS__3D_IC,
103#endif
104#if NH_3D_DMM || NH_3D_SDC_INTRA || NH_3D_SDC_INTER
105  STATS__CABAC_BITS__DELTADC_SIGN_EP,
106  STATS__CABAC_BITS__DELTADC_PREFIX,
107  STATS__CABAC_BITS__DELTADC_SUFFIX_EP,
108#endif
109#if NH_3D_DMM
110  STATS__CABAC_BITS__NOTDMM_FLAG,
111  STATS__CABAC_BITS__DMMMODE,
112  STATS__CABAC_BITS__DMM1_BITS_EP,
113#endif
114#if NH_3D_SDC_INTRA
115  STATS__CABAC_BITS__SDC_INTRA_FLAG,
116  STATS__CABAC_BITS__SDC_DELTADC_FLAG,
117#endif
118
119  STATS__NUM_STATS
120};
121
122static inline const Char* getName(TComCodingStatisticsType name)
123{
124  static const Char *statNames[]=
125  {
126    "NAL_UNIT_TOTAL_BODY", // This is a special case and is not included in the total sums.
127    "NAL_UNIT_PACKING",
128    "EMULATION_PREVENTION_3_BYTES",
129    "NAL_UNIT_HEADER_BITS",
130    "CABAC_INITIALISATION-and-rounding",
131    "CABAC_BITS__TQ_BYPASS_FLAG",
132    "CABAC_BITS__SKIP_FLAG",
133    "CABAC_BITS__MERGE_FLAG",
134    "CABAC_BITS__MERGE_INDEX",
135    "CABAC_BITS__MVP_IDX",
136    "CABAC_BITS__SPLIT_FLAG",
137    "CABAC_BITS__PART_SIZE",
138    "CABAC_BITS__PRED_MODE",
139    "CABAC_BITS__INTRA_DIR_ANG",
140    "CABAC_BITS__INTER_DIR",
141    "CABAC_BITS__REF_FRM_IDX",
142    "CABAC_BITS__MVD",
143    "CABAC_BITS__MVD_EP",
144    "CABAC_BITS__TRANSFORM_SUBDIV_FLAG",
145    "CABAC_BITS__QT_ROOT_CBF",
146    "CABAC_BITS__DELTA_QP_EP",
147    "CABAC_BITS__CHROMA_QP_ADJUSTMENT",
148    "CABAC_BITS__QT_CBF",
149    "CABAC_BITS__CROSS_COMPONENT_PREDICTION",
150    "CABAC_BITS__TRANSFORM_SKIP_FLAGS",
151    "CABAC_BITS__LAST_SIG_X_Y",
152    "CABAC_BITS__SIG_COEFF_GROUP_FLAG",
153    "CABAC_BITS__SIG_COEFF_MAP_FLAG",
154    "CABAC_BITS__GT1_FLAG",
155    "CABAC_BITS__GT2_FLAG",
156    "CABAC_BITS__SIGN_BIT",
157    "CABAC_BITS__ESCAPE_BITS",
158#if NH_3D_DBBP
159    "CABAC_BITS__DBBP_FLAG",
160#endif
161    "CABAC_BITS__SAO",
162    "CABAC_TRM_BITS",
163    "CABAC_FIXED_BITS",
164    "CABAC_PCM_ALIGN_BITS",
165    "CABAC_PCM_CODE_BITS",
166    "BYTE_ALIGNMENT_BITS",
167    "TRAILING_BITS",
168    "EXPLICIT_RDPCM_BITS",
169    "CABAC_EP_BIT_ALIGNMENT",
170    "CABAC_BITS__ALIGNED_SIGN_BIT",
171    "CABAC_BITS__ALIGNED_ESCAPE_BITS"
172
173#if NH_3D_IC
174    "CABAC_BITS__3D_IC"
175#endif
176#if NH_3D_DMM || NH_3D_SDC_INTRA || NH_3D_SDC_INTER
177   ,"STATS__CABAC_BITS__DELTADC_SIGN_EP"
178   ,"STATS__CABAC_BITS__DELTADC_PREFIX"
179   ,"STATS__CABAC_BITS__DELTADC_SUFFIX_EP"
180#endif
181#if NH_3D_DMM
182   ,"STATS__CABAC_BITS__NOTDMM_FLAG"
183   ,"STATS__CABAC_BITS__DMMMODE"
184   ,"STATS__CABAC_BITS__DMM1_BITS_EP"
185#endif
186#if NH_3D_SDC_INTRA
187    ,"STATS__CABAC_BITS__SDC_INTRA_FLAG"
188    ,"STATS__CABAC_BITS__SDC_DELTADC_FLAG"
189#endif
190  };
191  assert(STATS__NUM_STATS == sizeof(statNames)/sizeof(Char *) && name < STATS__NUM_STATS);
192  return statNames[name];
193}
194
195static inline Bool isAlignedBins(TComCodingStatisticsType statT) { return statT==STATS__CABAC_BITS__ALIGNED_SIGN_BIT || statT==STATS__CABAC_BITS__ALIGNED_ESCAPE_BITS; }
196
197static const UInt CODING_STATS_NUM_WIDTHS=7;
198static const UInt CODING_STATS_NUM_SUBCLASSES=CODING_STATS_NUM_WIDTHS*(1+MAX_NUM_COMPONENT+MAX_NUM_CHANNEL_TYPE);
199
200class TComCodingStatisticsClassType
201{
202public:
203
204  TComCodingStatisticsClassType(const TComCodingStatisticsType t)
205    : type(t), subClass(0)
206  { }
207  TComCodingStatisticsClassType(const TComCodingStatisticsType t, const UInt log2w )
208    : type(t), subClass(log2w)
209  { }
210  TComCodingStatisticsClassType(const TComCodingStatisticsType t, const Int log2w )
211    : type(t), subClass(log2w)
212  { }
213  TComCodingStatisticsClassType(const TComCodingStatisticsType t, const ComponentID cid )
214    : type(t), subClass((cid+1)*CODING_STATS_NUM_WIDTHS)
215  { }
216  TComCodingStatisticsClassType(const TComCodingStatisticsType t, const ChannelType chid )
217    : type(t), subClass((chid+MAX_NUM_COMPONENT+1)*CODING_STATS_NUM_WIDTHS)
218  { }
219  TComCodingStatisticsClassType(const TComCodingStatisticsType t, const UInt log2w, const ComponentID cid )
220    : type(t), subClass((cid+1)*CODING_STATS_NUM_WIDTHS + log2w)
221  { }
222  TComCodingStatisticsClassType(const TComCodingStatisticsType t, const UInt log2w, const ChannelType chid )
223    : type(t), subClass((chid+MAX_NUM_COMPONENT+1)*CODING_STATS_NUM_WIDTHS + log2w)
224  { }
225
226  static UInt GetSubClassWidth(const UInt subClass)
227  {
228    return subClass%CODING_STATS_NUM_WIDTHS;
229  }
230
231  static const Char *GetSubClassString(const UInt subClass)
232  {
233    assert (subClass<CODING_STATS_NUM_SUBCLASSES);
234    static const Char *strings[1+MAX_NUM_COMPONENT+MAX_NUM_CHANNEL_TYPE]={"-", "Y", "Cb", "Cr", "Luma", "Chroma"};
235    return strings[subClass/CODING_STATS_NUM_WIDTHS];
236  }
237
238  TComCodingStatisticsType type;
239  UInt subClass;
240};
241
242
243
244class TComCodingStatistics
245{
246  public:
247
248
249    struct StatLogValue
250    {
251      UInt values[512+1];
252      StatLogValue()
253      {
254        const Double es=Double(TCOMCODINGSTATISTICS_ENTROPYSCALE);
255        values[0]=0;
256        for(UInt i=1; i<sizeof(values)/sizeof(UInt); i++)
257        {
258          values[i]=UInt(    log(Double(i))*es/log(2.0)  );
259        }
260      }
261    };
262
263    struct SStat
264    {
265      SStat() : bits(0), count(0), sum(0) { }
266      Int64 bits;
267      Int64 count;
268      Int64 sum;
269      Void clear() { bits=0; count=0; sum=0; }
270
271      SStat &operator+=(const SStat &src)
272      { bits+=src.bits; count+=src.count; sum+=src.sum; return *this; }
273    };
274
275    class TComCodingStatisticsData
276    {
277      private:
278        SStat statistics[STATS__NUM_STATS+1][CODING_STATS_NUM_SUBCLASSES];
279        SStat statistics_ep[STATS__NUM_STATS+1][CODING_STATS_NUM_SUBCLASSES ];
280        std::map<std::string, SStat> mappings_ep;
281        friend class TComCodingStatistics;
282    };
283
284  private:
285
286    TComCodingStatisticsData data;
287
288    TComCodingStatistics() : data()
289    { }
290
291    static Void OutputLine(const Char *pName, const Char sep, UInt width, const Char *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
292    {
293      if (width==0)
294      {
295        OutputLine(pName, sep, "-", pSubClassStr, sCABAC, sEP);
296      }
297      else
298      {
299        printf("%c%-45s%c  %6d %6s %12lld %12lld %12lld %12lld %12lld %12lld %12lld (%12lld)%c\n",
300          sep=='~'?'[':' ', pName, sep, 1<<width, pSubClassStr,
301              sCABAC.count, sCABAC.sum, sCABAC.bits, sEP.count, sEP.sum, sEP.bits, sCABAC.bits+sEP.bits, (sCABAC.bits+sEP.bits)/8, sep=='~'?']':' ');
302      }
303    }
304    static Void OutputLine(const Char *pName, const Char sep, const Char *pWidthString, const Char *pSubClassStr, const SStat &sCABAC, const SStat &sEP)
305    {
306      printf("%c%-45s%c  %6s %6s %12lld %12lld %12lld %12lld %12lld %12lld %12lld (%12lld)%c\n",
307          sep=='~'?'[':' ', pName, sep, pWidthString, pSubClassStr,
308              sCABAC.count, sCABAC.sum, sCABAC.bits, sEP.count, sEP.sum, sEP.bits, sCABAC.bits+sEP.bits, (sCABAC.bits+sEP.bits)/8, sep=='~'?']':' ');
309    }
310    static Void OutputLine(const Char *pName, const Char sep, const Char *pWidthString, const Char *pSubClassStr,  const SStat &sEP)
311    {
312      printf("%c%-45s%c  %6s %6s %12s %12s %12s %12lld %12lld %12lld %12lld (%12lld)%c\n",
313          sep=='~'?'[':' ', pName, sep, pWidthString, pSubClassStr,
314              "", "", "", sEP.count, sEP.sum, sEP.bits, sEP.bits, (sEP.bits)/8, sep=='~'?']':' ');
315    }
316
317    static Void OutputDashedLine(const Char *pText)
318    {
319      printf("--%s",pText);
320      UInt tot=0;
321      for(;pText[tot]!=0; tot++);
322
323      tot+=2;
324      for (; tot<168; tot++)
325      {
326        printf("-");
327      }
328      printf("\n");
329    }
330
331    ~TComCodingStatistics()
332    {
333      const Int64 es=TCOMCODINGSTATISTICS_ENTROPYSCALE;
334
335      Int64 cr=0; // CABAC remainder, which is added to "STATS__CABAC_INITIALISATION"
336      {
337        Int64 totalCABACbits=0, roundedCABACbits=0;
338        for(Int i=STATS__NAL_UNIT_PACKING; i<STATS__NUM_STATS; i++)
339        {
340          for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c++)
341          {
342            totalCABACbits+=data.statistics[i][c].bits;
343            roundedCABACbits+=data.statistics[i][c].bits/es;
344          }
345        }
346        Int64 remainder=totalCABACbits - roundedCABACbits*es;
347        cr=(remainder+es/2)/es;
348      }
349
350      printf("Note %s will be excluded from the total as it should be the sum of all the other entries (except for %s)\n", getName(STATS__NAL_UNIT_TOTAL_BODY), getName(STATS__NAL_UNIT_PACKING));
351      printf(" %-45s-   Width   Type  CABAC Count    CABAC Sum   CABAC bits     EP Count       EP Sum      EP bits   Total bits ( Total bytes)\n", "Decoder statistics");
352
353      OutputDashedLine("");
354      SStat cabacTotalBits, epTotalBits;
355      SStat statTotals_cabac[CODING_STATS_NUM_SUBCLASSES];
356      SStat statTotals_ep[CODING_STATS_NUM_SUBCLASSES];
357
358      for(Int i=0; i<STATS__NUM_STATS; i++)
359      {
360        SStat cabacSubTotal, epSubTotal;
361        Bool bHadClassifiedEntry=false;
362        const Char *pName=getName(TComCodingStatisticsType(i));
363
364        for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c++)
365        {
366          SStat &sCABACorig=data.statistics[i][c];
367          SStat &sEP=data.statistics_ep[i][c];
368
369          if (sCABACorig.bits==0 && sEP.bits==0)
370          {
371            continue;
372          }
373
374          SStat sCABAC;
375          {
376            Int64 thisCABACbits=sCABACorig.bits/es;
377            if (i==STATS__CABAC_INITIALISATION && sCABACorig.bits!=0)
378            {
379              thisCABACbits+=cr;
380              cr=0;
381            }
382            sCABAC.bits=thisCABACbits;
383            sCABAC.count=sCABACorig.count;
384            sCABAC.sum=sCABACorig.sum;
385          }
386          UInt width=TComCodingStatisticsClassType::GetSubClassWidth(c);
387          OutputLine(pName, ':', width, TComCodingStatisticsClassType::GetSubClassString(c), sCABAC, sEP);
388          cabacSubTotal+=sCABAC;
389          epSubTotal+=sEP;
390          if (i!=STATS__NAL_UNIT_TOTAL_BODY)
391          {
392            cabacTotalBits+=sCABAC;
393            epTotalBits+=sEP;
394            statTotals_cabac[c]+=sCABAC;
395            statTotals_ep[c]+=sEP;
396          }
397          bHadClassifiedEntry=bHadClassifiedEntry||(c!=0);
398        }
399        if (bHadClassifiedEntry)
400        {
401          OutputLine(pName, '~', "~~ST~~", "~~ST~~", cabacSubTotal, epSubTotal);
402        }
403        if (i==STATS__NAL_UNIT_TOTAL_BODY)
404        {
405          OutputDashedLine("");
406        }
407      }
408      OutputDashedLine("");
409      OutputLine("CABAC Sub-total", '~', "~~ST~~", "~~ST~~", cabacTotalBits, epTotalBits);
410
411      OutputDashedLine("CAVLC HEADER BITS");
412      SStat cavlcTotalBits;
413      for(std::map<std::string, SStat>::iterator it=data.mappings_ep.begin(); it!=data.mappings_ep.end(); it++)
414      {
415        SStat s=it->second;
416        cavlcTotalBits+=s;
417        OutputLine(it->first.c_str(), ':', "-", "-", s);
418      }
419
420      OutputDashedLine("");
421      OutputLine("CAVLC Header Sub-total", '~', "~~ST~~", "~~ST~~", cavlcTotalBits);
422
423      // Now output the breakdowns
424      OutputDashedLine("CABAC Break down by size");
425      for(UInt s=0; s<CODING_STATS_NUM_WIDTHS; s++)
426      {
427        SStat subTotalCabac, subTotalEP;
428        for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c+=CODING_STATS_NUM_WIDTHS)
429        {
430          subTotalCabac+=statTotals_cabac[c+s];
431          subTotalEP+=statTotals_ep[c+s];
432        }
433        if (subTotalCabac.bits!=0 || subTotalEP.bits!=0)
434        {
435          OutputLine("CABAC by size Sub-total", '=', s, "All", subTotalCabac, subTotalEP);
436        }
437      }
438      OutputDashedLine("Break down by component/Channel type");
439      for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c+=CODING_STATS_NUM_WIDTHS)
440      {
441        SStat subTotalCabac, subTotalEP;
442        for(UInt s=0; s<CODING_STATS_NUM_WIDTHS; s++)
443        {
444          subTotalCabac+=statTotals_cabac[c+s];
445          subTotalEP+=statTotals_ep[c+s];
446        }
447        if (subTotalCabac.bits!=0 || subTotalEP.bits!=0)
448        {
449          OutputLine("CABAC by type Sub-total", '=', "-", TComCodingStatisticsClassType::GetSubClassString(c), subTotalCabac, subTotalEP);
450        }
451      }
452      OutputDashedLine("Break down by size and component/Channel type");
453      for(UInt c=0; c<CODING_STATS_NUM_SUBCLASSES; c+=CODING_STATS_NUM_WIDTHS)
454      {
455        for(UInt s=0; s<CODING_STATS_NUM_WIDTHS; s++)
456        {
457          SStat subTotalCabac, subTotalEP;
458          subTotalCabac+=statTotals_cabac[c+s];
459          subTotalEP+=statTotals_ep[c+s];
460          if (subTotalCabac.bits!=0 || subTotalEP.bits!=0)
461          {
462            OutputLine("CABAC by size and type Sub-total", '=', s, TComCodingStatisticsClassType::GetSubClassString(c), subTotalCabac, subTotalEP);
463          }
464        }
465      }
466
467      OutputDashedLine("");
468      OutputLine("CABAC Sub-total", '~', "~~ST~~", "~~ST~~", cabacTotalBits, epTotalBits);
469      OutputLine("CAVLC Header Sub-total", '~', "~~ST~~", "~~ST~~", cavlcTotalBits);
470      OutputDashedLine("GRAND TOTAL");
471      epTotalBits+=cavlcTotalBits;
472      OutputLine("TOTAL", '~', "~~GT~~", "~~GT~~", cabacTotalBits, epTotalBits);
473    }
474
475
476  public:
477    static TComCodingStatistics& GetSingletonInstance()
478    {
479      static TComCodingStatistics inst;
480      return inst;
481    }
482
483    static const TComCodingStatisticsData &GetStatistics()         { return GetSingletonInstance().data; }
484    static Void SetStatistics(const TComCodingStatisticsData &src) { GetSingletonInstance().data=src; }
485
486    static SStat &GetStatisticEP(const TComCodingStatisticsClassType &stat) { return GetSingletonInstance().data.statistics_ep[stat.type][stat.subClass]; }
487
488    static SStat &GetStatisticEP(const std::string &str) { return GetSingletonInstance().data.mappings_ep[str]; }
489
490    static SStat &GetStatisticEP(const Char *pKey) {return GetStatisticEP(std::string(pKey)); }
491
492    static Void IncrementStatisticEP(const TComCodingStatisticsClassType &stat, const Int numBits, const Int value)
493    {
494      SStat &s=GetStatisticEP(stat);
495      s.bits+=numBits;
496      s.count++;
497      s.sum+=value;
498    }
499
500    static Void IncrementStatisticEP(const std::string &str, const Int numBits, const Int value)
501    {
502      SStat &s=GetStatisticEP(str);
503      s.bits+=numBits;
504      s.count++;
505      s.sum+=value;
506    }
507
508    static Void IncrementStatisticEP(const Char *pKey, const Int numBits, const Int value)
509    {
510      SStat &s=GetStatisticEP(pKey);
511      s.bits+=numBits;
512      s.count++;
513      s.sum+=value;
514    }
515
516    StatLogValue values;
517
518    static Void UpdateCABACStat(const TComCodingStatisticsClassType &stat, UInt uiRangeBefore, UInt uiRangeAfter, Int val)
519    {
520      TComCodingStatistics &inst=GetSingletonInstance();
521      // doing rangeBefore*p(x)=rangeAfter
522      // p(x)=rangeAfter/rangeBefore
523      // entropy = -log2(p(x))=-log(p(x))/log(2) = -(log rangeAfter - log rangeBefore) / log(2) = (log rangeBefore / log 2 - log rangeAfter / log 2)
524      SStat &s=inst.data.statistics[stat.type][stat.subClass];
525      s.bits+=inst.values.values[uiRangeBefore]-inst.values.values[uiRangeAfter];
526      s.count++;
527      s.sum+=val;
528    }
529};
530
531#endif
Note: See TracBrowser for help on using the repository browser.