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