unpack.c

C编写的格式转换程序

	    {
	      ms_log (2, "msr_unpack(%s): Record length in Blockette 1000 (%d) != specified length (%d)\n",
		      UNPACK_SRCNAME, msr->reclen, reclen);
	    }
	  
	  msr->encoding = blkt_1000->encoding;
	  msr->byteorder = blkt_1000->byteorder;
	}
      
      else if ( blkt_type == 1001 )
	{			/* Found a Blockette 1001 */
	  blkt_link = msr_addblockette (msr, record + blkt_offset,
					sizeof (struct blkt_1001_s),
					blkt_type, 0);
	  if ( ! blkt_link )
	    break;
	  
	  blkt_link->next_blkt = next_blkt;
	}
      
      else if ( blkt_type == 2000 )
	{			/* Found a Blockette 2000 */
	  struct blkt_2000_s *blkt_2000;
	  uint16_t b2klen;
	  
	  /* Read the blockette length from blockette */
	  memcpy (&b2klen, record + blkt_offset, 2);
	  if ( headerswapflag ) ms_gswap2 (&b2klen);
	  
	  /* Minus four bytes for the blockette type and next fields */
	  b2klen -= 4;
	  
	  blkt_link = msr_addblockette (msr, record + blkt_offset,
					b2klen, blkt_type, 0);
	  if ( ! blkt_link )
	    break;
	  
	  blkt_link->next_blkt = next_blkt;
	  
	  blkt_2000 = (struct blkt_2000_s *) blkt_link->blktdata;
	  
	  if ( headerswapflag )
	    {
	      ms_gswap2 (&blkt_2000->length);
	      ms_gswap2 (&blkt_2000->data_offset);
	      ms_gswap4 (&blkt_2000->recnum);
	    }
	}
      
      else
	{                      /* Unknown blockette type */
	  if ( blkt_length >= 4 )
	    {
	      blkt_link = msr_addblockette (msr, record + blkt_offset,
					    blkt_length - 4,
					    blkt_type, 0);
	      
	      if ( ! blkt_link )
		break;
	      
	      blkt_link->next_blkt = next_blkt;
	    }
	}
      
      /* Check that the offset increases */
      if ( next_blkt && next_blkt <= blkt_offset )
	{
	  ms_log (2, "msr_unpack(%s): Offset to next blockette (%d) from type %d did not increase\n",
		  UNPACK_SRCNAME, next_blkt, blkt_type);
	  
	  blkt_offset = 0;
	}
      /* Check that the offset is within record length */
      else if ( next_blkt && next_blkt > reclen )
	{
	  ms_log (2, "msr_unpack(%s): Offset to next blockette (%d) from type %d is beyond record length\n",
		  UNPACK_SRCNAME, next_blkt, blkt_type);
	  
	  blkt_offset = 0;
	}
      else
	{
	  blkt_offset = next_blkt;
	}
    }  /* End of while looping through blockettes */
  
  if ( msr->Blkt1000 == 0 )
    {
      if ( verbose > 1 )
	{
	  ms_log (1, "%s: Warning: No Blockette 1000 found\n", UNPACK_SRCNAME);
	}
    }
  
  /* Populate remaining common header fields */
  msr->starttime = msr_starttime (msr);
  msr->samprate = msr_samprate (msr);
  
  /* Set MSRecord->byteorder if data byte order is forced */
  if ( unpackdatabyteorder >= 0 )
    {
      msr->byteorder = unpackdatabyteorder;
    }
  
  /* Check if encoding format is forced */
  if ( unpackencodingformat >= 0 )
    {
      msr->encoding = unpackencodingformat;
    }
  
  /* Use encoding format fallback if defined and no encoding is set,
   * also make sure the byteorder is set by default to big endian */
  if ( unpackencodingfallback >= 0 && msr->encoding == -1 )
    {
      msr->encoding = unpackencodingfallback;
      
      if ( msr->byteorder == -1 )
	{
	  msr->byteorder = 1;
	}
    }
  
  /* Unpack the data samples if requested */
  if ( dataflag && msr->samplecnt > 0 )
    {
      flag dswapflag = headerswapflag;
      flag bigendianhost = ms_bigendianhost();
      
      /* Determine byte order of the data and set the dswapflag as
	 needed; if no Blkt1000 or UNPACK_DATA_BYTEORDER environment
	 variable setting assume the order is the same as the header */
      if ( msr->Blkt1000 != 0 && unpackdatabyteorder < 0 )
	{
	  dswapflag = 0;
	  
	  if ( bigendianhost && msr->byteorder == 0 )
	    dswapflag = 1;
	  else if ( !bigendianhost && msr->byteorder == 1 )
	    dswapflag = 1;
	}
      else if ( unpackdatabyteorder >= 0 )
	{
	  dswapflag = dataswapflag;
	}
      
      if ( verbose > 2 && dswapflag )
	ms_log (1, "%s: Byte swapping needed for unpacking of data samples\n",
		UNPACK_SRCNAME);
      else if ( verbose > 2 )
	ms_log (1, "%s: Byte swapping NOT needed for unpacking of data samples \n",
		UNPACK_SRCNAME);
      
      retval = msr_unpack_data (msr, dswapflag, verbose);
      
      if ( retval < 0 )
	return retval;
      else
	msr->numsamples = retval;
    }
  else
    {
      if ( msr->datasamples )
	free (msr->datasamples);
      
      msr->datasamples = 0;
      msr->numsamples = 0;
    }
  
  /* Unset shared pointer to source name */
  UNPACK_SRCNAME = NULL;
  
  return MS_NOERROR;
} /* End of msr_unpack() */


/************************************************************************
 *  msr_unpack_data:
 *
 *  Unpack Mini-SEED data samples for a given MSRecord.  The packed
 *  data is accessed in the record indicated by MSRecord->record and
 *  the unpacked samples are placed in MSRecord->datasamples.  The
 *  resulting data samples are either 32-bit integers, 32-bit floats
 *  or 64-bit floats in host byte order.
 *
 *  Return number of samples unpacked or negative libmseed error code.
 ************************************************************************/
static int
msr_unpack_data ( MSRecord *msr, int swapflag, int verbose )
{
  int     datasize;             /* byte size of data samples in record 	*/
  int     nsamples;		/* number of samples unpacked		*/
  int     unpacksize;		/* byte size of unpacked samples	*/
  int     samplesize = 0;       /* size of the data samples in bytes    */
  const char *dbuf;
  int32_t    *diffbuff;
  int32_t     x0, xn;
  
  /* Sanity record length */
  if ( msr->reclen == -1 )
    {
      ms_log (2, "msr_unpack_data(%s): Record size unknown\n",
	      UNPACK_SRCNAME);
      return MS_NOTSEED;
    }
    
  switch (msr->encoding)
    {
    case DE_ASCII:
      samplesize = 1; break;
    case DE_INT16:
    case DE_INT32:
    case DE_FLOAT32:
    case DE_STEIM1:
    case DE_STEIM2:
    case DE_GEOSCOPE24:
    case DE_GEOSCOPE163:
    case DE_GEOSCOPE164:
    case DE_SRO:
    case DE_DWWSSN:
      samplesize = 4; break;
    case DE_FLOAT64:
      samplesize = 8; break;
    default:
      samplesize = 0; break;
    }
  
  /* Calculate buffer size needed for unpacked samples */
  unpacksize = msr->samplecnt * samplesize;
  
  /* (Re)Allocate space for the unpacked data */
  if ( unpacksize > 0 )
    {
      msr->datasamples = realloc (msr->datasamples, unpacksize);
      
      if ( msr->datasamples == NULL )
	{
	  ms_log (2, "msr_unpack_data(%s): Cannot (re)allocate memory\n",
		  UNPACK_SRCNAME);
	  return MS_GENERROR;
	}
    }
  else
    {
      if ( msr->datasamples )
	free (msr->datasamples);
      msr->datasamples = 0;
      msr->numsamples = 0;
    }
  
  datasize = msr->reclen - msr->fsdh->data_offset;
  dbuf = msr->record + msr->fsdh->data_offset;
  
  if ( verbose > 2 )
    ms_log (1, "%s: Unpacking %d samples\n",
	    UNPACK_SRCNAME, msr->samplecnt);
  
  /* Decide if this is a encoding that we can decode */
  switch (msr->encoding)
    {
      
    case DE_ASCII:
      if ( verbose > 1 )
	ms_log (1, "%s: Found ASCII data\n", UNPACK_SRCNAME);
      
      nsamples = msr->samplecnt;
      memcpy (msr->datasamples, dbuf, nsamples);
      msr->sampletype = 'a';      
      break;
      
    case DE_INT16:
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking INT-16 data samples\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_int_16 ((int16_t *)dbuf, msr->samplecnt,
				    msr->samplecnt, msr->datasamples,
				    swapflag);
      msr->sampletype = 'i';
      break;
      
    case DE_INT32:
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking INT-32 data samples\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_int_32 ((int32_t *)dbuf, msr->samplecnt,
				    msr->samplecnt, msr->datasamples,
				    swapflag);
      msr->sampletype = 'i';
      break;
      
    case DE_FLOAT32:
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking FLOAT-32 data samples\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_float_32 ((float *)dbuf, msr->samplecnt,
				      msr->samplecnt, msr->datasamples,
				      swapflag);
      msr->sampletype = 'f';
      break;
      
    case DE_FLOAT64:
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking FLOAT-64 data samples\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_float_64 ((double *)dbuf, msr->samplecnt,
				      msr->samplecnt, msr->datasamples,
				      swapflag);
      msr->sampletype = 'd';
      break;
      
    case DE_STEIM1:
      diffbuff = (int32_t *) malloc(unpacksize);
      if ( diffbuff == NULL )
	{
	  ms_log (2, "msr_unpack_data(%s): Cannot allocate diff buffer\n",
		  UNPACK_SRCNAME);
	  return MS_GENERROR;
	}
      
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking Steim-1 data frames\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_steim1 ((FRAME *)dbuf, datasize, msr->samplecnt,
				    msr->samplecnt, msr->datasamples, diffbuff, 
				    &x0, &xn, swapflag, verbose);
      msr->sampletype = 'i';
      free (diffbuff);
      break;
      
    case DE_STEIM2:
      diffbuff = (int32_t *) malloc(unpacksize);
      if ( diffbuff == NULL )
	{
	  ms_log (2, "msr_unpack_data(%s): Cannot allocate diff buffer\n",
		  UNPACK_SRCNAME);
	  return MS_GENERROR;
	}
      
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking Steim-2 data frames\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_steim2 ((FRAME *)dbuf, datasize, msr->samplecnt,
				    msr->samplecnt, msr->datasamples, diffbuff,
				    &x0, &xn, swapflag, verbose);
      msr->sampletype = 'i';
      free (diffbuff);
      break;
      
    case DE_GEOSCOPE24:
    case DE_GEOSCOPE163:
    case DE_GEOSCOPE164:
      if ( verbose > 1 )
	{
	  if ( msr->encoding == DE_GEOSCOPE24 )
	    ms_log (1, "%s: Unpacking GEOSCOPE 24bit integer data samples\n",
		    UNPACK_SRCNAME);
	  if ( msr->encoding == DE_GEOSCOPE163 )
	    ms_log (1, "%s: Unpacking GEOSCOPE 16bit gain ranged/3bit exponent data samples\n",
		    UNPACK_SRCNAME);
	  if ( msr->encoding == DE_GEOSCOPE164 )
	    ms_log (1, "%s: Unpacking GEOSCOPE 16bit gain ranged/4bit exponent data samples\n",
		    UNPACK_SRCNAME);
	}
      
      nsamples = msr_unpack_geoscope (dbuf, msr->samplecnt, msr->samplecnt,
				      msr->datasamples, msr->encoding, swapflag);
      msr->sampletype = 'f';
      break;
      
    case DE_SRO:
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking SRO encoded data samples\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_sro ((int16_t *)dbuf, msr->samplecnt, msr->samplecnt,
				 msr->datasamples, swapflag);
      msr->sampletype = 'i';
      break;
      
    case DE_DWWSSN:
      if ( verbose > 1 )
	ms_log (1, "%s: Unpacking DWWSSN encoded data samples\n", UNPACK_SRCNAME);
      
      nsamples = msr_unpack_dwwssn ((int16_t *)dbuf, msr->samplecnt, msr->samplecnt,
				    msr->datasamples, swapflag);
      msr->sampletype = 'i';
      break;
      
    default:
      ms_log (2, "%s: Unsupported encoding format %d (%s)\n",
	      UNPACK_SRCNAME, msr->encoding, (char *) ms_encodingstr(msr->encoding));
      
      return MS_UNKNOWNFORMAT;
    }
  
  return nsamples;
} /* End of msr_unpack_data() */


/************************************************************************
 *  check_environment:
 *
 *  Check environment variables and set global variables approriately.
 *  
 *  Return 0 on success and -1 on error.
 ************************************************************************/
static int
check_environment (int verbose)
{
  char *envvariable;

  /* Read possible environmental variables that force byteorder */
  if ( unpackheaderbyteorder == -2 )
    {
      if ( (envvariable = getenv("UNPACK_HEADER_BYTEORDER")) )
	{
	  if ( *envvariable != '0' && *envvariable != '1' )
	    {
	      ms_log (2, "Environment variable UNPACK_HEADER_BYTEORDER must be set to '0' or '1'\n");
	      return -1;
	    }
	  else if ( *envvariable == '0' )
	    {
	      unpackheaderbyteorder = 0;
	      if ( verbose > 2 )
		ms_log (1, "UNPACK_HEADER_BYTEORDER=0, unpacking little-endian header\n");
	    }
	  else
	    {
	      unpackheaderbyteorder = 1;
	      if ( verbose > 2 )
		ms_log (1, "UNPACK_HEADER_BYTEORDER=1, unpacking big-endian header\n");
	    }
	}
      else
	{
	  unpackheaderbyteorder = -1;
	}
    }

  if ( unpackdatabyteorder == -2 )
    {
      if ( (envvariable = getenv("UNPACK_DATA_BYTEORDER")) )
	{
	  if ( *envvariable != '0' && *envvariable != '1' )
	    {
	      ms_log (2, "Environment variable UNPACK_DATA_BYTEORDER must be set to '0' or '1'\n");
	      return -1;
	    }
	  else if ( *envvariable == '0' )
	    {
	      unpackdatabyteorder = 0;
	      if ( verbose > 2 )
		ms_log (1, "UNPACK_DATA_BYTEORDER=0, unpacking little-endian data samples\n");
	    }
	  else
	    {
	      unpackdatabyteorder = 1;
	      if ( verbose > 2 )
		ms_log (1, "UNPACK_DATA_BYTEORDER=1, unpacking big-endian data samples\n");
	    }
	}
      else
	{
	  unpackdatabyteorder = -1;
	}
    }
  
  /* Read possible environmental variable that forces encoding format */
  if ( unpackencodingformat == -2 )
    {
      if ( (envvariable = getenv("UNPACK_DATA_FORMAT")) )
	{
	  unpackencodingformat = (int) strtol (envvariable, NULL, 10);
	  
	  if ( unpackencodingformat < 0 || unpackencodingformat > 33 )
	    {
	      ms_log (2, "Environment variable UNPACK_DATA_FORMAT set to invalid value: '%d'\n", unpackencodingformat);
	      return -1;
	    }
	  else if ( verbose > 2 )
	    ms_log (1, "UNPACK_DATA_FORMAT, unpacking data in encoding format %d\n", unpackencodingformat);
	}
      else
	{
	  unpackencodingformat = -1;
	}
    }
  
  /* Read possible environmental variable to be used as a fallback encoding format */
  if ( unpackencodingfallback == -2 )
    {
      if ( (envvariable = getenv("UNPACK_DATA_FORMAT_FALLBACK")) )
	{
	  unpackencodingfallback = (int) strtol (envvariable, NULL, 10);
	  
	  if ( unpackencodingfallback < 0 || unpackencodingfallback > 33 )
	    {
	      ms_log (2, "Environment variable UNPACK_DATA_FORMAT_FALLBACK set to invalid value: '%d'\n",
		      unpackencodingfallback);
	      return -1;
	    }
	  else if ( verbose > 2 )
	    ms_log (1, "UNPACK_DATA_FORMAT_FALLBACK, fallback data unpacking encoding format %d\n",
		    unpackencodingfallback);
	}
      else
	{
	  unpackencodingfallback = 10;  /* Default fallback is Steim-1 encoding */
	}
    }
  
  return 0;
} /* End of check_environment() */