home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: Graphics / Graphics.zip / xfitsvew.zip / XFITSview / fitssubs / gziputil.h < prev    next >
C/C++ Source or Header  |  1998-04-02  |  11KB  |  230 lines
  1. /* utility header file for gzipread.c for gzip reading functions */
  2. /*-----------------------------------------------------------------------
  3. *  Copyright (C) 1996
  4. *  Associated Universities, Inc. Washington DC, USA.
  5. *  This program is free software; you can redistribute it and/or
  6. *  modify it under the terms of the GNU General Public License as
  7. *  published by the Free Software Foundation; either version 2 of
  8. *  the License, or (at your option) any later version.
  9. *
  10. *  This program is distributed in the hope that it will be useful,
  11. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. *  GNU General Public License for more details.
  14. *-----------------------------------------------------------------------*/
  15.  
  16. #include "fitsmem.h"
  17. #include "fitsio.h"
  18.  
  19. #ifndef GZIPUTIL_H
  20. #define GZIPUTIL_H
  21.  
  22. typedef char            GZboolean;
  23. typedef unsigned char   byte;
  24.  
  25. /* Tables for deflate from PKZIP's appnote.txt. */
  26.  
  27. static unsigned border[] = {    /* Order of the bit length code lengths */
  28.     16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
  29. static unsigned short cplens[] = {/* Copy lengths for literal codes 257..285 */
  30.     3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
  31.     35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
  32.     /* note: see note #13 above about the 258 in this list. */
  33. static unsigned short cplext[] = {/* Extra bits for literal codes 257..285 */
  34.     0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
  35.     3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99}; /* 99==invalid */
  36. static unsigned short cpdist[] = {/* Copy offsets for distance codes 0..29 */
  37.     1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
  38.     257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
  39.     8193, 12289, 16385, 24577};
  40. static unsigned short cpdext[] = {/* Extra bits for distance codes */
  41.     0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
  42.     7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
  43.     12, 12, 13, 13};
  44.  
  45. unsigned short mask_bits[] =
  46. {
  47.     0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
  48.     0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
  49. };
  50.  
  51.  
  52. /* 
  53.  * Macros for inflate() bit peeking and grabbing.
  54.  * The usage is:
  55.  * 
  56.  *      NEEDBITS(j)
  57.  *      x = b & mask_bits[j];
  58.  *      DUMPBITS(j)
  59.  *
  60.  * where NEEDBITS makes sure that b has at least j bits in it, and
  61.  * DUMPBITS removes the bits from b.  The macros use the variable k
  62.  * for the number of bits in b.  Normally, b and k are register
  63.  * variables for speed, and are initialized at the beginning of a
  64.  * routine that uses these macros from a global bit buffer and count.
  65.  *
  66.  * If we assume that EOB will be the longest code, then we will never
  67.  * ask for bits with NEEDBITS that are beyond the end of the stream.
  68.  * So, NEEDBITS should not read any more bytes than are needed to
  69.  * meet the request.  Then no bytes need to be "returned" to the buffer
  70.  * at the end of the last block.
  71.  *
  72.  * However, this assumption is not true for fixed blocks--the EOB code
  73.  * is 7 bits, but the other literal/length codes can be 8 or 9 bits.
  74.  * (The EOB code is shorter than other codes because fixed blocks are
  75.  * generally short.  So, while a block always has an EOB, many other
  76.  * literal/length codes have a significantly lower probability of
  77.  * showing up at all.)  However, by making the first table have a
  78.  * lookup of seven bits, the EOB code will be found in that first
  79.  * lookup, and so will not require that too many bits be pulled from
  80.  * the stream.
  81.  */
  82.  
  83. #define NEEDBITS(n) {while(k<(n)) \
  84.      {if (next_byte_buff>=max_byte_buff) load_byte_buffer();in_byte_count++;\
  85.       b|=((unsigned long)byte_buffer[next_byte_buff++])<<k;k+=8;}}
  86. #define DUMPBITS(n) {b>>=(n);k-=(n);}
  87.  
  88. /* 
  89.  * The inflate algorithm uses a sliding 32K byte window on the uncompressed
  90.  * stream to find repeated byte strings.  This is implemented here as a
  91.  * circular buffer.  The index is updated simply by incrementing and then
  92.  * and'ing with 0x7fff (32K-1). 
  93.  */
  94.  
  95.  
  96. #ifndef WSIZE
  97. #  define WSIZE 0x00008000 /* window size--must be a power of two, and */
  98. #endif                     /*  at least 32K for zip's deflate method */
  99. cMemPtr     window;     /* window memory pointer */
  100. int         hWindow;    /* handle for window memory */
  101. unsigned long outcnt;   /* current position in window */
  102.  
  103. #define GZIP_MAGIC     "\037\213" /* Magic header for gzip files, 1F 8B */
  104.  
  105. /* gzip flag byte  */
  106. #define ASCII_FLAG   0x01 /* bit 0 set: file probably ascii text */
  107. #define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
  108. #define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
  109. #define ORIG_NAME    0x08 /* bit 3 set: original file name present */
  110. #define COMMENT      0x10 /* bit 4 set: file comment present */
  111. #define ENCRYPTED    0x20 /* bit 5 set: file is encrypted */
  112. #define RESERVED     0xC0 /* bit 6,7:   reserved */
  113.  
  114. /* Compression methods (see algorithm.doc) */
  115. #define DEFLATED    8
  116.  
  117. /* execute with error check macros */
  118. #define PR_CHECK( s )           { int estatus; \
  119.                   if ( ( estatus = ( s ) ) < 0 ) { \
  120.                     return( estatus ); } }
  121.  
  122. #define PR_CHECK_NULL( s )      { if ( ( s ) == NULL ) {\
  123.                   pr_format_message( PR_E_MEMORY , NULL);\
  124.                   return( PR_E_MEMORY ); } }
  125.  
  126. /* 
  127.  * Huffman code lookup table entry--this entry is four bytes for machines
  128.  * that have 16-bit pointers (e.g. PC's in the small or medium model).
  129.  * Valid extra bits are 0..13.  e == 15 is EOB (end of block), e == 16
  130.  * means that v is a literal, 16 < e < 32 means that v is a pointer to
  131.  * the next table, which codes e - 16 bits, and lastly e == 99 indicates
  132.  * an unused code.  If a code with e == 99 is looked up, this implies an
  133.  * error in the data. 
  134.  */
  135.  
  136. struct huft 
  137. {
  138.     byte         e;             /* number of extra bits or operation    */
  139.     byte         b;             /* number of bits in this code or subcode */
  140.     union 
  141.     {
  142.     unsigned short  n;      /* literal, length base, or distance base */
  143.     struct huft     *t;     /* pointer to next level of table       */
  144.     } v;
  145. };
  146.   struct huft *tlsave=NULL;          /* literal/length code table    */
  147.   struct huft *tdsave=NULL;          /* distance code table          */
  148.  
  149. /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
  150. #define BMAX 16         /* maximum bit length of any code (16 for explode) */
  151. #define N_MAX 288       /* maximum number of codes in any set */
  152. #define EXTHDR  16              /* Size of extend local header.         */
  153.  
  154.  
  155. /*
  156.  * Huffman code decoding is performed using a multi-level table lookup.
  157.  * The fastest way to decode is to simply build a lookup table whose
  158.  * size is determined by the longest code.  However, the time it takes
  159.  * to build this table can also be a factor if the data being decoded
  160.  * is not very long.  The most common codes are necessarily the
  161.  * shortest codes, so those codes dominate the decoding time, and hence
  162.  * the speed.  The idea is you can have a shorter table that decodes the
  163.  * shorter, more probable codes, and then point to subsidiary tables for
  164.  * the longer codes.  The time it costs to decode the longer codes is
  165.  * then traded against the time it takes to make longer tables.
  166.  *
  167.  * This results of this trade are in the variables lbits and dbits
  168.  * below.  lbits is the number of bits the first level table for literal/
  169.  * length codes can decode in one step, and dbits is the same thing for
  170.  * the distance codes.  Subsequent tables are also less than or equal to
  171.  * those sizes.  These values may be adjusted either when all of the
  172.  * codes are shorter than that, in which case the longest code length in
  173.  * bits is used, or when the shortest code is *longer* than the requested
  174.  * table size, in which case the length of the shortest code in bits is
  175.  * used.
  176.  *
  177.  * There are two different values for the two tables, since they code a
  178.  * different number of possibilities each.  The literal/length table
  179.  * codes 286 possible values, or in a flat code, a little over eight
  180.  * bits.  The distance table codes 30 possible values, or a little less
  181.  * than five bits, flat.  The optimum values for speed end up being
  182.  * about one bit more than those, so lbits is 8+1 and dbits is 5+1.
  183.  * The optimum values may differ though from machine to machine, and
  184.  * possibly even between compilers.  Your mileage may vary.
  185.  */
  186.  
  187. int             lbits = 9;      /* bits in base literal/length lookup table */
  188. int             dbits = 6;      /* bits in base distance lookup table */
  189.  
  190. unsigned        hufts=0;         /* track memory usage */
  191.  
  192.   
  193. /* file global I/O variables */
  194. int             in_hFile;       /* input file handle                    */
  195. FITSfile       *current_file=0; /* FileRead file descriptor of in_hFile */
  196. long            in_byte_count;  /* current input byte index             */
  197. long            out_byte_count; /* current output byte index            */
  198. int             input_IO_error; /* if non zero the error exists in input*/
  199. GZboolean       last_block;     /* is this the last compressed block?   */
  200. long            first_block;    /* offset to beginning of first block   */
  201. GZboolean       IO_done;        /* if true input file exhausted         */
  202. #define         MAX_BYTE 256    /* byte buffer size                     */
  203. byte            byte_buffer[MAX_BYTE]; /* byte buffer                   */
  204. int             next_byte_buff; /* next available byte in byte buffer   */
  205. int             max_byte_buff;  /* number of bytes in byte buffer       */
  206. int             gzip_type;      /* block type 0=stored, 1=fixed, 2=dynamic*/
  207. unsigned long   bb;             /* bit buffer                           */
  208. unsigned        bk;             /* bits in bit buffer                   */
  209. GZboolean       MsgSup=0;       /* if true suppress error messages      */
  210.  
  211. /* function prototypes */
  212. int  gun_stored(GZboolean cont, long start, int *count,
  213.         cMemPtr buffer, GZboolean *end);
  214. int  gun_fixed(GZboolean cont, long start, int *count,
  215.            cMemPtr buffer, GZboolean *end);
  216. int  gun_dynamic(GZboolean cont, long start, int *count,
  217.          cMemPtr buffer, GZboolean *end);
  218. byte get_byte(void);
  219. int  char_in(byte *buff, int count);
  220. void load_byte_buffer(void);
  221. void pr_format_message(int code, int* arg);
  222. int  huft_build(unsigned *b, unsigned n, unsigned s, unsigned short *d,
  223.         unsigned short *e, struct huft **t, int *m);
  224. int  huft_free(struct huft *t );
  225. int  inflate_codes( GZboolean cont, long start, int *count,
  226.            cMemPtr buffer, GZboolean *end,
  227.            struct huft *tl, struct huft *td, int bl, int bd);
  228.  
  229. #endif /* GZIPUTIL_H */
  230.