source: SH_SHM/trunk/source/seed_io/seedquickdump.c @ 202

Revision 202, 12.9 KB checked in by marcus, 13 years ago (diff)

r119 | klaus | 2010-03-31 07:40:13 +0200 (Mi, 31 Mär 2010) | 1 line

extended error message

Line 
1
2/* file seedquickdump.c
3 *      ===============
4 *
5 * $Revision: 119 $, $Date: 2010-03-31 07:40:13 +0200 (Mi, 31 MÀr 2010) $
6 *
7 * Dumps out Headerinfo of SEED files.
8 * K. Stammler, 10-Aug-98
9 *
10 */
11
12
13#include <stdio.h>
14#include <string.h>
15#include BASECNST
16#include BC_SYSBASE
17#include BC_CPAR
18#include BC_TCUSRDEF
19#include BC_UTUSRDEF
20#include BC_ERUSRDEF
21#include "seedcfg.h"
22#include "seed_lib.h"
23
24
25typedef struct {
26        WORD     block_id;        /* blockette ID = 1000 */
27        WORD     next_block;      /* next blockette */
28        UBYTE    algorithm;       /* compression algorithm */
29        UBYTE    dunno1;          /* ... */
30        UBYTE    reclthpow;       /* power of record length */
31        UBYTE    dunno2;          /* ... */
32} SeedDataOnlyBlocketteT;
33
34typedef struct {
35        WORD     block_id;        /* blockette ID = 1001 */
36        WORD     next_block;      /* next blockette */
37        UBYTE    timequal;        /* time quality */
38        UBYTE    dunno1;          /* ...*/
39} SeedDataExtBlocketteT;
40
41
42
43int main( int argc, char *argv[] )
44{
45        /* local variables */
46        STATUS   status;                    /* return status */
47        int      recsize;                   /* SEED record size in bytes */
48        char     recsize_par[cBcLineLth];   /* record size parameter string */
49        SeedSbyteT *seedrec;                /* pointer to SEED record */
50        SeedDataHeaderT *seedhdr;           /* pointer to seed data header */
51        char     seedfile[BC_FILELTH+1];    /* name of SEED file */
52        int      read_ret;                  /* fread return values */
53        NTIME    ntime;                     /* numeric time */
54        FILE     *fp;                       /* pointer to SEED file */
55        char     sfd_t_start[BC_TIMELTH+1]; /* start time */
56        char     sfd_t_end[BC_TIMELTH+1];   /* end time */
57        int      sfd_recno;                 /* number of records in file */
58        char     sfd_stream[BC_LINELTH+1];  /* stream string */
59        BOOLEAN  sfd_swap_hdr;              /* swap header necessary */
60        int      i;                         /* counter */
61        long     fsize;                     /* file size */
62        float    dt;                        /* sample distance in sec */
63        char     *csrc, *cdst;              /* moving pointers */
64        char     outfile[BC_FILELTH+1];     /* output file */
65        FILE     *out;                      /* pointer to output file */
66        char     chanstr[BC_SHORTSTRLTH+1]; /* scratch string for channel */
67        int      byteoff;                   /* byte offset at beginning */
68        int      errcnt;                    /* error counter */
69        int      reccnt;                    /* record counter */
70        char     seq[cBcLineLth+1];         /* sequence number string */
71        SeedDataOnlyBlocketteT *donly;      /* data only blockette */
72        SeedDataExtBlocketteT *dext;        /* data extension blockette */
73        UWORD    tmp;                       /* scratch */
74        int      time_quality;              /* time quality factor */
75        char     lasttime[cBcTimeLth+1];    /* time of last record */
76        float    gaplth;                    /* length of gap in s */
77        unsigned long int usign;            /* first sample values */
78        BOOLEAN  print_locid;               /* print location ID */
79        char     showinfo[cBcLineLth+1];    /* show info qualifier */
80        BOOLEAN  b1000found;                /* blockette 1000 found */
81        int      gap_count=0;               /* gap counter */
82        float    gap_length=0.0;            /* total gap length in s */
83        int      jitter_count=0;            /* counts very small 'gaps' (<dt/2) */
84        BOOLEAN  write_newline;             /* write a new line after record */
85
86        /* executable code */
87
88        status = cBcNoError;
89        print_locid = FALSE;
90
91        pa_init( argc, argv );
92        if  (pa_pnumber() < 1 || pa_pnumber() > 2)  {
93                fprintf( stderr, "Usage: %s <seed-file> \n",
94                        pa_progname() );
95                return 1;
96        } /*endif*/
97        strcpy( seedfile, pa_pvalue(1) );
98        out = stdout;
99
100        /* check for record size qualifier */
101        recsize = 0;
102        if  (pa_qspecified("-seedrec"))  {
103                strcpy( recsize_par, pa_qvalue("-seedrec") );
104                if  (strcmp(recsize_par,"quickfind") == 0)  {
105                        /* just do nothing, leave recsize zero */
106                } else {
107                        if  (sscanf(recsize_par,"%d",&recsize) != 1)  {
108                                fprintf( stderr, "%s: illegal seedrec qualifier.  Abort.\n",
109                                        pa_progname() );
110                                return 1;
111                        } /*endif*/
112                } /*endif*/
113        } /*endif*/
114
115        if  (pa_qspecified("-locid"))  print_locid = TRUE;
116
117        *showinfo = '\0';
118        if  (pa_qvalue("-show") != NULL)  {
119                strcpy( showinfo, pa_qvalue("-show") );
120        } /*endif*/
121
122        /* allocate memory for SEED record */
123        seedrec = (SeedSbyteT *)sy_allocmem( 1, Seed_C_MAX_RECLTH, &status );
124        if  (Severe(&status))  err_writemsg( status, "", TRUE );
125
126        fp = fopen( seedfile, "rb" );
127        if  (fp == NULL)  {
128                fprintf( stderr, "*** %s: file %s not found\n", pa_progname(), seedfile );
129                fclose( out );
130                return 1;
131        } /*endif*/
132
133        /* determine record size if not specified */
134        if  (recsize == 0)  {
135                SeedQuickFindReclth( fp, &recsize, &byteoff );
136                if  (recsize <= 0)  {
137                        fclose( fp );
138                        if  (recsize == 0)  {
139                                fprintf( stderr, "%s: no valid SEED file %s\n",
140                                        pa_progname(), seedfile );
141                        } else {
142                                fprintf( stderr, "%s: cannot find record size in %s\n",
143                                        pa_progname(), seedfile );
144                        } /*endif*/
145                        return 1;
146                } /*endif*/
147        } /*endif*/
148
149        reccnt = 0;
150        gaplth = 0.0;
151        *lasttime = '\0';
152
153        /* read records */
154        FOREVER  {
155
156                reccnt++;
157
158                /* read next record */
159                read_ret = (int)fread( (char *)seedrec, recsize, 1, fp );
160                if  (read_ret != 1)  break;
161
162                /* check for swapping */
163                seedhdr = (SeedDataHeaderT *)seedrec;
164                sfd_swap_hdr = SeedSwapNecessary( seedhdr );
165                if  (sfd_swap_hdr)  SeedSwapHeader( seedhdr );
166
167                strncpy( seq, seedhdr->seqno, 6 );
168                seq[6] = '\0';
169                if  (seedhdr->indicator != 'D' && seedhdr->indicator != 'R'
170                        && seedhdr->indicator != 'Q')  {
171                        if  (*showinfo == '\0')
172                                printf( "%06d %6s %c\n", reccnt, seq, seedhdr->indicator );
173                        continue;
174                } /*endif*/
175
176                /* find start time */
177                SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status );
178                if  (Severe(&status))  {
179                        fprintf( stderr,
180                                "%s: couldn't read start time in file %s (status %d)\n",
181                                pa_progname(), seedfile, status );
182                        fclose( fp );
183                        fclose( out );
184                        return 1;
185                } /*endif*/
186                tc_n2t( &ntime, sfd_t_start, &status );
187                if  (Severe(&status))  {
188                        fprintf( stderr,
189                                "%s: couldn't convert start time (status %d) in file %s\n",
190                                pa_progname(), status, seedfile );
191                        fprintf( stderr, "%s: ntime: %d,%d,%d,%d,%d,%d,%d\n", pa_progname(),
192                                ntime.year, ntime.month, ntime.day, ntime.hour, ntime.min,
193                                ntime.sec, ntime.ms );
194                        fclose( fp );
195                        fclose( out );
196                        return 1;
197                } /*endif*/
198
199                /* channel name */
200                csrc = seedhdr->statcode;
201                cdst = sfd_stream;
202                *cdst = '\0';
203                while  (*csrc > ' ' && *csrc <= 'z')  *cdst++ = *csrc++;
204                *cdst++ = '-';
205                *cdst = '\0';
206                chanstr[0] = Cap( seedhdr->channel[0] );
207                chanstr[1] = Cap( seedhdr->channel[1] );
208                chanstr[2] = '\0';
209                if  (chanstr[0] <= ' ' || chanstr[0] > 'z')  chanstr[0] = '\0';
210                if  (chanstr[1] <= ' ' || chanstr[1] > 'z')  chanstr[1] = '\0';
211                ut_uncap( chanstr );
212
213                strcat( sfd_stream, chanstr );
214                strcat( sfd_stream, "-" );
215                i = (int)strlen( sfd_stream );
216                sfd_stream[i] = seedhdr->channel[2];
217                if  (chanstr[i] <= ' ' || chanstr[i] > 'z')  chanstr[i] = '\0';
218                sfd_stream[i+1] = '\0';
219                ut_uncap( sfd_stream );
220
221                /* get sample distance */
222                if  (seedhdr->smprate_fact == 0 || seedhdr->smprate_mult == 0)  {
223                        dt = 0.0;
224                } else {
225                        dt = SeedGetSampleDist( seedhdr );
226                } /*endif*/
227
228                tc_tadd( sfd_t_start, (float)(seedhdr->no_of_samples)*dt, sfd_t_end,
229                        &status );
230                if  (Severe(&status))  {
231                        fprintf( stderr, "%s: couldn't compute end time in file\n",
232                                pa_progname(), seedfile );
233                        fclose( fp );
234                        fclose( out );
235                        return 1;
236                } /*endif*/
237                if  (*lasttime != '\0')
238                        gaplth = tc_tdiff( sfd_t_start, lasttime, &status );
239
240                b1000found = FALSE;
241                time_quality = -1;
242                if  (seedhdr->first != 0)  {
243                        donly = (SeedDataOnlyBlocketteT *)(seedrec+(seedhdr->first));
244#ifdef XXX
245                        /* this is done in SeedSwapHeader now */
246                        if  (sfd_swap_hdr)  {
247                                tmp = (UWORD)(donly->block_id);
248                                donly->block_id = (tmp & 0xff) * 0x100;
249                                donly->block_id += (UWORD)(tmp & 0xff00) / (UWORD)0x100;
250                                tmp = (UWORD)(donly->next_block);
251                                donly->next_block = (tmp & 0xff) * 0x100;
252                                donly->next_block += (UWORD)(tmp & 0xff00) / (UWORD)0x100;
253                        } /*endif*/
254#endif
255                        b1000found = (donly->block_id == 1000);
256                        if  (b1000found && donly->next_block > 0)  {
257                                dext = (SeedDataExtBlocketteT *)(seedrec+(donly->next_block));
258#ifdef XXX
259                                /* this is done in SeedSwapHeader now */
260                                if  (sfd_swap_hdr)  {
261                                        tmp = (UWORD)(dext->block_id);
262                                        dext->block_id = (tmp & 0xff) * 0x100;
263                                        dext->block_id += (UWORD)(tmp & 0xff00) / (UWORD)0x100;
264                                } /*endif*/
265#endif
266                                if  (dext->block_id == 1001)  {
267                                        time_quality = dext->timequal;
268                                } /*endif*/
269                                if  (!b1000found && dext->block_id == 1000)  b1000found = TRUE;
270                        } /*endif*/
271                } /*endif*/
272
273                usign = *((unsigned long int *)(seedrec+68));
274                /*
275                tmp = usign & 0x0000ffff;
276                usign >>= 16;
277                usign += (unsigned long)tmp * 65536;
278                */
279
280                write_newline = TRUE;
281                if  (*showinfo == '\0')  {
282                        printf( "%06d %6s %c %s %s %5d %7.5f %d ", reccnt, seq, seedhdr->indicator,
283                                sfd_stream, sfd_t_start, seedhdr->no_of_samples, dt, time_quality );
284
285                        if  (gaplth == 0.0)  {
286                                printf( "cont" );
287                        } else {
288                                printf( "%g", gaplth );
289                                if (Abs(gaplth) > (dt/2.0))  {
290                                        gap_length += Abs(gaplth);
291                                        gap_count++;
292                                } else {
293                                        jitter_count++;
294                                } /*endif*/
295                        } /*endif*/
296
297                        if  (seedhdr->timecorr != 0)  printf( " (%d)", seedhdr->timecorr );
298
299                        if  (print_locid)  printf( " %c%c", seedhdr->locid[0], seedhdr->locid[1] );
300
301                } else {
302
303                        if  (gaplth != 0.0)  {
304                                if (Abs(gaplth) > (dt/2.0))  {
305                                        gap_length += Abs(gaplth);
306                                        gap_count++;
307                                } else {
308                                        jitter_count++;
309                                } /*endif*/
310                        } /*endif*/
311
312                        if  (strcmp(showinfo,"netcode") == 0)  {
313                                printf( "%c%c ", seedhdr->network[0], seedhdr->network[1] );
314                        } else if  (strcmp(showinfo,"timecorr") == 0)  {
315                                printf( "%d ", seedhdr->timecorr );
316                        } else if  (strcmp(showinfo,"locid") == 0)  {
317                                printf( "%c%c ", seedhdr->locid[0], seedhdr->locid[1] );
318                        } else if  (strcmp(showinfo,"activity") == 0)  {
319                                printf( "0x%x ", (int)(seedhdr->activity) );
320                        } else if  (strcmp(showinfo,"b1000") == 0)  {
321                                printf( "%d ", b1000found );
322                        } else {
323                                write_newline = FALSE;
324                        } /*endif*/
325
326                } /*endif*/
327
328                if  (write_newline)  printf( "\n" );
329
330                strcpy( lasttime, sfd_t_end );
331
332        } /*endfor*/
333
334        if  (strcmp(showinfo,"gaps") == 0)  {
335                printf( "gap_count %d gap_length %f jitter_count %d\n",
336                        gap_count, gap_length, jitter_count );
337        } /*endif*/
338
339        fclose( fp );
340        return 0;
341
342#ifdef XXX
343
344
345        /* get length of file */
346        fseek( fp, 0, 2 );
347        fsize = ftell( fp ) - byteoff;
348        if  (fsize % recsize != 0)  {
349                fprintf( stderr, "*** %s: illegal size %ld bytes of SEED file %s\n",
350                        pa_progname(), fsize, seedfile );
351                fclose( fp );
352                fclose( out );
353                return 1 ;
354        } /*endif*/
355        sfd_recno = (int)(fsize / (long)recsize);
356
357        /* get last record */
358        fseek( fp,
359                (long)(sfd_recno-1)*(long)recsize + (long)byteoff, 0 );
360        read_ret = (int)fread( (char *)seedrec, recsize, 1, fp );
361        if  (read_ret != 1)  {
362                fprintf( stderr, "*** %s: read error on file %s (end)\n",
363                        pa_progname(), seedfile );
364                fclose( fp );
365                fclose( out );
366                return 1;
367        } /*endif*/
368        seedhdr = (SeedDataHeaderT *)seedrec;
369        if  (SeedSwapNecessary(seedhdr))  SeedSwapHeader(seedhdr);
370        errcnt = 0;
371        SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status );
372        while  (Severe(&status))  {
373                errcnt++;
374                fprintf( stderr,
375                        "%s: unreadable last record, take %d before in file %s\n",
376                        pa_progname(), errcnt, seedfile );
377                status = BC_NOERROR;
378                /* get previous record */
379                sfd_recno--;
380                fseek( fp,
381                        (long)(sfd_recno-1)*(long)recsize + (long)byteoff,
382                        0 );
383                read_ret = (int)fread( (char *)seedrec, recsize, 1, fp);
384                if  (read_ret != 1)  {
385                        fprintf( stderr, "%s: read error on file %s (end)\n",
386                                pa_progname(), seedfile );
387                        fclose( fp );
388                        fclose( out );
389                        return 1;
390                } /*endif*/
391                seedhdr = (SeedDataHeaderT *)seedrec;
392                if  (SeedSwapNecessary(seedhdr))  SeedSwapHeader(seedhdr);
393                SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status );
394                if  (Severe(&status) && errcnt > 10)  {
395                        fprintf( stderr,
396                                "%s: couldn't read start time of last record in file %s\n",
397                                pa_progname(), seedfile );
398                        fclose( fp );
399                        fclose( out );
400                        return 1;
401                } /*endif*/
402        } /*endwhile*/
403        tc_nadd( &ntime, (float)(seedhdr->no_of_samples)*dt, &ntime, &status );
404        if  (Severe(&status))  {
405                fprintf( stderr, "%s: couldn't compute end time in file\n",
406                        pa_progname(), seedfile );
407                fclose( fp );
408                fclose( out );
409                return 1;
410        } /*endif*/
411        tc_n2t( &ntime, sfd_t_end, &status );
412        if  (Severe(&status))  {
413                fprintf( stderr, "%s: couldn't convert end time in file %s\n",
414                        pa_progname(), seedfile );
415                fclose( fp );
416                fclose( out );
417                return 1;
418        } /*endif*/
419
420        fclose( fp );
421
422        fprintf( out, "%c>%s %c>%s %c>%s %c>%s %c>%d %c>%d %c>%d %c>%d\n",
423                Seed_C_SfdStream, sfd_stream, Seed_C_SfdName, seedfile,
424                Seed_C_SfdTStart, sfd_t_start, Seed_C_SfdTEnd, sfd_t_end,
425                Seed_C_SfdRecno, sfd_recno, Seed_C_SfdSwapH, sfd_swap_hdr,
426                Seed_C_SfdReclth, recsize, Seed_C_SfdOffset, byteoff );
427
428        if  (out != stdout)  fclose( out );
429
430        return 0;
431
432#endif
433
434} /* end of main */
Note: See TracBrowser for help on using the repository browser.