TMidasEvent.cxx

Go to the documentation of this file.

//
//  TMidasEvent.cxx.
//
//  $Id$
//
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <assert.h>
 
#include "TMidasEvent.h"
 
TMidasEvent::TMidasEvent()
{
  fData = NULL;
  fAllocatedByUs = false;
 
  fBanksN = 0;
  fBankList = NULL;
 
  fEventHeader.fEventId      = 0;
  fEventHeader.fTriggerMask  = 0;
  fEventHeader.fSerialNumber = 0;
  fEventHeader.fTimeStamp    = 0;
  fEventHeader.fDataSize     = 0;
}
 
void TMidasEvent::Copy(const TMidasEvent& rhs)
{
  fEventHeader = rhs.fEventHeader;
 
  fData        = (char*)malloc(fEventHeader.fDataSize);
  assert(fData);
  memcpy(fData, rhs.fData, fEventHeader.fDataSize);
  fAllocatedByUs = true;
 
  fBanksN      = rhs.fBanksN;
  fBankList    = strdup(rhs.fBankList);
  assert(fBankList);
}
 
TMidasEvent::TMidasEvent(const TMidasEvent &rhs)
{
  Copy(rhs);
}
 
TMidasEvent::~TMidasEvent()
{
  Clear();
}
 
TMidasEvent& TMidasEvent::operator=(const TMidasEvent &rhs)
{
  if (&rhs != this)
    Clear();
 
  this->Copy(rhs);
  return *this;
}
 
void TMidasEvent::Clear()
{
  if (fBankList)
    free(fBankList);
  fBankList = NULL;
 
  if (fData && fAllocatedByUs)
    free(fData);
  fData = NULL;
 
  fAllocatedByUs = false;
  fBanksN = 0;
 
  fEventHeader.fEventId      = 0;
  fEventHeader.fTriggerMask  = 0;
  fEventHeader.fSerialNumber = 0;
  fEventHeader.fTimeStamp    = 0;
  fEventHeader.fDataSize     = 0;
}
 
void TMidasEvent::SetData(uint32_t size, char* data)
{
  fEventHeader.fDataSize = size;
  assert(!fAllocatedByUs);
  assert(IsGoodSize());
  fData = data;
  fAllocatedByUs = false;
  SwapBytes(false);
}
 
uint16_t TMidasEvent::GetEventId() const
{
  return fEventHeader.fEventId;
}
 
uint16_t TMidasEvent::GetTriggerMask() const
{
  return fEventHeader.fTriggerMask;
}
 
uint32_t TMidasEvent::GetSerialNumber() const
{
  return fEventHeader.fSerialNumber;
}
 
uint32_t TMidasEvent::GetTimeStamp() const
{
  return fEventHeader.fTimeStamp;
}
 
uint32_t TMidasEvent::GetDataSize() const
{
  return fEventHeader.fDataSize;
}
 
char* TMidasEvent::GetData()
{
  if (!fData)
    AllocateData();
  return fData;
}
 
TMidas_EVENT_HEADER * TMidasEvent::GetEventHeader()
{
  return &fEventHeader;
}
 
bool TMidasEvent::IsGoodSize() const
{
  return fEventHeader.fDataSize > 0 && fEventHeader.fDataSize <= 500 * 1024 * 1024;
}
 
bool TMidasEvent::IsBank32() const
{
  return (((TMidas_BANK_HEADER *)fData)->fFlags & (3<<4)) == 0x10;
}
 
bool TMidasEvent::IsBank32a() const
{
  return (((TMidas_BANK_HEADER *)fData)->fFlags & (3<<4)) == 0x30;
}
 
int TMidasEvent::LocateBank(const void *unused, const char *name, void **pdata) const
{
  /// See FindBank()
 
  int bktype, bklen;
 
  int status = FindBank(name, &bklen, &bktype, pdata);
  
  if (!status)
    {
      *pdata = NULL;
      return 0;
    }
 
  return bklen;
}
 
static const unsigned TID_SIZE[] = {0, 1, 1, 1, 2, 2, 4, 4, 4, 4, 8, 1, 0, 0, 0, 0, 0, 8, 8};
static const unsigned TID_MAX = (sizeof(TID_SIZE)/sizeof(TID_SIZE[0]));
 
int TMidasEvent::FindBank(const char* name, int *bklen, int *bktype, void **pdata) const
{
  /// Find a data bank.
  /// \param [in] name Name of the data bank to look for.
  /// \param [out] bklen Number of array elements in this bank.
  /// \param [out] bktype Bank data type (MIDAS TID_xxx).
  /// \param [out] pdata Pointer to bank data, Returns NULL if bank not found.
  /// \returns 1 if bank found, 0 otherwise.
  ///
 
  const TMidas_BANK_HEADER *pbkh = (const TMidas_BANK_HEADER*)fData; 
  TMidas_BANK *pbk;
  //uint32_t dname;
 
  if (((pbkh->fFlags & (1<<5)) > 0)) {
#if 0
    TMidas_BANK32 *pbk32;
    pbk32 = (TMidas_BANK32 *) (pbkh + 1);
    memcpy(&dname, name, 4);
    do {
      if (*((uint32_t *) pbk32->fName) == dname) {
        *pdata = pbk32 + 1;
        if (TID_SIZE[pbk32->fType & 0xFF] == 0)
          *bklen = pbk32->fDataSize;
        else
          *bklen = pbk32->fDataSize / TID_SIZE[pbk32->fType & 0xFF];
 
        *bktype = pbk32->fType;
        return 1;
      }
      pbk32 = (TMidas_BANK32 *) ((char*) (pbk32 + 1) +
                          (((pbk32->fDataSize)+7) & ~7));
    } while ((char*) pbk32 < (char*) pbkh + pbkh->fDataSize + sizeof(TMidas_BANK_HEADER));
#endif
 
    TMidas_BANK32a *pbk32a = NULL;
 
    while (1) {
      IterateBank32a(&pbk32a, (char**)pdata);
      //printf("looking for [%s] got [%s]\n", name, pbk32->fName);
      if (pbk32a == NULL)
    break;
 
      if (name[0]==pbk32a->fName[0] &&
      name[1]==pbk32a->fName[1] &&
      name[2]==pbk32a->fName[2] &&
      name[3]==pbk32a->fName[3]) {
    
    if (TID_SIZE[pbk32a->fType & 0xFF] == 0)
      *bklen = pbk32a->fDataSize;
    else
      *bklen = pbk32a->fDataSize / TID_SIZE[pbk32a->fType & 0xFF];
    
    *bktype = pbk32a->fType;
    return 1;
      }
    }
  } else if (((pbkh->fFlags & (1<<4)) > 0)) {
#if 0
    TMidas_BANK32 *pbk32;
    pbk32 = (TMidas_BANK32 *) (pbkh + 1);
    memcpy(&dname, name, 4);
    do {
      if (*((uint32_t *) pbk32->fName) == dname) {
        *pdata = pbk32 + 1;
        if (TID_SIZE[pbk32->fType & 0xFF] == 0)
          *bklen = pbk32->fDataSize;
        else
          *bklen = pbk32->fDataSize / TID_SIZE[pbk32->fType & 0xFF];
 
        *bktype = pbk32->fType;
        return 1;
      }
      pbk32 = (TMidas_BANK32 *) ((char*) (pbk32 + 1) +
                          (((pbk32->fDataSize)+7) & ~7));
    } while ((char*) pbk32 < (char*) pbkh + pbkh->fDataSize + sizeof(TMidas_BANK_HEADER));
#endif
 
    TMidas_BANK32 *pbk32 = NULL;
 
    while (1) {
      IterateBank32(&pbk32, (char**)pdata);
      //printf("looking for [%s] got [%s]\n", name, pbk32->fName);
      if (pbk32 == NULL)
    break;
 
      if (name[0]==pbk32->fName[0] &&
      name[1]==pbk32->fName[1] &&
      name[2]==pbk32->fName[2] &&
      name[3]==pbk32->fName[3]) {
    
    if (TID_SIZE[pbk32->fType & 0xFF] == 0)
      *bklen = pbk32->fDataSize;
    else
      *bklen = pbk32->fDataSize / TID_SIZE[pbk32->fType & 0xFF];
    
    *bktype = pbk32->fType;
    return 1;
      }
    }
  } else {
    pbk = (TMidas_BANK *) (pbkh + 1);
    do {
      if (name[0]==pbk->fName[0] &&
      name[1]==pbk->fName[1] &&
      name[2]==pbk->fName[2] &&
      name[3]==pbk->fName[3]) {
        *pdata = pbk + 1;
        if (TID_SIZE[pbk->fType & 0xFF] == 0)
          *bklen = pbk->fDataSize;
        else
          *bklen = pbk->fDataSize / TID_SIZE[pbk->fType & 0xFF];
 
        *bktype = pbk->fType;
        return 1;
      }
      pbk = (TMidas_BANK *) ((char*) (pbk + 1) + (((pbk->fDataSize)+7) & ~7));
    } while ((char*) pbk < (char*) pbkh + pbkh->fDataSize + sizeof(TMidas_BANK_HEADER));
  }
  //
  // bank not found
  //
  *pdata = NULL;
  return 0;
}
 
void TMidasEvent::Print(const char *option) const
{
  /// Print data held in this class.
  /// \param [in] option If 'a' (for "all") then the raw data will be
  /// printed out too.
  ///
  
  time_t t = (time_t)fEventHeader.fTimeStamp;
 
  printf("Event start:\n");
  printf("  event id:       0x%04x\n", fEventHeader.fEventId);
  printf("  trigger mask:   0x%04x\n", fEventHeader.fTriggerMask);
  printf("  serial number:%8d\n", fEventHeader.fSerialNumber);
  printf("  time stamp:     %d, %s", fEventHeader.fTimeStamp, ctime(&t));
  printf("  data size:    %8d\n", fEventHeader.fDataSize);
  if ((fEventHeader.fEventId & 0xffff) == 0x8000)
    {
      printf("Begin of run %d\n", fEventHeader.fSerialNumber);
    }
  else if ((fEventHeader.fEventId & 0xffff) == 0x8001)
    {
      printf("End of run %d\n", fEventHeader.fSerialNumber);
    }
  else if (fBanksN <= 0)
    {
      printf("TMidasEvent::Print: Use SetBankList() before Print() to print bank data\n");
    }
  else
    {
      printf("Banks: %s\n", fBankList);
 
      for (int i = 0; i < fBanksN * 4; i += 4)
    {
      int bankLength = 0;
      int bankType = 0;
      void *pdata = 0;
      int found = FindBank(&fBankList[i], &bankLength, &bankType, &pdata);
      
      printf("Bank %c%c%c%c, length %6d, type %2d\n",
         fBankList[i], fBankList[i+1], fBankList[i+2], fBankList[i+3],
         bankLength, bankType);
 
      if (option[0] == 'a' && found)
        switch (bankType)
          {
          case 4: // TID_WORD
        for (int j = 0; j < bankLength; j++)
          printf("0x%04x%c", ((uint16_t*)pdata)[j], (j%10==9)?'\n':' ');
        printf("\n");
        break;
          case 6: // TID_DWORD
        for (int j = 0; j < bankLength; j++)
          printf("0x%08x%c", ((uint32_t*)pdata)[j], (j%10==9)?'\n':' ');
        printf("\n");
        break;
          case 7: // TID_nd280 (like a DWORD?)
        for (int j = 0; j < bankLength; j++)
          printf("0x%08x%c", ((uint32_t*)pdata)[j], (j%10==9)?'\n':' ');
        printf("\n");
        break;
          case 9: // TID_FLOAT
        for (int j = 0; j < bankLength; j++)
          printf("%.8g%c", ((float*)pdata)[j], (j%10==9)?'\n':' ');
        printf("\n");
        break;
          case 10: // TID_DOUBLE
        for (int j = 0; j < bankLength; j++)
          printf("%.16g%c", ((double*)pdata)[j], (j%10==9)?'\n':' ');
        printf("\n");
        break;
          default:
        printf("TMidasEvent::Print: Do not know how to print bank of type %d\n", bankType);
        break;
          }
    }
    }
}
 
void TMidasEvent::AllocateData()
{
  assert(!fAllocatedByUs);
  assert(IsGoodSize());
  fData = (char*)malloc(fEventHeader.fDataSize);
  assert(fData);
  fAllocatedByUs = true;
}
 
const char* TMidasEvent::GetBankList() const
{
  return fBankList;
}
 
int TMidasEvent::SetBankList()
{
  if (fEventHeader.fEventId <= 0)
    return 0;
 
  // Check if it is FIXED-style event ; but comment out check for now
  if(0){
    TMidas_BANK_HEADER *pbh = (TMidas_BANK_HEADER *) (fData);  
    if(GetEventHeader()->fDataSize - (pbh->fDataSize + 8) != 0){ 
      printf("Found FIXED-style event.  Skipping.\n"); 
      return 0;  
    }       
  }               
 
  if (fBankList)
    return fBanksN;
 
  int listSize = 0;
 
  fBanksN = 0;
 
  TMidas_BANK32a *pmbk32a = NULL;
  TMidas_BANK32 *pmbk32 = NULL;
  TMidas_BANK *pmbk = NULL;
  char *pdata = NULL;
 
  while (1)
    {
      if (fBanksN*4 >= listSize)
    {
      listSize += 400;
      fBankList = (char*)realloc(fBankList, listSize);
    }
 
      if (IsBank32a())
    {
      IterateBank32a(&pmbk32a, &pdata);
      if (pmbk32a == NULL)
        break;
      memcpy(fBankList+fBanksN*4, pmbk32a->fName, 4);
      fBanksN++;
    }
      else if (IsBank32())
    {
      IterateBank32(&pmbk32, &pdata);
      if (pmbk32 == NULL)
        break;
      memcpy(fBankList+fBanksN*4, pmbk32->fName, 4);
      fBanksN++;
    }
      else
    {
      IterateBank(&pmbk, &pdata);
      if (pmbk == NULL)
        break;
      memcpy(fBankList+fBanksN*4, pmbk->fName, 4);
      fBanksN++;
    }
    }
 
  fBankList[fBanksN*4] = 0;
 
  return fBanksN;
}
 
int TMidasEvent::IterateBank(TMidas_BANK **pbk, char **pdata) const
{
  /// Iterates through banks inside an event. The function can be used
  /// to enumerate all banks of an event.
  /// \param [in] pbk Pointer to the bank header, must be NULL for the
  /// first call to this function. Returns NULL if no more banks
  /// \param [in] pdata Pointer to data area of bank. Returns NULL if no more banks
  /// \returns Size of bank in bytes or 0 if no more banks.
  ///
  const TMidas_BANK_HEADER* event = (const TMidas_BANK_HEADER*)fData;
 
  if (*pbk == NULL)
    *pbk = (TMidas_BANK *) (event + 1);
  else
    *pbk = (TMidas_BANK *) ((char*) (*pbk + 1) + ((((*pbk)->fDataSize)+7) & ~7));
 
  *pdata = (char*)((*pbk) + 1);
 
  if ((char*) *pbk >=  (char*) event + event->fDataSize + sizeof(TMidas_BANK_HEADER))
    {
      *pbk = NULL;
      *pdata = NULL;
      return 0;
    }
 
  return (*pbk)->fDataSize;
}
 
int TMidasEvent::IterateBank32(TMidas_BANK32 **pbk, char **pdata) const
{
  /// See IterateBank()
 
  const TMidas_BANK_HEADER* event = (const TMidas_BANK_HEADER*)fData;
  if (*pbk == NULL)
    *pbk = (TMidas_BANK32 *) (event + 1);
  else {
    uint32_t length = (*pbk)->fDataSize;
    uint32_t length_adjusted = (length+7) & ~7;
    //printf("length %6d 0x%08x, 0x%08x\n", length, length, length_adjusted);
    *pbk = (TMidas_BANK32 *) ((char*) (*pbk + 1) + length_adjusted);
  }
 
  TMidas_BANK32 *bk4 = (TMidas_BANK32*)(((char*) *pbk) + 4);
 
  //printf("iterate bank32: pbk 0x%p, align %d, type %d %d, name [%s], next [%s], TID_MAX %d\n", *pbk, (int)( ((uint64_t)(*pbk))&7), (*pbk)->fType, bk4->fType, (*pbk)->fName, bk4->fName, TID_MAX);
 
  if ((*pbk)->fType > TID_MAX) // bad - unknown bank type - it's invalid MIDAS file?
    {
      if (bk4->fType <= TID_MAX) // okey, this is a malformed T2K/ND280 data file
    {
      *pbk = bk4;
 
      //printf("iterate bank32: pbk 0x%p, align %d, type %d, name [%s]\n", *pbk, (int)(((uint64_t)(*pbk))&7), (*pbk)->fType, (*pbk)->fName);
    }
      else
    {
      // truncate invalid data
      *pbk = NULL;
      *pdata = NULL;
      return 0;
    }
    }
 
  *pdata = (char*)((*pbk) + 1);
 
  if ((char*) *pbk >= (char*)event  + event->fDataSize + sizeof(TMidas_BANK_HEADER))
    {
      *pbk = NULL;
      *pdata = NULL;
      return 0;
    }
 
  return (*pbk)->fDataSize;
}
 
int TMidasEvent::IterateBank32a(TMidas_BANK32a **pbk, char **pdata) const
{
  /// See IterateBank()
 
  const TMidas_BANK_HEADER* event = (const TMidas_BANK_HEADER*)fData;
  if (*pbk == NULL)
    *pbk = (TMidas_BANK32a *) (event + 1);
  else {
    uint32_t length = (*pbk)->fDataSize;
    uint32_t length_adjusted = (length+7) & ~7;
    //printf("length %6d 0x%08x, 0x%08x\n", length, length, length_adjusted);
    *pbk = (TMidas_BANK32a *) ((char*) (*pbk + 1) + length_adjusted);
  }
 
  TMidas_BANK32a *bk4 = (TMidas_BANK32a*)(((char*) *pbk) + 4);
 
  //printf("iterate bank32: pbk 0x%p, align %d, type %d %d, name [%s], next [%s], TID_MAX %d\n", *pbk, (int)( ((uint64_t)(*pbk))&7), (*pbk)->fType, bk4->fType, (*pbk)->fName, bk4->fName, TID_MAX);
 
  if ((*pbk)->fType > TID_MAX) // bad - unknown bank type - it's invalid MIDAS file?
    {
      if (bk4->fType <= TID_MAX) // okey, this is a malformed T2K/ND280 data file
    {
      *pbk = bk4;
 
      //printf("iterate bank32: pbk 0x%p, align %d, type %d, name [%s]\n", *pbk, (int)(((uint64_t)(*pbk))&7), (*pbk)->fType, (*pbk)->fName);
    }
      else
    {
      // truncate invalid data
      *pbk = NULL;
      *pdata = NULL;
      return 0;
    }
    }
 
  *pdata = (char*)((*pbk) + 1);
 
  if ((char*) *pbk >= (char*)event  + event->fDataSize + sizeof(TMidas_BANK_HEADER))
    {
      *pbk = NULL;
      *pdata = NULL;
      return 0;
    }
 
  return (*pbk)->fDataSize;
}
 
typedef uint8_t BYTE;
 
/// Byte swapping routine.
///
#define QWORD_SWAP(x) { BYTE _tmp;       \
_tmp= *((BYTE *)(x));                    \
*((BYTE *)(x)) = *(((BYTE *)(x))+7);     \
*(((BYTE *)(x))+7) = _tmp;               \
_tmp= *(((BYTE *)(x))+1);                \
*(((BYTE *)(x))+1) = *(((BYTE *)(x))+6); \
*(((BYTE *)(x))+6) = _tmp;               \
_tmp= *(((BYTE *)(x))+2);                \
*(((BYTE *)(x))+2) = *(((BYTE *)(x))+5); \
*(((BYTE *)(x))+5) = _tmp;               \
_tmp= *(((BYTE *)(x))+3);                \
*(((BYTE *)(x))+3) = *(((BYTE *)(x))+4); \
*(((BYTE *)(x))+4) = _tmp; }
 
/// Byte swapping routine.
///
#define DWORD_SWAP(x) { BYTE _tmp;       \
_tmp= *((BYTE *)(x));                    \
*((BYTE *)(x)) = *(((BYTE *)(x))+3);     \
*(((BYTE *)(x))+3) = _tmp;               \
_tmp= *(((BYTE *)(x))+1);                \
*(((BYTE *)(x))+1) = *(((BYTE *)(x))+2); \
*(((BYTE *)(x))+2) = _tmp; }
 
/// Byte swapping routine.
///
#define WORD_SWAP(x) { BYTE _tmp;        \
_tmp= *((BYTE *)(x));                    \
*((BYTE *)(x)) = *(((BYTE *)(x))+1);     \
*(((BYTE *)(x))+1) = _tmp; }
 
void TMidasEvent::SwapBytesEventHeader()
{
  WORD_SWAP(&fEventHeader.fEventId);
  WORD_SWAP(&fEventHeader.fTriggerMask);
  DWORD_SWAP(&fEventHeader.fSerialNumber);
  DWORD_SWAP(&fEventHeader.fTimeStamp);
  DWORD_SWAP(&fEventHeader.fDataSize);
}
 
int TMidasEvent::SwapBytes(bool force)
{
  TMidas_BANK_HEADER *pbh;
  TMidas_BANK *pbk;
  TMidas_BANK32 *pbk32;
  void *pdata;
  uint16_t type;
 
  pbh = (TMidas_BANK_HEADER *) fData;
 
  uint32_t dssw = pbh->fDataSize;
 
  DWORD_SWAP(&dssw);
 
  //printf("SwapBytes %d, flags 0x%x 0x%x\n", force, pbh->fFlags, pbh->fDataSize);
  //printf("evh.datasize: 0x%08x, SwapBytes: %d, pbh.flags: 0x%08x, pbh.datasize: 0x%08x swapped 0x%08x\n", fEventHeader.fDataSize, force, pbh->fFlags, pbh->fDataSize, dssw);
 
  //
  // only swap if flags in high 16-bit
  //
  if (pbh->fFlags < 0x10000 && ! force)
    return 0;
 
  if (pbh->fDataSize == 0x6d783f3c) // string "<xml..." in wrong-endian format
    return 1;
 
  if (pbh->fDataSize == 0x3c3f786d) // string "<xml..."
    return 1;
 
  if (dssw > fEventHeader.fDataSize + 100) // swapped data size looks wrong. do not swap.
    return 1;
 
  //
  // swap bank header
  //
  DWORD_SWAP(&pbh->fDataSize);
  DWORD_SWAP(&pbh->fFlags);
  //
  // check for 32-bit banks
  //
  bool b32 = IsBank32();
  bool b32a = IsBank32a();
 
  if (b32a) {
    fprintf(stderr, "TMidasEvent::SwapBytes() cannot swap bk_init32a data, sorry. bye!\n");
    abort();
  }
 
  pbk = (TMidas_BANK *) (pbh + 1);
  pbk32 = (TMidas_BANK32 *) pbk;
  //
  // scan event
  //
  while ((char*) pbk < (char*) pbh + pbh->fDataSize + sizeof(TMidas_BANK_HEADER)) {
    //
    // swap bank header
    //
    if (b32) {
      DWORD_SWAP(&pbk32->fType);
      DWORD_SWAP(&pbk32->fDataSize);
      pdata = pbk32 + 1;
      type = (uint16_t) pbk32->fType;
    } else {
      WORD_SWAP(&pbk->fType);
      WORD_SWAP(&pbk->fDataSize);
      pdata = pbk + 1;
      type = pbk->fType;
    }
    //
    // pbk points to next bank
    //
    if (b32) {
      assert(pbk32->fDataSize < fEventHeader.fDataSize + 100);
      pbk32 = (TMidas_BANK32 *) ((char*) (pbk32 + 1) +
                          (((pbk32->fDataSize)+7) & ~7));
      pbk = (TMidas_BANK *) pbk32;
    } else {
      assert(pbk->fDataSize < fEventHeader.fDataSize + 100);
      pbk = (TMidas_BANK *) ((char*) (pbk + 1) +  (((pbk->fDataSize)+7) & ~7));
      pbk32 = (TMidas_BANK32 *) pbk;
    }
 
    switch (type) {
    case 4:
    case 5:
      while (pdata < pbk) {
        WORD_SWAP(pdata);
        pdata = ((char*)pdata) + 2;
      }
      break;
    case 6:
    case 7:
    case 8:
    case 9:
      while (pdata < pbk) {
        DWORD_SWAP(pdata);
        pdata = ((char*)pdata) + 4;
      }
      break;
    case 10: // TID_DOUBLE
      while (pdata < pbk) {
        QWORD_SWAP(pdata);
        pdata = ((char*)pdata) + 8;
      }
      break;
    case 17: // TID_INT64
    case 18: // TID_UINT64
      while (pdata < pbk) {
        QWORD_SWAP(pdata);
        pdata = ((char*)pdata) + 8;
      }
      break;
    }
  }
  return 1;
}
 
#include "midasio.h"
 
// read and write functions
bool TMReadEvent(TMReaderInterface* reader, TMidasEvent* event)
{
  static uint32_t endian = 0x12345678;
  static bool once = true;
  static bool gDoByteSwap = false;
  if (once) {
    once = false;
    gDoByteSwap = *(char*)(&endian) != 0x78;
  }
 
  event->Clear();
 
  int rd = reader->Read((char*)event->GetEventHeader(), sizeof(TMidas_EVENT_HEADER));
 
  if (rd == 0)
    {
      return false;
    }
  else if (rd != sizeof(TMidas_EVENT_HEADER))
    {
      return false;
    }
 
  if (gDoByteSwap)
    event->SwapBytesEventHeader();
 
  if (!event->IsGoodSize())
    {
      return false;
    }
 
  rd = reader->Read((char*)event->GetData(), event->GetDataSize());
 
  if (rd != (int)event->GetDataSize())
    {
      return false;
    }
 
  event->SwapBytes(false);
 
  return true;
}
 
bool TMWriteEvent(TMWriterInterface* writer, TMidasEvent* event)
{
  int wr = writer->Write((char*)event->GetEventHeader(), sizeof(TMidas_EVENT_HEADER));
  
  if (wr != sizeof(TMidas_EVENT_HEADER)) {
    printf("TMidasFile: error on write event header, return %d, size requested %d\n", wr, (int)sizeof(TMidas_EVENT_HEADER));
    return false;
  }
  
  wr = writer->Write((char*)event->GetData(), event->GetDataSize());
  
  if (wr != (int)event->GetDataSize()) {
    printf("TMidasFile: error on write event header, return %d, size requested %d\n", wr, (int)event->GetDataSize());
    return false;
  }
 
  return true;
}
 
// end