readheader()

MiniSEEDblock datrw::mseed::MiniSEEDRecord::readheader ( std::istream &  is )

private

read header and return block

Definition at line 54 of file mseedread_mseedrecord_readheader.cc.

References datrw::mseed::SEED::ascii, datrw::mseed::MiniSEEDblock::block(), datrw::mseed::SEED::DataOnlySEEDBlockette::bytesex, datrw::mseed::MiniSEEDblock::bytesize(), datrw::util::cpu(), datrw::util::cpu_Intel, datrw::util::cpu_unknown, date(), DATRW_assert, datrw::mseed::SEED::FixedDataRecordHeader::dbeg, datrw::mseed::SEED::FixedDataRecordHeader::fblock, datrw::mseed::SEED::DataOnlySEEDBlockette::format, Mblockette1000, Mblockette1001, Mdebug, Mhasblockette1000, Mhasblockette1001, Mrecordheader, Mvalid, datrw::mseed::needswap(), datrw::mseed::SEED::FixedDataRecordHeader::numblock, datrw::mseed::SEED::DataOnlySEEDBlockette::reclenbytes(), and datrw::mseed::Debug::report_ascii_data_to_stdout.

Referenced by read(), and skipdata().

    {
      // create block to read MiniSEED
      MiniSEEDblock block;
      // count blocks
      int iblock=0;
      // reset blockette indicators
      Mhasblockette1000=false;
      Mhasblockette1001=false;

      /* read first block and extract essential header fields
       * ----------------------------------------------------
       * Look for data control header
       * This initial sequence is required to skip the telemetry volume header
       * if present.
       *
       * See chapter 8, page 108: "Fixed Section of Data Header (48 bytes)"
       * in recent SEED V2.4 Manual for changes in the type field definition.
       *
       * Data header/quality indicator. Previously, this field was only
       * allowed to be “D” and was only used to indicate that this is a data
       * header. As of SEED version 2.4 the meaning of this field has been
       * extended to also indicate the level of quality control that has been
       * applied to the record.
       *
       * With SEED version 2.4 the type field may contain the following
       * indicators:
       *
       * D — The state of quality control of the data is indeterminate.
       * R — Raw Waveform Data with no Quality Control
       * Q — Quality Controlled Data, some processes have been applied to the
       *     data.
       * M — Data center modified, time-series values have not been changed.
       */
      bool nodataheader=true;
      while (nodataheader && is.good()) {
        is >> block;
        SEED::ControlHeader controlheader(block.block());
        if ((controlheader.type == 'D')
         || (controlheader.type == 'R')
         || (controlheader.type == 'Q')
         || (controlheader.type == 'M'))
            { nodataheader=false; }
      }

      if (nodataheader)
      {
        // trapped if EOF is reached before a valid controlheader
        // of type 'D' is found
        Mvalid=false;
      }
      else
      {
        // Flag which will be set true, if we have met a header in front
        // of valid sample block from which time series data can be extracted.
        // Alternative blocks are ASCII log data block, which will be skipped.
        bool seriesheader=false;
        while ((!seriesheader) && is.good())
        {
          // data header is present
          ++iblock;
          // SEED defines Motorola (big-endian) to be the standard byte order
          // for all headers
          // check our CPU type
          datrw::util::Ecpu_type mysex=datrw::util::cpu();
          DATRW_assert((mysex != datrw::util::cpu_unknown),
                           "ERROR (reading MiniSEED record): "
                           "cannot identify CPU type");
          bool doswap = (mysex == datrw::util::cpu_Intel);
          Mrecordheader=SEED::FixedDataRecordHeader(block.block(), doswap);
          // extract essential header fields
          // Blockette1000 is essential to determine bytesex
          if (Mrecordheader.fblock > block.bytesize())
          {
            // try it the other way
            doswap = !doswap;
            Mrecordheader=SEED::FixedDataRecordHeader(block.block(), doswap);
            DATRW_assert((Mrecordheader.fblock < block.bytesize()),
                           "ERROR (reading MiniSEED record): "
                           "cannot find first blockette");
          }
          // read Blockettes
          unsigned int blocketteadr=Mrecordheader.fblock;
          for (int i=0; i<Mrecordheader.numblock; i++)
          {
            SEED::DataRecordBlocketteHeader 
              bh(block.block(blocketteadr), doswap);
            if (bh.type == 1000)
            {
              Mhasblockette1000=true;
              Mblockette1000=
                SEED::DataOnlySEEDBlockette(block.block(blocketteadr), doswap);
            }
            else if (bh.type == 1001)
            {
              Mhasblockette1001=true;
              Mblockette1001=
                SEED::DataExtensionBlockette(block.block(blocketteadr), doswap);
            }
            blocketteadr=bh.next;
          }
          DATRW_assert(Mhasblockette1000,
                         "ERROR (reading MiniSEED record): " 
                         "Data Only SEED Blockette is essential");
          // check bytesex integrity
          DATRW_assert((needswap(Mblockette1000.bytesex)==doswap),
                         "ERROR (reading MiniSEED record): "
                         "swapping is not consistent");
          // check for possible ASCII data and skip ASCII data
          if (Mblockette1000.format == datrw::mseed::SEED::ascii)
          {
            unsigned int totalreclen=Mblockette1000.reclenbytes();
            unsigned int bytecount=Mrecordheader.dbeg;
            unsigned int pframe=Mrecordheader.dbeg;
            if (Mdebug.report_ascii_data_to_stdout)
            {
              std::cout << this->date().hierarchicalstring() << " ASCII data block:"
                << std::endl;
              std::cout << ">>";
            }
            while ((bytecount < totalreclen) && is.good())
            {
              if (pframe >= block.bytesize())
              {
                is >> block;
                pframe=0;
                iblock++;
              }
              while (pframe < block.bytesize())
              {
                char c=block[pframe];
                if (isprint(c))
                {
                  if (Mdebug.report_ascii_data_to_stdout)
                  {
                    std::cout << c;
                  }
                }
                else if (c == 0x0d)
                {
                  if (Mdebug.report_ascii_data_to_stdout)
                  {
                    std::cout << std::endl << ">>";
                  }
                }
                ++pframe;
                ++bytecount;
              } // while (pframe < block.bytesize())
            } // while ((bytecount < totalreclen) && is.good())
            if (Mdebug.report_ascii_data_to_stdout)
            {
              std::cout << std::endl;
            }
            is >> block;
            iblock++;
          } // if (Mblockette1000.format == datrw::mseed::SEED::ascii)
          else
          {
            // we expect to have met a valid series header
            seriesheader=true;
          }
        } // while ((!seriesheader) && is.good())
        // finished successfully
        if (is.good()) { Mvalid=true; }
      }
      return(block);
    } // MiniSEEDblock MiniSEEDRecord::readheader(std::istream& is)

Here is the call graph for this function:

Here is the caller graph for this function: