/************************************************************************ * msr_decode_int16: * * Decode 16-bit integer data and place in supplied buffer as 32-bit * integers. * * Return number of samples in output buffer on success, -1 on error. ************************************************************************/ int msr_decode_int16 (int16_t *input, int samplecount, int32_t *output, int outputlength, int swapflag) { int16_t sample; int idx; if (samplecount <= 0) return 0; if (!input || !output || outputlength <= 0) return -1; for (idx = 0; idx < samplecount && outputlength >= (int)sizeof (int32_t); idx++) { sample = input[idx]; if (swapflag) ms_gswap2a (&sample); output[idx] = (int32_t)sample; outputlength -= sizeof (int32_t); } return idx; } /* End of msr_decode_int16() */
/************************************************************************ * msr_decode_dwwssn: * * Decode DWWSSN encoded miniSEED data and place in supplied buffer * as 32-bit integers. * * Return number of samples in output buffer on success, -1 on error. ************************************************************************/ int msr_decode_dwwssn (int16_t *input, int samplecount, int32_t *output, int outputlength, int swapflag) { int32_t idx = 0; int32_t sample; uint16_t sint; if (samplecount < 0) return 0; for (idx = 0; idx < samplecount && outputlength >= (int)sizeof (int32_t); idx++) { memcpy (&sint, &input[idx], sizeof (uint16_t)); if (swapflag) ms_gswap2a (&sint); sample = (int32_t)sint; /* Take 2's complement for sample */ if (sample > MAX16) sample -= 2 * (MAX16 + 1); /* Save sample in output array */ output[idx] = sample; outputlength -= sizeof (int32_t); } return idx; } /* End of msr_decode_dwwssn() */
/************************************************************************ * msr_decode_sro: * * Decode SRO gain ranged data encoded miniSEED data and place in * supplied buffer as 32-bit integers. * * Notes from original rdseed routine: * SRO data are represented according to the formula * * sample = M * (b exp {[m * (G + agr)] + ar}) * * where * sample = seismic data sample * M = mantissa * G = gain range factor * b = base to be exponentiated = 2 for SRO * m = multiplier = -1 for SRO * agr = term to be added to gain range factor = 0 for SRO * ar = term to be added to [m * (gr + agr)] = 10 for SRO * exp = exponentiation operation * Data are stored in two bytes as follows: * fedc ba98 7654 3210 = bit number, power of two * GGGG MMMM MMMM MMMM = form of SEED data * where G = gain range factor and M = mantissa * Masks to recover gain range and mantissa: * fedc ba98 7654 3210 = bit number = power of two * 0000 1111 1111 1111 = 0x0fff = mask for mantissa * 1111 0000 0000 0000 = 0xf000 = mask for gain range * * Return number of samples in output buffer on success, -1 on error. ************************************************************************/ int msr_decode_sro (int16_t *input, int samplecount, int32_t *output, int outputlength, char *srcname, int swapflag) { int32_t idx = 0; int32_t mantissa; /* mantissa */ int32_t gainrange; /* gain range factor */ int32_t add2gr; /* added to gainrage factor */ int32_t mult; /* multiplier for gain range */ int32_t add2result; /* added to multiplied gain rage */ int32_t exponent; /* total exponent */ uint16_t sint; int32_t sample; if (samplecount <= 0) return 0; add2gr = 0; mult = -1; add2result = 10; for (idx = 0; idx < samplecount && outputlength >= (int)sizeof (int32_t); idx++) { memcpy (&sint, &input[idx], sizeof (int16_t)); if (swapflag) ms_gswap2a (&sint); /* Recover mantissa and gain range factor */ mantissa = (sint & SRO_MANTISSA_MASK); gainrange = (sint & SRO_GAINRANGE_MASK) >> SRO_SHIFT; /* Take 2's complement for mantissa */ if (mantissa > MAX12) mantissa -= 2 * (MAX12 + 1); /* Calculate exponent, SRO exponent = 0..10 */ exponent = (mult * (gainrange + add2gr)) + add2result; if (exponent < 0 || exponent > 10) { ms_log (2, "msr_decode_sro(%s): SRO gain ranging exponent out of range: %d\n", srcname, exponent); return MS_GENERROR; } /* Calculate sample as mantissa * 2^exponent */ sample = mantissa * ((uint64_t)1 << exponent); /* Save sample in output array */ output[idx] = sample; outputlength -= sizeof (int32_t); } return idx; } /* End of msr_decode_sro() */
/************************************************************************ * msr_decode_cdsn: * * Decode CDSN gain ranged data encoded miniSEED data and place in * supplied buffer as 32-bit integers. * * Notes from original rdseed routine: * CDSN data are compressed according to the formula * * sample = M * (2 exp G) * * where * sample = seismic data sample * M = mantissa; biased mantissa B is written to tape * G = exponent of multiplier (i.e. gain range factor); * key K is written to tape * exp = exponentiation operation * B = M + 8191, biased mantissa, written to tape * K = key to multiplier exponent, written to tape * K may have any of the values 0 - 3, as follows: * 0 => G = 0, multiplier = 2 exp 0 = 1 * 1 => G = 2, multiplier = 2 exp 2 = 4 * 2 => G = 4, multiplier = 2 exp 4 = 16 * 3 => G = 7, multiplier = 2 exp 7 = 128 * Data are stored on tape in two bytes as follows: * fedc ba98 7654 3210 = bit number, power of two * KKBB BBBB BBBB BBBB = form of SEED data * where K = key to multiplier exponent and B = biased mantissa * * Masks to recover key to multiplier exponent and biased mantissa * from tape are: * fedc ba98 7654 3210 = bit number = power of two * 0011 1111 1111 1111 = 0x3fff = mask for biased mantissa * 1100 0000 0000 0000 = 0xc000 = mask for gain range key * * Return number of samples in output buffer on success, -1 on error. ************************************************************************/ int msr_decode_cdsn (int16_t *input, int samplecount, int32_t *output, int outputlength, int swapflag) { int32_t idx = 0; int32_t mantissa; /* mantissa */ int32_t gainrange; /* gain range factor */ int32_t mult = -1; /* multiplier for gain range */ uint16_t sint; int32_t sample; if (samplecount <= 0) return 0; for (idx = 0; idx < samplecount && outputlength >= (int)sizeof (int32_t); idx++) { memcpy (&sint, &input[idx], sizeof (int16_t)); if (swapflag) ms_gswap2a (&sint); /* Recover mantissa and gain range factor */ mantissa = (sint & CDSN_MANTISSA_MASK); gainrange = (sint & CDSN_GAINRANGE_MASK) >> CDSN_SHIFT; /* Determine multiplier from the gain range factor and format definition * because shift operator is used later, these are powers of two */ if (gainrange == 0) mult = 0; else if (gainrange == 1) mult = 2; else if (gainrange == 2) mult = 4; else if (gainrange == 3) mult = 7; /* Unbias the mantissa */ mantissa -= MAX14; /* Calculate sample from mantissa and multiplier using left shift * mantissa << mult is equivalent to mantissa * (2 exp (mult)) */ sample = (mantissa << mult); /* Save sample in output array */ output[idx] = sample; outputlength -= sizeof (int32_t); } return idx; } /* End of msr_decode_cdsn() */
/************************************************************************ * msr_decode_geoscope: * * Decode GEOSCOPE gain ranged data (demultiplexed only) encoded * miniSEED data and place in supplied buffer as 32-bit floats. * * Return number of samples in output buffer on success, -1 on error. ************************************************************************/ int msr_decode_geoscope (char *input, int samplecount, float *output, int outputlength, int encoding, char *srcname, int swapflag) { int idx = 0; int mantissa; /* mantissa from SEED data */ int gainrange; /* gain range factor */ int exponent; /* total exponent */ int k; uint64_t exp2val; int16_t sint; double dsample = 0.0; union { uint8_t b[4]; uint32_t i; } sample32; if (!input || !output) return -1; if (samplecount <= 0 || outputlength <= 0) return -1; /* Make sure we recognize this as a GEOSCOPE encoding format */ if (encoding != DE_GEOSCOPE24 && encoding != DE_GEOSCOPE163 && encoding != DE_GEOSCOPE164) { ms_log (2, "msr_decode_geoscope(%s): unrecognized GEOSCOPE encoding: %d\n", srcname, encoding); return -1; } for (idx = 0; idx < samplecount && outputlength >= (int)sizeof (float); idx++) { switch (encoding) { case DE_GEOSCOPE24: sample32.i = 0; if (swapflag) for (k = 0; k < 3; k++) sample32.b[2 - k] = input[k]; else for (k = 0; k < 3; k++) sample32.b[1 + k] = input[k]; mantissa = sample32.i; /* Take 2's complement for mantissa for overflow */ if (mantissa > MAX24) mantissa -= 2 * (MAX24 + 1); /* Store */ dsample = (double)mantissa; break; case DE_GEOSCOPE163: memcpy (&sint, input, sizeof (int16_t)); if (swapflag) ms_gswap2a (&sint); /* Recover mantissa and gain range factor */ mantissa = (sint & GEOSCOPE_MANTISSA_MASK); gainrange = (sint & GEOSCOPE_GAIN3_MASK) >> GEOSCOPE_SHIFT; /* Exponent is just gainrange for GEOSCOPE */ exponent = gainrange; /* Calculate sample as mantissa / 2^exponent */ exp2val = (uint64_t)1 << exponent; dsample = ((double)(mantissa - 2048)) / exp2val; break; case DE_GEOSCOPE164: memcpy (&sint, input, sizeof (int16_t)); if (swapflag) ms_gswap2a (&sint); /* Recover mantissa and gain range factor */ mantissa = (sint & GEOSCOPE_MANTISSA_MASK); gainrange = (sint & GEOSCOPE_GAIN4_MASK) >> GEOSCOPE_SHIFT; /* Exponent is just gainrange for GEOSCOPE */ exponent = gainrange; /* Calculate sample as mantissa / 2^exponent */ exp2val = (uint64_t)1 << exponent; dsample = ((double)(mantissa - 2048)) / exp2val; break; } /* Save sample in output array */ output[idx] = (float)dsample; outputlength -= sizeof (float); /* Increment edata pointer depending on size */ switch (encoding) { case DE_GEOSCOPE24: input += 3; break; case DE_GEOSCOPE163: case DE_GEOSCOPE164: input += 2; break; } } return idx; } /* End of msr_decode_geoscope() */
/************************************************************************ * msr_decode_steim1: * * Decode Steim1 encoded miniSEED data and place in supplied buffer * as 32-bit integers. * * Return number of samples in output buffer on success, -1 on error. ************************************************************************/ int msr_decode_steim1 (int32_t *input, int inputlength, int samplecount, int32_t *output, int outputlength, char *srcname, int swapflag) { int32_t *outputptr = output; /* Pointer to next output sample location */ uint32_t frame[16]; /* Frame, 16 x 32-bit quantities = 64 bytes */ int32_t X0 = 0; /* Forward integration constant, aka first sample */ int32_t Xn = 0; /* Reverse integration constant, aka last sample */ int maxframes = inputlength / 64; int frameidx; int startnibble; int nibble; int widx; int diffcount; int idx; union dword { int8_t d8[4]; int16_t d16[2]; int32_t d32; } * word; if (inputlength <= 0) return 0; if (!input || !output || outputlength <= 0 || maxframes <= 0) return -1; if (decodedebug) ms_log (1, "Decoding %d Steim1 frames, swapflag: %d, srcname: %s\n", maxframes, swapflag, (srcname) ? srcname : ""); for (frameidx = 0; frameidx < maxframes && samplecount > 0; frameidx++) { /* Copy frame, each is 16x32-bit quantities = 64 bytes */ memcpy (frame, input + (16 * frameidx), 64); /* Save forward integration constant (X0) and reverse integration constant (Xn) and set the starting nibble index depending on frame. */ if (frameidx == 0) { if (swapflag) { ms_gswap4a (&frame[1]); ms_gswap4a (&frame[2]); } X0 = frame[1]; Xn = frame[2]; startnibble = 3; /* First frame: skip nibbles, X0, and Xn */ if (decodedebug) ms_log (1, "Frame %d: X0=%d Xn=%d\n", frameidx, X0, Xn); } else { startnibble = 1; /* Subsequent frames: skip nibbles */ if (decodedebug) ms_log (1, "Frame %d\n", frameidx); } /* Swap 32-bit word containing the nibbles */ if (swapflag) ms_gswap4a (&frame[0]); /* Decode each 32-bit word according to nibble */ for (widx = startnibble; widx < 16 && samplecount > 0; widx++) { /* W0: the first 32-bit contains 16 x 2-bit nibbles for each word */ nibble = EXTRACTBITRANGE (frame[0], (30 - (2 * widx)), 2); word = (union dword *)&frame[widx]; diffcount = 0; switch (nibble) { case 0: /* 00: Special flag, no differences */ if (decodedebug) ms_log (1, " W%02d: 00=special\n", widx); break; case 1: /* 01: Four 1-byte differences */ diffcount = 4; if (decodedebug) ms_log (1, " W%02d: 01=4x8b %d %d %d %d\n", widx, word->d8[0], word->d8[1], word->d8[2], word->d8[3]); break; case 2: /* 10: Two 2-byte differences */ diffcount = 2; if (swapflag) { ms_gswap2a (&word->d16[0]); ms_gswap2a (&word->d16[1]); } if (decodedebug) ms_log (1, " W%02d: 10=2x16b %d %d\n", widx, word->d16[0], word->d16[1]); break; case 3: /* 11: One 4-byte difference */ diffcount = 1; if (swapflag) ms_gswap4a (&word->d32); if (decodedebug) ms_log (1, " W%02d: 11=1x32b %d\n", widx, word->d32); break; } /* Done with decoding 32-bit word based on nibble */ /* Apply accumulated differences to calculate output samples */ if (diffcount > 0) { for (idx = 0; idx < diffcount && samplecount > 0; idx++, outputptr++) { if (outputptr == output) /* Ignore first difference, instead store X0 */ *outputptr = X0; else if (diffcount == 4) /* Otherwise store difference from previous sample */ *outputptr = *(outputptr - 1) + word->d8[idx]; else if (diffcount == 2) *outputptr = *(outputptr - 1) + word->d16[idx]; else if (diffcount == 1) *outputptr = *(outputptr - 1) + word->d32; samplecount--; } } } /* Done looping over nibbles and 32-bit words */ } /* Done looping over frames */ /* Check data integrity by comparing last sample to Xn (reverse integration constant) */ if (outputptr != output && *(outputptr - 1) != Xn) { ms_log (1, "%s: Warning: Data integrity check for Steim1 failed, Last sample=%d, Xn=%d\n", srcname, *(outputptr - 1), Xn); } return (outputptr - output); } /* End of msr_decode_steim1() */
/*************************************************************************** * ms_parse_raw: * * Parse and verify a SEED data record header (fixed section and * blockettes) at the lowest level, printing error messages for * invalid header values and optionally print raw header values. The * memory at 'record' is assumed to be a Mini-SEED record. Not every * possible test is performed, common errors and those causing * libmseed parsing to fail should be detected. * * The 'details' argument is interpreted as follows: * * details: * 0 = only print error messages for invalid header fields * 1 = print basic fields in addition to invalid field errors * 2 = print all fields in addition to invalid field errors * * The 'swapflag' argument is interpreted as follows: * * swapflag: * 1 = swap multibyte quantities * 0 = do no swapping * -1 = autodetect byte order using year test, swap if needed * * Any byte swapping performed by this routine is applied directly to * the memory reference by the record pointer. * * This routine is primarily intended to diagnose invalid Mini-SEED headers. * * Returns 0 when no errors were detected or a positive count of * errors detected. ***************************************************************************/ int ms_parse_raw ( char *record, int maxreclen, flag details, flag swapflag ) { struct fsdh_s *fsdh; double nomsamprate; char srcname[50]; char *X; char b; int retval = 0; int b1000encoding = -1; int b1000reclen = -1; int endofblockettes = -1; int idx; if ( ! record ) return 1; /* Generate a source name string */ srcname[0] = '\0'; ms_recsrcname (record, srcname, 1); fsdh = (struct fsdh_s *) record; /* Check to see if byte swapping is needed by testing the year */ if ( swapflag == -1 && ((fsdh->start_time.year < 1900) || (fsdh->start_time.year > 2050)) ) swapflag = 1; else swapflag = 0; if ( details > 1 ) { if ( swapflag == 1 ) ms_log (0, "Swapping multi-byte quantities in header\n"); else ms_log (0, "Not swapping multi-byte quantities in header\n"); } /* Swap byte order */ if ( swapflag ) { MS_SWAPBTIME (&fsdh->start_time); ms_gswap2a (&fsdh->numsamples); ms_gswap2a (&fsdh->samprate_fact); ms_gswap2a (&fsdh->samprate_mult); ms_gswap4a (&fsdh->time_correct); ms_gswap2a (&fsdh->data_offset); ms_gswap2a (&fsdh->blockette_offset); } /* Validate fixed section header fields */ X = record; /* Pointer of convenience */ /* Check record sequence number, 6 ASCII digits */ if ( ! isdigit((unsigned char) *(X)) || ! isdigit ((unsigned char) *(X+1)) || ! isdigit((unsigned char) *(X+2)) || ! isdigit ((unsigned char) *(X+3)) || ! isdigit((unsigned char) *(X+4)) || ! isdigit ((unsigned char) *(X+5)) ) { ms_log (2, "%s: Invalid sequence number: '%c%c%c%c%c%c'\n", srcname, X, X+1, X+2, X+3, X+4, X+5); retval++; } /* Check header/quality indicator */ if ( ! MS_ISDATAINDICATOR(*(X+6)) ) { ms_log (2, "%s: Invalid header indicator (DRQM): '%c'\n", srcname, X+6); retval++; } /* Check reserved byte, space or NULL */ if ( ! (*(X+7) == ' ' || *(X+7) == '\0') ) { ms_log (2, "%s: Invalid fixed section reserved byte (Space): '%c'\n", srcname, X+7); retval++; } /* Check station code, 5 alphanumerics or spaces */ if ( ! (isalnum((unsigned char) *(X+8)) || *(X+8) == ' ') || ! (isalnum((unsigned char) *(X+9)) || *(X+9) == ' ') || ! (isalnum((unsigned char) *(X+10)) || *(X+10) == ' ') || ! (isalnum((unsigned char) *(X+11)) || *(X+11) == ' ') || ! (isalnum((unsigned char) *(X+12)) || *(X+12) == ' ') ) { ms_log (2, "%s: Invalid station code: '%c%c%c%c%c'\n", srcname, X+8, X+9, X+10, X+11, X+12); retval++; } /* Check location ID, 2 alphanumerics or spaces */ if ( ! (isalnum((unsigned char) *(X+13)) || *(X+13) == ' ') || ! (isalnum((unsigned char) *(X+14)) || *(X+14) == ' ') ) { ms_log (2, "%s: Invalid location ID: '%c%c'\n", srcname, X+13, X+14); retval++; } /* Check channel codes, 3 alphanumerics or spaces */ if ( ! (isalnum((unsigned char) *(X+15)) || *(X+15) == ' ') || ! (isalnum((unsigned char) *(X+16)) || *(X+16) == ' ') || ! (isalnum((unsigned char) *(X+17)) || *(X+17) == ' ') ) { ms_log (2, "%s: Invalid channel codes: '%c%c%c'\n", srcname, X+15, X+16, X+17); retval++; } /* Check network code, 2 alphanumerics or spaces */ if ( ! (isalnum((unsigned char) *(X+18)) || *(X+18) == ' ') || ! (isalnum((unsigned char) *(X+19)) || *(X+19) == ' ') ) { ms_log (2, "%s: Invalid network code: '%c%c'\n", srcname, X+18, X+19); retval++; } /* Check start time fields */ if ( fsdh->start_time.year < 1920 || fsdh->start_time.year > 2050 ) { ms_log (2, "%s: Unlikely start year (1920-2050): '%d'\n", srcname, fsdh->start_time.year); retval++; } if ( fsdh->start_time.day < 1 || fsdh->start_time.day > 366 ) { ms_log (2, "%s: Invalid start day (1-366): '%d'\n", srcname, fsdh->start_time.day); retval++; } if ( fsdh->start_time.hour > 23 ) { ms_log (2, "%s: Invalid start hour (0-23): '%d'\n", srcname, fsdh->start_time.hour); retval++; } if ( fsdh->start_time.min > 59 ) { ms_log (2, "%s: Invalid start minute (0-59): '%d'\n", srcname, fsdh->start_time.min); retval++; } if ( fsdh->start_time.sec > 60 ) { ms_log (2, "%s: Invalid start second (0-60): '%d'\n", srcname, fsdh->start_time.sec); retval++; } if ( fsdh->start_time.fract > 9999 ) { ms_log (2, "%s: Invalid start fractional seconds (0-9999): '%d'\n", srcname, fsdh->start_time.fract); retval++; } /* Check number of samples, max samples in 4096-byte Steim-2 encoded record: 6601 */ if ( fsdh->numsamples > 20000 ) { ms_log (2, "%s: Unlikely number of samples (>20000): '%d'\n", srcname, fsdh->numsamples); retval++; } /* Sanity check that there is space for blockettes when both data and blockettes are present */ if ( fsdh->numsamples > 0 && fsdh->numblockettes > 0 && fsdh->data_offset <= fsdh->blockette_offset ) { ms_log (2, "%s: No space for %d blockettes, data offset: %d, blockette offset: %d\n", srcname, fsdh->numblockettes, fsdh->data_offset, fsdh->blockette_offset); retval++; } /* Print raw header details */ if ( details >= 1 ) { /* Determine nominal sample rate */ nomsamprate = ms_nomsamprate (fsdh->samprate_fact, fsdh->samprate_mult); /* Print header values */ ms_log (0, "RECORD -- %s\n", srcname); ms_log (0, " sequence number: '%c%c%c%c%c%c'\n", fsdh->sequence_number[0], fsdh->sequence_number[1], fsdh->sequence_number[2], fsdh->sequence_number[3], fsdh->sequence_number[4], fsdh->sequence_number[5]); ms_log (0, " data quality indicator: '%c'\n", fsdh->dataquality); if ( details > 0 ) ms_log (0, " reserved: '%c'\n", fsdh->reserved); ms_log (0, " station code: '%c%c%c%c%c'\n", fsdh->station[0], fsdh->station[1], fsdh->station[2], fsdh->station[3], fsdh->station[4]); ms_log (0, " location ID: '%c%c'\n", fsdh->location[0], fsdh->location[1]); ms_log (0, " channel codes: '%c%c%c'\n", fsdh->channel[0], fsdh->channel[1], fsdh->channel[2]); ms_log (0, " network code: '%c%c'\n", fsdh->network[0], fsdh->network[1]); ms_log (0, " start time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", fsdh->start_time.year, fsdh->start_time.day, fsdh->start_time.hour, fsdh->start_time.min, fsdh->start_time.sec, fsdh->start_time.fract, fsdh->start_time.unused); ms_log (0, " number of samples: %d\n", fsdh->numsamples); ms_log (0, " sample rate factor: %d (%.10g samples per second)\n", fsdh->samprate_fact, nomsamprate); ms_log (0, " sample rate multiplier: %d\n", fsdh->samprate_mult); /* Print flag details if requested */ if ( details > 1 ) { /* Activity flags */ b = fsdh->act_flags; ms_log (0, " activity flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x01 ) ms_log (0, " [Bit 0] Calibration signals present\n"); if ( b & 0x02 ) ms_log (0, " [Bit 1] Time correction applied\n"); if ( b & 0x04 ) ms_log (0, " [Bit 2] Beginning of an event, station trigger\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] End of an event, station detrigger\n"); if ( b & 0x10 ) ms_log (0, " [Bit 4] A positive leap second happened in this record\n"); if ( b & 0x20 ) ms_log (0, " [Bit 5] A negative leap second happened in this record\n"); if ( b & 0x40 ) ms_log (0, " [Bit 6] Event in progress\n"); if ( b & 0x80 ) ms_log (0, " [Bit 7] Undefined bit set\n"); /* I/O and clock flags */ b = fsdh->io_flags; ms_log (0, " I/O and clock flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x01 ) ms_log (0, " [Bit 0] Station volume parity error possibly present\n"); if ( b & 0x02 ) ms_log (0, " [Bit 1] Long record read (possibly no problem)\n"); if ( b & 0x04 ) ms_log (0, " [Bit 2] Short record read (record padded)\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] Start of time series\n"); if ( b & 0x10 ) ms_log (0, " [Bit 4] End of time series\n"); if ( b & 0x20 ) ms_log (0, " [Bit 5] Clock locked\n"); if ( b & 0x40 ) ms_log (0, " [Bit 6] Undefined bit set\n"); if ( b & 0x80 ) ms_log (0, " [Bit 7] Undefined bit set\n"); /* Data quality flags */ b = fsdh->dq_flags; ms_log (0, " data quality flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x01 ) ms_log (0, " [Bit 0] Amplifier saturation detected\n"); if ( b & 0x02 ) ms_log (0, " [Bit 1] Digitizer clipping detected\n"); if ( b & 0x04 ) ms_log (0, " [Bit 2] Spikes detected\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] Glitches detected\n"); if ( b & 0x10 ) ms_log (0, " [Bit 4] Missing/padded data present\n"); if ( b & 0x20 ) ms_log (0, " [Bit 5] Telemetry synchronization error\n"); if ( b & 0x40 ) ms_log (0, " [Bit 6] A digital filter may be charging\n"); if ( b & 0x80 ) ms_log (0, " [Bit 7] Time tag is questionable\n"); } ms_log (0, " number of blockettes: %d\n", fsdh->numblockettes); ms_log (0, " time correction: %ld\n", (long int) fsdh->time_correct); ms_log (0, " data offset: %d\n", fsdh->data_offset); ms_log (0, " first blockette offset: %d\n", fsdh->blockette_offset); } /* Done printing raw header details */ /* Validate and report information in the blockette chain */ if ( fsdh->blockette_offset > 46 && fsdh->blockette_offset < maxreclen ) { int blkt_offset = fsdh->blockette_offset; int blkt_count = 0; int blkt_length; uint16_t blkt_type; uint16_t next_blkt; char *blkt_desc; /* Traverse blockette chain */ while ( blkt_offset != 0 && blkt_offset < maxreclen ) { /* Every blockette has a similar 4 byte header: type and next */ memcpy (&blkt_type, record + blkt_offset, 2); memcpy (&next_blkt, record + blkt_offset+2, 2); if ( swapflag ) { ms_gswap2 (&blkt_type); ms_gswap2 (&next_blkt); } /* Print common header fields */ if ( details >= 1 ) { blkt_desc = ms_blktdesc(blkt_type); ms_log (0, " BLOCKETTE %u: (%s)\n", blkt_type, (blkt_desc) ? blkt_desc : "Unknown"); ms_log (0, " next blockette: %u\n", next_blkt); } blkt_length = ms_blktlen (blkt_type, record + blkt_offset, swapflag); if ( blkt_length == 0 ) { ms_log (2, "%s: Unknown blockette length for type %d\n", srcname, blkt_type); retval++; } /* Track end of blockette chain */ endofblockettes = blkt_offset + blkt_length - 1; /* Sanity check that the blockette is contained in the record */ if ( endofblockettes > maxreclen ) { ms_log (2, "%s: Blockette type %d at offset %d with length %d does not fix in record (%d)\n", srcname, blkt_type, blkt_offset, blkt_length, maxreclen); retval++; break; } if ( blkt_type == 100 ) { struct blkt_100_s *blkt_100 = (struct blkt_100_s *) (record + blkt_offset + 4); if ( swapflag ) ms_gswap4 (&blkt_100->samprate); if ( details >= 1 ) { ms_log (0, " actual sample rate: %.10g\n", blkt_100->samprate); if ( details > 1 ) { b = blkt_100->flags; ms_log (0, " undefined flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); ms_log (0, " reserved bytes (3): %u,%u,%u\n", blkt_100->reserved[0], blkt_100->reserved[1], blkt_100->reserved[2]); } } } else if ( blkt_type == 200 ) { struct blkt_200_s *blkt_200 = (struct blkt_200_s *) (record + blkt_offset + 4); if ( swapflag ) { ms_gswap4 (&blkt_200->amplitude); ms_gswap4 (&blkt_200->period); ms_gswap4 (&blkt_200->background_estimate); MS_SWAPBTIME (&blkt_200->time); } if ( details >= 1 ) { ms_log (0, " signal amplitude: %g\n", blkt_200->amplitude); ms_log (0, " signal period: %g\n", blkt_200->period); ms_log (0, " background estimate: %g\n", blkt_200->background_estimate); if ( details > 1 ) { b = blkt_200->flags; ms_log (0, " event detection flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x01 ) ms_log (0, " [Bit 0] 1: Dilatation wave\n"); else ms_log (0, " [Bit 0] 0: Compression wave\n"); if ( b & 0x02 ) ms_log (0, " [Bit 1] 1: Units after deconvolution\n"); else ms_log (0, " [Bit 1] 0: Units are digital counts\n"); if ( b & 0x04 ) ms_log (0, " [Bit 2] Bit 0 is undetermined\n"); ms_log (0, " reserved byte: %u\n", blkt_200->reserved); } ms_log (0, " signal onset time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_200->time.year, blkt_200->time.day, blkt_200->time.hour, blkt_200->time.min, blkt_200->time.sec, blkt_200->time.fract, blkt_200->time.unused); ms_log (0, " detector name: %.24s\n", blkt_200->detector); } } else if ( blkt_type == 201 ) { struct blkt_201_s *blkt_201 = (struct blkt_201_s *) (record + blkt_offset + 4); if ( swapflag ) { ms_gswap4 (&blkt_201->amplitude); ms_gswap4 (&blkt_201->period); ms_gswap4 (&blkt_201->background_estimate); MS_SWAPBTIME (&blkt_201->time); } if ( details >= 1 ) { ms_log (0, " signal amplitude: %g\n", blkt_201->amplitude); ms_log (0, " signal period: %g\n", blkt_201->period); ms_log (0, " background estimate: %g\n", blkt_201->background_estimate); b = blkt_201->flags; ms_log (0, " event detection flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x01 ) ms_log (0, " [Bit 0] 1: Dilation wave\n"); else ms_log (0, " [Bit 0] 0: Compression wave\n"); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_201->reserved); ms_log (0, " signal onset time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_201->time.year, blkt_201->time.day, blkt_201->time.hour, blkt_201->time.min, blkt_201->time.sec, blkt_201->time.fract, blkt_201->time.unused); ms_log (0, " SNR values: "); for (idx=0; idx < 6; idx++) ms_log (0, "%u ", blkt_201->snr_values[idx]); ms_log (0, "\n"); ms_log (0, " loopback value: %u\n", blkt_201->loopback); ms_log (0, " pick algorithm: %u\n", blkt_201->pick_algorithm); ms_log (0, " detector name: %.24s\n", blkt_201->detector); } } else if ( blkt_type == 300 ) { struct blkt_300_s *blkt_300 = (struct blkt_300_s *) (record + blkt_offset + 4); if ( swapflag ) { MS_SWAPBTIME (&blkt_300->time); ms_gswap4 (&blkt_300->step_duration); ms_gswap4 (&blkt_300->interval_duration); ms_gswap4 (&blkt_300->amplitude); ms_gswap4 (&blkt_300->reference_amplitude); } if ( details >= 1 ) { ms_log (0, " calibration start time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_300->time.year, blkt_300->time.day, blkt_300->time.hour, blkt_300->time.min, blkt_300->time.sec, blkt_300->time.fract, blkt_300->time.unused); ms_log (0, " number of calibrations: %u\n", blkt_300->numcalibrations); b = blkt_300->flags; ms_log (0, " calibration flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x01 ) ms_log (0, " [Bit 0] First pulse is positive\n"); if ( b & 0x02 ) ms_log (0, " [Bit 1] Calibration's alternate sign\n"); if ( b & 0x04 ) ms_log (0, " [Bit 2] Calibration was automatic\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] Calibration continued from previous record(s)\n"); ms_log (0, " step duration: %u\n", blkt_300->step_duration); ms_log (0, " interval duration: %u\n", blkt_300->interval_duration); ms_log (0, " signal amplitude: %g\n", blkt_300->amplitude); ms_log (0, " input signal channel: %.3s", blkt_300->input_channel); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_300->reserved); ms_log (0, " reference amplitude: %u\n", blkt_300->reference_amplitude); ms_log (0, " coupling: %.12s\n", blkt_300->coupling); ms_log (0, " rolloff: %.12s\n", blkt_300->rolloff); } } else if ( blkt_type == 310 ) { struct blkt_310_s *blkt_310 = (struct blkt_310_s *) (record + blkt_offset + 4); if ( swapflag ) { MS_SWAPBTIME (&blkt_310->time); ms_gswap4 (&blkt_310->duration); ms_gswap4 (&blkt_310->period); ms_gswap4 (&blkt_310->amplitude); ms_gswap4 (&blkt_310->reference_amplitude); } if ( details >= 1 ) { ms_log (0, " calibration start time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_310->time.year, blkt_310->time.day, blkt_310->time.hour, blkt_310->time.min, blkt_310->time.sec, blkt_310->time.fract, blkt_310->time.unused); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_310->reserved1); b = blkt_310->flags; ms_log (0, " calibration flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x04 ) ms_log (0, " [Bit 2] Calibration was automatic\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] Calibration continued from previous record(s)\n"); if ( b & 0x10 ) ms_log (0, " [Bit 4] Peak-to-peak amplitude\n"); if ( b & 0x20 ) ms_log (0, " [Bit 5] Zero-to-peak amplitude\n"); if ( b & 0x40 ) ms_log (0, " [Bit 6] RMS amplitude\n"); ms_log (0, " calibration duration: %u\n", blkt_310->duration); ms_log (0, " signal period: %g\n", blkt_310->period); ms_log (0, " signal amplitude: %g\n", blkt_310->amplitude); ms_log (0, " input signal channel: %.3s", blkt_310->input_channel); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_310->reserved2); ms_log (0, " reference amplitude: %u\n", blkt_310->reference_amplitude); ms_log (0, " coupling: %.12s\n", blkt_310->coupling); ms_log (0, " rolloff: %.12s\n", blkt_310->rolloff); } } else if ( blkt_type == 320 ) { struct blkt_320_s *blkt_320 = (struct blkt_320_s *) (record + blkt_offset + 4); if ( swapflag ) { MS_SWAPBTIME (&blkt_320->time); ms_gswap4 (&blkt_320->duration); ms_gswap4 (&blkt_320->ptp_amplitude); ms_gswap4 (&blkt_320->reference_amplitude); } if ( details >= 1 ) { ms_log (0, " calibration start time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_320->time.year, blkt_320->time.day, blkt_320->time.hour, blkt_320->time.min, blkt_320->time.sec, blkt_320->time.fract, blkt_320->time.unused); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_320->reserved1); b = blkt_320->flags; ms_log (0, " calibration flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x04 ) ms_log (0, " [Bit 2] Calibration was automatic\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] Calibration continued from previous record(s)\n"); if ( b & 0x10 ) ms_log (0, " [Bit 4] Random amplitudes\n"); ms_log (0, " calibration duration: %u\n", blkt_320->duration); ms_log (0, " peak-to-peak amplitude: %g\n", blkt_320->ptp_amplitude); ms_log (0, " input signal channel: %.3s", blkt_320->input_channel); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_320->reserved2); ms_log (0, " reference amplitude: %u\n", blkt_320->reference_amplitude); ms_log (0, " coupling: %.12s\n", blkt_320->coupling); ms_log (0, " rolloff: %.12s\n", blkt_320->rolloff); ms_log (0, " noise type: %.8s\n", blkt_320->noise_type); } } else if ( blkt_type == 390 ) { struct blkt_390_s *blkt_390 = (struct blkt_390_s *) (record + blkt_offset + 4); if ( swapflag ) { MS_SWAPBTIME (&blkt_390->time); ms_gswap4 (&blkt_390->duration); ms_gswap4 (&blkt_390->amplitude); } if ( details >= 1 ) { ms_log (0, " calibration start time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_390->time.year, blkt_390->time.day, blkt_390->time.hour, blkt_390->time.min, blkt_390->time.sec, blkt_390->time.fract, blkt_390->time.unused); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_390->reserved1); b = blkt_390->flags; ms_log (0, " calibration flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( b & 0x04 ) ms_log (0, " [Bit 2] Calibration was automatic\n"); if ( b & 0x08 ) ms_log (0, " [Bit 3] Calibration continued from previous record(s)\n"); ms_log (0, " calibration duration: %u\n", blkt_390->duration); ms_log (0, " signal amplitude: %g\n", blkt_390->amplitude); ms_log (0, " input signal channel: %.3s", blkt_390->input_channel); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_390->reserved2); } } else if ( blkt_type == 395 ) { struct blkt_395_s *blkt_395 = (struct blkt_395_s *) (record + blkt_offset + 4); if ( swapflag ) MS_SWAPBTIME (&blkt_395->time); if ( details >= 1 ) { ms_log (0, " calibration end time: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_395->time.year, blkt_395->time.day, blkt_395->time.hour, blkt_395->time.min, blkt_395->time.sec, blkt_395->time.fract, blkt_395->time.unused); if ( details > 1 ) ms_log (0, " reserved bytes (2): %u,%u\n", blkt_395->reserved[0], blkt_395->reserved[1]); } } else if ( blkt_type == 400 ) { struct blkt_400_s *blkt_400 = (struct blkt_400_s *) (record + blkt_offset + 4); if ( swapflag ) { ms_gswap4 (&blkt_400->azimuth); ms_gswap4 (&blkt_400->slowness); ms_gswap4 (&blkt_400->configuration); } if ( details >= 1 ) { ms_log (0, " beam azimuth (degrees): %g\n", blkt_400->azimuth); ms_log (0, " beam slowness (sec/degree): %g\n", blkt_400->slowness); ms_log (0, " configuration: %u\n", blkt_400->configuration); if ( details > 1 ) ms_log (0, " reserved bytes (2): %u,%u\n", blkt_400->reserved[0], blkt_400->reserved[1]); } } else if ( blkt_type == 405 ) { struct blkt_405_s *blkt_405 = (struct blkt_405_s *) (record + blkt_offset + 4); uint16_t firstvalue = blkt_405->delay_values[0]; /* Work on a private copy */ if ( swapflag ) ms_gswap2 (&firstvalue); if ( details >= 1 ) ms_log (0, " first delay value: %u\n", firstvalue); } else if ( blkt_type == 500 ) { struct blkt_500_s *blkt_500 = (struct blkt_500_s *) (record + blkt_offset + 4); if ( swapflag ) { ms_gswap4 (&blkt_500->vco_correction); MS_SWAPBTIME (&blkt_500->time); ms_gswap4 (&blkt_500->exception_count); } if ( details >= 1 ) { ms_log (0, " VCO correction: %g%%\n", blkt_500->vco_correction); ms_log (0, " time of exception: %d,%d,%d:%d:%d.%04d (unused: %d)\n", blkt_500->time.year, blkt_500->time.day, blkt_500->time.hour, blkt_500->time.min, blkt_500->time.sec, blkt_500->time.fract, blkt_500->time.unused); ms_log (0, " usec: %d\n", blkt_500->usec); ms_log (0, " reception quality: %u%%\n", blkt_500->reception_qual); ms_log (0, " exception count: %u\n", blkt_500->exception_count); ms_log (0, " exception type: %.16s\n", blkt_500->exception_type); ms_log (0, " clock model: %.32s\n", blkt_500->clock_model); ms_log (0, " clock status: %.128s\n", blkt_500->clock_status); } } else if ( blkt_type == 1000 ) { struct blkt_1000_s *blkt_1000 = (struct blkt_1000_s *) (record + blkt_offset + 4); char order[40]; /* Calculate record size in bytes as 2^(blkt_1000->rec_len) */ b1000reclen = (unsigned int) 1 << blkt_1000->reclen; /* Big or little endian? */ if (blkt_1000->byteorder == 0) strncpy (order, "Little endian", sizeof(order)-1); else if (blkt_1000->byteorder == 1) strncpy (order, "Big endian", sizeof(order)-1); else strncpy (order, "Unknown value", sizeof(order)-1); if ( details >= 1 ) { ms_log (0, " encoding: %s (val:%u)\n", (char *) ms_encodingstr (blkt_1000->encoding), blkt_1000->encoding); ms_log (0, " byte order: %s (val:%u)\n", order, blkt_1000->byteorder); ms_log (0, " record length: %d (val:%u)\n", b1000reclen, blkt_1000->reclen); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_1000->reserved); } /* Save encoding format */ b1000encoding = blkt_1000->encoding; /* Sanity check encoding format */ if ( ! (b1000encoding >= 0 && b1000encoding <= 5) && ! (b1000encoding >= 10 && b1000encoding <= 19) && ! (b1000encoding >= 30 && b1000encoding <= 33) ) { ms_log (2, "%s: Blockette 1000 encoding format invalid (0-5,10-19,30-33): %d\n", srcname, b1000encoding); retval++; } /* Sanity check byte order flag */ if ( blkt_1000->byteorder != 0 && blkt_1000->byteorder != 1 ) { ms_log (2, "%s: Blockette 1000 byte order flag invalid (0 or 1): %d\n", srcname, blkt_1000->byteorder); retval++; } } else if ( blkt_type == 1001 ) { struct blkt_1001_s *blkt_1001 = (struct blkt_1001_s *) (record + blkt_offset + 4); if ( details >= 1 ) { ms_log (0, " timing quality: %u%%\n", blkt_1001->timing_qual); ms_log (0, " micro second: %d\n", blkt_1001->usec); if ( details > 1 ) ms_log (0, " reserved byte: %u\n", blkt_1001->reserved); ms_log (0, " frame count: %u\n", blkt_1001->framecnt); } } else if ( blkt_type == 2000 ) { struct blkt_2000_s *blkt_2000 = (struct blkt_2000_s *) (record + blkt_offset + 4); char order[40]; if ( swapflag ) { ms_gswap2 (&blkt_2000->length); ms_gswap2 (&blkt_2000->data_offset); ms_gswap4 (&blkt_2000->recnum); } /* Big or little endian? */ if (blkt_2000->byteorder == 0) strncpy (order, "Little endian", sizeof(order)-1); else if (blkt_2000->byteorder == 1) strncpy (order, "Big endian", sizeof(order)-1); else strncpy (order, "Unknown value", sizeof(order)-1); if ( details >= 1 ) { ms_log (0, " blockette length: %u\n", blkt_2000->length); ms_log (0, " data offset: %u\n", blkt_2000->data_offset); ms_log (0, " record number: %u\n", blkt_2000->recnum); ms_log (0, " byte order: %s (val:%u)\n", order, blkt_2000->byteorder); b = blkt_2000->flags; ms_log (0, " data flags: [%u%u%u%u%u%u%u%u] 8 bits\n", bit(b,0x01), bit(b,0x02), bit(b,0x04), bit(b,0x08), bit(b,0x10), bit(b,0x20), bit(b,0x40), bit(b,0x80)); if ( details > 1 ) { if ( b & 0x01 ) ms_log (0, " [Bit 0] 1: Stream oriented\n"); else ms_log (0, " [Bit 0] 0: Record oriented\n"); if ( b & 0x02 ) ms_log (0, " [Bit 1] 1: Blockette 2000s may NOT be packaged\n"); else ms_log (0, " [Bit 1] 0: Blockette 2000s may be packaged\n"); if ( ! (b & 0x04) && ! (b & 0x08) ) ms_log (0, " [Bits 2-3] 00: Complete blockette\n"); else if ( ! (b & 0x04) && (b & 0x08) ) ms_log (0, " [Bits 2-3] 01: First blockette in span\n"); else if ( (b & 0x04) && (b & 0x08) ) ms_log (0, " [Bits 2-3] 11: Continuation blockette in span\n"); else if ( (b & 0x04) && ! (b & 0x08) ) ms_log (0, " [Bits 2-3] 10: Final blockette in span\n"); if ( ! (b & 0x10) && ! (b & 0x20) ) ms_log (0, " [Bits 4-5] 00: Not file oriented\n"); else if ( ! (b & 0x10) && (b & 0x20) ) ms_log (0, " [Bits 4-5] 01: First blockette of file\n"); else if ( (b & 0x10) && ! (b & 0x20) ) ms_log (0, " [Bits 4-5] 10: Continuation of file\n"); else if ( (b & 0x10) && (b & 0x20) ) ms_log (0, " [Bits 4-5] 11: Last blockette of file\n"); } ms_log (0, " number of headers: %u\n", blkt_2000->numheaders); /* Crude display of the opaque data headers */ if ( details > 1 ) ms_log (0, " headers: %.*s\n", (blkt_2000->data_offset - 15), blkt_2000->payload); } } else { ms_log (2, "%s: Unrecognized blockette type: %d\n", srcname, blkt_type); retval++; } /* Sanity check the next blockette offset */ if ( next_blkt && next_blkt <= endofblockettes ) { ms_log (2, "%s: Next blockette offset (%d) is within current blockette ending at byte %d\n", srcname, next_blkt, endofblockettes); blkt_offset = 0; } else { blkt_offset = next_blkt; } blkt_count++; } /* End of looping through blockettes */ /* Check that the blockette offset is within the maximum record size */ if ( blkt_offset > maxreclen ) { ms_log (2, "%s: Blockette offset (%d) beyond maximum record length (%d)\n", srcname, blkt_offset, maxreclen); retval++; } /* Check that the data and blockette offsets are within the record */ if ( b1000reclen && fsdh->data_offset > b1000reclen ) { ms_log (2, "%s: Data offset (%d) beyond record length (%d)\n", srcname, fsdh->data_offset, b1000reclen); retval++; } if ( b1000reclen && fsdh->blockette_offset > b1000reclen ) { ms_log (2, "%s: Blockette offset (%d) beyond record length (%d)\n", srcname, fsdh->blockette_offset, b1000reclen); retval++; } /* Check that the data offset is beyond the end of the blockettes */ if ( fsdh->numsamples && fsdh->data_offset <= endofblockettes ) { ms_log (2, "%s: Data offset (%d) is within blockette chain (end of blockettes: %d)\n", srcname, fsdh->data_offset, endofblockettes); retval++; } /* Check that the correct number of blockettes were parsed */ if ( fsdh->numblockettes != blkt_count ) { ms_log (2, "%s: Specified number of blockettes (%d) not equal to those parsed (%d)\n", srcname, fsdh->numblockettes, blkt_count); retval++; } } return retval; } /* End of ms_parse_raw() */