rlenc.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------

    BUFR encoding and decoding software and library
    Copyright (c) 2007,  Institute of Broadband Communication, TU-Graz
    on behalf of EUMETNET OPERA, http://www.knmi.nl/opera

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; version 2.1 
    of the License.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 

----------------------------------------------------------------------------

FILE:          RLENC.C
IDENT:         $Id: rlenc.c,v 1.7 2007/12/18 14:40:13 fuxi Exp $

AUTHOR:        Konrad Koeck
               Institute of Communication and Wave Propagation, 
               Technical University Graz, Austria

VERSION NUMBER:3.0

DATE CREATED:  18-DEC-2001

STATUS:        DEVELOPMENT FINISHED


FUNCTIONAL DESCRIPTION:
-----------------------

Functions to encode and decode an "n byte per pixel" radar image to
to and from BUFR runlength-code

AMENDMENT RECORD:

ISSUE       DATE            SCNREF      CHANGE DETAILS
-----       ----            ------      --------------
V2.0        18-DEC-2001     Koeck       Initial Issue

$Log: rlenc.c,v $
Revision 1.7  2007/12/18 14:40:13  fuxi
added licence header

Revision 1.6  2007/12/07 08:35:21  fuxi
update to version 3.0

Revision 1.5  2005/04/04 14:57:28  helmutp
update to version 2.3

Revision 1.4  2004/03/04 13:38:30  kon
change the buffer length from 1000 to 2000

Revision 1.3  2003/03/27 17:17:39  helmutp
update to version 2.2

Revision 1.2  2003/03/06 17:12:32  helmutp
update to version 2.1

Revision 1.1  2003/02/28 13:41:12  helmutp
Initial revision

--------------------------------------------------------------------------- */
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "desc.h"
#include "bufr.h"
#include "rlenc.h"

#define LBUFLEN 5000         
#define ENCBUFL 5000         
/*===========================================================================*/

int rlenc (char* infile, int nrows, int ncols, varfl** vals, size_t* nvals)

{
  FILE *fp;
  unsigned char buf[LBUFLEN];
  int i, n;

/* check if the internal buffer is large enough to hold one uncompressed
         line */

  assert (ncols <= LBUFLEN);

/* open file holding the radar image */

  fp = fopen (infile, "rb");
  if (fp == NULL) {
    fprintf (stderr, "error opening '%s'\n", infile);
    return 0;
  }

/* output number of rows */

  val_to_array (vals, (varfl) nrows, nvals);  

/* compress line by line */

  for (i = 0; i < nrows; i ++) {
    n = fread (buf, 1, ncols, fp);
    if (n != ncols) {
      fprintf (stderr, "read error from file '%s'\n", infile);
      goto err;
    }
    if (!rlenc_compress_line (i, buf, ncols, vals, nvals)) goto err;
  }
  fclose (fp);
  return 1;

err:
  fclose (fp);
  return 0;
}


/*===========================================================================*/
int rlenc_compress_line (int line, unsigned char* src, int ncols, 
                         varfl** dvals, size_t* nvals)


{
  int count, i, n, npar, lens[LBUFLEN], cw, ncgi, nngi = 0;
  unsigned char val, lval = 0, vals[LBUFLEN];
  varfl encbuf[ENCBUFL];

  /* compress Line into a runlength format */

  count = n = 0;
  for (i = 0; i < ncols; i ++) {
    val = *(src + i);
    if (i != 0 && (val != lval || count >= 255)) {  /* (n >= 255) to ensure that BUFR-descriptor 0 31 001 does not exceed */
      lens[n] = count;
      vals[n] = lval;
      n ++;
      count = 0;
      lval = val;
    }
    lval = val;
    count ++;
  }
  lens[n] = count;
  vals[n] = lval;
  n ++;
  

  /* line is runlength-compressed now to N parts, each of them identified 
     by a length (LENS) and a value (VALS). */
    

  /* Count number of parcels. One parcel is identified by a COUNT of 1
     followed by a COUNT > 1 */

  npar = 0;
  for (i = 0; i < n - 1; i ++) if (lens[i] == 1 && lens[i+1] > 1) npar ++;
  npar ++;

  /* output line-number */

  for (i = 0; i < ENCBUFL; i ++) encbuf[i] = (varfl) 0.0;
  cw = 0;
  encbuf[cw++] = line;  

  /* compress it to parcels */

  encbuf[cw++] = npar;                   /* number of parcels */

  ncgi = cw ++;                          /* is where the number of compressable groups is stored */
  encbuf[ncgi] = (varfl) 0.0;            /* number of compressable groups */

  i = 0;
  for (i = 0; i < n; i ++) {
    if (lens[i] > 1) {                   /* compressable group found */
      if (i > 0 && lens[i-1] == 1) {     /* A new parcel starts here */
        ncgi = cw ++;                    /* is where the number of compressable groups is stored */
        encbuf[ncgi] = (varfl) 0.0;      /* number of compressable groups */
      }
      encbuf[ncgi] += 1.0;
      encbuf[cw++] = lens[i];
      encbuf[cw++] = vals[i];
    }
    else {                               /* non compressable group found */
      if (i == 0 || lens[i-1] != 1) {    /* this is the first uncompressable group in the current parcel */
        nngi = cw ++;                    /* is where the number of non compressable groups is stored */
        encbuf[nngi] = (varfl) 0.0;      /* Number of non compressable groups */
      }
      encbuf[nngi] += 1.0;
      encbuf[cw++] = vals[i];
    }
  }
  if (lens[n-1] != 1) encbuf[cw++] = 0;  /* number of noncompressable groups in the last parcel = 0 */
  assert (cw <= ENCBUFL);

  /* compresson to parcels finished */


  for (i = 0; i < cw; i ++)
      if (!val_to_array (dvals, encbuf[i], nvals)) return 0;

  /* Output data for debugging purposes */

  /*cw = 0;
  printf ("\n\nline no. %d:\n", (int) encbuf[cw++]);
  npar = (int) encbuf[cw];
  printf ("number of parcels: %d\n", (int) encbuf[cw++]);
  for (i = 0; i < npar; i ++) {
    ncgi = (int) encbuf[cw];
    printf ("number of compressable groups: %d\n", (int) encbuf[cw++]);
    for (j = 0; j < ncgi; j ++) {
      printf ("count: %d\n", (int) encbuf[cw++]);
      printf ("val: %d\n", (int) encbuf[cw++]);
    }
    nngi = (int) encbuf[cw];
    printf ("number of uncompressable pixels: %d\n", (int) encbuf[cw++]);
    for (j = 0; j < nngi; j ++) {
      printf ("val: %d\n", (int) encbuf[cw++]);
    }
  }*/

  return 1;
}

/*===========================================================================*/
int rldec (char* outfile, varfl* vals, size_t* nvals)

{
  FILE *fp;
  int i, j, k, l, ngr, nrows, npar, val, count, nup;
  varfl *ovals;

/* Open destination-file for output */

  fp = fopen (outfile, "wb");
  if (fp == NULL) return 0;

/* decode line by line */

  ovals = vals;
  nrows = (int) *vals ++;               /* number of rows */
  for (i = 0; i < nrows; i ++) {        /* loop for lines */
      vals ++;                            /* skip linenumber */
      npar = (int) *vals ++;              /* number of parcels */
      for (j = 0; j < npar; j ++) {       /* loop for parcels */
          ngr = (int) *vals ++;             /* number of compressable groups */
          for (k = 0; k < ngr; k ++) {      /* loop for compressable groups */
              count = (int) *vals ++;
              val =   (int) *vals ++;
              for (l = 0; l < count; l ++) {  /* loop for length of group */
                  fputc (val, fp);
              }
          }
          nup = (int) *vals ++;             /* number of uncompressable pixels */
          for (k = 0; k < nup; k ++) {      /* loop for uncompressable pixels */
              val = (int) *vals ++;
              fputc (val, fp);
          }
      }
  }

  /* close file */

  fclose (fp);

  /* calculate number of values in VALS occupied by the radar image */

  *nvals = vals - ovals;
  return 1;
}

/*===========================================================================*/
/* New functions */
/*===========================================================================*/

int rlenc_from_file (char* infile, int nrows, int ncols, varfl* *vals, 
                     int *nvals, int depth)

{
    FILE *fp;
    unsigned char cbuf[LBUFLEN * 2];
    unsigned int ibuf[LBUFLEN];
    int i, n, j;

    if (depth > 2) {
        fprintf (stderr, 
                 "Unsupported number of bits per bixel!\n");
        return 0;
    }

    /* check if the internal buffer is large enough to hold one uncompressed
       line */

    if (ncols > LBUFLEN) {
        fprintf (stderr, "ERROR: Number of columns larger than %d!\n",
                 LBUFLEN);
        return 0;
    }

    /* open file holding the radar image */

    fp = fopen (infile, "rb");
    if (fp == NULL) {
        fprintf (stderr, "error opening '%s'\n", infile);
        return 0;
    }

    /* output number of rows */

    bufr_val_to_array (vals, (varfl) nrows, nvals);  

    /* compress line by line */

    for (i = 0; i < nrows; i ++) {

        /* read row from file */

        n = fread (cbuf, 1, ncols * depth, fp);
        if (n != ncols * depth) {
            fprintf (stderr, "read error from file '%s'\n", infile);
            fclose (fp);
            return 0;
        }
            
        /* convert to integer */
        
        if (depth == 1) {

            for (j = 0; j < ncols; j ++)
                ibuf[j] = (unsigned int) cbuf[j];
        } else {
            for (j = 0; j < ncols; j++)
                ibuf[j] = (cbuf[j*2] << 8) + cbuf[j*2+1];
        }

        /* compress line to varfl array */

        if (!rlenc_compress_line_new (i, ibuf, ncols, vals, nvals)) {
            fclose (fp);
            return 0;
        }
    }
    fclose (fp);
    return 1;
}

/*===========================================================================*/
int rldec_to_file (char* outfile, varfl* vals, int depth, int* nvals)

{
    FILE *fp;
    int i, j, nrows, ncols, nc, nv;
    unsigned int ibuf[LBUFLEN];
    unsigned char cbuf[LBUFLEN*2];
    varfl *ovals;

    if (depth > 2) {
        fprintf (stderr, 
                 "Unsupported number of bits per bixel!\n");
        return 0;
    }

    /* Open destination-file for output */

    fp = fopen (outfile, "wb");
    if (fp == NULL) {
        fprintf (stderr, "Could not open file %s!\n", outfile);
        return 0;
    }

    ovals = vals;

    /* get number of rows and columns */

    rldec_get_size (vals, &nrows, &ncols);   

    /* check if the buffer is large enough to hold one uncompressed
       line */

    if (ncols > LBUFLEN) {
        fprintf (stderr, "ERROR: Number of columns larger than %d!\n",
                 LBUFLEN);
        return 0;
    }

    /* skip number of rows */

    *nvals = 0;
    vals ++;
    (*nvals) ++;

    /* decode line by line */

    for (i = 0; i < nrows; i ++) {

        /* decompress line */

        rldec_decompress_line (vals, ibuf, &nc, &nv);

        /* check for correct image size */
        
        if (nc != ncols) {
            fprintf (stderr, "Error in run-length decoding!\n");
            fclose (fp);
            return 0;
        }

        /* increase vals pointer */

        vals += nv;
        (*nvals) += nv;

        /* convert to char */

        if (depth == 1) {
            for (j = 0; j < ncols; j ++)
                cbuf[j] = (unsigned char) ibuf[j];
        } else {
            for (j = 0; j < ncols; j++) {
                cbuf[j*2] = (unsigned char) ((ibuf[j] >> 8) & 0xff);
                cbuf[j*2+1] = (unsigned char) (ibuf[j] & 0xff);
            }
        }

        /* write to file */

        if (fwrite (cbuf, 1, ncols * depth, fp) != (size_t) ncols * depth) {
            fprintf (stderr, "Write error to file '%s'\n", outfile);
            fclose (fp);
            return 0;
        }
    }


    /* close file */

    fclose (fp);

    assert (*nvals == vals - ovals);
    return 1;
}
/*===========================================================================*/
int rlenc_from_mem (unsigned short* img, int nrows, int ncols, varfl* *vals, 
                     int *nvals)

{
    unsigned int ibuf[LBUFLEN];
    int i, j;

    if (img == (unsigned short*) NULL) {
        fprintf (stderr, "Image for rlenc not available!\n");
        return 0;
    }

    /* check if the internal buffer is large enough to hold one uncompressed
       line */

    if (ncols > LBUFLEN) {
        fprintf (stderr, "ERROR: Number of columns larger than %d!\n",
                 LBUFLEN);
        return 0;
    }

    /* output number of rows */

    bufr_val_to_array (vals, (varfl) nrows, nvals);  

    /* compress line by line */

    for (i = 0; i < nrows; i ++) {

        /* get row from memory and convert to int */

        for (j = 0; j < ncols; j ++)
            ibuf[j] = (unsigned int) img[i*ncols+j];
        
        /* compress line to varfl array */

        if (!rlenc_compress_line_new (i, ibuf, ncols, vals, nvals)) {
            return 0;
        }
    }
    return 1;
}

/*===========================================================================*/
int rldec_to_mem (varfl* vals, unsigned short* *img, int* nvals, int* nrows,
                  int* ncols)

{
    int i, j, nc, nv;
    unsigned int ibuf[LBUFLEN];
    varfl *ovals;

    ovals = vals;

    /* get number of rows and columns */

    rldec_get_size (vals, nrows, ncols);   

    /* Allocate memory for image if necessary */

    if (*img == NULL) {
        *img = (unsigned short*) calloc (*nrows * *ncols, 
                                         sizeof (unsigned short));
        if (*img == NULL) {
            fprintf (stderr, "Could not allacote memory for radar image!\n");
            return 0;
        }
    }

    /* check if the buffer is large enough to hold one uncompressed
       line */

    if (*ncols > LBUFLEN) {
        fprintf (stderr, "ERROR: Number of columns larger than %d!\n",
                 LBUFLEN);
        return 0;
    }

    /* skip number of rows */

    *nvals = 0;
    vals ++;
    (*nvals) ++;

    /* decode line by line */

    for (i = 0; i < *nrows; i ++) {

        /* decompress line */

        rldec_decompress_line (vals, ibuf, &nc, &nv);

        /* check for correct image size */
        
        if (nc != *ncols) {
            fprintf (stderr, "Error in run-length decoding!\n");
            return 0;
        }

        /* increase vals pointer */

        vals += nv;
        (*nvals) += nv;

        /* convert to short and write to memory*/

        for (j = 0; j < *ncols; j ++)
            (*img)[i * *ncols + j] = (unsigned short) ibuf[j];
    }

    assert (*nvals == vals - ovals);
    return 1;
}

/*===========================================================================*/
int rlenc_compress_line_new (int line, unsigned int* src, int ncols, 
                             varfl* *dvals, int *nvals)

{
    int count, i, n, npar, lens[LBUFLEN], cw, ncgi, nngi = 0;
    unsigned int val, lval = 0, vals[LBUFLEN];
    varfl encbuf[ENCBUFL];

    /* line is runlength-compressed now to N parts, each of them identified 
       by a length (LENS) and a value (VALS). */

    count = n = 0;
    for (i = 0; i < ncols; i ++) {
        val = *(src + i);
    
        /* limit length of one part to 255 to ensure that descriptor 0 31 001 
           does not exceed */
        if (i != 0 && (val != lval || count >= 255)) {  
            lens[n] = count;
            vals[n] = lval;
            n ++;
            count = 0;
            lval = val;
        }
        lval = val;
        count ++;
    }
    lens[n] = count;
    vals[n] = lval;
    n ++;

    /* Count number of parcels. One parcel is identified by a COUNT of 1
       followed by a COUNT > 1 */

    npar = 0;
    for (i = 0; i < n - 1; i ++) if (lens[i] == 1 && lens[i+1] > 1) npar ++;
    npar ++;

    /* output line-number */

    for (i = 0; i < ENCBUFL; i ++) encbuf[i] = (varfl) 0.0;
    cw = 0;
    encbuf[cw++] = line;  

    /* compress it to parcels */
  
    encbuf[cw++] = npar;                   /* number of parcels */

    ncgi = cw ++;                          /* is where the number of 
                                              compressable groups is stored */
    encbuf[ncgi] = (varfl) 0.0;            /* number of compressable groups */

    i = 0;
    for (i = 0; i < n; i ++) {
        if (lens[i] > 1) {                   /* compressable group found */
            if (i > 0 && lens[i-1] == 1) {   /* A new parcel starts here */
                ncgi = cw ++;                /* where the number of compress-
                                                able groups is stored */
                encbuf[ncgi] = (varfl) 0.0;  /* number of compressable groups*/
            }
            encbuf[ncgi] += 1.0;
            encbuf[cw++] = lens[i];
            encbuf[cw++] = vals[i];
        }
        else {                               /* non compressable group found */
            if (i == 0 || lens[i-1] != 1) {  /* this is the first 
                                                uncompressable group in 
                                                the current parcel */
                nngi = cw ++;                /* is where the number of non 
                                               compressable groups is stored */
                encbuf[nngi] = (varfl) 0.0;  /* Number of non compressable 
                                                groups */
            }
            encbuf[nngi] += 1.0;
            encbuf[cw++] = vals[i];
        }
    }
    if (lens[n-1] != 1) encbuf[cw++] = 0;  /* number of noncompressable 
                                              groups in the last parcel = 0 */
    assert (cw <= ENCBUFL);
    
    /* compresson to parcels finished, write values to destination array */

    for (i = 0; i < cw; i ++) {
        if (!bufr_val_to_array (dvals, encbuf[i], nvals)) 
            return 0;
    }

    return 1;
}

/*===========================================================================*/
void rldec_decompress_line (varfl* vals, unsigned int* dest, int* ncols, 
                            int* nvals) 
{
    int i = 0, j, k, l, count = 0, npar, ngr, nup;
    unsigned int val;
    varfl* ovals;

    ovals = vals;
    vals ++;                          /* skip linenumber */
    npar = (int) *vals ++;            /* number of parcels */
    for (j = 0; j < npar; j ++) {     /* loop for parcels */
        ngr = (int) *vals ++;         /* number of compressable groups */
        for (k = 0; k < ngr; k ++) {  /* loop for compressable groups */
            count = (int) *vals ++;
            if (*vals == MISSVAL) {
                val = 0xFFFF;
                vals ++;
            } else {
                val =   (unsigned int) *vals ++;
            }
            for (l = 0; l < count; l ++) {  /* loop for length of group */
                dest[i++] = val;
            }
        }
        nup = (int) *vals ++;         /* number of uncompressable pixels */
        for (k = 0; k < nup; k ++) {  /* loop for uncompressable pixels */
            if (*vals == MISSVAL) {
                dest[i++] = 0xFFFF;
                vals ++;
            } else {
                dest[i++] = (unsigned int) *vals ++;
            }
        }
    }


    *nvals = vals - ovals;
    *ncols = i;
}

/*===========================================================================*/
void rldec_get_size (varfl* vals, int* nrows, int* ncols)
{
    int npar, ngr, nup, j, k, l, count;
    
    *nrows = (int) *vals ++;            /* number of rows */
    *ncols = 0;
    vals ++;                            /* skip linenumber */
    npar = (int) *vals ++;              /* number of parcels */
    for (j = 0; j < npar; j ++) {       /* loop for parcels */
        ngr = (int) *vals ++;           /* number of compressable groups */
        for (k = 0; k < ngr; k ++)  {   /* loop for compressable groups */
            count = (int) *vals ++;
            vals ++;                                /* skip pixel value */
            for (l = 0; l < count; l ++) {  /* loop for length of group */
                (*ncols) ++;      
            }
        }
        nup = (int) *vals ++;             /* number of uncompressable pixels */
        for (k = 0; k < nup; k ++) {      /* loop for uncompressable pixels */
            vals ++;                              /* skip pixel value */
            (*ncols) ++;
        }
    }
}

/* end of file */

---