int
main (int argc, char **argv)
{
MSTraceGroup *mstg = 0;
MSTrace *mst;
MSRecord *msr = 0;
struct listnode *flp;
int retcode;
int totalsamps = 0;
/* Process given parameters (command line and parameter file) */
if (parameter_proc (argc, argv) < 0)
return -1;
/* Init MSTraceGroup */
mstg = mst_initgroup (mstg);
/* Read input miniSEED files into MSTraceGroup */
flp = filelist;
if ( verbose )
fprintf (stderr, "Reading %s\n", flp->data);
while ( (retcode = ms_readmsr(&msr, flp->data, reclen, NULL, NULL,
1, 1, verbose-1)) == MS_NOERROR )
{
if ( verbose > 1)
msr_print (msr, verbose - 2);
mst_addmsrtogroup (mstg, msr, 1, timetol, sampratetol);
totalsamps += msr->samplecnt;
}
if ( retcode != MS_ENDOFFILE )
fprintf (stderr, "Error reading %s: %s\n", flp->data, ms_errorstr(retcode));
/* Make sure everything is cleaned up */
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
/* If processing each file individually, write ASCII and reset */
if ( indifile )
{
mst = mstg->traces;
while ( mst )
{
writeascii (mst);
mst = mst->next;
}
mstg = mst_initgroup (mstg);
}
/* Make sure everything is cleaned up */
mst_freegroup (&mstg);
if ( ofp )
fclose (ofp);
return 0;
} /* End of main() */
int
main (int argc, char **argv)
{
MSRecord *msr = 0;
MSTraceGroup *mstg = 0;
MSTrace *mst;
int retcode;
int totalrecs = 0;
int totalsamps = 0;
int packedsamples;
int packedrecords;
int lastrecord;
int iseqnum = 1;
#ifndef WIN32
/* Signal handling, use POSIX calls with standardized semantics */
struct sigaction sa;
sa.sa_flags = SA_RESTART;
sigemptyset (&sa.sa_mask);
sa.sa_handler = term_handler;
sigaction (SIGINT, &sa, NULL);
sigaction (SIGQUIT, &sa, NULL);
sigaction (SIGTERM, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction (SIGHUP, &sa, NULL);
sigaction (SIGPIPE, &sa, NULL);
#endif
/* Process given parameters (command line and parameter file) */
if (parameter_proc (argc, argv) < 0)
return -1;
/* Setup input encoding format if specified */
if ( encodingstr )
{
int inputencoding = strtoul (encodingstr, NULL, 10);
if ( inputencoding == 0 && errno == EINVAL )
{
ms_log (2, "Error parsing input encoding format: %s\n", encodingstr);
return -1;
}
MS_UNPACKENCODINGFORMAT (inputencoding);
}
/* Init MSTraceGroup */
mstg = mst_initgroup (mstg);
/* Loop over the input file */
while ( (retcode = ms_readmsr (&msr, inputfile, reclen, NULL, &lastrecord,
1, 1, verbose)) == MS_NOERROR )
{
totalrecs++;
totalsamps += msr->samplecnt;
msr_print (msr, ppackets);
if ( packreclen >= 0 )
msr->reclen = packreclen;
else
packreclen = msr->reclen;
if ( packencoding >= 0 )
msr->encoding = packencoding;
else
packencoding = msr->encoding;
if ( byteorder >= 0 )
msr->byteorder = byteorder;
else
byteorder = msr->byteorder;
/* After unpacking the record, the start time in msr->starttime
is a potentially corrected start time, if correction has been
applied make sure the correction bit flag is set as it will
be used as a packing template. */
if ( msr->fsdh->time_correct && ! (msr->fsdh->act_flags & 0x02) )
{
ms_log (1, "Setting time correction applied flag for %s_%s_%s_%s\n",
msr->network, msr->station, msr->location, msr->channel);
msr->fsdh->act_flags |= 0x02;
}
/* If no samples in the record just pack the header */
if ( outfile && msr->numsamples == 0 )
{
msr_pack_header (msr, 1, verbose);
record_handler (msr->record, msr->reclen, NULL);
}
/* Pack each record individually */
else if ( outfile && ! tracepack )
{
msr->sequence_number = iseqnum;
packedrecords = msr_pack (msr, &record_handler, NULL, &packedsamples, 1, verbose);
if ( packedrecords == -1 )
ms_log (2, "Cannot pack records\n");
else
ms_log (1, "Packed %d records\n", packedrecords);
iseqnum = msr->sequence_number;
}
/* Pack records from a MSTraceGroup */
else if ( outfile && tracepack )
{
mst = mst_addmsrtogroup (mstg, msr, 0, -1.0, -1.0);
if ( ! mst )
{
ms_log (2, "Error adding MSRecord to MStrace!\n");
break;
}
/* Reset sequence number and free previous template */
if ( mst->prvtptr )
{
MSRecord *tmsr = (MSRecord *) mst->prvtptr;
/* Retain sequence number from previous template */
msr->sequence_number = tmsr->sequence_number;
msr_free (&tmsr);
}
else
{
msr->sequence_number = 1;
}
/* Copy MSRecord and store as template */
mst->prvtptr = msr_duplicate (msr, 0);
if ( ! mst->prvtptr )
{
ms_log (2, "Error duplicating MSRecord for template!\n");
break;
}
/* Pack traces based on selected method */
packedrecords = 0;
if ( tracepack == 1 )
{
mst = mstg->traces;
while ( mst )
{
packedrecords += mst_pack (mst, &record_handler, NULL, packreclen,
packencoding, byteorder, &packedsamples,
lastrecord, verbose, (MSRecord *)mst->prvtptr);
mst = mst->next;
}
ms_log (1, "Packed %d records\n", packedrecords);
}
if ( tracepack == 2 && lastrecord )
{
mst = mstg->traces;
while ( mst )
{
packedrecords += mst_pack (mst, &record_handler, NULL, packreclen,
packencoding, byteorder, &packedsamples,
lastrecord, verbose, (MSRecord *)mst->prvtptr);
mst = mst->next;
}
ms_log (1, "Packed %d records\n", packedrecords);
}
}
}
if ( retcode != MS_ENDOFFILE )
ms_log (2, "Error reading %s: %s\n", inputfile, ms_errorstr(retcode));
/* Make sure everything is cleaned up */
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
mst_freegroup (&mstg);
if ( outfile )
fclose (outfile);
getchar();
return 0;
} /* End of main() */
static PyObject*
mseed_get_traces (PyObject *dummy, PyObject *args)
{
char *filename;
MSTraceGroup *mstg = NULL;
MSTrace *mst = NULL;
int retcode;
npy_intp array_dims[1] = {0};
PyObject *array = NULL;
PyObject *out_traces = NULL;
PyObject *out_trace = NULL;
int numpytype;
char strbuf[BUFSIZE];
PyObject *unpackdata = NULL;
if (!PyArg_ParseTuple(args, "sO", &filename, &unpackdata)) {
PyErr_SetString(MSeedError, "usage get_traces(filename, dataflag)" );
return NULL;
}
if (!PyBool_Check(unpackdata)) {
PyErr_SetString(MSeedError, "Second argument must be a boolean" );
return NULL;
}
/* get data from mseed file */
retcode = ms_readtraces (&mstg, filename, 0, -1.0, -1.0, 0, 1, (unpackdata == Py_True), 0);
if ( retcode < 0 ) {
snprintf (strbuf, BUFSIZE, "Cannot read file '%s': %s", filename, ms_errorstr(retcode));
PyErr_SetString(MSeedError, strbuf);
return NULL;
}
if ( ! mstg ) {
snprintf (strbuf, BUFSIZE, "Error reading file");
PyErr_SetString(MSeedError, strbuf);
return NULL;
}
/* check that there is data in the traces */
if (unpackdata == Py_True) {
mst = mstg->traces;
while (mst) {
if (mst->datasamples == NULL) {
snprintf (strbuf, BUFSIZE, "Error reading file - datasamples is NULL");
PyErr_SetString(MSeedError, strbuf);
return NULL;
}
mst = mst->next;
}
}
out_traces = Py_BuildValue("[]");
mst = mstg->traces;
/* convert data to python tuple */
while (mst) {
if (unpackdata == Py_True) {
array_dims[0] = mst->numsamples;
switch (mst->sampletype) {
case 'i':
assert( ms_samplesize('i') == 4 );
numpytype = NPY_INT32;
break;
case 'a':
assert( ms_samplesize('a') == 1 );
numpytype = NPY_INT8;
break;
case 'f':
assert( ms_samplesize('f') == 4 );
numpytype = NPY_FLOAT32;
break;
case 'd':
assert( ms_samplesize('d') == 8 );
numpytype = NPY_FLOAT64;
break;
default:
snprintf (strbuf, BUFSIZE, "Unknown sampletype %c\n", mst->sampletype);
PyErr_SetString(MSeedError, strbuf);
Py_XDECREF(out_traces);
return NULL;
}
array = PyArray_SimpleNew(1, array_dims, numpytype);
memcpy( PyArray_DATA(array), mst->datasamples, mst->numsamples*ms_samplesize(mst->sampletype) );
} else {
Py_INCREF(Py_None);
array = Py_None;
}
out_trace = Py_BuildValue( "(c,s,s,s,s,L,L,d,N)",
mst->dataquality,
mst->network,
mst->station,
mst->location,
mst->channel,
mst->starttime,
mst->endtime,
mst->samprate,
array );
PyList_Append(out_traces, out_trace);
Py_DECREF(out_trace);
mst = mst->next;
}
mst_freegroup (&mstg);
return out_traces;
}
int
main (int argc, char **argv)
{
struct filelink *flp;
MSRecord *msr = 0;
MSTraceList *mstl = 0;
FILE *bfp = 0;
FILE *ofp = 0;
int retcode = MS_NOERROR;
char envvariable[100];
int dataflag = 0;
long long int totalrecs = 0;
long long int totalsamps = 0;
long long int totalfiles = 0;
off_t filepos = 0;
char srcname[50];
char stime[30];
/* Set default error message prefix */
ms_loginit (NULL, NULL, NULL, "ERROR: ");
/* Process given parameters (command line and parameter file) */
if ( processparam (argc, argv) < 0 )
return 1;
/* Setup encoding environment variable if specified, ugly kludge */
if ( encodingstr )
{
snprintf (envvariable, sizeof(envvariable), "UNPACK_DATA_FORMAT=%s", encodingstr);
if ( putenv (envvariable) )
{
ms_log (2, "Cannot set environment variable UNPACK_DATA_FORMAT\n");
return 1;
}
}
/* Open the integer output file if specified */
if ( binfile )
{
if ( strcmp (binfile, "-") == 0 )
{
bfp = stdout;
}
else if ( (bfp = fopen (binfile, "wb")) == NULL )
{
ms_log (2, "Cannot open binary data output file: %s (%s)\n",
binfile, strerror(errno));
return 1;
}
}
/* Open the output file if specified */
if ( outfile )
{
if ( strcmp (outfile, "-") == 0 )
{
ofp = stdout;
}
else if ( (ofp = fopen (outfile, "wb")) == NULL )
{
ms_log (2, "Cannot open output file: %s (%s)\n",
outfile, strerror(errno));
return 1;
}
}
if ( printdata || binfile )
dataflag = 1;
if ( tracegapsum || tracegaponly )
mstl = mstl_init (NULL);
flp = filelist;
while ( flp != 0 )
{
if ( verbose >= 2 )
{
if ( flp->offset )
ms_log (1, "Processing: %s (starting at byte %lld)\n", flp->filename, flp->offset);
else
ms_log (1, "Processing: %s\n", flp->filename);
}
/* Set starting byte offset if supplied as negative file position */
filepos = - flp->offset;
/* Loop over the input file */
while ( reccntdown != 0 )
{
if ( (retcode = ms_readmsr (&msr, flp->filename, reclen, &filepos,
NULL, skipnotdata, 0, verbose)) != MS_NOERROR )
break;
/* Check if record matches start/end time criteria */
if ( starttime != HPTERROR || endtime != HPTERROR )
{
hptime_t recendtime = msr_endtime (msr);
if ( starttime != HPTERROR && (msr->starttime < starttime && ! (msr->starttime <= starttime && recendtime >= starttime)) )
{
if ( verbose >= 3 )
{
msr_srcname (msr, srcname, 1);
ms_hptime2seedtimestr (msr->starttime, stime, 1);
ms_log (1, "Skipping (starttime) %s, %s\n", srcname, stime);
}
continue;
}
if ( endtime != HPTERROR && (recendtime > endtime && ! (msr->starttime <= endtime && recendtime >= endtime)) )
{
if ( verbose >= 3 )
{
msr_srcname (msr, srcname, 1);
ms_hptime2seedtimestr (msr->starttime, stime, 1);
ms_log (1, "Skipping (starttime) %s, %s\n", srcname, stime);
}
continue;
}
}
if ( match || reject )
{
/* Generate the srcname with the quality code */
msr_srcname (msr, srcname, 1);
/* Check if record is matched by the match regex */
if ( match )
{
if ( regexec ( match, srcname, 0, 0, 0) != 0 )
{
if ( verbose >= 3 )
{
ms_hptime2seedtimestr (msr->starttime, stime, 1);
ms_log (1, "Skipping (match) %s, %s\n", srcname, stime);
}
continue;
}
}
/* Check if record is rejected by the reject regex */
if ( reject )
{
if ( regexec ( reject, srcname, 0, 0, 0) == 0 )
{
if ( verbose >= 3 )
{
ms_hptime2seedtimestr (msr->starttime, stime, 1);
ms_log (1, "Skipping (reject) %s, %s\n", srcname, stime);
}
continue;
}
}
}
if ( reccntdown > 0 )
reccntdown--;
totalrecs++;
totalsamps += msr->samplecnt;
if ( ! tracegaponly )
{
if ( printoffset )
ms_log (0, "%-10lld", (long long) filepos);
if ( printlatency )
ms_log (0, "%-10.6g secs ", msr_host_latency(msr));
if ( printraw )
ms_parse_raw (msr->record, msr->reclen, ppackets, -1);
else
msr_print (msr, ppackets);
}
if ( tracegapsum || tracegaponly )
mstl_addmsr (mstl, msr, dataquality, 1, timetol, sampratetol);
if ( dataflag )
{
/* Parse the record (again) and unpack the data */
int rv = msr_unpack (msr->record, msr->reclen, &msr, 1, verbose);
if ( rv == MS_NOERROR && printdata && ! tracegaponly )
{
int line, col, cnt, samplesize;
int lines = (msr->numsamples / 6) + 1;
void *sptr;
if ( (samplesize = ms_samplesize(msr->sampletype)) == 0 )
{
ms_log (2, "Unrecognized sample type: %c\n", msr->sampletype);
}
if ( msr->sampletype == 'a' )
{
char *ascii = (char *)msr->datasamples;
int length = msr->numsamples;
ms_log (0, "ASCII Data:\n");
/* Print maximum log message segments */
while ( length > (MAX_LOG_MSG_LENGTH-1) )
{
ms_log (0, "%.*s", (MAX_LOG_MSG_LENGTH-1), ascii);
ascii += MAX_LOG_MSG_LENGTH-1;
length -= MAX_LOG_MSG_LENGTH-1;
}
/* Print any remaining ASCII and add a newline */
if ( length > 0 )
{
ms_log (0, "%.*s\n", length, ascii);
}
else
{
ms_log (0, "\n");
}
}
else
for ( cnt = 0, line = 0; line < lines; line++ )
{
for ( col = 0; col < 6 ; col ++ )
{
if ( cnt < msr->numsamples )
{
sptr = (char*)msr->datasamples + (cnt * samplesize);
if ( msr->sampletype == 'i' )
ms_log (0, "%10d ", *(int32_t *)sptr);
else if ( msr->sampletype == 'f' )
ms_log (0, "%10.8g ", *(float *)sptr);
else if ( msr->sampletype == 'd' )
ms_log (0, "%10.10g ", *(double *)sptr);
cnt++;
}
}
ms_log (0, "\n");
/* If only printing the first 6 samples break out here */
if ( printdata == 1 )
break;
}
}
if ( binfile )
{
uint8_t samplesize = ms_samplesize (msr->sampletype);
if ( samplesize )
{
fwrite (msr->datasamples, samplesize, msr->numsamples, bfp);
}
else
{
ms_log (1, "Cannot write to binary file, unknown sample type: %c\n",
msr->sampletype);
}
}
}
if ( outfile )
{
fwrite (msr->record, 1, msr->reclen, ofp);
}
}
/* Print error if not EOF and not counting down records */
if ( retcode != MS_ENDOFFILE && reccntdown != 0 )
{
ms_log (2, "Cannot read %s: %s\n", flp->filename, ms_errorstr(retcode));
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
exit (1);
}
/* Make sure everything is cleaned up */
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
totalfiles++;
flp = flp->next;
} /* End of looping over file list */
if ( binfile )
fclose (bfp);
if ( outfile )
fclose (ofp);
if ( basicsum )
ms_log (0, "Files: %lld, Records: %lld, Samples: %lld\n", totalfiles, totalrecs, totalsamps);
if ( tracegapsum || tracegaponly )
{
if ( tracegapsum == 1 || tracegaponly == 1 )
{
mstl_printtracelist (mstl, timeformat, 1, tracegaps);
}
if ( tracegapsum == 2 || tracegaponly == 2 )
{
mstl_printgaplist (mstl, timeformat, mingapptr, maxgapptr);
}
if ( tracegaponly == 3 )
{
mstl_printsynclist (mstl, NULL, 1);
}
}
if ( mstl )
mstl_free (&mstl, 0);
return 0;
} /* End of main() */
static str
MseedLoadIntern(BAT **bbtime, BAT **bbdata, str targetfile)
{
str msg = MAL_SUCCEED;
MSRecord *msr = 0;
BAT *btime, *bdata;
int verbose = 1;
//int ppackets = 2;
int reclen = -1;
int dataflag = 1;
int retcode;
int j;
time_t t;
struct tm *tm;
timestamp ts;
char file[BUFSIZ];
date d;
daytime dt;
tzone tz;
int ms,stepsize,minutes=0;
snprintf(file,BUFSIZ,"%s%c%s",vaultpath,DIR_SEP,targetfile);
if ( access(file,R_OK) )
throw(MAL, "mseed.load", "Cannot access %s\n", file);
btime = BATnew(TYPE_void,TYPE_timestamp,0);
if ( btime == NULL)
throw(MAL,"mseed.load",MAL_MALLOC_FAIL);
BATseqbase(btime,0);
bdata = BATnew(TYPE_void,TYPE_int,0);
if ( bdata == NULL){
BBPreleaseref(btime->batCacheid);
throw(MAL,"mseed.load",MAL_MALLOC_FAIL);
}
BATseqbase(bdata,0);
if ( btime == NULL || bdata == NULL ){
if ( btime) BBPreleaseref(btime->batCacheid);
if ( bdata) BBPreleaseref(bdata->batCacheid);
throw(MAL, "mseed.load", MAL_MALLOC_FAIL);
}
*bbtime = btime;
*bbdata = bdata;
MTIMEtzone_create(&tz, &minutes);
while ( (retcode = ms_readmsr (&msr, file, reclen, NULL, NULL, 1, dataflag, verbose)) == MS_NOERROR )
{
stepsize = 1000000/ msr->samprate;
/* collect the statistics */
switch(msr->sampletype){
case 'i':
if (msr->datasamples)
for ( j=0;j< msr->samplecnt; j++){
t= MS_HPTIME2EPOCH(msr->starttime);
tm = gmtime(&t);
tm->tm_year += (tm->tm_year > 80?1900:2000);
ms = (msr->starttime % HPTMODULUS)/1000;
tm->tm_mon++;
MTIMEdate_create(&d,&tm->tm_year, &tm->tm_mon, &tm->tm_mday);
MTIMEdaytime_create(&dt, &tm->tm_hour, &tm->tm_min, &tm->tm_sec, &ms);
MTIMEtimestamp_create(&ts, &d, &dt, &tz);
BUNappend(btime, (ptr) &ts , FALSE);
BUNappend(bdata, (ptr)(((int*) msr->datasamples)+j) , FALSE);
msr->starttime += stepsize;
}
break;
case 'a': case 'f': case 'd':
default:
msg = createException(MAL,"mseed.load","data type not yet implemented");
goto wrapup;
}
}
wrapup:
/* Make sure everything is cleaned up */
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
if ( retcode != MS_ENDOFFILE )
throw(MAL, "mseed.load", "Cannot read %s: %s\n", targetfile, ms_errorstr(retcode));
return msg;
}
str
MseedImport(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
{
int *ret = (int*) getArgReference(stk,pci,0);
int *vid = (int*) getArgReference(stk,pci,1);
str *targetfile = (str*) getArgReference(stk,pci,2);
str msg = MAL_SUCCEED;
MSRecord *msr = 0;
int verbose = 1;
//int ppackets = 2;
int reclen = -1;
int dataflag = 1;
int retcode;
int j;
int sampleindex = 0;
time_t t;
struct tm *tm;
char file[BUFSIZ];
char buf[BUFSIZ], *s= buf;
char starttime[BUFSIZ];
int imin = INT_MAX, imax = INT_MIN;
/* keep state of a file to detect major deviances */
str network =0, station = 0 , location = 0 , channel = 0;
char sampletype = 0;
(void) mb;
*ret = int_nil;
snprintf(file,BUFSIZ,"%s%c%s",vaultpath,DIR_SEP,*targetfile);
if ( access(file,R_OK) )
throw(MAL, "mseed.load", "Cannot access %s\n", file);
while ( (retcode = ms_readmsr (&msr, file, reclen, NULL, NULL, 1, dataflag, verbose)) == MS_NOERROR )
{
if ( network == 0){
network= GDKstrdup(msr->network);
station= GDKstrdup(msr->station);
location= GDKstrdup(msr->location);
channel= GDKstrdup(msr->channel);
sampletype = msr->sampletype;
} else {
if( strcmp(network,msr->network))
msg = createException(MAL,"mseed.import","network name is not stable");
if( strcmp(station,msr->station))
msg = createException(MAL,"mseed.import","station name is not stable");
if( strcmp(location,msr->location))
msg = createException(MAL,"mseed.import","location name is not stable");
if( strcmp(channel,msr->channel))
msg = createException(MAL,"mseed.import","channel name is not stable");
if ( sampletype != msr->sampletype)
msg = createException(MAL,"mseed.import","sample type is not stable");
if (msg) goto wrapup;
}
t= MS_HPTIME2EPOCH(msr->starttime);
tm = gmtime(&t);
snprintf(starttime,BUFSIZ,"%d-%02d-%02d %02d:%02d:%02d.%06d", tm->tm_year +(tm->tm_year > 80?1900:2000), tm->tm_mon+1,tm->tm_mday, tm->tm_hour, tm->tm_min,tm->tm_sec, (int) (msr->starttime % HPTMODULUS));
/* collect the statistics */
switch(msr->sampletype){
case 'i':
imin = INT_MAX, imax = INT_MIN;
if (msr->datasamples)
for ( j=0;j< msr->samplecnt; j++){
if ( imin > ((int*) msr->datasamples)[j]) imin = ((int*) msr->datasamples)[j];
if ( imax < ((int*) msr->datasamples)[j]) imax = ((int*) msr->datasamples)[j];
}
snprintf(buf,BUFSIZ,QRYinsertI, *vid, msr->sequence_number,msr->dataquality,msr->network, msr->station, msr->location, msr->channel,
starttime,msr->samprate, sampleindex,(lng)msr->samplecnt,"int",imin,imax);
break;
case 'a': case 'f': case 'd':
default:
msg = createException(MAL,"mseed.import","data type not yet implemented");
goto wrapup;
}
if ( ( msg =SQLstatementIntern(cntxt,&s,"mseed.import",TRUE,FALSE)) != MAL_SUCCEED)
break;
sampleindex += msr->samplecnt;
}
wrapup:
/* Make sure everything is cleaned up */
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
if ( network) GDKfree(network);
if ( station) GDKfree(station);
if ( location) GDKfree(location);
if ( channel) GDKfree(channel);
if ( msg)
return msg;
if ( retcode != MS_ENDOFFILE )
throw(MAL, "mseed.dump", "Cannot read %s: %s\n", *targetfile, ms_errorstr(retcode));
*ret = *vid;
return msg;
}
int
main (int argc, char **argv)
{
MSRecord *msr = 0;
int64_t totalrecs = 0;
int64_t totalsamps = 0;
int retcode;
#ifndef WIN32
/* Signal handling, use POSIX calls with standardized semantics */
struct sigaction sa;
sa.sa_flags = SA_RESTART;
sigemptyset (&sa.sa_mask);
sa.sa_handler = term_handler;
sigaction (SIGINT, &sa, NULL);
sigaction (SIGQUIT, &sa, NULL);
sigaction (SIGTERM, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction (SIGHUP, &sa, NULL);
sigaction (SIGPIPE, &sa, NULL);
#endif
/* Process given parameters (command line and parameter file) */
if (parameter_proc (argc, argv) < 0)
return -1;
/* Loop over the input file */
while ((retcode = ms_readmsr (&msr, inputfile, reclen, NULL, NULL, 1,
printdata, verbose)) == MS_NOERROR)
{
totalrecs++;
totalsamps += msr->samplecnt;
msr_print (msr, ppackets);
if (printdata && msr->numsamples > 0)
{
int line, col, cnt, samplesize;
int lines = (msr->numsamples / 6) + 1;
void *sptr;
if ((samplesize = ms_samplesize (msr->sampletype)) == 0)
{
ms_log (2, "Unrecognized sample type: '%c'\n", msr->sampletype);
}
for (cnt = 0, line = 0; line < lines; line++)
{
for (col = 0; col < 6; col++)
{
if (cnt < msr->numsamples)
{
sptr = (char *)msr->datasamples + (cnt * samplesize);
if (msr->sampletype == 'i')
ms_log (0, "%10d ", *(int32_t *)sptr);
else if (msr->sampletype == 'f')
ms_log (0, "%10.8g ", *(float *)sptr);
else if (msr->sampletype == 'd')
ms_log (0, "%10.10g ", *(double *)sptr);
cnt++;
}
}
ms_log (0, "\n");
/* If only printing the first 6 samples break out here */
if (printdata == 1)
break;
}
}
}
if (retcode != MS_ENDOFFILE)
ms_log (2, "Cannot read %s: %s\n", inputfile, ms_errorstr (retcode));
/* Make sure everything is cleaned up */
ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0);
if (basicsum)
ms_log (1, "Records: %" PRId64 ", Samples: %" PRId64 "\n",
totalrecs, totalsamps);
return 0;
} /* End of main() */