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

Revision 352, 10.2 KB checked in by marcus, 12 years ago (diff)

r189 | klaus | 2011-03-25 18:54:37 +0100 (Fr, 25 Mär 2011) | 1 line

find blockette 1000 within multipleblockettes

Line 
1
2/* file seedquickdump.c
3 *      ===============
4 *
5 * $Revision: 189 $, $Date: 2011-03-25 18:54:37 +0100 (Fr, 25 MÀr 2011) $
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    int      compression;               /* compression ID of record data */
86
87        /* executable code */
88
89        status = cBcNoError;
90        print_locid = FALSE;
91
92        pa_init( argc, argv );
93        if  (pa_pnumber() < 1 || pa_pnumber() > 2)  {
94                fprintf( stderr, "Usage: %s <seed-file> \n",
95                        pa_progname() );
96                return 1;
97        } /*endif*/
98        strcpy( seedfile, pa_pvalue(1) );
99        out = stdout;
100
101        /* check for record size qualifier */
102        recsize = 0;
103        if  (pa_qspecified("-seedrec"))  {
104                strcpy( recsize_par, pa_qvalue("-seedrec") );
105                if  (strcmp(recsize_par,"quickfind") == 0)  {
106                        /* just do nothing, leave recsize zero */
107                } else {
108                        if  (sscanf(recsize_par,"%d",&recsize) != 1)  {
109                                fprintf( stderr, "%s: illegal seedrec qualifier.  Abort.\n",
110                                        pa_progname() );
111                                return 1;
112                        } /*endif*/
113                } /*endif*/
114        } /*endif*/
115
116        if  (pa_qspecified("-locid"))  print_locid = TRUE;
117
118        *showinfo = '\0';
119        if  (pa_qvalue("-show") != NULL)  {
120                strcpy( showinfo, pa_qvalue("-show") );
121        } /*endif*/
122
123        /* allocate memory for SEED record */
124        seedrec = (SeedSbyteT *)sy_allocmem( 1, Seed_C_MAX_RECLTH, &status );
125        if  (Severe(&status))  err_writemsg( status, "", TRUE );
126
127        fp = fopen( seedfile, "rb" );
128        if  (fp == NULL)  {
129                fprintf( stderr, "*** %s: file %s not found\n", pa_progname(), seedfile );
130                fclose( out );
131                return 1;
132        } /*endif*/
133
134        /* determine record size if not specified */
135        if  (recsize == 0)  {
136                SeedQuickFindReclth( fp, &recsize, &byteoff );
137                if  (recsize <= 0)  {
138                        fclose( fp );
139                        if  (recsize == 0)  {
140                                fprintf( stderr, "%s: no valid SEED file %s\n",
141                                        pa_progname(), seedfile );
142                        } else {
143                                fprintf( stderr, "%s: cannot find record size in %s\n",
144                                        pa_progname(), seedfile );
145                        } /*endif*/
146                        return 1;
147                } /*endif*/
148        } /*endif*/
149
150        reccnt = 0;
151        gaplth = 0.0;
152        *lasttime = '\0';
153
154        /* read records */
155        FOREVER  {
156
157                reccnt++;
158
159                /* read next record */
160                read_ret = (int)fread( (char *)seedrec, recsize, 1, fp );
161                if  (read_ret != 1)  break;
162
163                /* check for swapping */
164                seedhdr = (SeedDataHeaderT *)seedrec;
165                sfd_swap_hdr = SeedSwapNecessary( seedhdr );
166                if  (sfd_swap_hdr)  SeedSwapHeader( seedhdr );
167
168                strncpy( seq, seedhdr->seqno, 6 );
169                seq[6] = '\0';
170                if  (seedhdr->indicator != 'D' && seedhdr->indicator != 'R'
171                        && seedhdr->indicator != 'Q')  {
172                        if  (*showinfo == '\0')
173                                printf( "%06d %6s %c\n", reccnt, seq, seedhdr->indicator );
174                        continue;
175                } /*endif*/
176
177                /* find start time */
178                SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status );
179                if  (Severe(&status))  {
180                        fprintf( stderr,
181                                "%s: could not read start time in file %s (status %d)\n",
182                                pa_progname(), seedfile, status );
183                        fclose( fp );
184                        fclose( out );
185                        return 1;
186                } /*endif*/
187                tc_n2t( &ntime, sfd_t_start, &status );
188                if  (Severe(&status))  {
189                        fprintf( stderr,
190                                "%s: could not convert start time (status %d) in file %s\n",
191                                pa_progname(), status, seedfile );
192                        fprintf( stderr, "%s: ntime: %d,%d,%d,%d,%d,%d,%d\n", pa_progname(),
193                                ntime.year, ntime.month, ntime.day, ntime.hour, ntime.min,
194                                ntime.sec, ntime.ms );
195                        fclose( fp );
196                        fclose( out );
197                        return 1;
198                } /*endif*/
199
200                /* channel name */
201                csrc = seedhdr->statcode;
202                cdst = sfd_stream;
203                *cdst = '\0';
204                while  (*csrc > ' ' && *csrc <= 'z')  *cdst++ = *csrc++;
205                *cdst++ = '-';
206                *cdst = '\0';
207                chanstr[0] = Cap( seedhdr->channel[0] );
208                chanstr[1] = Cap( seedhdr->channel[1] );
209                chanstr[2] = '\0';
210                if  (chanstr[0] <= ' ' || chanstr[0] > 'z')  chanstr[0] = '\0';
211                if  (chanstr[1] <= ' ' || chanstr[1] > 'z')  chanstr[1] = '\0';
212                ut_uncap( chanstr );
213
214                strcat( sfd_stream, chanstr );
215                strcat( sfd_stream, "-" );
216                i = (int)strlen( sfd_stream );
217                sfd_stream[i] = seedhdr->channel[2];
218                if  (chanstr[i] <= ' ' || chanstr[i] > 'z')  chanstr[i] = '\0';
219                sfd_stream[i+1] = '\0';
220                ut_uncap( sfd_stream );
221
222                /* get sample distance */
223                if  (seedhdr->smprate_fact == 0 || seedhdr->smprate_mult == 0)  {
224                        dt = 0.0;
225                } else {
226                        dt = SeedGetSampleDist( seedhdr );
227                } /*endif*/
228
229                tc_tadd( sfd_t_start, (float)(seedhdr->no_of_samples)*dt, sfd_t_end,
230                        &status );
231                if  (Severe(&status))  {
232                        fprintf( stderr, "%s: could not compute end time in file\n",
233                                pa_progname(), seedfile );
234                        fclose( fp );
235                        fclose( out );
236                        return 1;
237                } /*endif*/
238                if  (*lasttime != '\0')
239                        gaplth = tc_tdiff( sfd_t_start, lasttime, &status );
240
241        compression = SeedGetCompression( (SeedDataHeaderT *)seedrec );
242                b1000found = FALSE;
243                time_quality = -1;
244                if  (seedhdr->first != 0)  {
245                        donly = (SeedDataOnlyBlocketteT *)(seedrec+(seedhdr->first));
246                        b1000found = (donly->block_id == 1000);
247                        if  (b1000found && donly->next_block > 0)  {
248                                dext = (SeedDataExtBlocketteT *)(seedrec+(donly->next_block));
249                                if  (dext->block_id == 1001)  {
250                                        time_quality = dext->timequal;
251                                } /*endif*/
252                                if  (!b1000found && dext->block_id == 1000)  b1000found = TRUE;
253                        } /*endif*/
254                } /*endif*/
255
256                usign = *((unsigned long int *)(seedrec+68));
257                /*
258                tmp = usign & 0x0000ffff;
259                usign >>= 16;
260                usign += (unsigned long)tmp * 65536;
261                */
262
263                write_newline = TRUE;
264                if  (*showinfo == '\0')  {
265                        printf( "%06d %6s %c %s %s %5d %7.5f %d ", reccnt, seq, seedhdr->indicator,
266                                sfd_stream, sfd_t_start, seedhdr->no_of_samples, dt, time_quality );
267
268                        if  (gaplth == 0.0)  {
269                                printf( "cont" );
270                        } else {
271                                printf( "%g", gaplth );
272                                if (Abs(gaplth) > (dt/2.0))  {
273                                        gap_length += Abs(gaplth);
274                                        gap_count++;
275                                } else {
276                                        jitter_count++;
277                                } /*endif*/
278                        } /*endif*/
279
280                        if  (seedhdr->timecorr != 0)  printf( " (%d)", seedhdr->timecorr );
281
282                        if  (print_locid)  printf( " %c%c", seedhdr->locid[0], seedhdr->locid[1] );
283
284                } else {
285
286                        if  (gaplth != 0.0)  {
287                                if (Abs(gaplth) > (dt/2.0))  {
288                                        gap_length += Abs(gaplth);
289                                        gap_count++;
290                                } else {
291                                        jitter_count++;
292                                } /*endif*/
293                        } /*endif*/
294
295                        if  (strcmp(showinfo,"netcode") == 0)  {
296                                printf( "%c%c ", seedhdr->network[0], seedhdr->network[1] );
297                        } else if  (strcmp(showinfo,"timecorr") == 0)  {
298                                printf( "%d ", seedhdr->timecorr );
299                        } else if  (strcmp(showinfo,"locid") == 0)  {
300                                printf( "%c%c ", seedhdr->locid[0], seedhdr->locid[1] );
301                        } else if  (strcmp(showinfo,"activity") == 0)  {
302                                printf( "%s 0x%x ", sfd_t_start, (int)(seedhdr->activity) );
303                        } else if  (strcmp(showinfo,"ioflags") == 0)  {
304                                printf( "%s 0x%x ", sfd_t_start, (int)(seedhdr->ioflags) );
305                        } else if  (strcmp(showinfo,"quality") == 0)  {
306                                printf( "%s 0x%x ", sfd_t_start, (int)(seedhdr->quality) );
307                        } else if  (strcmp(showinfo,"b1000") == 0)  {
308                                printf( "%d ", b1000found );
309                        } else if  (strcmp(showinfo,"compression") == 0)  {
310                printf( "%d ", compression );
311                        } else {
312                                write_newline = FALSE;
313                        } /*endif*/
314
315                } /*endif*/
316
317                if  (write_newline)  printf( "\n" );
318
319                strcpy( lasttime, sfd_t_end );
320
321        } /*endfor*/
322
323        if  (strcmp(showinfo,"gaps") == 0)  {
324                printf( "gap_count %d gap_length %f jitter_count %d\n",
325                        gap_count, gap_length, jitter_count );
326        } /*endif*/
327
328        fclose( fp );
329        return 0;
330
331} /* end of main */
Note: See TracBrowser for help on using the repository browser.