]>
Commit | Line | Data |
---|---|---|
6666bfe5 | 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 | ||
6666bfe5 | 37 | /** ROOT macro for the implementation of ROOT specific class methods */ |
38 | ClassImp(AliHLTRawReaderPublisherComponent) | |
39 | ||
40 | AliHLTRawReaderPublisherComponent::AliHLTRawReaderPublisherComponent() | |
41 | : | |
0a51d3cf | 42 | fMaxSize(5000000), |
6666bfe5 | 43 | fDetector(), |
44 | fMinEquId(-1), | |
45 | fMaxEquId(-1), | |
46 | fVerbose(kFALSE), | |
0a51d3cf | 47 | fDataType(kAliHLTVoidDataType), |
48 | fSpecification(kAliHLTVoidDataSpec) | |
6666bfe5 | 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 | { | |
f3506ea2 | 70 | // see header file for class documentation |
6666bfe5 | 71 | return fDataType; |
72 | } | |
73 | ||
74 | void AliHLTRawReaderPublisherComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) | |
75 | { | |
f3506ea2 | 76 | // see header file for class documentation |
6666bfe5 | 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 | ||
6666bfe5 | 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 | ||
10ca703e | 173 | if (!fDetector.IsNull()) { |
174 | AliErrorStream() << "option \'-detector\' not implemented" << endl; | |
175 | return -ENOSYS; | |
176 | } | |
177 | ||
6666bfe5 | 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) { | |
6666bfe5 | 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 | int offset=0; | |
210 | AliHLTUInt8_t* pTgt=outputPtr; | |
10ca703e | 211 | assert(outputPtr!=NULL || size==0); |
6666bfe5 | 212 | AliRawReader* pRawReader=GetRawReader(); |
213 | if (pRawReader) { | |
0a51d3cf | 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)); | |
6666bfe5 | 217 | while (pRawReader->ReadHeader() && (iResult>=0 || iResult==-ENOSPC)) { |
0a51d3cf | 218 | const AliRawDataHeader* pHeader=pRawReader->GetDataHeader(); |
219 | assert(pHeader!=NULL); | |
220 | if (pHeader==NULL) continue; | |
221 | int readSize=pRawReader->GetDataSize()+sizeof(AliRawDataHeader); | |
6666bfe5 | 222 | int id=pRawReader->GetEquipmentId(); |
10ca703e | 223 | AliInfo(Form("got header for id %d, size %d", id, readSize)); |
0a51d3cf | 224 | if (fMinEquId>id || fMaxEquId<id) { |
6666bfe5 | 225 | AliError(Form("id %d returned from RawReader is outside range [%d,%d]", id, fMinEquId, fMaxEquId)); |
226 | continue; | |
227 | } | |
0a51d3cf | 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)); | |
6666bfe5 | 234 | iResult=-ENODATA; |
235 | break; | |
236 | } | |
0a51d3cf | 237 | pTgt+=readSize-sizeof(AliRawDataHeader); |
6666bfe5 | 238 | } |
0a51d3cf | 239 | } else { |
240 | // we keep the loop going in order to collect the full size | |
241 | fMaxSize=offset+readSize; | |
242 | iResult=-ENOSPC; | |
6666bfe5 | 243 | } |
244 | if (iResult>=0) { | |
245 | AliHLTComponentBlockData bd; | |
246 | FillBlockData( bd ); | |
247 | bd.fOffset = offset; | |
248 | bd.fSize = readSize; | |
249 | bd.fDataType = fDataType; | |
0a51d3cf | 250 | if (fSpecification == kAliHLTVoidDataSpec) { |
251 | GetSpecificationFromEquipmentId(id, bd.fSpecification); | |
252 | } else { | |
253 | bd.fSpecification=fSpecification; | |
254 | } | |
6666bfe5 | 255 | outputBlocks.push_back( bd ); |
256 | } | |
257 | offset+=readSize; | |
258 | } | |
6666bfe5 | 259 | if (offset<=size) size=offset; |
260 | } else { | |
261 | AliErrorStream() << "RawReader uninitialized" << endl; | |
262 | iResult=-EFAULT; | |
263 | } | |
264 | return iResult; | |
265 | } | |
266 | ||
0a51d3cf | 267 | int AliHLTRawReaderPublisherComponent::GetSpecificationFromEquipmentId(int id, AliHLTUInt32_t& specification) const { |
f3506ea2 | 268 | // see header file for class documentation |
0a51d3cf | 269 | return specification=id; |
6666bfe5 | 270 | } |