int main(int argc,char *argv[]) {
int i;
struct {
double x,y,z;
int16 flg;
int32 data[4];
float angle;
} dat;
int pattern[]={8,3,2,1,4,4,4,1,0,0};
unsigned char *str;
dat.x=0.5;
dat.y=0.2;
dat.z=0.3;
dat.flg=1023;
dat.data[0]=18000;
dat.data[1]=32000;
dat.data[2]=64000;
dat.data[3]=12000;
dat.angle=45.5;
str=(unsigned char *) &dat;
ConvertBlock(str,pattern);
fprintf(stdout,"buf=");
for (i=0;i<sizeof(dat);i++) fprintf(stdout,"%.2x",str[i]);
fprintf(stdout,"\n");
return 0;
}
struct fitfp *fit_open(char *fitfile,char *inxfile) {
int r1_pat[]={4,2,1,2,2,17,4,2,2,14,4,4,2,4,
2,PULSE_PAT_LEN,2,2*LAG_TAB_LEN,1,ORIG_COMBF_SIZE,4,3,
2,2*ORIG_MAX_RANGE,1,ORIG_MAX_RANGE,0,0};
int status=0;
union fit_out r;
struct fitfp *ptr=NULL;
int16 tmp,i,j;
int32 inx_buf[4];
struct radar_parms *prms=NULL;
char *tmpbuf;
ptr=malloc(sizeof(struct fitfp));
if (ptr==NULL) return NULL;
ptr->fitfp=-1;
ptr->inxfp=-1;
ptr->ibuf=NULL;
ptr->fbuf=NULL;
ptr->iptr=0;
ptr->fptr=0;
ptr->ctime=-1;
ptr->stime=-1;
ptr->etime=-1;
ptr->fitfp=open(fitfile,O_RDONLY);
if (ptr->fitfp==-1) {
free(ptr);
return NULL;
}
fstat(ptr->fitfp,&ptr->fstat);
/* buffering disabled as it is actually slower to load into memory!
ptr->fbuf=malloc(ptr->fstat.st_size);
if (ptr->fbuf !=NULL) {
if (read(ptr->fitfp,ptr->fbuf,
ptr->fstat.st_size) !=ptr->fstat.st_size) {
close(ptr->fitfp);
free(ptr->fbuf);
free(ptr);
return NULL;
}
close(ptr->fitfp);
ptr->fitfp=-1;
}
*/
if (inxfile !=NULL) { /* open the index file */
ptr->inxfp=open(inxfile,O_RDONLY);
if (ptr->inxfp !=-1) {
fstat(ptr->inxfp,&ptr->istat);
ptr->ibuf=malloc(ptr->istat.st_size);
if ((ptr->ibuf !=NULL) &&
(read(ptr->inxfp,ptr->ibuf,ptr->istat.st_size)
!=ptr->istat.st_size)) free(ptr->ibuf);
close(ptr->inxfp);
ptr->inxfp=-1;
}
}
if (ptr->fitfp !=-1) {
ConvertReadShort(ptr->fitfp,&tmp);
ptr->fit_recl=tmp;
ConvertReadShort(ptr->fitfp,&tmp);
ptr->inx_recl=tmp;
tmpbuf=malloc(ptr->fit_recl);
if (tmpbuf !=NULL) { /* get the header information */
memset(tmpbuf,0,ptr->fit_recl);
status=(read(ptr->fitfp,tmpbuf,ptr->fit_recl) !=ptr->fit_recl);
/* now decode the header information */
if (status==0) {
for (i=0;(tmpbuf[i] !='\n') && (tmpbuf[i] !=0) && (i<80);i++)
ptr->header[i]=tmpbuf[i];
ptr->header[i]=0;
j=i+1;
for (i=0;(tmpbuf[j+i] !='\n') && (tmpbuf[j+i] !=0) && (i<32);i++)
ptr->date[i]=tmpbuf[j+i];
ptr->date[i]=0;
j+=i+1;
for (i=0;(tmpbuf[j+i] !=0) && (i<256);i++)
ptr->extra[i]=tmpbuf[j+i];
ptr->extra[i]=0;
/* okay extra the version information - look for the '.' */
for (i=0;(ptr->header[i] !='.') && (ptr->header[i] !=0);i++);
if (ptr->header[i] !=0) {
tmpbuf[i]=0; /* work backwards for the major number */
for (j=0;(ptr->header[i-1-j] !=' ') && ((i-1-j)>0);j++)
tmpbuf[i-1-j]=ptr->header[i-1-j];
ptr->major_rev=atoi(tmpbuf+i-j);
for (j=0;(ptr->header[i+1+j] !=' ') &&
(ptr->header[i+1+j] !=0);i++) tmpbuf[j]=ptr->header[i+1+j];
tmpbuf[j]=0;
ptr->minor_rev=atoi(tmpbuf);
}
}
free(tmpbuf);
}
lseek(ptr->fitfp,ptr->fit_recl,SEEK_SET);
/* read the first parameter block se we can determine the year */
status=(read(ptr->fitfp,&r,sizeof(union fit_out)) !=sizeof(union fit_out));
if (status==0) {
ConvertBlock( (unsigned char *) &r,r1_pat);
status=(r.r1.rrn !=0);
prms=(struct radar_parms *) &(r.r1.plist[0]);
}
lseek(ptr->fitfp,ptr->fit_recl,SEEK_SET);
} else {
ConvertToShort(ptr->fbuf,&tmp);
ptr->fit_recl=tmp;
ConvertToShort(ptr->fbuf+2,&tmp);
ptr->inx_recl=tmp;
ptr->fptr=ptr->fit_recl;
memcpy( (unsigned char *) &r,
ptr->fbuf+ptr->fit_recl,sizeof(union fit_out));
ConvertBlock( (unsigned char *) &r,r1_pat);
status=(r.r1.rrn !=0);
prms=(struct radar_parms *) &(r.r1.plist[0]);
}
if (status !=0) {
if (ptr->fitfp !=-1) close(ptr->fitfp);
if (ptr->fbuf !=NULL) free(ptr->fbuf);
if (ptr->inxfp !=-1) close(ptr->inxfp);
if (ptr->ibuf !=NULL) free(ptr->ibuf);
free(ptr);
return NULL;
}
ptr->ctime=TimeYMDHMSToEpoch(prms->YEAR,prms->MONTH,prms->DAY,
prms->HOUR,prms->MINUT,prms->SEC);
ptr->stime=ptr->ctime;
if (fit_read_inx(ptr,inx_buf,-1)==0) {
if (inx_buf[0] > inx_buf[1]) prms->YEAR++;
/* generate the end time of the file */
ptr->etime=TimeYMDHMSToEpoch(prms->YEAR,1,1,0,0,0)
+inx_buf[1];
ptr->inx_srec=inx_buf[2]-2;
ptr->inx_erec=inx_buf[3];
} else { /* corrupt index file */
if (ptr->inxfp !=-1) close(ptr->inxfp);
if (ptr->ibuf !=NULL) free(ptr->ibuf);
ptr->ibuf=NULL;
ptr->inxfp=-1;
}
ptr->fitread=fit_read_current;
return ptr;
}
int OldFitCnxDecodeIPMsg(struct RadarParm *prm,struct FitData *fit,
unsigned char *buffer) {
unsigned char *buf;
unsigned char *gsct;
unsigned char *dflg;
struct radar_parms oldprm;
int pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
int i;
int rng_num=0;
int index;
if (buffer[0] !='d') return 0;
buf=buffer+1;
ConvertBlock(buf,pat);
memcpy(&oldprm,buf,sizeof(struct radar_parms));
buf+=sizeof(struct radar_parms);
gsct=buf;
dflg=buf+10;
buf+=20;
prm->revision.major=oldprm.REV.MAJOR;
prm->revision.minor=oldprm.REV.MINOR;
prm->cp=oldprm.CP;
prm->stid=oldprm.ST_ID;
prm->time.yr=oldprm.YEAR;
prm->time.mo=oldprm.MONTH;
prm->time.dy=oldprm.DAY;
prm->time.hr=oldprm.HOUR;
prm->time.mt=oldprm.MINUT;
prm->time.sc=oldprm.SEC;
prm->time.us=0;
prm->txpow=oldprm.TXPOW;
prm->nave=oldprm.NAVE;
prm->atten=oldprm.ATTEN;
prm->lagfr=oldprm.LAGFR;
prm->smsep=oldprm.SMSEP;
prm->ercod=oldprm.ERCOD;
prm->stat.agc=oldprm.AGC_STAT;
prm->stat.lopwr=oldprm.LOPWR_STAT;
prm->noise.search=oldprm.NOISE;
prm->noise.mean=oldprm.NOISE_MEAN;
prm->channel=oldprm.CHANNEL;
prm->bmnum=oldprm.BMNUM;
prm->scan=oldprm.SCAN;
prm->offset=oldprm.usr_resL1;
prm->rxrise=oldprm.RXRISE;
prm->intt.sc=oldprm.INTT;
prm->intt.us=0;
prm->txpl=oldprm.TXPL;
prm->mpinc=oldprm.MPINC;
prm->mppul=oldprm.MPPUL;
prm->mplgs=oldprm.MPLGS;
prm->nrang=oldprm.NRANG;
prm->frang=oldprm.FRANG;
prm->rsep=oldprm.RSEP;
prm->xcf=oldprm.XCF;
prm->tfreq=oldprm.TFREQ;
prm->mxpwr=oldprm.MXPWR;
prm->lvmax=oldprm.LVMAX;
for (i=0;i<MAX_RANGE;i++) {
fit->rng[i].qflg=0;
fit->rng[i].gsct=0;
fit->rng[i].v=0;
fit->rng[i].v_err=0;
fit->rng[i].p_0=0;
fit->rng[i].p_l=0;
fit->rng[i].p_l_err=0;
fit->rng[i].p_s=0;
fit->rng[i].p_s_err=0;
fit->rng[i].w_l=0;
fit->rng[i].w_l_err=0;
fit->rng[i].w_s=0;
fit->rng[i].w_s_err=0;
fit->rng[i].phi0=0;
fit->rng[i].phi0_err=0;
fit->rng[i].sdev_l=0;
fit->rng[i].sdev_s=0;
fit->rng[i].sdev_phi=0;
fit->rng[i].nump=0;
}
for (i=0;i<ORIG_MAX_RANGE;i++) {
if (read_bit(dflg,i) !=0) {
fit->rng[i].qflg=1;
rng_num++;
}
}
if (rng_num == 0) return 1;
index=0;
for (i=0;i<ORIG_MAX_RANGE;i++) {
if (fit->rng[i].qflg !=0) {
if (read_bit(gsct,i) !=0) fit->rng[i].gsct=1;
ConvertToDouble(buf+8*index,&fit->rng[i].p_l);
ConvertToDouble(buf+8*(index+rng_num),&fit->rng[i].v);
ConvertToDouble(buf+8*(index+2*rng_num),&fit->rng[i].w_l);
index++;
}
}
return 1;
}
int raw_read_current(struct rawfp *fp,struct rawdata *raw_data) {
/* read raw data block from file */
int radar_parms_pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
int i;
int16 range;
int j;
int16 prev_range;
int xcf_data;
unsigned int stat;
int16 num_byte;
int32 rec_num=0;
unsigned char *inbuf;
unsigned char *inbuf_ptr;
xcf_data = 0;
prev_range = -1;
inbuf=malloc(sizeof(struct rawdata));
/* zero out the raw data buffer */
memset(raw_data,0,sizeof(struct rawdata));
fp->rlen=0;
do {
if (ConvertReadShort(fp->rawfp,&num_byte) !=0) {
free(inbuf);
return -1;
}
fp->rlen+=num_byte;
fp->ptr+=num_byte;
num_byte = num_byte - 2;
stat = read(fp->rawfp,inbuf,num_byte);
if(stat != num_byte) {
free(inbuf);
return -1;
}
inbuf_ptr=inbuf;
ConvertToInt(inbuf_ptr,&rec_num);
} while (rec_num==0);
inbuf_ptr = inbuf_ptr + 12; /* skip rec_num + rawwrite */
num_byte = num_byte - 12;
/* zero out the raw data buffer */
/* copy radar_parms */
ConvertBlock(inbuf_ptr,radar_parms_pat);
memcpy((void *) &(raw_data->PARMS),inbuf_ptr,sizeof(struct radar_parms));
inbuf_ptr = inbuf_ptr + sizeof(struct radar_parms);
num_byte = num_byte - sizeof(struct radar_parms);
/* copy the pulse pattern */
for (i=0;i<raw_data->PARMS.MPPUL;i++) {
ConvertToShort(inbuf_ptr,&raw_data->PULSE_PATTERN[i]);
inbuf_ptr+=sizeof(int16);
num_byte-=sizeof(int16);
}
/* copy the lag table */
for(j=0;j < 2; ++j)
for(i=0; i < raw_data->PARMS.MPLGS; ++i) {
ConvertToShort(inbuf_ptr,&raw_data->LAG_TABLE[j][i]);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
/* copy comment buffer */
memcpy(raw_data->COMBF,inbuf_ptr,ORIG_COMBF_SIZE);
inbuf_ptr = inbuf_ptr + ORIG_COMBF_SIZE;
num_byte = num_byte - ORIG_COMBF_SIZE;
/* decompress and copy the lag-0 powers */
for(i=0 ; i < raw_data->PARMS.NRANG ; ++i) {
raw_data->pwr0[i] = dcmpr(inbuf_ptr);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
/* decompress and copy acfs */
while ( num_byte > 0 ) {
ConvertToShort(inbuf_ptr,&range);
--range;
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
if((range <= prev_range) && (raw_data->PARMS.XCF))
xcf_data = 1;
for(i = 0; i < raw_data->PARMS.MPLGS ; ++i) {
for(j=0 ; j < 2; ++j) {
if (xcf_data) raw_data->xcfd[range][i][j] = dcmpr(inbuf_ptr);
else raw_data->acfd[range][i][j] = dcmpr(inbuf_ptr);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
}
prev_range = range;
}
fp->ctime=TimeYMDHMSToEpoch(raw_data->PARMS.YEAR,
raw_data->PARMS.MONTH,
raw_data->PARMS.DAY,
raw_data->PARMS.HOUR,
raw_data->PARMS.MINUT,
raw_data->PARMS.SEC);
free(inbuf);
return 0;
}
unsigned char *fitpacket(struct RadarParm *prm,
struct FitData *fit,int *size) {
int pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
int dpat[]={8,0,0,0};
int rtab[ORIG_MAX_RANGE];
float *snr;
unsigned char *ptr=NULL;
unsigned char *dflg;
unsigned char *gsct;
double *store;
int rng_num,loop,l,inx,s,step;
float maxval;
struct radar_parms oldprm;
oldprm.REV.MAJOR=prm->revision.major;
oldprm.REV.MINOR=prm->revision.minor;
oldprm.NPARM=48;
oldprm.CP=prm->cp;
oldprm.ST_ID=prm->stid;
oldprm.YEAR=prm->time.yr;
oldprm.MONTH=prm->time.mo;
oldprm.DAY=prm->time.dy;
oldprm.HOUR=prm->time.hr;
oldprm.MINUT=prm->time.mt;
oldprm.SEC=prm->time.sc;
oldprm.TXPOW=prm->txpow;
oldprm.NAVE=prm->nave;
oldprm.ATTEN=prm->atten;
oldprm.LAGFR=prm->lagfr;
oldprm.SMSEP=prm->smsep;
oldprm.ERCOD=prm->ercod;
oldprm.AGC_STAT=prm->stat.agc;
oldprm.LOPWR_STAT=prm->stat.lopwr;
oldprm.NOISE=prm->noise.search;
oldprm.NOISE_MEAN=prm->noise.mean;
oldprm.CHANNEL=prm->channel;
oldprm.BMNUM=prm->bmnum;
oldprm.SCAN=prm->scan;
oldprm.RXRISE=prm->rxrise;
oldprm.INTT=prm->intt.sc;
oldprm.TXPL=prm->txpl;
oldprm.MPINC=prm->mpinc;
oldprm.MPPUL=prm->mppul;
oldprm.MPLGS=prm->mplgs;
oldprm.NRANG=prm->nrang;
oldprm.FRANG=prm->frang;
oldprm.RSEP=prm->rsep;
oldprm.XCF=prm->xcf;
oldprm.TFREQ=prm->tfreq;
oldprm.MXPWR=prm->mxpwr;
oldprm.LVMAX=prm->lvmax;
snr=malloc(sizeof(float)*prm->nrang);
if (snr==NULL) return NULL;
for (l=0;l<prm->nrang;l++) {
if (prm->noise.search>0)
snr[l]=fit->rng[l].p_0/prm->noise.search;
else snr[l]=0;
}
if (prm->nrang>ORIG_MAX_RANGE) {
step=prm->nrang/ORIG_MAX_RANGE;
for (l=0;l<ORIG_MAX_RANGE;l++) {
maxval=0.0;
inx=l*step;
for (s=0;s<step;s++) {
/*
if (fit->rng[l*step+s].qflg==0) continue;
if (fit->rng[l*step+s].gsct !=0) continue;
*/
if (snr[l*step+s]>maxval) {
maxval=snr[l*step+s];
inx=l*step+s;
}
}
rtab[l]=inx;
}
oldprm.RSEP=prm->rsep*step;
} else for (l=0;l<ORIG_MAX_RANGE;l++) rtab[l]=l;
free(snr);
rng_num=0;
for (loop=0;loop<ORIG_MAX_RANGE;loop++)
if (fit->rng[rtab[loop]].qflg ==1) rng_num++;
ptr=malloc(sizeof(struct radar_parms)+21+3*sizeof(double)*rng_num);
if (ptr==NULL) return 0;
ptr[0]='d';
gsct=ptr+1+sizeof(struct radar_parms);
dflg=gsct+10;
store=(double *) (dflg+10);
memcpy(ptr+1,&oldprm,sizeof(struct radar_parms));
ConvertBlock(ptr+1,pat);
memset(gsct,0,10);
memset(dflg,0,10);
/* work out which ranges to store */
for (loop=0;loop<ORIG_MAX_RANGE;loop++) {
if (fit->rng[rtab[loop]].gsct !=0) set_bit(gsct,loop);
if (fit->rng[rtab[loop]].qflg ==1) set_bit(dflg,loop);
}
/* store the ranges */
if (rng_num>0) {
int index=0;
for (loop=0;loop<ORIG_MAX_RANGE;loop++) {
if (read_bit(dflg,loop) !=0) {
store[index]=fit->rng[rtab[loop]].p_l;
store[index+rng_num]=fit->rng[rtab[loop]].v;
store[index+2*rng_num]=fit->rng[rtab[loop]].w_l;
/* store[index+2*rng_num]=fit->rng[rtab[loop]].v_err; */
index++;
}
}
}
/* convert the stored values */
dpat[1]=3*rng_num;
ConvertBlock( (unsigned char *) store,dpat);
*size=(sizeof(struct radar_parms)+21+3*sizeof(double)*rng_num);
return ptr;
}
struct OldRawFp *OldRawOpenFd(int rawfd,int inxfd) {
int radar_parms_pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
unsigned char *inbuf=NULL;
int16 num_byte;
int32 rec_num;
int stat;
struct radar_parms *prm;
struct OldRawFp *ptr=NULL;
int status=0;
int j;
inbuf=malloc(sizeof(struct rawdata));
if (inbuf==NULL) return NULL;
ptr=malloc(sizeof(struct OldRawFp));
if (ptr==NULL) return NULL;
ptr->rawfp=rawfd;
ptr->stime=-1;
ptr->ctime=-1;
ptr->frec=0;
ptr->rlen=0;
ptr->ptr=0;
fstat(ptr->rawfp,&ptr->rstat);
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
ptr->frec=num_byte+2;
ptr->rlen=num_byte+2;
ptr->ptr=num_byte+2;
if (rec_num==0) { /* decode header to get the threshold */
char tmp[256];
char *str;
strcpy(tmp,(char *) (inbuf+sizeof(struct rawrechdr)-sizeof(int16)+1));
ptr->thr=3;
str=strtok(tmp," ");
if (str==NULL) status=-1;
if ((status==0) && (strcmp(str,"version") !=0)) status=-1;
if (status==0) str=strtok(NULL," ");
if (str==NULL) status=-1;
for (j=0;str[j] !=0;j++) if (str[j]=='.') break;
if (str[j]==0) {
ptr->major_rev=atoi(str);
} else {
str[j]=0;
ptr->major_rev=atoi(str);
ptr->minor_rev=atoi(str+j+1);
}
if (status==0) str=strtok(NULL," ");
if (str==NULL) status=-1;
if ((status==0) && (strcmp(str,"threshold") !=0)) status=-1;
if (status==0) str=strtok(NULL," ");
if (str==NULL) status=-1;
if (status==0) ptr->thr=atoi(str);
}
if (rec_num !=0) { /* not the header so rewind the file */
lseek(ptr->rawfp,0L,SEEK_SET);
ptr->rlen=0;
}
/* read the first record so that we can determine the start time of
the file */
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
/* now decode the parameter block */
ConvertBlock(inbuf+12,radar_parms_pat);
prm=(struct radar_parms *) (inbuf+12);
ptr->stime=TimeYMDHMSToEpoch(prm->YEAR,prm->MONTH,prm->DAY,
prm->HOUR,prm->MINUT,prm->SEC);
ptr->ctime=ptr->stime;
/* rewind to the first record */
lseek(ptr->rawfp,ptr->frec,SEEK_SET);
ptr->rawread=OldRawReadCurrent;
free(inbuf);
return ptr;
}
struct rawfp *raw_open(char *rawfile,char *inxfile) {
int radar_parms_pat[]= {1,2,2,17,4,2,2,14,4,4,2,4,0,0};
unsigned char *inbuf=NULL;
int16 num_byte;
int32 rec_num;
int stat;
struct radar_parms *prm;
struct rawfp *ptr=NULL;
inbuf=malloc(sizeof(struct rawdata));
if (inbuf==NULL) return NULL;
ptr=malloc(sizeof(struct rawfp));
if (ptr==NULL) return NULL;
ptr->rawfp=open(rawfile,O_RDONLY);
ptr->stime=-1;
ptr->ctime=-1;
ptr->frec=0;
ptr->rlen=0;
ptr->ptr=0;
if (ptr->rawfp==-1) {
free(ptr);
free(inbuf);
return NULL;
}
fstat(ptr->rawfp,&ptr->rstat);
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
ptr->frec=num_byte+2;
ptr->rlen=num_byte+2;
ptr->ptr=num_byte+2;
if (rec_num !=0) { /* not the header so rewind the file */
lseek(ptr->rawfp,0L,SEEK_SET);
ptr->rlen=0;
}
/* read the first record so that we can determine the start time of
the file */
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
/* now decode the parameter block */
ConvertBlock(inbuf+12,radar_parms_pat);
prm=(struct radar_parms *) (inbuf+12);
ptr->stime=TimeYMDHMSToEpoch(prm->YEAR,prm->MONTH,prm->DAY,
prm->HOUR,prm->MINUT,prm->SEC);
/* rewind to the first record */
lseek(ptr->rawfp,ptr->frec,SEEK_SET);
ptr->rawread=raw_read_current;
free(inbuf);
return ptr;
}
