static char rcsid[]="$Id: scv_rdr.c,v 1.0 1992/07/28 23:07:53 maurer $";      
/***********************************************************************      
                                                                              
  scv_rdr.c                                                                   
                                                                              
  Function:  Reads SCVDR data files into SCVDR data structures                
                                                                              
  This file is part of the STARLab Magellan Altimeter Data Processing         
  Software.  Joe Twicken, June 1992.                                          
                                                                              
***********************************************************************/      
                                                                              
/* $Log: scv_rdr.c,v $                                                        
 * Revision 1.0  1992/07/28  23:07:53  maurer                                 
 * Initial revision                                                           
 * */                                                                         
                                                                              
#include <stdio.h>                                                            
#include <malloc.h>                                                           
                                                                              
#include "scvdr.h"                                                            
#include "scvparse.h"                                                         
                                                                              
#define SCV_RDR_C                                                             
#include "scvparse.i"                                                         
#include "scv_rdr.i"                                                          
                                                                              
/***********************************************************************      
                                                                              
  vhf_read                                                                    
                                                                              
  Reads SFDU records that form the VHF file                                   
                                                                              
  #1      CCSD    file header                                                 
  #2      NJPL    catalog items (keyword & value SFDU)                        
  #4      CCSD    aggregation start                                           
                                                                              
  The user must free the space allocated for the keyword/value lists          
  with calls to free_catalog().                                               
                                                                              
  Returns 0 on success                                                        
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
vhf_read(f,psf1,psf2,pkv2,psf4,pkv4)                                          
FILE *f;                /* File pointer */                                    
sfdu *psf1;             /* Pointer to CCSDS SFDU label */                     
sfdu *psf2;             /* Pointer to catalog SFDU label */                   
keyval_t **pkv2;        /* Pointer to catalog keyword/value list */           
sfdu *psf4;             /* Pointer to smarker SFDU */                         
keyval_t **pkv4;        /* Pointer to smarker keyword/value list */           
{                                                                             
        sfdu sf3;       /* Missing header record SFDU */                      
        char *phdr;     /* Pointer to missing SFDU */                         
        int err;        /* Function return code */                            
                                                                              
        /* Allocate space for missing header record SFDU */                   
        phdr = (char *) calloc(1,sizeof(sfdu));                               
                                                                              
        /* Initialize the keyword/value list pointers */                      
        *pkv2 = *pkv4 = NULL;                                                 
                                                                              
        /* Read the SFDU records */                                           
        err = scv_rhdr(f,psf1,psf2,pkv2,&sf3,&phdr,psf4,pkv4);                
                                                                              
        /* Free the missing header record SFDU */                             
        free(phdr);                                                           
                                                                              
        /* Return the error code (0=success) */                               
        return(err);                                                          
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  hdr_read                                                                    
                                                                              
  Reads 4 SFDU records forming header of SCVDR files (except VHF & VTF)       
                                                                              
  #1      CCSD    file header                                                 
  #2      NJPL    catalog items (keyword & value SFDU)                        
  #3      NJPL    file header record                                          
  #4      CCSD    aggregation start                                           
                                                                              
  The user must free the space allocated for the keyword/value lists          
  with calls to free_catalog().                                               
                                                                              
  Returns 0 on success                                                        
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
hdr_read(f,psf1,psf2,pkv2,psf3,phdr,psf4,pkv4)                                
FILE *f;                /* File pointer */                                    
sfdu *psf1;             /* Pointer to CCSDS SFDU label */                     
sfdu *psf2;             /* Pointer to catalog SFDU label */                   
keyval_t **pkv2;        /* Pointer to catalog keyword/value list */           
sfdu *psf3;             /* Pointer to header record SFDU label */             
char *phdr;             /* Pointer to header record */                        
sfdu *psf4;             /* Pointer to smarker SFDU */                         
keyval_t **pkv4;        /* Pointer to smarker keyword/value list */           
{                                                                             
        /* Initialize the keyword/value list pointers */                      
        *pkv2 = *pkv4 = NULL;                                                 
                                                                              
        /* Read the 4 SFDU records and return error code (0=success) */       
        return(scv_rhdr(f,psf1,psf2,pkv2,psf3,&phdr,psf4,pkv4));              
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  anf_allocn                                                                  
                                                                              
  Allocate space for the variable-length fields in the altimetry              
  inversion data records. For each call to anf_allocn(), the user must        
  call anf_freen() to free memory space allocated to the variable             
  length fields. Since the amount of allocated memory space is                
  sufficient to accommodate the largest altimetry inversion data              
  record, this routine need only be called once per orbit                     
                                                                              
  Returns 0 on success                                                        
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
anf_allocn(nr,n,pnh)                                                          
nr_rec *nr;             /* Alt inv data record pointer */                     
int n;                  /* Number of records to read */                       
nh_rec *pnh;            /* Alt inv header record pointer */                   
{                                                                             
        int bsize;      /* Size of scattering and angle vectors */            
        int nsize;      /* Size of covariance matrix */                       
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and allocate maximum necessary space for each         
           variable-length field in each data record */                       
                                                                              
        bsize = pnh->nh_maxB*sizeof(float);                                   
        nsize = pnh->nh_maxN*sizeof(float);                                   
                                                                              
        for (i=0;i<n;i++) {                                                   
                if ((nr[i].nr_sig0 = (float *) malloc(bsize)) == NULL) {      
                       return(1);                                             
                }                                                             
                if ((nr[i].nr_ang = (float *) malloc(bsize)) == NULL) {       
                       return(2);                                             
                }                                                             
                if ((nr[i].nr_cvm = (float *) malloc(nsize)) == NULL) {       
                       return(3);                                             
                }                                                             
        }                                                                     
                                                                              
        return(0);                                                            
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  anf_readn                                                                   
                                                                              
  Read a given number of altimetry inversion data records from the ANF        
  file.  The user is responsible for not trying to read more records          
  than exist in the ANF file. The user must have already called               
  hdr_read() so that the file pointer is pointing to the altimetry            
  inversion data records. The user must have already allocated memory         
  for the fixed-length and variable-length portions of the data               
  records. Reading the records one at a time is certainly permissible         
                                                                              
  Returns the number of records successfully read                             
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
anf_readn(f,nr,n)                                                             
FILE *f;                /* ANF file pointer */                                
nr_rec *nr;             /* Alt inv data record pointer */                     
int n;                  /* Number of records to read */                       
{                                                                             
        ulong rsize;    /* Size of fixed portion of record */                 
        int vsize;      /* Size of vector */                                  
        int nread = 0;  /* Number of records read */                          
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and read fixed portion of altimetry inversion         
           data records plus scattering function, solution angles and         
           covariance matrix */                                               
                                                                              
        for (i=0,rsize=(ulong)&nr->nr_sig0-(ulong)nr;i<n;i++) {               
                                                                              
                if (fread(&nr[i],rsize,1,f) != 1) {                           
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = nr[i].nr_blen*sizeof(float);                          
                if (fread(nr[i].nr_sig0,vsize,1,f) != 1) {                    
                        return(nread);                                        
                }                                                             
                                                                              
                if (fread(nr[i].nr_ang,vsize,1,f) != 1) {                     
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = nr[i].nr_ncvm*sizeof(float);                          
                if (fread(nr[i].nr_cvm,vsize,1,f) != 1) {                     
                        return(nread);                                        
                }                                                             
                                                                              
                nread++;                                                      
        }                                                                     
                                                                              
        return(nread);                                                        
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  anf_freen                                                                   
                                                                              
  Free the memory space for variable length fields in n altimetry             
  inversion data records which was allocated in anf_allocn(). This            
  function must be called once for each call to anf_allocn()                  
                                                                              
***********************************************************************/      
                                                                              
anf_freen(nr,n)                                                               
nr_rec *nr;             /* Alt inv data record pointer */                     
int n;                  /* Number of records to free */                       
{                                                                             
        int i;          /* Counter */                                         
                                                                              
        /* For each data record, free the space from the scattering           
           function, angle vector and covariance matrix */                    
                                                                              
        for (i=0;i<n;i++) {                                                   
                free(nr[i].nr_sig0);                                          
                free(nr[i].nr_ang);                                           
                free(nr[i].nr_cvm);                                           
        }                                                                     
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  nff_allocn                                                                  
                                                                              
  Allocate space for the variable-length fields in the inversion fit          
  data records. For each call to nff_allocn(), the user must call             
  nff_freen() to free memory space allocated to the variable length           
  fields. Since the amount of allocated memory space is sufficient to         
  accommodate the largest inversion fit data record, this routine need        
  only be called once per orbit                                               
                                                                              
  Returns 0 on success                                                        
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
nff_allocn(fr,n,pfh)                                                          
fr_rec *fr;             /* Inv fit data record pointer */                     
int n;                  /* Number of records to read */                       
fh_rec *pfh;            /* Inv fit header record pointer */                   
{                                                                             
        int fsize;      /* Size of fit results */                             
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and allocate maximum necessary space for each         
           set of fit results */                                              
                                                                              
        fsize = pfh->fh_nlaw*sizeof(fr_sslf_t);                               
                                                                              
        for (i=0;i<n;i++) {                                                   
                if ((fr[i].fr_sslf = (fr_sslf_t *) malloc(fsize))             
                                == NULL) {                                    
                        return(1);                                            
                }                                                             
        }                                                                     
                                                                              
        return(0);                                                            
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  nff_readn                                                                   
                                                                              
  Read a given number of inversion fit data records from the NFF file.        
  The user is responsible for not trying to read more records than exist      
  in the NFF file. The user must have already called hdr_read() so that       
  the file pointer is pointing to the inversion fit data records. The         
  user must have already allocated memory for the fixed-length and            
  variable-length portions of the data records.  Reading the records one      
  at a time is certainly permissible                                          
                                                                              
  Returns the number of records successfully read                             
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
nff_readn(f,fr,n)                                                             
FILE *f;                /* NFF file pointer */                                
fr_rec *fr;             /* Inversion fit data record pointer */               
int n;                  /* Number of records to read */                       
{                                                                             
        ulong rsize;    /* Size of fixed portion of record */                 
        int vsize;      /* Size of vector */                                  
        int nread = 0;  /* Number of records read */                          
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and read fixed portion of inversion fit               
           data records plus fit results for all scattering laws */           
                                                                              
        for (i=0,rsize=(ulong)&fr->fr_sslf-(ulong)fr;i<n;i++) {               
                                                                              
                if (fread(&fr[i],rsize,1,f) != 1) {                           
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = fr[i].fr_nlaw*sizeof(fr_sslf_t);                      
                if (fread(fr[i].fr_sslf,vsize,1,f) != 1) {                    
                        return(nread);                                        
                }                                                             
                                                                              
                nread++;                                                      
        }                                                                     
                                                                              
        return(nread);                                                        
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  nff_freen                                                                   
                                                                              
  Free the memory space for variable length fields in n inversion fit         
  data records which was allocated in nff_allocn(). This function must        
  be called once for each call to nff_allocn()                                
                                                                              
***********************************************************************/      
                                                                              
nff_freen(fr,n)                                                               
fr_rec *fr;             /* Inversion fit data record pointer */               
int n;                  /* Number of records to free */                       
{                                                                             
        int i;          /* Counter */                                         
                                                                              
        /* For each data record, free the space for the scattering law        
           fit results */                                                     
                                                                              
        for (i=0;i<n;i++) {                                                   
                free(fr[i].fr_sslf);                                          
        }                                                                     
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  sif_oif_allocn                                                              
                                                                              
  Allocate space for the variable-length fields in the image data             
  records. For each call to sif_oif_allocn(), the user must call              
  sif_oif_freen() to free memory space allocated to the variable length       
  fields. Since the amount of allocated memory space is sufficient to         
  accommodate the largest image data record, this routine need only be        
  called once per orbit                                                       
                                                                              
  Returns 0 on success                                                        
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
sif_oif_allocn(ir,n,pih)                                                      
ir_rec *ir;             /* Image data record pointer */                       
int n;                  /* Number of records to read */                       
ih_rec *pih;            /* Image header record pointer */                     
{                                                                             
        int bsize;      /* Size of backscatter vector */                      
        int isize;      /* Size of histogram vector */                        
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and allocate maximum necessary space for each         
           variable-length field in each data record */                       
                                                                              
        bsize = pih->ih_maxB*sizeof(bin_t);                                   
        isize = pih->ih_maxI*sizeof(ulong);                                   
                                                                              
        for (i=0;i<n;i++) {                                                   
                if ((ir[i].ir_bins = (bin_t *) malloc(bsize))==NULL) {        
                        return(1);                                            
                }                                                             
                if ((ir[i].ir_I_count=(ulong *)malloc(isize))==NULL) {        
                        return(2);                                            
                }                                                             
        }                                                                     
                                                                              
        return(0);                                                            
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  sif_oif_readn                                                               
                                                                              
  Read a given number of image data records from the SIF/OIF file.  The       
  user is responsible for not trying to read more records than exist in       
  the image file. The user must have already called hdr_read() so that        
  the file pointer is pointing to the image data records. The user must       
  have already allocated memory for the fixed-length and variable-length      
  portions of the data records.  Reading the records one at a time is         
  certainly permissible                                                       
                                                                              
  Returns the number of records successfully read                             
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
sif_oif_readn(f,ir,n)                                                         
FILE *f;                /* SIF/OIF file pointer */                            
ir_rec *ir;             /* Image data record pointer */                       
int n;                  /* Number of records to read */                       
{                                                                             
        ulong rsize;    /* Size of fixed portion of record */                 
        int vsize;      /* Size of vector */                                  
        int nread = 0;  /* Number of records read */                          
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and read fixed portion of image data records          
           plus backscatter data and histogram of pixel values */             
                                                                              
        for (i=0,rsize=(ulong)&ir->ir_bins-(ulong)ir;i<n;i++) {               
                                                                              
                if (fread(&ir[i],rsize,1,f) != 1) {                           
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = ir[i].ir_nth*sizeof(bin_t);                           
                if (fread(ir[i].ir_bins,vsize,1,f) != 1) {                    
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = ir[i].ir_nI*sizeof(ulong);                            
                if (fread(ir[i].ir_I_count,vsize,1,f) != 1) {                 
                        return(nread);                                        
                }                                                             
                                                                              
                nread++;                                                      
        }                                                                     
                                                                              
        return(nread);                                                        
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  sif_oif_freen                                                               
                                                                              
  Free the memory space for variable length fields in n image data            
  records which was allocated in sif_oif_allocn(). This function must be      
  called once for each call to sif_oif_allocn()                               
                                                                              
***********************************************************************/      
                                                                              
sif_oif_freen(ir,n)                                                           
ir_rec *ir;             /* Image data record pointer */                       
int n;                  /* Number of records to free */                       
{                                                                             
        int i;          /* Counter */                                         
                                                                              
        /* For each data record, free the space for the backscatter data      
           and histogram of pixel values */                                   
                                                                              
        for (i=0;i<n;i++) {                                                   
                free(ir[i].ir_bins);                                          
                free(ir[i].ir_I_count);                                       
        }                                                                     
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  edf_readn                                                                   
                                                                              
  Read a given number of emissivity data records from the EDF file. The       
  user is responsible for not trying to read more records than exist in       
  the EDF file.  The user must have already called hdr_read() so that         
  the file pointer is pointing to the emissivity data records. The user       
  must have already allocated memory for the data records. Reading the        
  records one at a time is certainly permissible                              
                                                                              
  Returns the number of records successfully read                             
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
edf_readn(f,er,n)                                                             
FILE *f;                /* EDF file pointer */                                
er_rec *er;             /* Emissivity data record pointer */                  
int n;                  /* Number of records to read */                       
{                                                                             
        /* Read emissivity data records */                                    
        return(fread(er,sizeof(er_rec),n,f));                                 
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  gmf_allocn                                                                  
                                                                              
  Allocate space for the variable-length fields in the G-matrix data          
  records.  For each call to gmf_allocn(), the user must call                 
  gmf_freen() to free memory space allocated to the variable length           
  fields. Since the amount of allocated memory space is sufficient to         
  accommodate the largest G-matrix data record, this routine need only        
  be called once per G-matrix file                                            
                                                                              
  Returns 0 on success                                                        
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
gmf_allocn(gr,n,pgh)                                                          
gr_rec *gr;             /* G-matrix data record pointer */                    
int n;                  /* Number of records to read */                       
gh_rec *pgh;            /* G-matrix header record pointer */                  
{                                                                             
        int bsize;      /* Size of angle vector */                            
        int rsize;      /* Size of range vector */                            
        int fsize;      /* Size of frequency vector */                        
        int brsize;     /* Size of angle-range G-matrix */                    
        int bfsize;     /* Size of angle-frequency G-matrix */                
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and allocate maximum necessary space for each         
           variable-length field in each data record */                       
                                                                              
        bsize = pgh->gh_maxB*sizeof(float);                                   
        rsize = pgh->gh_maxR*sizeof(float);                                   
        fsize = pgh->gh_maxF*sizeof(float);                                   
        brsize = pgh->gh_maxBR*sizeof(float);                                 
        bfsize = pgh->gh_maxBF*sizeof(float);                                 
                                                                              
        for (i=0;i<n;i++) {                                                   
                if ((gr[i].gr_b = (float *) malloc(bsize)) == NULL) {         
                        return(1);                                            
                }                                                             
                if ((gr[i].gr_r = (float *) malloc(rsize)) == NULL) {         
                        return(2);                                            
                }                                                             
                if ((gr[i].gr_f = (float *) malloc(fsize)) == NULL) {         
                        return(3);                                            
                }                                                             
                if ((gr[i].gr_gbr = (float *) malloc(brsize))==NULL) {        
                        return(4);                                            
                }                                                             
                if ((gr[i].gr_gbf = (float *) malloc(bfsize))==NULL) {        
                        return(5);                                            
                }                                                             
        }                                                                     
                                                                              
        return(0);                                                            
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  gmf_readn                                                                   
                                                                              
  Read a given number of G-matrix data records from the GMF file.  The        
  user is responsible for not trying to read more records than exist in       
  the GMF file.  The user must have already called hdr_read() so that         
  the file pointer is pointing to the G-matrix data records. The user         
  must have already allocated memory for the fixed-length and                 
  variable-length portions of the data records.  Reading the records          
  one at a time is certainly permissible                                      
                                                                              
  Returns the number of records successfully read                             
                                                                              
***********************************************************************/      
                                                                              
int                                                                           
gmf_readn(f,gr,n)                                                             
FILE *f;                /* ANF file pointer */                                
gr_rec *gr;             /* G-matrix data record pointer */                    
int n;                  /* Number of records to read */                       
{                                                                             
        ulong rsize;    /* Size of fixed portion of record */                 
        int vsize;      /* Size of vector */                                  
        int nread = 0;  /* Number of records read */                          
        int i;          /* Counter */                                         
                                                                              
        /* Loop through and read fixed portion of G-matrix data               
           records plus angle vector, range vector, frequency vector,         
           angle-range G-matrix and angle-Doppler G-matrix */                 
                                                                              
        for (i=0,rsize=(ulong)&gr->gr_b-(ulong)gr;i<n;i++) {                  
                                                                              
                if (fread(&gr[i],rsize,1,f) != 1) {                           
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = gr[i].gr_blen*sizeof(float);                          
                if (fread(gr[i].gr_b,vsize,1,f) != 1) {                       
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = gr[i].gr_rlen*sizeof(float);                          
                if (fread(gr[i].gr_r,vsize,1,f) != 1) {                       
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = gr[i].gr_flen*sizeof(float);                          
                if (fread(gr[i].gr_f,vsize,1,f) != 1) {                       
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = (gr[i].gr_blen*gr[i].gr_rlen)*sizeof(float);          
                if (fread(gr[i].gr_gbr,vsize,1,f) != 1) {                     
                        return(nread);                                        
                }                                                             
                                                                              
                vsize = (gr[i].gr_blen*gr[i].gr_flen)*sizeof(float);          
                if (fread(gr[i].gr_gbf,vsize,1,f) != 1) {                     
                        return(nread);                                        
                }                                                             
                                                                              
                nread++;                                                      
        }                                                                     
                                                                              
        return(nread);                                                        
}                                                                             
                                                                              
/***********************************************************************      
                                                                              
  gmf_freen                                                                   
                                                                              
  Free the memory space for variable length fields in n G-matrix data         
  records which was allocated in gmf_allocn(). This function must be          
  called once for each call to gmf_allocn()                                   
                                                                              
***********************************************************************/      
                                                                              
gmf_freen(gr,n)                                                               
gr_rec *gr;             /* G-matrix data record pointer */                    
int n;                  /* Number of records to free */                       
{                                                                             
        int i;          /* Counter */                                         
                                                                              
        /* For each data record, free the space from the angle vector,        
           range vector, frequency vector, angle-range G-matrix and           
           angle-Doppler G-matrix */                                          
                                                                              
        for (i=0;i<n;i++) {                                                   
                free(gr[i].gr_b);                                             
                free(gr[i].gr_r);                                             
                free(gr[i].gr_f);                                             
                free(gr[i].gr_gbr);                                           
                free(gr[i].gr_gbf);                                           
        }                                                                     
}                                                                             
                                                                              
/**********************************************************************/