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.3"     
#define LIBMSEED_RELEASE "2024.165"  
 
/* C99 standard headers */
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <string.h>
#include <ctype.h>
#include <math.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 <windows.h>
  #include <sys/types.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>
#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 (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;
 
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_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);
 
#define mstl3_addmsr(mstl, msr, splitversion, autoheal, flags, tolerance) \
  mstl3_addmsr_recordptr (mstl, msr, NULL, splitversion, autoheal, flags, 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 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 *mst, 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 (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 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  
#ifdef __cplusplus
}
#endif
 
#endif /* LIBMSEED_H */