[u/mrichter/AliRoot.git] / HLT / comp / AliHLTCOMPHuffmanAltroComponent.cxx

// $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),
  fOrigin(kAliHLTVoidDataOrigin),
  fRunNumber(0),
  fDataSpec(0),
  fTablePath(),
  fNrcuTrailerwords(0),
  fHuffmanData(NULL) 
{
   // 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, ...)
	  fOrigin=argv[i+1];

	  while(fOrigin.Length() <  kAliHLTComponentDataTypefOriginSize)
	    {
	      fOrigin.Append(" ");
	    }
     
	  HLTDebug("Origin is set to %s.", fOrigin.Data());
         
	  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|fOrigin.Data()).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|fOrigin.Data()).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;   
}
Commit	Line	Data
c2440081	1	// $Id$
	2
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* All rights reserved. *
	6	* *
	7	* Primary Author: Jenny Wagner (jwagner@cern.ch) *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/** @file AliHLTCOMPHuffmanAltroComponent.cxx
	19	@author Jenny Wagner
	20	@date 29-08-2007
	21	@brief The Huffman compressor component.
	22	*/
	23
	24	#if __GNUC__>= 3
	25	using namespace std;
	26	#endif
	27
	28	#include "AliHLTCOMPHuffmanAltroComponent.h"
	29	#include "AliHLTCOMPHuffmanAltro.h"
	30	#include "AliHLTCOMPHuffmanData.h"
	31	#include "AliHLTCompDefinitions.h"
	32	#include "AliHLTStdIncludes.h"
	33	#include "TFile.h"
	34
	35	ClassImp(AliHLTCOMPHuffmanAltroComponent)
	36
	37	/* constructur with arguments */
	38	AliHLTCOMPHuffmanAltroComponent::AliHLTCOMPHuffmanAltroComponent(bool compression)
	39	:
	40	fHuffmanCompressor(NULL),
	41	fCompressionSwitch(compression),
	42	fTrainingMode(kFALSE),
c2440081	43	fOrigin(kAliHLTVoidDataOrigin),
	44	fRunNumber(0),
	45	fDataSpec(0),
	46	fTablePath(),
f0d05e66	47	fNrcuTrailerwords(0),
f0d05e66	48	fHuffmanData(NULL)
c2440081	49	{
	50	// see header file for class documentation
	51	// or
	52	// refer to README to build package
	53	// or
	54	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	55	}
	56
	57	AliHLTCOMPHuffmanAltroComponent::~AliHLTCOMPHuffmanAltroComponent()
	58	{
	59	// see header file for class documentation
	60	}
	61
	62	// Public functions to implement AliHLTComponent's interface.
	63	// These functions are required for the registration process
	64
	65	const char* AliHLTCOMPHuffmanAltroComponent::GetComponentID()
	66	{
	67	// see header file for class documentation
	68	if(fCompressionSwitch)
	69	{
	70	return "COMPHuffmanCompressor";
	71	}
	72	else
	73	{
	74	return "COMPHuffmanDecompressor";
	75	}
	76	}
	77
	78	void AliHLTCOMPHuffmanAltroComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	79	{
	80	// see header file for class documentation
	81	// initialise list
	82	list.clear();
	83
	84	// if compression is to be done, input data is packed raw data
	85	// else (decompression): input data is special entropy encoded raw data
	86	if (fCompressionSwitch) list.push_back( kAliHLTDataTypeDDLRaw );
	87	else list.push_back( AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType);
	88
	89	}
	90
	91	AliHLTComponentDataType AliHLTCOMPHuffmanAltroComponent::GetOutputDataType()
	92	{
	93	// see header file for class documentation
	94	// if compression is to be one, output data is special entropy encoded raw data
	95	// else (decompression): output data is packed raw data
	96	AliHLTComponentDataType dt=kAliHLTDataTypeDDLRaw;
	97	if(fCompressionSwitch)
	98	dt=AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType;
	99	if (!fOrigin.IsNull()) SetDataType(dt, NULL, fOrigin.Data());
	100	return dt;
	101	}
	102
	103	void AliHLTCOMPHuffmanAltroComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
	104	{
	105	// see header file for class documentation
	106	// reserved outputsize = inputside * inputMultiplier
	107	constBase = 0;
	108	if (fCompressionSwitch == kFALSE)
	109	{
	110	// for decompression: compressed * 4 = (enough space for) decompressed
	111	inputMultiplier = 4.0 ;
	112	}
113	else
114	{
115	// for compression: original * 1 = (enough space for) compressed
116	inputMultiplier = 1.0;
117	}
118	}
119
120	AliHLTComponent* AliHLTCOMPHuffmanAltroComponent::Spawn()
121	{
122	// see header file for class documentation
123	return new AliHLTCOMPHuffmanAltroComponent(fCompressionSwitch);
124	}
125
126
127	int AliHLTCOMPHuffmanAltroComponent::DoInit( int argc, const char** argv )
128	{
129
130	// see header file for class documentation
131
132	if ( fHuffmanCompressor )
133	return EINPROGRESS;
134
135
136	Int_t i = 0;
af2ed151	137	//Char_t* cpErr;
c2440081	138
	139	while ( i < argc )
	140	{
	141	// -- training mode wrongly called here
	142	if ( !strcmp( argv[i], "-training" ) )
	143	{
	144	fTrainingMode = kTRUE;
	145
	146	HLTInfo("HuffmanCompressor called in training mode, please call HuffmanCalibration instead.");
	147
	148	return EINVAL;
	149	}
	150
	151	// mode option: compress or decompress
	152	// if ( !strcmp( argv[i], "-compress" ) )
	153	// {
	154	// fCompressionSwitch = kTRUE;
	155
	156	// ++i;
	157	// continue;
	158	//}
	159
	160	//if(!strcmp( argv[i], "-decompress" ) )
	161	// {
	162	// fCompressionSwitch = kFALSE;
	163
	164	// ++i;
	165	// continue;
	166	// }
	167
	168	// -- argument to load correct code table for respective data specifications (origin, runnumber, specification)
	169	if ( !strcmp( argv[i], "-origin" ) )
	170	{
	171
	172	if ( argc <= i+1 )
	173	{
	174	HLTError("Missing data origin specification");
	175	return ENOTSUP;
	176	}
	177
bf7a3243	178	// get data origin (TPC, PHOS, ...)
c2440081	179	fOrigin=argv[i+1];
c2440081	180
bf7a3243	181	while(fOrigin.Length() < kAliHLTComponentDataTypefOriginSize)
	182	{
	183	fOrigin.Append(" ");
	184	}
	185
c2440081	186	HLTDebug("Origin is set to %s.", fOrigin.Data());
bf7a3243	187
c2440081	188	i += 2;
	189	continue;
	190	}
	191
	192	// -- get run number specification
	193	if ( !strcmp( argv[i], "-runnumber" ) )
	194	{
	195	if ( argc <= i+1 )
	196	{
	197	HLTError("Missing run number specification");
	198	return ENOTSUP;
	199	}
	200
	201	// get run number
	202	const char* runnumber = argv[i+1];
	203
	204	fRunNumber = atoi(runnumber);
	205
	206	HLTDebug("Run number set to %d (Dec) = %X (Hex).", fRunNumber, fRunNumber);
	207
	208	// validation check of run number?!
	209
	210	i += 2;
	211	continue;
	212	}
	213
	214
	215	// -- get data specification (e.g. TPC: slice and patch information contained in "dataspec")
	216	if ( !strcmp( argv[i], "-dataspec" ) )
	217	{
	218	if ( argc <= i+1 )
	219	{
	220	HLTError("Missing data specification");
	221	return ENOTSUP;
	222	}
	223
	224	// get data spec
	225	fDataSpec = strtoul(argv[i+1], NULL, 16);
	226
	227	HLTDebug("Dataspecification set to %d (Dec) = %08X (Hex).", fDataSpec, fDataSpec);
	228
	229	// validation check of specification?!
	230
	231	i += 2;
	232	continue;
	233	}
	234
	235	// -- get tablepathname (e.g. ../HLT-data/)
	236	if ( !strcmp( argv[i], "-tablepath" ) )
	237	{
	238	if ( argc <= i+1 )
	239	{
	240	HLTDebug("Missing table path argument.");
	241	}
	242
	243	// get data spec
	244	fTablePath=argv[i+1];
	245
	246	HLTDebug("Table path set to %s.", fTablePath.Data());
	247
	248	// validation check of specification?!
	249
	250	i += 2;
	251	continue;
252	}
253
254	// -- number of trailerwords: from 1 to 3
255	if ( !strcmp( argv[i], "-trailerwords" ) )
256	{
257	if ( argc <= i+1 )
258	{
259	HLTError("Missing trailerword specification");
260	return ENOTSUP;
261	}
262
263	if ( !strcmp( argv[i+1], "1" ) )
264	fNrcuTrailerwords = 1;
265	else if ( !strcmp( argv[i+1], "2" ) )
266	fNrcuTrailerwords = 2;
267	else if ( !strcmp( argv[i+1], "3" ) )
268	fNrcuTrailerwords = 3;
269	else
270	{
271	HLTError("Missing number of trailerwords, cannot accept argument '%s'.", argv[i+1] );
272
273	return EINVAL;
274	}
275
276	i += 2;
277	continue;
278	}
279
280	HLTError("Unknown Option '%s'", argv[i] );
281	return EINVAL;
282	} // end while-loop
283
284	// load HuffmanData from root-file to acquire translation table
285	fHuffmanData = new AliHLTCOMPHuffmanData();
286
287	TString rootfilename;
288	if(fTablePath.IsNull())
289	{
290	// if no table path is explicity set, take current path as table path
291	rootfilename.Form("huffmanData_%s_%08X_%08X.root", fOrigin.Data(), fRunNumber, fDataSpec);
292	}
293	else
294	{
295	rootfilename.Form("%shuffmanData_%s_%08X_%08X.root", fTablePath.Data(), fOrigin.Data(), fRunNumber, fDataSpec);
296	}
297
298	TFile* huffmancodefile = new TFile(rootfilename, "READ");
299
300	if(huffmancodefile->IsZombie())
301	{
302	HLTFatal("No Huffman code table available for %s.", rootfilename.Data());
303	return EINVAL;
304	}
305	fHuffmanData = (AliHLTCOMPHuffmanData*) huffmancodefile->Get("HuffmanData");
306
307	// create a new Huffman compressor
308	fHuffmanCompressor = new AliHLTCOMPHuffmanAltro(fCompressionSwitch, kFALSE, NULL, fNrcuTrailerwords);
309
310	// get translation table for pure encoding and decoding from HuffmanData
311	fHuffmanCompressor->GetTranslationTable(fHuffmanData);
312
313	return 0;
314	}
315
316	int AliHLTCOMPHuffmanAltroComponent::DoDeinit()
317	{
318
319	// see header file for class documentation
320	if (fHuffmanCompressor)
321	delete fHuffmanCompressor;
322	fHuffmanCompressor = NULL;
323
324	if ( fHuffmanData )
325	delete fHuffmanData;
326	fHuffmanData = NULL;
327
328	return 0;
329	}
330
331	int AliHLTCOMPHuffmanAltroComponent::DoEvent( const AliHLTComponentEventData& evtData,
332	const AliHLTComponentBlockData* blocks,
af2ed151	333	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
c2440081	334	AliHLTUInt32_t& size,
	335	vector<AliHLTComponentBlockData>& outputBlocks )
	336	{
	337	// see header file for class documentation
	338
	339	// == init iter (pointer to datablock)
	340	const AliHLTComponentBlockData* iter = NULL;
	341	unsigned long ndx;
	342
	343	// == OUTdatatype pointer
	344	// AliHLTTPCClusterData* outPtr;
	345
	346	AliHLTUInt8_t* outBPtr;
	347	UInt_t offset, mysize, tSize = 0;
	348
	349	outBPtr = outputPtr;
	350	// outPtr = (AliHLTTPCClusterData*)outBPtr;
	351
	352
	353	for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
	354	{
	355	iter = blocks+ndx;
	356	mysize = 0;
	357	offset = tSize;
	358
	359	if(fCompressionSwitch) // show selected mode
	360	{
	361	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",evtData.fEventID, evtData.fEventID,
bf7a3243	362	DataType2Text(iter->fDataType).c_str(), DataType2Text(kAliHLTDataTypeDDLRaw\|fOrigin.Data()).c_str());
c2440081	363
	364	// check if current block has correct data format
	365	// if not, take next block
	366	if ( iter->fDataType != (kAliHLTDataTypeDDLRaw\|fOrigin.Data()) ) continue;
	367	}
	368	else
	369	{
	370	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",evtData.fEventID, evtData.fEventID,
bf7a3243	371	DataType2Text(iter->fDataType).c_str(), DataType2Text(AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType\|fOrigin.Data()).c_str());
c2440081	372
	373	// check if current block has correct data format
	374	// if not, take next block
	375	if ( iter->fDataType != (AliHLTCompDefinitions::fgkDDLEncodedHuffmanAltroDataType\|fOrigin.Data()) ) continue;
	376	}
	377
	378	// HLTDebug("HLT::HuffmanCompressor::DoEvent", "Event received", "Starting to process data");
	379
	380	fHuffmanCompressor->SetInputData(iter->fPtr, iter->fSize);
	381
	382	// validation test
	383	// HLTDebug("input data pointer (HEX) = %x ", iter->fPtr);
	384	// HLTDebug("input data size (bytes) = %i ", iter->fSize);
	385
	386	fHuffmanCompressor->SetOutputData(outBPtr, size);
	387
	388	// validation test
	389	// HLTDebug("output data pointer (HEX) = %x ", outBPtr);
	390	// HLTDebug("reserved output data size (bytes) = %i ", size);
	391
	392	fHuffmanCompressor->ProcessData();
	393
	394	// outPtr = (AliHLTTPCClusterData*)outBPtr;
	395
	396	mysize = fHuffmanCompressor->GetOutputDataSize();
	397
	398	if(mysize != 0)
	399	{
	400	AliHLTComponentBlockData bd;
	401	FillBlockData( bd );
	402	bd.fOffset = offset;
	403	bd.fSize = mysize;
	404	bd.fSpecification = iter->fSpecification;
	405	//AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
	406	outputBlocks.push_back( bd );
	407
	408	tSize += mysize;
	409	outBPtr += mysize;
	410	//outPtr = (AliHLTTPCClusterData*)outBPtr;
	411
	412	if ( tSize > size )
	413	{
	414	HLTFatal("HLT::TPCHuffmanCompressor::DoEvent: Too much data, data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",tSize, size );
	415	return EMSGSIZE;
	416	}
	417
	418	} // end of output-block-generation
	419
	420	}
	421
	422	size = tSize;
	423
	424	return 0;
	425	}
	426