int main(int argc,char *argv[]) {
int16 val;
int fd;
fd=open(FNAME,O_RDONLY);
if (fd==-1) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
while (ConvertReadShort(fd,&val)==0) {
fprintf(stdout,"%d\n",val);
}
close(fd);
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 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;
}
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;
}
int CFitRead(struct CFitfp *fptr,struct CFitdata *ptr) {
float val;
int i;
if (fptr->fp !=-1) {
if (ConvertReadDouble(fptr->fp,&ptr->time) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->stid) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->scan) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->cp) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->bmnum) !=0) return -1;
if (ConvertReadFloat(fptr->fp,&ptr->bmazm) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->channel) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->intt.sc) !=0) return -1;
if (ConvertReadInt(fptr->fp,&ptr->intt.us) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->frang) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->rsep) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->rxrise) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->tfreq) !=0) return -1;
if (ConvertReadInt(fptr->fp,&ptr->noise) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->atten) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->nave) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->nrang) !=0) return -1;
} else {
if ((fptr->fptr+sizeof(double)+7*sizeof(int16)+
sizeof(int32)+sizeof(float))>fptr->fsze) return -1;
ConvertToDouble(&fptr->fbuf[fptr->fptr],&ptr->time);
fptr->fptr+=sizeof(double);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->stid);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->scan);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->cp);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->bmnum);
fptr->fptr+=sizeof(int16);
ConvertToFloat(fptr->fbuf+fptr->fptr,&ptr->bmazm);
fptr->fptr+=sizeof(float);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->channel);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->intt.sc);
fptr->fptr+=sizeof(int16);
ConvertToInt(fptr->fbuf+fptr->fptr,&ptr->intt.us);
fptr->fptr+=sizeof(int32);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->frang);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->rsep);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->rxrise);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->tfreq);
fptr->fptr+=sizeof(int16);
ConvertToInt(fptr->fbuf+fptr->fptr,&ptr->noise);
fptr->fptr+=sizeof(int32);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->atten);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->nave);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->nrang);
fptr->fptr+=sizeof(int16);
}
fptr->ctime=ptr->time;
if (fptr->fp !=-1) {
if (read(fptr->fp,&ptr->num,1) !=1) return -1;
if (read(fptr->fp,ptr->rng,ptr->num) !=ptr->num) return -1;
} else {
if (fptr->fptr>=fptr->fsze) return -1;
ptr->num=fptr->fbuf[fptr->fptr];
fptr->fptr+=1;
if ((fptr->fptr+ptr->num)>=fptr->fsze) return -1;
memcpy(ptr->rng,&fptr->fbuf[fptr->fptr],ptr->num);
fptr->fptr+=ptr->num;
}
for (i=0;i<ptr->num;i++) {
if (fptr->fp !=-1) {
if (read(fptr->fp,&ptr->data[i].gsct,1) !=1) return -1;
if (ptr->data[i].gsct==EOF) return -1;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_0=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_0_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].v=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_l=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].w_l=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].v_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_l_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].w_l_e=val;
} else {
if ((fptr->fptr+1+sizeof(float)*6)>=fptr->fsze) return -1;
ptr->data[i].gsct=fptr->fbuf[fptr->fptr];
fptr->fptr+=1;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_0=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_0_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].v=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_l=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].w_l=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].v_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_l_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].w_l_e=val;
}
}
return 0;
}
