/*===========================================================================*//* DMC Interim out |            get_scaninfo.c             |   Scan_phase    *//*===========================================================================*//*	Name:		get_scaninfo.c	Purpose:	retrieve a subset of SEED data header info from a given buffer				containing one data record	Usage:		void get_scaninfo ()				char *buf				struct input_time *end_tspan;				struct input_scan *scan;				struct input_time *rec_start;				struct input_time *rec_end;				long *interval;				get_scaninfo (buf, scan, rec_start, rec_end, interval)	Input:		char *buf;		ptr->data record hdr			struct input_time *end_tspan;	ptr->tspan end time	Output:		struct input_scan *scan;ptr->scan subset of data hdr			struct input_time *rec_start;	ptr->start time of data record			struct input_time *rec_end;ptr->end time of data record			long *interval;		ptr->data sample interval													(fracsec/samp)	Externals:	Debug - setting of environment variable DEBUG (globals.h)	Messages:	None	Warnings:	None	Errors:		None	Fatals:		None	Called by:		Calls to:	add_time	adds delta e-04 sec to struct input_time	Algorithm:		Notes:		Assumes input buffer data in cpu-compatible byte order	Problems:	None known	Debug:		level D_MIN -				level D_MED -				level D_MAX -	References:	none	Language:	ANSI standard C, under Sun OS 3.5	Revisions:	03/06/89  Kevin MacKenzie  original version				10jul90	mw	bugfix						fix 0 sample interval channel's end time				19apr91	mw	bugfix						"duration" in units of e-4 sec overflows						for 100 sec sample interval data. This causes						end times earlier than start times. Change to						duration in seconds, use add_longtime.*/                   /*=====================================*//*=================|                                       |=================*/                   /*=====================================*/#include "output.h"#define isaleap(year) (((year%100 != 0) && (year%4 == 0)) || (year%400 == 0))void get_scaninfo (buf, end_tspan, scan, rec_start, rec_end, interval, fname)char *buf;			/* ptr->data record hdr */struct input_time *end_tspan;	/* ptr->time of end of current tspan */struct input_scan *scan;	/* ptr->scan subset of data record hdr */struct input_time *rec_start;	/* ptr->start time of data record */struct input_time *rec_end;	/* ptr->end time of data record */long *interval;			/* ptr->data sample interval(fracsec/samp)*/char *fname;			/* used for error reporting */{	struct input_data_logrec  *rec; /* log rec header plus data rec header */	float frate;		/* data sample rate, e-04 sec/samp */	register long	lrate;	/* data sample rate, e-04 sec/samp */	long duration;		/* time duration of data rec, e-04 sec *//* * compute end time of the data record from its header info * There is a special case for log or aux channels, where we * don't have a sample interval. In this case we must use * an end time derived from the timespan. */	rec = (struct input_data_logrec *) buf;	if (bytes_need_swapping(buf))	{		/* swap the bytes */		rec->hdr.scan.time.year    = swap_2byte(rec->hdr.scan.time.year);		rec->hdr.scan.time.day     = swap_2byte(rec->hdr.scan.time.day);		rec->hdr.scan.time.fracsec = swap_2byte(rec->hdr.scan.time.fracsec); 		rec->hdr.full.nsamples	   = swap_2byte(rec->hdr.full.nsamples);		rec->hdr.full.sample_rate  = swap_2byte(rec->hdr.full.sample_rate);		rec->hdr.full.sample_rate_multiplier =						 swap_2byte(rec->hdr.full.sample_rate_multiplier);		rec->hdr.full.number_time_corrections =						swap_4byte(rec->hdr.full.number_time_corrections);		rec->hdr.full.bod  = swap_2byte(rec->hdr.full.bod);		rec->hdr.full.bofb = swap_2byte(rec->hdr.full.bofb);	}	*scan = rec->hdr.scan;	*rec_start = rec->hdr.full.time;/* Do time correction */	if ((rec->hdr.full.activity_flags & 0x02) == 0)	{/*		printf("%02x %s %02d:%02d:%02d.%05d + %05d = ", input_data_hdr->activity_flags, this_channel, rec_start->hour, rec_start->minute, rec_start->second, rec_start->fracsec, input_data_hdr->number_time_corrections); */		rec_start->fracsec += rec->hdr.full.number_time_corrections;		while ((rec_start->fracsec >= 10000) || (rec_start->fracsec < 0)) {		if (rec_start->fracsec >= 10000)		{			rec_start->second += rec_start->fracsec/10000;			rec_start->fracsec = rec_start->fracsec%10000;			if (rec_start->second >= 60)			{				rec_start->minute += rec_start->second/60;				rec_start->second = rec_start->second%60;				if (rec_start->minute >= 60)				{					rec_start->hour += rec_start->minute/60;					rec_start->minute = rec_start->minute%60;					if (rec_start->hour >= 24)					{						rec_start->day += rec_start->hour/24;						rec_start->hour = rec_start->hour%24;						if (rec_start->day > (isaleap(rec_start->year) ? 366 : 365))						{							rec_start->year += 1;							rec_start->day = 1;						}					}				}			}		}		else if (rec_start->fracsec < 0)		{			rec_start->second -= 1;			rec_start->fracsec += 10000;			if (rec_start->second < 0)			{				rec_start->minute -= 1;				rec_start->second += 60;				if (rec_start->minute < 0)				{					rec_start->hour -= 1;					rec_start->minute += 60;					if (rec_start->hour < 0)					{						rec_start->day -= 1;						rec_start->hour += 24;						if (rec_start->day == 0)						{							rec_start->year -= 1;							rec_start->day = (isaleap(rec_start->year) ? 366 : 365);						}					}				}			}		}		}/*		printf("%02d:%02d:%02d.%05d\n", rec_start->hour, rec_start->minute, rec_start->second, rec_start->fracsec);  */	}	scan->time = *rec_start; /* Save correct time in scan header */		lrate = rec->hdr.full.sample_rate;	if( lrate != 0 )	{		if (lrate > 0)		{			if (rec->hdr.full.sample_rate_multiplier > 0)				frate = lrate * rec->hdr.full.sample_rate_multiplier;			else if (rec->hdr.full.sample_rate_multiplier < 0)				frate = (float)lrate /					(float)(-rec->hdr.full.sample_rate_multiplier);			else			{				frate = lrate;	/* multiplier == 0 should not happen? */				fprintf( D_OUT,					"[get_scaninfo] sample rate mult zero? %.5s %.3s %d %d\n",					rec->hdr.full.station, rec->hdr.full.channel,					rec->hdr.full.sample_rate,					rec->hdr.full.sample_rate_multiplier );			}		}		else		{			if (rec->hdr.full.sample_rate_multiplier > 0)				frate = ((double)rec->hdr.full.sample_rate_multiplier)/ ((double)(-lrate));			else if (rec->hdr.full.sample_rate_multiplier < 0)				frate = (double)rec->hdr.full.sample_rate_multiplier/ (double)lrate;			else			{				frate = lrate;	/* multiplier == 0 should not happen? */				fprintf( D_OUT,					"[get_scaninfo] sample rate mult zero? %.5s %.3s %d %d\n",					rec->hdr.full.station, rec->hdr.full.channel,					rec->hdr.full.sample_rate,					rec->hdr.full.sample_rate_multiplier );			}		}		if (rec->hdr.full.number_blockettes)					if (parse_type100 (&rec->hdr.full, &frate, fname)) 			{				if (frate == 0)                                {                                         fprintf(stderr, "Warning: get_scaninfo(), bad sample rate found in blockette 100!\n");                                        fprintf(stderr, "Net/stn/chn/loc:%2.2s, %5.5s, %3.3s, %2.2s\n",                                                scan->network,                                                scan->station,                                                scan->channel,                                                scan->location);                                         fprintf(stderr, "\tfor time:%d,%d,%d:%d:%d\n", 							scan->time.year,                                                        scan->time.day,							scan->time.hour,                                                        scan->time.minute,                                                        scan->time.second);                                         frate = lrate;                                }                                else				lrate = 999;			}		*interval = (1e4 / frate);		duration = ((float)(rec->hdr.full.nsamples))/ frate;  /*seconds*//* *			will it fit in 31 bits of e-4 msec *			and still be able to have up to a day of seconds added? */		if( duration < (214748-86400) )		{/*			duration = ((double)(rec->hdr.full.nsamples)*10000.0)/(double)frate; */  /* e-4 seconds*/			duration = (int) (((double)((rec->hdr.full.nsamples-1)*10000))/(double)frate);  /* e-4 seconds*/			*rec_end = add_time (*rec_start, duration);		}		else		{			*rec_end = add_longtime (*rec_start, duration);		}	}	else	{		*rec_end = *rec_start;			*interval = 20;	}	return;}/*===========================================================================*//* SEED reader     |            parse_type100              |     data block  *//*===========================================================================*//*	Name:		parse_type100	Purpose:	parse a data record header for blockette 100s.	Usage:		void parse_type100 ();				char *input_data_ptr;				float *sample_rate;				parse_type100 (input_data_ptr, &sample_rate);	Input:		pointer to beginning of data record header	Output:		none	Externals:	none	Warnings:	none	Errors:		none	Called by:	process_data	Calls to:	none	Algorithm:	search through data record blockettes for blockette 100 sample rate	Notes:		none	Problems:	none known	References:	none	Language:	C, hopefully ANSI standard	Author:		Allen Nance	Revisions:	09/18/92  Allen Nance  Initial version*/parse_type100 (input_data_ptr, sample_rate, fname)char *input_data_ptr;		/* ptr to start of data record */float *sample_rate;		/* ptr to returned sample rate */char *fname;			/* for error reporting */{	struct input_data_hdr *input_data_hdr;	/* fixed data header */	struct data_blk_100 *blk_100;		/* blockette 100 pointer */	int i;					/*counter */	/* point to beginning data header structure */	input_data_hdr = (struct input_data_hdr *) input_data_ptr;	blk_100 = (struct data_blk_100 *) (input_data_ptr + (input_data_hdr->bofb - 8));/*	printf("data blk next %d\n", blk_100->hdr.next_blk_byte); */	while (blk_100->hdr.next_blk_byte != 0)	{		if (blk_100->hdr.type == 100)		{			*sample_rate = blk_100->sample_rate;			return(1);		}		if ( ((blk_100->hdr.next_blk_byte%4)!=0) ||		     (blk_100->hdr.next_blk_byte < (sizeof(struct input_data_hdr)+8)) )		{			fprintf (stderr, "WARNING (parse_type100):  ");			fprintf (stderr, "invalid byte pointer = %04x, in %.5s,%.3s at %4d,%3d,%2d:%2d:%2d\n",				blk_100->hdr.next_blk_byte, input_data_hdr->station,				input_data_hdr->channel, input_data_hdr->time.year,				input_data_hdr->time.day, input_data_hdr->time.hour,				input_data_hdr->time.minute, input_data_hdr->time.second);			fprintf (stderr, "\tData blockette 100 parsing will be ignored.\n");			fprintf(stderr, "\tfile name: %s\n", fname);			break;		}		blk_100 = (struct data_blk_100 *) (input_data_ptr+(blk_100->hdr.next_blk_byte-8));	}	return(0);}