libmseed.h

Go to the documentation of this file.

 
#ifndef LIBMSEED_H
#define LIBMSEED_H 1
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define LIBMSEED_VERSION "3.1.9"    
#define LIBMSEED_RELEASE "2025.267" 


 
/* C99 standard headers */
#include <ctype.h>
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define PRIsize_t "zu"
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#define LMP_WIN 1
#endif
 
/* Set platform specific features, Windows versus everything else */
#if defined(LMP_WIN)
#include <sys/timeb.h>
#include <sys/types.h>
#include <windows.h>
 
/* Re-define print conversion for size_t values */
#undef PRIsize_t
#if defined(WIN64) || defined(_WIN64)
#define PRIsize_t "I64u"
#else
#define PRIsize_t "I32u"
#endif
 
/* For MSVC 2012 and earlier define standard int types, otherwise use inttypes.h */
#if defined(_MSC_VER) && _MSC_VER <= 1700
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef signed short int int16_t;
typedef unsigned short int uint16_t;
typedef signed int int32_t;
typedef unsigned int uint32_t;
typedef signed __int64 int64_t;
typedef unsigned __int64 uint64_t;
#else
#include <inttypes.h>
#endif
 
/* For MSVC define PRId64 and SCNd64 and alternate functions */
#if defined(_MSC_VER)
#if !defined(PRId64)
#define PRId64 "I64d"
#endif
#if !defined(SCNd64)
#define SCNd64 "I64d"
#endif
 
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#define strcasecmp _stricmp
#define strncasecmp _strnicmp
#define strtoull _strtoui64
#define fileno _fileno
#define fdopen _fdopen
#endif
 
/* Extras needed for MinGW */
#if defined(__MINGW32__) || defined(__MINGW64__)
#include <fcntl.h>
 
#define _fseeki64 fseeko64
#define _ftelli64 ftello64
 
#define fstat _fstat
#define stat _stat
#endif
#else
/* All other platforms */
#include <inttypes.h>
#include <sys/time.h>
#endif
 
#define MINRECLEN 40       
#define MAXRECLEN 10485760 
#define MAXRECLENv2 131172 
 
#define LM_SIDLEN 64 

#define MS_ISRATETOLERABLE(A, B) (fabs (1.0 - ((A) / (B))) < 0.0001)

#define MS2_ISDATAINDICATOR(X) ((X) == 'D' || (X) == 'R' || (X) == 'Q' || (X) == 'M')

#define MS3_ISVALIDHEADER(X)                                                                       \
  (*(X) == 'M' && *((X) + 1) == 'S' && *((X) + 2) == 3 && (uint8_t)(*((X) + 12)) >= 0 &&           \
   (uint8_t)(*((X) + 12)) <= 23 && (uint8_t)(*((X) + 13)) >= 0 && (uint8_t)(*((X) + 13)) <= 59 &&  \
   (uint8_t)(*((X) + 14)) >= 0 && (uint8_t)(*((X) + 14)) <= 60)

#define MS2_ISVALIDHEADER(X)                                                                       \
  ((isdigit ((uint8_t)*(X)) || *(X) == ' ' || !*(X)) &&                                            \
   (isdigit ((uint8_t)*((X) + 1)) || *((X) + 1) == ' ' || !*((X) + 1)) &&                          \
   (isdigit ((uint8_t)*((X) + 2)) || *((X) + 2) == ' ' || !*((X) + 2)) &&                          \
   (isdigit ((uint8_t)*((X) + 3)) || *((X) + 3) == ' ' || !*((X) + 3)) &&                          \
   (isdigit ((uint8_t)*((X) + 4)) || *((X) + 4) == ' ' || !*((X) + 4)) &&                          \
   (isdigit ((uint8_t)*((X) + 5)) || *((X) + 5) == ' ' || !*((X) + 5)) &&                          \
   MS2_ISDATAINDICATOR (*((X) + 6)) && (*((X) + 7) == ' ' || *((X) + 7) == '\0') &&                \
   (uint8_t)(*((X) + 24)) >= 0 && (uint8_t)(*((X) + 24)) <= 23 && (uint8_t)(*((X) + 25)) >= 0 &&   \
   (uint8_t)(*((X) + 25)) <= 59 && (uint8_t)(*((X) + 26)) >= 0 && (uint8_t)(*((X) + 26)) <= 60)

#define bit(x, y) ((x) & (y)) ? 1 : 0

#ifdef _MSC_VER
#define DEPRECATED __declspec (deprecated)
#elif defined(__GNUC__) | defined(__clang__)
#define DEPRECATED __attribute__ ((__deprecated__))
#else
#define DEPRECATED
#endif


typedef int64_t nstime_t;

#define NSTMODULUS 1000000000

#define NSTERROR -2145916800000000000LL

#define NSTUNSET -2145916799999999999LL

#define MS_EPOCH2NSTIME(X) (X) * (nstime_t)NSTMODULUS

#define MS_NSTIME2EPOCH(X) (X) / NSTMODULUS

#define MS_HPTIME2NSTIME(X) (X) * (nstime_t)1000

#define MS_NSTIME2HPTIME(X) (X) / 1000

typedef enum
{
  ISOMONTHDAY = 0,
  ISOMONTHDAY_Z = 1,
  ISOMONTHDAY_DOY = 2,
  ISOMONTHDAY_DOY_Z = 3,
  ISOMONTHDAY_SPACE = 4,
  ISOMONTHDAY_SPACE_Z = 5,
  SEEDORDINAL = 6,
  UNIXEPOCH = 7,
  NANOSECONDEPOCH = 8
} ms_timeformat_t;

typedef enum
{
  NONE = 0,
  MICRO = 1,
  NANO = 2,
  MICRO_NONE = 3,
  NANO_NONE = 4,
  NANO_MICRO = 5,
  NANO_MICRO_NONE = 6
} ms_subseconds_t;
 
extern int ms_nstime2time (nstime_t nstime, uint16_t *year, uint16_t *yday, uint8_t *hour,
                           uint8_t *min, uint8_t *sec, uint32_t *nsec);
extern char *ms_nstime2timestr_n (nstime_t nstime, char *timestr, size_t timestrsize,
                                  ms_timeformat_t timeformat, ms_subseconds_t subsecond);
DEPRECATED extern char *ms_nstime2timestr (nstime_t nstime, char *timestr,
                                           ms_timeformat_t timeformat, ms_subseconds_t subsecond);
DEPRECATED extern char *ms_nstime2timestrz (nstime_t nstime, char *timestr,
                                            ms_timeformat_t timeformat, ms_subseconds_t subsecond);
extern nstime_t ms_time2nstime (int year, int yday, int hour, int min, int sec, uint32_t nsec);
extern nstime_t ms_timestr2nstime (const char *timestr);
extern nstime_t ms_mdtimestr2nstime (const char *timestr);
extern nstime_t ms_seedtimestr2nstime (const char *seedtimestr);
extern int ms_doy2md (int year, int yday, int *month, int *mday);
extern int ms_md2doy (int year, int month, int mday, int *yday);



#define MS_PACK_DEFAULT_RECLEN 4096

#define MS_PACK_DEFAULT_ENCODING DE_STEIM2


typedef struct MS3Record
{
  const char *record; 
  int32_t reclen;     
  uint8_t swapflag;   
 
  /* Common header fields in accessible form */
  char sid[LM_SIDLEN];   
  uint8_t formatversion; 
  uint8_t flags;         
  nstime_t starttime;    
  double samprate;       
  int16_t encoding;      
  uint8_t pubversion;    
  int64_t samplecnt;     
  uint32_t crc;          
  uint16_t extralength;  
  uint32_t datalength;   
  char *extra;           
 
  /* Data sample fields */
  void *datasamples;  
  uint64_t datasize;  
  int64_t numsamples; 
  char sampletype;    
} MS3Record;

#define MS3Record_INITIALIZER                                                                      \
  {.record = NULL,                                                                                 \
   .reclen = -1,                                                                                   \
   .swapflag = 0,                                                                                  \
   .sid = {0},                                                                                     \
   .formatversion = 0,                                                                             \
   .flags = 0,                                                                                     \
   .starttime = NSTUNSET,                                                                          \
   .samprate = 0.0,                                                                                \
   .encoding = -1,                                                                                 \
   .pubversion = 0,                                                                                \
   .samplecnt = -1,                                                                                \
   .crc = 0,                                                                                       \
   .extralength = 0,                                                                               \
   .datalength = 0,                                                                                \
   .extra = NULL,                                                                                  \
   .datasamples = NULL,                                                                            \
   .datasize = 0,                                                                                  \
   .numsamples = 0,                                                                                \
   .sampletype = 0}
 
extern int msr3_parse (const char *record, uint64_t recbuflen, MS3Record **ppmsr, uint32_t flags,
                       int8_t verbose);
 
extern int msr3_pack (const MS3Record *msr, void (*record_handler) (char *, int, void *),
                      void *handlerdata, int64_t *packedsamples, uint32_t flags, int8_t verbose);
 
extern int msr3_repack_mseed3 (const MS3Record *msr, char *record, uint32_t recbuflen,
                               int8_t verbose);
 
extern int msr3_repack_mseed2 (const MS3Record *msr, char *record, uint32_t recbuflen,
                               int8_t verbose);
 
extern int msr3_pack_header3 (const MS3Record *msr, char *record, uint32_t recbuflen,
                              int8_t verbose);
 
extern int msr3_pack_header2 (const MS3Record *msr, char *record, uint32_t recbuflen,
                              int8_t verbose);
 
extern int64_t msr3_unpack_data (MS3Record *msr, int8_t verbose);
 
extern int msr3_data_bounds (const MS3Record *msr, uint32_t *dataoffset, uint32_t *datasize);
 
extern int64_t ms_decode_data (const void *input, uint64_t inputsize, uint8_t encoding,
                               uint64_t samplecount, void *output, uint64_t outputsize,
                               char *sampletype, int8_t swapflag, const char *sid, int8_t verbose);
 
extern MS3Record *msr3_init (MS3Record *msr);
extern void msr3_free (MS3Record **ppmsr);
extern MS3Record *msr3_duplicate (const MS3Record *msr, int8_t datadup);
extern nstime_t msr3_endtime (const MS3Record *msr);
extern void msr3_print (const MS3Record *msr, int8_t details);
extern int msr3_resize_buffer (MS3Record *msr);
extern double msr3_sampratehz (const MS3Record *msr);
extern nstime_t msr3_nsperiod (const MS3Record *msr);
extern double msr3_host_latency (const MS3Record *msr);
 
extern int64_t ms3_detect (const char *record, uint64_t recbuflen, uint8_t *formatversion);
extern int ms_parse_raw3 (const char *record, int maxreclen, int8_t details);
extern int ms_parse_raw2 (const char *record, int maxreclen, int8_t details, int8_t swapflag);


typedef struct MS3SelectTime
{
  nstime_t starttime;         
  nstime_t endtime;           
  struct MS3SelectTime *next; 
} MS3SelectTime;

typedef struct MS3Selections
{
  char sidpattern[100];              
  struct MS3SelectTime *timewindows; 
  struct MS3Selections *next;        
  uint8_t pubversion;                
} MS3Selections;
 
extern const MS3Selections *ms3_matchselect (const MS3Selections *selections, const char *sid,
                                             nstime_t starttime, nstime_t endtime, int pubversion,
                                             const MS3SelectTime **ppselecttime);
extern const MS3Selections *msr3_matchselect (const MS3Selections *selections, const MS3Record *msr,
                                              const MS3SelectTime **ppselecttime);
extern int ms3_addselect (MS3Selections **ppselections, const char *sidpattern, nstime_t starttime,
                          nstime_t endtime, uint8_t pubversion);
extern int ms3_addselect_comp (MS3Selections **ppselections, char *network, char *station,
                               char *location, char *channel, nstime_t starttime, nstime_t endtime,
                               uint8_t pubversion);
extern int ms3_readselectionsfile (MS3Selections **ppselections, const char *filename);
extern void ms3_freeselections (MS3Selections *selections);
extern void ms3_printselections (const MS3Selections *selections);


typedef struct MS3RecordPtr
{
  const char *bufferptr; 
  FILE *fileptr;         
  const char *filename;  
  int64_t fileoffset;    
  MS3Record *msr;        
  nstime_t endtime;      
  uint32_t dataoffset;   
  void *prvtptr;         
  struct MS3RecordPtr *next; 
} MS3RecordPtr;

typedef struct MS3RecordList
{
  uint64_t recordcnt;  
  MS3RecordPtr *first; 
  MS3RecordPtr *last;  
} MS3RecordList;



#define MSTRACEID_SKIPLIST_HEIGHT 8

typedef struct MS3TraceSeg
{
  nstime_t starttime; 
  nstime_t endtime;   
  double samprate;    
  int64_t samplecnt;  
  void *datasamples;  
  uint64_t datasize;  
  int64_t numsamples; 
  char sampletype;    
  void *prvtptr; 
  struct MS3RecordList *recordlist; 
  struct MS3TraceSeg *prev;         
  struct MS3TraceSeg *next;         
} MS3TraceSeg;

typedef struct MS3TraceID
{
  char sid[LM_SIDLEN];       
  uint8_t pubversion;        
  nstime_t earliest;         
  nstime_t latest;           
  void *prvtptr;             
  uint32_t numsegments;      
  struct MS3TraceSeg *first; 
  struct MS3TraceSeg *last;  
  struct MS3TraceID
      *next[MSTRACEID_SKIPLIST_HEIGHT]; 
  uint8_t height;                       
} MS3TraceID;

typedef struct MS3TraceList
{
  uint32_t numtraceids;     
  struct MS3TraceID traces; 
  uint64_t prngstate;       
} MS3TraceList;

typedef struct MS3Tolerance
{
  double (*time) (const MS3Record *msr); 
  double (*samprate) (
      const MS3Record *msr); 
} MS3Tolerance;

#define MS3Tolerance_INITIALIZER {.time = NULL, .samprate = NULL}
 
extern MS3TraceList *mstl3_init (MS3TraceList *mstl);
extern void mstl3_free (MS3TraceList **ppmstl, int8_t freeprvtptr);
extern MS3TraceID *mstl3_findID (MS3TraceList *mstl, const char *sid, uint8_t pubversion,
                                 MS3TraceID **prev);
 
extern MS3TraceSeg *mstl3_addmsr (MS3TraceList *mstl, const MS3Record *msr, int8_t splitversion,
                                  int8_t autoheal, uint32_t flags, const MS3Tolerance *tolerance);
extern MS3TraceSeg *mstl3_addmsr_recordptr (MS3TraceList *mstl, const MS3Record *msr,
                                            MS3RecordPtr **pprecptr, int8_t splitversion,
                                            int8_t autoheal, uint32_t flags,
                                            const MS3Tolerance *tolerance);
extern int64_t mstl3_readbuffer (MS3TraceList **ppmstl, const char *buffer, uint64_t bufferlength,
                                 int8_t splitversion, uint32_t flags, const MS3Tolerance *tolerance,
                                 int8_t verbose);
extern int64_t mstl3_readbuffer_selection (MS3TraceList **ppmstl, const char *buffer,
                                           uint64_t bufferlength, int8_t splitversion,
                                           uint32_t flags, const MS3Tolerance *tolerance,
                                           const MS3Selections *selections, int8_t verbose);
extern int64_t mstl3_unpack_recordlist (MS3TraceID *id, MS3TraceSeg *seg, void *output,
                                        uint64_t outputsize, int8_t verbose);
extern int mstl3_convertsamples (MS3TraceSeg *seg, char type, int8_t truncate);
extern int mstl3_resize_buffers (MS3TraceList *mstl);
extern int64_t mstl3_pack (MS3TraceList *mstl, void (*record_handler) (char *, int, void *),
                           void *handlerdata, int reclen, int8_t encoding, int64_t *packedsamples,
                           uint32_t flags, int8_t verbose, char *extra);
extern int64_t mstl3_pack_ppupdate_flushidle (MS3TraceList *mstl,
                                              void (*record_handler) (char *, int, void *),
                                              void *handlerdata, int reclen, int8_t encoding,
                                              int64_t *packedsamples, uint32_t flags,
                                              int8_t verbose, char *extra,
                                              uint32_t flush_idle_seconds);
extern int64_t mstl3_pack_segment (MS3TraceList *mstl, MS3TraceID *id, MS3TraceSeg *seg,
                                   void (*record_handler) (char *, int, void *), void *handlerdata,
                                   int reclen, int8_t encoding, int64_t *packedsamples,
                                   uint32_t flags, int8_t verbose, char *extra);
DEPRECATED extern int64_t mstraceseg3_pack (MS3TraceID *, MS3TraceSeg *,
                                            void (*) (char *, int, void *), void *, int, int8_t,
                                            int64_t *, uint32_t, int8_t, char *);
extern void mstl3_printtracelist (const MS3TraceList *mstl, ms_timeformat_t timeformat,
                                  int8_t details, int8_t gaps, int8_t versions);
extern void mstl3_printsynclist (const MS3TraceList *mstl, const char *dccid,
                                 ms_subseconds_t subseconds);
extern void mstl3_printgaplist (const MS3TraceList *mstl, ms_timeformat_t timeformat,
                                double *mingap, double *maxgap);


typedef struct LMIO
{
  enum
  {
    LMIO_NULL = 0,   
    LMIO_FILE = 1,   
    LMIO_URL = 2,    
    LMIO_FD = 3      
  } type;            
  void *handle;      
  void *handle2;     
  int still_running; 
} LMIO;

#define LMIO_INITIALIZER {.type = LMIO_NULL, .handle = NULL, .handle2 = NULL, .still_running = 0}

typedef struct MS3FileParam
{
  char path[512];      
  int64_t startoffset; 
  int64_t endoffset;   
  int64_t streampos;   
  int64_t recordcount; 
 
  char *readbuffer; 
  int readlength;   
  int readoffset;   
  uint32_t flags;   
  LMIO input;       
} MS3FileParam;

#define MS3FileParam_INITIALIZER                                                                   \
  {.path = "",                                                                                     \
   .startoffset = 0,                                                                               \
   .endoffset = 0,                                                                                 \
   .streampos = 0,                                                                                 \
   .recordcount = 0,                                                                               \
   .readbuffer = NULL,                                                                             \
   .readlength = 0,                                                                                \
   .readoffset = 0,                                                                                \
   .flags = 0,                                                                                     \
   .input = LMIO_INITIALIZER}
 
extern int ms3_readmsr (MS3Record **ppmsr, const char *mspath, uint32_t flags, int8_t verbose);
extern int ms3_readmsr_r (MS3FileParam **ppmsfp, MS3Record **ppmsr, const char *mspath,
                          uint32_t flags, int8_t verbose);
extern int ms3_readmsr_selection (MS3FileParam **ppmsfp, MS3Record **ppmsr, const char *mspath,
                                  uint32_t flags, const MS3Selections *selections, int8_t verbose);
extern int ms3_readtracelist (MS3TraceList **ppmstl, const char *mspath,
                              const MS3Tolerance *tolerance, int8_t splitversion, uint32_t flags,
                              int8_t verbose);
extern int ms3_readtracelist_timewin (MS3TraceList **ppmstl, const char *mspath,
                                      const MS3Tolerance *tolerance, nstime_t starttime,
                                      nstime_t endtime, int8_t splitversion, uint32_t flags,
                                      int8_t verbose);
extern int ms3_readtracelist_selection (MS3TraceList **ppmstl, const char *mspath,
                                        const MS3Tolerance *tolerance,
                                        const MS3Selections *selections, int8_t splitversion,
                                        uint32_t flags, int8_t verbose);
extern int ms3_url_useragent (const char *program, const char *version);
extern int ms3_url_userpassword (const char *userpassword);
extern int ms3_url_addheader (const char *header);
extern void ms3_url_freeheaders (void);
extern int64_t msr3_writemseed (MS3Record *msr, const char *mspath, int8_t overwrite,
                                uint32_t flags, int8_t verbose);
extern int64_t mstl3_writemseed (MS3TraceList *mstl, const char *mspath, int8_t overwrite,
                                 int maxreclen, int8_t encoding, uint32_t flags, int8_t verbose);
extern int libmseed_url_support (void);
extern MS3FileParam *ms3_mstl_init_fd (int fd);

extern int ms_sid2nslc_n (const char *sid, char *net, size_t netsize, char *sta, size_t stasize,
                          char *loc, size_t locsize, char *chan, size_t chansize);
DEPRECATED extern int ms_sid2nslc (const char *sid, char *net, char *sta, char *loc, char *chan);
extern int ms_nslc2sid (char *sid, int sidlen, uint16_t flags, const char *net, const char *sta,
                        const char *loc, const char *chan);
extern int ms_seedchan2xchan (char *xchan, const char *seedchan);
extern int ms_xchan2seedchan (char *seedchan, const char *xchan);
extern int ms_strncpclean (char *dest, const char *source, int length);
extern int ms_strncpcleantail (char *dest, const char *source, int length);
extern int ms_strncpopen (char *dest, const char *source, int length);


typedef struct MSEHEventDetection
{
  char type[30];             
  char detector[30];         
  double signalamplitude;    
  double signalperiod;       
  double backgroundestimate; 
  char wave[30];             
  char units[30]; 
  nstime_t onsettime; 
  uint8_t
      medsnr[6]; 
  int medlookback;                 
  int medpickalgorithm;            
  struct MSEHEventDetection *next; 
} MSEHEventDetection;

typedef struct MSEHCalibration
{
  char type[30]; 
  nstime_t begintime;      
  nstime_t endtime;        
  int steps;               
  int firstpulsepositive;  
  int alternatesign;       
  char trigger[30];        
  int continued;           
  double amplitude;        
  char inputunits[30];     
  char amplituderange[30]; 
  double duration;         
  double sineperiod;       
  double stepbetween;      
  char inputchannel[30];   
  double refamplitude;     
  char coupling[30];       
  char rolloff[30];        
  char noise[30];          
  struct MSEHCalibration *next; 
} MSEHCalibration;

typedef struct MSEHTimingException
{
  nstime_t time;        
  float vcocorrection;  
  int usec;             
  int receptionquality; 
  uint32_t count;       
  char type[16];        
  char
      clockstatus[128]; 
} MSEHTimingException;

typedef struct MSEHRecenter
{
  char type[30];      
  nstime_t begintime; 
  nstime_t endtime;   
  char trigger[30];   
} MSEHRecenter;

typedef struct LM_PARSED_JSON_s LM_PARSED_JSON;

#define mseh_get(msr, ptr, valueptr, type, maxlength)                                              \
  mseh_get_ptr_r (msr, ptr, valueptr, type, maxlength, NULL)

#define mseh_get_number(msr, ptr, valueptr) mseh_get_ptr_r (msr, ptr, valueptr, 'n', 0, NULL)

#define mseh_get_int64(msr, ptr, valueptr) mseh_get_ptr_r (msr, ptr, valueptr, 'i', 0, NULL)

#define mseh_get_string(msr, ptr, buffer, maxlength)                                               \
  mseh_get_ptr_r (msr, ptr, buffer, 's', maxlength, NULL)

#define mseh_get_boolean(msr, ptr, valueptr) mseh_get_ptr_r (msr, ptr, valueptr, 'b', 0, NULL)

#define mseh_exists(msr, ptr) (!mseh_get_ptr_r (msr, ptr, NULL, 0, 0, NULL))
 
extern int mseh_get_ptr_r (const MS3Record *msr, const char *ptr, void *value, char type,
                           uint32_t maxlength, LM_PARSED_JSON **parsestate);

#define mseh_set(msr, ptr, valueptr, type) mseh_set_ptr_r (msr, ptr, valueptr, type, NULL)

#define mseh_set_number(msr, ptr, valueptr) mseh_set_ptr_r (msr, ptr, valueptr, 'n', NULL)

#define mseh_set_int64(msr, ptr, valueptr) mseh_set_ptr_r (msr, ptr, valueptr, 'i', NULL)

#define mseh_set_string(msr, ptr, valueptr) mseh_set_ptr_r (msr, ptr, valueptr, 's', NULL)

#define mseh_set_boolean(msr, ptr, valueptr) mseh_set_ptr_r (msr, ptr, valueptr, 'b', NULL)
 
extern int mseh_set_ptr_r (MS3Record *msr, const char *ptr, void *value, char type,
                           LM_PARSED_JSON **parsestate);
 
extern int mseh_add_event_detection_r (MS3Record *msr, const char *ptr,
                                       MSEHEventDetection *eventdetection,
                                       LM_PARSED_JSON **parsestate);
 
extern int mseh_add_calibration_r (MS3Record *msr, const char *ptr, MSEHCalibration *calibration,
                                   LM_PARSED_JSON **parsestate);
 
extern int mseh_add_timing_exception_r (MS3Record *msr, const char *ptr,
                                        MSEHTimingException *exception,
                                        LM_PARSED_JSON **parsestate);
 
extern int mseh_add_recenter_r (MS3Record *msr, const char *ptr, MSEHRecenter *recenter,
                                LM_PARSED_JSON **parsestate);
 
extern int mseh_serialize (MS3Record *msr, LM_PARSED_JSON **parsestate);
extern void mseh_free_parsestate (LM_PARSED_JSON **parsestate);
extern int mseh_replace (MS3Record *msr, char *jsonstring);
 
extern int mseh_print (const MS3Record *msr, int indent);



#define MAX_LOG_MSG_LENGTH 200

typedef struct MSLogEntry
{
  int level;                        
  char function[30];                
  char message[MAX_LOG_MSG_LENGTH]; 
  struct MSLogEntry *next;
} MSLogEntry;

typedef struct MSLogRegistry
{
  int maxmessages;
  int messagecnt;
  MSLogEntry *messages;
} MSLogRegistry;

#define MSLogRegistry_INITIALIZER {.maxmessages = 0, .messagecnt = 0, .messages = NULL}

typedef struct MSLogParam
{
  void (*log_print) (const char *);  
  const char *logprefix;             
  void (*diag_print) (const char *); 
  const char *errprefix;             
  MSLogRegistry registry;            
} MSLogParam;

#define MSLogParam_INITIALIZER                                                                     \
  {.log_print = NULL,                                                                              \
   .logprefix = NULL,                                                                              \
   .diag_print = NULL,                                                                             \
   .errprefix = NULL,                                                                              \
   .registry = MSLogRegistry_INITIALIZER}

#define ms_log(level, ...) ms_rlog (__func__, level, __VA_ARGS__)

#define ms_log_l(logp, level, ...) ms_rlog_l (logp, __func__, level, __VA_ARGS__)
 
#if defined(__GNUC__) || defined(__clang__)
__attribute__ ((__format__ (__printf__, 3, 4)))
#endif
extern int
ms_rlog (const char *function, int level, const char *format, ...);
#if defined(__GNUC__) || defined(__clang__)
__attribute__ ((__format__ (__printf__, 4, 5)))
#endif
extern int
ms_rlog_l (MSLogParam *logp, const char *function, int level, const char *format, ...);

#define ms_loginit(log_print, logprefix, diag_print, errprefix)                                    \
  ms_rloginit (log_print, logprefix, diag_print, errprefix, 0)

#define ms_loginit_l(logp, log_print, logprefix, diag_print, errprefix)                            \
  ms_rloginit_l (logp, log_print, logprefix, diag_print, errprefix, 0)
 
extern void ms_rloginit (void (*log_print) (const char *), const char *logprefix,
                         void (*diag_print) (const char *), const char *errprefix, int maxmessages);
extern MSLogParam *ms_rloginit_l (MSLogParam *logp, void (*log_print) (const char *),
                                  const char *logprefix, void (*diag_print) (const char *),
                                  const char *errprefix, int maxmessages);
extern int ms_rlog_emit (MSLogParam *logp, int count, int context);
extern int ms_rlog_free (MSLogParam *logp);


typedef struct LeapSecond
{
  nstime_t leapsecond;     
  int32_t TAIdelta;        
  struct LeapSecond *next; 
} LeapSecond;

extern LeapSecond *leapsecondlist;
extern int ms_readleapseconds (const char *envvarname);
extern int ms_readleapsecondfile (const char *filename);

 
extern uint8_t ms_samplesize (char sampletype);
extern int ms_encoding_sizetype (uint8_t encoding, uint8_t *samplesize, char *sampletype);
extern const char *ms_encodingstr (uint8_t encoding);
extern const char *ms_errorstr (int errorcode);
 
extern nstime_t ms_sampletime (nstime_t time, int64_t offset, double samprate);
extern int ms_bigendianhost (void);

#define ms_dabs(val) fabs (val)

extern int64_t lmp_ftell64 (FILE *stream);
extern int lmp_fseek64 (FILE *stream, int64_t offset, int whence);
extern uint64_t lmp_nanosleep (uint64_t nanoseconds);
extern nstime_t lmp_systemtime (void);

extern uint32_t ms_crc32c (const uint8_t *input, int length, uint32_t previousCRC32C);

static inline void
ms_gswap2 (void *data2)
{
  uint16_t dat;
 
  memcpy (&dat, data2, 2);
 
  dat = ((dat & 0xff00) >> 8) | ((dat & 0x00ff) << 8);
 
  memcpy (data2, &dat, 2);
}

static inline void
ms_gswap4 (void *data4)
{
  uint32_t dat;
 
  memcpy (&dat, data4, 4);
 
  dat = ((dat & 0xff000000) >> 24) | ((dat & 0x000000ff) << 24) | ((dat & 0x00ff0000) >> 8) |
        ((dat & 0x0000ff00) << 8);
 
  memcpy (data4, &dat, 4);
}

static inline void
ms_gswap8 (void *data8)
{
  uint64_t dat;
 
  memcpy (&dat, data8, sizeof (uint64_t));
 
  dat = ((dat & 0xff00000000000000) >> 56) | ((dat & 0x00000000000000ff) << 56) |
        ((dat & 0x00ff000000000000) >> 40) | ((dat & 0x000000000000ff00) << 40) |
        ((dat & 0x0000ff0000000000) >> 24) | ((dat & 0x0000000000ff0000) << 24) |
        ((dat & 0x000000ff00000000) >> 8) | ((dat & 0x00000000ff000000) << 8);
 
  memcpy (data8, &dat, sizeof (uint64_t));
}
 
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) || defined(__clang__)
__attribute__ ((deprecated ("Use ms_gswap2 instead."))) static inline void
ms_gswap2a (void *data2)
{
  ms_gswap2 (data2);
}
__attribute__ ((deprecated ("Use ms_gswap4 instead."))) static inline void
ms_gswap4a (void *data4)
{
  ms_gswap4 (data4);
}
__attribute__ ((deprecated ("Use ms_gswap8 instead."))) static inline void
ms_gswap8a (void *data8)
{
  ms_gswap8 (data8);
}
#elif defined(_MSC_FULL_VER) && (_MSC_FULL_VER > 140050320)
__declspec (deprecated ("Use ms_gswap2 instead.")) static inline void
ms_gswap2a (void *data2)
{
  ms_gswap2 (data2);
}
__declspec (deprecated ("Use ms_gswap4 instead.")) static inline void
ms_gswap4a (void *data4)
{
  ms_gswap4 (data4);
}
__declspec (deprecated ("Use ms_gswap8 instead.")) static inline void
ms_gswap8a (void *data8)
{
  ms_gswap8 (data8);
}
#else
static inline void
ms_gswap2a (void *data2)
{
  ms_gswap2 (data2);
}
static inline void
ms_gswap4a (void *data4)
{
  ms_gswap4 (data4);
}
static inline void
ms_gswap8a (void *data8)
{
  ms_gswap8 (data8);
}
#endif


typedef int8_t flag;


typedef struct LIBMSEED_MEMORY
{
  void *(*malloc) (size_t);          
  void *(*realloc) (void *, size_t); 
  void (*free) (void *);             
} LIBMSEED_MEMORY;

extern LIBMSEED_MEMORY libmseed_memory;

extern size_t libmseed_prealloc_block_size;

extern void *libmseed_memory_prealloc (void *ptr, size_t size, size_t *currentsize);

 
#define DE_ASCII DE_TEXT 

#define DE_TEXT 0         
#define DE_INT16 1        
#define DE_INT32 3        
#define DE_FLOAT32 4      
#define DE_FLOAT64 5      
#define DE_STEIM1 10      
#define DE_STEIM2 11      
#define DE_GEOSCOPE24 12  
#define DE_GEOSCOPE163 13 
#define DE_GEOSCOPE164 14 
#define DE_CDSN 16        
#define DE_SRO 30         
#define DE_DWWSSN 32      

#define MSSWAP_HEADER 0x01  
#define MSSWAP_PAYLOAD 0x02 

#define MS_ENDOFFILE 1      
#define MS_NOERROR 0        
#define MS_GENERROR -1      
#define MS_NOTSEED -2       
#define MS_WRONGLENGTH -3   
#define MS_OUTOFRANGE -4    
#define MS_UNKNOWNFORMAT -5 
#define MS_STBADCOMPFLAG -6 
#define MS_INVALIDCRC -7    

#define MSF_UNPACKDATA 0x0001  
#define MSF_SKIPNOTDATA 0x0002 
#define MSF_VALIDATECRC 0x0004 
#define MSF_PNAMERANGE 0x0008  
#define MSF_ATENDOFFILE 0x0010 
#define MSF_SEQUENCE 0x0020    
#define MSF_FLUSHDATA                                                                              \
  0x0040 
#define MSF_PACKVER2 0x0080     
#define MSF_RECORDLIST 0x0100   
#define MSF_MAINTAINMSTL 0x0200 
#define MSF_PPUPDATETIME                                                                           \
  0x0400 

 
#ifdef __cplusplus
}
#endif
 
#endif /* LIBMSEED_H */