void bx_sound_linux_c::record_timer(void)
{
record_handler(this->device, record_packet_size);
}
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() */
/***************************************************************************
* msr_pack:
*
* Pack data into SEED data records. Using the record header values
* in the MSRecord as a template the common header fields are packed
* into the record header, blockettes in the blockettes chain are
* packed and data samples are packed in the encoding format indicated
* by the MSRecord->encoding field. A Blockette 1000 will be added if
* one is not present.
*
* The MSRecord->datasamples array and MSRecord->numsamples value will
* not be changed by this routine. It is the responsibility of the
* calling routine to adjust the data buffer if desired.
*
* As each record is filled and finished they are passed to
* record_handler which expects 1) a char * to the record, 2) the
* length of the record and 3) a pointer supplied by the original
* caller containing optional private data (handlerdata). It is the
* responsibility of record_handler to process the record, the memory
* will be re-used or freed when record_handler returns.
*
* If the flush flag != 0 all of the data will be packed into data
* records even though the last one will probably not be filled.
*
* Default values are: data record & quality indicator = 'D', record
* length = 4096, encoding = 11 (Steim2) and byteorder = 1 (MSBF).
* The defaults are triggered when the the msr->dataquality is 0 or
* msr->reclen, msr->encoding and msr->byteorder are -1 respectively.
*
* Returns the number of records created on success and -1 on error.
***************************************************************************/
int
msr_pack ( MSRecord * msr, void (*record_handler) (char *, int, void *),
void *handlerdata, int64_t *packedsamples, flag flush, flag verbose )
{
uint16_t *HPnumsamples;
uint16_t *HPdataoffset;
struct blkt_1001_s *HPblkt1001 = NULL;
char *rawrec;
char *envvariable;
char srcname[50];
flag headerswapflag = 0;
flag dataswapflag = 0;
flag packret;
int samplesize;
int headerlen;
int dataoffset;
int maxdatabytes;
int maxsamples;
int recordcnt = 0;
int packsamples, packoffset;
int64_t totalpackedsamples;
hptime_t segstarttime;
if ( ! msr )
return -1;
if ( ! record_handler )
{
ms_log (2, "msr_pack(): record_handler() function pointer not set!\n");
return -1;
}
/* Allocate stream processing state space if needed */
if ( ! msr->ststate )
{
msr->ststate = (StreamState *) malloc (sizeof(StreamState));
if ( ! msr->ststate )
{
ms_log (2, "msr_pack(): Could not allocate memory for StreamState\n");
return -1;
}
memset (msr->ststate, 0, sizeof(StreamState));
}
/* Generate source name for MSRecord */
if ( msr_srcname (msr, srcname, 1) == NULL )
{
ms_log (2, "msr_unpack_data(): Cannot generate srcname\n");
return MS_GENERROR;
}
/* Set shared srcname pointer to source name */
PACK_SRCNAME = &srcname[0];
/* Track original segment start time for new start time calculation */
segstarttime = msr->starttime;
/* Read possible environmental variables that force byteorder */
if ( packheaderbyteorder == -2 )
{
if ( (envvariable = getenv("PACK_HEADER_BYTEORDER")) )
{
if ( *envvariable != '0' && *envvariable != '1' )
{
ms_log (2, "Environment variable PACK_HEADER_BYTEORDER must be set to '0' or '1'\n");
return -1;
}
else if ( *envvariable == '0' )
{
packheaderbyteorder = 0;
if ( verbose > 2 )
ms_log (1, "PACK_HEADER_BYTEORDER=0, packing little-endian header\n");
}
else
{
packheaderbyteorder = 1;
if ( verbose > 2 )
ms_log (1, "PACK_HEADER_BYTEORDER=1, packing big-endian header\n");
}
}
else
{
packheaderbyteorder = -1;
}
}
if ( packdatabyteorder == -2 )
{
if ( (envvariable = getenv("PACK_DATA_BYTEORDER")) )
{
if ( *envvariable != '0' && *envvariable != '1' )
{
ms_log (2, "Environment variable PACK_DATA_BYTEORDER must be set to '0' or '1'\n");
return -1;
}
else if ( *envvariable == '0' )
{
packdatabyteorder = 0;
if ( verbose > 2 )
ms_log (1, "PACK_DATA_BYTEORDER=0, packing little-endian data samples\n");
}
else
{
packdatabyteorder = 1;
if ( verbose > 2 )
ms_log (1, "PACK_DATA_BYTEORDER=1, packing big-endian data samples\n");
}
}
else
{
packdatabyteorder = -1;
}
}
/* Set default indicator, record length, byte order and encoding if needed */
if ( msr->dataquality == 0 ) msr->dataquality = 'D';
if ( msr->reclen == -1 ) msr->reclen = 4096;
if ( msr->byteorder == -1 ) msr->byteorder = 1;
if ( msr->encoding == -1 ) msr->encoding = DE_STEIM2;
/* Cleanup/reset sequence number */
if ( msr->sequence_number <= 0 || msr->sequence_number > 999999)
msr->sequence_number = 1;
if ( msr->reclen < MINRECLEN || msr->reclen > MAXRECLEN )
{
ms_log (2, "msr_pack(%s): Record length is out of range: %d\n",
PACK_SRCNAME, msr->reclen);
return -1;
}
if ( msr->numsamples <= 0 )
{
ms_log (2, "msr_pack(%s): No samples to pack\n", PACK_SRCNAME);
return -1;
}
samplesize = ms_samplesize (msr->sampletype);
if ( ! samplesize )
{
ms_log (2, "msr_pack(%s): Unknown sample type '%c'\n",
PACK_SRCNAME, msr->sampletype);
return -1;
}
/* Sanity check for msr/quality indicator */
if ( ! MS_ISDATAINDICATOR(msr->dataquality) )
{
ms_log (2, "msr_pack(%s): Record header & quality indicator unrecognized: '%c'\n",
PACK_SRCNAME, msr->dataquality);
ms_log (2, "msr_pack(%s): Packing failed.\n", PACK_SRCNAME);
return -1;
}
/* Allocate space for data record */
rawrec = (char *) malloc (msr->reclen);
if ( rawrec == NULL )
{
ms_log (2, "msr_pack(%s): Cannot allocate memory\n", PACK_SRCNAME);
return -1;
}
/* Set header pointers to known offsets into FSDH */
HPnumsamples = (uint16_t *) (rawrec + 30);
HPdataoffset = (uint16_t *) (rawrec + 44);
/* Check to see if byte swapping is needed */
if ( msr->byteorder != ms_bigendianhost() )
headerswapflag = dataswapflag = 1;
/* Check if byte order is forced */
if ( packheaderbyteorder >= 0 )
{
headerswapflag = ( msr->byteorder != packheaderbyteorder ) ? 1 : 0;
}
if ( packdatabyteorder >= 0 )
{
dataswapflag = ( msr->byteorder != packdatabyteorder ) ? 1 : 0;
}
if ( verbose > 2 )
{
if ( headerswapflag && dataswapflag )
ms_log (1, "%s: Byte swapping needed for packing of header and data samples\n", PACK_SRCNAME);
else if ( headerswapflag )
ms_log (1, "%s: Byte swapping needed for packing of header\n", PACK_SRCNAME);
else if ( dataswapflag )
ms_log (1, "%s: Byte swapping needed for packing of data samples\n", PACK_SRCNAME);
else
ms_log (1, "%s: Byte swapping NOT needed for packing\n", PACK_SRCNAME);
}
/* Add a blank 1000 Blockette if one is not present, the blockette values
will be populated in msr_pack_header_raw()/msr_normalize_header() */
if ( ! msr->Blkt1000 )
{
struct blkt_1000_s blkt1000;
memset (&blkt1000, 0, sizeof (struct blkt_1000_s));
if ( verbose > 2 )
ms_log (1, "%s: Adding 1000 Blockette\n", PACK_SRCNAME);
if ( ! msr_addblockette (msr, (char *) &blkt1000, sizeof(struct blkt_1000_s), 1000, 0) )
{
ms_log (2, "msr_pack(%s): Error adding 1000 Blockette\n", PACK_SRCNAME);
return -1;
}
}
headerlen = msr_pack_header_raw (msr, rawrec, msr->reclen, headerswapflag, 1, &HPblkt1001, verbose);
if ( headerlen == -1 )
{
ms_log (2, "msr_pack(%s): Error packing header\n", PACK_SRCNAME);
return -1;
}
/* Determine offset to encoded data */
if ( msr->encoding == DE_STEIM1 || msr->encoding == DE_STEIM2 )
{
dataoffset = 64;
while ( dataoffset < headerlen )
dataoffset += 64;
/* Zero memory between blockettes and data if any */
memset (rawrec + headerlen, 0, dataoffset - headerlen);
}
else
{
dataoffset = headerlen;
}
*HPdataoffset = (uint16_t) dataoffset;
if ( headerswapflag ) ms_gswap2 (HPdataoffset);
/* Determine the max data bytes and sample count */
maxdatabytes = msr->reclen - dataoffset;
if ( msr->encoding == DE_STEIM1 )
{
maxsamples = (int) (maxdatabytes/64) * STEIM1_FRAME_MAX_SAMPLES;
}
else if ( msr->encoding == DE_STEIM2 )
{
maxsamples = (int) (maxdatabytes/64) * STEIM2_FRAME_MAX_SAMPLES;
}
else
{
maxsamples = maxdatabytes / samplesize;
}
/* Pack samples into records */
*HPnumsamples = 0;
totalpackedsamples = 0;
if ( packedsamples ) *packedsamples = 0;
packoffset = 0;
while ( (msr->numsamples - totalpackedsamples) > maxsamples || flush )
{
packret = msr_pack_data (rawrec + dataoffset,
(char *) msr->datasamples + packoffset,
(int)(msr->numsamples - totalpackedsamples), maxdatabytes,
&packsamples, &msr->ststate->lastintsample, msr->ststate->comphistory,
msr->sampletype, msr->encoding, dataswapflag, verbose);
if ( packret )
{
ms_log (2, "msr_pack(%s): Error packing record\n", PACK_SRCNAME);
return -1;
}
packoffset += packsamples * samplesize;
/* Update number of samples */
*HPnumsamples = (uint16_t) packsamples;
if ( headerswapflag ) ms_gswap2 (HPnumsamples);
if ( verbose > 0 )
ms_log (1, "%s: Packed %d samples\n", PACK_SRCNAME, packsamples);
/* Send record to handler */
record_handler (rawrec, msr->reclen, handlerdata);
totalpackedsamples += packsamples;
if ( packedsamples ) *packedsamples = totalpackedsamples;
msr->ststate->packedsamples += packsamples;
/* Update record header for next record */
msr->sequence_number = ( msr->sequence_number >= 999999 ) ? 1 : msr->sequence_number + 1;
if ( msr->samprate > 0 )
msr->starttime = segstarttime + (hptime_t)(totalpackedsamples / msr->samprate * HPTMODULUS + 0.5);
msr_update_header (msr, rawrec, headerswapflag, HPblkt1001, verbose);
recordcnt++;
msr->ststate->packedrecords++;
/* Set compression history flag for subsequent records (Steim encodings) */
if ( ! msr->ststate->comphistory )
msr->ststate->comphistory = 1;
if ( totalpackedsamples >= msr->numsamples )
break;
}
if ( verbose > 2 )
ms_log (1, "%s: Packed %d total samples\n", PACK_SRCNAME, totalpackedsamples);
free (rawrec);
return recordcnt;
} /* End of msr_pack() */
