Update master to aliroot
[u/mrichter/AliRoot.git] / HLT / RCU / AliHLTAltroEncoder.h
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   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   void SetUse32BitFormat(Bool_t flag){f32BitFormat=flag;}
147
148   void PrintDebug();
149
150   void SetDDLid(Int_t ddl){fDDLid=ddl;}
151
152   void SetSlice(UInt_t slice){fSlice=slice;}
153
154   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   ClassDef(AliHLTAltroEncoder, 2);
235 };
236
237 #endif