bitio.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:          BITIO.C
IDENT:         $Id: bitio.c,v 1.6 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

AMENDMENT RECORD:

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

Revision 1.5  2007/12/07 08:35:46  fuxi
update to version 3.0

Revision 1.4  2005/04/04 14:58:39  helmutp
update to version 2.3

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 <memory.h>
#include "desc.h"
#include "bufr.h"
#include "bitio.h"

/*===========================================================================*/
/* functions for bit-io follow:                                   */
/*===========================================================================*/

/* internal data and definitions needed to hold the bitstreams: */

#define MAXIOSTR    10                 /* Max. number of streams that can be 
                                          open simultaneously */
#define INCSIZE     1000               /* for holding a bitstream the open-
                                          function allocates INCSIZE bytes of
                                          memory. When outputing to the 
                                          bitstream and the size of the
                                          memoryblocks exceeds subsequent 
                                          blocks with INCSIZE bytes are
                                          allocated to hold the bitstream. This
                                          is done by a realloc of the buffer. */

typedef struct bitio_stream {          /* structure that defines a bitstrem */
  int used;                            /* identifier if the bitstream is used */
  char *buf;                           /* buffer holding the bitstream */
  long nbits;                          /* currend size of bitstream (counted 
                                          in bits !) */
  size_t size;                         /* current size of allocated memory for
                                          holding the bitstream. */
} bitio_stream;

bitio_stream bios[MAXIOSTR];          /* Data describing MAXIOSTR bitstreams */
int first = 1;                         /* to indicate the first call to one of these functions */

/*===========================================================================*/
int bitio_i_open (void* buf, size_t size)
{
  int i, handle;

  /* On the first call mark all bitstreams as unused */

  if (first) {
    for (i = 0; i < MAXIOSTR; i ++) bios[i].used = 0;
    first = 0;
  }

  /* search for an unused stream. */

  for (handle = 0; handle < MAXIOSTR; handle ++) {
    if (!bios[handle].used) goto found;
  }
  return -1;

  /* unused bitstream found -> initialize bitstream-data */

found:
  bios[handle].used = 1;
  bios[handle].buf = (char *) buf;
  bios[handle].size = size;
  bios[handle].nbits = 0;                 /* Holds the current bitposition */
  return handle;
}

/*===========================================================================*/
int bitio_i_input (int handle, unsigned long* val, int nbits)
{
  int i, bit;
  size_t byte;
  unsigned long l, bitval;
  char *pc;

  
  l = 0;
  for (i = nbits - 1; i >= 0; i --) {

      /* calculate bit- and byte-number for input and check if bytenumber is
         in a valid range */

      byte = (int) (bios[handle].nbits / 8);
      bit  = (int) (bios[handle].nbits % 8);
      bit = 7 - bit;
      if (byte >= bios[handle].size) return 1;

      /* get bit-value from input-stream */

      pc = bios[handle].buf + byte;
      bitval = (unsigned long) ((*pc >> bit) & 1);

      /* Set a 1-bit in the data value, 0-bits need not to be set, as L has
         been initialized to 0 */

      if (bitval) {
          l |= (bitval << i);
      }
      bios[handle].nbits ++;
  }
  *val = l;
  return 1;
}

/*===========================================================================*/
void bitio_i_close (int handle)

{
  bios[handle].used = 0;
}

/*===========================================================================*/
int bitio_o_open ()

{
  int i, handle;

  /* On the first call mark all bitstreams as unused */

  if (first) {
    for (i = 0; i < MAXIOSTR; i ++) bios[i].used = 0;
    first = 0;
  }

  /* search for an unused stream. */

  for (handle = 0; handle < MAXIOSTR; handle ++) {
    if (!bios[handle].used) goto found;
  }
  return -1;

  /* unused bitstream found -> initalize it and allocate memory for it */

found:
  bios[handle].buf = (char *) malloc (INCSIZE);
  if (bios[handle].buf == NULL) return -1;
  memset (bios[handle].buf, 0, INCSIZE);
  bios[handle].used = 1;
  bios[handle].nbits = 0;
  bios[handle].size = INCSIZE;

  return handle;
}

/*===========================================================================*/
long bitio_o_append (int handle, unsigned long val, int nbits)

{
    /* Check if bitstream is allready initialized and number of bits does not
       exceed sizeof (unsigned long). */

  assert (bios[handle].used);
  assert (sizeof (unsigned long) * 8 >= nbits);

  /* check if there is enough memory to store the new value. Reallocate
     the memory-block if not */

  if ((bios[handle].nbits + nbits) / 8 + 1 > (long) bios[handle].size) {
    bios[handle].buf = realloc (bios[handle].buf, bios[handle].size + INCSIZE);
    if (bios[handle].buf == NULL) return 0;
        memset (bios[handle].buf + bios[handle].size, 0, INCSIZE);
    bios[handle].size += INCSIZE;
  }

  /* output data to bitstream */

  bitio_o_outp (handle, val, nbits, bios[handle].nbits);
  bios[handle].nbits += nbits;

  return bios[handle].nbits;
}

/*===========================================================================*/
void bitio_o_outp (int handle, unsigned long val, int nbits, long bitpos)

{
  int i, bit, bitval;
  size_t byte;
  char *pc, c;

  /* Check if bitstream is allready initialized and number of bits does not
     exceed sizeof (unsigned long). */

  assert (bios[handle].used);
  assert (sizeof (unsigned long) * 8 >= nbits);

  for (i = nbits - 1; i >= 0; i --) {

      /* Get bit-value */

    bitval = (int) (val >> i) & 1;

    /* calculate bit- and byte-number for output */

    byte = (int) (bitpos / 8);
    bit  = (int) (bitpos % 8);
    bit  = 7 - bit;

    /* set bit-value to output stream */

    pc = bios[handle].buf + byte;
    if (bitval) {
      c = (char) (1 << bit);
      *pc |= c;
    }
    else {
      c = (char) (1 << bit);
      c ^= 0xff;
      *pc &= c;
    }
    bitpos ++;
  }
}

/*===========================================================================*/
size_t bitio_o_get_size (int handle)

{
  if (!bios[handle].used) return 0;

  return (size_t) ((bios[handle].nbits - 1) / 8 + 1);
}


/*===========================================================================*/
void *bitio_o_close (int handle, size_t* nbytes)
{

  if (!bios[handle].used) return NULL;

/* Fill up the last byte with 0-bits */

  while (bios[handle].nbits % 8 != 0) bitio_o_append (handle, 0, 1);

  *nbytes = (size_t) ((bios[handle].nbits - 1) / 8 + 1);
  bios[handle].used = 0;
  return (void *) bios[handle].buf;
}

/* end of file */

---