More robust raw-reader for HLT (Artur)
[u/mrichter/AliRoot.git] / RAW / AliRawReaderMemory.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 ///////////////////////////////////////////////////////////////////////////////
19 /// 
20 /// This is a class for reading raw data memory buffers.
21 ///
22 ///////////////////////////////////////////////////////////////////////////////
23
24 #include "AliRawReaderMemory.h"
25 #include <TSystem.h>
26
27
28 ClassImp(AliRawReaderMemory)
29
30
31 AliRawReaderMemory::AliRawReaderMemory() :
32   fBuffer(NULL),
33   fBufferSize(0),
34   fPosition(0),
35   fEquipmentId(-1)
36 {
37 // create an object to read digits from
38 // the given memory location
39 }
40
41 AliRawReaderMemory::AliRawReaderMemory(UChar_t* memory, UInt_t size) :
42   fBuffer(memory),
43   fBufferSize(size),
44   fPosition(0),
45   fEquipmentId(-1)
46 {
47 // create an object to read digits from the given memory
48 }
49
50 AliRawReaderMemory::~AliRawReaderMemory()
51 {
52 // close the input memory
53 }
54
55 void AliRawReaderMemory::RequireHeader(Bool_t required)
56 {
57   // Reading of raw data in case of missing
58   // raw data header is not implemented for
59   // this class
60   if (!required)
61     Fatal("AliRawReaderMemory","Reading of raw data without raw data header is not implemented !");
62
63   AliRawReader::RequireHeader(required);
64 }
65
66 Bool_t AliRawReaderMemory::ReadHeader()
67 {
68 // read a data header at the current buffer position
69 // returns kFALSE if the mini header could not be read
70
71   if (fEquipmentId == -1)
72   {
73     Warning("ReadHeader", "The equipment ID is not set for the DDL memory buffer.");
74   }
75
76   if (!fBuffer) return kFALSE;
77   do {
78     // Check if we would not read past the end of the buffer.
79     if ( fPosition+fCount+sizeof(AliRawDataHeader) > fBufferSize ) return kFALSE;
80     
81     fHeader = reinterpret_cast<AliRawDataHeader*>(fBuffer+fPosition+fCount);
82     
83     // Check that the header is sane, that is the size does not go past the buffer.
84     // Otherwise try again at the next word location.
85     if (fHeader->fSize == 0 or fPosition+fCount+fHeader->fSize > fBufferSize) {
86       if (fPosition + sizeof(UInt_t) <= fBufferSize) {
87         fPosition += sizeof(UInt_t);
88         continue;
89       } else {
90         Error("ReadHeader", "Could not find a valid DDL header!");
91         return kFALSE;
92       }
93     } else {
94       fPosition += fCount + sizeof(AliRawDataHeader);
95     }
96
97     if (fHeader->fSize != 0xFFFFFFFF) {
98       fCount = fHeader->fSize - sizeof(AliRawDataHeader);
99     } else {
100       fCount = fBufferSize - fPosition - sizeof(AliRawDataHeader);
101     }
102   } while (!IsSelected());
103
104   return kTRUE;
105 }
106
107 Bool_t AliRawReaderMemory::ReadNextData(UChar_t*& data)
108 {
109 // reads the next payload at the current buffer position
110 // returns kFALSE if the data could not be read
111
112   while (fCount == 0) {
113     if (!ReadHeader()) return kFALSE;
114   }
115   UInt_t currentPosition = fPosition;
116   fPosition += fCount;
117   fCount = 0;
118
119   data = fBuffer+currentPosition;
120   return kTRUE;
121 }
122
123 Bool_t AliRawReaderMemory::ReadNext(UChar_t* data, Int_t size)
124 {
125 // reads the next block of data at the current buffer position
126 // returns kFALSE if the data could not be read
127
128   if ( fBufferSize-fPosition < (UInt_t)size ) return kFALSE;
129
130   memcpy( data, fBuffer+fPosition, size );
131   fCount -= size;
132   fPosition += size;
133   return kTRUE;
134 }
135
136
137 Bool_t AliRawReaderMemory::Reset()
138 {
139 // reset the current position in the buffer to the beginning of the curevent
140
141   fHeader = NULL;
142   fCount = 0;
143   fPosition = 0;
144   return kTRUE;
145 }
146
147 Bool_t AliRawReaderMemory::NextEvent()
148 {
149 // each memory buffer always contains only one event
150   if (fEventNumber < 0) {
151     fEventNumber++;
152     return kTRUE;
153   }
154   else
155     return kFALSE; 
156 }
157
158 Bool_t AliRawReaderMemory::RewindEvents()
159 {
160 // reset the event counter
161   fEventNumber = -1;
162
163   return Reset();
164 }
165
166 Bool_t AliRawReaderMemory::SetMemory( UChar_t* memory, ULong_t size )
167 {
168   fBuffer = memory;
169   fBufferSize = size;
170   fHeader = NULL;
171   fCount = 0;
172   fPosition = 0;
173   return (fBuffer && fBufferSize>0) ? kTRUE : kFALSE;
174 }
175