9ab55b5c4b4fd26ef06304e5581fad9f91962799
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTComponent.cxx
1 // $Id$
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
8  *          for The ALICE Off-line Project.                               *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   AliHLTComponent.cxx
20     @author Matthias Richter, Timm Steinbeck
21     @date   
22     @brief  Base class implementation for HLT components. */
23
24 #if __GNUC__>= 3
25 using namespace std;
26 #endif
27
28 #include "AliHLTStdIncludes.h"
29 #include "AliHLTComponent.h"
30 #include "AliHLTComponentHandler.h"
31 #include "AliHLTMessage.h"
32 #include "TString.h"
33 #include "TObjArray.h"
34 #include "TClass.h"
35
36 /** ROOT macro for the implementation of ROOT specific class methods */
37 ClassImp(AliHLTComponent)
38
39 AliHLTComponent::AliHLTComponent()
40   :
41   fEnvironment(),
42   fCurrentEvent(0),
43   fEventCount(-1),
44   fFailedEvents(0),
45   fCurrentEventData(),
46   fpInputBlocks(NULL),
47   fCurrentInputBlock(-1),
48   fSearchDataType(kAliHLTVoidDataType),
49   fClassName(),
50   fpInputObjects(NULL),
51   fpOutputBuffer(NULL),
52   fOutputBufferSize(0),
53   fOutputBufferFilled(0),
54   fOutputBlocks()
55 {
56   // see header file for class documentation
57   // or
58   // refer to README to build package
59   // or
60   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
61   memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
62   if (fgpComponentHandler)
63     fgpComponentHandler->ScheduleRegister(this);
64   SetLocalLoggingLevel(kHLTLogDefault);
65 }
66
67 AliHLTComponent::AliHLTComponent(const AliHLTComponent&)
68   :
69   AliHLTLogging(),
70   fEnvironment(),
71   fCurrentEvent(0),
72   fEventCount(-1),
73   fFailedEvents(0),
74   fCurrentEventData(),
75   fpInputBlocks(NULL),
76   fCurrentInputBlock(-1),
77   fSearchDataType(kAliHLTVoidDataType),
78   fClassName(),
79   fpInputObjects(NULL),
80   fpOutputBuffer(NULL),
81   fOutputBufferSize(0),
82   fOutputBufferFilled(0),
83   fOutputBlocks()
84 {
85   // see header file for class documentation
86   HLTFatal("copy constructor untested");
87 }
88
89 AliHLTComponent& AliHLTComponent::operator=(const AliHLTComponent&)
90
91   // see header file for class documentation
92   HLTFatal("assignment operator untested");
93   return *this;
94 }
95
96 AliHLTComponent::~AliHLTComponent()
97 {
98   // see header file for function documentation
99   CleanupInputObjects();
100 }
101
102 AliHLTComponentHandler* AliHLTComponent::fgpComponentHandler=NULL;
103
104 int AliHLTComponent::SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite) 
105 {
106   // see header file for function documentation
107   int iResult=0;
108   if (fgpComponentHandler==NULL || bOverwrite!=0)
109     fgpComponentHandler=pCH;
110   else
111     iResult=-EPERM;
112   return iResult;
113 }
114
115 int AliHLTComponent::UnsetGlobalComponentHandler() 
116 {
117   // see header file for function documentation
118   return SetGlobalComponentHandler(NULL,1);
119 }
120
121 int AliHLTComponent::Init( AliHLTComponentEnvironment* environ, void* environParam, int argc, const char** argv )
122 {
123   // see header file for function documentation
124   int iResult=0;
125   if (environ) {
126     memcpy(&fEnvironment, environ, sizeof(AliHLTComponentEnvironment));
127     fEnvironment.fParam=environParam;
128   }
129   const char** pArguments=NULL;
130   int iNofChildArgs=0;
131   TString argument="";
132   int bMissingParam=0;
133   if (argc>0) {
134     pArguments=new const char*[argc];
135     if (pArguments) {
136       for (int i=0; i<argc && iResult>=0; i++) {
137         argument=argv[i];
138         if (argument.IsNull()) continue;
139
140         // benchmark
141         if (argument.CompareTo("benchmark")==0) {
142
143           // loglevel
144         } else if (argument.CompareTo("loglevel")==0) {
145           if ((bMissingParam=(++i>=argc))) break;
146           TString parameter(argv[i]);
147           parameter.Remove(TString::kLeading, ' '); // remove all blanks
148           if (parameter.BeginsWith("0x") &&
149               parameter.Replace(0,2,"",0).IsHex()) {
150             AliHLTComponentLogSeverity loglevel=kHLTLogNone;
151             sscanf(parameter.Data(),"%x", &loglevel);
152             SetLocalLoggingLevel(loglevel);
153           } else {
154             HLTError("wrong parameter for argument %s, hex number expected", argument.Data());
155             iResult=-EINVAL;
156           }
157         } else {
158           pArguments[iNofChildArgs++]=argv[i];
159         }
160       }
161     } else {
162       iResult=-ENOMEM;
163     }
164   }
165   if (bMissingParam) {
166     HLTError("missing parameter for argument %s", argument.Data());
167     iResult=-EINVAL;
168   }
169   if (iResult>=0) {
170     iResult=DoInit(iNofChildArgs, pArguments);
171   }
172   if (iResult>=0) fEventCount=0;
173   if (pArguments) delete [] pArguments;
174   return iResult;
175 }
176
177 int AliHLTComponent::Deinit()
178 {
179   // see header file for function documentation
180   int iResult=0;
181   iResult=DoDeinit();
182   return iResult;
183 }
184
185 int AliHLTComponent::DoInit( int argc, const char** argv )
186 {
187   // see header file for function documentation
188   if (argc==0 && argv==NULL) {
189     // this is currently just to get rid of the warning "unused parameter"
190   }
191   return 0;
192 }
193
194 int AliHLTComponent::DoDeinit()
195 {
196   // see header file for function documentation
197   return 0;
198 }
199
200 void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2] ) const
201 {
202   // see header file for function documentation
203   memset( output, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
204   strncat( output, type.fOrigin, kAliHLTComponentDataTypefOriginSize );
205   strcat( output, ":" );
206   strncat( output, type.fID, kAliHLTComponentDataTypefIDsize );
207 }
208
209 string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type )
210 {
211   // see header file for function documentation
212   string out("");
213   
214   if (type==kAliHLTVoidDataType) {
215     out="VOID:VOID";
216   } else {
217     // some gymnastics in order to avoid a '0' which is part of either or both
218     // ID and origin terminating the whole string. Unfortunately, string doesn't
219     // stop appending at the '0' if the number of elements to append was 
220     // explicitely specified
221     string tmp("");
222     tmp.append(type.fOrigin, kAliHLTComponentDataTypefOriginSize);
223     out.append(tmp.c_str());
224     out.append(":");
225     tmp="";
226     tmp.append(type.fID, kAliHLTComponentDataTypefIDsize);
227     out.append(tmp.c_str());
228   }
229   return out;
230 }
231
232
233 void* AliHLTComponent::AllocMemory( unsigned long size ) 
234 {
235   // see header file for function documentation
236   if (fEnvironment.fAllocMemoryFunc)
237     return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size );
238   HLTFatal("no memory allocation handler registered");
239   return NULL;
240 }
241
242 int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponentBlockData>& blocks, AliHLTUInt32_t* blockCount,
243                                               AliHLTComponentBlockData** outputBlocks ) 
244 {
245   // see header file for function documentation
246     if ( blockCount==NULL || outputBlocks==NULL )
247         return -EFAULT;
248     AliHLTUInt32_t count = blocks.size();
249     if ( !count )
250         {
251         *blockCount = 0;
252         *outputBlocks = NULL;
253         return 0;
254         }
255     *outputBlocks = reinterpret_cast<AliHLTComponentBlockData*>( AllocMemory( sizeof(AliHLTComponentBlockData)*count ) );
256     if ( !*outputBlocks )
257         return -ENOMEM;
258     for ( unsigned long i = 0; i < count; i++ ) {
259         (*outputBlocks)[i] = blocks[i];
260         if (blocks[i].fDataType==kAliHLTAnyDataType) {
261           (*outputBlocks)[i].fDataType=GetOutputDataType();
262           /* data type was set to the output data type by the PubSub AliRoot
263              Wrapper component, if data type of the block was ********:****.
264              Now handled by the component base class in order to have same
265              behavior when running embedded in AliRoot
266           memset((*outputBlocks)[i].fDataType.fID, '*', kAliHLTComponentDataTypefIDsize);
267           memset((*outputBlocks)[i].fDataType.fOrigin, '*', kAliHLTComponentDataTypefOriginSize);
268           */
269         }
270     }
271     *blockCount = count;
272     return 0;
273
274 }
275
276 int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) 
277 {
278   // see header file for function documentation
279   if (fEnvironment.fGetEventDoneDataFunc)
280     return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
281   return -ENOSYS;
282 }
283
284 int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList) 
285 {
286   // see header file for function documentation
287   int iResult=0;
288   if (pConsumer) {
289     vector<AliHLTComponentDataType> ctlist;
290     ((AliHLTComponent*)pConsumer)->GetInputDataTypes(ctlist);
291     vector<AliHLTComponentDataType>::iterator type=ctlist.begin();
292     //AliHLTComponentDataType ouptdt=GetOutputDataType();
293     //PrintDataTypeContent(ouptdt, "publisher \'%s\'");
294     while (type!=ctlist.end() && iResult==0) {
295       //PrintDataTypeContent((*type), "consumer \'%s\'");
296       if ((*type)==GetOutputDataType() ||
297           (*type)==kAliHLTAnyDataType) {
298         if (tgtList) tgtList->push_back(*type);
299         iResult++;
300         // this loop has to be changed in case of multiple output types
301         break;
302       }
303       type++;
304     }
305   } else {
306     iResult=-EINVAL;
307   }
308   return iResult;
309 }
310
311 void AliHLTComponent::PrintDataTypeContent(AliHLTComponentDataType& dt, const char* format) const
312 {
313   const char* fmt="publisher \'%s\'";
314   if (format) fmt=format;
315   HLTMessage(fmt, (DataType2Text(dt)).c_str());
316   HLTMessage("%x %x %x %x %x %x %x %x : %x %x %x %x", 
317              dt.fID[0],
318              dt.fID[1],
319              dt.fID[2],
320              dt.fID[3],
321              dt.fID[4],
322              dt.fID[5],
323              dt.fID[6],
324              dt.fID[7],
325              dt.fOrigin[0],
326              dt.fOrigin[1],
327              dt.fOrigin[2],
328              dt.fOrigin[3]);
329 }
330
331 void AliHLTComponent::FillBlockData( AliHLTComponentBlockData& blockData ) const
332 {
333   // see header file for function documentation
334   blockData.fStructSize = sizeof(blockData);
335   FillShmData( blockData.fShmKey );
336   blockData.fOffset = ~(AliHLTUInt32_t)0;
337   blockData.fPtr = NULL;
338   blockData.fSize = 0;
339   FillDataType( blockData.fDataType );
340   blockData.fSpecification = kAliHLTVoidDataSpec;
341 }
342
343 void AliHLTComponent::FillShmData( AliHLTComponentShmData& shmData ) const
344 {
345   // see header file for function documentation
346   shmData.fStructSize = sizeof(shmData);
347   shmData.fShmType = gkAliHLTComponentInvalidShmType;
348   shmData.fShmID = gkAliHLTComponentInvalidShmID;
349 }
350
351 void AliHLTComponent::FillDataType( AliHLTComponentDataType& dataType ) const
352 {
353   // see header file for function documentation
354   dataType=kAliHLTAnyDataType;
355 }
356
357 void AliHLTComponent::CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt) 
358 {
359   // see header file for function documentation
360   memcpy(&tgtdt.fID[0], &srcdt.fID[0], kAliHLTComponentDataTypefIDsize);
361   memcpy(&tgtdt.fOrigin[0], &srcdt.fOrigin[0], kAliHLTComponentDataTypefOriginSize);
362 }
363
364 void AliHLTComponent::SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin) 
365 {
366   // see header file for function documentation
367   tgtdt.fStructSize = sizeof(AliHLTComponentDataType);
368   memset(&tgtdt.fID[0], 0, kAliHLTComponentDataTypefIDsize);
369   memset(&tgtdt.fOrigin[0], 0, kAliHLTComponentDataTypefOriginSize);
370
371   if ((int)strlen(id)>kAliHLTComponentDataTypefIDsize) {
372     HLTWarning("data type id %s is too long, truncated to %d", id, kAliHLTComponentDataTypefIDsize);
373   }
374   strncpy(&tgtdt.fID[0], id, kAliHLTComponentDataTypefIDsize);
375
376   if ((int)strlen(origin)>kAliHLTComponentDataTypefOriginSize) {
377     HLTWarning("data type origin %s is too long, truncated to %d", origin, kAliHLTComponentDataTypefOriginSize);
378   }
379   strncpy(&tgtdt.fOrigin[0], origin, kAliHLTComponentDataTypefOriginSize);
380 }
381
382 void AliHLTComponent::FillEventData(AliHLTComponentEventData& evtData)
383 {
384   // see header file for function documentation
385   memset(&evtData, 0, sizeof(AliHLTComponentEventData));
386   evtData.fStructSize=sizeof(AliHLTComponentEventData);
387 }
388
389 void AliHLTComponent::PrintComponentDataTypeInfo(const AliHLTComponentDataType& dt) 
390 {
391   // see header file for function documentation
392   TString msg;
393   msg.Form("AliHLTComponentDataType(%d): ID=\"", dt.fStructSize);
394   for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) {
395    if (dt.fID[i]!=0) msg+=dt.fID[i];
396    else msg+="\\0";
397   }
398   msg+="\" Origin=\"";
399   for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) {
400    if (dt.fOrigin[i]!=0) msg+=dt.fOrigin[i];
401    else msg+="\\0";
402   }
403   msg+="\"";
404   AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, msg.Data());
405 }
406
407 int AliHLTComponent::GetEventCount() const
408 {
409   // see header file for function documentation
410   return fEventCount;
411 }
412
413 int AliHLTComponent::IncrementEventCounter()
414 {
415   // see header file for function documentation
416   if (fEventCount>=0) fEventCount++;
417   return fEventCount;
418 }
419
420 int AliHLTComponent::GetNumberOfInputBlocks()
421 {
422   // see header file for function documentation
423   if (fpInputBlocks!=NULL) {
424     return fCurrentEventData.fBlockCnt;
425   }
426   return 0;
427 }
428
429 const TObject* AliHLTComponent::GetFirstInputObject(const AliHLTComponentDataType& dt,
430                                                     const char* classname,
431                                                     int bForce)
432 {
433   // see header file for function documentation
434   fSearchDataType=dt;
435   if (classname) fClassName=classname;
436   else fClassName.clear();
437   int idx=FindInputBlock(fSearchDataType, 0);
438   HLTDebug("found block %d when searching for data type %s", idx, DataType2Text(dt).c_str());
439   TObject* pObj=NULL;
440   if (idx>=0) {
441     if ((pObj=GetInputObject(idx, fClassName.c_str(), bForce))!=NULL) {
442       fCurrentInputBlock=idx;
443     } else {
444     }
445   }
446   return pObj;
447 }
448
449 const TObject* AliHLTComponent::GetFirstInputObject(const char* dtID, 
450                                                     const char* dtOrigin,
451                                                     const char* classname,
452                                                     int         bForce)
453 {
454   // see header file for function documentation
455   AliHLTComponentDataType dt;
456   SetDataType(dt, dtID, dtOrigin);
457   return GetFirstInputObject(dt, classname, bForce);
458 }
459
460 const TObject* AliHLTComponent::GetNextInputObject(int bForce)
461 {
462   // see header file for function documentation
463   int idx=FindInputBlock(fSearchDataType, fCurrentInputBlock+1);
464   //HLTDebug("found block %d when searching for data type %s", idx, DataType2Text(fSearchDataType).c_str());
465   TObject* pObj=NULL;
466   if (idx>=0) {
467     if ((pObj=GetInputObject(idx, fClassName.c_str(), bForce))!=NULL) {
468       fCurrentInputBlock=idx;
469     }
470   }
471   return pObj;
472 }
473
474 int AliHLTComponent::FindInputBlock(const AliHLTComponentDataType& dt, int startIdx)
475 {
476   // see header file for function documentation
477   int iResult=-ENOENT;
478   if (fpInputBlocks!=NULL) {
479     int idx=startIdx<0?0:startIdx;
480     for ( ; (UInt_t)idx<fCurrentEventData.fBlockCnt && iResult==-ENOENT; idx++) {
481       if (dt == kAliHLTAnyDataType || fpInputBlocks[idx].fDataType == dt) {
482         iResult=idx;
483       }
484     }
485   }
486   return iResult;
487 }
488
489 TObject* AliHLTComponent::CreateInputObject(int idx, int bForce)
490 {
491   // see header file for function documentation
492   TObject* pObj=NULL;
493   if (fpInputBlocks!=NULL) {
494     if ((UInt_t)idx<fCurrentEventData.fBlockCnt) {
495       if (fpInputBlocks[idx].fPtr) {
496         AliHLTUInt32_t firstWord=*((AliHLTUInt32_t*)fpInputBlocks[idx].fPtr);
497         if (firstWord==fpInputBlocks[idx].fSize-sizeof(AliHLTUInt32_t)) {
498           HLTDebug("create object from block %d size %d", idx, fpInputBlocks[idx].fSize);
499           AliHLTMessage msg(fpInputBlocks[idx].fPtr, fpInputBlocks[idx].fSize);
500           pObj=msg.ReadObject(msg.GetClass());
501           if (pObj && msg.GetClass()) {
502             HLTDebug("object %p type %s created", pObj, msg.GetClass()->GetName());
503           } else {
504           }
505         } else {
506           //    } else if (bForce!=0) {
507           HLTError("size missmatch: block size %d, indicated %d", fpInputBlocks[idx].fSize, firstWord+sizeof(AliHLTUInt32_t));
508         }
509       } else {
510         HLTFatal("block descriptor empty");
511       }
512     } else {
513       HLTError("index %d out of range %d", idx, fCurrentEventData.fBlockCnt);
514     }
515   } else {
516     HLTError("no input blocks available");
517   }
518   
519   return pObj;
520 }
521
522 TObject* AliHLTComponent::GetInputObject(int idx, const char* classname, int bForce)
523 {
524   // see header file for function documentation
525   if (fpInputObjects==NULL) {
526     fpInputObjects=new TObjArray(fCurrentEventData.fBlockCnt);
527   }
528   TObject* pObj=NULL;
529   if (fpInputObjects) {
530     pObj=fpInputObjects->At(idx);
531     if (pObj==NULL) {
532       pObj=CreateInputObject(idx, bForce);
533       if (pObj) {
534         fpInputObjects->AddAt(pObj, idx);
535       }
536     }
537   } else {
538     HLTFatal("memory allocation failed: TObjArray of size %d", fCurrentEventData.fBlockCnt);
539   }
540   return pObj;
541 }
542
543 int AliHLTComponent::CleanupInputObjects()
544 {
545   if (!fpInputObjects) return 0;
546   TObjArray* array=fpInputObjects;
547   fpInputObjects=NULL;
548   for (int i=0; i<array->GetEntries(); i++) {
549     TObject* pObj=array->At(i);
550     if (pObj) delete pObj;
551   }
552   delete array;
553 }
554
555 AliHLTComponentDataType AliHLTComponent::GetDataType(const TObject* pObject)
556 {
557   // see header file for function documentation
558   AliHLTComponentDataType dt=kAliHLTVoidDataType;
559   int idx=fCurrentInputBlock;
560   if (pObject) {
561     if (fpInputObjects==NULL || (idx=fpInputObjects->IndexOf(pObject))>=0) {
562     } else {
563       HLTError("unknown object %p", pObject);
564     }
565   }
566   if (idx>=0) {
567     if ((UInt_t)idx<fCurrentEventData.fBlockCnt) {
568       dt=fpInputBlocks[idx].fDataType;
569     } else {
570       HLTFatal("severe internal error, index out of range");
571     }
572   }
573   return dt;
574 }
575
576 AliHLTUInt32_t AliHLTComponent::GetSpecification(const TObject* pObject)
577 {
578   // see header file for function documentation
579   AliHLTUInt32_t iSpec=kAliHLTVoidDataSpec;
580   int idx=fCurrentInputBlock;
581   if (pObject) {
582     if (fpInputObjects==NULL || (idx=fpInputObjects->IndexOf(pObject))>=0) {
583     } else {
584       HLTError("unknown object %p", pObject);
585     }
586   }
587   if (idx>=0) {
588     if ((UInt_t)idx<fCurrentEventData.fBlockCnt) {
589       iSpec=fpInputBlocks[idx].fSpecification;
590     } else {
591       HLTFatal("severe internal error, index out of range");
592     }
593   }
594   return iSpec;
595 }
596
597 const AliHLTComponentBlockData* AliHLTComponent::GetFirstInputBlock(const AliHLTComponentDataType& dt)
598 {
599   // see header file for function documentation
600   fSearchDataType=dt;
601   fClassName.clear();
602   int idx=FindInputBlock(fSearchDataType, 0);
603   const AliHLTComponentBlockData* pBlock=NULL;
604   if (idx>=0) {
605     // check for fpInputBlocks pointer done in FindInputBlock
606     pBlock=&fpInputBlocks[idx];
607   }
608   return pBlock;
609 }
610
611 const AliHLTComponentBlockData* AliHLTComponent::GetFirstInputBlock(const char* dtID, 
612                                                                     const char* dtOrigin)
613 {
614   // see header file for function documentation
615   AliHLTComponentDataType dt;
616   SetDataType(dt, dtID, dtOrigin);
617   return GetFirstInputBlock(dt);
618 }
619
620 const AliHLTComponentBlockData* AliHLTComponent::GetNextInputBlock()
621 {
622   // see header file for function documentation
623   int idx=FindInputBlock(fSearchDataType, fCurrentInputBlock+1);
624   const AliHLTComponentBlockData* pBlock=NULL;
625   if (idx>=0) {
626     // check for fpInputBlocks pointer done in FindInputBlock
627     pBlock=&fpInputBlocks[idx];
628   }
629   return pBlock;
630 }
631
632 int AliHLTComponent::FindInputBlock(const AliHLTComponentBlockData* pBlock)
633 {
634   // see header file for function documentation
635   int iResult=-ENOENT;
636   if (fpInputBlocks!=NULL) {
637     if (pBlock) {
638       if (pBlock>=fpInputBlocks && pBlock<fpInputBlocks+fCurrentEventData.fBlockCnt) {
639         iResult=(int)(pBlock-fpInputBlocks);
640       }
641     } else {
642       iResult=-EINVAL;
643     }
644   }
645   return iResult;
646 }
647
648 AliHLTUInt32_t AliHLTComponent::GetSpecification(const AliHLTComponentBlockData* pBlock)
649 {
650   // see header file for function documentation
651   AliHLTUInt32_t iSpec=kAliHLTVoidDataSpec;
652   int idx=fCurrentInputBlock;
653   if (pBlock) {
654     if (fpInputObjects==NULL || (idx=FindInputBlock(pBlock))>=0) {
655     } else {
656       HLTError("unknown Block %p", pBlock);
657     }
658   }
659   if (idx>=0) {
660     // check for fpInputBlocks pointer done in FindInputBlock
661     iSpec=fpInputBlocks[idx].fSpecification;
662   }
663   return iSpec;
664 }
665
666 int AliHLTComponent::PushBack(TObject* pObject, const AliHLTComponentDataType& dt, AliHLTUInt32_t spec)
667 {
668   // see header file for function documentation
669   int iResult=0;
670   if (pObject) {
671     AliHLTMessage msg(kMESS_OBJECT);
672     msg.WriteObject(pObject);
673     Int_t iMsgLength=msg.Length();
674     if (iMsgLength>0) {
675       msg.SetLength(); // sets the length to the first (reserved) word
676       iResult=InsertOutputBlock(msg.Buffer(), iMsgLength, dt, spec);
677       if (iResult>=0) {
678         HLTDebug("object %s (%p) size %d inserted to output", pObject->ClassName(), pObject, iMsgLength);
679       }
680     } else {
681       HLTError("object serialization failed for object %p", pObject);
682       iResult=-ENOMSG;
683     }
684   } else {
685     iResult=-EINVAL;
686   }
687   return iResult;
688 }
689
690 int AliHLTComponent::PushBack(TObject* pObject, const char* dtID, const char* dtOrigin, AliHLTUInt32_t spec)
691 {
692   // see header file for function documentation
693   AliHLTComponentDataType dt;
694   SetDataType(dt, dtID, dtOrigin);
695   return PushBack(pObject, dt, spec);
696 }
697
698 int AliHLTComponent::PushBack(void* pBuffer, int iSize, const AliHLTComponentDataType& dt, AliHLTUInt32_t spec)
699 {
700   // see header file for function documentation
701   return InsertOutputBlock(pBuffer, iSize, dt, spec);
702 }
703
704 int AliHLTComponent::PushBack(void* pBuffer, int iSize, const char* dtID, const char* dtOrigin, AliHLTUInt32_t spec)
705 {
706   // see header file for function documentation
707   AliHLTComponentDataType dt;
708   SetDataType(dt, dtID, dtOrigin);
709   return PushBack(pBuffer, iSize, dt, spec);
710 }
711
712 int AliHLTComponent::InsertOutputBlock(void* pBuffer, int iSize, const AliHLTComponentDataType& dt, AliHLTUInt32_t spec)
713 {
714   // see header file for function documentation
715   int iResult=0;
716   if (pBuffer) {
717     if (fpOutputBuffer && iSize<=(fOutputBufferSize-fOutputBufferFilled)) {
718       AliHLTUInt8_t* pTgt=fpOutputBuffer+fOutputBufferFilled;
719       AliHLTComponentBlockData bd;
720       FillBlockData( bd );
721       bd.fOffset        = fOutputBufferFilled;
722       bd.fPtr           = pTgt;
723       bd.fSize          = iSize;
724       bd.fDataType      = dt;
725       bd.fSpecification = spec;
726       if (pBuffer!=NULL && pBuffer!=pTgt) {
727         memcpy(pTgt, pBuffer, iSize);
728         //AliHLTUInt32_t firstWord=*((AliHLTUInt32_t*)pBuffer); 
729         //HLTDebug("copy %d bytes from %p to output buffer %p, first word %#x", iSize, pBuffer, pTgt, firstWord);
730       }
731       fOutputBufferFilled+=bd.fSize;
732       fOutputBlocks.push_back( bd );
733       //HLTDebug("buffer inserted to output: size %d data type %s spec %#x", iSize, DataType2Text(dt).c_str(), spec);
734     } else {
735       if (fpOutputBuffer) {
736         HLTError("too little space in output buffer: %d, required %d", fOutputBufferSize-fOutputBufferFilled, iSize);
737       } else {
738         HLTError("output buffer not available");
739       }
740       iResult=-ENOSPC;
741     }
742   } else {
743     iResult=-EINVAL;
744   }
745   return iResult;
746 }
747
748 int AliHLTComponent::EstimateObjectSize(TObject* pObject) const
749 {
750   if (!pObject) return -EINVAL;
751     AliHLTMessage msg(kMESS_OBJECT);
752     msg.WriteObject(pObject);
753     return msg.Length();  
754 }
755
756 int AliHLTComponent::CreateEventDoneData(AliHLTComponentEventDoneData edd)
757 {
758   // see header file for function documentation
759   int iResult=-ENOSYS;
760   //#warning  function not yet implemented
761   HLTWarning("function not yet implemented");
762   return iResult;
763 }
764
765 int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
766                                    const AliHLTComponentBlockData* blocks, 
767                                    AliHLTComponentTriggerData& trigData,
768                                    AliHLTUInt8_t* outputPtr, 
769                                    AliHLTUInt32_t& size,
770                                    AliHLTUInt32_t& outputBlockCnt, 
771                                    AliHLTComponentBlockData*& outputBlocks,
772                                    AliHLTComponentEventDoneData*& edd )
773 {
774   // see header file for function documentation
775   int iResult=0;
776   fCurrentEvent=evtData.fEventID;
777   fCurrentEventData=evtData;
778   fpInputBlocks=blocks;
779   fCurrentInputBlock=-1;
780   fSearchDataType=kAliHLTAnyDataType;
781   fpOutputBuffer=outputPtr;
782   fOutputBufferSize=size;
783   fOutputBufferFilled=0;
784   fOutputBlocks.clear();
785   
786   vector<AliHLTComponentBlockData> blockData;
787   iResult=DoProcessing(evtData, blocks, trigData, outputPtr, size, blockData, edd);
788   if (iResult>=0) {
789     if (fOutputBlocks.size()>0) {
790       //HLTDebug("got %d block(s) via high level interface", fOutputBlocks.size());
791       if (blockData.size()>0) {
792         HLTError("low level and high interface must not be mixed; use PushBack methods to insert data blocks");
793         iResult=-EFAULT;
794       } else {
795         iResult=MakeOutputDataBlockList(fOutputBlocks, &outputBlockCnt, &outputBlocks);
796         size=fOutputBufferFilled;
797       }
798     } else {
799       iResult=MakeOutputDataBlockList(blockData, &outputBlockCnt, &outputBlocks);
800     }
801     if (iResult<0) {
802       HLTFatal("component %s (%p): can not convert output block descriptor list", GetComponentID(), this);
803     }
804   }
805   if (iResult<0) {
806     outputBlockCnt=0;
807     outputBlocks=NULL;
808   }
809   CleanupInputObjects();
810   IncrementEventCounter();
811   return iResult;
812 }
813