[u/mrichter/AliRoot.git] / HLT / comp / AliHLTCOMPHuffmanAltro.h

// @(#) $Id$

#ifndef ALIHLTCOMPHUFFMANALTRO_H
#define ALIHLTCOMPHUFFMANALTRO_H

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Author: Jenny Wagner  (jwagner@cern.ch)                        *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          * 
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTCOMPHuffmanAltro.h
    @author Jenny Wagner
    @date   20-11-2007
    @brief  The Huffman compressor
*/

#include "AliHLTLogging.h"
#include "AliHLTCOMPHuffmanData.h"

/** @class   AliHLTCOMPHuffmanAltro
    @author Jenny Wagner
    @date   20-11-2007
    @brief  The Huffman Compressor with functions training (for Calibration), compress and decompress, calculate entropy  
*/
class AliHLTCOMPHuffmanAltro : public AliHLTLogging
{
 public:

  /** constructor for test use only */
  AliHLTCOMPHuffmanAltro();

  /** standard constructor
   *
   * @param compressionswitch   decides whether to compress or decompress (TRUE for calibration/training)
   * @param trainingmode        decides whether to create a new Huffman table 
   * @param translationtable    pointer to lookup Huffman table for compression and decompression
   * @param nrcutrailerwords    number of NRCU trailer words (ranging from 1 to 3)
   */
  AliHLTCOMPHuffmanAltro(Bool_t compressionswitch, Bool_t trainingmode, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* translationtable, Int_t nrcutrailerwords);
  /** destructor */
  virtual ~AliHLTCOMPHuffmanAltro();

  /** SetInputData 
   *  @param inputdata  pointer to input data
   *  @param datasize   size of input data
   */
  void SetInputData(void* inputdata, unsigned long datasize);
  
  /** SetOutputData
   *  @param outputdata  pointer to output data
   *  @param outputsize  size of output data
   */
  void SetOutputData(AliHLTUInt8_t* outputdata, unsigned long outputsize);

  /** get patch from component and set it as currently processed patch of this class  (only needed for binary output)*/
  //void SetPatch(Int_t patch) {fPatch = patch;};

 /** get slice from component and set it as currently processed slice of this class (only needed for binary output) */
  // void SetSlice(Int_t slice) {fSlice = slice;};
  
  /** GetOutputDataSize (which is unknown at first and has to be calculated
   * @return output data size
  */
  unsigned long GetOutputDataSize();

  /** initialise training table */
  void InitNewTrainingTable();

  /** write out new HuffmanData
   * @param huffmandata   pointer to Huffman data 
  */
  void SetHuffmanData(AliHLTCOMPHuffmanData* huffmandata);

  /** get training table from HuffmanData instance
   * @param huffmandata  pointer to Huffman data
  */
  void GetTrainingTable(AliHLTCOMPHuffmanData* huffmandata);

  /** initialise the translation table
   * @param huffmandata  pointer to Huffman data
  */
  void GetTranslationTable(AliHLTCOMPHuffmanData* huffmandata);

  /** function to compress or decompress data */
  void ProcessData();

 /** function to create Huffman code table by means of private functions
  * @return zero upon success
 */
  Int_t CreateCodeTable();

  /** calculate the entropy of the input data
   * @return calculated entropy (in double precision)
  */
  Double_t GetEntropy();

  /** function to read 10 bit data in and write same 10 bit data out (performance test) */
  Int_t CopyData();

 private:

  /** copy constructor prohibited */
  AliHLTCOMPHuffmanAltro(const AliHLTCOMPHuffmanAltro&);
  /** assignment operator prohibited */
  AliHLTCOMPHuffmanAltro& operator=(const AliHLTCOMPHuffmanAltro&);

  /** function to calculate the entropy of the incoming data */
  Int_t CalcEntropy();

  /** function for merge sorting the array data 
   * @param unsortedarray   unsorted array of data from occurrence table
   * @param n               number of entries in the unsorted array
   * @return pointer to first element of sorted list
   */
  AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanDataStruct* Mergesort(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanDataStruct* unsortedarray, Int_t n);

  /** function to create the HuffmanCode and write it in a sorted array 
   * @param treeroot           pointer to root of Huffman tree
   * @param HuffmanCodearray   pointer to final Huffman code table (array)
   * @return zero upon success
   */ 
 Int_t HuffmanCode(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* treeroot, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* HuffmanCodearray);
  
  /** function to create the Huffmantree
   * @param listroot   pointer to first element of sorted list to build Huffman tree from
   * @param listend    pointer to last element of sorted list to build Huffman tree from
   * @param n          number of entries in the list
   * @return pointer to root of Huffman tree
   */
 AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* CreateHuffmanTree(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* listroot,  AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* listend, Int_t n);
  
  /** entropy encoding function: read in data, table lookup to encode, write encoded data to output array and set fOutputDataSize
   * @return zero upon success
   */
 Int_t EntropyCompression();

  /** merge sorting function for translation table
   * @param unsortedarray   Huffman code table which is not sorted for decompression yet
   * @param n               number of entries in the unsorted array
   * @return pointer to first element of sorted list
   */
 AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* TTMergesort(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* unsortedarray, Int_t n);
    
  /** entropy decoding function
   * @return zero upon success
   */
  Int_t EntropyDecompression();
  
  /** training function for the translation table
   * @return zero upon success
   */
  Int_t TrainingData(); 

  /** boolean to decide whether to process data (FALSE) or create a new code table (TRUE) */
  Bool_t fTrainingMode;                         // choice if new codetable is created or not
  /** boolean to decide whether to compress (TRUE) or decompress (FALSE) incoming data (automatically TRUE for code creation) */
  Bool_t fCompressionSwitch;                    // mode choice (training, compress, decompress)
  /** pointer to input data */
  AliHLTUInt8_t* fPointer2InData;               // pointer to input data (uncompressed raw data)
  /** pointer to output data */
  AliHLTUInt64_t* fPointer2OutData;             // pointer to output data (compressed data)
  /** input data size */
  unsigned long fInputDataSize;                 // input data size
  /** output data size */
  UInt_t fOutputDataSize;                        // output data size
  /** number of NRCU trailer words */
  UInt_t fNrcuTrailerwords;                      // number of RCU trailerwords
  /** calculated entropy of input data */
  Double_t fEntropy;                            // entropy of the file

  //AliHLTUInt8_t fSlice;                         // transient variables to specify
  //AliHLTUInt8_t fPatch;                         // where output root file comes from
 
  /** pointer to occurrence table */
  AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanDataStruct* fTrainingTable;       // training table with amplitudes and resp. abundances
  /** pointer to Huffman code table */
  AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* fTranslationTable;    // Huffman Entropy Code Table


  ClassDef(AliHLTCOMPHuffmanAltro, 0)
	};
#endif
Commit	Line	Data
c2440081	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
c2440081	27	#include "AliHLTLogging.h"
	28	#include "AliHLTCOMPHuffmanData.h"
	29
	30	/** @class AliHLTCOMPHuffmanAltro
	31	@author Jenny Wagner
	32	@date 20-11-2007
	33	@brief The Huffman Compressor with functions training (for Calibration), compress and decompress, calculate entropy
	34	*/
	35	class AliHLTCOMPHuffmanAltro : public AliHLTLogging
	36	{
	37	public:
	38
	39	/** constructor for test use only */
	40	AliHLTCOMPHuffmanAltro();
	41
	42	/** standard constructor
	43	*
	44	* @param compressionswitch decides whether to compress or decompress (TRUE for calibration/training)
	45	* @param trainingmode decides whether to create a new Huffman table
	46	* @param translationtable pointer to lookup Huffman table for compression and decompression
	47	* @param nrcutrailerwords number of NRCU trailer words (ranging from 1 to 3)
	48	*/
bf7a3243	49	AliHLTCOMPHuffmanAltro(Bool_t compressionswitch, Bool_t trainingmode, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* translationtable, Int_t nrcutrailerwords);
c2440081	50	/** destructor */
	51	virtual ~AliHLTCOMPHuffmanAltro();
	52
	53	/** SetInputData
	54	* @param inputdata pointer to input data
	55	* @param datasize size of input data
	56	*/
	57	void SetInputData(void* inputdata, unsigned long datasize);
	58
	59	/** SetOutputData
	60	* @param outputdata pointer to output data
	61	* @param outputsize size of output data
	62	*/
	63	void SetOutputData(AliHLTUInt8_t* outputdata, unsigned long outputsize);
	64
	65	/** get patch from component and set it as currently processed patch of this class (only needed for binary output)*/
	66	//void SetPatch(Int_t patch) {fPatch = patch;};
	67
	68	/** get slice from component and set it as currently processed slice of this class (only needed for binary output) */
	69	// void SetSlice(Int_t slice) {fSlice = slice;};
	70
	71	/** GetOutputDataSize (which is unknown at first and has to be calculated
	72	* @return output data size
	73	*/
	74	unsigned long GetOutputDataSize();
	75
	76	/** initialise training table */
	77	void InitNewTrainingTable();
	78
	79	/** write out new HuffmanData
	80	* @param huffmandata pointer to Huffman data
	81	*/
	82	void SetHuffmanData(AliHLTCOMPHuffmanData* huffmandata);
	83
	84	/** get training table from HuffmanData instance
	85	* @param huffmandata pointer to Huffman data
	86	*/
	87	void GetTrainingTable(AliHLTCOMPHuffmanData* huffmandata);
	88
	89	/** initialise the translation table
	90	* @param huffmandata pointer to Huffman data
	91	*/
	92	void GetTranslationTable(AliHLTCOMPHuffmanData* huffmandata);
	93
	94	/** function to compress or decompress data */
	95	void ProcessData();
	96
	97	/** function to create Huffman code table by means of private functions
	98	* @return zero upon success
	99	*/
	100	Int_t CreateCodeTable();
	101
	102	/** calculate the entropy of the input data
	103	* @return calculated entropy (in double precision)
	104	*/
	105	Double_t GetEntropy();
	106
	107	/** function to read 10 bit data in and write same 10 bit data out (performance test) */
	108	Int_t CopyData();
	109
	110	private:
	111
	112	/** copy constructor prohibited */
	113	AliHLTCOMPHuffmanAltro(const AliHLTCOMPHuffmanAltro&);
114	/** assignment operator prohibited */
115	AliHLTCOMPHuffmanAltro& operator=(const AliHLTCOMPHuffmanAltro&);
116
117	/** function to calculate the entropy of the incoming data */
118	Int_t CalcEntropy();
119
120	/** function for merge sorting the array data
a7ad9794	121	* @param unsortedarray unsorted array of data from occurrence table
c2440081	122	* @param n number of entries in the unsorted array
	123	* @return pointer to first element of sorted list
	124	*/
bf7a3243	125	AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanDataStruct* Mergesort(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanDataStruct* unsortedarray, Int_t n);
c2440081	126
	127	/** function to create the HuffmanCode and write it in a sorted array
	128	* @param treeroot pointer to root of Huffman tree
	129	* @param HuffmanCodearray pointer to final Huffman code table (array)
	130	* @return zero upon success
	131	*/
bf7a3243	132	Int_t HuffmanCode(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* treeroot, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* HuffmanCodearray);
c2440081	133
	134	/** function to create the Huffmantree
	135	* @param listroot pointer to first element of sorted list to build Huffman tree from
	136	* @param listend pointer to last element of sorted list to build Huffman tree from
	137	* @param n number of entries in the list
	138	* @return pointer to root of Huffman tree
	139	*/
bf7a3243	140	AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* CreateHuffmanTree(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* listroot, AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeDataStruct* listend, Int_t n);
c2440081	141
	142	/** entropy encoding function: read in data, table lookup to encode, write encoded data to output array and set fOutputDataSize
	143	* @return zero upon success
	144	*/
	145	Int_t EntropyCompression();
	146
	147	/** merge sorting function for translation table
a7ad9794	148	* @param unsortedarray Huffman code table which is not sorted for decompression yet
c2440081	149	* @param n number of entries in the unsorted array
	150	* @return pointer to first element of sorted list
	151	*/
bf7a3243	152	AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* TTMergesort(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* unsortedarray, Int_t n);
c2440081	153
	154	/** entropy decoding function
	155	* @return zero upon success
	156	*/
	157	Int_t EntropyDecompression();
	158
	159	/** training function for the translation table
	160	* @return zero upon success
	161	*/
	162	Int_t TrainingData();
	163
	164	/** boolean to decide whether to process data (FALSE) or create a new code table (TRUE) */
	165	Bool_t fTrainingMode; // choice if new codetable is created or not
	166	/** boolean to decide whether to compress (TRUE) or decompress (FALSE) incoming data (automatically TRUE for code creation) */
	167	Bool_t fCompressionSwitch; // mode choice (training, compress, decompress)
	168	/** pointer to input data */
	169	AliHLTUInt8_t* fPointer2InData; // pointer to input data (uncompressed raw data)
	170	/** pointer to output data */
	171	AliHLTUInt64_t* fPointer2OutData; // pointer to output data (compressed data)
	172	/** input data size */
	173	unsigned long fInputDataSize; // input data size
	174	/** output data size */
bf7a3243	175	UInt_t fOutputDataSize; // output data size
c2440081	176	/** number of NRCU trailer words */
bf7a3243	177	UInt_t fNrcuTrailerwords; // number of RCU trailerwords
c2440081	178	/** calculated entropy of input data */
	179	Double_t fEntropy; // entropy of the file
	180
	181	//AliHLTUInt8_t fSlice; // transient variables to specify
	182	//AliHLTUInt8_t fPatch; // where output root file comes from
	183
	184	/** pointer to occurrence table */
bf7a3243	185	AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanDataStruct* fTrainingTable; // training table with amplitudes and resp. abundances
c2440081	186	/** pointer to Huffman code table */
bf7a3243	187	AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeStruct* fTranslationTable; // Huffman Entropy Code Table
c2440081	188
	189
	190	ClassDef(AliHLTCOMPHuffmanAltro, 0)
	191	};
	192	#endif