HLT/BASE/AliHLTDataDeflater.h

   1 //-*- Mode: C++ -*-
   2 // $Id$
   3 #ifndef ALIHLTDATADEFLATER_H
   4 #define ALIHLTDATADEFLATER_H
   5 //* This file is property of and copyright by the ALICE HLT Project        *
   6 //* ALICE Experiment at CERN, All rights reserved.                         *
   7 //* See cxx source for full Copyright notice                               *
   8
   9 /// @file   AliHLTDataDeflater.h
  10 /// @author Matthias Richter, Timm Steinbeck
  11 /// @date   2011-08-10
  12 /// @brief  Data deflater class storing only necessary bits
  13 /// @note   Code original from AliHLTTPCCompModelDeflater
  14
  15 #include "AliHLTLogging.h"
  16 #include "AliHLTDataTypes.h"
  17 #include "AliHLTStdIncludes.h"
  18 #include <bitset>
  19
  20 class TObjArray;
  21 class TH1;
  22 class TH2;
  23
  24 /**
  25  * @class AliHLTDataDeflater
  26  * Data deflater class to write a bitstream into a buffer. The necessary
  27  * number of bits for each value is written to a stream without gaps.
  28  * The buffer can be padded to fill full bytes and continue writing at the
  29  * next byte.
  30  *
  31  * @ingroup alihlt_base
  32  */
  33 class AliHLTDataDeflater : public AliHLTLogging
  34 {
  35 public:
  36   /// standard constructor
  37   AliHLTDataDeflater();
  38   /// destructor
  39   ~AliHLTDataDeflater();
  40
  41   /** function to initialise bit data output
  42    * @param output AliHLTUInt8_t* pointer to output data
  43    * @param outputSize UInt_t output size
  44    */
  45   int InitBitDataOutput( AliHLTUInt8_t* output, UInt_t outputSize );
  46
  47   /** function to close bit data output */
  48   void CloseBitDataOutput();
  49
  50   /** function to get current byte output position
  51    * @return unsigned long value for current byte output position
  52    */
  53   unsigned long GetCurrentByteOutputPosition() const
  54   {
  55     return (unsigned long)( fBitDataCurrentOutput - fBitDataCurrentOutputStart );
  56   }
  57
  58   /** function to get current bit output position
  59    * @return unsigned long value for current bit output position
  60    */
  61   unsigned GetCurrentBitOutputPosition() const
  62   {
  63     return fBitDataCurrentPosInWord;
  64   }
  65
  66   /** function to get current output byte
  67    * @param offset Int_t (set to zero if not specified explicitly)
  68    * @return AliHLTUInt8_t value for current output byte
  69    */
  70   AliHLTUInt8_t GetCurrentOutputByte( Int_t offset=0 ) const;
  71
  72   /** function to get bit data output size bytes
  73    * @return UInt_t value of bit data output size bytes
  74    */
  75   UInt_t GetBitDataOutputSizeBytes() const
  76   {
  77     return fBitDataCurrentOutput-fBitDataCurrentOutputStart;
  78   }
  79
  80   /** function for output bit
  81    * @param value  AliHLTUInt32_t const & input
  82    * @return boolean (output bit)
  83    */
  84   bool OutputBit( AliHLTUInt32_t const & value );
  85
  86   /** function to output bits
  87    * @param value     AliHLTUInt64_t const &
  88    * @param bitCount  UInt_t const &
  89    * @return zero upon success
  90    */
  91   bool OutputBits( AliHLTUInt64_t const & value, UInt_t const & bitCount );
  92
  93   /** function to output bits from a bitset
  94    * @param value     AliHLTUInt64_t const &
  95    * @param bitCount  UInt_t const &
  96    * @return zero upon success
  97    */
  98   bool OutputBits( std::bitset<64> const & value, UInt_t const & bitCount );
  99
 100   /* function pad 8 bits */
 101   void Pad8Bits();
 102
 103   /** function to output bytes
 104    * @param data  AliHLTUInt8_t const *
 105    * @param byteCount UInt_t const &
 106    * @return boolean (output bytes)
 107    */
 108   bool OutputBytes( AliHLTUInt8_t const * data, UInt_t const & byteCount );
 109
 110   /// add a histogram for deflater statistic of the corresponding parameter
 111   /// a histogram is created with default settings if h is not specified; if
 112   /// provided, the ownership goes over to the base class
 113   int AddHistogram(int id, const char* name, int bitWidth, TH1* h=NULL);
 114
 115   /// enable statistics accounting
 116   int EnableStatistics();
 117
 118   /// check if statistics writing is enabled
 119   bool DoStatistics() const {return fHistograms!=NULL;}
 120
 121   /// fill statistics for a parameter
 122   /// @param id           id of the parameter
 123   /// @param value        value
 124   /// @param length       bit length
 125   /// @param codingWeight fraction of bit lenght used for this value
 126   int FillStatistics(int id, AliHLTUInt64_t value, unsigned length, float codingWeight=0.0);
 127
 128   static float CalcEntropy(TH1* histo, const char* option="", int mode=0);
 129
 130   /// save data according to option
 131   virtual void SaveAs(const char *filename="",Option_t *option="") const;
 132
 133   /// clear the object and reset pointer references
 134   virtual void Clear(Option_t * /*option*/ ="");
 135
 136   /// print info
 137   virtual void Print(Option_t *option="") const;
 138
 139   /// print info
 140   virtual void Print(ostream& out, Option_t *option="") const;
 141
 142   /// find object
 143   virtual TObject *FindObject(const char */*name*/) const {return NULL;}
 144
 145   /// write bit pattern of a parameter to the current byte and position
 146   virtual bool OutputParameterBits( int parameterId, AliHLTUInt64_t const & value );
 147
 148   /// write bit pattern of a parameter to the current byte and position
 149   virtual bool OutputParameterBits( int parameterId, AliHLTUInt64_t const & value, int lengthOffset );
 150
 151   /// return unique version of the deflater, base class has version 0
 152   virtual int GetDeflaterVersion() const {return 0;}
 153
 154 protected:
 155
 156 private:
 157   /// copy constructor prohibited
 158   AliHLTDataDeflater(const AliHLTDataDeflater&);
 159   /// assignment operator prohibited
 160   AliHLTDataDeflater& operator=(const AliHLTDataDeflater&);
 161
 162   /// bit data current word
 163   AliHLTUInt8_t fBitDataCurrentWord; //! bit data current word
 164   /// bit data current position in word
 165   UInt_t fBitDataCurrentPosInWord; //! data current position in word
 166   /// bit data current output
 167   AliHLTUInt8_t *fBitDataCurrentOutput; //! bit data current output
 168   /// bit data current output start
 169   AliHLTUInt8_t *fBitDataCurrentOutputStart; //! bit data current output start
 170   /// bit data current output end
 171   AliHLTUInt8_t *fBitDataCurrentOutputEnd; //! bit data current output end
 172
 173   TObjArray* fHistograms; //! list of histograms for parameters
 174   TH2* fParameterCompression; //! compression for individual parameters
 175   TH2* fParameterSize; //! accumulated size for individual parameters
 176
 177   ClassDef(AliHLTDataDeflater, 0)
 178 };
 179
 180 ostream& operator<<(ostream &out, const AliHLTDataDeflater& me);
 181
 182 #endif