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() */