src/gdcmjpegls/Decoder/bitio.c

   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    COMMERCIAL 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 /*
  43  *
  44  * Initial code by Alex Jakulin,  Aug. 1995
  45  *
  46  * Modified and optimized: Gadiel Seroussi, October 1995
  47  *
  48  * Modified and added Restart marker and input tables by:
  49  * David Cheng-Hsiu Chu, and Ismail R. Ismail march 1999
  50  */
  51
  52 #include "global.h"
  53 #include "bitio.h"
  54
  55
  56 extern int zeroLUT[];     /* lookup table to find number of leading zeroes */
  57
  58 extern FILE *in, *out;
  59
  60 byte negbuff[BUFSIZE+4];    /* byte I/O buffer, allowing for 4 "negative"
  61                    locations  */
  62
  63 /*
  64  'buff' is defined as 'rawbuff+4' in bitio.h, so that buff[-4]..buff[-1]
  65  are well defined. Those locations are used to "return" data to
  66  the byte buffer when flushing the input bit buffer .
  67  */
  68
  69
  70 int fp;          /* index into byte buffer */
  71 int truebufsize;       /* true size of byte buffer ( <= BUFSIZE) */
  72 int foundeof;
  73
  74 int zeroLUT[256];      /* table to find out number of leading zeros */
  75
  76
  77 /* BIT I/O variables */
  78 dword reg; /* BIT buffer for input/output */
  79 int bits;  /* number of bits free in bit buffer (on output) */
  80      /* (number of bits free)-8 in bit buffer (on input)*/
  81
  82
  83 /****************************************************************************
  84  *  INPUT ROUTINES
  85  *  note: some routines are implemented as preprocessor macros. See bitio.h.
  86  ****************************************************************************/
  87
  88
  89 void bufiinit(FILE *fil) {
  90     /* argument is ignored */
  91     fp = BUFSIZE;
  92     truebufsize = 0;
  93     foundeof = 0;
  94 }
  95
  96
  97 byte fillinbuff(FILE *fil)
  98 {
  99   int i;
 100
 101   /* remember 4 last bytes of current buffer (for "undo") */
 102   for ( i=-4; i<0; i++ )
 103     buff[i] = buff[fp+i];
 104         truebufsize = fread(buff, 1, BUFSIZE, fil);
 105   if ( truebufsize < BUFSIZE )
 106   {
 107       if ( truebufsize <= 0 )
 108     {
 109       if ( foundeof )
 110       {  /* second attempt to read past EOF */
 111         fprintf(stderr,"*** Premature EOF in compressed file\n");
 112         exit(10);
 113       }
 114       else
 115       {
 116         /* One attempt to read past EOF is OK  */
 117         foundeof = 1;
 118       }
 119       }
 120       /* fill buffer with zeros */
 121       memset(buff+truebufsize, 0, (BUFSIZE-truebufsize)*sizeof(*buff));
 122   }
 123
 124   fp = 1;
 125     return buff[0];
 126 }
 127
 128
 129 /* Initializes the bit input routines */
 130 void bitiinit() {
 131         bits = reg = 0;
 132         fillbuffer(24);
 133 }
 134
 135
 136 /*
 137    Flush the input bit buffer TO A BYTE BOUNDARY. Return unused whole
 138    bytes to the byte buffer
 139  */
 140 void bitiflush()  {
 141     int filled,
 142   discard,
 143   dbytes,
 144   i, k, treg;
 145     byte *bp;
 146
 147     filled = 24 - bits;    /* how many bits at the MS part of reg
 148             have unused data. These correspond to
 149             at most filled+2 bits from the input
 150             stream, as at most 2 '0' bits might have
 151             been dropped by marker processing */
 152
 153     dbytes = (filled+2)/8;  /* the coorrect number of bytes we need to
 154         "unget" is either dbytes or dbytes-1 */
 155     /* this solution is more general than what is required here: it
 156        will work correctly even if the end of a scan is not followed
 157        by a marker, as will necessarily be the case with the standard JPEG
 158        format */
 159     for ( ; ; dbytes-- )
 160   {
 161     bp = buff + fp - dbytes;  /* back-in the buffer */
 162     treg = k = 0;
 163     for ( i=0; i<dbytes; i++ )
 164     {
 165       if ( bp[i-1]==0xff && (bp[i]&0x80)==0 )
 166       {
 167         treg |= bp[i] << (BITBUFSIZE-7-k);
 168         k += 7;
 169       }
 170       else
 171       {
 172         treg |= bp[i] << (BITBUFSIZE-8-k);
 173         k += 8;
 174       }
 175     }
 176
 177     if ( k <= filled )
 178     break;
 179     }
 180     /* check consistency */
 181     if ( filled-k > 7 ) {
 182   fprintf(stderr,"bitiflush: inconsistent bits=%d filled=%d k=%d\n",bits,filled,k);
 183   exit(10);
 184     }
 185     discard = filled-k;
 186     if ( treg != (reg<<discard) ) {
 187   fprintf(stderr,"bitiflush: inconsistent bits=%d discard=%d reg=%08x treg=%08x\n",bits, discard, reg, treg);
 188   exit(10);
 189     }
 190     if ( reg & (((1<<discard)-1)<<(BITBUFSIZE-discard)) )
 191   fprintf(stderr,"bitiflush: Warning: discarding nonzero bits; reg=%08x bits=%d discard=%d\n",reg,bits,discard);
 192
 193     fp -= dbytes;  /* do the unget */
 194     if ( buff[fp-1]==0xff && buff[fp]==0 ) fp++;
 195
 196     bits = 0;
 197     reg = 0;
 198 }
 199
 200
 201
 202
 203 /* Unpad zeros from byte length */
 204 void unpadzeros()
 205 {
 206   int z;
 207
 208   z = bits % 8;
 209
 210   if (bits!=24)
 211   {
 212     reg = (reg << z);
 213     bits = bits + z;
 214   }
 215
 216
 217 }
 218
 219
 220
 221
 222 /* creates the bit counting look-up table. */
 223 void createzeroLUT()
 224 {
 225         int i, j, k, l;
 226
 227         j = k = 1; l = 8;
 228         for (i = 0; i < 256; ++i) {
 229                 zeroLUT[i] = l;
 230                 --k;
 231                 if (k == 0) {
 232                         k = j;
 233                         --l;
 234                         j *= 2;
 235                 }
 236         }
 237 }
 238
 239
 240
 241 #ifdef IOFXNS
 242 /* if using functions instead of macros */
 243 dword
 244 getbits(int no)
 245 {
 246         register dword temp;
 247
 248         assert(no > 0 && no <= 18);
 249         temp = reg >> (32 - no);
 250         fillbuffer(no);
 251         return temp;
 252 }
 253 #  define GETBITS(n)  getbits(n)
 254 #else
 255 /* see GETBITS(x,n) in bitio.h */
 256 #endif