coding conventions and compilation warnings
[u/mrichter/AliRoot.git] / HLT / BASE / util / AliHLTRawReaderPublisherComponent.cxx
1 // @(#) $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  for The ALICE HLT 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   AliHLTRawReaderPublisherComponent.cxx
20     @author Matthias Richter
21     @date   
22     @brief  A general tree publisher component for the AliRawReader.
23 */
24
25 // see header file for class documentation
26 // or
27 // refer to README to build package
28 // or
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31 #include "AliHLTRawReaderPublisherComponent.h"
32 #include "AliRawReader.h"
33 #include "AliLog.h"
34 #include <cerrno>
35 #include <cassert>
36
37 /** ROOT macro for the implementation of ROOT specific class methods */
38 ClassImp(AliHLTRawReaderPublisherComponent)
39
40 AliHLTRawReaderPublisherComponent::AliHLTRawReaderPublisherComponent()
41   :
42   fMaxSize(5000000),
43   fDetector(),
44   fMinEquId(-1),
45   fMaxEquId(-1),
46   fVerbose(kFALSE),
47   fDataType(kAliHLTVoidDataType),
48   fSpecification(kAliHLTVoidDataSpec)
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 AliHLTRawReaderPublisherComponent::~AliHLTRawReaderPublisherComponent()
58 {
59   // see header file for class documentation
60 }
61
62 const char* AliHLTRawReaderPublisherComponent::GetComponentID()
63 {
64   // see header file for class documentation
65   return "AliRawReaderPublisher";
66 }
67
68 AliHLTComponentDataType AliHLTRawReaderPublisherComponent::GetOutputDataType()
69 {
70   // see header file for class documentation
71   return fDataType;
72 }
73
74 void AliHLTRawReaderPublisherComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
75 {
76   // see header file for class documentation
77   constBase=fMaxSize;
78   inputMultiplier=1;
79 }
80
81 AliHLTComponent* AliHLTRawReaderPublisherComponent::Spawn()
82 {
83   // see header file for class documentation
84   return new AliHLTRawReaderPublisherComponent;
85 }
86
87 int AliHLTRawReaderPublisherComponent::DoInit( int argc, const char** argv )
88 {
89   // see header file for class documentation
90   int iResult=0;
91
92   // scan arguments
93   TString argument="";
94   int bMissingParam=0;
95   for (int i=0; i<argc && iResult>=0; i++) {
96     argument=argv[i];
97     if (argument.IsNull()) continue;
98
99     // -detector
100     if (argument.CompareTo("-detector")==0) {
101       if ((bMissingParam=(++i>=argc))) break;
102       fDetector=argv[i];
103
104       // -equipmentid, -minid
105     } else if (argument.CompareTo("-equipmentid")==0 ||
106                argument.CompareTo("-minid")==0) {
107       if ((bMissingParam=(++i>=argc))) break;
108       TString parameter(argv[i]);
109       parameter.Remove(TString::kLeading, ' '); // remove all blanks
110       if (parameter.IsDigit()) {
111         fMinEquId=(AliHLTUInt32_t)parameter.Atoi();
112       } else {
113         HLTError("wrong parameter for argument %s, number expected", argument.Data());
114         iResult=-EINVAL;
115       }
116
117       // -maxid
118     } else if (argument.CompareTo("-maxid")==0) {
119       if ((bMissingParam=(++i>=argc))) break;
120       TString parameter(argv[i]);
121       parameter.Remove(TString::kLeading, ' '); // remove all blanks
122       if (parameter.IsDigit()) {
123         fMaxEquId=(AliHLTUInt32_t)parameter.Atoi();
124       } else {
125         HLTError("wrong parameter for argument %s, number expected", argument.Data());
126         iResult=-EINVAL;
127       }
128
129       // -verbose
130     } else if (argument.CompareTo("-verbose")==0) {
131       fVerbose=kTRUE;
132
133       // -datatype
134     } else if (argument.CompareTo("-datatype")==0) {
135       if ((bMissingParam=(++i>=argc))) break;
136       memcpy(&fDataType.fID, argv[i], TMath::Min(kAliHLTComponentDataTypefIDsize, (Int_t)strlen(argv[i])));
137       if ((bMissingParam=(++i>=argc))) break;
138       memcpy(&fDataType.fOrigin, argv[i], TMath::Min(kAliHLTComponentDataTypefOriginSize, (Int_t)strlen(argv[i])));
139
140       // -dataspec
141     } else if (argument.CompareTo("-dataspec")==0) {
142       if ((bMissingParam=(++i>=argc))) break;
143       TString parameter(argv[i]);
144       parameter.Remove(TString::kLeading, ' '); // remove all blanks
145       if (parameter.IsDigit()) {
146         fSpecification=(AliHLTUInt32_t)parameter.Atoi();
147       } else if (parameter.BeginsWith("0x") &&
148                  parameter.Replace(0,2,"",0).IsHex()) {
149         sscanf(parameter.Data(),"%x", &fSpecification);
150       } else {
151         HLTError("wrong parameter for argument %s, number expected", argument.Data());
152         iResult=-EINVAL;
153       }
154     } else {
155       HLTError("unknown argument %s", argument.Data());
156       iResult=-EINVAL;
157     }
158   }
159   if (bMissingParam) {
160     HLTError("missing parameter for argument %s", argument.Data());
161     iResult=-EINVAL;
162   }
163
164   if (iResult<0) return iResult;
165
166   if (fMinEquId>fMaxEquId) fMaxEquId=fMinEquId;
167
168   if (fMinEquId<0) {
169     AliErrorStream() << "equipment id required, use \'-equipmentid\' option" << endl;
170     return -EINVAL;
171   }
172
173   if (!fDetector.IsNull()) {
174     AliErrorStream() << "option \'-detector\' not implemented" << endl;
175     return -ENOSYS;
176   }
177
178   AliHLTUInt32_t dummy;
179   if (fMinEquId!=fMaxEquId && GetSpecificationFromEquipmentId(0, dummy)==-ENOSYS) {
180     AliWarningStream() << "publication of multiple equipment ids needs implementation of a child and function GetSpecificationFromEquipmentId to set correct specifications" << endl;
181     //return -EINVAL;
182   }
183
184   AliRawReader* pRawReader=GetRawReader();
185   if ((pRawReader=GetRawReader())!=NULL) {
186   } else {
187     AliErrorStream() << "RawReader instance needed" << endl;
188     return -EINVAL;
189   }
190
191   return iResult;
192 }
193
194 int AliHLTRawReaderPublisherComponent::DoDeinit()
195 {
196   // see header file for class documentation
197   int iResult=0;
198   return iResult;
199 }
200
201 int AliHLTRawReaderPublisherComponent::GetEvent(const AliHLTComponentEventData& evtData, 
202                                                 AliHLTComponentTriggerData& trigData, 
203                                                 AliHLTUInt8_t* outputPtr, 
204                                                 AliHLTUInt32_t& size, 
205                                                 vector<AliHLTComponentBlockData>& outputBlocks)
206 {
207   // see header file for class documentation
208   int iResult=0;
209   unsigned int offset=0;
210   AliHLTUInt8_t* pTgt=outputPtr;
211   assert(outputPtr!=NULL || size==0);
212   AliRawReader* pRawReader=GetRawReader();
213   if (pRawReader) {
214     pRawReader->Reset();
215     pRawReader->SelectEquipment(-1, fMinEquId, fMaxEquId);
216     AliInfo(Form("get event from RawReader %p equipment id range [%d,%d]", pRawReader, fMinEquId, fMaxEquId));
217     while (pRawReader->ReadHeader() && (iResult>=0 || iResult==-ENOSPC)) {
218       const AliRawDataHeader* pHeader=pRawReader->GetDataHeader();
219       assert(pHeader!=NULL);
220       if (pHeader==NULL) continue;
221       unsigned int readSize=pRawReader->GetDataSize()+sizeof(AliRawDataHeader);
222       int id=pRawReader->GetEquipmentId();
223       AliInfo(Form("got header for id %d, size %d", id, readSize));
224       if (fMinEquId>id || fMaxEquId<id) {
225         AliError(Form("id %d returned from RawReader is outside range [%d,%d]", id, fMinEquId, fMaxEquId));
226         continue;
227       }
228       if (readSize<=size-offset) {
229         memcpy(pTgt, pHeader, sizeof(AliRawDataHeader));
230         pTgt+=sizeof(AliRawDataHeader);
231         if (readSize>0) {
232           if (!pRawReader->ReadNext(pTgt, readSize-sizeof(AliRawDataHeader))) {
233             AliError(Form("error reading %d bytes from RawReader %p", readSize-sizeof(AliRawDataHeader), pRawReader));
234             iResult=-ENODATA;
235             break;
236           }
237           pTgt+=readSize-sizeof(AliRawDataHeader);
238         }
239       } else {
240         // we keep the loop going in order to collect the full size
241         fMaxSize=offset+readSize;
242         iResult=-ENOSPC;
243       }
244       if (iResult>=0) {
245         AliHLTComponentBlockData bd;
246         FillBlockData( bd );
247         bd.fOffset = offset;
248         bd.fSize = readSize;
249         bd.fDataType = fDataType;
250         if (fSpecification == kAliHLTVoidDataSpec) {
251           GetSpecificationFromEquipmentId(id, bd.fSpecification);
252         } else {
253           bd.fSpecification=fSpecification;
254         }
255         outputBlocks.push_back( bd );
256       }
257       offset+=readSize;
258     }
259     if (offset<=size) size=offset;
260   } else {
261     AliErrorStream() << "RawReader uninitialized" << endl;
262     iResult=-EFAULT;
263   }
264   return iResult;
265 }
266
267 int AliHLTRawReaderPublisherComponent::GetSpecificationFromEquipmentId(int id, AliHLTUInt32_t& specification) const {
268   // see header file for class documentation
269   return specification=id;
270 }