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) ||
  86            ((Int_t)fPosition + fCount + (Int_t)fHeader->fSize > (Int_t)fBufferSize ) )
  87          && fHeader->fSize != 0xFFFFFFFF) {
  88
  89       if (fPosition + sizeof(UInt_t) <= fBufferSize) {
  90         fPosition += sizeof(UInt_t);
  91         continue;
  92       } else {
  93         Error("ReadHeader", "Could not find a valid DDL header!");
  94         return kFALSE;
  95       }
  96     } else {
  97       fPosition += fCount + sizeof(AliRawDataHeader);
  98     }
  99
 100     if (fHeader->fSize != 0xFFFFFFFF) {
 101       fCount = fHeader->fSize - sizeof(AliRawDataHeader);
 102     } else {
 103       fCount = fBufferSize - sizeof(AliRawDataHeader);
 104     }
 105   } while (!IsSelected());
 106
 107   return kTRUE;
 108 }
 109
 110 Bool_t AliRawReaderMemory::ReadNextData(UChar_t*& data)
 111 {
 112 // reads the next payload at the current buffer position
 113 // returns kFALSE if the data could not be read
 114
 115   while (fCount == 0) {
 116     if (!ReadHeader()) return kFALSE;
 117   }
 118   UInt_t currentPosition = fPosition;
 119   fPosition += fCount;
 120   fCount = 0;
 121
 122   data = fBuffer+currentPosition;
 123   return kTRUE;
 124 }
 125
 126 Bool_t AliRawReaderMemory::ReadNext(UChar_t* data, Int_t size)
 127 {
 128 // reads the next block of data at the current buffer position
 129 // returns kFALSE if the data could not be read
 130
 131   if ( fBufferSize-fPosition < (UInt_t)size ) return kFALSE;
 132
 133   memcpy( data, fBuffer+fPosition, size );
 134   fCount -= size;
 135   fPosition += size;
 136   return kTRUE;
 137 }
 138
 139
 140 Bool_t AliRawReaderMemory::Reset()
 141 {
 142 // reset the current position in the buffer to the beginning of the curevent
 143
 144   fHeader = NULL;
 145   fCount = 0;
 146   fPosition = 0;
 147   return kTRUE;
 148 }
 149
 150 Bool_t AliRawReaderMemory::NextEvent()
 151 {
 152 // each memory buffer always contains only one event
 153   if (fEventNumber < 0) {
 154     fEventNumber++;
 155     return kTRUE;
 156   }
 157   else
 158     return kFALSE;
 159 }
 160
 161 Bool_t AliRawReaderMemory::RewindEvents()
 162 {
 163 // reset the event counter
 164   fEventNumber = -1;
 165
 166   return Reset();
 167 }
 168
 169 Bool_t AliRawReaderMemory::SetMemory( UChar_t* memory, ULong_t size )
 170 {
 171   fBuffer = memory;
 172   fBufferSize = size;
 173   fHeader = NULL;
 174   fCount = 0;
 175   fPosition = 0;
 176   return (fBuffer && fBufferSize>0) ? kTRUE : kFALSE;
 177 }
 178