8ea02196610d01c8670fd9cf842d5d6b0cdcd30f
[wimlib] / src / decompress_common.c
1 /*
2  * decompress_common.c
3  *
4  * Code for decompression shared among multiple compression formats.
5  */
6
7 /*
8  * Copyright (C) 2012, 2013, 2014 Eric Biggers
9  *
10  * This file is part of wimlib, a library for working with WIM files.
11  *
12  * wimlib is free software; you can redistribute it and/or modify it under the
13  * terms of the GNU General Public License as published by the Free
14  * Software Foundation; either version 3 of the License, or (at your option)
15  * any later version.
16  *
17  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
19  * A PARTICULAR PURPOSE. See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with wimlib; if not, see http://www.gnu.org/licenses/.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 #  include "config.h"
28 #endif
29
30 #include "wimlib/decompress_common.h"
31 #include "wimlib/error.h"
32
33 #include <string.h>
34
35 #ifdef __GNUC__
36 #  ifdef __SSE2__
37 #    define USE_SSE2_FILL
38 #    include <emmintrin.h>
39 #  else
40 #    define USE_LONG_FILL
41 #  endif
42 #endif
43
44 /* Construct a direct mapping entry in the lookup table.  */
45 #define MAKE_DIRECT_ENTRY(symbol, length) ((symbol) | ((length) << 11))
46
47 /*
48  * make_huffman_decode_table() -
49  *
50  * Build a decoding table for a canonical prefix code, or "Huffman code".
51  *
52  * This takes as input the length of the codeword for each symbol in the
53  * alphabet and produces as output a table that can be used for fast
54  * decoding of prefix-encoded symbols using read_huffsym().
55  *
56  * Strictly speaking, a canonical prefix code might not be a Huffman
57  * code.  But this algorithm will work either way; and in fact, since
58  * Huffman codes are defined in terms of symbol frequencies, there is no
59  * way for the decompressor to know whether the code is a true Huffman
60  * code or not until all symbols have been decoded.
61  *
62  * Because the prefix code is assumed to be "canonical", it can be
63  * reconstructed directly from the codeword lengths.  A prefix code is
64  * canonical if and only if a longer codeword never lexicographically
65  * precedes a shorter codeword, and the lexicographic ordering of
66  * codewords of the same length is the same as the lexicographic ordering
67  * of the corresponding symbols.  Consequently, we can sort the symbols
68  * primarily by codeword length and secondarily by symbol value, then
69  * reconstruct the prefix code by generating codewords lexicographically
70  * in that order.
71  *
72  * This function does not, however, generate the prefix code explicitly.
73  * Instead, it directly builds a table for decoding symbols using the
74  * code.  The basic idea is this: given the next 'max_codeword_len' bits
75  * in the input, we can look up the decoded symbol by indexing a table
76  * containing 2**max_codeword_len entries.  A codeword with length
77  * 'max_codeword_len' will have exactly one entry in this table, whereas
78  * a codeword shorter than 'max_codeword_len' will have multiple entries
79  * in this table.  Precisely, a codeword of length n will be represented
80  * by 2**(max_codeword_len - n) entries in this table.  The 0-based index
81  * of each such entry will contain the corresponding codeword as a prefix
82  * when zero-padded on the left to 'max_codeword_len' binary digits.
83  *
84  * That's the basic idea, but we implement two optimizations regarding
85  * the format of the decode table itself:
86  *
87  * - For many compression formats, the maximum codeword length is too
88  *   long for it to be efficient to build the full decoding table
89  *   whenever a new prefix code is used.  Instead, we can build the table
90  *   using only 2**table_bits entries, where 'table_bits' is some number
91  *   less than or equal to 'max_codeword_len'.  Then, only codewords of
92  *   length 'table_bits' and shorter can be directly looked up.  For
93  *   longer codewords, the direct lookup instead produces the root of a
94  *   binary tree.  Using this tree, the decoder can do traditional
95  *   bit-by-bit decoding of the remainder of the codeword.  Child nodes
96  *   are allocated in extra entries at the end of the table; leaf nodes
97  *   contain symbols.  Note that the long-codeword case is, in general,
98  *   not performance critical, since in Huffman codes the most frequently
99  *   used symbols are assigned the shortest codeword lengths.
100  *
101  * - When we decode a symbol using a direct lookup of the table, we still
102  *   need to know its length so that the bitstream can be advanced by the
103  *   appropriate number of bits.  The simple solution is to simply retain
104  *   the 'lens' array and use the decoded symbol as an index into it.
105  *   However, this requires two separate array accesses in the fast path.
106  *   The optimization is to store the length directly in the decode
107  *   table.  We use the bottom 11 bits for the symbol and the top 5 bits
108  *   for the length.  In addition, to combine this optimization with the
109  *   previous one, we introduce a special case where the top 2 bits of
110  *   the length are both set if the entry is actually the root of a
111  *   binary tree.
112  *
113  * @decode_table:
114  *      The array in which to create the decoding table.
115  *      This must be 16-byte aligned and must have a length of at least
116  *      ((2**table_bits) + 2 * num_syms) entries.
117  *
118  * @num_syms:
119  *      The number of symbols in the alphabet; also, the length of the
120  *      'lens' array.  Must be less than or equal to
121  *      DECODE_TABLE_MAX_SYMBOLS.
122  *
123  * @table_bits:
124  *      The order of the decode table size, as explained above.  Must be
125  *      less than or equal to DECODE_TABLE_MAX_TABLE_BITS.
126  *
127  * @lens:
128  *      An array of length @num_syms, indexable by symbol, that gives the
129  *      length of the codeword, in bits, for that symbol.  The length can
130  *      be 0, which means that the symbol does not have a codeword
131  *      assigned.
132  *
133  * @max_codeword_len:
134  *      The longest codeword length allowed in the compression format.
135  *      All entries in 'lens' must be less than or equal to this value.
136  *      This must be less than or equal to DECODE_TABLE_MAX_CODEWORD_LEN.
137  *
138  * Returns 0 on success, or -1 if the lengths do not form a valid prefix
139  * code.
140  */
141 int
142 make_huffman_decode_table(u16 decode_table[const restrict],
143                           const unsigned num_syms,
144                           const unsigned table_bits,
145                           const u8 lens[const restrict],
146                           const unsigned max_codeword_len)
147 {
148         const unsigned table_num_entries = 1 << table_bits;
149         unsigned len_counts[max_codeword_len + 1];
150         u16 sorted_syms[num_syms];
151         int left;
152         void *decode_table_ptr;
153         unsigned sym_idx;
154         unsigned codeword_len;
155         unsigned stores_per_loop;
156         unsigned decode_table_pos;
157
158 #ifdef USE_LONG_FILL
159         const unsigned entries_per_long = sizeof(unsigned long) / sizeof(decode_table[0]);
160 #endif
161
162 #ifdef USE_SSE2_FILL
163         const unsigned entries_per_xmm = sizeof(__m128i) / sizeof(decode_table[0]);
164 #endif
165
166         /* Check parameters if assertions are enabled.  */
167         wimlib_assert2((uintptr_t)decode_table % DECODE_TABLE_ALIGNMENT == 0);
168         wimlib_assert2(num_syms <= DECODE_TABLE_MAX_SYMBOLS);
169         wimlib_assert2(table_bits <= DECODE_TABLE_MAX_TABLE_BITS);
170         wimlib_assert2(max_codeword_len <= DECODE_TABLE_MAX_CODEWORD_LEN);
171         for (unsigned sym = 0; sym < num_syms; sym++)
172                 wimlib_assert2(lens[sym] <= max_codeword_len);
173
174         /* Count how many symbols have each possible codeword length.
175          * Note that a length of 0 indicates the corresponding symbol is not
176          * used in the code and therefore does not have a codeword.  */
177         for (unsigned len = 0; len <= max_codeword_len; len++)
178                 len_counts[len] = 0;
179         for (unsigned sym = 0; sym < num_syms; sym++)
180                 len_counts[lens[sym]]++;
181
182         /* We can assume all lengths are <= max_codeword_len, but we
183          * cannot assume they form a valid prefix code.  A codeword of
184          * length n should require a proportion of the codespace equaling
185          * (1/2)^n.  The code is valid if and only if the codespace is
186          * exactly filled by the lengths, by this measure.  */
187         left = 1;
188         for (unsigned len = 1; len <= max_codeword_len; len++) {
189                 left <<= 1;
190                 left -= len_counts[len];
191                 if (unlikely(left < 0)) {
192                         /* The lengths overflow the codespace; that is, the code
193                          * is over-subscribed.  */
194                         DEBUG("Invalid prefix code (over-subscribed)");
195                         return -1;
196                 }
197         }
198
199         if (unlikely(left != 0)) {
200                 /* The lengths do not fill the codespace; that is, they form an
201                  * incomplete set.  */
202                 if (left == (1 << max_codeword_len)) {
203                         /* The code is completely empty.  This is arguably
204                          * invalid, but in fact it is valid in LZX and XPRESS,
205                          * so we must allow it.  By definition, no symbols can
206                          * be decoded with an empty code.  Consequently, we
207                          * technically don't even need to fill in the decode
208                          * table.  However, to avoid accessing uninitialized
209                          * memory if the algorithm nevertheless attempts to
210                          * decode symbols using such a code, we zero out the
211                          * decode table.  */
212                         memset(decode_table, 0,
213                                table_num_entries * sizeof(decode_table[0]));
214                         return 0;
215                 }
216                 DEBUG("Invalid prefix code (incomplete set)");
217                 return -1;
218         }
219
220         /* Sort the symbols primarily by length and secondarily by symbol order.
221          */
222         {
223                 unsigned offsets[max_codeword_len + 1];
224
225                 /* Initialize 'offsets' so that offsets[len] for 1 <= len <=
226                  * max_codeword_len is the number of codewords shorter than
227                  * 'len' bits.  */
228                 offsets[1] = 0;
229                 for (unsigned len = 1; len < max_codeword_len; len++)
230                         offsets[len + 1] = offsets[len] + len_counts[len];
231
232                 /* Use the 'offsets' array to sort the symbols.
233                  * Note that we do not include symbols that are not used in the
234                  * code.  Consequently, fewer than 'num_syms' entries in
235                  * 'sorted_syms' may be filled.  */
236                 for (unsigned sym = 0; sym < num_syms; sym++)
237                         if (lens[sym] != 0)
238                                 sorted_syms[offsets[lens[sym]]++] = sym;
239         }
240
241         /* Fill entries for codewords with length <= table_bits
242          * --- that is, those short enough for a direct mapping.
243          *
244          * The table will start with entries for the shortest codeword(s), which
245          * have the most entries.  From there, the number of entries per
246          * codeword will decrease.  As an optimization, we may begin filling
247          * entries with SSE2 vector accesses (8 entries/store), then change to
248          * 'unsigned long' accesses (2 or 4 entries/store), then change to
249          * 16-bit accesses (1 entry/store).  */
250         decode_table_ptr = decode_table;
251         sym_idx = 0;
252         codeword_len = 1;
253 #ifdef USE_SSE2_FILL
254         /* Fill the entries one 128-bit vector at a time.
255          * This is 8 entries per store.  */
256         stores_per_loop = (1 << (table_bits - codeword_len)) / entries_per_xmm;
257         for (; stores_per_loop != 0; codeword_len++, stores_per_loop >>= 1) {
258                 unsigned end_sym_idx = sym_idx + len_counts[codeword_len];
259                 for (; sym_idx < end_sym_idx; sym_idx++) {
260                         /* Note: unlike in the 'long' version below, the __m128i
261                          * type already has __attribute__((may_alias)), so using
262                          * it to access the decode table, which is an array of
263                          * unsigned shorts, will not violate strict aliasing.
264                          */
265                         u16 entry;
266                         __m128i v;
267                         __m128i *p;
268                         unsigned n;
269
270                         entry = MAKE_DIRECT_ENTRY(sorted_syms[sym_idx], codeword_len);
271
272                         v = _mm_set1_epi16(entry);
273                         p = (__m128i*)decode_table_ptr;
274                         n = stores_per_loop;
275                         do {
276                                 *p++ = v;
277                         } while (--n);
278                         decode_table_ptr = p;
279                 }
280         }
281 #endif /* USE_SSE2_FILL */
282
283 #ifdef USE_LONG_FILL
284         /* Fill the entries one 'unsigned long' at a time.
285          * On 32-bit systems this is 2 entries per store, while on 64-bit
286          * systems this is 4 entries per store.  */
287         stores_per_loop = (1 << (table_bits - codeword_len)) / entries_per_long;
288         for (; stores_per_loop != 0; codeword_len++, stores_per_loop >>= 1) {
289                 unsigned end_sym_idx = sym_idx + len_counts[codeword_len];
290                 for (; sym_idx < end_sym_idx; sym_idx++) {
291
292                         /* Accessing the array of unsigned shorts as unsigned
293                          * longs would violate strict aliasing and would require
294                          * compiling the code with -fno-strict-aliasing to
295                          * guarantee correctness.  To work around this problem,
296                          * use the gcc 'may_alias' extension to define a special
297                          * unsigned long type that may alias any other in-memory
298                          * variable.  */
299                         typedef unsigned long __attribute__((may_alias)) aliased_long_t;
300
301                         unsigned long v;
302                         aliased_long_t *p;
303                         unsigned n;
304
305                         BUILD_BUG_ON(sizeof(unsigned long) != 4 &&
306                                      sizeof(unsigned long) != 8);
307
308                         v = MAKE_DIRECT_ENTRY(sorted_syms[sym_idx], codeword_len);
309                         v |= v << 16;
310                         if (sizeof(unsigned long) == 8) {
311                                 /* This may produce a compiler warning if an
312                                  * 'unsigned long' is 32 bits, but this won't be
313                                  * executed unless an 'unsigned long' is at
314                                  * least 64 bits anyway.  */
315                                 v |= v << 32;
316                         }
317
318                         p = (aliased_long_t *)decode_table_ptr;
319                         n = stores_per_loop;
320
321                         do {
322                                 *p++ = v;
323                         } while (--n);
324                         decode_table_ptr = p;
325                 }
326         }
327 #endif /* USE_LONG_FILL */
328
329         /* Fill the entries one 16-bit integer at a time.  */
330         stores_per_loop = (1 << (table_bits - codeword_len));
331         for (; stores_per_loop != 0; codeword_len++, stores_per_loop >>= 1) {
332                 unsigned end_sym_idx = sym_idx + len_counts[codeword_len];
333                 for (; sym_idx < end_sym_idx; sym_idx++) {
334                         u16 entry;
335                         u16 *p;
336                         unsigned n;
337
338                         entry = MAKE_DIRECT_ENTRY(sorted_syms[sym_idx], codeword_len);
339
340                         p = (u16*)decode_table_ptr;
341                         n = stores_per_loop;
342
343                         do {
344                                 *p++ = entry;
345                         } while (--n);
346
347                         decode_table_ptr = p;
348                 }
349         }
350
351         /* If we've filled in the entire table, we are done.  Otherwise,
352          * there are codes longer than table_bits for which we must
353          * generate binary trees.  */
354
355         decode_table_pos = (u16*)decode_table_ptr - decode_table;
356         if (decode_table_pos != table_num_entries) {
357                 unsigned j;
358                 unsigned next_free_tree_slot;
359                 unsigned cur_codeword;
360
361                 /* First, zero out the rest of the entries.  This is
362                  * necessary so that the entries appear as "unallocated"
363                  * in the next part.  Each of these entries will
364                  * eventually be filled the representation of the root
365                  * node of a binary tree.  */
366                 j = decode_table_pos;
367                 do {
368                         decode_table[j] = 0;
369                 } while (++j != table_num_entries);
370
371                 /* We allocate child nodes starting at the end of the
372                  * direct lookup table.  Note that there should be
373                  * 2*num_syms extra entries for this purpose.  */
374                 next_free_tree_slot = table_num_entries;
375
376                 /* Iterate through each codeword with length greater than
377                  * 'table_bits', primarily in order of codeword length
378                  * and secondarily in order of symbol.  */
379                 for (cur_codeword = decode_table_pos << 1;
380                      codeword_len <= max_codeword_len;
381                      codeword_len++, cur_codeword <<= 1)
382                 {
383                         unsigned end_sym_idx = sym_idx + len_counts[codeword_len];
384                         for (; sym_idx < end_sym_idx; sym_idx++, cur_codeword++)
385                         {
386                                 /* 'sym' is the symbol represented by the
387                                  * codeword.  */
388                                 unsigned sym = sorted_syms[sym_idx];
389
390                                 unsigned extra_bits = codeword_len - table_bits;
391
392                                 unsigned node_idx = cur_codeword >> extra_bits;
393
394                                 /* Go through each bit of the current codeword
395                                  * beyond the prefix of length @table_bits and
396                                  * walk the appropriate binary tree, allocating
397                                  * any slots that have not yet been allocated.
398                                  *
399                                  * Note that the 'pointer' entry to the binary
400                                  * tree, which is stored in the direct lookup
401                                  * portion of the table, is represented
402                                  * identically to other internal (non-leaf)
403                                  * nodes of the binary tree; it can be thought
404                                  * of as simply the root of the tree.  The
405                                  * representation of these internal nodes is
406                                  * simply the index of the left child combined
407                                  * with the special bits 0xC000 to distingush
408                                  * the entry from direct mapping and leaf node
409                                  * entries.  */
410                                 do {
411
412                                         /* At least one bit remains in the
413                                          * codeword, but the current node is an
414                                          * unallocated leaf.  Change it to an
415                                          * internal node.  */
416                                         if (decode_table[node_idx] == 0) {
417                                                 decode_table[node_idx] =
418                                                         next_free_tree_slot | 0xC000;
419                                                 decode_table[next_free_tree_slot++] = 0;
420                                                 decode_table[next_free_tree_slot++] = 0;
421                                         }
422
423                                         /* Go to the left child if the next bit
424                                          * in the codeword is 0; otherwise go to
425                                          * the right child.  */
426                                         node_idx = decode_table[node_idx] & 0x3FFF;
427                                         --extra_bits;
428                                         node_idx += (cur_codeword >> extra_bits) & 1;
429                                 } while (extra_bits != 0);
430
431                                 /* We've traversed the tree using the entire
432                                  * codeword, and we're now at the entry where
433                                  * the actual symbol will be stored.  This is
434                                  * distinguished from internal nodes by not
435                                  * having its high two bits set.  */
436                                 decode_table[node_idx] = sym;
437                         }
438                 }
439         }
440         return 0;
441 }