g2_unpack3.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include "grib2.h"
 
g2int
g2_unpack3(unsigned char *cgrib, g2int *iofst, g2int **igds, g2int **igdstmpl,
           g2int *mapgridlen, g2int **ideflist, g2int *idefnum)
{
    g2int ierr, i, j, nbits, isecnum;
    g2int lensec, ibyttem = 0, isign, newlen;
    g2int *ligds, *ligdstmpl = NULL, *lideflist = NULL;
    gtemplate *mapgrid;
 
    ierr = 0;
    *igds = NULL;
    *igdstmpl = NULL;
    *ideflist = NULL;
 
    gbit(cgrib, &lensec, *iofst, 32);        /* Get Length of Section */
    *iofst = *iofst + 32;
    gbit(cgrib, &isecnum, *iofst, 8);         /* Get Section Number */
    *iofst = *iofst + 8;
 
    if (isecnum != 3)
    {
        ierr = 2;
        *idefnum = 0;
        *mapgridlen = 0;
        /* fprintf(stderr, "g2_unpack3: Not Section 3 data.\n"); */
        return(ierr);
    }
 
    ligds = calloc(5, sizeof(g2int));
    *igds = ligds;
 
    gbit(cgrib, &ligds[0], *iofst, 8);     /* Get source of Grid def. */
    *iofst = *iofst + 8;
    gbit(cgrib, &ligds[1], *iofst, 32);    /* Get number of grid pts. */
    *iofst = *iofst + 32;
    gbit(cgrib, &ligds[2], *iofst, 8);     /* Get num octets for opt. list */
    *iofst = *iofst + 8;
    gbit(cgrib, &ligds[3], *iofst, 8);     /* Get interpret. for opt. list */
    *iofst = *iofst + 8;
    gbit(cgrib, &ligds[4], *iofst, 16);    /* Get Grid Def Template num. */
    *iofst = *iofst + 16;
 
    if (ligds[4] != 65535)
    {
        /*   Get Grid Definition Template */
        mapgrid = getgridtemplate(ligds[4]);
        if (!mapgrid)
        {         /* undefined template */
            ierr = 5;
            return(ierr);
        }
        *mapgridlen = mapgrid->maplen;
 
        /*   Unpack each value into array igdstmpl from the the
         *   appropriate number of octets, which are specified in
         *   corresponding entries in array mapgrid. */
        if (*mapgridlen > 0)
        {
            if (!(ligdstmpl = calloc(*mapgridlen, sizeof(g2int))))
            {
                ierr = 6;
                *mapgridlen = 0;
                *igdstmpl = NULL;
                if (mapgrid)
                    free(mapgrid);
                return(ierr);
            }
            *igdstmpl = ligdstmpl;
        }
        ibyttem = 0;
        for (i = 0; i < *mapgridlen; i++)
        {
            nbits = abs(mapgrid->map[i]) * 8;
            if (mapgrid->map[i] >= 0)
            {
                gbit(cgrib, ligdstmpl + i, *iofst, nbits);
            }
            else
            {
                gbit(cgrib, &isign, *iofst, 1);
                gbit(cgrib, ligdstmpl + i, *iofst + 1, nbits - 1);
                if (isign == 1)
                    ligdstmpl[i] = -1 * ligdstmpl[i];
            }
            *iofst = *iofst + nbits;
            ibyttem = ibyttem + abs(mapgrid->map[i]);
        }
 
        /*   Check to see if the Grid Definition Template needs to be
         *   extended. The number of values in a specific template may
         *   vary depending on data specified in the "static" part of
         *   the gtemplate. */
        if (mapgrid->needext == 1)
        {
            free(mapgrid);
            mapgrid = extgridtemplate(ligds[4], ligdstmpl);
            /*   Unpack the rest of the Grid Definition Template */
            newlen = mapgrid->maplen + mapgrid->extlen;
            ligdstmpl = realloc(ligdstmpl, newlen * sizeof(g2int));
            *igdstmpl = ligdstmpl;
            j = 0;
            for (i = *mapgridlen; i < newlen; i++)
            {
                nbits = abs(mapgrid->ext[j]) * 8;
                if (mapgrid->ext[j] >= 0)
                {
                    gbit(cgrib, ligdstmpl + i, *iofst, nbits);
                }
                else
                {
                    gbit(cgrib, &isign, *iofst, 1);
                    gbit(cgrib, ligdstmpl + i, *iofst + 1, nbits - 1);
                    if (isign == 1)
                        ligdstmpl[i] = -1 * ligdstmpl[i];
                }
                *iofst = *iofst + nbits;
                ibyttem = ibyttem + abs(mapgrid->ext[j]);
                j++;
            }
            *mapgridlen = newlen;
        }
        if (mapgrid->ext)
            free(mapgrid->ext);
        if (mapgrid)
            free(mapgrid);
    }
    else
    {              /* No Grid Definition Template */
        *mapgridlen = 0;
        *igdstmpl = 0;
    }
 
    /* Unpack optional list of numbers defining number of points in
     * each row or column, if included.  This is used for non
     * regular grids. */
    if ( ligds[2] != 0 )
    {
        nbits = ligds[2] * 8;
        *idefnum = (lensec - 14 - ibyttem) / ligds[2];
        if (*idefnum > 0)
            lideflist = calloc(*idefnum, sizeof(g2int));
        if (!lideflist)
        {
            ierr = 6;
            *idefnum = 0;
            *ideflist = NULL;
            return(ierr);
        }
        *ideflist = lideflist;
        gbits(cgrib, lideflist, *iofst, nbits, 0, *idefnum);
        *iofst = *iofst + (nbits * *idefnum);
    }
    else
    {
        *idefnum = 0;
        *ideflist = NULL;
    }
 
    return(ierr);    /* End of Section 3 processing */
}