Add support for 64 bits
[u/mrichter/AliRoot.git] / RAW / AliTPCBuffer160.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 // Interface to the Altro format
19 // to read and write digits
20 // To be used in Alice Data Challenges 
21 // and in the compression of the RAW data
22 // Author: D.Favretto
23
24 #include "AliTPCBuffer160.h"
25 #include <TObjArray.h>
26 #include <Riostream.h>
27 #include <TMath.h>
28 #include <stdlib.h>
29
30
31 ClassImp(AliTPCBuffer160)
32
33 AliTPCBuffer160::AliTPCBuffer160(const char* fileName,Int_t flag){
34   //if flag = 1 the actual object is used in the write mode
35   //if flag = 0 the actual object is used in the read mode
36   fFlag=flag;
37   fCurrentCell=0;
38   fMiniHeaderPos=0;
39   fMaskBackward=0xFF;
40   fVerbose=0;
41   if (flag){
42     fFreeCellBuffer=16;
43     fShift=32; 
44     //the buffer is cleaned 
45     for (Int_t i=0;i<5;i++)fBuffer[i]=0;
46     //open the output file
47 #ifndef __DECCXX
48     f = new fstream(fileName,ios::binary|ios::out);
49 #else
50     f = new fstream(fileName,ios::out);
51 #endif
52   }
53   else{
54     //open the input file
55 #ifndef __DECCXX
56     f = new fstream(fileName,ios::binary|ios::in);
57 #else
58     f = new fstream(fileName,ios::in);
59 #endif
60     if(!f){cout<<"File doesn't exist:"<<fileName<<endl;;exit(-1);}
61     fShift=0;
62     //To get the file dimension (position of the last element in term of bytes)
63     f->seekg(0, ios::end);
64     fFilePosition= f->tellg();
65     fFileEnd=fFilePosition;
66     f->seekg(0);
67   }
68   fCreated = kTRUE;
69 }
70
71 AliTPCBuffer160::AliTPCBuffer160(fstream* file, Int_t size){
72 //constructor for reading a file with mini header
73   fFlag=0;
74   f=file;
75   fCurrentCell=0;
76   fShift=0;
77   fMaskBackward=0xFF;
78   fVerbose=0;
79
80   fMiniHeaderPos=f->tellg();
81   f->seekg(fMiniHeaderPos+size);
82   fFilePosition=f->tellg();
83   fFileEnd=fFilePosition;
84   f->seekg(fMiniHeaderPos);
85   fCreated = kFALSE;
86 }
87
88 AliTPCBuffer160::~AliTPCBuffer160(){
89   // destructor
90   if (fFlag){
91     //Flush out the Buffer content at the end only if Buffer wasn't completely filled
92     Flush();
93     if(fVerbose)
94       cout<<"File Created\n";
95   }//end if
96   if (fCreated) {
97     f->close();
98     delete f;
99   }
100 }
101
102
103 AliTPCBuffer160::AliTPCBuffer160(const AliTPCBuffer160 &source)
104   :TObject(source){
105   // Copy Constructor
106   if(&source==this)return;
107   this->fShift=source.fShift;
108   this->fCurrentCell=source.fCurrentCell;
109   this->fFreeCellBuffer=source.fFreeCellBuffer;
110   this->fFlag=source.fFlag;
111   this->fMaskBackward=source.fMaskBackward;
112   this->fFilePosition=source.fFilePosition;
113   this->fMiniHeaderPos=source.fMiniHeaderPos;
114   this->fVerbose=source.fVerbose;
115   for (Int_t i=0;i<5;i++)this->fBuffer[i]=source.fBuffer[i];
116   return;
117 }
118
119 AliTPCBuffer160& AliTPCBuffer160::operator=(const AliTPCBuffer160 &source){
120   //Assigment operator
121   if(&source==this)return *this;
122   this->fShift=source.fShift;
123   this->fCurrentCell=source.fCurrentCell;
124   this->fFreeCellBuffer=source.fFreeCellBuffer;
125   this->fFlag=source.fFlag;
126   this->fMaskBackward=source.fMaskBackward;
127   this->fFilePosition=source.fFilePosition;
128   this->fMiniHeaderPos=source.fMiniHeaderPos;
129   this->fVerbose=source.fVerbose;
130   for (Int_t i=0;i<5;i++)this->fBuffer[i]=source.fBuffer[i];
131   return *this;
132 }
133
134 Int_t AliTPCBuffer160::GetNext(){
135   //It reads a 10 bits word in forward dicection from the Buffer.
136   //A new Buffer is read from the file only when Buffer is empty.
137   //If there aren't elements anymore -1 is returned otherwise 
138   //the next element is returned
139   UInt_t mask=0xFFC00000;
140   UInt_t temp;
141   UInt_t value;
142   if (!fShift){
143     if (f->tellg()>=(Int_t)fFileEnd) return -1;
144     if ( f->read((char*)fBuffer,sizeof(UInt_t)*5) ){
145       fCurrentCell=0;
146       fShift=22;
147       value=fBuffer[fCurrentCell]&mask;
148       value=value>>22;
149       fBuffer[fCurrentCell]=fBuffer[fCurrentCell]<<10;
150       return value;      
151     }
152     else return -1;
153   }//end if
154   else{
155     if (fShift>=10){
156       value=fBuffer[fCurrentCell]&mask;
157       value=value>>22;
158       fShift-=10;
159       fBuffer[fCurrentCell]=fBuffer[fCurrentCell]<<10;
160     }
161     else{
162       value=fBuffer[fCurrentCell]&mask;
163       fCurrentCell++;
164       temp=fBuffer[fCurrentCell];
165       temp=temp>>fShift;
166       temp=temp&mask;
167       value=value|temp;
168       value=value>>22;
169       fBuffer[fCurrentCell]=fBuffer[fCurrentCell]<<(10-fShift);
170       fShift=22+fShift;
171     }
172     return value;
173   }//end else
174 }
175
176 Int_t AliTPCBuffer160::GetNextBackWord(){
177   //It reads a 10 bits word in backward dicection from the Buffer.
178   //A new Buffer is read from the file only when Buffer is empty.
179   //If there aren't elements anymore -1 is returned otherwise 
180   //the next element is returned
181   UInt_t mask=0x3FF;
182   UInt_t temp;
183   UInt_t value;
184   if (!fShift){
185     if (fFilePosition>fMiniHeaderPos){
186       fFilePosition-=sizeof(UInt_t)*5;
187       f->seekg(fFilePosition);
188       f->read((char*)fBuffer,sizeof(UInt_t)*5);
189       
190       //cout<<"Buffer letto"<<endl;
191       /*
192       char* tt=(char*)fBuffer;
193       for(Int_t ii=0;ii<20;ii++){
194         cout<<hex;
195         cout<<ii<<"==> "<<(Int_t)*tt<<endl;
196         cout<<dec;
197         tt++;
198       }
199       cout<<0<<" --- "<<hex<<fBuffer[0]<<dec<<endl;
200       cout<<1<<" --- "<<hex<<fBuffer[1]<<dec<<endl;
201       cout<<2<<" --- "<<hex<<fBuffer[2]<<dec<<endl;
202       cout<<3<<" --- "<<hex<<fBuffer[3]<<dec<<endl;
203       cout<<4<<" --- "<<hex<<fBuffer[4]<<dec<<endl;
204       cout<<"Fine UInt_t"<<endl;
205       */
206       fCurrentCell=4;
207       fShift=22;
208       fMaskBackward=0xFF;
209       value=fBuffer[fCurrentCell]&mask;
210       fBuffer[fCurrentCell]=fBuffer[fCurrentCell]>>10;
211       return value;      
212     }
213     else {
214 //      f->seekg(fFileEnd);
215       f->seekg(fMiniHeaderPos);
216       return -1;
217     }
218   }//end if
219   else{
220     if (fShift>=10){
221       value=fBuffer[fCurrentCell]&mask;
222       fShift-=10;
223       fBuffer[fCurrentCell]=fBuffer[fCurrentCell]>>10;
224     }
225     else{
226       value=fBuffer[fCurrentCell];
227       fCurrentCell--;
228       temp=fBuffer[fCurrentCell]&mask;
229       temp=temp&fMaskBackward;
230       fMaskBackward=fMaskBackward>>2;
231       temp=temp<<fShift;
232       value=value|temp;
233       fBuffer[fCurrentCell]=fBuffer[fCurrentCell]>>(10-fShift);
234       fShift=22+fShift;
235     }
236     return value;
237   }//end else
238 }
239
240 void AliTPCBuffer160::Flush(){
241   // Flushes the Buffer content 
242   if(fFreeCellBuffer!=16){
243     Int_t temp=fFreeCellBuffer;
244     for(Int_t i=0;i<temp;i++){
245       FillBuffer(0x2AA);
246     }//end for
247   }//end if
248 }
249
250 void AliTPCBuffer160::FillBuffer(Int_t Val){
251   //Fills the Buffer with 16 ten bits words and write into a file 
252   fFreeCellBuffer--;
253   if (fShift<10){
254     Int_t temp=Val;
255     Val=Val>>(10-fShift);
256     fBuffer[fCurrentCell]|=Val;
257     fCurrentCell++;
258     fShift+=32;
259     Val=temp;
260   }
261   fShift-=10;
262   Val=Val<<fShift;
263   fBuffer[fCurrentCell]|=Val;
264   if(!fShift){
265     //Buffer is written into a file
266     f->write((char*)fBuffer,sizeof(UInt_t)*5);
267    //Buffer is empty
268     for(Int_t j=0;j<5;j++)fBuffer[j]=0;
269     fShift=32;
270     fCurrentCell=0;
271     fFreeCellBuffer=16;
272   }
273   /*
274     for(Int_t jj=0;jj<5;jj++){
275     cout.flags(ios::hex);
276     cout<<fBuffer[jj]<<endl;
277     cout.flags(ios::dec);
278     }
279     
280   */
281   return;
282 }
283
284 void   AliTPCBuffer160::WriteTrailer(Int_t WordsNumber,Int_t PadNumber,Int_t RowNumber,Int_t SecNumber){
285   //Writes a trailer of 40 bits
286   Int_t num=fFreeCellBuffer%4;
287   for(Int_t i=0;i<num;i++){
288     FillBuffer(0x2AA);
289   }//end for
290   FillBuffer(WordsNumber);
291   FillBuffer(PadNumber);
292   FillBuffer(RowNumber);
293   FillBuffer(SecNumber);
294 }
295
296 void AliTPCBuffer160::ReadTrailer(Int_t &WordsNumber,Int_t &PadNumber,Int_t &RowNumber,Int_t &SecNumber){
297   //Read a trailer of 40 bits in the forward reading mode
298   WordsNumber=GetNext();
299   PadNumber=GetNext();
300   RowNumber=GetNext();
301   SecNumber=GetNext();
302 }
303
304
305 Int_t AliTPCBuffer160::ReadTrailerBackward(Int_t &WordsNumber,Int_t &PadNumber,Int_t &RowNumber,Int_t &SecNumber){
306   //Read a trailer of 40 bits in the backward reading mode
307   Int_t temp;
308   fEndingFillWords=0;
309   do{
310     temp=GetNextBackWord();
311     fEndingFillWords++;
312     if (temp==-1)return -1;
313   }while (temp==0x2AA);  
314   fEndingFillWords--;
315   SecNumber=temp;
316   RowNumber=GetNextBackWord();
317   PadNumber=GetNextBackWord();
318   WordsNumber=GetNextBackWord();
319   return 0;
320
321
322 void AliTPCBuffer160::WriteMiniHeader(UInt_t Size,Int_t SecNumber,Int_t SubSector,Int_t Detector,Int_t Flag ){
323   //Size msg errore sector number sub-sector number 0 for TPC 0 for uncompressed
324   Int_t ddlNumber;
325   UInt_t miniHeader[3];
326   Int_t version=1;
327   if(SecNumber<36)
328     ddlNumber=SecNumber*2+SubSector;
329   else
330     ddlNumber=72+(SecNumber-36)*4+SubSector;
331   //  cout<<"DDL number "<<ddlNumber<<endl;
332   for(Int_t i=0;i<3;i++)miniHeader[i]=0;
333   Int_t miniHeaderSize=(sizeof(UInt_t))*3;
334   PackWord(miniHeader[1],Detector,0,7);
335   PackWord(miniHeader[1],0x123456,8,31);
336   PackWord(miniHeader[2],version,0,7);
337   PackWord(miniHeader[2],Flag,8,15);
338   PackWord(miniHeader[2],ddlNumber,16,31);
339   if (!Size){
340     //if size=0 it means that this mini header is a dummi mini header
341     fMiniHeaderPos=f->tellp();
342     //cout<<" Position of the DUMMY MH:"<<fMiniHeaderPos<<" Size:"<<Size<<endl;
343     miniHeader[0]=Size;
344     f->write((char*)(miniHeader),miniHeaderSize);
345   }//end if
346   else{
347     UInt_t currentFilePos=f->tellp();
348     f->seekp(fMiniHeaderPos);
349     Size=currentFilePos-fMiniHeaderPos-miniHeaderSize;
350     //cout<<"Current Position (Next MH) "<<currentFilePos<<" Position of the MH:"<<fMiniHeaderPos<<" Size:"<<Size<<endl;
351     miniHeader[0]=Size;
352     //cout<<"Mini Header Size:"<<miniHeader[0]<<endl;
353     f->write((char*)(miniHeader),miniHeaderSize);
354     f->seekp(currentFilePos);
355   }
356   return;
357 }
358
359
360 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
361
362 void AliTPCBuffer160::PackWord(UInt_t &BaseWord, UInt_t Word, Int_t StartBit, Int_t StopBit){
363   //Packs a word into the BaseWord buffer from StartBit bit up to StopBit bit
364   UInt_t dummyWord,offSet;
365   Int_t   length;
366   UInt_t sum;
367   //The BaseWord is being filled with 1 from StartBit to StopBit
368   length=StopBit-StartBit+1;
369   sum=(UInt_t)TMath::Power(2,length)-1;
370   if(Word > sum){
371     cout<<"WARNING::Word to be filled is not within desired length"<<endl;
372     exit(-1);
373   }
374   offSet=sum;
375   offSet<<=StartBit;
376   BaseWord=BaseWord|offSet;
377   //The Word to be filled is shifted to the position StartBit
378   //and the remaining  Left and Right bits are filled with 1
379   sum=(UInt_t)TMath::Power(2,StartBit)-1;
380   dummyWord=0xFFFFFFFF<<length;
381   dummyWord +=Word;
382   dummyWord<<=StartBit;
383   dummyWord+=sum;
384   BaseWord=BaseWord&dummyWord;
385   return;
386 }
387
388 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
389
390 void AliTPCBuffer160::UnpackWord(UInt_t PackedWord, Int_t StartBit, Int_t StopBit, UInt_t &Word){       
391   //Unpacks a word of StopBit-StartBit+1 bits from PackedWord buffer starting from the position 
392   //indicated by StartBit
393   UInt_t offSet;
394   Int_t length;
395   length=StopBit-StartBit+1;
396   offSet=(UInt_t)TMath::Power(2,length)-1;
397   offSet<<=StartBit;
398   Word=PackedWord&offSet;
399   Word>>=StartBit;
400   return;
401 }
402
403 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////