added Huffman compression stuff for ALTRO data (Jenny)
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Nov 2007 13:46:20 +0000 (13:46 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Nov 2007 13:46:20 +0000 (13:46 +0000)
16 files changed:
HLT/comp/AliHLTCOMPHuffmanAltro.cxx [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanAltro.h [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.cxx [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.h [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanAltroComponent.cxx [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanAltroComponent.h [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanCodeData.cxx [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanCodeData.h [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanData.cxx [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanData.h [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanOccurrenceData.cxx [new file with mode: 0644]
HLT/comp/AliHLTCOMPHuffmanOccurrenceData.h [new file with mode: 0644]
HLT/comp/AliHLTCompAgent.cxx
HLT/comp/AliHLTCompDefinitions.cxx [new file with mode: 0644]
HLT/comp/AliHLTCompDefinitions.h [new file with mode: 0644]
HLT/libAliHLTComp.pkg

diff --git a/HLT/comp/AliHLTCOMPHuffmanAltro.cxx b/HLT/comp/AliHLTCOMPHuffmanAltro.cxx
new file mode 100644 (file)
index 0000000..da90b2a
--- /dev/null
@@ -0,0 +1,1965 @@
+// @(#) $Id$
+
+/**************************************************************************
+ * 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.cxx
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  The Huffman compressor
+*/
+
+#include "AliHLTCOMPHuffmanAltro.h"
+#include "AliHLTDataTypes.h"
+#include "AliHLTStdIncludes.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
+
+ClassImp(AliHLTCOMPHuffmanAltro)
+
+/** construction without any arguments (used for isolated tests) */
+AliHLTCOMPHuffmanAltro::AliHLTCOMPHuffmanAltro()
+  :
+  fTrainingMode(0),
+  fCompressionSwitch(0),
+  fPointer2InData(NULL),
+  fPointer2OutData(NULL),
+  fInputDataSize(0),
+  fOutputDataSize(0),
+  fNrcuTrailerwords(0),
+  fEntropy(0.0),
+  fTrainingTable(NULL),
+  fTranslationTable(NULL)
+{
+  // see header file for class documentation
+}
+
+/** construction with arguments: compressionswitch (compress/ decompress), trainingmode (create new CodeTable or not) and translationtable (read in given CodeTable) */
+AliHLTCOMPHuffmanAltro::AliHLTCOMPHuffmanAltro(Bool_t compressionswitch, Bool_t trainingmode, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* translationtable, Int_t nrcutrailerwords)
+  :
+  fTrainingMode(trainingmode),
+  fCompressionSwitch(compressionswitch),
+  fPointer2InData(NULL),
+  fPointer2OutData(NULL),
+  fInputDataSize(0),
+  fOutputDataSize(0),
+  fNrcuTrailerwords(nrcutrailerwords),
+  fEntropy(0.0),
+  fTrainingTable(NULL),
+  fTranslationTable(translationtable)
+{
+  // see header file for class documentation
+  // initialise member variables
+  fCompressionSwitch = compressionswitch;
+  fTrainingMode = trainingmode;
+  fTranslationTable = translationtable;
+  fNrcuTrailerwords = nrcutrailerwords;
+   
+}
+
+/** EntropyEncoder destructor  */
+AliHLTCOMPHuffmanAltro::~AliHLTCOMPHuffmanAltro()
+{
+  /* destructor, see header file for class documentation */
+}
+
+/** SetInputData takes input data pointer and input data size from component class */
+void AliHLTCOMPHuffmanAltro::SetInputData(void* inputdata, unsigned long datasize)
+{
+  // see header file for class documentation
+  fPointer2InData = (AliHLTUInt8_t*)inputdata;
+  fInputDataSize = datasize; // size in bytes
+  
+  // error when inputdata = NULL
+  if (inputdata == NULL)
+    {
+      HLTError("Error! Pointer to input data == NULL");
+    };
+  
+  // error when datasize < header + trailer
+  if (datasize <= 32 + fNrcuTrailerwords) // 8*32 (headerwords) = 8* 4*8 (headerbytes)
+    {
+      HLTError("Error! Size of input data less than header and trailer");
+    }
+}
+
+
+/** SetOuptputData takes output data pointer and outputsize from component class */
+void AliHLTCOMPHuffmanAltro::SetOutputData(AliHLTUInt8_t* outputdata, unsigned long outputsize)
+{
+  // see header file for class documentation
+  fPointer2OutData = (AliHLTUInt64_t*) outputdata;
+  fOutputDataSize = outputsize;
+
+  // error when outputdata = NULL
+  if (outputdata == NULL)
+    {
+      HLTError("Error! Pointer to output data == NULL");
+    };
+  
+  // errors: compression: when outputdatasize < inputdatasize
+  //         decompress.: when outputdatasize < inputMultiplier * inputdatasize
+  // this should not happen with current config in component (inputMultiplier = 4.0 for decomp and 1.0 for comp)
+  if (fCompressionSwitch == kTRUE) // compression
+    {
+      if(outputsize < fInputDataSize)
+       {
+         HLTError("Error! Size of output data not equal to size of input data for compression: reserved memory space might be too small");
+       };
+    }
+  else // decompression
+    {
+      if(outputsize < (fInputDataSize << 1)) // smaller than inputdatasize * 2 not possible
+       {
+         HLTError("Error! Size of output data too small for decompression");
+       };
+    }
+}
+
+/** GetOutputDataSize delivers output data size for component class to arrange blocks for output writing */
+unsigned long AliHLTCOMPHuffmanAltro::GetOutputDataSize()
+{
+  // see header file for class documentation
+  // error when fOuputDataSize = 0; (not by training as there is no output when training)
+  if((fOutputDataSize == 0) && (fTrainingMode == kFALSE))
+    {
+      HLTError("Error! Calculated output data size is zero");
+    };
+
+  return fOutputDataSize;
+}
+
+/** Initialise training table */
+void AliHLTCOMPHuffmanAltro::InitNewTrainingTable()
+{
+  // see header file for class documentation
+  // define array for training table with amplitudes and abundances
+  fTrainingTable =  new AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t[TIMEBINS];
+  
+  //initialise this array:
+  for(Int_t ii = 0; ii < TIMEBINS; ii++)
+    {
+      
+      fTrainingTable[ii].amplitude = ii;   
+      
+      fTrainingTable[ii].abundance = 0;
+      
+      fTrainingTable[ii].code = 2; //to assure that each leaf is assigned either 0 or 1!!!
+    }
+  
+}
+
+/** write produced code and occurrence table to Huffman Data */
+void AliHLTCOMPHuffmanAltro::SetHuffmanData(AliHLTCOMPHuffmanData* huffmandata)
+{
+  // see header file for class documentation
+  huffmandata->InitHuffmanData(fTrainingTable, fTranslationTable);
+}
+
+/** GetTrainingTable delivers training table for statistics */
+void AliHLTCOMPHuffmanAltro::GetTrainingTable(AliHLTCOMPHuffmanData* huffmandata)
+{
+  // see header file for class documentation
+  // take translation table from HuffmanData
+  fTrainingTable = huffmandata->GetOccurrenceTable(fTrainingTable);
+   
+  // print fTrainingTable to screen (non-zero entries only):
+  // for(Int_t jj = 0; jj < TIMEBINS; jj++)
+  //  {
+  //   if(fTrainingTable[jj].abundance != 0)
+  //   cout << jj << "  |  " << fTrainingTable[jj].amplitude << "  |  " << fTrainingTable[jj].abundance << endl;
+  //  }
+
+  // error when no training table available
+  if (fTrainingTable == NULL)
+    {
+      HLTError("Error! Pointer to training table = NULL");
+    };
+}
+
+/** initialisation of the code table for the Huffman compressor/ decompressor */
+void AliHLTCOMPHuffmanAltro::GetTranslationTable(AliHLTCOMPHuffmanData* huffmandata)
+{
+  // see header file for class documentation
+  // initialise fTranslationTable to be read from a file:
+  fTranslationTable = new AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t[TIMEBINS];
+
+  for(Int_t kk = 0; kk < TIMEBINS; kk++)
+    {
+      fTranslationTable[kk].amplitude = 0;
+      fTranslationTable[kk].code = 0;
+      // fTranslationTable[kk].morecode = NULL;
+      fTranslationTable[kk].validcodelength = 0;
+    }
+
+  // take translation table from HuffmanData
+   fTranslationTable = huffmandata->GetCodeTable(fTranslationTable);
+
+  // print fTranlsationTable to screen (non-zero entries only):
+  // for(Int_t jj = 0; jj < TIMEBINS; jj++)
+  //  {
+  //   if(fTranslationTable[jj].validcodelength != 0)
+  //   cout << jj << "  |  " << fTranslationTable[jj].code << "  |  " << fTranslationTable[jj].validcodelength << endl;
+  //  }
+
+  // error when fTranslationTable = NULL
+  if (fTranslationTable == NULL)
+    {
+      HLTError("Error! Pointer to Huffman coding table = NULL");
+    }
+}
+
+/** ProcessData function to process data compression or decompression */
+void AliHLTCOMPHuffmanAltro::ProcessData()
+{
+  // see header file for class documentation
+  // set mode to process:
+  if(fCompressionSwitch == kTRUE && fTrainingMode == kFALSE) // encoding without training
+    {
+      EntropyCompression();
+
+      // information about compression ratio
+       Double_t compressionratio = ((Double_t) fOutputDataSize)/fInputDataSize;
+       HLTDebug("original filesize (bytes) = %d", fInputDataSize);
+       HLTDebug("compressed filesize (bytes) = %d", fOutputDataSize);
+       HLTDebug("compression ratio after Huffman encoding is %f", compressionratio);
+    }
+  else
+    {
+      if(fCompressionSwitch == kTRUE && fTrainingMode == kTRUE) // encoding with training
+       {
+         TrainingData();
+
+         // information about calculated entropy (contained in GetEntropy()) and compression ratio
+          CalcEntropy();
+          GetEntropy();
+       }
+      else // decoding (no training possible, which is checked for errors by component)
+       {
+        EntropyDecompression();
+
+        // information about compression ratio
+        Double_t compressionratio = ((Double_t) fInputDataSize)/fOutputDataSize;
+        HLTDebug("compressed filesize (bytes) = %d", fInputDataSize);
+        HLTDebug("filesize after decoding (bytes) = %d", fOutputDataSize);
+        HLTDebug("compression ratio calculated from Huffman decompressing has been %f", compressionratio);
+       }
+    }
+}
+
+/** GetEntropy returns entropy and prints it to screen */
+Double_t AliHLTCOMPHuffmanAltro::GetEntropy()
+{
+  // see header file for class documentation
+  // Information about calculated entropy
+  HLTInfo("Calculated entropy =  %f",fEntropy);
+
+  return fEntropy;
+}
+
+/** Compression: take raw input data, code table and put out entropy encoded data */
+Int_t AliHLTCOMPHuffmanAltro::EntropyCompression()
+{
+  // see header file for class documentation
+  // initialise input and output pointers
+  AliHLTUInt32_t* pointer2InData = (AliHLTUInt32_t*) fPointer2InData;
+  AliHLTUInt64_t* pointeroutputprop = fPointer2OutData;
+
+  //first output word has to be initialised
+  pointeroutputprop[0] = 0;
+
+  // initialise output size
+  fOutputDataSize = 0;
+
+  // initialise required variables for input reading
+  AliHLTUInt32_t data10 = 0; // temporary number to read out 10bit word
+  UInt_t idxwd = 8;           // counts lines in input array (start after 8 x 32 bits header words)
+  UInt_t idx10 = 0;           // counts 10-bits words
+  UInt_t bitpswd = 0;         // counts current bitposition in idxwd
+
+  // number of 32-bits trailer and 32-bits common data header words:
+  // (taken out of compression!)
+  // UInt_t fNrcuTrailerwords = 1; // determined by user input as argument
+  UInt_t headerwords = 8;
+
+  // initialise required variables for ouput creation:
+  UInt_t idxoutwd = headerwords >> 1;  // counts lines in output array (start after header words)
+  UInt_t bitpsoutwd = 0;               // counts current bitposition in idxoutwd
+
+  // validation test variables:
+  //  Int_t bitcounter = 0;           // additional test for number of read in 10 bit words
+  // Int_t sumlength = 0;             // additional test for length of encoded file
+
+  // error and abort when total number of bits cannot be divided by 32:
+  // remember that fInputDataSize is given in BYTES!
+  if (((fInputDataSize << 3) & 0x1F) != 0)
+    {
+      HLTError("Error! Input data size (bytes) %i cannot be divided into 32 bit words", fInputDataSize);
+
+      return 1;
+    };
+  
+  // error and abort when input data without trailer words cannot be divided into 10 bit words:
+  if ((( (fInputDataSize << 3) - (fNrcuTrailerwords << 5) - (headerwords << 5)) % 10) != 0)
+    {
+      HLTError("Error! Input data (bytes) %i without trailer (bytes) %i and header words (bytes) %i cannot be divided into 10 bit words", fInputDataSize, (fNrcuTrailerwords << 2),(headerwords << 2));
+
+      return 1;
+    };
+  
+  // last line of 32-bits which is to be encoded
+  UInt_t endNdx = (fInputDataSize>>2)-fNrcuTrailerwords;
+
+  // write header to output (two 32-bits words input header in one 64-bits word output header):
+  UInt_t headcntr = 0;
+  UInt_t headwordcntr = 0;
+
+  while(headcntr != (headerwords >> 1))
+    {
+      // write first header word to the left
+      pointeroutputprop[headcntr] = ((AliHLTUInt64_t) pointer2InData[headwordcntr]);
+
+      // write second header word to the right
+      pointeroutputprop[headcntr] |= ( ((AliHLTUInt64_t) pointer2InData[headwordcntr+1]) << 32);
+
+      // goto next header line and next two header words
+       ++headcntr;
+       headwordcntr += 2;
+    }
+
+    // EntropyCompression() for 10-bit values of ALTRO-Blocks: 
+    while (idxwd < endNdx)
+      {
+       // write input data in data10 and cut out 10 bits with mask 0x3FFU = 0011 1111 1111
+       data10 = (pointer2InData[idxwd] >> bitpswd ) & 0x3FFU;
+
+       // validation test
+       // cout << "10 bit data cut out from data10 =  " << data10 << endl;
+       
+       // if number of bits left in read input less than 10, get remaining bits from next 32-bits word
+       if(bitpswd > 21)
+         {
+           // validation test
+           // cout << "adding bits from next word at bit position  " << bitpswd << endl;
+
+           data10 |= (pointer2InData[idxwd + 1]) << (32 - bitpswd);
+           data10 &= 0x3FFU;
+
+           // validation test
+           // cout << "complete 10-bits word = << data10 << endl;
+         };
+           
+       // validation test
+       // print first 100 10-bits words with resp.code and validcodelength to screen...
+       // if (idx10 < 101)
+       //  {
+       //    cout << "read 10-bits word (HEX) =  " << hex << data10 << dec <<" with code (DEC) =  " << fTranslationTable[data10].code << "  and validcodelength (DEC) =  " << fTranslationTable[data10].validcodelength << endl;
+       // };
+
+         // start encoding of codes with less than 65 bits codelength
+         if(fTranslationTable[data10].validcodelength < 65)
+           {
+             // error and abortion when validcodelength = 0
+             if (fTranslationTable[data10].validcodelength == 0)
+               {
+                 HLTError("Error! Valid codelength of read 10 bit word (DEC) %i is zero", data10);
+
+                 return 1;
+               }
+
+             // validation test
+             // bitcounter += 1;
+             // sumlength += fTranslationTable[data10].validcodelength;
+                   
+             if(fTranslationTable[data10].validcodelength + bitpsoutwd < 64) //if new code fits in current output line
+               {
+                 // validation test
+                 // cout << "writing code (HEX) =  " << hex << fTranslationTable[data10].code << dec << " to line (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+
+                 // shift line to right
+                 pointeroutputprop[idxoutwd] <<= fTranslationTable[data10].validcodelength;
+             
+                 // append code at left side of line
+                 pointeroutputprop[idxoutwd] |= fTranslationTable[data10].code;
+
+                 // validation test
+                 // cout << "code written and current line updated to (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+               }
+             else //if not, write lowest bits to next line
+               {
+                 // validation test
+                  // cout << "writing bits of code (HEX) =  " << hex << fTranslationTable[data10].code << dec << " to line (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+
+                 // create temporary variable for performance gain:
+                 Int_t restcode = fTranslationTable[data10].validcodelength - 64 + bitpsoutwd;
+                 
+                 // shift line completely to the right
+                 pointeroutputprop[idxoutwd] <<= (64 - bitpsoutwd);
+                 
+                 // append upper bits of code to this line
+                 pointeroutputprop[idxoutwd] |= (fTranslationTable[data10].code >> (restcode));
+                 
+                 // validation test
+                 // cout << "code bits written and current line updated to (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+
+                 // write lowest code bits to next line
+                 
+                 ++idxoutwd;
+             
+                 // trick to cut out already written bits from code              
+                 AliHLTUInt64_t tempbuffer = fTranslationTable[data10].code;
+                 tempbuffer <<= 64-bitpsoutwd; // shift away written code
+                 tempbuffer >>= 64-bitpsoutwd; // shift back to get lowest bits
+                 
+                 pointeroutputprop[idxoutwd] = tempbuffer;
+
+                 // validation test
+                 // cout << "code bits written and next line started as (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+               }
+           }
+         else   // if code is longer than 64 bits: use *morecode (not tested therefore left away)
+           {
+             HLTError("Error! Huffman Code Table does not contain codes with valid codelength longer than 64 bits");
+
+             return 1;
+
+           }
+      
+         // validation test
+         // cout << " current positions:" << endl;
+         // cout << "input :  idxwd (DEC) =  " << idxwd << "   bitpswd (DEC) =  " << bitpswd << "   idx10 (DEC) =  " << idx10 << endl;
+         // cout << "output :  idxoutwd (DEC) =  " << idxoutwd << "   bitpsoutwd (DEC) =  " << bitpsoutwd << endl;
+        
+         // calculate new positions
+         bitpsoutwd = (fTranslationTable[data10].validcodelength + bitpsoutwd) & 0x3F;
+         
+         ++idx10; // go on reading 10 bit word
+         
+         // bit position word reads position in 32bit word when 10 bits are read out  
+         bitpswd = (idx10 * 10) & 0x1F;
+
+         // index word reads position of 32bit word in input array
+         idxwd = ((idx10 * 10)>>5)+8; 
+
+         // validation test
+         //if(idxoutwd > 2635)
+         // {
+         //   cout << " encoding value (HEX) = " << hex << data10 << dec << endl;
+         //   cout << " code (HEX) = " << hex << fTranslationTable[data10].code << dec << endl;
+         //   cout << " valid code length (DEC) = " << fTranslationTable[data10].validcodelength << endl;
+         //   cout << " new positions:" << endl;
+         //   cout << "input :  idxwd (DEC) =  " << idxwd << "   bitpswd (DEC) =  " << bitpswd << "   idx10 (DEC) =  " << idx10 << endl;
+         //   cout << "output :  idxoutwd (DEC) =  " << idxoutwd << "   bitpsoutwd (DEC) =  " << bitpsoutwd << endl; 
+         // }
+
+      }// end of encoding (while loop)
+    
+    // if new line is already started
+    if(bitpsoutwd == 0)
+      {
+       --idxoutwd;
+       bitpsoutwd = 64;
+      }
+    else
+      {
+       // fill rest of line with zeroes
+       pointeroutputprop[idxoutwd] <<= (64 - bitpsoutwd);
+      }
+
+    // next 32 bits are to memorise first bitposition after the code
+    UInt_t lastvalidbitps = bitpsoutwd;     
+    
+    // validation test
+    // cout << "last bitpsoutwd = lastvalidbitps (DEC) =  " << bitpsoutwd << endl;
+    
+    // validation test
+    // cout << "second last code line (HEX) = " <<  hex << pointeroutputprop[idxoutwd-1] << dec << endl;
+    // cout << "last code line (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+    // cout << "idxoutwd (DEC) =  " << idxoutwd << endl;
+    
+    // start new line and write last valid bit position and trailer words there:
+    bitpsoutwd = 32;
+    ++idxoutwd;
+    
+    pointeroutputprop[idxoutwd] = lastvalidbitps;
+    
+    // validation test
+    // cout << "first trailer line with lastvalidbitps (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+    // cout << "idxoutwd (DEC) =  " << idxoutwd << endl;
+    
+    // write first trailerword
+    bitpsoutwd = 64;
+    pointeroutputprop[idxoutwd] <<= 32;
+    pointeroutputprop[idxoutwd] |= pointer2InData[endNdx];
+    
+    // validation test
+    // cout << "first trailer line with lastvalidbitpos and first trailerword (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+    
+    if(fNrcuTrailerwords > 1) // if there is more than one trailerword
+      { 
+       ++idxoutwd;
+       bitpsoutwd = 32;
+       
+       pointeroutputprop[idxoutwd] = pointer2InData[endNdx + 1];  // write second
+       
+       // validation test
+       // cout << "last trailer line with second trailerword (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+       // cout << "idxoutwd (DEC) =  " << idxoutwd << endl;
+       
+       if (fNrcuTrailerwords == 3) // write third
+         {
+           bitpsoutwd = 64;
+           
+           pointeroutputprop[idxoutwd] <<= 32;
+           pointeroutputprop[idxoutwd] |= pointer2InData[endNdx +2];
+           
+           // validation test
+           // cout << "last trailer line with last trailerword (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+         }
+      }
+    
+    // validation tests
+    // cout << "file ended at current positions:" << endl;
+    // cout << "input :  idxwd (DEC) =  " << idxwd << "   bitpswd (DEC) =  " << bitpswd << "   idx10 (DEC) =  " << idx10 << endl;
+    // cout << "output :  idxoutwd (DEC) =  " << idxoutwd << "   bitpsoutwd (DEC) =  " << bitpsoutwd << endl; 
+    // cout << "current output line (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+    // cout << "sum of codelengths (DEC) =  " << sumlength << endl;
+    // cout << "number of read 10 bit data (DEC) =  " << bitcounter << endl;
+    // cout << "first input trailer (HEX) =  " << hex << pointer2InData[endNdx] << dec << endl;
+
+    // set fOutputDataSize in byte:
+    // idxoutwd*8 = number of whole 64 bits words in byte
+    // bitpsoutwd/8 = number of wohle 8 bits words within last idxoutwd
+     fOutputDataSize = (Int_t) ((idxoutwd << 3) + (bitpsoutwd >> 3));
+
+    // error and abortion when output data size for encoding is larger than input data size
+    if(fOutputDataSize > fInputDataSize)
+      {
+       HLTError("Error! Calculated data size for compressed output stream is larger than input data size");
+
+       return 1;
+      };
+    
+    // validation test
+    // cout << "output data size (DEC) =  " << fOutputDataSize << endl;
+
+    return 0;
+}
+
+/** Mergesort used by TrainingData to sort an array with n entries from high abundance to low abundance */
+AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* AliHLTCOMPHuffmanAltro::Mergesort(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t *unsortedarray, Int_t n)
+{
+  // see header file for class documentation
+  //divide array into two halfs: left and right (left.size = divlength)
+  Int_t divlength = n >> 1;
+      
+  if (n==1)
+    {
+      // error when unsorted array = NULL
+      if (unsortedarray == NULL)
+       {
+         HLTError("Error! Pointer to final merge sorted abundance array = NULL");
+       };
+
+      return unsortedarray;
+    }
+  else
+    {
+      // sort both halfs recursively:
+      Mergesort(unsortedarray, divlength);  //left half
+      Mergesort(&unsortedarray[divlength], n-divlength); //right half
+
+      // merge together:
+      // create temporary result array:   
+      AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* temp = new AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t[n];
+
+      // counters:
+      Int_t ii, jj, kk;
+
+      // if left and right halves both have elements: chose the smaller one:
+      for (ii = 0, jj = divlength, kk = 0; ii < divlength && jj < n;)
+        {
+         if (unsortedarray[ii].abundance > unsortedarray[jj].abundance)
+           { 
+             temp[kk] = unsortedarray[ii];
+             ++ii;
+           }
+          else 
+           {
+             temp[kk] = unsortedarray[jj];
+             ++jj;
+           }
+         
+          // increase kk
+         ++kk;
+       }     
+      
+      // if one half is empty take elements of the other one:
+      while (ii < divlength)
+        {
+          temp[kk] = unsortedarray[ii];
+         ++kk;
+         ++ii;
+        }
+      
+      while (jj < n) 
+        {
+          temp[kk] = unsortedarray[jj];
+        ++kk;
+        ++jj;
+        }
+      
+      // copy sorted temp array back into original data array
+      for (Int_t ll = 0; ll < n; ll++)
+        {
+          unsortedarray[ll] = temp[ll];
+        }
+   
+      // free space
+      delete[] temp;
+         
+      // return pointer to original data array (which is sorted now)
+      return unsortedarray;
+    }
+}
+
+/** CreateHuffmanTree used by TrainingData to create the binary Huffman tree */
+AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* AliHLTCOMPHuffmanAltro::CreateHuffmanTree(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* listroot,AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* lastelement, Int_t n)
+{
+  // see header file for class documentation
+  // initialise pointer to go through list
+ AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* nextpointer = listroot;
+ AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* lastpointer = lastelement;
+
+  // build Huffman tree while there are still elements in the list
+  while(n > 2)
+    {
+      // validation test
+      // cout << "current number of remaining list elements n (DEC) =  " << n << endl;
+      // cout << "current abundance of last list element (DEC) =  " << lastpointer->leafcontents.abundance << endl;
+      // cout << "print all list elements from high to low to screen:" << endl;
+      // while(nextpointer != NULL)
+      //    { 
+      //      cout << nextpointer->leafcontents.abundance << endl; 
+      //      nextpointer = nextpointer->next; 
+      //    }
+      // cout << " end of list " << endl;
+
+      // create new tree element from last two entries in orderedarray
+     AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* temptree = new AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t;
+
+      // initialise the new element:
+      temptree->leafcontents.amplitude = TIMEBINS; //internal nodes mustn't be confused with real amplitudes (from 0 to bitsize)!
+
+      // validation test
+      // cout <<"current abundance of last list element (DEC) =  " << lastpointer->leafcontents.abundance << endl;
+
+      // initialise abundance starting with last element
+      temptree->leafcontents.abundance = lastpointer->leafcontents.abundance;
+
+      // code assignment small ones get 0, large ones get 1:
+      lastpointer->leafcontents.code = 0;
+
+      // append smallest element on the left and set pointer temptree = parent
+      temptree->left = lastpointer;
+      lastpointer->parent = temptree;
+
+      // go on to second last element and set abundance, code and append on right side of the new element
+      lastpointer = lastpointer->previous;
+
+      // validation test
+      //  cout << "current abundance of second last list element (DEC) =  " << lastpointer->leafcontents.abundance << endl;
+
+      cout.flush();
+
+      temptree->leafcontents.abundance += lastpointer->leafcontents.abundance;
+      lastpointer->leafcontents.code = 1;
+      temptree->right = lastpointer;
+      lastpointer->parent = temptree;
+
+      temptree->next = NULL;
+      temptree->previous = NULL; 
+      temptree->parent = NULL;
+
+      // validation test
+      // cout <<   "current abundance of temptree element = sum of leaf abundances (DEC) =  " << temptree->leafcontents.abundance << endl;
+
+      // write temptree at the suitable place according to its abundance in the list
+      // initialise searchpointer to go through list
+     AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* search = listroot;
+     AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* sorting = listroot; // pointer from previous element
+    
+      // check if listroot[0].leafcontents.abundance < temptree.leafcontents.abundance,
+      // if so, make temptree new root of list
+      if (temptree->leafcontents.abundance > listroot[0].leafcontents.abundance)
+       {
+         // validation test
+         // cout << "abundance of new element (DEC) =  " << temptree->leafcontents.abundance << "   is larger than root abundance (DEC) =  " << listroot[0].leafcontents.abundance << endl;
+
+         // temptree = root
+         temptree->next = search; 
+         search->previous = temptree;
+         //temptree->previous = NULL // for first list element is already done!
+         listroot = temptree;
+       }
+      else //sort in at the suitable point in the list
+       {
+         search = listroot->next; // go one further than listroot!
+
+         while(search != NULL)
+           {
+             // validation test
+             // cout << "current abundance of searchpointer (DEC) =  " << searchpointer->leafcontents.abundance << endl;
+
+             // if abundance of list entry > abundance of new element, go to next element,
+             // else sort in at that point
+             if(search->leafcontents.abundance > temptree->leafcontents.abundance)
+               {
+                 // validation test              
+                 // cout << "abundance of searchpointer (DEC) =  " << search->leafcontents.abundance << "   is larger than temptree abundance (DEC) =  " << temptree->leafcontents.abundance << endl;
+
+                 sorting = search;        // remember previous element
+                 search = sorting->next;  // goto next element
+               }
+             else 
+               {
+                 sorting->next = temptree;     //insert temptree to previous
+                 search->previous = temptree;  //insert temptree to next
+                 temptree->previous = sorting; // insert temptree to previous
+                 temptree->next = search;      //insert temptree to next 
+                
+                 search = NULL;                //stop sorting in
+               }
+           }     
+       } //end of sorting in
+
+      // cut the two elements out of the list:
+  
+      lastpointer = lastpointer->previous;
+      lastpointer->next = NULL;
+      
+      // validation test
+      // cout << "cutting out last two list elements, abundance of current last list element is (DEC) =  " << lastpointer->leafcontents.abundance << endl;
+      
+      cout.flush();
+      
+      // validation test
+      // if(n <= 15)
+      // {
+      //   cout << "current list with new (temptree) element sorted in:" << endl;
+         
+      //  AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t * showpointer = listroot;
+      //   while((showpointer->next != NULL) && (showpointer->leafcontents.abundance != 0))      
+      //    {
+      //      cout << "amplitude (DEC) =  " << showpointer->leafcontents.amplitude << "   abundance (DEC) =  " <<  showpointer->leafcontents.abundance << endl; 
+             
+      //      showpointer = showpointer->next;
+      //    }
+         
+      //   cout << "amplitude (DEC) =  " << showpointer->leafcontents.amplitude << "   abundance (DEC) =  " <<  showpointer->leafcontents.abundance << endl; 
+      // };
+      
+      // perform createHuffmanTree with n-1 elements:
+      --n;
+    }
+      
+  // termination for n = 2:
+  // create new tree element from last two entries
+ AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* temptree = new AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t;
+  
+  // initialise the new element:
+  temptree->leafcontents.amplitude = TIMEBINS; //internal nodes mustn't be confused with real event names (from 0 to TIMEBINS)!
+  // validation test 
+  // cout << "assemble last two elements to final tree:" << endl;
+  // cout << "abundance of last list element (DEC) =  " << lastpointer->leafcontents.abundance << endl;
+  
+  // initialise abundance starting with last element
+  temptree->leafcontents.abundance = lastpointer->leafcontents.abundance;
+  
+  // code assignment small ones get 0, large ones get 1:
+  lastpointer->leafcontents.code = 0;
+  
+  // append smallest element on the left:
+  temptree->left = lastpointer;
+  lastpointer->parent = temptree;
+  // validation test
+  // cout << "abundance of first list element (DEC) =  " << listroot->leafcontents.abundance << endl;
+
+  cout.flush();
+  // go on to second last element and set abundance, code and append on right side of the new element 
+  temptree->leafcontents.abundance +=listroot->leafcontents.abundance;
+  listroot->leafcontents.code = 1;
+  temptree->right = listroot;
+  listroot->parent = temptree;
+  
+  temptree->next = NULL;
+  temptree->previous = NULL; 
+  temptree->parent = NULL;
+  
+  // validation test
+  // cout << "  final abundance of tree root (DEC) =  " << temptree->leafcontents.abundance << endl;
+  
+  // error if temptree = NULL
+  if (temptree == NULL)
+    {
+      HLTError("Error! Pointer to root of Huffman binary tree = NULL");
+    };
+
+  return temptree;
+}
+
+/** HuffmanCode used by TrainingData to create the Huffman code for all leaves of the HuffmanTree */
+Int_t AliHLTCOMPHuffmanAltro::HuffmanCode(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* treeroot, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* HuffmanCodearray)
+{
+  // see header file for class documentation
+  while ((treeroot->left != NULL) || (treeroot->right != NULL))
+    {
+      // define pointer to go through tree
+     AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* finder = treeroot;
+      
+      // define temporary HuffmanCode struct to sort into the Huffmanarray later
+      // array necessary for codelengths > 64 bits
+      Int_t tempstructsize = (Int_t) ceil((double) TIMEBINS/64); // maximal codelength: TIMEBINS
+      Int_t tempstructcntr = 0; // used to write in tempstruct
+
+      AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* tempstruct = new AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t[tempstructsize];
+
+      for(Int_t jj = 0; jj < tempstructsize; jj++)
+       {
+         tempstruct[jj].code = 0;
+       }
+
+      Int_t passednodes = 0;
+
+      // start searching for leaves
+      while (1)
+       {
+         // if finder points at a leaf:
+         if (finder->right == NULL && finder->left == NULL)
+           { 
+             //if it is an internal node
+             if(finder->leafcontents.amplitude == TIMEBINS) 
+               {
+                 // validation test  
+                 // cout << "found internal node with following abundance to delete (DEC) =  " << finder->leafcontents.abundance <<  endl; 
+
+                 //go back to parent and delete node with 256
+                 if (finder->leafcontents.code == 0) // node was left one
+                   {
+                    AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* parent = finder->parent;
+                     parent->left = NULL;
+                   }
+                 else // node was right one
+                   {
+                    AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* parent = finder->parent;
+                     parent->right = NULL;
+                   }    
+                 
+                 break;
+               }
+             else // if it is a leaf
+               {
+                 Int_t checkright = 0; // so leaf is left children
+                 
+                 // leaf can also be a right leaf:
+                 if (finder->leafcontents.code == 1)
+                   {
+                     checkright = 1; // if code == 1, leaf is right children
+                   };
+                 
+                 // write collected data in the respective array:
+
+                 // validation test if amplitudes are correctly found (after being initialised to TIMEBINS+1 in TrainingData()
+                 // HuffmanCodearray[finder->leafcontents.amplitude].amplitude = finder->leafcontents.amplitude;
+                 
+                 // validation test
+                 // cout << "found leaf with amplitude (DEC) =  " << finder->leafcontents.amplitude << endl;
+                 
+                 HuffmanCodearray[finder->leafcontents.amplitude].validcodelength = passednodes;
+
+                 // validation test
+                 // cout << "found leaf with validlength (DEC) =  " << HuffmanCodearray[foundleaves].validcodelength << endl;
+                
+                 //write code:
+                 HuffmanCodearray[finder->leafcontents.amplitude].code = tempstruct[0].code;
+
+                 // validation test
+                 //cout << "found leaf with code (HEX) =  " << hex << HuffmanCodearray[finder->leafcontents.amplitude].code << dec << endl;
+
+                 if(passednodes > 64) // if there is more code to write (not usual in normal zero-suppressed data streams!) 
+                   {
+
+                     HLTError("Error! Valid codelength for datum (DEC) %d is larger than 64 bits, which is not usual for normal input data", finder->leafcontents.amplitude);
+
+                     return 1;
+                   }
+                 
+                 // validation test  
+                 // cout << "found leaf written after passed nodes (DEC) =  " << passednodes << endl;
+                 
+                 // deleting found leaf from tree
+                AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* parent = finder->parent; // go one up and set pointer to leaf to zero:
+                 
+                  // validation test             
+                  // cout << "parent abundance from found leaf (DEC) =  " << finder->leafcontents.abundance << endl;
+
+                 if (checkright == 1) // if leaf is right children -> delete right
+                   {
+                     parent->right = NULL;   
+                   }
+                 else  //else: delete left
+                   {
+                     parent->left = NULL;
+                   }
+                 
+                 break;                  
+               } 
+             // validation test
+             // cout << " finder pointer at end of deleting the found leaf (DEC) =  " << finder << endl; 
+           }
+         else // if node is not a leaf     
+           {
+             // validation test
+             //cout << "finder pointer to left child (DEC) =  " << finder->left << endl;
+             //cout << "finder pointer to right child (DEC) =  " << finder->right << endl;
+             
+             if(finder->left != NULL)
+               {
+                 finder = finder->left;  // pointer to children
+
+                 // validation test
+                 //cout << "left child has abundance (DEC) =  " << finder->leafcontents.abundance << endl;
+                
+                 // shift left to arrange space for new code element which is zero (->left!)
+                 // i.e. nothing further needed to create code
+
+                 // validation test
+                 //cout << "code for left child is created as (DEC) =  " << tempstruct->code << endl;
+                 
+                 //problem if passednodes > 63 --> inserting another bit becomes tricky:
+                 if(passednodes < 64)
+                   {
+                     tempstruct[0].code = tempstruct[0].code << 1; 
+                   }
+                 else // error as valid codelength should not exceed 64 bits
+                   {
+
+                     HLTError("Error! Valid codelength for current encoding process becomes larger than 64 bits, which is not usual for normal input data");
+
+                     return 1;
+                   }
+
+                 // validation test
+                 //cout << "code for left child has been written as (DEC) =  " << tempstruct->code << endl;
+                 
+                ++passednodes;
+               }
+             else
+               {
+                 finder = finder->right; // goto right children
+
+                 // validation test
+                 //cout << "right child has abundance (DEC) =  " << finder->leafcontents.abundance << endl;
+
+                 // shift left to arrange space for new code element which is one (->right!)
+                 // i.e. append 1 at the right end of the code via OR-function
+
+                 // validation test
+                 //cout << "code for right child is created as (DEC) =  " << tempstruct->code << endl;
+
+                 //problem if passednodes > 63 --> inserting another bit becomes tricky:
+                 if(passednodes < 64)
+                   {
+                     tempstruct[0].code = tempstruct[0].code << 1; 
+                     tempstruct[0].code = (tempstruct[0].code) | 1;
+                   }
+                 else
+                   {
+
+                     HLTError("Error! Valid codelength for current encoding process becomes larger than 64 bits, which is not usual for normal input data");
+
+                   }
+                                 
+                 // validation test
+                 //cout << "code for right children has been written as (DEC) =  " << tempstruct->code << endl;
+                 
+                 ++passednodes;
+               } // end of right children search
+           } // end of no-leaf-search
+       } // end of while-loop for leaf-search
+
+      //freespace
+      delete[] tempstruct;  
+    } // end of while-loop for tree != root only
+    
+    // error when there is an amplitude = TIMEBINS in the HuffmanArray
+    for(int jj = 0; jj < TIMEBINS; jj++)
+      {
+       if(HuffmanCodearray[jj].amplitude == TIMEBINS)
+         {
+           HLTError("Error! Internal node from Huffman tree in Huffmanarray for 10 bit word (DEC) %i", jj);
+         };
+      }
+    
+    return 0;
+}
+
+/** Training function to create the HuffmanCode from a binary tree */
+Int_t AliHLTCOMPHuffmanAltro::TrainingData()
+{ 
+  // see header file for class documentation
+  // total number of events counted
+  Int_t totalnumber = 0;
+
+  // 10 BIT READ IN !!!
+  AliHLTUInt32_t* pointer2InData = (AliHLTUInt32_t*)fPointer2InData;
+  // initialise required variables for input reading:
+  AliHLTUInt32_t data10 = 0; // temporary number to read out 10bit word with
+  Int_t idxwd = 8;           // because of common data header words (see below)!
+  Int_t bitpswd = 0;
+
+  // number 32-bit trailer and common data header words:
+  // Int_t fNrcuTrailerwords = 1; // determined by user input as argument
+  Int_t headerwords = 8;
+  
+  // validation test
+  // check if the input data size is appropriate:
+  // cout << "size of input data in bytes (DEC) =  " << fInputDataSize << endl;
+  
+  // error and abort when total number of bits cannot be divided by 32:
+  // remember that fInputDataSize is given in BYTES!
+  if (((fInputDataSize << 3) & 0x1F) != 0)
+    {
+      HLTError("Error! Input data size (bytes) %i cannot be divided into 32 bit words", fInputDataSize);
+
+      return 1;
+    };
+  
+  // error and abort when input data without trailer words cannot be divided into 10 bit words:
+  if ((( (fInputDataSize << 3) - (fNrcuTrailerwords << 5) - (headerwords << 5)) % 10) != 0)
+    {
+ HLTError("Error! Input data (bytes) %i without trailer (bytes) %i and header words (bytes) %i cannot be divided into 10 bit words", fInputDataSize, (fNrcuTrailerwords << 2),(headerwords << 2));     
+
+      return 1;
+    };
+  
+  // index word reads position of 32bit word in input array
+  Int_t idx10 = 0;
+    
+  // last valid bit 
+  UInt_t endNdx = (fInputDataSize>>2)-fNrcuTrailerwords;
+
+  // start reading input data (which are 10 bit words):
+  while (idxwd < endNdx)
+    {
+      // write input data in temp and cut out 10 bits with mask 0x3FF
+      data10 = (pointer2InData[idxwd] >> bitpswd ) & 0x3FFU;
+
+      // if number of bits left in read input less than ten, get remaining bits from next 32bit word
+      if(bitpswd > 21)
+       {
+         data10 |= (pointer2InData[idxwd + 1]) << (32 - bitpswd);
+         data10 &= 0x3FFU;
+       };
+
+      // fill abundances in training table
+      fTrainingTable[(Int_t)(data10)].abundance += 1;
+      
+      // increase total number of events
+      totalnumber += 1;
+      
+      ++idx10; // go on reading 10 bit word
+
+      // bit position word reads position in 32bit word when 10 bits are read out  
+      bitpswd = (idx10 * 10) & 0x1F;
+      
+      idxwd = ((idx10 * 10)>>5)+8; 
+    }
+
+  // validation test
+  // cout << "abundance table is now filled " << endl;
+
+  // set fOutputDataSize to zero as no output has been created:
+    fOutputDataSize = 0;
+
+    return 0;
+}
+
+/** Create Huffman code table out of abundance table filled by training data in DoEvent function of component */
+Int_t AliHLTCOMPHuffmanAltro::CreateCodeTable()
+{
+  // see header file for class documentation
+  // using merge sort to sort the list: (stable algorithm, quick even in worst case O(nlogn))
+  AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* HuffmanArraySorted = Mergesort(fTrainingTable, TIMEBINS);
+
+  // abort when there is no pointer to sorted array (error produced in Mergesort function)
+  if(HuffmanArraySorted == NULL)
+    {
+      return 1;
+    }
+
+  // error and abort if list not properly sorted:
+  // go through list and watch if current abundance of HuffmanData is always larger than next element
+  for(int kk = 0; kk < TIMEBINS - 1; kk++)
+    {
+      if(HuffmanArraySorted[kk].abundance < HuffmanArraySorted[kk+1].abundance)
+       {
+         HLTError("Error! List of 10 bit word abundances not properly sorted by merge sort", "Element with 10 bit word (DEC) %i has abundance %i which is smaller than element with 10 bit word (DEC) %i with abundance %i",HuffmanArraySorted[kk].amplitude, HuffmanArraySorted[kk].abundance, HuffmanArraySorted[kk+1].amplitude, HuffmanArraySorted[kk+1].abundance);
+
+         return 1;
+       };
+    }
+
+  // validation test
+  //cout << "merge sort for training table is now done " << endl;
+  
+  // after mergesorting, zero arrays are last ones in array with abundance = 0
+  //  -> count filled array entries
+  UInt_t filled = TIMEBINS; // to ensure that every amplitude (no matter if it appears in training or not) gets a code
+  UInt_t zeroentries = 0;  // number of non used 10 bit words (with abundance = 0)
+
+  // check how many 10 bit words are used ("missing channel problem)
+  for(int kk = 0; kk < TIMEBINS; kk++)
+    {
+      if((HuffmanArraySorted[kk].abundance == 0))
+       {
+         ++zeroentries;
+       };
+    }
+  
+  // -> new array size is "filled"
+  // validation test
+  // cout << "number of filled array entries (DEC) =  " << filled << endl;
+  
+  // warning when there are a lot of non used 10 bit words -> this training table cannot be used in general case and taken to encode other files
+  if(zeroentries > 50)
+    {
+      HLTWarning("Only %i different 10 bit words out of %i are used, i.e. created Huffman Code table might not be optimal to encode other data", TIMEBINS-zeroentries, TIMEBINS);
+    }
+  
+  // initialise leaves of the tree as list (= queue) ofAliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t,
+ AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t HuffmanTreeList[filled];
+  
+  // initialise first element
+  HuffmanTreeList[0].leafcontents = HuffmanArraySorted[0];
+  HuffmanTreeList[0].left = NULL;
+  HuffmanTreeList[0].right = NULL;
+  HuffmanTreeList[0].next =  &HuffmanTreeList[1];
+  HuffmanTreeList[0].previous = NULL;
+  
+  // validation test
+  // write list to screen
+  // cout <<"Amplitude  " << HuffmanTreeList[0].leafcontents.amplitude << " | " << "Abundance   "<<  HuffmanTreeList[0].leafcontents.abundance << " | " << "Left " << HuffmanTreeList[0].left << " | " << "Right " << HuffmanTreeList[0].right << " | " << "Next " << HuffmanTreeList[0].next << endl; 
+  
+  // initialise 1 to filled-2 elements
+  Int_t kk = 1;
+  while(kk < filled-1)
+    {
+      HuffmanTreeList[kk].leafcontents = HuffmanArraySorted[kk];
+      HuffmanTreeList[kk].left = NULL;
+      HuffmanTreeList[kk].right = NULL;
+      HuffmanTreeList[kk].next =  &HuffmanTreeList[kk+1];
+      HuffmanTreeList[kk].previous = &HuffmanTreeList[kk-1];
+      
+      // validation test
+      // write list to screen
+      // cout <<"Amplitude  " << HuffmanTreeList[kk].leafcontents.amplitude << " | " << "Abundance   "<<  HuffmanTreeList[kk].leafcontents.abundance << " | " << "Left " << HuffmanTreeList[kk].left << " | " << "Right " << HuffmanTreeList[kk].right << " | " << "Next " << HuffmanTreeList[kk].next << endl; 
+      
+      kk += 1;
+    }
+  
+  // initialise last list entry with next pointer to NULL
+  HuffmanTreeList[filled-1].leafcontents = HuffmanArraySorted[filled-1];
+  HuffmanTreeList[filled-1].left = NULL;
+  HuffmanTreeList[filled-1].right = NULL;
+  HuffmanTreeList[filled-1].next = NULL;
+  HuffmanTreeList[filled-1].previous = &HuffmanTreeList[filled-2];
+  
+  // initialise pointer to last list element:
+ AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* lastelement = &HuffmanTreeList[filled-1];
+  
+  // validation test
+  // write last element to screen
+  //  cout <<"Amplitude  " << HuffmanTreeList[filled-1].leafcontents.amplitude << " | " << "Abundance   "<<  HuffmanTreeList[filled-1].leafcontents.abundance << " | " << "Left " << HuffmanTreeList[filled-1].left << " | " << "Right " << HuffmanTreeList[filled-1].right << " | " << "Next " << HuffmanTreeList[filled-1].next << endl; 
+  
+  //use this sorted list to build up the binary tree with root pointer to the beginning:
+ AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* root = CreateHuffmanTree(HuffmanTreeList, lastelement, filled);
+
+  // abort if root = NULL (error already produced in CreateHuffmanTree function)
+  if(root == NULL)
+    {
+      return 1;
+    };
+
+  // validation test
+  // cout << "binary tree is now created " << endl;
+
+  // create an array for the HuffmanCode data:
+  fTranslationTable = new AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t[TIMEBINS];
+
+  // initialise the array with validcodelengths 0 and codes = 0
+  for(Int_t kk = 0; kk < TIMEBINS; kk++)
+    {
+      // validation test for correct HuffmanCode()
+      // fTranslationTable[kk].amplitude = TIMEBINS+1; // check if eventnames are written
+
+      fTranslationTable[kk].amplitude = kk;
+      fTranslationTable[kk].code = 0;
+      fTranslationTable[kk].validcodelength = 0;
+      // fTranslationTable[kk].morecode = NULL;
+    }
+
+  // create HuffmanCode and abort when HuffmanCode produces errors
+  if(HuffmanCode(root,fTranslationTable) == 1)
+    {
+      return 1;
+    };
+
+  // validation test
+  // cout << "Huffman coding is now done " << endl;
+
+  // validation test
+  // print the Huffman code table to screen
+  // for(Int_t kk = 0; kk < TIMEBINS; kk++)
+  //  {
+  //    if (fTranslationTable[kk].validcodelength != 0)
+  //     cout << fTranslationTable[kk].amplitude << "   |   " << fTranslationTable[kk].code << "   |   " << fTranslationTable[kk].validcodelength << endl;
+  //  }
+  
+  // findout maximal and minimal codelength and print them out
+    Int_t maxcodelength = fTranslationTable[0].validcodelength;
+    Int_t mincodelength = TIMEBINS;
+
+    for (Int_t kk = 0; kk < TIMEBINS; kk++)
+      {
+       //      if(fTranslationTable[kk].validcodelength != 0) {cout << kk << " |  " << fTranslationTable[kk].code << " |  " << fTranslation "Table[kk].validcodelength << endl;}
+
+       if(fTranslationTable[kk].validcodelength > maxcodelength)
+         { maxcodelength = fTranslationTable[kk].validcodelength;};
+       if( (fTranslationTable[kk].validcodelength != 0) && (fTranslationTable[kk].validcodelength < mincodelength) )
+         { mincodelength = fTranslationTable[kk].validcodelength;};
+      }
+
+    // print results to screen
+    HLTInfo("maximal codelength (DEC) = %i ", maxcodelength);
+    HLTInfo("minimal codelength (DEC) = %i ", mincodelength);
+  
+    return 0;
+}
+
+/** TTMergesort used by EntropyDecoding to sort translation table according to validcodelength from low to high */
+AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* AliHLTCOMPHuffmanAltro::TTMergesort(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t *unsortedarray, Int_t n)
+{
+  // see heaeder file for class documentation
+  //divide array into two halfs: left and right (left.size = divlength)
+  Int_t divlength = n >> 1;
+      
+  if (n==1)
+    {
+      // error when unsorted array = NULL
+      if (unsortedarray == NULL)
+       {
+         HLTError("Error! Pointer to final merge sorted code table = NULL");
+       };
+
+      return unsortedarray;
+    }
+  else
+    {
+      // sort both halfs recursively:
+      TTMergesort(unsortedarray, divlength);  //left half
+      TTMergesort(&unsortedarray[divlength], n-divlength); //right half
+
+      // merge together:
+      // create temporary result array:   
+      AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* temp = new AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t[n];
+
+      // counters:
+      Int_t ii, jj, kk;
+
+      // if left and right halves both have elements: chose the smaller one:
+      for (ii = 0, jj = divlength, kk = 0; ii < divlength && jj < n;)
+        {
+         if (unsortedarray[ii].validcodelength < unsortedarray[jj].validcodelength)
+           { 
+             temp[kk] = unsortedarray[ii];
+             ++ii;
+           }
+          else 
+           {
+             temp[kk] = unsortedarray[jj];
+             ++jj;
+           }
+         
+          // increase kk
+         ++kk;
+       }     
+      
+      // if one half is empty take elements of the other one:
+      while (ii < divlength)
+        {
+          temp[kk] = unsortedarray[ii];
+         ++kk;
+         ++ii;
+        }
+      
+      while (jj < n) 
+        {
+          temp[kk] = unsortedarray[jj];
+        ++kk;
+        ++jj;
+        }
+      
+      // copy sorted temp array back into original data array
+      for (Int_t ll = 0; ll < n; ll++)
+        {
+          unsortedarray[ll] = temp[ll];
+        }
+   
+      // free space
+      delete[] temp;
+         
+      // return pointer to original data array (which is sorted now)
+      return unsortedarray;
+    }
+}
+
+/** function for the entropy decoding, needed input: code table, input data pointer and size and pointer where to write decoded data */
+Int_t AliHLTCOMPHuffmanAltro::EntropyDecompression()
+{
+  // see heaeder file for class documentation
+  // validation test
+  // print translation table to screen
+  // for(int kk= 0; kk < TIMEBINS; kk++)
+  // {
+  //   cout << fTranslationTable[kk].amplitude << "  |  " << fTranslationTable[kk].code << "  |  " << fTranslationTable[kk].validcodelength << endl;
+  // }
+  
+  // sort translation table according to validcodelengths from low to high (codes that occur often are found quickly)
+   fTranslationTable = TTMergesort(fTranslationTable, TIMEBINS);
+
+  // validation test
+  // print merge sorted translation table to screen
+  // for(int kk= 0; kk < TIMEBINS; kk++)
+  // {
+  //     cout << fTranslationTable[kk].amplitude << "  |  " << fTranslationTable[kk].code << "  |  " << fTranslationTable[kk].validcodelength << endl;
+  // }
+
+  // do set output data first in order to know the size of the decompressed array!
+  // take care of trailers and headers when decoding!
+
+  // initialise reading pointer on compressed data 
+  AliHLTUInt64_t* pointerprop = (AliHLTUInt64_t*)fPointer2InData;
+
+  // initialise writing pointer for decompressed output array
+  AliHLTUInt64_t* pointeroutputprop = (AliHLTUInt64_t*) fPointer2OutData;
+
+  // outputdata size initialised
+  fOutputDataSize = 0;
+  
+  // validation test
+  // cout << "input data size of encoded data (DEC) =  " << fInputDataSize << endl;
+  // cout << "output data size of decoded data (DEC) =  " << fOutputDataSize << endl;
+
+  // create temporary word to read out 1 bit from, maximal length: 64 bits */
+  AliHLTUInt64_t codedata = 0;
+  Int_t codedatalength = 0;
+
+  // number of 32-bit trailer and common data header words:
+  Int_t headerwords = 8;
+  Int_t header64 = headerwords >> 1;
+
+  // initialise counter variables for input array:
+  Int_t idxwd = header64; // due to 8*32 = 4*64 bit header words
+  Int_t bitpswd = 0;
+
+  // initialise counter variables for output array:
+  UInt_t idxoutwd = header64; // due to 8*32 = 4*64 bit header words
+  UInt_t idx10out = 0;
+  UInt_t bitpsoutwd = 0;
+
+  // write header to output (two words input header in one word output header):
+  UInt_t head64cntr = 0;
+  
+  while(head64cntr < header64)
+    {
+      pointeroutputprop[head64cntr] = pointerprop[head64cntr];
+
+      // validation test
+      //cout << "header line in output stream (HEX) =  " << hex << pointeroutputprop[head64cntr] << dec << endl;
+    
+      ++head64cntr;
+    }
+  
+  // end of encoded ALTRO-blocks [Byte] = finputdatasize - (number of 32-bit-trailer-words + 1) / 4 
+  // match this with idxwd as number of 64-bit-words (endNdx[#64-bit-wds] = endNdx[#8-bit-wds]*8/64)
+  UInt_t lastfullline = (fInputDataSize) >> 3;
+  UInt_t lastbit = (fInputDataSize << 3) & 0x3F;
+  UInt_t lastcodeline = lastfullline - ((fNrcuTrailerwords +1) >> 1);
+
+  --lastfullline;
+  --lastcodeline;
+
+  if (lastbit == 0)
+    {
+      lastbit = 64;
+    }
+
+  // initialise last valid bit position and trailer array
+  AliHLTUInt32_t lastvalidbitpos = 0;
+  AliHLTUInt64_t* trailer = new AliHLTUInt64_t[fNrcuTrailerwords];
+
+  // validation test
+  // cout << "last bit (DEC) =  " << lastbit << endl;
+  // cout << "lastfullline (DEC) =  " << lastfullline << endl;
+  // cout << "lastcodeline(DEC) =  " << lastcodeline << endl;
+  // cout << "second last code line data (HEX) = " <<  hex << pointerprop[lastcodeline-1] << dec << endl;
+  //  cout << "last code line data (HEX) =  " << hex << pointerprop[lastcodeline] << dec << endl;
+  // cout << "last full line data (HEX) =  " << hex << pointerprop[lastfullline] << dec << endl;
+  // get last valid bit position (first 32 bit word in first trailer line after code
+  // and trailerwords
+  if (fNrcuTrailerwords < 3) // then lastfullline = only trailerline
+    {
+      lastvalidbitpos = (pointerprop[lastfullline] >> 32);
+
+      // first trailerword
+      trailer[0] = ((pointerprop[lastfullline] << 32 ) >> 32);
+
+      // second trailerword
+      if(fNrcuTrailerwords == 2)
+       {
+         trailer[1] = ((pointerprop[lastfullline+1] << 32) >> 32);
+       };
+    }
+  else
+    {
+      lastvalidbitpos = (pointerprop[lastfullline-1] >> 32);
+
+      // first trailerword
+      trailer[0] = ((pointerprop[lastfullline-1] << 32 ) >> 32);
+
+      //second trailerword
+      trailer[1] = (pointerprop[lastfullline] >> 32);
+
+      // third trailerword
+      trailer[2] =((pointerprop[lastfullline] << 32 ) >> 32);
+    }
+
+  // validation test
+  // cout << "last valid bit position (DEC) =  " << lastvalidbitpos << endl;
+
+  // warning if one of the trailer words is zero:
+  for (int kk = 0; kk < fNrcuTrailerwords; kk++)
+    {
+      if(trailer[kk] == 0)
+       {
+         HLTWarning("Trailer word %i is zero",kk+1);
+       };
+    }
+
+  // validation test
+  // print trailer array to screen
+  // for(Int_t ii=0; ii < fNrcuTrailerwords; ii++)
+  // {
+  // cout << "trailerword " << ii+1 << " after getting whole trailer (HEX) =  " << hex << trailer[ii] << dec << endl;
+  //  }
+
+  // find minmal validcodelength from first entry of translation table and
+  // read in minimal validcodelength bits if codedata is zero...
+  UInt_t minimalcodelength = fTranslationTable[0].validcodelength;
+
+  // validation test
+  // cout << "minimal codelength (DEC) =  " << minimalcodelength << endl;
+
+  Int_t readnewcode = 1; // read new code = 1; go on with old code = 0
+
+  // start decoding
+  // NEW  (bitpswd >= lastvalidbitpos) instead of  (bitpswd > lastvalidbitpos)
+  while (!((idxwd >= lastcodeline) && (bitpswd >= lastvalidbitpos)) )
+    {
+      if((idxwd == lastcodeline+1) && (bitpswd == 0)) break; // abortion when lastvalidbitpos = 64
+
+      if (codedatalength < 64) // if codedata can still get one further bit
+       {
+         // if new code word is read before end position
+         if((readnewcode == 1) && !((idxwd >= lastcodeline) && (bitpswd + minimalcodelength > lastvalidbitpos)))
+           {
+             // codedata gets next bits from encoded input file:
+             codedata <<= minimalcodelength; //shift bits left
+             
+             if (bitpswd + minimalcodelength < 65) // all bits in the same line
+               {
+                 codedata |= ((pointerprop[idxwd] << bitpswd)) >> (64 - minimalcodelength); //append bits from input file to the right
+               }
+             else // some of this bits in the next line
+               {
+                 // append bits of current line to the right end of codedata
+                 codedata |= (((pointerprop[idxwd] << bitpswd)) >> (bitpswd)) << (minimalcodelength - 64 + bitpswd);
+                 
+                 // append bits of next line to the right end of codedata
+                 codedata |= (pointerprop[idxwd+1] >> (128 - minimalcodelength - bitpswd)); // 128 - mcl - bitpswd = 64 - (mcl - (64 - bitpswd))
+               }
+             
+             codedatalength += minimalcodelength;
+             
+             // new code is read, set readnewcode back to 0 again
+             readnewcode = 0;
+             
+             // go and get next input bit
+             bitpswd += minimalcodelength;
+           }
+         else
+           {
+             // codedata gets on bit after another from encoded input file:
+             codedata <<= 1; //shift one bit left
+             codedata |= ((pointerprop[idxwd] << bitpswd)) >> 63; //append next bit from input file to the right
+             
+             ++codedatalength;
+             
+             // go and get next input bit
+             ++bitpswd;
+           }
+         
+         // go and get next input bit
+         if(bitpswd > 63) 
+           {
+             ++idxwd;
+             bitpswd = bitpswd & 0x3F;
+           };
+         
+         // compare if new codedata is in translation table:
+         for(Int_t kk = 0; kk < TIMEBINS; kk++)
+           {
+             // stopping when current codedatalength smaller than lookup validcodelength (i.e. current code not in table, read next bit)
+             if(fTranslationTable[kk].validcodelength > codedatalength)
+               {
+                 break;
+               };
+
+             if(fTranslationTable[kk].code == codedata) //lookup bit pattern
+               {
+                 if(fTranslationTable[kk].validcodelength == codedatalength) //lookup correct codelength
+                   {
+                     // validation test
+                     // if( idxoutwd >= 2636)
+                     //{
+                     //  cout << "write 10 bit word to decoded output (DEC) =  " << fTranslationTable[kk].amplitude << endl;
+                     //  cout << "current idxwd (DEC) =  " << idxwd << endl;
+                     //  cout << "current idxoutwd (DEC) =  " << idxoutwd << endl;
+                     //}
+                     if(bitpsoutwd + 10 < 65) //fits in old line
+                       {
+                         // valdidation test for end of decoded data
+                         // print all relevant quantities to screen
+                         //if(idxwd > 2635)
+                         // {
+                         //   cout << "current input in codedata (HEX) =  " << hex << (pointerprop[idxwd] << bitpswd) << dec << endl;
+                         //  cout << "current idxwd (DEC) =  " << idxwd << endl;
+                         //  cout << "current bitpswd (DEC) =  " << bitpswd << endl;
+                         //  cout << "current idxoutwd (DEC) =  " << idxoutwd << endl;
+                         //  cout << "current bitpsoutwd (DEC) =  " << bitpsoutwd << endl;
+                         //  cout << "decoding value (DEC) =  " << codedata << endl;
+                         //  cout << "value length (DEC) =  " << codedatalength << endl;
+                         //  cout << "10 bit value (HEX) =  " << hex << fTranslationTable[kk].amplitude << dec << endl;
+                         // }
+                         
+                         pointeroutputprop[idxoutwd] |= ((AliHLTUInt64_t)(fTranslationTable[kk].amplitude)) << bitpsoutwd;
+                         
+                         // validation test
+                         // if (idxoutwd > 362880)
+                         // {
+                         //   cout << "updated output line (HEX) =  " <<hex << pointeroutputprop[idxoutwd] <<dec << endl;
+                         // }
+                         
+                         // goto next 10-bits output position
+                         bitpsoutwd += 10;
+                         
+                         if(bitpsoutwd == 64) {bitpsoutwd = 0; ++idxoutwd;};
+                         
+                       }
+                     else //needs start of new line
+                       {
+                         
+                         pointeroutputprop[idxoutwd] |= ((AliHLTUInt64_t)(fTranslationTable[kk].amplitude)) << (bitpsoutwd); 
+                         
+                         ++idxoutwd; //start new line
+                         
+                         // validation test
+                         // if(idxwd > 2635)
+                         //{
+                         //  cout << "current input in codedata (HEX) =  " << hex << (pointerprop[idxwd] << bitpswd) << dec << endl;
+                         //  cout << "current idxwd (DEC) =  " << idxwd << endl;
+                         //  cout << "current bitpswd (DEC) =  " << bitpswd << endl;
+                         //  cout << "current idxoutwd (DEC) =  " << idxoutwd << endl;
+                         //  cout << "current bitpsoutwd (DEC) =  " << bitpsoutwd << endl;
+                         //  cout << "decoding value (DEC) =  " << codedata << endl;
+                         //  cout << "value length (DEC) =  " << codedatalength << endl;
+                         //  cout << "10 bit value (HEX) =  " << hex << fTranslationTable[kk].amplitude << dec << endl;
+                         //}
+                         
+                         // write next line
+                         AliHLTUInt64_t buffer = fTranslationTable[kk].amplitude;        
+                         buffer >>= (64 - bitpsoutwd);
+                         
+                         pointeroutputprop[idxoutwd] = buffer;
+                     
+                         // validation test
+                         // if (idxoutwd > 362880)
+                         // {
+                         //   cout << "new line (HEX) =  " << hex << pointeroutputprop[idxoutwd] << dec << endl;
+                         // }
+
+                         // go to next bit position
+                         bitpsoutwd -= 54;
+                       }
+                     
+                     // set buffers to zero again
+                     codedata = 0;
+                     codedatalength = 0;
+                     
+                     // prepare codedata to read new code word
+                     readnewcode = 1;
+
+                     // go on with next code bits from input
+                     break;
+                   };
+               };
+           }   
+       }
+      else // if *morecode is used
+       {
+
+         HLTError("Error! Valid codelength for current decoding is larger than 64 bits, error in recognising the correct code");
+
+         return 1;
+
+       }
+    }
+
+  // last (incomplete) line from input encoded data
+  // after all code is read, bitpsoutwd at lastvalidbitpos
+  // -> go to next byte (i.e. start of trailer)
+
+  // validation test
+  // cout << "bit position after decoding (DEC) =  " << bitpsoutwd << endl;
+  // cout << "line position after decoding (DEC) =  " << idxoutwd << endl;
+
+  // warning if byte position is not 8-bits aligned
+  if ((bitpsoutwd & 0x07) != 0 )
+    {
+      HLTWarning("Bit position after decoding %i is not aligned to 8 bits", bitpsoutwd);
+    };
+
+  if(bitpsoutwd + 32 < 65) // trailer fits in current line, append on the right
+    {
+      pointeroutputprop[idxoutwd] <<= 32;
+
+      pointeroutputprop[idxoutwd] |= trailer[0]; 
+
+      bitpsoutwd += 32;
+    }
+  else
+    {
+      pointeroutputprop[idxoutwd] <<= 64 - bitpsoutwd;
+      pointeroutputprop[idxoutwd]|= (trailer[0] >> (bitpsoutwd - 32));
+
+      // go to next line
+      ++idxoutwd;
+
+      // get rid of upper, already written bits
+      trailer[0] <<= 96 - bitpsoutwd;
+      trailer[0] >>= 96 - bitpsoutwd;
+
+      pointeroutputprop[idxoutwd] = trailer[0]; // write lower bits to next line
+
+      bitpsoutwd -= 32;
+    }
+
+  if(fNrcuTrailerwords > 1)
+    {
+
+      if(bitpsoutwd == 64)
+       {
+         bitpsoutwd = 0;
+         ++idxoutwd;
+       }
+
+      for(int ii = 1; ii < fNrcuTrailerwords; ii++)
+       {
+         // write second trailer to output data
+         if(bitpsoutwd + 32 < 65) // trailer fits in current line, append on the right
+           {
+             pointeroutputprop[idxoutwd] <<= 32;
+             
+             pointeroutputprop[idxoutwd] |= trailer[ii]; 
+
+             bitpsoutwd += 32;
+
+             if(bitpsoutwd == 64)
+               {
+                 bitpsoutwd = 0;
+                 ++idxoutwd;
+               }
+           }
+         else
+           {
+             pointeroutputprop[idxoutwd] <<= 64 - bitpsoutwd;
+             pointeroutputprop[idxoutwd]|= (trailer[ii] >> (bitpsoutwd - 32));
+             
+             // go to next line
+             ++idxoutwd;
+             
+             // get rid of upper, already written bits
+             trailer[ii] <<= 96 - bitpsoutwd;
+             trailer[ii] >>= 96 - bitpsoutwd;
+             
+             pointeroutputprop[idxoutwd] = trailer[ii]; // write lower bits to next line
+             
+             bitpsoutwd -= 32;
+           }
+       }
+    }
+      // validation test
+  // cout << "bitpswd after decoding (DEC) =  " << bitpswd << endl;
+  // cout << "bitpsoutwd after decoding (DEC) =  " << bitpsoutwd << endl;
+  // cout << "idxwd after decoding (DEC) =  " << idxwd << endl;
+  // cout << "idxoutwd after decoding (DEC) =  " << idxoutwd << endl;
+
+  // write trailer to decoded output
+
+  // set fOutputDataSize in byte:
+  // idxoutwd*8 = number of whole 64 bits words in byte
+  // bitpsoutwd/8 = number of wohle 8 bits words within last idxoutwd
+  // (bitpsoutwd%8)?1:0 = determine whether one more byte has to be used for "left over" bits
+  fOutputDataSize = (Int_t) ((idxoutwd << 3) + (bitpsoutwd >> 3) + ((bitpsoutwd & 0x7) ? 1 : 0) );
+  
+  // error and abort when output data size smaller than input data size (impossible when decompressing)
+  if(fOutputDataSize < fInputDataSize)
+    {
+      HLTError("Error! Data size for decompressed output stream (bytes) %i is smaller than compressed input data size (bytes)  %i", fOutputDataSize, fInputDataSize);
+
+      return 1;
+    };
+
+  // validation test
+  // cout << "output data size (DEC) =  " << fOutputDataSize << endl;
+  
+  return 0;
+}
+
+/** CalcEntropy is to calculate entropy for 10 bits amplitudes of input data (per event only!) */
+Int_t AliHLTCOMPHuffmanAltro::CalcEntropy()
+{
+  // see heaeder file for class documentation
+  // create result array with TIMEBINS entries according to their abundance in the input data:
+  Int_t* histogrammarray = new Int_t[TIMEBINS];
+
+  // initialise histrogramm:
+  for(Int_t jj = 0; jj < TIMEBINS; jj++)
+    {
+      histogrammarray[jj] = 0;
+    }
+
+  // total number of counted data
+  Int_t totalnumber = 0;
+
+  fEntropy = 0.0;
+
+  // 10 BIT READ IN !!!
+  AliHLTUInt32_t* pointer2InData = (AliHLTUInt32_t*)fPointer2InData;
+  
+  // initialise required variables for input reading:
+  AliHLTUInt32_t data10 = 0; // temporary number to read out 10bit word with
+  Int_t idxwd = 8; // because of common data header words (see below)!
+  Int_t bitpswd = 0;
+
+  // number 32-bit trailer and common data header words:
+  // Int_t fNrcuTrailerwords = 1;   // determined by user input as argument
+  Int_t headerwords = 8;
+  
+  // validation test
+  // check if the input data size is appropriate:
+  // cout << "size of input data in bytes (DEC) =  " << fInputDataSize << endl;
+  
+  // error and abort when total number of bits cannot be divided by 32:
+  // remember that fInputDataSize is given in BYTES!
+  if (((fInputDataSize << 3) & 0x1F) != 0)
+    {
+      HLTError("Error! Input data size (bytes) %i cannot be divided into 32 bit words", fInputDataSize);
+
+      return 1;
+    };
+  
+  // error and abort when input data without trailer words cannot be divided into 10 bit words:
+  if ((( (fInputDataSize << 3) - (fNrcuTrailerwords << 5) - (headerwords << 5)) % 10) != 0)
+    {
+      HLTError("Error! Input data without trailer and header words (bytes) %i cannot be divided into 10 bit words", fInputDataSize);
+
+      return 1;
+    };
+
+  // index to watch current bit position of 10 bits words
+  Int_t idx10 = 0;
+  // last valid bit for read in
+  UInt_t endNdx = (fInputDataSize>>2)-fNrcuTrailerwords;
+
+  // start reading and encoding input data (which are 10 bit words):
+  while (idxwd < endNdx)
+    {
+      // write input data in temp and cut out 10 bits with mask 0x3FF
+      data10 = (pointer2InData[idxwd] >> bitpswd ) & 0x3FFU;
+
+      // if number of bits left in read input less than ten, get remaining bits from next 32bit word
+      if(bitpswd > 21)
+       {
+         data10 |= (pointer2InData[idxwd + 1]) << (32 - bitpswd);
+         data10 &= 0x3FFU;
+       };
+
+      // validation test
+      // print first 10 bits words to screen
+      // if (idx10 < 100)
+      //  {
+      //    cout << "read 10 bits word (HEX) =  " << hex <<  data10 << dec << endl;
+      //  };
+      
+      // store abundance of data10 in histogrammarray
+      histogrammarray[(Int_t) data10] += 1;
+      
+      ++totalnumber;
+      
+      idx10 += 1; // go on reading 10 bit word
+      // bit position word reads position in 32bit word when 10 bits are read out  
+      bitpswd = (idx10 * 10) & 0x1F;
+      idxwd = ((idx10 * 10)>>5)+8;
+    }
+  
+  // validation test
+  // print abundance table to screen
+  // for (Int_t jj=0; jj < TIMEBINS; jj++)
+  //  {
+  //    cout << histogrammarray[jj] << endl;
+  //  }
+
+  // save log(2) in special variable for performance gain:
+  double l2 = log(2.0);
+
+  // calculate the entropy of the array 
+  for(Int_t jj = 0; jj < TIMEBINS; jj++)
+    {
+      if (histogrammarray[jj] != 0)
+       {
+         fEntropy += (- (Double_t) histogrammarray[jj] / (Double_t) totalnumber ) * log( ( (Double_t) histogrammarray[jj] / (Double_t) totalnumber )) / (l2);
+       };
+    }
+  // free space 
+  delete[] histogrammarray;
+  
+  return 0;
+}
+
+/* CopyData is just a function for performance testing */
+Int_t AliHLTCOMPHuffmanAltro::CopyData()
+{
+  // see heaeder file for class documentation
+  // output data: fPointer2OutData (to 8-bit words)
+  // initialise propagation pointer for output array
+  AliHLTUInt32_t* pointer2InData = (AliHLTUInt32_t*) fPointer2InData;
+  AliHLTUInt32_t* pointeroutprop = (AliHLTUInt32_t*) fPointer2OutData;
+
+  //first output word has to be initialised
+  pointeroutprop[0] = 0;
+
+  fOutputDataSize = fInputDataSize;
+
+  // initialise required variables for input reading:
+  AliHLTUInt32_t data10 = 0; // temporary number to read out 10bit word with
+  Int_t idxwd = 8;
+  Int_t idx10 = 0;
+  Int_t bitpswd = 0;
+
+  // number of 32-bit trailer and common data header words:
+  // (taken out of compression!)
+  // Int_t fNrcuTrailerwords = 1;   // determined by user input as argument
+  Int_t headerwords = 8;
+
+  // initialise required variables for ouput creation:
+  Int_t idxoutwd = 0;
+  //  Int_t bitcounter = 0; // additional test for number of read in 10 bit words
+  // Int_t sumlength = 0;   // additional test for length of encoded file
+  
+  UInt_t endNdx = (fInputDataSize>>2)-fNrcuTrailerwords;
+
+  // start reading and encoding input data (which are 10 bit words):  
+  while (idxwd < endNdx)
+    {
+      // write input data in temp and cut out 10 bits with mask 0x3FF
+      data10 = (pointer2InData[idxwd] >> bitpswd ) & 0x3FFU;
+      
+      // validation test
+      //cout << "current 10 bits word (DEC) =  " << data10 << endl;
+         
+         // if number of bits left in read input less than ten, get remaining bits from next 32bit word
+         if(bitpswd > 21)
+           {
+             data10 |= (pointer2InData[idxwd + 1]) << (32 - bitpswd);
+             data10 &= 0x3FFU;
+           };
+
+         // validation test
+         // print first 10 bits words to screen
+         // if (idx10 < 100)
+         // {
+         //   cout << "read data:  " << hex << data10 << dec << endl;
+         // };
+
+         // write data to 32 bit output:
+         pointeroutprop[idxoutwd] |= (data10 << bitpswd);
+
+         if(bitpswd > 21)
+           {
+             pointeroutprop[idxoutwd + 1] = (data10 >> (32 - bitpswd));
+           }
+
+         // validation test
+         // cout << "next bitpswd (DEC) =  " << bitpswd << endl;
+
+         ++idx10; // go on reading 10 bit word
+         
+         // index word reads position of 32bit word in input array
+         idxoutwd = (idx10 * 10);
+         bitpswd = idxoutwd & 0x1F;
+         idxoutwd >>= 5;
+         idxwd = idxoutwd+8;
+         // bit position word reads position in 32bit word when 10 bits are read out  
+    }
+
+  // validation test
+  // cout << "output data size (DEC) =  " << fOutputDataSize <<  endl;
+  // cout << "sum of codelengths (DEC) =  " << sumlength << endl;
+  // cout << "number of 10 bits words (DEC) =  " << bitcounter << endl;
+   
+  return 0;
+}
diff --git a/HLT/comp/AliHLTCOMPHuffmanAltro.h b/HLT/comp/AliHLTCOMPHuffmanAltro.h
new file mode 100644 (file)
index 0000000..15b550e
--- /dev/null
@@ -0,0 +1,193 @@
+// @(#) $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 "AliHLTDataTypes.h"
+#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::AliHLTCOMPHuffmanCode_t* 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 unsorted array  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::AliHLTCOMPHuffmanData_t* Mergesort(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* 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::AliHLTCOMPHuffmanTreeData_t* treeroot, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* 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::AliHLTCOMPHuffmanTreeData_t* CreateHuffmanTree(AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* listroot,  AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanTreeData_t* 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 unsorted array  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::AliHLTCOMPHuffmanCode_t* TTMergesort(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* 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 */
+  Int_t fOutputDataSize;                        // output data size
+  /** number of NRCU trailer words */
+  Int_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::AliHLTCOMPHuffmanData_t* fTrainingTable;       // training table with amplitudes and resp. abundances
+  /** pointer to Huffman code table */
+  AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* fTranslationTable;    // Huffman Entropy Code Table
+
+
+  ClassDef(AliHLTCOMPHuffmanAltro, 0)
+       };
+#endif
diff --git a/HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.cxx b/HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.cxx
new file mode 100644 (file)
index 0000000..d31c297
--- /dev/null
@@ -0,0 +1,360 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>                *
+ *          for The ALICE Off-line Project.                               *
+ *                                                                        *
+ * 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   AliHLTCOMPHuffmanAltroCalibComponent.cxx
+    @author Jochen Thaeder
+    @date   
+    @brief  A calibration component for the Huffman code creation.
+*/
+
+#if __GNUC__>= 3
+using namespace std;
+#endif
+
+#include "AliHLTCOMPHuffmanAltroCalibComponent.h"
+#include "AliHLTCOMPHuffmanAltro.h"
+#include "AliHLTCompDefinitions.h"
+#include "AliHLTStdIncludes.h"
+#include "TFile.h" // necessary for HuffmanData writing
+
+ClassImp(AliHLTCOMPHuffmanAltroCalibComponent)
+
+AliHLTCOMPHuffmanAltroCalibComponent::AliHLTCOMPHuffmanAltroCalibComponent()
+  :
+  fHuffmanCompressor(NULL),
+  fHuffmanData(NULL),
+  fOrigin(kAliHLTVoidDataOrigin),
+  fRunNumber(0),
+  fSpecification(0),
+  fTablePath(),
+  fNRCUTrailerWords(0) {
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTCOMPHuffmanAltroCalibComponent::~AliHLTCOMPHuffmanAltroCalibComponent() {
+  // see header file for class documentation
+}
+
+// Public functions to implement AliHLTComponent's interface.
+// These functions are required for the registration process
+
+const char* AliHLTCOMPHuffmanAltroCalibComponent::GetComponentID() {
+  // see header file for class documentation
+
+  return "COMPHuffmanTrainer";
+}
+
+void AliHLTCOMPHuffmanAltroCalibComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
+  // see header file for class documentation
+
+  list.clear(); 
+  list.push_back( kAliHLTDataTypeDDLRaw );
+}
+
+AliHLTComponentDataType AliHLTCOMPHuffmanAltroCalibComponent::GetOutputDataType() {
+  // see header file for class documentation
+
+  AliHLTComponentDataType dt=AliHLTCompDefinitions::fgkHuffmanAltroCalDataType;
+  if (!fOrigin.IsNull()) dt=dt|fOrigin.Data();
+  return dt;
+}
+
+void AliHLTCOMPHuffmanAltroCalibComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
+  // see header file for class documentation
+
+  constBase = sizeof(AliHLTCOMPHuffmanData);
+  inputMultiplier = (0.0);
+}
+
+AliHLTComponent* AliHLTCOMPHuffmanAltroCalibComponent::Spawn() {
+  // see header file for class documentation
+
+  return new AliHLTCOMPHuffmanAltroCalibComponent();
+}  
+
+
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::ScanArgument( Int_t argc, const char** argv ) {
+  // see header file for class documentation
+
+  Int_t iResult = 0;
+  TString argument = " ";
+  TString parameter = " ";
+
+  if ( !argc ) 
+    return -EINVAL;
+
+  argument = argv[iResult];
+  
+  if ( argument.IsNull() ) 
+    return -EINVAL;
+
+  // get data origin
+  if ( argument.CompareTo("-origin") == 0 ) 
+    {
+
+      if ( ++iResult >= argc  ) 
+       {
+         iResult = -EPROTO;
+       }
+      else 
+       {
+         fOrigin = argv[1];
+
+         HLTInfo("Origin is set to %s.", fOrigin.Data());        
+
+       }
+    }
+
+  else
+    {
+      // get run number   
+      if ( argument.CompareTo("-runnumber") == 0 ) 
+       {
+         
+       if ( ++iResult >= argc  ) 
+         {
+           iResult = -EPROTO;
+         }
+       else 
+         {
+           parameter = argv[1];
+           
+           // get run number
+        
+           fRunNumber =  atoi(parameter.Data());
+              
+           HLTInfo( "Run number is set to %d (Dec) = %X (Hex).", fRunNumber, fRunNumber ); 
+         }
+       }
+      else
+       {
+         // get data specification
+         if(argument.CompareTo("-dataspec") == 0 ) 
+           {
+             if ( ++iResult >= argc  ) 
+               {
+                 iResult = -EPROTO;
+               }
+             else 
+               {
+                 // get data specification
+                 fSpecification = strtoul( argv[1], NULL, 16);
+                 
+                 HLTInfo( "Specification is set to %d (Dec) = %08X (Hex).", fSpecification, fSpecification ); 
+               }
+           }
+         // get number of trailer words
+         else 
+           {
+             
+             if ( argument.CompareTo("-tablepath") == 0)
+               {
+                 if ( ++iResult >= argc  ) 
+                   {
+                     iResult = -EPROTO;
+                   }
+                 else 
+                   {
+                     // get table path
+                     fTablePath = argv[1];
+                     HLTInfo( "Path for Huffman table output is set to %s.", fTablePath.Data() );                    
+                     if (!fTablePath.IsNull() && !fTablePath.EndsWith("/"))
+                         fTablePath+="/";
+                   }
+               }
+
+             else 
+               {
+                 if ( argument.CompareTo("-trailerwords") == 0 ) 
+                   { 
+                     
+                     if ( ++iResult >= argc  ) 
+                       {
+                         iResult = -EPROTO;
+                       }
+                     else 
+                       {
+                         parameter = argv[1];
+                         if ( parameter.CompareTo("1") == 0 ) 
+                           {
+                             fNRCUTrailerWords = 1;
+                             HLTInfo( "Number of trailer words is set to 1." );
+                           }
+                         else if ( parameter.CompareTo("2") == 0 ) 
+                           {
+                             fNRCUTrailerWords = 2;
+                         HLTInfo( "Number of trailer words is set to 2." );
+                           }
+                         else if ( parameter.CompareTo("3") == 0 ) 
+                           {
+                             fNRCUTrailerWords = 3;
+                         HLTInfo( "Number of trailer words is set to 3." );
+                           }
+                         else 
+                           {
+                             HLTError( "Invalid number of trailerwords: '%s'.", argv[1] );
+                             iResult = -EPROTO;
+                           }
+                       } 
+                   }
+                 else 
+                   {
+                     iResult = -EINVAL;
+                   }
+               }
+           }
+       }
+    }
+  
+  return iResult;
+}
+
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::InitCalibration() {
+  // see header file for class documentation
+    
+  // ** Create a calibration instance to train the Huffman code table
+  if ( fHuffmanCompressor )
+    return EINPROGRESS;
+  
+  if ( fHuffmanData )
+    return EINPROGRESS;
+
+  // create a new instance of HuffmanData to write results from training in
+  fHuffmanData = new AliHLTCOMPHuffmanData();
+
+  fHuffmanCompressor = new AliHLTCOMPHuffmanAltro(kTRUE, kTRUE, NULL, fNRCUTrailerWords);
+
+  // initialise new training table
+  fHuffmanCompressor->InitNewTrainingTable(); 
+  return 0;
+}
+
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::DeinitCalibration() {
+  // see header file for class documentation
+
+  if ( fHuffmanCompressor )
+    delete fHuffmanCompressor; 
+  fHuffmanCompressor = NULL;
+
+  if ( fHuffmanData )
+    delete fHuffmanData; 
+  fHuffmanData = NULL;
+
+  return 0;
+}
+
+/** function to do the calibration */
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
+  // see header file for class documentation
+  const AliHLTComponentBlockData* iter = NULL;
+
+  //AliHLTUInt8_t slice, patch;
+  // ** Loop over all input blocks and specify which data format should be read - only select Raw Data
+  iter = GetFirstInputBlock( kAliHLTDataTypeDDLRaw );
+  
+  if ( iter != NULL ) do {
+
+    // ** Print Debug output which data format was received
+    HLTDebug ( "Event received - Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", 
+              evtData.fEventID, evtData.fEventID, DataType2Text(iter->fDataType).c_str(), DataType2Text(kAliHLTDataTypeDDLRaw).c_str());
+
+    
+    TString blockorigin("");
+    blockorigin.Insert(0, iter->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize);
+    
+    if (fOrigin.IsNull())
+      {
+       // if origin is not explicitly set by command line, take origin from data block
+       fOrigin=blockorigin;
+       HLTDebug("Origin of current data block set by block itself is %s.", blockorigin.Data());
+      }
+    else
+      {
+       // if set origin is not equal to current block origin, printout warning!
+       if(fOrigin.CompareTo(blockorigin)!=0) {
+         HLTWarning("Origin %s of current data block does not match origin set by command line argument %s.", blockorigin.Data(), fOrigin.Data());
+         continue;
+       }
+      }
+
+    // ** Get DDL ID in order to tell the memory reader which slice/patch to use
+    //fSlice = AliHLTCompDefinitions::GetMinSliceNr( *iter );
+    //fPatch = AliHLTCompDefinitions::GetMinPatchNr( *iter );
+
+    //HLTDebug ( "Input Raw Data - Slice/Patch: %d/%d.", fSlice, fPatch);
+
+    fHuffmanCompressor->SetInputData(iter->fPtr, iter->fSize);
+
+    // only necessary for output in binary file
+    //fHuffmanCompressor->SetSlice(fSlice);
+    //fHuffmanCompressor->SetPatch(fPatch);
+   
+    fHuffmanCompressor->ProcessData();
+  
+    // ** Get next input block, with the same specification as defined in GetFirstInputBlock()
+  } while ( (iter = GetNextInputBlock()) != NULL );
+
+  // ** Get output specification
+  // commented out for the moment to read spec in from command line argument
+  //fSpecification = AliHLTCompDefinitions::EncodeDataSpecification( fSlice, fSlice, fPatch, fPatch );
+  //fSpecification = fSlice<<24 | fSlice<<16 | fPatch<<8 | fPatch;
+
+  // ** PushBack data to shared memory ... 
+
+  // DATA TYE to DEFINE !!! XXXX
+  PushBack( (TObject*) fHuffmanData, AliHLTCompDefinitions::fgkHuffmanAltroCalDataType|fOrigin.Data(), fSpecification);
+  return 0;
+} // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
+
+
+Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
+  // see header file for class documentation
+
+  // create code from training table
+  fHuffmanCompressor->CreateCodeTable();
+
+  // write code table and occurrence table to HuffmanData instance
+  fHuffmanCompressor->SetHuffmanData(fHuffmanData);
+
+  TString rootfilename;
+  if(fTablePath.IsNull() )
+    {
+      // if there is no explicit table path, take current path
+      rootfilename.Form("calib_huffmanData_%s_%08X_%08X.root", fOrigin.Data(), fRunNumber, fSpecification);      
+    }
+  else
+    {
+      rootfilename.Form("%scalib_huffmanData_%s_%08X_%08X.root", fTablePath.Data(), fOrigin.Data(), fRunNumber, fSpecification);
+    }
+  TFile* huffmanrootfile = new TFile(rootfilename, "RECREATE");
+  huffmanrootfile->WriteObject(fHuffmanData,"HuffmanData");
+  huffmanrootfile->Write();
+  huffmanrootfile->Close();
+
+  // ** PushBack data to FXS ...
+
+  PushToFXS( (TObject*) fHuffmanData, "TPC", "HuffmanData" ) ;
+  
+  return 0;
+} // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
diff --git a/HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.h b/HLT/comp/AliHLTCOMPHuffmanAltroCalibComponent.h
new file mode 100644 (file)
index 0000000..27adda8
--- /dev/null
@@ -0,0 +1,123 @@
+//-*- Mode: C++ -*-
+#ifndef ALIHLTCOMPHUFFMANALTROCALIBCOMPONENT_H
+#define ALIHLTCOMPHUFFMANALTROCALIBCOMPONENT_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTCOMPHuffmanAltroCalibComponent.h
+    @author Jochen Thaeder
+    @author extended by Jenny Wagner
+    @date   20-11-2007
+    @brief  A calibration component for the Huffman code creator 
+*/
+
+#include "AliHLTCalibrationProcessor.h"
+
+class AliHLTCOMPHuffmanAltro;
+class AliHLTCOMPHuffmanData;
+
+/**
+ * @class AliHLTCOMPHuffmanAltroCalibComponent
+ * Component ID: \b HuffmanAltroCalibComponent <br>
+ * Library: \b libAliHLTComp
+ * This class is the calibration component for the AliTPCCalibHuffmanAltro class 
+ * used for calibration of the Huffman code table (which is created here). 
+ *
+ * Mandatory arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
+ * \li -origin <i> detector <\i> <br>
+ *  set origin of data for code creation to specify output table (parameter transient)
+ * \li -runnumber <i> decimal number <\i> <br>
+ *  set runnumber to specify output table (parameter transient)
+ * \li -dataspec <i> 0xYYXXaabb <\i> <br>
+ *  set usual HLT dataspec (last slice, first slice, last patch, first patch)_Hexadezimal to specify output table
+ * \li -trailerwords <i> decimal number <\i> <br>
+ *  set number of trailerwords of incoming data (ranging from 1 to 3)
+ *
+ * Optional arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
+ * \li -tablepath <i> path to Huffman code table <\i> <br>
+ *  set path to out put Huffman code table as root file, if no path is given, output path is set to current path (parameter transient)
+ *
+ * It inherits from the @ref AliHLTCalibrationProcessor and uses the high-level 
+ * interface. The output is the class @ref HuffmanData as a TObject which is written to the data base
+ *
+ * @ingroup alihlt_comp
+ */
+class AliHLTCOMPHuffmanAltroCalibComponent : public AliHLTCalibrationProcessor
+    {
+    public:
+      /** constructor */
+      AliHLTCOMPHuffmanAltroCalibComponent();
+      
+      /** destructor */
+      virtual ~AliHLTCOMPHuffmanAltroCalibComponent();
+      
+      // Public functions to implement AliHLTComponent's interface.
+      // These functions are required for the registration process
+
+      const char* GetComponentID();
+      void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+      AliHLTComponentDataType GetOutputDataType();
+      virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+      AliHLTComponent* Spawn();
+
+    protected:
+      
+      // Protected functions to implement AliHLTComponent's interface.
+      // These functions provide initialization as well as the actual processing
+      // capabilities of the component. 
+      
+      /** Initialize the calibration component. */
+      Int_t InitCalibration();
+
+      /** Scan commandline arguments of the calibration component. */
+      Int_t ScanArgument( Int_t argc, const char** argv );
+
+      /** DeInitialize the calibration component. */
+      Int_t DeinitCalibration();
+
+      /** Process the data in the calibration component. */
+      Int_t ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
+
+      /** Ship the data to the FXS at end of run or eventmodulo. */
+      Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
+
+    private:
+
+      /** copy constructor prohibited */
+      AliHLTCOMPHuffmanAltroCalibComponent(const AliHLTCOMPHuffmanAltroCalibComponent&);
+
+      /** assignment operator prohibited */
+      AliHLTCOMPHuffmanAltroCalibComponent& operator=(const AliHLTCOMPHuffmanAltroCalibComponent&);
+
+      /** Huffman compressor class */
+      AliHLTCOMPHuffmanAltro * fHuffmanCompressor; //! instance of Huffman Compressor in this component
+      
+      /** pointer to output Huffman code table and occurrence table (togehter in this class) */
+      AliHLTCOMPHuffmanData * fHuffmanData;            //! instance of output (Huffman Data, containing code table)
+
+      /** The Specification for this component */
+      /** explicit specification of the origin of the data (transient) */
+      TString fOrigin;                      // input line argument to determine origin for Huffman table
+                                           // -> no input --> default taken from incoming data
+      /** explicit specification of the run number */
+      AliHLTUInt64_t fRunNumber;           // input line argument to determine run number for Huffman table
+
+      /** specifications of the data */
+      AliHLTUInt64_t fSpecification;      // see above
+
+      /** explicit path to Huffman code table which will be put out */
+      TString fTablePath;                 // input line argument to determine path for Huffman table
+                                          // -> no input --> default set to current path name
+      //AliHLTUInt8_t fSlice;             // slice 
+      //AliHLTUInt8_t fPatch;            // patch   
+
+      /** number of NRCU trailer words of input data */
+      Int_t fNRCUTrailerWords;          // see above
+
+      ClassDef(AliHLTCOMPHuffmanAltroCalibComponent, 0)
+
+    };
+#endif
diff --git a/HLT/comp/AliHLTCOMPHuffmanAltroComponent.cxx b/HLT/comp/AliHLTCOMPHuffmanAltroComponent.cxx
new file mode 100644 (file)
index 0000000..c163898
--- /dev/null
@@ -0,0 +1,424 @@
+// $Id$
+
+/**************************************************************************
+ * 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   AliHLTCOMPHuffmanAltroComponent.cxx
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  The Huffman compressor component.
+*/
+
+#if __GNUC__>= 3
+using namespace std;
+#endif
+
+#include "AliHLTCOMPHuffmanAltroComponent.h"
+#include "AliHLTCOMPHuffmanAltro.h"
+#include "AliHLTCOMPHuffmanData.h"
+#include "AliHLTCompDefinitions.h"
+#include "AliHLTStdIncludes.h"
+#include "TFile.h"
+
+ClassImp(AliHLTCOMPHuffmanAltroComponent)
+
+/* constructur with arguments */
+AliHLTCOMPHuffmanAltroComponent::AliHLTCOMPHuffmanAltroComponent(bool compression)
+  :
+  fHuffmanCompressor(NULL),
+  fCompressionSwitch(compression),
+  fTrainingMode(kFALSE),
+  fHuffmanData(NULL),
+  fOrigin(kAliHLTVoidDataOrigin),
+  fRunNumber(0),
+  fDataSpec(0),
+  fTablePath(),
+  fNrcuTrailerwords(0)
+{
+   // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTCOMPHuffmanAltroComponent::~AliHLTCOMPHuffmanAltroComponent()
+{
+  // see header file for class documentation
+}
+
+// Public functions to implement AliHLTComponent's interface.
+// These functions are required for the registration process
+
+const char* AliHLTCOMPHuffmanAltroComponent::GetComponentID()
+{
+  // see header file for class documentation
+  if(fCompressionSwitch)
+    {
+      return "COMPHuffmanCompressor";
+    }
+  else
+    {
+      return "COMPHuffmanDecompressor";
+    }
+}
+
+void AliHLTCOMPHuffmanAltroComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+{
+  // see header file for class documentation
+  // initialise list
+  list.clear(); 
+
+  // if compression is to be done, input data is packed raw data
+  // else (decompression): input data is special entropy encoded raw data
+  if (fCompressionSwitch) list.push_back( kAliHLTDataTypeDDLRaw );
+  else list.push_back( AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType);
+  
+}
+
+AliHLTComponentDataType AliHLTCOMPHuffmanAltroComponent::GetOutputDataType()
+{
+  // see header file for class documentation
+  // if compression is to be one, output data is special entropy encoded raw data
+  // else (decompression): output data is packed raw data
+  AliHLTComponentDataType dt=kAliHLTDataTypeDDLRaw;
+  if(fCompressionSwitch)
+    dt=AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType;
+  if (!fOrigin.IsNull()) SetDataType(dt, NULL, fOrigin.Data());
+  return dt;
+}
+
+void AliHLTCOMPHuffmanAltroComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
+{
+  // see header file for class documentation
+  // reserved outputsize = inputside * inputMultiplier
+  constBase = 0;
+  if (fCompressionSwitch == kFALSE)
+    {
+      // for decompression: compressed * 4 = (enough space for) decompressed
+      inputMultiplier = 4.0 ;
+    }
+  else
+    {
+      // for compression: original * 1 = (enough space for) compressed
+      inputMultiplier = 1.0;
+    }
+}
+
+AliHLTComponent* AliHLTCOMPHuffmanAltroComponent::Spawn()
+{
+  // see header file for class documentation
+  return new AliHLTCOMPHuffmanAltroComponent(fCompressionSwitch);
+}
+
+
+int AliHLTCOMPHuffmanAltroComponent::DoInit( int argc, const char** argv )
+{
+  
+  // see header file for class documentation
+  
+  if ( fHuffmanCompressor )
+    return EINPROGRESS;
+  
+  
+  Int_t i = 0;
+  Char_t* cpErr;
+  
+  while ( i < argc ) 
+    {     
+      // -- training mode wrongly called here
+      if ( !strcmp( argv[i], "-training" ) ) 
+       {
+         fTrainingMode = kTRUE;
+         
+         HLTInfo("HuffmanCompressor called in training mode, please call HuffmanCalibration instead.");
+
+         return EINVAL;
+       }
+      
+      // mode option: compress or decompress
+      //  if ( !strcmp( argv[i], "-compress" ) ) 
+      //       {
+      //         fCompressionSwitch = kTRUE;
+
+      //  ++i;
+      //  continue;
+         //}
+    
+      //if(!strcmp( argv[i], "-decompress" ) ) 
+      //       {
+      //         fCompressionSwitch = kFALSE;
+         
+      //         ++i;
+      //  continue;
+      //       }
+   
+      // -- argument to load correct code table for respective data specifications (origin, runnumber, specification)
+      if ( !strcmp( argv[i], "-origin" ) ) 
+       {
+        
+         if ( argc <= i+1 ) 
+           {
+             HLTError("Missing data origin specification");
+             return ENOTSUP;
+           }
+
+         // get data origin (TPC, PHOS, ITS...)
+         fOrigin=argv[i+1];
+
+         HLTDebug("Origin is set to %s.", fOrigin.Data());
+         
+         // validation checker
+         
+         i += 2;
+         continue;
+       }
+
+      // -- get run number specification
+      if ( !strcmp( argv[i], "-runnumber" ) ) 
+       {
+         if ( argc <= i+1 ) 
+           {
+             HLTError("Missing run number specification");
+             return ENOTSUP;
+           }
+
+         // get run number
+         const char* runnumber = argv[i+1];
+         
+         fRunNumber =  atoi(runnumber);
+
+         HLTDebug("Run number set to %d (Dec) = %X (Hex).", fRunNumber, fRunNumber);
+         
+         // validation check of run number?!
+
+         i += 2;
+         continue;
+       }
+
+
+      // -- get data specification (e.g. TPC: slice and patch information contained in "dataspec")
+      if ( !strcmp( argv[i], "-dataspec" ) ) 
+       {
+         if ( argc <= i+1 ) 
+           {
+             HLTError("Missing data specification");
+             return ENOTSUP;
+           }
+
+         // get data spec
+         fDataSpec = strtoul(argv[i+1], NULL, 16);
+
+         HLTDebug("Dataspecification set to %d (Dec) = %08X (Hex).", fDataSpec, fDataSpec);
+         
+         // validation check of specification?!
+
+         i += 2;
+         continue;
+       }
+
+      // -- get tablepathname (e.g. ../HLT-data/)
+      if ( !strcmp( argv[i], "-tablepath" ) ) 
+       {
+         if ( argc <= i+1 ) 
+           {
+             HLTDebug("Missing table path argument.");
+           }
+
+         // get data spec
+         fTablePath=argv[i+1];
+
+         HLTDebug("Table path set to %s.", fTablePath.Data());
+         
+         // validation check of specification?!
+
+         i += 2;
+         continue;
+       }
+
+      // -- number of trailerwords: from 1 to 3
+      if ( !strcmp( argv[i], "-trailerwords" ) ) 
+       {
+         if ( argc <= i+1 ) 
+           {
+             HLTError("Missing trailerword specification");
+             return ENOTSUP;
+           }
+         
+         if ( !strcmp( argv[i+1], "1" ) ) 
+             fNrcuTrailerwords = 1;
+         else if ( !strcmp( argv[i+1], "2" ) ) 
+           fNrcuTrailerwords = 2; 
+         else if ( !strcmp( argv[i+1], "3" ) ) 
+           fNrcuTrailerwords = 3; 
+         else
+           {
+             HLTError("Missing number of trailerwords, cannot accept argument '%s'.", argv[i+1] );
+             
+             return EINVAL;
+           }   
+         
+         i += 2;
+         continue;
+       }
+            
+      HLTError("Unknown Option '%s'", argv[i] );
+      return EINVAL;
+    } // end while-loop
+  
+  // load HuffmanData from root-file to acquire translation table
+  fHuffmanData = new AliHLTCOMPHuffmanData();
+
+  TString rootfilename;
+  if(fTablePath.IsNull())
+    {
+      // if no table path is explicity set, take current path as table path
+      rootfilename.Form("huffmanData_%s_%08X_%08X.root", fOrigin.Data(), fRunNumber, fDataSpec);   
+    }
+  else
+    {
+      rootfilename.Form("%shuffmanData_%s_%08X_%08X.root", fTablePath.Data(), fOrigin.Data(), fRunNumber, fDataSpec);
+    }
+
+  TFile* huffmancodefile = new TFile(rootfilename, "READ");
+  
+  if(huffmancodefile->IsZombie())
+  { 
+    HLTFatal("No Huffman code table available for %s.", rootfilename.Data());
+      return EINVAL;
+    }    
+  fHuffmanData = (AliHLTCOMPHuffmanData*) huffmancodefile->Get("HuffmanData");
+
+  // create a new Huffman compressor 
+  fHuffmanCompressor = new AliHLTCOMPHuffmanAltro(fCompressionSwitch, kFALSE, NULL, fNrcuTrailerwords);
+  
+  // get translation table for pure encoding and decoding from HuffmanData
+  fHuffmanCompressor->GetTranslationTable(fHuffmanData);
+    
+  return 0;
+}
+
+int AliHLTCOMPHuffmanAltroComponent::DoDeinit()
+{
+
+  // see header file for class documentation
+  if (fHuffmanCompressor) 
+    delete fHuffmanCompressor;
+  fHuffmanCompressor = NULL;
+
+  if ( fHuffmanData )
+    delete fHuffmanData; 
+  fHuffmanData = NULL;
+  
+  return 0;
+}
+
+int AliHLTCOMPHuffmanAltroComponent::DoEvent( const AliHLTComponentEventData& evtData, 
+                                             const AliHLTComponentBlockData* blocks, 
+                                             AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                                             AliHLTUInt32_t& size, 
+                                             vector<AliHLTComponentBlockData>& outputBlocks )
+{
+  // see header file for class documentation
+  
+  //  == init iter (pointer to datablock)
+  const AliHLTComponentBlockData* iter = NULL;
+  unsigned long ndx;
+  
+  //  == OUTdatatype pointer
+  //    AliHLTTPCClusterData* outPtr;
+  
+  AliHLTUInt8_t* outBPtr;
+  UInt_t offset, mysize, tSize = 0;
+  
+  outBPtr = outputPtr;
+  //    outPtr = (AliHLTTPCClusterData*)outBPtr;
+  
+  
+  for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+    {
+      iter = blocks+ndx;
+      mysize = 0;
+      offset = tSize;
+      
+      if(fCompressionSwitch) // show selected mode
+       {
+         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",evtData.fEventID, evtData.fEventID, 
+                  DataType2Text(iter->fDataType).c_str(), DataType2Text(kAliHLTDataTypeDDLRaw).c_str());
+
+         // check if current block has correct data format
+         // if not, take next block
+         if ( iter->fDataType != (kAliHLTDataTypeDDLRaw|fOrigin.Data()) ) continue;
+       }
+      else
+       {
+         HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",evtData.fEventID, evtData.fEventID,
+                  DataType2Text(iter->fDataType).c_str(), DataType2Text(AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType).c_str());
+
+         // check if current block has correct data format
+         // if not, take next block
+         if ( iter->fDataType != (AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType|fOrigin.Data()) ) continue;
+       }
+
+      // HLTDebug("HLT::HuffmanCompressor::DoEvent", "Event received", "Starting to process data");
+
+      fHuffmanCompressor->SetInputData(iter->fPtr, iter->fSize);
+
+      // validation test
+      // HLTDebug("input data pointer (HEX) = %x ", iter->fPtr);
+      // HLTDebug("input data size (bytes) = %i ", iter->fSize);
+      
+      fHuffmanCompressor->SetOutputData(outBPtr, size);
+      
+      // validation test
+      // HLTDebug("output data pointer (HEX) = %x ", outBPtr);
+      // HLTDebug("reserved output data size (bytes) = %i ", size);
+      
+      fHuffmanCompressor->ProcessData();
+      
+      //       outPtr = (AliHLTTPCClusterData*)outBPtr;
+      
+      mysize = fHuffmanCompressor->GetOutputDataSize();
+      
+      if(mysize != 0)
+       {
+         AliHLTComponentBlockData bd;
+         FillBlockData( bd );
+         bd.fOffset = offset;
+         bd.fSize = mysize;
+         bd.fSpecification = iter->fSpecification;
+         //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
+         outputBlocks.push_back( bd );
+           
+         tSize += mysize;
+           outBPtr += mysize;
+           //outPtr = (AliHLTTPCClusterData*)outBPtr;
+           
+           if ( tSize > size )
+             {
+               HLTFatal("HLT::TPCHuffmanCompressor::DoEvent: Too much data, data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",tSize, size );
+               return EMSGSIZE;
+             }
+           
+       } // end of output-block-generation
+      
+    }
+  
+  size = tSize;
+
+  return 0;   
+}
+   
diff --git a/HLT/comp/AliHLTCOMPHuffmanAltroComponent.h b/HLT/comp/AliHLTCOMPHuffmanAltroComponent.h
new file mode 100644 (file)
index 0000000..0f7473f
--- /dev/null
@@ -0,0 +1,111 @@
+// @(#) $Id$
+
+#ifndef ALIHLTCOMPHUFFMANALTROCOMPONENT_H
+#define ALIHLTCOMPHUFFMANALTROCOMPONENT_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/** @file   AliHLTCOMPHuffmanAltroComponent.h
+    @author Jenny Wagner
+    @date   20-11-2007
+    @brief  The Huffman compressor component.
+*/
+
+#include "AliHLTProcessor.h"
+
+class AliHLTCOMPHuffmanAltro;
+class AliHLTCOMPHuffmanData;
+
+/**
+ * @class AliHLTCOMPHuffmanAltroComponent
+ * Implementation of the Huffman compressor component.
+ * The component implements the interface methods of the @ref AliHLTProcessor.
+ * The actual Huffman compression and decompression algorithms are implemented in @ref AliHLTCOMPHuffmanAltro.
+ * The component can handle compressed and decompressed data of different formats.
+ * Two components are registered, the HuffmanCompressor and the HuffmanDecompressor.
+ * Component ID: \b COMPHuffmanCompressor, COMPHuffmanCompressor <br>
+ * Library: \b libAliHLTComp
+ * 
+ * Mandatory arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
+ * \li -origin <i> detector <\i> <br>
+ *  set origin of data to specify Huffman code table to be read in (parameter transient)
+ * \li -runnumber <i> decimal number <\i> <br>
+ *  set runnumber to specify Huffman code table to be read in (parameter transient)
+ * \li -dataspec <i> 0xYYXXaabb <\i> <br>
+ *  set usual HLT dataspec (last slice, first slice, last patch, first patch)_Hexadezimal to specify Huffman code table to be read in
+ * \li -trailerwords <i> decimal number <\i> <br>
+ *  set number of trailerwords of incoming data (ranging from 1 to 3)
+ *
+ * Optional arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formating -->
+ * \li -tablepath <i> path to Huffman code table <\i> <br>
+ *  set path to read Huffman code table from root file, if no path is given, path is set to current path (parameter transient)
+ *
+ * @ingroup alihlt_comp
+ */
+class AliHLTCOMPHuffmanAltroComponent : public AliHLTProcessor {
+ public:
+  /**
+   * constructor 
+   * @param compression    whether to use the compressor or decompressor 
+   **/
+  AliHLTCOMPHuffmanAltroComponent(bool compression);
+  /** destructor */
+  virtual ~AliHLTCOMPHuffmanAltroComponent();
+  
+  // Public functions to implement AliHLTComponent's interface.
+  // These functions are required for the registration process
+  
+  const char* GetComponentID();
+  void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
+  AliHLTComponentDataType GetOutputDataType();
+  virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
+  AliHLTComponent* Spawn();
+  
+  
+ protected:
+  
+  // Protected functions to implement AliHLTComponent's interface.
+  // These functions provide initialization as well as the actual processing
+  // capabilities of the component. 
+  
+  int DoInit( int argc, const char** argv );
+  int DoDeinit();
+  int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+              AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+              AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );
+  
+ private:
+  /** copy constructor prohibited */
+  AliHLTCOMPHuffmanAltroComponent(const AliHLTCOMPHuffmanAltroComponent&);
+  /** assignment operator prohibited */
+  AliHLTCOMPHuffmanAltroComponent& operator=(const AliHLTCOMPHuffmanAltroComponent&);
+
+  /** the entropy encoder object */
+  AliHLTCOMPHuffmanAltro* fHuffmanCompressor;        // instance of Huffman compressor component   
+  /** bool to decide whether to compress (TRUE) or to decompress (FALSE)  */                            
+  Bool_t fCompressionSwitch;                         // mode choice for compressor instance from input line arguments
+  /** pointer to Huffman code table for read in */
+  AliHLTCOMPHuffmanData* fHuffmanData;               // instance of Huffman Data containing the code table
+  /** bool to decide wheter to calibrate (create a new code table) (TRUE) or to (de)compress data (FALSE) */
+  Bool_t fTrainingMode;                              // mode choice for training instance from input line arguments
+  /** number of NRCU trailer words of incoming data */
+  Int_t fNrcuTrailerwords;                           // number of rcu trailer words
+
+  /** specification of origin of input data to load correct Huffman code table */
+  TString fOrigin;   // gets input line argument to specify the origin of the Huffman table
+  /** specification of run number to load correct Huffman code table */
+  AliHLTUInt64_t fRunNumber;                           // gets input line argument to specify run type of Huffman Table
+  /** data specifications (0xYYXXaabb) to load correct Huffman code table */
+  AliHLTUInt64_t fDataSpec;                            // gets input line argument to specify the data of the Huffman table
+  /** path to load Huffman code table from (if not explicitly given, table is taken from current path) */
+  TString fTablePath;                                  // gets explicit path for Huffman table from command line
+  
+  //AliHLTUInt8_t fSlice;  // determine slice number from input event block
+  //AliHLTUInt8_t fPatch;  // determine patch number from input event bloc
+  
+  ClassDef(AliHLTCOMPHuffmanAltroComponent, 0)
+    };
+#endif
diff --git a/HLT/comp/AliHLTCOMPHuffmanCodeData.cxx b/HLT/comp/AliHLTCOMPHuffmanCodeData.cxx
new file mode 100644 (file)
index 0000000..d26af05
--- /dev/null
@@ -0,0 +1,65 @@
+//-*- Mode: C++ -*-
+/**************************************************************************
+ * 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   ALIHLTCOMPHuffmanCodeData.cxx
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  Data class for the Huffman code table of 10-bit-ADC-values
+*/
+
+#include "AliHLTCOMPHuffmanCodeData.h"
+#include "AliHLTStdIncludes.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
+
+
+ClassImp(AliHLTCOMPHuffmanCodeData)
+
+/** construction without any arguments (used for isolated tests) */
+AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCodeData()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+/** HuffmanCodeData destructor  */
+AliHLTCOMPHuffmanCodeData::~AliHLTCOMPHuffmanCodeData()
+{
+  /* destructor, see header file for class documentation */
+}
+
+void AliHLTCOMPHuffmanCodeData::SetHuffmanCodeData(AliHLTCOMPHuffmanCode_t const& codetableentry)
+{
+  // see header file for class documentation
+  amplitude = codetableentry.amplitude;
+  code = codetableentry.code;
+  validcodelength = codetableentry.validcodelength;
+}
+
+AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* AliHLTCOMPHuffmanCodeData::GetHuffmanCodeData(AliHLTCOMPHuffmanCode_t* codetableentry)
+{
+  // see header file for class documentation
+  codetableentry->amplitude = amplitude;
+  codetableentry->code = code;
+  codetableentry->validcodelength = validcodelength;
+
+  return codetableentry;
+}
diff --git a/HLT/comp/AliHLTCOMPHuffmanCodeData.h b/HLT/comp/AliHLTCOMPHuffmanCodeData.h
new file mode 100644 (file)
index 0000000..1f84997
--- /dev/null
@@ -0,0 +1,76 @@
+//-*- Mode: C++ -*-
+
+#ifndef ALIHLTCOMPHUFFMANCODEDATA_H
+#define ALIHLTCOMPHUFFMANCODEDATA_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   AliHLTCOMPHuffmanCodeData.h
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  Data class containing the Huffman code table of ADV-values
+*/
+
+#include "AliHLTLogging.h"
+#include "AliHLTDataTypes.h"
+
+// typedef for the final HuffmanCodeArray
+/** @class   AliHLTCOMPHuffmanCodeData
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  The Huffman Code Data containing the struture of the Huffman code table 
+*/
+class AliHLTCOMPHuffmanCodeData : public TObject, public AliHLTLogging
+{
+public:
+
+  /** typedef for the structs in Huffman code table */
+  typedef struct AliHLTCOMPHuffmanCode_t
+  {
+    Int_t amplitude;
+    AliHLTUInt64_t code; // maximal possible codelength: 64 bits
+    Int_t validcodelength; // validcodelength needed as code is of variable length!!
+  } AliHLTCOMPHuffmanCode_t;
+  
+  /** standard constructor */
+  AliHLTCOMPHuffmanCodeData();
+
+  /** destructor */
+  virtual ~AliHLTCOMPHuffmanCodeData();
+
+  /** convert Huffman code struct into class instance of HuffmanCodeData */
+  void SetHuffmanCodeData(AliHLTCOMPHuffmanCode_t const& codetableentry);
+
+  /** return Huffman code struct */
+  AliHLTCOMPHuffmanCode_t* GetHuffmanCodeData(AliHLTCOMPHuffmanCode_t* codetableentry);
+
+private:
+
+  /** copy constructor prohibited */
+  AliHLTCOMPHuffmanCodeData(const AliHLTCOMPHuffmanCodeData&);
+
+  /** assignment operator prohibited */
+  AliHLTCOMPHuffmanCodeData& operator=(const AliHLTCOMPHuffmanCodeData&);
+
+  Int_t amplitude;       // 10-bit ADC-value
+  AliHLTUInt64_t code;   // respective Huffman code with maximal possible codelength: 64 bits
+  Int_t validcodelength; // variable to store the respective valid codelength
+  
+  ClassDef(AliHLTCOMPHuffmanCodeData, 1)
+    
+    };
+#endif
+
diff --git a/HLT/comp/AliHLTCOMPHuffmanData.cxx b/HLT/comp/AliHLTCOMPHuffmanData.cxx
new file mode 100644 (file)
index 0000000..040db86
--- /dev/null
@@ -0,0 +1,80 @@
+//-*- Mode: C++ -*-
+/**************************************************************************
+ * 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   ALIHLTCOMPHuffmanData.cxx
+    @author Jenny Wagner
+    @date   29-08-2007
+*/
+
+#include "AliHLTCOMPHuffmanData.h"
+#include "AliHLTStdIncludes.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
+
+ClassImp(AliHLTCOMPHuffmanData)
+
+/** construction without any arguments (used for isolated tests) */
+AliHLTCOMPHuffmanData::AliHLTCOMPHuffmanData()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+/** HuffmanData destructor  */
+AliHLTCOMPHuffmanData::~AliHLTCOMPHuffmanData()
+{
+  /* destructor, see header file for class documentation */
+}
+
+/** get data from OCDB and write them into instance of HuffmanData */
+void AliHLTCOMPHuffmanData::InitHuffmanData(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* occurrencetable, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* codetable)
+{
+  // see header file for class documentation
+  for(Int_t ii = 0; ii < TIMEBINS; ii++)
+    {
+      fOccurrenceTable[ii].SetHuffmanOccurrenceData(occurrencetable[ii]);
+      
+      fCodeTable[ii].SetHuffmanCodeData(codetable[ii]);
+    }
+}
+
+AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* AliHLTCOMPHuffmanData::GetOccurrenceTable(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* occurrencetable) 
+{
+  // see header file for class documentation
+  for (Int_t ii = 0; ii < TIMEBINS; ii++)
+    {
+      fOccurrenceTable[ii].GetHuffmanOccurrenceData(&(occurrencetable[ii]));
+    }
+
+  return occurrencetable;
+  
+}
+
+AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* AliHLTCOMPHuffmanData::GetCodeTable(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* codetable)
+{
+  // see header file for class documentation
+  for (Int_t ii = 0; ii < TIMEBINS; ii++)
+    {
+      fCodeTable[ii].GetHuffmanCodeData(&(codetable[ii]));
+    }
+
+  return codetable;
+}
diff --git a/HLT/comp/AliHLTCOMPHuffmanData.h b/HLT/comp/AliHLTCOMPHuffmanData.h
new file mode 100644 (file)
index 0000000..d0f1e27
--- /dev/null
@@ -0,0 +1,98 @@
+//-*- Mode: C++ -*-
+
+#ifndef ALIHLTCOMPHUFFMANDATA_H
+#define ALIHLTCOMPHUFFMANDATA_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   AliHLTCOMPHuffmanData.h
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  The Huffman Data containing the Huffman code table and the occurrence table of ADV-values
+*/
+
+#include "AliHLTLogging.h"
+#include "AliHLTDataTypes.h"
+#include "AliHLTCOMPHuffmanOccurrenceData.h"
+#include "AliHLTCOMPHuffmanCodeData.h"
+
+// type definitions needed for the Huffman compression
+/** @class   AliHLTCOMPHuffmanData
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  The Huffman Data containing the Huffman code table and the occurrence table of ADC-values
+*/
+
+#define TIMEBINS 1024
+
+class AliHLTCOMPHuffmanData : public TObject, public AliHLTLogging
+{
+public:
+
+  /** typedef for the nodes in the Huffman tree */
+  typedef struct AliHLTCOMPHuffmanTreeData_t
+  {
+    AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t leafcontents;
+    AliHLTCOMPHuffmanTreeData_t* left;
+    AliHLTCOMPHuffmanTreeData_t* right;
+    AliHLTCOMPHuffmanTreeData_t* parent;
+    
+    AliHLTCOMPHuffmanTreeData_t* next;
+    AliHLTCOMPHuffmanTreeData_t* previous;
+   
+  } AliHLTCOMPHuffmanTreeData_t;
+  
+  
+  /** standard constructor */
+  AliHLTCOMPHuffmanData();
+
+  /** destructor */
+  virtual ~AliHLTCOMPHuffmanData();
+
+  /** get data from OCDB (currently from ROOT-file) and write into instance of HuffmanData 
+   * @param occurrencetable   pointer to occurrence table
+   * @param codetable         pointer to Huffman code table
+   */
+  void InitHuffmanData(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* occurrencetable, AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* codetable);
+
+  /** return occurrence table to be used/written somewhere else (intialisation of Huffman Compressor tables)
+   * @param occurrence table  pointer to occurrence table
+   */
+  AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* GetOccurrenceTable(AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* occurrencetable);
+  
+  /** return code table to be used/ written somewhere else (initialisation of the Huffman Compressor tables)
+   * @param codetable   pointer to Huffman code table
+  */
+  AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* GetCodeTable(AliHLTCOMPHuffmanCodeData::AliHLTCOMPHuffmanCode_t* codetable);
+
+private:
+
+  /** copy constructor prohibited */
+  AliHLTCOMPHuffmanData(const AliHLTCOMPHuffmanData&);
+
+  /** assignment operator prohibited */
+  AliHLTCOMPHuffmanData& operator=(const AliHLTCOMPHuffmanData&);
+  
+  /** array of instances of HuffmanOccurrenceData that contains occurrence table */
+  AliHLTCOMPHuffmanOccurrenceData fOccurrenceTable[TIMEBINS]; // occurrence table for all ADC-values
+  /** array of instances of HuffmanCodeData thtat contains complete Huffman code table */
+  AliHLTCOMPHuffmanCodeData fCodeTable[TIMEBINS];             // Huffman translation table for all ADC-values
+    
+  ClassDef(AliHLTCOMPHuffmanData, 1)
+    
+    };
+#endif
+
diff --git a/HLT/comp/AliHLTCOMPHuffmanOccurrenceData.cxx b/HLT/comp/AliHLTCOMPHuffmanOccurrenceData.cxx
new file mode 100644 (file)
index 0000000..679d645
--- /dev/null
@@ -0,0 +1,65 @@
+//-*- Mode: C++ -*-
+/**************************************************************************
+ * 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   ALIHLTCOMPHuffmanOccurrenceData.cxx
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  Data class for the occurrence table of 10-bit-ADC-values
+*/
+
+#include "AliHLTCOMPHuffmanOccurrenceData.h"
+#include "AliHLTStdIncludes.h"
+
+#if __GNUC__ >= 3
+using namespace std;
+#endif
+
+
+ClassImp(AliHLTCOMPHuffmanOccurrenceData)
+
+/** construction without any arguments (used for isolated tests) */
+AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanOccurrenceData()
+{
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+/** HuffmanOccurrenceData destructor  */
+AliHLTCOMPHuffmanOccurrenceData::~AliHLTCOMPHuffmanOccurrenceData()
+{
+  /* destructor, see header file for class documentation */
+}
+
+void AliHLTCOMPHuffmanOccurrenceData::SetHuffmanOccurrenceData(AliHLTCOMPHuffmanData_t const& occurrencetableentry)
+{
+  // see header file for class documentation
+  amplitude = occurrencetableentry.amplitude;
+  abundance = occurrencetableentry.abundance;
+  code = occurrencetableentry.code;
+}
+
+AliHLTCOMPHuffmanOccurrenceData::AliHLTCOMPHuffmanData_t* AliHLTCOMPHuffmanOccurrenceData::GetHuffmanOccurrenceData(AliHLTCOMPHuffmanData_t* occurrencetableentry)
+{
+  // see header file for class documentation
+  occurrencetableentry->amplitude = amplitude;
+  occurrencetableentry->abundance = abundance;
+  occurrencetableentry->code = code;
+
+  return occurrencetableentry;
+}
diff --git a/HLT/comp/AliHLTCOMPHuffmanOccurrenceData.h b/HLT/comp/AliHLTCOMPHuffmanOccurrenceData.h
new file mode 100644 (file)
index 0000000..93d1abe
--- /dev/null
@@ -0,0 +1,79 @@
+//-*- Mode: C++ -*-
+
+#ifndef ALIHLTCOMPHUFFMANOCCURRENCEDATA_H
+#define ALIHLTCOMPHUFFMANOCCURRENCEDATA_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   AliHLTCOMPHuffmanOccurrenceData.h
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  Data class containing the occurrence table of ADC-values
+*/
+
+#include "AliHLTLogging.h"
+#include "AliHLTDataTypes.h"
+
+// type definitions needed for the Huffman compression
+
+/** @class   AliHLTCOMPHuffmanOccurrenceData
+    @author Jenny Wagner
+    @date   29-08-2007
+    @brief  The Huffman Occurrence Data containing the struture of the ADC-value occurrence table 
+*/
+class AliHLTCOMPHuffmanOccurrenceData : public TObject, public AliHLTLogging
+{
+public:
+
+  /** typedef for the array data of occurrence data */
+  typedef struct
+  {
+    Int_t amplitude; 
+    double abundance;
+    Int_t code;
+  } AliHLTCOMPHuffmanData_t;
+  
+  /** standard constructor */
+  AliHLTCOMPHuffmanOccurrenceData();
+
+  /** destructor */
+  virtual ~AliHLTCOMPHuffmanOccurrenceData();
+
+  /** convert one entry of occurrence table into a class instance of HuffmanOccurrenceData */
+  void SetHuffmanOccurrenceData(AliHLTCOMPHuffmanData_t const& occurrencetableentry);
+
+  /** return one entry of occurrence table */
+  AliHLTCOMPHuffmanData_t* GetHuffmanOccurrenceData(AliHLTCOMPHuffmanData_t* occurrencetableentry);
+
+private:
+
+   /** copy constructor prohibited */
+  AliHLTCOMPHuffmanOccurrenceData(const AliHLTCOMPHuffmanOccurrenceData&);
+
+  /** assignment operator prohibited */
+  AliHLTCOMPHuffmanOccurrenceData& operator=(const AliHLTCOMPHuffmanOccurrenceData&);
+
+  /** 10-bit ADC value used for conversion from struct to class */
+  Int_t amplitude;  // 10-bit ADC-value
+  /** occurrence = abundance used for conversion from struct to class */
+  double abundance; // occurrence of one 10-bit ADC-value
+  Int_t code;       // internal variable used for sorting the binary tree (nothing to do with Huffman code!)
+  
+  ClassDef(AliHLTCOMPHuffmanOccurrenceData, 1)
+    
+    };
+#endif
+
index 81b44df..a014042 100644 (file)
@@ -34,7 +34,8 @@
 #include "AliHLTConfiguration.h"
 
 // header files of library components
-// ....
+#include "AliHLTCOMPHuffmanAltroComponent.h"
+#include "AliHLTCOMPHuffmanAltroCalibComponent.h"
 
 /** global instance for agent registration */
 AliHLTCompAgent gAliHLTCompAgent;
@@ -74,6 +75,9 @@ const char* AliHLTCompAgent::GetReconstructionChains(AliRawReader* /*rawReader*/
 const char* AliHLTCompAgent::GetRequiredComponentLibraries() const
 {
   // see header file for class documentation
+
+  // libAliHLTUtil.so for AliRawReaderPublisher
+  //return "libAliHLTUtil.so";
   return NULL;
 }
 
@@ -82,6 +86,11 @@ int AliHLTCompAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
   // see header file for class documentation
   assert(pHandler);
   if (!pHandler) return -EINVAL;
-  //pHandler->AddComponent(new ...);
+  // use fCompressionSwitch = true for decompressed inputtype (i.e. compressed output)
+  pHandler->AddComponent(new AliHLTCOMPHuffmanAltroComponent(true));
+  // use fCompressionSwitch = false for compressed inputtype (i.e. decompressed output)
+  pHandler->AddComponent(new AliHLTCOMPHuffmanAltroComponent(false));
+  pHandler->AddComponent(new AliHLTCOMPHuffmanAltroCalibComponent);
+
   return 0;
 }
diff --git a/HLT/comp/AliHLTCompDefinitions.cxx b/HLT/comp/AliHLTCompDefinitions.cxx
new file mode 100644 (file)
index 0000000..a0a844a
--- /dev/null
@@ -0,0 +1,46 @@
+// $Id$
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ *                                                                        *
+ * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+ *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
+ *                  for The ALICE HLT Project.                            *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// Definitions for the HLT COMP components                                    //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliHLTCompDefinitions.h"
+
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTCompDefinitions)
+
+/*
+general concept for data types is needed: how do we define data types
+across different libraries. Currently, all definitions have data origin
+TPC but this has to change.
+ */
+//const AliHLTComponentDataType AliHLTCompDefinitions::fgkDDLRawDataType = { sizeof(AliHLTComponentDataType),         {'D','D','L','_','R','A','W',' '},kAliHLTDataOriginTPC};;
+const AliHLTComponentDataType AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType = { sizeof(AliHLTComponentDataType), {'E','N','C','_','H','U','F','F'},kAliHLTDataOriginAny};;
+
+//const AliHLTComponentDataType AliHLTCompDefinitions::fgkPackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','P','A','K','E','D'},kAliHLTDataOriginTPC};;
+//const AliHLTComponentDataType AliHLTCompDefinitions::fgkUnpackedRawDataType = { sizeof(AliHLTComponentDataType), {'R','A','W','U','N','P','A','K'},kAliHLTDataOriginTPC};;
+//const AliHLTComponentDataType AliHLTCompDefinitions::fgkClustersDataType = { sizeof(AliHLTComponentDataType), {'C','L','U','S','T','E','R','S'},kAliHLTDataOriginTPC};;
+//const AliHLTComponentDataType AliHLTCompDefinitions::fgkTrackSegmentsDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','K','S','E','G','S'},kAliHLTDataOriginTPC};;
+//const AliHLTComponentDataType AliHLTCompDefinitions::fgkTracksDataType = { sizeof(AliHLTComponentDataType), {'T','R','A','C','K','S',' ',' '},kAliHLTDataOriginTPC};;
+
+const AliHLTComponentDataType AliHLTCompDefinitions::fgkHuffmanAltroCalDataType = { sizeof(AliHLTComponentDataType), {'C','A','L','_','H','U','F','F'},kAliHLTDataOriginAny};;
diff --git a/HLT/comp/AliHLTCompDefinitions.h b/HLT/comp/AliHLTCompDefinitions.h
new file mode 100644 (file)
index 0000000..2b60b87
--- /dev/null
@@ -0,0 +1,43 @@
+// XEmacs -*-C++-*-
+// @(#) $Id$
+
+#ifndef ALIHLTCOMPDEFINITIONS_H
+#define ALIHLTCOMPDEFINITIONS_H
+/* This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
+ * See cxx source for full Copyright notice                               */
+
+/* AliHLTCompDefinitions
+ */
+
+#include "AliHLTDataTypes.h"
+#include "Rtypes.h"
+
+class AliHLTCompDefinitions
+{
+public:
+  AliHLTCompDefinitions() {}
+  virtual ~AliHLTCompDefinitions() {}
+
+//   /** DDL packed RAW data */
+//   static const AliHLTComponentDataType fgkDDLRawDataType;    // see above
+  /** DDL entropy encoded data */
+  static const AliHLTComponentDataType fgkDDLEncodedHuffmanAltroDataType; // see above
+//   /** packed RAW data */
+//   static const AliHLTComponentDataType fgkPackedRawDataType;       // see above
+//   /** unpacked RAW data */
+//   static const AliHLTComponentDataType fgkUnpackedRawDataType;     // see above
+//   /** cluster data */
+//   static const AliHLTComponentDataType fgkClustersDataType;        // see above
+//   /** track segments in local coordinates */
+//   static const AliHLTComponentDataType fgkTrackSegmentsDataType;   // see above
+//   /** tracks in global koordinates */
+//   static const AliHLTComponentDataType fgkTracksDataType;          // see above
+  /** altro huffman compression table */
+  static const AliHLTComponentDataType fgkHuffmanAltroCalDataType; // see above
+
+  ClassDef(AliHLTCompDefinitions, 0);
+
+};
+
+#endif
index 77bec0c..69886a2 100644 (file)
@@ -3,7 +3,14 @@
 
 include $(MODDIR)/hlt.conf
 
-CLASS_HDRS:=   AliHLTCompAgent.h
+CLASS_HDRS:=   AliHLTCompAgent.h \
+               AliHLTCompDefinitions.h \
+               AliHLTCOMPHuffmanAltro.h \
+               AliHLTCOMPHuffmanAltroComponent.h \
+               AliHLTCOMPHuffmanCodeData.h \
+               AliHLTCOMPHuffmanData.h \
+               AliHLTCOMPHuffmanOccurrenceData.h \
+               AliHLTCOMPHuffmanAltroCalibComponent.h
 
 MODULE_SRCS:=  $(CLASS_HDRS:.h=.cxx)
 
@@ -11,7 +18,7 @@ MODULE_HDRS:=         $(CLASS_HDRS)
 
 MODULE_DHDR:=          
 
-EINCLUDE := HLT/BASE
+EINCLUDE := HLT/BASE HLT/TPCLib
 
 ###############################################################################
 #