framefast/framefast.hh

/*----------------------------------------------------------------------*/
/*                                                                      */
/* Module Name: framefast                                               */
/*                                                                      */
/* Module Description: Frame reader using TOC for fast access           */
/*                                                                      */
/* Revision History:                                                    */
/* Rel   Date     Programmer    Comments                                */
/* 0.1   26Sep00  D. Sigg       First release                           */
/*                                                                      */
/* Documentation References:                                            */
/*      Man Pages: framefast.html                                       */
/*      References: none                                                */
/*                                                                      */
/* Author Information:                                                  */
/* Name          Telephone       Fax             e-mail                 */
/* Daniel Sigg   (509) 372-8132  (509) 372-8137  sigg_d@ligo.mit.edu    */
/*                                                                      */
/*                                                                      */
/*                      -------------------                             */
/*                                                                      */
/*                             LIGO                                     */
/*                                                                      */
/*        THE LASER INTERFEROMETER GRAVITATIONAL WAVE OBSERVATORY.      */
/*                                                                      */
/*                     (C) The LIGO Project, 1999.                      */
/*                                                                      */
/*                                                                      */
/* Caltech                              MIT                             */
/* LIGO Project MS 51-33                LIGO Project NW-17 161          */
/* Pasadena CA 91125                    Cambridge MA 01239              */
/*                                                                      */
/* LIGO Hanford Observatory             LIGO Livingston Observatory     */
/* P.O. Box 1970 S9-02                  19100 LIGO Lane Rd.             */
/* Richland WA 99352                    Livingston, LA 70754            */
/*                                                                      */
/*----------------------------------------------------------------------*/

#ifndef _LIGO_FRAMEFAST_H
#define _LIGO_FRAMEFAST_H


#include <iosfwd>
#include <deque>
#include <vector>
#include "Time.hh"
#include "Interval.hh"
#include "framefast/frametype.hh"
#include "framefast/frameio.hh"

#if defined(__SUNPRO_CC) && defined(G__DICTIONARY)
   namespace framefast {}
   using namespace framefast;
#endif



namespace framefast {

   class framereader {
   private:
      framereader (const framereader&);
      framereader& operator= (const framereader&);
   
   public:
      framereader ();
      virtual ~framereader();
   
      bool loadFile (const char* filename, bool map = true);
      bool loadFrame (const void* fdata, int len, bool ownit = false);
      bool loadFrame (basic_frame_storage* frame) {
         frame_storage_ptr ptr (frame); 
         return loadFrame (ptr); }
      bool loadFrame (frame_storage_ptr& frame) {
         fFrame = frame;
         return (fFrame.data() != 0); }
      bool releaseFrame (frame_storage_ptr& frame);
   
      void unload ();
   
      bool isFrame ();
   
      bool getDict (dict_t& dict);
   
      bool getFrameHeader (frameheader_t& h, int fnum = 0);
   
      bool getDetectorInfo (detector_t& det, int fnum = 0, int dnum = 0);
      int getDetectorInfoNum();
   
      bool getHistoryInfo (hist_t& hist, int fnum = 0);
   
      bool getRawDataInfo (rawdata_t& raw, int fnum = 0);
   
      bool getData (data_t& dat, int_8u_t pos, datatype_t dtype,
                   frvect_t::datacopy cpy = frvect_t::fv_copy);
   
      bool getData (data_t& dat, const char* channel, int nframe = 0,  
                   frvect_t::datacopy cpy = frvect_t::fv_copy);
   
      int copy (const char* chnname, real_4_t* x, int max);

      int copy (const char* chnname, real_8_t* x, int max);

      int copy (const char* chnname, int_2s_t* x, int max);

      int copy (const char* chnname, int_4s_t* x, int max);
   
      std::ostream& writeTOC (std::ostream& os);
   
      std::ostream& writeFileHeader (std::ostream& os);
   
      int length() const {
         return fFrame.size(); }
      const char* frame() const {
         return fFrame.data(); }
      const char* frameend() const {
         return frame() + length(); }
      const char* fname() const {
         return fFrame.name(); }
      std::string guessFilename();
   
      int nframe();
      Time starttime (int framenum = 0);
      Interval duration (int framenum = 0);
      Time nexttime ();
      const toc_t* getTOC();
      void setScanTOC (bool set = true) {
         fForceScanToc = set; }
   
   protected:
      enum toc_status_t {
      kTOCUndefined = 0,
      kTOCNo,
      kTOCYes
      };
      enum header_status_t {
      kFileHeaderUndefined = 0,
      kFileHeaderInvalid,
      kFileHeaderValid
      };
   
      bool              fDebug;
      frame_storage_ptr fFrame;
      toc_t*            fTOC;
      toc_status_t      fHasTOC;
      bool              fForceScanToc;
      fileheader_t*     fFileHeader;
      header_status_t   fHasFileHeader;
      frameheader_t*    fFrameHeader;
      bool              fSwap;
   
      bool newTOC();
      bool freeTOC();
      bool readTOC();
      bool scanTOC();
   
      bool newFileHeader();
      bool freeFileHeader();
      bool readFileHeader();
   
      int lookup (const char* chnname, int_8u_t*& ofs, datatype_t& dtype);
   };


   std::ostream& operator<< (std::ostream& os, const framereader& fr);


   class framewriter {
   private:
      framewriter (const framewriter&);
      framewriter& operator= (const framewriter&);
   
   public:
      enum framepos {
      framebegin = 0,
      framebusy,
      framebreak,
      frameend
      };
   
      class framebuffer_t {
      public:
         explicit framebuffer_t (int size = 0);
         framebuffer_t (const framebuffer_t& buf);
         ~framebuffer_t ();
         framebuffer_t& operator= (const framebuffer_t& buf);
         bool allocate (int size);
         void deallocate ();
      
         const char* data() const {
            return fData; }
         char* pos() const {
            return fData ? fData + fLen : 0; }
         int len() const {
            return fLen; }
         int size() const {
            return fSize; }
         void expand (int len) {
            fLen += len; }
      protected:
         int            fLen;
         int            fSize;
         char*          fData;
         mutable bool   fOwn;
      };
      typedef std::deque<framebuffer_t> framebufferlist;
      typedef std::vector<detector_t> detector_array_t;
   
   
      explicit framewriter (int nFrameLen = 1, int nFrame = 1,
                        int compress = 0, 
                        int version = kDefaultFrameVersion);
      ~framewriter ();
   
      framepos status() {
         return fFramePos; }
      bool setFormat (int nFrameLen = 1, int nFrame = 1, 
                     int compress = 0,
                     int version = kDefaultFrameVersion);
      int frameLength () const {
         return fFrameLen; }
      bool setTime (const Time& time);
   
      bool setDetectorInfo (const detector_t& det);
      bool addDetectorInfo (const detector_t& det);
      const detector_t* getDetectorInfo (int dnum = 0) const {
         return ((dnum >= 0) && (dnum < (int)fDetector.size())) ?
            &fDetector[0] : 0; }
      const toc_t* getTOC () const {
         return &fTOC; }
      int nframe() const;
      Time starttime (int framenum = 0) const;
      Interval duration (int framenum = 0) const;
      Time nexttime () const;
   
      bool addData (const adcdata_t& adc, const frvect_t& vect);
   
      bool next();

      bool next (const Time& nextframe);
   
      bool write (basic_frameout* out);
      bool getBuffers (framebufferlist& bufs) {
         bufs = fFrameBuffer; purge(); 
         return true; }
   
      int buffers() const {
         return fFrameBuffer.size(); }
      const char* framebuffer (int buffer) const {
         return ((buffer >= 0) && (buffer < (int)fFrameBuffer.size())) ? 
            fFrameBuffer[buffer].data() : 0; }
      int bufferlen (int buffer) const {
         return ((buffer >= 0) && (buffer < (int)fFrameBuffer.size())) ? 
            fFrameBuffer[buffer].len() : 0; }
      int total() const {
         return fTotal; }
      void purge () {
         fFrameBuffer.clear(); }
   
      void setFilename (const char* filename) {
         fFilename = filename; }
      const char* getFilename () const {
         return fFilename.c_str(); }
      std::string guessFilename() const;
      void setFrameNum (int num) {
         fFrameNum = num; }
      int getFrameNum () const {
         return fFrameNum; }
      void setRunNum (int num) {
         fRunNum = num; }
      int getRunNum () const {
         return fRunNum; }
   
   protected:
      bool              fSwap;
      int               fVersion;
      framepos          fFramePos;
      Time              fTime;
      Time              fNext;
      int               fRunNum;
      int               fFrameNum;
      int               fFrameLen;
      int               fNFrame;
      int               fCompress;
      int               fN;
      int               fTotal;
      framebufferlist   fFrameBuffer;
      detector_array_t  fDetector;
      toc_t             fTOC;
      std::string       fFilename;
   
      ptr_struct        fPtr[9];
   
      framebuffer_t* currentBuffer();
      bool appendBuffer (const char* dat, int len);
      bool beginFile();
      bool endFile();
      bool beginFrame();
      bool endFrame();
   };

}

#endif /* _LIGO_FRAMEFAST_H */

---