Line data Source code
1 : //-*- Mode: C++ -*-
2 : // $Id$
3 :
4 : #ifndef ALIHLTALTROENCODER_H
5 : #define ALIHLTALTROENCODER_H
6 : //* This file is property of and copyright by the ALICE HLT Project *
7 : //* ALICE Experiment at CERN, All rights reserved. *
8 : //* See cxx source for full Copyright notice *
9 :
10 : /** @file AliHLTAltroEncoder.h
11 : @author Matthias Richter
12 : @date
13 : @brief Encoder class for 10/40bit Altro Data format
14 : */
15 :
16 : #include "AliHLTDataTypes.h"
17 : #include "AliHLTLogging.h"
18 : #include <vector>
19 :
20 : #define AliHLTUInt16MAX 0xffff
21 :
22 : class TArrayC;
23 :
24 : /**
25 : * @class AliHLTAltroEncoder
26 : * Encoder of the RCU/Altro data format.
27 : * The class allows to encodes data sets of channel, timebin and signal
28 : * value into the 10bit/40bit Altro format. It works on a provided buffer.
29 : *
30 : * Signal values can be added by using the AddSignal(AliHLTUInt16_t, AliHLTUInt16_t)
31 : * function. It functions works on a 'current channel'. If data is supposed to go into
32 : * a new channel, SetChannel(AliHLTUInt16_t) has to be used.
33 : *
34 : * <pre>
35 : * AliHLTAltroEncoder encoder;
36 : * encoder.SetBuffer(pBuffer, size);
37 : *
38 : * for (channel ...) {
39 : * int channelAddress=...;
40 : * ...
41 : * for (int bunch=0; bunch<nofBunches; bunch++) {
42 : * int bunchLength=...;
43 : * int startTime=...;
44 : * int time=startTime;
45 : * for (; time<startTime+bunchLength; time++) {
46 : * iResult=encoder.AddSignal(signal, time);
47 : * }
48 : * }
49 : *
50 : * encoder.SetChannel(channelAddress);
51 : * }
52 : * </pre>
53 : *
54 : * By default, the encoder provides only the ALTRO data, but not the common
55 : * data header (in AliRoot language AliRawDataHeader) nor the RCU trailer.
56 : * The CDH is 32 bytes long, the first 4 byte contain the data length excluding
57 : * the CDH itsself. The CDH can be set by SetCDH(AliHLTUInt8_t*, int).
58 : *
59 : * The RCU trailer has varying formats, actually the last 4 byte are supposed
60 : * to contain the length of the trailer itsself. The first 4 byte contain the
61 : * number of 40bit ALTRO words. Currently, the RCU firmware adds only one 4 byte
62 : * word, the number of 40bit wirds. The trailer can be set using
63 : * SetRCUTrailer(AliHLTUInt8_t*, int);
64 : *
65 : * When using CDH and Trailer the Finalize() function must be called at the end
66 : * in order to copy the trailer and update the size members correctly.
67 : *
68 : * @ingroup alihlt_rcu
69 : */
70 : class AliHLTAltroEncoder : AliHLTLogging {
71 : public:
72 : /** default constructor */
73 : AliHLTAltroEncoder();
74 : /** constructor */
75 : AliHLTAltroEncoder(AliHLTUInt8_t* pBuffer, int iSize);
76 : /** destructor */
77 : virtual ~AliHLTAltroEncoder();
78 :
79 : /**
80 : * Set the target buffer.
81 : */
82 : int SetBuffer(AliHLTUInt8_t* pBuffer, int iSize);
83 :
84 : /**
85 : * Add a signal value.
86 : * If the timebin is a consecutive timebin, the signal is added to the
87 : * current bunch. If not, the previous bunch is terminated and a new
88 : * one opened.
89 : *
90 : * The first timebins decide whether the order is ascending or descending.
91 : * @param signal 10bit signal value
92 : * @param timebin 10bot time bin value
93 : */
94 : int AddSignal(AliHLTUInt16_t signal, AliHLTUInt16_t timebin);
95 :
96 : /**
97 : * Set and terminate the current channel.
98 : *
99 : * @param hwaddress Hardware address of the channel
100 : */
101 : int SetChannel(AliHLTUInt16_t hwaddress);
102 :
103 : /**
104 : * Add a signal value.
105 : * The function is a combination of ::AddSignal and ::SetChannel.
106 : * All signal of the same channel are added and if a new channel is detected,
107 : * the current one is terminated and a new one created.
108 : *
109 : * @param signal 10bit signal value
110 : * @param timebin 10bot time bin value
111 : * @param hwaddress Hardware address of the channel
112 : * @return number of 10bit words added
113 : */
114 : int AddChannelSignal(AliHLTUInt16_t signal, AliHLTUInt16_t timebin, AliHLTUInt16_t hwaddress);
115 :
116 : /**
117 : * Get total number of 40bit Altro words
118 : */
119 : int GetTotal40bitWords();
120 :
121 : /**
122 : * Sets the common data header at the beginning of the buffer
123 : */
124 : int SetCDH(AliHLTUInt8_t* pCDH, int size);
125 :
126 : /**
127 : * Sets the RCU trailer at the end of the buffer
128 : */
129 : int SetRCUTrailer(AliHLTUInt8_t* pTrailer, int size);
130 :
131 : /**
132 : * Finalize the encoded data.
133 : * Finish the last channel if open, copy RCU trailer if available and update
134 : * ALTRO word count in the trailer. Update the data length in the CDH if
135 : * available.
136 : */
137 : int SetLength();
138 :
139 0 : int GetOffset(){return fOffset;}
140 :
141 : /**
142 : * Revert the 40 bit altro data
143 : */
144 : void Revert40BitWords(Int_t CDHSize, Int_t trailerSize);
145 :
146 0 : void SetUse32BitFormat(Bool_t flag){f32BitFormat=flag;}
147 :
148 : void PrintDebug();
149 :
150 0 : void SetDDLid(Int_t ddl){fDDLid=ddl;}
151 :
152 0 : void SetSlice(UInt_t slice){fSlice=slice;}
153 :
154 0 : void SetPartition(UInt_t partition){fPartition=partition;}
155 :
156 : enum {
157 : kUnknownOrder = 0,
158 : kAscending,
159 : kDescending
160 : };
161 :
162 : protected:
163 :
164 : private:
165 : /** copy constructor prohibited */
166 : AliHLTAltroEncoder(const AliHLTAltroEncoder&);
167 : /** assignment operator prohibited */
168 : AliHLTAltroEncoder& operator=(const AliHLTAltroEncoder&);
169 :
170 : /**
171 : * Add 10bit value to the buffer
172 : */
173 : int Add10BitValue(AliHLTUInt16_t value);
174 :
175 : /**
176 : * Fill with 0x2aa paddings to reach complete 40bit word
177 : */
178 : int Pad40Bit();
179 :
180 : /**
181 : * Finalize the current bunch
182 : */
183 : int SetBunch();
184 :
185 : /// external data buffer
186 : AliHLTUInt8_t* fpBuffer; //!transient
187 :
188 : /// size of the data buffer
189 : int fBufferSize; //!transient
190 :
191 : /// the previous time bin
192 : AliHLTUInt16_t fPrevTimebin; //!transient
193 :
194 : /// length of the current bunch
195 : AliHLTUInt16_t fBunchLength; //!transient
196 :
197 : /// start of the current channel in 10bit word count
198 : AliHLTUInt16_t fChannelStart; //!transient
199 :
200 : /// the current channel
201 : AliHLTUInt16_t fChannel; //!transient
202 :
203 : /// list of already finished channels
204 : vector<AliHLTUInt16_t> fChannels; //!transient
205 :
206 : /// current byte offset
207 : int fOffset; //!transient
208 :
209 : /// current 10bit word count
210 : int f10bitWords; //!transient
211 :
212 : /// time bin order
213 : int fOrder; //!transient
214 :
215 : /// common data header
216 : TArrayC* fpCDH; //!transient
217 :
218 : // size of CDH
219 : Int_t fCDHSize; //! transient
220 :
221 : /// RCU trailer
222 : TArrayC* fpRCUTrailer; //!transient
223 :
224 : Bool_t f32BitFormat;
225 : AliHLTUInt8_t *fPointerToCurrentAltroHeader; //! transient Pointer to the AltroHeader of the current channel (pad)
226 : AliHLTUInt8_t *fPointerToCurrentBunchWord; //! transient This points to the first 8 bit in the 32 bit word that contain the bunch length information
227 : Int_t fWordLocationOfBunchCount; //! Number containing information on which of the 3 10 bit words containing the bunch size
228 : Int_t fNumberOfAltroHeadersInPayload; //! transient
229 : Bool_t fFillWord; //! transient
230 : Int_t fDDLid; //! transient
231 : UInt_t fSlice; //! transient
232 : UInt_t fPartition; //! transient
233 :
234 6 : ClassDef(AliHLTAltroEncoder, 2);
235 : };
236 :
237 : #endif
|
