[u/mrichter/AliRoot.git] / RAW / AliAltroBuffer.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

// Interface to the Altro format
// to read and write digits
// To be used in Alice Data Challenges 
// and in the compression of the RAW data
// Author: D.Favretto

#include "AliAltroBuffer.h"
#include "AliRawDataHeader.h"
#include <Riostream.h>
#include <stdlib.h>


ClassImp(AliAltroBuffer)


//_____________________________________________________________________________
AliAltroBuffer::AliAltroBuffer(const char* fileName, Int_t flag):
  fShift(0),
  fCurrentCell(0),
  fFreeCellBuffer(0),
  fFlag(flag),
  fVerbose(0),
  fFile(NULL),
  fMaskBackward(0xFF),
  fFilePosition(0),
  fFileEnd(0),
  fDataHeaderPos(0),
  fEndingFillWords(0)
{
//if flag = 1 the actual object is used in the write mode
//if flag = 0 the actual object is used in the read mode

  //the buffer is cleaned 
  for (Int_t i = 0; i < 5; i++) fBuffer[i] = 0;

  if (flag) {
    fFreeCellBuffer = 16;
    fShift = 32; 
    //open the output file
#ifndef __DECCXX
    fFile = new fstream(fileName, ios::binary|ios::out);
#else
    fFile = new fstream(fileName, ios::out);
#endif
  } else {
    //open the input file
#ifndef __DECCXX
    fFile = new fstream(fileName, ios::binary|ios::in);
#else
    fFile = new fstream(fileName, ios::in);
#endif
    if (!fFile) {
      Error("AliAltroBuffer", "File doesn't exist: %s", fileName);
      return;
    }
    fShift = 0;
    //To get the file dimension (position of the last element in term of bytes)
    fFile->seekg(0, ios::end);
    fFilePosition = fFile->tellg();
    fFileEnd = fFilePosition;
    fFile->seekg(0);
  }
}

//_____________________________________________________________________________
AliAltroBuffer::~AliAltroBuffer()
{
// destructor

  if (fFlag) {
    //Flush out the Buffer content at the end only if Buffer wasn't completely filled
    Flush();
    if (fVerbose) Info("~AliAltroBuffer", "File Created");
  }//end if
  fFile->close();
  delete fFile;
}

//_____________________________________________________________________________
AliAltroBuffer::AliAltroBuffer(const AliAltroBuffer& source):
  TObject(source),
  fShift(source.fShift),
  fCurrentCell(source.fCurrentCell),
  fFreeCellBuffer(source.fFreeCellBuffer),
  fFlag(source.fFlag),
  fVerbose(source.fVerbose),
  fFile(NULL),
  fMaskBackward(source.fMaskBackward),
  fFilePosition(source.fFilePosition),
  fFileEnd(source.fFileEnd),
  fDataHeaderPos(source.fDataHeaderPos),
  fEndingFillWords(source.fEndingFillWords)
{
// Copy Constructor

  Fatal("AliAltroBuffer", "copy constructor not implemented");
}

//_____________________________________________________________________________
AliAltroBuffer& AliAltroBuffer::operator = (const AliAltroBuffer& /*source*/)
{
//Assigment operator

  Fatal("operator =", "assignment operator not implemented");
  return *this;
}


//_____________________________________________________________________________
Int_t AliAltroBuffer::GetNext()
{
//It reads a 10 bits word in forward dicection from the Buffer.
//A new Buffer is read from the file only when Buffer is empty.
//If there aren't elements anymore -1 is returned otherwise 
//the next element is returned

  UInt_t mask = 0xFFC00000;
  UInt_t temp;
  UInt_t value;
  if (!fShift) {
    if (fFile->tellg() >= (Int_t)fFileEnd) return -1;
    if (fFile->read((char*)fBuffer, sizeof(UInt_t)*5)) {
      fCurrentCell = 0;
      fShift = 22;
      value = fBuffer[fCurrentCell] & mask;
      value = value >> 22;
      fBuffer[fCurrentCell] = fBuffer[fCurrentCell] << 10;
      return value;      
    } else {
      return -1;
    }
  } else {
    if (fShift >= 10) {
      value = fBuffer[fCurrentCell] & mask;
      value = value >> 22;
      fShift -= 10;
      fBuffer[fCurrentCell] = fBuffer[fCurrentCell] << 10;
    } else {
      value = fBuffer[fCurrentCell] & mask;
      fCurrentCell++;
      temp = fBuffer[fCurrentCell];
      temp = temp >> fShift;
      temp = temp & mask;
      value = value | temp;
      value = value >> 22;
      fBuffer[fCurrentCell] = fBuffer[fCurrentCell] << (10-fShift);
      fShift += 22;
    }
    return value;
  }//end else
}

//_____________________________________________________________________________
Int_t AliAltroBuffer::GetNextBackWord()
{
//It reads a 10 bits word in backward dicection from the Buffer.
//A new Buffer is read from the file only when Buffer is empty.
//If there aren't elements anymore -1 is returned otherwise 
//the next element is returned

  UInt_t mask = 0x3FF;
  UInt_t temp;
  UInt_t value;
  if (!fShift) {
    if (fFilePosition > fDataHeaderPos){
      fFilePosition -= sizeof(UInt_t)*5;
      fFile->seekg(fFilePosition);
      fFile->read((char*)fBuffer, sizeof(UInt_t)*5);
      
      fCurrentCell = 4;
      fShift = 22;
      fMaskBackward = 0xFF;
      value = fBuffer[fCurrentCell] & mask;
      fBuffer[fCurrentCell] = fBuffer[fCurrentCell] >> 10;
      return value;
    } else {
      fFile->seekg(fDataHeaderPos);
      return -1;
    }
  } else {
    if (fShift >= 10) {
      value = fBuffer[fCurrentCell] & mask;
      fShift -= 10;
      fBuffer[fCurrentCell] = fBuffer[fCurrentCell] >> 10;
    } else {
      value = fBuffer[fCurrentCell];
      fCurrentCell--;
      temp = fBuffer[fCurrentCell] & mask;
      temp = temp & fMaskBackward;
      fMaskBackward = fMaskBackward >> 2;
      temp = temp << fShift;
      value = value | temp;
      fBuffer[fCurrentCell] = fBuffer[fCurrentCell] >> (10-fShift);
      fShift = 22 + fShift;
    }
    return value;
  }//end else
}

//_____________________________________________________________________________
void AliAltroBuffer::Flush()
{
// Flushes the Buffer content 
  if (fFreeCellBuffer != 16) {
    Int_t temp = fFreeCellBuffer;
    for (Int_t i = 0; i < temp; i++){
      FillBuffer(0x2AA);
    }//end for
  }//end if
}

//_____________________________________________________________________________
void AliAltroBuffer::FillBuffer(Int_t val)
{
//Fills the Buffer with 16 ten bits words and write into a file 

  if ((val > 0x3FF) || (val < 0)) {
    Error("FillBuffer", "Value out of range (10 bits): %d", val);
    val = 0x3FF;
  }
  fFreeCellBuffer--;
  if (fShift < 10) {
    Int_t temp = val;
    val = val >> (10-fShift);
    fBuffer[fCurrentCell] |= val;
    fCurrentCell++;
    fShift += 32;
    val = temp;
  }
  fShift -= 10;
  val = val << fShift;
  fBuffer[fCurrentCell] |= val;
  if (!fShift) {
    //Buffer is written into a file
    fFile->write((char*)fBuffer, sizeof(UInt_t)*5);
    //Buffer is empty
    for (Int_t j = 0; j < 5; j++) fBuffer[j] = 0;
    fShift = 32;
    fCurrentCell = 0;
    fFreeCellBuffer = 16;
  }
}


//_____________________________________________________________________________
void AliAltroBuffer::WriteTrailer(Int_t wordsNumber, Int_t padNumber,
				  Int_t rowNumber, Int_t secNumber)
{
//Writes a trailer of 40 bits

  Int_t num = fFreeCellBuffer % 4;
  for(Int_t i = 0; i < num; i++) {
    FillBuffer(0x2AA);
  }//end for
  FillBuffer(wordsNumber);
  FillBuffer(padNumber);
  FillBuffer(rowNumber);
  FillBuffer(secNumber);
}

//_____________________________________________________________________________
Bool_t AliAltroBuffer::ReadTrailer(Int_t& wordsNumber, Int_t& padNumber,
				   Int_t& rowNumber, Int_t& secNumber)
{
//Read a trailer of 40 bits in the forward reading mode

  wordsNumber = GetNext();
  if (wordsNumber == -1) return kFALSE;
  padNumber = GetNext();
  if (padNumber == -1) return kFALSE;
  rowNumber = GetNext();
  if (rowNumber == -1) return kFALSE;
  secNumber = GetNext();
  if (secNumber == -1) return kFALSE;
  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliAltroBuffer::ReadTrailerBackward(Int_t& wordsNumber, 
					   Int_t& padNumber,
					   Int_t& rowNumber, Int_t& secNumber)
{
//Read a trailer of 40 bits in the backward reading mode

  Int_t temp;
  fEndingFillWords = 0;
  do {
    temp = GetNextBackWord();
    fEndingFillWords++;
    if (temp == -1) return kFALSE;
  } while (temp == 0x2AA);  
  fEndingFillWords--;
  secNumber = temp;
  rowNumber = GetNextBackWord();
  if (rowNumber == -1) return kFALSE;
  padNumber = GetNextBackWord();
  if (padNumber == -1) return kFALSE;
  wordsNumber = GetNextBackWord();
  if (wordsNumber == -1) return kFALSE;
  return kTRUE;
} 


//_____________________________________________________________________________
void AliAltroBuffer::WriteChannel(Int_t padNumber, Int_t rowNumber, 
				  Int_t secNumber,
				  Int_t nTimeBins, const Int_t* adcValues,
				  Int_t threshold)
{
//Write all ADC values and the trailer of a channel

  Int_t nWords = 0;
  Int_t timeBin = -1;
  Int_t bunchLength = 0;

  // loop over time bins
  for (Int_t iTime = 0; iTime < nTimeBins; iTime++) {
    if (adcValues[iTime] >= threshold) { // ADC value above threshold
      FillBuffer(adcValues[iTime]);
      nWords++;
      timeBin = iTime;
      bunchLength++;

    } else if (timeBin >= 0) {  // end of bunch
      FillBuffer(timeBin);
      FillBuffer(bunchLength + 2);
      nWords += 2;
      timeBin = -1;
      bunchLength = 0;
    }
  }

  if (timeBin >= 0) {  // end of bunch
    FillBuffer(timeBin);
    FillBuffer(bunchLength + 2);
    nWords += 2;
  }

  // write the trailer
  WriteTrailer(nWords, padNumber, rowNumber, secNumber);
}


//_____________________________________________________________________________
void AliAltroBuffer::WriteDataHeader(Bool_t dummy, Bool_t compressed)
{
//Write a (dummy or real) DDL data header, 
//set the compression bit if compressed

  AliRawDataHeader header;
  if (dummy) {
    //if size=0 it means that this data header is a dummy data header
    fDataHeaderPos = fFile->tellp();
    fFile->write((char*)(&header), sizeof(header));
  } else {
    UInt_t currentFilePos = fFile->tellp();
    fFile->seekp(fDataHeaderPos);
    header.fSize = currentFilePos-fDataHeaderPos;
    header.SetAttribute(0);  // valid data
    if (compressed) header.SetAttribute(1); 
    fFile->write((char*)(&header), sizeof(header));
    fFile->seekp(currentFilePos);
  }
}

//_____________________________________________________________________________
Bool_t AliAltroBuffer::ReadDataHeader()
{
//Read the DDL data header at the beginning of the file, 
//returns true in case of valid data

  AliRawDataHeader header;
  UInt_t currentPos = fFile->tellp();
  fFile->seekp(0);
  if (!fFile->read((char*)(&header), sizeof(header))) return kFALSE;
  fDataHeaderPos = fFile->tellp();
  fFile->seekp(currentPos);
  return header.TestAttribute(0);
}
Commit	Line	Data
3ea47630	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 "AliAltroBuffer.h"
	25	#include "AliRawDataHeader.h"
	26	#include <Riostream.h>
	27	#include <stdlib.h>
	28
	29
	30	ClassImp(AliAltroBuffer)
	31
	32
	33	//_____________________________________________________________________________
	34	AliAltroBuffer::AliAltroBuffer(const char* fileName, Int_t flag):
	35	fShift(0),
	36	fCurrentCell(0),
	37	fFreeCellBuffer(0),
	38	fFlag(flag),
	39	fVerbose(0),
	40	fFile(NULL),
	41	fMaskBackward(0xFF),
	42	fFilePosition(0),
	43	fFileEnd(0),
	44	fDataHeaderPos(0),
	45	fEndingFillWords(0)
	46	{
	47	//if flag = 1 the actual object is used in the write mode
	48	//if flag = 0 the actual object is used in the read mode
	49
	50	//the buffer is cleaned
	51	for (Int_t i = 0; i < 5; i++) fBuffer[i] = 0;
	52
	53	if (flag) {
	54	fFreeCellBuffer = 16;
	55	fShift = 32;
	56	//open the output file
	57	#ifndef __DECCXX
	58	fFile = new fstream(fileName, ios::binary\|ios::out);
	59	#else
	60	fFile = new fstream(fileName, ios::out);
	61	#endif
	62	} else {
	63	//open the input file
	64	#ifndef __DECCXX
65	fFile = new fstream(fileName, ios::binary\|ios::in);
66	#else
67	fFile = new fstream(fileName, ios::in);
68	#endif
69	if (!fFile) {
70	Error("AliAltroBuffer", "File doesn't exist: %s", fileName);
71	return;
72	}
73	fShift = 0;
74	//To get the file dimension (position of the last element in term of bytes)
75	fFile->seekg(0, ios::end);
76	fFilePosition = fFile->tellg();
77	fFileEnd = fFilePosition;
78	fFile->seekg(0);
79	}
80	}
81
82	//_____________________________________________________________________________
83	AliAltroBuffer::~AliAltroBuffer()
84	{
85	// destructor
86
87	if (fFlag) {
88	//Flush out the Buffer content at the end only if Buffer wasn't completely filled
89	Flush();
90	if (fVerbose) Info("~AliAltroBuffer", "File Created");
91	}//end if
92	fFile->close();
93	delete fFile;
94	}
95
96	//_____________________________________________________________________________
97	AliAltroBuffer::AliAltroBuffer(const AliAltroBuffer& source):
98	TObject(source),
99	fShift(source.fShift),
100	fCurrentCell(source.fCurrentCell),
101	fFreeCellBuffer(source.fFreeCellBuffer),
102	fFlag(source.fFlag),
103	fVerbose(source.fVerbose),
104	fFile(NULL),
105	fMaskBackward(source.fMaskBackward),
106	fFilePosition(source.fFilePosition),
107	fFileEnd(source.fFileEnd),
108	fDataHeaderPos(source.fDataHeaderPos),
109	fEndingFillWords(source.fEndingFillWords)
110	{
111	// Copy Constructor
112
113	Fatal("AliAltroBuffer", "copy constructor not implemented");
114	}
115
116	//_____________________________________________________________________________
117	AliAltroBuffer& AliAltroBuffer::operator = (const AliAltroBuffer& /source/)
118	{
119	//Assigment operator
120
121	Fatal("operator =", "assignment operator not implemented");
122	return *this;
123	}
124
125
126	//_____________________________________________________________________________
127	Int_t AliAltroBuffer::GetNext()
128	{
129	//It reads a 10 bits word in forward dicection from the Buffer.
130	//A new Buffer is read from the file only when Buffer is empty.
131	//If there aren't elements anymore -1 is returned otherwise
132	//the next element is returned
133
134	UInt_t mask = 0xFFC00000;
135	UInt_t temp;
136	UInt_t value;
137	if (!fShift) {
138	if (fFile->tellg() >= (Int_t)fFileEnd) return -1;
139	if (fFile->read((char)fBuffer, sizeof(UInt_t)5)) {
140	fCurrentCell = 0;
141	fShift = 22;
142	value = fBuffer[fCurrentCell] & mask;
143	value = value >> 22;
144	fBuffer[fCurrentCell] = fBuffer[fCurrentCell] << 10;
145	return value;
146	} else {
147	return -1;
148	}
149	} else {
150	if (fShift >= 10) {
151	value = fBuffer[fCurrentCell] & mask;
152	value = value >> 22;
153	fShift -= 10;
154	fBuffer[fCurrentCell] = fBuffer[fCurrentCell] << 10;
155	} else {
156	value = fBuffer[fCurrentCell] & mask;
157	fCurrentCell++;
158	temp = fBuffer[fCurrentCell];
159	temp = temp >> fShift;
160	temp = temp & mask;
161	value = value \| temp;
162	value = value >> 22;
163	fBuffer[fCurrentCell] = fBuffer[fCurrentCell] << (10-fShift);
164	fShift += 22;
165	}
166	return value;
167	}//end else
168	}
169
170	//_____________________________________________________________________________
171	Int_t AliAltroBuffer::GetNextBackWord()
172	{
173	//It reads a 10 bits word in backward dicection from the Buffer.
174	//A new Buffer is read from the file only when Buffer is empty.
175	//If there aren't elements anymore -1 is returned otherwise
176	//the next element is returned
177
178	UInt_t mask = 0x3FF;
179	UInt_t temp;
180	UInt_t value;
181	if (!fShift) {
182	if (fFilePosition > fDataHeaderPos){
183	fFilePosition -= sizeof(UInt_t)*5;
184	fFile->seekg(fFilePosition);
185	fFile->read((char)fBuffer, sizeof(UInt_t)5);
186
187	fCurrentCell = 4;
188	fShift = 22;
189	fMaskBackward = 0xFF;
190	value = fBuffer[fCurrentCell] & mask;
191	fBuffer[fCurrentCell] = fBuffer[fCurrentCell] >> 10;
192	return value;
193	} else {
194	fFile->seekg(fDataHeaderPos);
195	return -1;
196	}
197	} else {
198	if (fShift >= 10) {
199	value = fBuffer[fCurrentCell] & mask;
200	fShift -= 10;
201	fBuffer[fCurrentCell] = fBuffer[fCurrentCell] >> 10;
202	} else {
203	value = fBuffer[fCurrentCell];
204	fCurrentCell--;
205	temp = fBuffer[fCurrentCell] & mask;
206	temp = temp & fMaskBackward;
207	fMaskBackward = fMaskBackward >> 2;
208	temp = temp << fShift;
209	value = value \| temp;
210	fBuffer[fCurrentCell] = fBuffer[fCurrentCell] >> (10-fShift);
211	fShift = 22 + fShift;
212	}
213	return value;
214	}//end else
215	}
216
217	//_____________________________________________________________________________
218	void AliAltroBuffer::Flush()
219	{
220	// Flushes the Buffer content
221	if (fFreeCellBuffer != 16) {
222	Int_t temp = fFreeCellBuffer;
223	for (Int_t i = 0; i < temp; i++){
224	FillBuffer(0x2AA);
225	}//end for
226	}//end if
227	}
228
229	//_____________________________________________________________________________
230	void AliAltroBuffer::FillBuffer(Int_t val)
231	{
232	//Fills the Buffer with 16 ten bits words and write into a file
233
23b19451	234	if ((val > 0x3FF) \|\| (val < 0)) {
	235	Error("FillBuffer", "Value out of range (10 bits): %d", val);
	236	val = 0x3FF;
	237	}
3ea47630	238	fFreeCellBuffer--;
	239	if (fShift < 10) {
	240	Int_t temp = val;
	241	val = val >> (10-fShift);
	242	fBuffer[fCurrentCell] \|= val;
	243	fCurrentCell++;
	244	fShift += 32;
	245	val = temp;
	246	}
	247	fShift -= 10;
	248	val = val << fShift;
	249	fBuffer[fCurrentCell] \|= val;
	250	if (!fShift) {
	251	//Buffer is written into a file
	252	fFile->write((char)fBuffer, sizeof(UInt_t)5);
	253	//Buffer is empty
	254	for (Int_t j = 0; j < 5; j++) fBuffer[j] = 0;
	255	fShift = 32;
	256	fCurrentCell = 0;
	257	fFreeCellBuffer = 16;
	258	}
	259	}
	260
	261
	262	//_____________________________________________________________________________
	263	void AliAltroBuffer::WriteTrailer(Int_t wordsNumber, Int_t padNumber,
	264	Int_t rowNumber, Int_t secNumber)
	265	{
	266	//Writes a trailer of 40 bits
	267
	268	Int_t num = fFreeCellBuffer % 4;
	269	for(Int_t i = 0; i < num; i++) {
	270	FillBuffer(0x2AA);
	271	}//end for
	272	FillBuffer(wordsNumber);
	273	FillBuffer(padNumber);
	274	FillBuffer(rowNumber);
	275	FillBuffer(secNumber);
	276	}
	277
	278	//_____________________________________________________________________________
	279	Bool_t AliAltroBuffer::ReadTrailer(Int_t& wordsNumber, Int_t& padNumber,
	280	Int_t& rowNumber, Int_t& secNumber)
	281	{
	282	//Read a trailer of 40 bits in the forward reading mode
	283
	284	wordsNumber = GetNext();
	285	if (wordsNumber == -1) return kFALSE;
	286	padNumber = GetNext();
	287	if (padNumber == -1) return kFALSE;
	288	rowNumber = GetNext();
	289	if (rowNumber == -1) return kFALSE;
	290	secNumber = GetNext();
	291	if (secNumber == -1) return kFALSE;
	292	return kTRUE;
	293	}
	294
	295	//_____________________________________________________________________________
	296	Bool_t AliAltroBuffer::ReadTrailerBackward(Int_t& wordsNumber,
	297	Int_t& padNumber,
	298	Int_t& rowNumber, Int_t& secNumber)
	299	{
	300	//Read a trailer of 40 bits in the backward reading mode
	301
302	Int_t temp;
303	fEndingFillWords = 0;
304	do {
305	temp = GetNextBackWord();
306	fEndingFillWords++;
307	if (temp == -1) return kFALSE;
308	} while (temp == 0x2AA);
309	fEndingFillWords--;
310	secNumber = temp;
311	rowNumber = GetNextBackWord();
312	if (rowNumber == -1) return kFALSE;
313	padNumber = GetNextBackWord();
314	if (padNumber == -1) return kFALSE;
315	wordsNumber = GetNextBackWord();
316	if (wordsNumber == -1) return kFALSE;
317	return kTRUE;
318	}
319
320
321	//_____________________________________________________________________________
322	void AliAltroBuffer::WriteChannel(Int_t padNumber, Int_t rowNumber,
323	Int_t secNumber,
324	Int_t nTimeBins, const Int_t* adcValues,
325	Int_t threshold)
326	{
327	//Write all ADC values and the trailer of a channel
328
329	Int_t nWords = 0;
330	Int_t timeBin = -1;
331	Int_t bunchLength = 0;
332
333	// loop over time bins
334	for (Int_t iTime = 0; iTime < nTimeBins; iTime++) {
335	if (adcValues[iTime] >= threshold) { // ADC value above threshold
336	FillBuffer(adcValues[iTime]);
337	nWords++;
338	timeBin = iTime;
339	bunchLength++;
340
341	} else if (timeBin >= 0) { // end of bunch
342	FillBuffer(timeBin);
343	FillBuffer(bunchLength + 2);
344	nWords += 2;
345	timeBin = -1;
346	bunchLength = 0;
347	}
348	}
349
350	if (timeBin >= 0) { // end of bunch
351	FillBuffer(timeBin);
352	FillBuffer(bunchLength + 2);
353	nWords += 2;
354	}
355
356	// write the trailer
357	WriteTrailer(nWords, padNumber, rowNumber, secNumber);
358	}
359
360
361	//_____________________________________________________________________________
362	void AliAltroBuffer::WriteDataHeader(Bool_t dummy, Bool_t compressed)
363	{
364	//Write a (dummy or real) DDL data header,
365	//set the compression bit if compressed
366
367	AliRawDataHeader header;
368	if (dummy) {
369	//if size=0 it means that this data header is a dummy data header
370	fDataHeaderPos = fFile->tellp();
371	fFile->write((char*)(&header), sizeof(header));
372	} else {
373	UInt_t currentFilePos = fFile->tellp();
374	fFile->seekp(fDataHeaderPos);
375	header.fSize = currentFilePos-fDataHeaderPos;
376	header.SetAttribute(0); // valid data
377	if (compressed) header.SetAttribute(1);
378	fFile->write((char*)(&header), sizeof(header));
379	fFile->seekp(currentFilePos);
380	}
381	}
b0aef454	382
	383	//_____________________________________________________________________________
	384	Bool_t AliAltroBuffer::ReadDataHeader()
	385	{
	386	//Read the DDL data header at the beginning of the file,
	387	//returns true in case of valid data
	388
	389	AliRawDataHeader header;
	390	UInt_t currentPos = fFile->tellp();
	391	fFile->seekp(0);
	392	if (!fFile->read((char*)(&header), sizeof(header))) return kFALSE;
	393	fDataHeaderPos = fFile->tellp();
	394	fFile->seekp(currentPos);
	395	return header.TestAttribute(0);
	396	}