src/gdcmjpegls/Encoder/bitio.h

   1 /* SPMG/JPEG-LS IMPLEMENTATION V.2.1
   2    =====================================
   3    These programs are Copyright (c) University of British Columbia. All rights reserved.
   4    They may be freely redistributed in their entirety provided that this copyright
   5    notice is not removed. THEY MAY NOT BE SOLD FOR PROFIT OR INCORPORATED IN
   6    OMMERCIAL PROGRAMS WITHOUT THE WRITTEN PERMISSION OF THE COPYRIGHT HOLDER.
   7    Each program is provided as is, without any express or implied warranty,
   8    without even the warranty of fitness for a particular purpose.
   9
  10    =========================================================
  11    THIS SOFTWARE IS BASED ON HP's implementation of jpeg-ls:
  12    =========================================================
  13
  14    LOCO-I/JPEG-LS IMPLEMENTATION V.0.90
  15    -------------------------------------------------------------------------------
  16    (c) COPYRIGHT HEWLETT-PACKARD COMPANY, 1995-1999.
  17         HEWLETT-PACKARD COMPANY ("HP") DOES NOT WARRANT THE ACCURACY OR
  18    COMPLETENESS OF THE INFORMATION GIVEN HERE.  ANY USE MADE OF, OR
  19    RELIANCE ON, SUCH INFORMATION IS ENTIRELY AT USER'S OWN RISK.
  20         BY DOWNLOADING THE LOCO-I/JPEG-LS COMPRESSORS/DECOMPRESSORS
  21    ("THE SOFTWARE") YOU AGREE TO BE BOUND BY THE TERMS AND CONDITIONS
  22    OF THIS LICENSING AGREEMENT.
  23         YOU MAY DOWNLOAD AND USE THE SOFTWARE FOR NON-COMMERCIAL PURPOSES
  24    FREE OF CHARGE OR FURTHER OBLIGATION.  YOU MAY NOT, DIRECTLY OR
  25    INDIRECTLY, DISTRIBUTE THE SOFTWARE FOR A FEE, INCORPORATE THIS
  26    SOFTWARE INTO ANY PRODUCT OFFERED FOR SALE, OR USE THE SOFTWARE
  27    TO PROVIDE A SERVICE FOR WHICH A FEE IS CHARGED.
  28         YOU MAY MAKE COPIES OF THE SOFTWARE AND DISTRIBUTE SUCH COPIES TO
  29    OTHER PERSONS PROVIDED THAT SUCH COPIES ARE ACCOMPANIED BY
  30    HEWLETT-PACKARD'S COPYRIGHT NOTICE AND THIS AGREEMENT AND THAT
  31    SUCH OTHER PERSONS AGREE TO BE BOUND BY THE TERMS OF THIS AGREEMENT.
  32         THE SOFTWARE IS NOT OF PRODUCT QUALITY AND MAY HAVE ERRORS OR DEFECTS.
  33    THE JPEG-LS STANDARD IS STILL UNDER DEVELOPMENT. THE SOFTWARE IS NOT A
  34    FINAL OR FULL IMPLEMENTATION OF THE STANDARD.  HP GIVES NO EXPRESS OR
  35    IMPLIED WARRANTY OF ANY KIND AND ANY IMPLIED WARRANTIES OF
  36    MERCHANTABILITY AND FITNESS FOR PURPOSE ARE DISCLAIMED.
  37         HP SHALL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
  38    OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE.
  39    -------------------------------------------------------------------------------
  40 */
  41
  42 /* bitio.h --- for I/O routines
  43  *
  44  * Initial code by Alex Jakulin,  Aug. 1995
  45  *
  46  * Modified and optimized: Gadiel Seroussi, October 1995
  47  *
  48  * Color Enhancement: Guillermo Sapiro, August 1996
  49  *
  50  * Modified and added Restart marker and input tables by:
  51  * David Cheng-Hsiu Chu, and Ismail R. Ismail march 1999
  52  */
  53
  54 #ifndef BITIO_H
  55 #define BITIO_H
  56
  57 #include "global.h"
  58
  59 /* BYTE I/O variables */
  60 #define BUFSIZE ((16*1024)-4) /* Size of input BYTE buffer */
  61 extern int fp;                /* index into byte  buffer */
  62 extern int truebufsize;       /* true size of byte buffer ( <= BUFSIZE) */
  63 extern byte negbuff[];        /* the buffer */
  64 #define buff (negbuff+4)
  65
  66
  67 /* BIT I/O variables */
  68 extern dword reg;         /* BIT buffer for input/output */
  69 extern int bits;          /* number of bits free in bit buffer (on output) */
  70                           /* (number of bits free)-8 in bit buffer (on input)*/
  71 #define BITBUFSIZE (8*sizeof(reg))
  72
  73 extern FILE *in, *out;
  74
  75 #define myputc(c, fil) ((fp >= BUFSIZE) ? (flushbuff(fil), buff[fp++] = c) :\
  76                                                         (buff[fp++] = c))
  77
  78 extern void flushbuff(FILE *fil);
  79
  80
  81 /* Flushes the bit output buffers and closes the output file */
  82 extern void bitoflush();
  83
  84
  85 #define put_zeros(n)                                          \
  86 {                                                             \
  87         bits -= n;                                            \
  88         while (bits <= 24) {                                  \
  89                 if (fp >= BUFSIZE) {                          \
  90                         fwrite(buff, 1, fp, out);             \
  91                         fp = 0;                               \
  92                 }                                             \
  93                 buff[fp++] = reg >> 24;                       \
  94                 reg <<= 8;                                    \
  95                 bits += 8;                                    \
  96         }                                                     \
  97 }
  98
  99 #define PUT_ZEROS(n) put_zeros(n)
 100
 101
 102 #define put_ones(n)                                             \
 103 {                                                               \
 104   if ( n < 24 ) {            \
 105       putbits((1<<n)-1,n);        \
 106   }              \
 107   else {              \
 108       register unsigned nn = n;        \
 109       while ( nn >= 24 ) {        \
 110     putbits((1<<24)-1,24);        \
 111     nn -= 24;          \
 112       }              \
 113       if ( nn ) putbits((1<<nn)-1,nn);      \
 114   }              \
 115 }
 116
 117 #define PUT_ONES(n) put_ones(n)
 118
 119
 120 /*
 121  * Put an n-bit number x in the output stream (inline code).
 122  * Check for output bytes of the form 0xff and stuff
 123  * a 0 bit following each one.
 124  */
 125
 126 #define putbits(x, n)                                           \
 127 {                \
 128   assert(n <= 24 && n >= 0 && ((1<<n)>x));    \
 129         bits -= n;                                              \
 130         reg |= x << bits;                                       \
 131         while (bits <= 24) {                                     \
 132       register unsigned int outbyte;    \
 133             if (fp >= BUFSIZE) {                           \
 134         fwrite(buff, 1, fp, out);       \
 135         fp = 0;                         \
 136       }                                       \
 137             outbyte = (buff[fp++] = (reg >> 24) );    \
 138       if ( outbyte == 0xff ) {    \
 139         bits += 7;      \
 140         reg <<= 7;      \
 141                                 /* stuff a 0 at MSB */          \
 142         reg &= ~(1<<(8*sizeof(reg)-1)); \
 143       }          \
 144       else {          \
 145         bits += 8;                      \
 146         reg <<= 8;                      \
 147       }          \
 148         }                                                       \
 149 }
 150
 151
 152 #define PUTBITS(x,n) putbits(x,n)
 153
 154
 155 /* Initializes the bit output routines */
 156 extern void bitoinit();
 157
 158
 159 #endif /* BITIO_H */