• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

contrib/zlib/contrib/infback9/inftree9.c

00001 /* inftree9.c -- generate Huffman trees for efficient decoding
00002  * Copyright (C) 1995-2010 Mark Adler
00003  * For conditions of distribution and use, see copyright notice in zlib.h
00004  */
00005 
00006 #include "zutil.h"
00007 #include "inftree9.h"
00008 
00009 #define MAXBITS 15
00010 
00011 const char inflate9_copyright[] =
00012    " inflate9 1.2.5 Copyright 1995-2010 Mark Adler ";
00013 /*
00014   If you use the zlib library in a product, an acknowledgment is welcome
00015   in the documentation of your product. If for some reason you cannot
00016   include such an acknowledgment, I would appreciate that you keep this
00017   copyright string in the executable of your product.
00018  */
00019 
00020 /*
00021    Build a set of tables to decode the provided canonical Huffman code.
00022    The code lengths are lens[0..codes-1].  The result starts at *table,
00023    whose indices are 0..2^bits-1.  work is a writable array of at least
00024    lens shorts, which is used as a work area.  type is the type of code
00025    to be generated, CODES, LENS, or DISTS.  On return, zero is success,
00026    -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
00027    on return points to the next available entry's address.  bits is the
00028    requested root table index bits, and on return it is the actual root
00029    table index bits.  It will differ if the request is greater than the
00030    longest code or if it is less than the shortest code.
00031  */
00032 int inflate_table9(type, lens, codes, table, bits, work)
00033 codetype type;
00034 unsigned short FAR *lens;
00035 unsigned codes;
00036 code FAR * FAR *table;
00037 unsigned FAR *bits;
00038 unsigned short FAR *work;
00039 {
00040     unsigned len;               /* a code's length in bits */
00041     unsigned sym;               /* index of code symbols */
00042     unsigned min, max;          /* minimum and maximum code lengths */
00043     unsigned root;              /* number of index bits for root table */
00044     unsigned curr;              /* number of index bits for current table */
00045     unsigned drop;              /* code bits to drop for sub-table */
00046     int left;                   /* number of prefix codes available */
00047     unsigned used;              /* code entries in table used */
00048     unsigned huff;              /* Huffman code */
00049     unsigned incr;              /* for incrementing code, index */
00050     unsigned fill;              /* index for replicating entries */
00051     unsigned low;               /* low bits for current root entry */
00052     unsigned mask;              /* mask for low root bits */
00053     code this;                  /* table entry for duplication */
00054     code FAR *next;             /* next available space in table */
00055     const unsigned short FAR *base;     /* base value table to use */
00056     const unsigned short FAR *extra;    /* extra bits table to use */
00057     int end;                    /* use base and extra for symbol > end */
00058     unsigned short count[MAXBITS+1];    /* number of codes of each length */
00059     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
00060     static const unsigned short lbase[31] = { /* Length codes 257..285 base */
00061         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17,
00062         19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115,
00063         131, 163, 195, 227, 3, 0, 0};
00064     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
00065         128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
00066         130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
00067         133, 133, 133, 133, 144, 73, 195};
00068     static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
00069         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
00070         65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
00071         4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153};
00072     static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
00073         128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132,
00074         133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138,
00075         139, 139, 140, 140, 141, 141, 142, 142};
00076 
00077     /*
00078        Process a set of code lengths to create a canonical Huffman code.  The
00079        code lengths are lens[0..codes-1].  Each length corresponds to the
00080        symbols 0..codes-1.  The Huffman code is generated by first sorting the
00081        symbols by length from short to long, and retaining the symbol order
00082        for codes with equal lengths.  Then the code starts with all zero bits
00083        for the first code of the shortest length, and the codes are integer
00084        increments for the same length, and zeros are appended as the length
00085        increases.  For the deflate format, these bits are stored backwards
00086        from their more natural integer increment ordering, and so when the
00087        decoding tables are built in the large loop below, the integer codes
00088        are incremented backwards.
00089 
00090        This routine assumes, but does not check, that all of the entries in
00091        lens[] are in the range 0..MAXBITS.  The caller must assure this.
00092        1..MAXBITS is interpreted as that code length.  zero means that that
00093        symbol does not occur in this code.
00094 
00095        The codes are sorted by computing a count of codes for each length,
00096        creating from that a table of starting indices for each length in the
00097        sorted table, and then entering the symbols in order in the sorted
00098        table.  The sorted table is work[], with that space being provided by
00099        the caller.
00100 
00101        The length counts are used for other purposes as well, i.e. finding
00102        the minimum and maximum length codes, determining if there are any
00103        codes at all, checking for a valid set of lengths, and looking ahead
00104        at length counts to determine sub-table sizes when building the
00105        decoding tables.
00106      */
00107 
00108     /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
00109     for (len = 0; len <= MAXBITS; len++)
00110         count[len] = 0;
00111     for (sym = 0; sym < codes; sym++)
00112         count[lens[sym]]++;
00113 
00114     /* bound code lengths, force root to be within code lengths */
00115     root = *bits;
00116     for (max = MAXBITS; max >= 1; max--)
00117         if (count[max] != 0) break;
00118     if (root > max) root = max;
00119     if (max == 0) return -1;            /* no codes! */
00120     for (min = 1; min <= MAXBITS; min++)
00121         if (count[min] != 0) break;
00122     if (root < min) root = min;
00123 
00124     /* check for an over-subscribed or incomplete set of lengths */
00125     left = 1;
00126     for (len = 1; len <= MAXBITS; len++) {
00127         left <<= 1;
00128         left -= count[len];
00129         if (left < 0) return -1;        /* over-subscribed */
00130     }
00131     if (left > 0 && (type == CODES || max != 1))
00132         return -1;                      /* incomplete set */
00133 
00134     /* generate offsets into symbol table for each length for sorting */
00135     offs[1] = 0;
00136     for (len = 1; len < MAXBITS; len++)
00137         offs[len + 1] = offs[len] + count[len];
00138 
00139     /* sort symbols by length, by symbol order within each length */
00140     for (sym = 0; sym < codes; sym++)
00141         if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
00142 
00143     /*
00144        Create and fill in decoding tables.  In this loop, the table being
00145        filled is at next and has curr index bits.  The code being used is huff
00146        with length len.  That code is converted to an index by dropping drop
00147        bits off of the bottom.  For codes where len is less than drop + curr,
00148        those top drop + curr - len bits are incremented through all values to
00149        fill the table with replicated entries.
00150 
00151        root is the number of index bits for the root table.  When len exceeds
00152        root, sub-tables are created pointed to by the root entry with an index
00153        of the low root bits of huff.  This is saved in low to check for when a
00154        new sub-table should be started.  drop is zero when the root table is
00155        being filled, and drop is root when sub-tables are being filled.
00156 
00157        When a new sub-table is needed, it is necessary to look ahead in the
00158        code lengths to determine what size sub-table is needed.  The length
00159        counts are used for this, and so count[] is decremented as codes are
00160        entered in the tables.
00161 
00162        used keeps track of how many table entries have been allocated from the
00163        provided *table space.  It is checked for LENS and DIST tables against
00164        the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
00165        the initial root table size constants.  See the comments in inftree9.h
00166        for more information.
00167 
00168        sym increments through all symbols, and the loop terminates when
00169        all codes of length max, i.e. all codes, have been processed.  This
00170        routine permits incomplete codes, so another loop after this one fills
00171        in the rest of the decoding tables with invalid code markers.
00172      */
00173 
00174     /* set up for code type */
00175     switch (type) {
00176     case CODES:
00177         base = extra = work;    /* dummy value--not used */
00178         end = 19;
00179         break;
00180     case LENS:
00181         base = lbase;
00182         base -= 257;
00183         extra = lext;
00184         extra -= 257;
00185         end = 256;
00186         break;
00187     default:            /* DISTS */
00188         base = dbase;
00189         extra = dext;
00190         end = -1;
00191     }
00192 
00193     /* initialize state for loop */
00194     huff = 0;                   /* starting code */
00195     sym = 0;                    /* starting code symbol */
00196     len = min;                  /* starting code length */
00197     next = *table;              /* current table to fill in */
00198     curr = root;                /* current table index bits */
00199     drop = 0;                   /* current bits to drop from code for index */
00200     low = (unsigned)(-1);       /* trigger new sub-table when len > root */
00201     used = 1U << root;          /* use root table entries */
00202     mask = used - 1;            /* mask for comparing low */
00203 
00204     /* check available table space */
00205     if ((type == LENS && used >= ENOUGH_LENS) ||
00206         (type == DISTS && used >= ENOUGH_DISTS))
00207         return 1;
00208 
00209     /* process all codes and make table entries */
00210     for (;;) {
00211         /* create table entry */
00212         this.bits = (unsigned char)(len - drop);
00213         if ((int)(work[sym]) < end) {
00214             this.op = (unsigned char)0;
00215             this.val = work[sym];
00216         }
00217         else if ((int)(work[sym]) > end) {
00218             this.op = (unsigned char)(extra[work[sym]]);
00219             this.val = base[work[sym]];
00220         }
00221         else {
00222             this.op = (unsigned char)(32 + 64);         /* end of block */
00223             this.val = 0;
00224         }
00225 
00226         /* replicate for those indices with low len bits equal to huff */
00227         incr = 1U << (len - drop);
00228         fill = 1U << curr;
00229         do {
00230             fill -= incr;
00231             next[(huff >> drop) + fill] = this;
00232         } while (fill != 0);
00233 
00234         /* backwards increment the len-bit code huff */
00235         incr = 1U << (len - 1);
00236         while (huff & incr)
00237             incr >>= 1;
00238         if (incr != 0) {
00239             huff &= incr - 1;
00240             huff += incr;
00241         }
00242         else
00243             huff = 0;
00244 
00245         /* go to next symbol, update count, len */
00246         sym++;
00247         if (--(count[len]) == 0) {
00248             if (len == max) break;
00249             len = lens[work[sym]];
00250         }
00251 
00252         /* create new sub-table if needed */
00253         if (len > root && (huff & mask) != low) {
00254             /* if first time, transition to sub-tables */
00255             if (drop == 0)
00256                 drop = root;
00257 
00258             /* increment past last table */
00259             next += 1U << curr;
00260 
00261             /* determine length of next table */
00262             curr = len - drop;
00263             left = (int)(1 << curr);
00264             while (curr + drop < max) {
00265                 left -= count[curr + drop];
00266                 if (left <= 0) break;
00267                 curr++;
00268                 left <<= 1;
00269             }
00270 
00271             /* check for enough space */
00272             used += 1U << curr;
00273             if ((type == LENS && used >= ENOUGH_LENS) ||
00274                 (type == DISTS && used >= ENOUGH_DISTS))
00275                 return 1;
00276 
00277             /* point entry in root table to sub-table */
00278             low = huff & mask;
00279             (*table)[low].op = (unsigned char)curr;
00280             (*table)[low].bits = (unsigned char)root;
00281             (*table)[low].val = (unsigned short)(next - *table);
00282         }
00283     }
00284 
00285     /*
00286        Fill in rest of table for incomplete codes.  This loop is similar to the
00287        loop above in incrementing huff for table indices.  It is assumed that
00288        len is equal to curr + drop, so there is no loop needed to increment
00289        through high index bits.  When the current sub-table is filled, the loop
00290        drops back to the root table to fill in any remaining entries there.
00291      */
00292     this.op = (unsigned char)64;                /* invalid code marker */
00293     this.bits = (unsigned char)(len - drop);
00294     this.val = (unsigned short)0;
00295     while (huff != 0) {
00296         /* when done with sub-table, drop back to root table */
00297         if (drop != 0 && (huff & mask) != low) {
00298             drop = 0;
00299             len = root;
00300             next = *table;
00301             curr = root;
00302             this.bits = (unsigned char)len;
00303         }
00304 
00305         /* put invalid code marker in table */
00306         next[huff >> drop] = this;
00307 
00308         /* backwards increment the len-bit code huff */
00309         incr = 1U << (len - 1);
00310         while (huff & incr)
00311             incr >>= 1;
00312         if (incr != 0) {
00313             huff &= incr - 1;
00314             huff += incr;
00315         }
00316         else
00317             huff = 0;
00318     }
00319 
00320     /* set return parameters */
00321     *table += used;
00322     *bits = root;
00323     return 0;
00324 }

Generated on Wed Oct 20 2010 11:12:17 for APBS by  doxygen 1.7.2