/*********************************************************************
* ms_readtraces_selection:
*
* This routine will open and read all Mini-SEED records in specified
* file and populate a trace group. This routine is thread safe.
*
* If reclen is <= 0 the length of every record is automatically
* detected.
*
* If a Selections list is supplied it will be used to limit which
* records are added to the trace group.
*
* Returns MS_NOERROR and populates an MSTraceGroup struct at *ppmstg
* on successful read, otherwise returns a libmseed error code (listed
* in libmseed.h).
*********************************************************************/
int
ms_readtraces_selection (MSTraceGroup **ppmstg, const char *msfile,
int reclen, double timetol, double sampratetol,
Selections *selections, flag dataquality,
flag skipnotdata, flag dataflag, flag verbose)
{
MSRecord *msr = 0;
MSFileParam *msfp = 0;
int retcode;
if (!ppmstg)
return MS_GENERROR;
/* Initialize MSTraceGroup if needed */
if (!*ppmstg)
{
*ppmstg = mst_initgroup (*ppmstg);
if (!*ppmstg)
return MS_GENERROR;
}
/* Loop over the input file */
while ((retcode = ms_readmsr_main (&msfp, &msr, msfile, reclen, NULL, NULL,
skipnotdata, dataflag, NULL, verbose)) == MS_NOERROR)
{
/* Test against selections if supplied */
if (selections)
{
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if (ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL)
{
continue;
}
}
/* Add to trace group */
mst_addmsrtogroup (*ppmstg, msr, dataquality, timetol, sampratetol);
}
/* Reset return code to MS_NOERROR on successful read by ms_readmsr() */
if (retcode == MS_ENDOFFILE)
retcode = MS_NOERROR;
ms_readmsr_main (&msfp, &msr, NULL, 0, NULL, NULL, 0, 0, NULL, 0);
return retcode;
} /* End of ms_readtraces_selection() */
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() */
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() */