added Huffman compression stuff for ALTRO data (Jenny)
[u/mrichter/AliRoot.git] / HLT / comp / AliHLTCOMPHuffmanAltro.h
1 // @(#) $Id$
2
3 #ifndef ALIHLTCOMPHUFFMANALTRO_H
4 #define ALIHLTCOMPHUFFMANALTRO_H
5
6 /**************************************************************************
7  * This file is property of and copyright by the ALICE HLT Project        * 
8  * All rights reserved.                                                   *
9  *                                                                        *
10  * Primary Author: Jenny Wagner  (jwagner@cern.ch)                        *
11  *                                                                        *
12  * Permission to use, copy, modify and distribute this software and its   *
13  * documentation strictly for non-commercial purposes is hereby granted   *
14  * without fee, provided that the above copyright notice appears in all   *
15  * copies and that both the copyright notice and this permission notice   *
16  * appear in the supporting documentation. The authors make no claims     *
17  * about the suitability of this software for any purpose. It is          * 
18  * provided "as is" without express or implied warranty.                  *
19  **************************************************************************/
20
21 /** @file   AliHLTCOMPHuffmanAltro.h
22     @author Jenny Wagner
23     @date   20-11-2007
24     @brief  The Huffman compressor
25 */
26
27 #include "AliHLTDataTypes.h"
28 #include "AliHLTLogging.h"
29 #include "AliHLTCOMPHuffmanData.h"
30
31 /** @class   AliHLTCOMPHuffmanAltro
32     @author Jenny Wagner
33     @date   20-11-2007
34     @brief  The Huffman Compressor with functions training (for Calibration), compress and decompress, calculate entropy  
35 */
36 class AliHLTCOMPHuffmanAltro : public AliHLTLogging
37 {
38  public:
39
40   /** constructor for test use only */
41   AliHLTCOMPHuffmanAltro();
42
43   /** standard constructor
44    *
45    * @param compressionswitch   decides whether to compress or decompress (TRUE for calibration/training)
46    * @param trainingmode        decides whether to create a new Huffman table 
47    * @param translationtable    pointer to lookup Huffman table for compression and decompression
48    * @param nrcutrailerwords    number of NRCU trailer words (ranging from 1 to 3)
49    */
50   AliHLTCOMPHuffmanAltro(Bool_t compressionswitch, Bool_t trainingmode, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* translationtable, Int_t nrcutrailerwords);
51   /** destructor */
52   virtual ~AliHLTCOMPHuffmanAltro();
53
54   /** SetInputData 
55    *  @param inputdata  pointer to input data
56    *  @param datasize   size of input data
57    */
58   void SetInputData(void* inputdata, unsigned long datasize);
59   
60   /** SetOutputData
61    *  @param outputdata  pointer to output data
62    *  @param outputsize  size of output data
63    */
64   void SetOutputData(AliHLTUInt8_t* outputdata, unsigned long outputsize);
65
66   /** get patch from component and set it as currently processed patch of this class  (only needed for binary output)*/
67   //void SetPatch(Int_t patch) {fPatch = patch;};
68
69  /** get slice from component and set it as currently processed slice of this class (only needed for binary output) */
70   // void SetSlice(Int_t slice) {fSlice = slice;};
71   
72   /** GetOutputDataSize (which is unknown at first and has to be calculated
73    * @return output data size
74   */
75   unsigned long GetOutputDataSize();
76
77   /** initialise training table */
78   void InitNewTrainingTable();
79
80   /** write out new HuffmanData
81    * @param huffmandata   pointer to Huffman data 
82   */
83   void SetHuffmanData(AliHLTCOMPHuffmanData* huffmandata);
84
85   /** get training table from HuffmanData instance
86    * @param huffmandata  pointer to Huffman data
87   */
88   void GetTrainingTable(AliHLTCOMPHuffmanData* huffmandata);
89
90   /** initialise the translation table
91    * @param huffmandata  pointer to Huffman data
92   */
93   void GetTranslationTable(AliHLTCOMPHuffmanData* huffmandata);
94
95   /** function to compress or decompress data */
96   void ProcessData();
97
98  /** function to create Huffman code table by means of private functions
99   * @return zero upon success
100  */
101   Int_t CreateCodeTable();
102
103   /** calculate the entropy of the input data
104    * @return calculated entropy (in double precision)
105   */
106   Double_t GetEntropy();
107
108   /** function to read 10 bit data in and write same 10 bit data out (performance test) */
109   Int_t CopyData();
110
111  private:
112
113   /** copy constructor prohibited */
114   AliHLTCOMPHuffmanAltro(const AliHLTCOMPHuffmanAltro&);
115   /** assignment operator prohibited */
116   AliHLTCOMPHuffmanAltro& operator=(const AliHLTCOMPHuffmanAltro&);
117
118   /** function to calculate the entropy of the incoming data */
119   Int_t CalcEntropy();
120
121   /** function for merge sorting the array data 
122    * @param unsorted array  unsorted array of data from occurrence table
123    * @param n               number of entries in the unsorted array
124    * @return pointer to first element of sorted list
125    */
126   AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* Mergesort(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* unsortedarray, Int_t n);
127
128   /** function to create the HuffmanCode and write it in a sorted array 
129    * @param treeroot           pointer to root of Huffman tree
130    * @param HuffmanCodearray   pointer to final Huffman code table (array)
131    * @return zero upon success
132    */ 
133  Int_t HuffmanCode(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* treeroot, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* HuffmanCodearray);
134   
135   /** function to create the Huffmantree
136    * @param listroot   pointer to first element of sorted list to build Huffman tree from
137    * @param listend    pointer to last element of sorted list to build Huffman tree from
138    * @param n          number of entries in the list
139    * @return pointer to root of Huffman tree
140    */
141  AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* CreateHuffmanTree(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* listroot,  AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* listend, Int_t n);
142   
143   /** entropy encoding function: read in data, table lookup to encode, write encoded data to output array and set fOutputDataSize
144    * @return zero upon success
145    */
146  Int_t EntropyCompression();
147
148   /** merge sorting function for translation table
149    * @param unsorted array  Huffman code table which is not sorted for decompression yet
150    * @param n               number of entries in the unsorted array
151    * @return pointer to first element of sorted list
152    */
153  AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* TTMergesort(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* unsortedarray, Int_t n);
154     
155   /** entropy decoding function
156    * @return zero upon success
157    */
158   Int_t EntropyDecompression();
159   
160   /** training function for the translation table
161    * @return zero upon success
162    */
163   Int_t TrainingData(); 
164
165   /** boolean to decide whether to process data (FALSE) or create a new code table (TRUE) */
166   Bool_t fTrainingMode;                         // choice if new codetable is created or not
167   /** boolean to decide whether to compress (TRUE) or decompress (FALSE) incoming data (automatically TRUE for code creation) */
168   Bool_t fCompressionSwitch;                    // mode choice (training, compress, decompress)
169   /** pointer to input data */
170   AliHLTUInt8_t* fPointer2InData;               // pointer to input data (uncompressed raw data)
171   /** pointer to output data */
172   AliHLTUInt64_t* fPointer2OutData;             // pointer to output data (compressed data)
173   /** input data size */
174   unsigned long fInputDataSize;                 // input data size
175   /** output data size */
176   Int_t fOutputDataSize;                        // output data size
177   /** number of NRCU trailer words */
178   Int_t fNrcuTrailerwords;                      // number of RCU trailerwords
179   /** calculated entropy of input data */
180   Double_t fEntropy;                            // entropy of the file
181
182   //AliHLTUInt8_t fSlice;                         // transient variables to specify
183   //AliHLTUInt8_t fPatch;                         // where output root file comes from
184  
185   /** pointer to occurrence table */
186   AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* fTrainingTable;       // training table with amplitudes and resp. abundances
187   /** pointer to Huffman code table */
188   AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* fTranslationTable;    // Huffman Entropy Code Table
189
190
191   ClassDef(AliHLTCOMPHuffmanAltro, 0)
192         };
193 #endif