47ce9943b23cb90bc263f33fad25588d727ba143
[wimlib] / src / decompress.c
1 /*
2  * decompress.c
3  *
4  * Functions used for decompression.
5  */
6
7 /*
8  * Copyright (C) 2012 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 #include "decompress.h"
27 #include <string.h>
28
29 /* Reads @n bytes from the bitstream @stream into the location pointed to by @dest.
30  * The bitstream must be 16-bit aligned. */
31 int bitstream_read_bytes(struct input_bitstream *stream, size_t n, void *dest)
32 {
33         /* Precondition:  The bitstream is 16-byte aligned. */
34         wimlib_assert(stream->bitsleft % 16 == 0);
35
36         u8 *p = dest;
37
38         /* Get the bytes currently in the buffer variable. */
39         while (stream->bitsleft != 0) {
40                 if (n-- == 0)
41                         return 0;
42                 *p++ = bitstream_peek_bits(stream, 8);
43                 bitstream_remove_bits(stream, 8);
44         }
45
46         /* Get the rest directly from the pointer to the data.  Of course, it's
47          * necessary to check there are really n bytes available. */
48         if (n > stream->data_bytes_left) {
49                 ERROR("Unexpected end of input when reading %zu bytes from "
50                       "bitstream (only have %u bytes left)",
51                       n, stream->data_bytes_left);
52                 return 1;
53         }
54         memcpy(p, stream->data, n);
55         stream->data += n;
56         stream->data_bytes_left -= n;
57
58         /* It's possible to copy an odd number of bytes and leave the stream in
59          * an inconsistent state. Fix it by reading the next byte, if it is
60          * there. */
61         if ((n & 1) && stream->data_bytes_left != 0) {
62                 stream->bitsleft = 8;
63                 stream->data_bytes_left--;
64                 stream->bitbuf |= (input_bitbuf_t)(*stream->data) <<
65                                         (sizeof(input_bitbuf_t) * 8 - 8);
66                 stream->data++;
67         }
68         return 0;
69 }
70
71 /* Aligns the bitstream on a 16-bit boundary.
72  *
73  * Note: M$'s idea of "alignment" means that for some reason, a 16-bit word
74  * should be skipped over if the buffer happens to already be aligned on such a
75  * boundary.  This only applies for realigning the stream after the blocktype
76  * and length fields of an uncompressed block, however; it does not apply when
77  * realigning the stream after the end of the uncompressed block.
78  */
79 int align_input_bitstream(struct input_bitstream *stream,
80                           bool skip_word_if_aligned)
81 {
82         int ret;
83         if (stream->bitsleft % 16 != 0) {
84                 bitstream_remove_bits(stream, stream->bitsleft % 16);
85         } else if (skip_word_if_aligned) {
86                 if (stream->bitsleft == 0) {
87                         ret = bitstream_ensure_bits(stream, 16);
88                         if (ret != 0) {
89                                 ERROR("Unexpected end of input when "
90                                       "aligning bitstream");
91                                 return ret;
92                         }
93                 }
94                 bitstream_remove_bits(stream, 16);
95         }
96         return 0;
97 }
98
99 /*
100  * Builds a fast huffman decoding table from a canonical huffman code lengths
101  * table.  Based on code written by David Tritscher.
102  *
103  * @decode_table:       The array in which to create the fast huffman decoding
104  *                              table.  It must have a length of at least
105  *                              (2**num_bits) + 2 * num_syms to guarantee
106  *                              that there is enough space.
107  *
108  * @num_syms:   Total number of symbols in the Huffman tree.
109  *
110  * @num_bits:   Any symbols with a code length of num_bits or less can be
111  *                      decoded in one lookup of the table.  2**num_bits
112  *                      must be greater than or equal to @num_syms if there are
113  *                      any Huffman codes longer than @num_bits.
114  *
115  * @lens:       An array of length @num_syms, indexable by symbol, that
116  *                      gives the length of that symbol.  Because the Huffman
117  *                      tree is in canonical form, it can be reconstructed by
118  *                      only knowing the length of the code for each symbol.
119  *
120  * @make_codeword_len:  An integer that gives the longest possible codeword
121  *                      length.
122  *
123  * Returns 0 on success; returns 1 if the length values do not correspond to a
124  * valid Huffman tree, or if there are codes of length greater than @num_bits
125  * but 2**num_bits < num_syms.
126  *
127  * What exactly is the format of the fast Huffman decoding table?  The first
128  * (1 << num_bits) entries of the table are indexed by chunks of the input of
129  * size @num_bits.  If the next Huffman code in the input happens to have a
130  * length of exactly @num_bits, the symbol is simply read directly from the
131  * decoding table.  Alternatively, if the next Huffman code has length _less
132  * than_ @num_bits, the symbol is also read directly from the decode table; this
133  * is possible because every entry in the table that is indexed by an integer
134  * that has the shorter code as a binary prefix is filled in with the
135  * appropriate symbol.  If a code has length n <= num_bits, it will have
136  * 2**(num_bits - n) possible suffixes, and thus that many entries in the
137  * decoding table.
138  *
139  * It's a bit more complicated if the next Huffman code has length of more than
140  * @num_bits.  The table entry indexed by the first @num_bits of that code
141  * cannot give the appropriate symbol directly, because that entry is guaranteed
142  * to be referenced by the Huffman codes for multiple symbols.  And while the
143  * LZX compression format does not allow codes longer than 16 bits, a table of
144  * size (2 ** 16) = 65536 entries would be too slow to create.
145  *
146  * There are several different ways to make it possible to look up the symbols
147  * for codes longer than @num_bits.  A common way is to make the entries for the
148  * prefixes of length @num_bits of those entries be pointers to additional
149  * decoding tables that are indexed by some number of additional bits of the
150  * code symbol.  The technique used here is a bit simpler, however.  We just
151  * store the needed subtrees of the Huffman tree in the decoding table after the
152  * lookup entries, beginning at index (2**num_bits).  Real pointers are
153  * replaced by indices into the decoding table, and we distinguish symbol
154  * entries from pointers by the fact that values less than @num_syms must be
155  * symbol values.
156  */
157 int make_huffman_decode_table(u16 decode_table[],  uint num_syms,
158                               uint num_bits, const u8 lens[],
159                               uint max_code_len)
160 {
161         /* Number of entries in the decode table. */
162         u32 table_num_entries = 1 << num_bits;
163
164         /* Current position in the decode table. */
165         u32 decode_table_pos = 0;
166
167         /* Fill entries for codes short enough for a direct mapping.  Here we
168          * are taking advantage of the ordering of the codes, since they are for
169          * a canonical Huffman tree.  It must be the case that all the codes of
170          * some length @code_length, zero-extended or one-extended, numerically
171          * precede all the codes of length @code_length + 1.  Furthermore, if we
172          * have 2 symbols A and B, such that A is listed before B in the lens
173          * array, and both symbols have the same code length, then we know that
174          * the code for A numerically precedes the code for B.
175          * */
176         for (uint code_len = 1; code_len <= num_bits; code_len++) {
177
178                 /* Number of entries that a code of length @code_length would
179                  * need.  */
180                 u32 code_num_entries = 1 << (num_bits - code_len);
181
182
183                 /* For each symbol of length @code_len, fill in its entries in
184                  * the decode table. */
185                 for (uint sym = 0; sym < num_syms; sym++) {
186
187                         if (lens[sym] != code_len)
188                                 continue;
189
190
191                         /* Check for table overrun.  This can only happen if the
192                          * given lengths do not correspond to a valid Huffman
193                          * tree.  */
194                         if (decode_table_pos >= table_num_entries) {
195                                 ERROR("Huffman decoding table overrun: "
196                                       "pos = %u, num_entries = %u",
197                                       decode_table_pos, table_num_entries);
198                                 return 1;
199                         }
200
201                         /* Fill all possible lookups of this symbol with
202                          * the symbol itself. */
203                         for (uint i = 0; i < code_num_entries; i++)
204                                 decode_table[decode_table_pos + i] = sym;
205
206                         /* Increment the position in the decode table by
207                          * the number of entries that were just filled
208                          * in. */
209                         decode_table_pos += code_num_entries;
210                 }
211         }
212
213         /* If all entries of the decode table have been filled in, there are no
214          * codes longer than num_bits, so we are done filling in the decode
215          * table. */
216         if (decode_table_pos == table_num_entries)
217                 return 0;
218
219         /* Otherwise, fill in the remaining entries, which correspond to codes longer
220          * than @num_bits. */
221
222
223         /* First, zero out the rest of the entries; this is necessary so
224          * that the entries appear as "unallocated" in the next part.  */
225         for (uint i = decode_table_pos; i < table_num_entries; i++)
226                 decode_table[i] = 0;
227
228         /* Assert that 2**num_bits is at least num_syms.  If this wasn't the
229          * case, we wouldn't be able to distinguish pointer entries from symbol
230          * entries. */
231         wimlib_assert((1 << num_bits) >= num_syms);
232
233
234         /* The current Huffman code.  */
235         uint current_code = decode_table_pos;
236
237         /* The tree nodes are allocated starting at
238          * decode_table[table_num_entries].  Remember that the full size of the
239          * table, including the extra space for the tree nodes, is actually
240          * 2**num_bits + 2 * num_syms slots, while table_num_entries is only
241          * 2**num_bits. */
242         uint next_free_tree_slot = table_num_entries;
243
244         /* Go through every codeword of length greater than @num_bits.  Note:
245          * the LZX format guarantees that the codeword length can be at most 16
246          * bits. */
247         for (uint code_len = num_bits + 1; code_len <= max_code_len;
248                                                         code_len++)
249         {
250                 current_code <<= 1;
251                 for (uint sym = 0; sym < num_syms; sym++) {
252                         if (lens[sym] != code_len)
253                                 continue;
254
255
256                         /* i is the index of the current node; find it from the
257                          * prefix of the current Huffman code. */
258                         uint i = current_code >> (code_len - num_bits);
259
260                         if (i >= (1 << num_bits)) {
261                                 ERROR("Invalid canonical Huffman code");
262                                 return 1;
263                         }
264
265                         /* Go through each bit of the current Huffman code
266                          * beyond the prefix of length num_bits and walk the
267                          * tree, "allocating" slots that have not yet been
268                          * allocated. */
269                         for (int bit_num = num_bits + 1; bit_num <= code_len; bit_num++) {
270
271                                 /* If the current tree node points to nowhere
272                                  * but we need to follow it, allocate a new node
273                                  * for it to point to. */
274                                 if (decode_table[i] == 0) {
275                                         decode_table[i] = next_free_tree_slot;
276                                         decode_table[next_free_tree_slot++] = 0;
277                                         decode_table[next_free_tree_slot++] = 0;
278                                 }
279
280                                 i = decode_table[i];
281
282                                 /* Is the next bit 0 or 1? If 0, go left;
283                                  * otherwise, go right (by incrementing i by 1) */
284                                 int bit_pos = code_len - bit_num;
285
286                                 int bit = (current_code & (1 << bit_pos)) >>
287                                                                 bit_pos;
288                                 i += bit;
289                         }
290
291                         /* i is now the index of the leaf entry into which the
292                          * actual symbol will go. */
293                         decode_table[i] = sym;
294
295                         /* Increment decode_table_pos only if the prefix of the
296                          * Huffman code changes. */
297                         if (current_code >> (code_len - num_bits) !=
298                                         (current_code + 1) >> (code_len - num_bits))
299                                 decode_table_pos++;
300
301                         /* current_code is always incremented because this is
302                          * how canonical Huffman codes are generated (add 1 for
303                          * each code, then left shift whenever the code length
304                          * increases) */
305                         current_code++;
306                 }
307         }
308
309
310         /* If the lengths really represented a valid Huffman tree, all
311          * @table_num_entries in the table will have been filled.  However, it
312          * is also possible that the tree is completely empty (as noted
313          * earlier) with all 0 lengths, and this is expected to succeed. */
314
315         if (decode_table_pos != table_num_entries) {
316
317                 for (uint i = 0; i < num_syms; i++) {
318                         if (lens[i] != 0) {
319                                 ERROR("Lengths do not form a valid canonical "
320                                       "Huffman tree (only filled %u of %u "
321                                       "decode table slots)",
322                                       decode_table_pos, table_num_entries);
323                                 return 1;
324                         }
325                 }
326         }
327         return 0;
328 }
329
330 /* Reads a Huffman-encoded symbol when it is known there are less than
331  * MAX_CODE_LEN bits remaining in the bitstream. */
332 static int read_huffsym_near_end_of_input(struct input_bitstream *istream,
333                                           const u16 decode_table[],
334                                           const u8 lens[],
335                                           uint num_syms,
336                                           uint table_bits,
337                                           uint *n)
338 {
339         uint bitsleft = istream->bitsleft;
340         uint key_size;
341         u16 sym;
342         u16 key_bits;
343
344         if (table_bits > bitsleft) {
345                 key_size = bitsleft;
346                 bitsleft = 0;
347                 key_bits = bitstream_peek_bits(istream, key_size) <<
348                                                 (table_bits - key_size);
349         } else {
350                 key_size = table_bits;
351                 bitsleft -= table_bits;
352                 key_bits = bitstream_peek_bits(istream, table_bits);
353         }
354
355         sym = decode_table[key_bits];
356         if (sym >= num_syms) {
357                 bitstream_remove_bits(istream, key_size);
358                 do {
359                         if (bitsleft == 0) {
360                                 ERROR("Input stream exhausted");
361                                 return 1;
362                         }
363                         key_bits = sym + bitstream_peek_bits(istream, 1);
364                         bitstream_remove_bits(istream, 1);
365                         bitsleft--;
366                 } while ((sym = decode_table[key_bits]) >= num_syms);
367         } else {
368                 bitstream_remove_bits(istream, lens[sym]);
369         }
370         *n = sym;
371         return 0;
372 }
373
374 /*
375  * Reads a Huffman-encoded symbol from a bitstream.
376  *
377  * This function may be called hundreds of millions of times when extracting a
378  * large WIM file.  I'm not sure it could be made much faster that it is,
379  * especially since there isn't enough time to make a big table that allows
380  * decoding multiple symbols per lookup.  But if extracting files to a hard
381  * disk, the IO will be the bottleneck anyway.
382  *
383  * @buf:        The input buffer from which the symbol will be read.
384  * @decode_table:       The fast Huffman decoding table for the Huffman tree.
385  * @lengths:            The table that gives the length of the code for each
386  *                              symbol.
387  * @num_symbols:        The number of symbols in the Huffman code.
388  * @table_bits:         Huffman codes this length or less can be looked up
389  *                              directory in the decode_table, as the
390  *                              decode_table contains 2**table_bits entries.
391  */
392 int read_huffsym(struct input_bitstream *stream,
393                  const u16 decode_table[],
394                  const u8 lengths[],
395                  unsigned num_symbols,
396                  unsigned table_bits,
397                  uint *n,
398                  unsigned max_codeword_len)
399 {
400         /* In the most common case, there are at least max_codeword_len bits
401          * remaining in the stream. */
402         if (bitstream_ensure_bits(stream, max_codeword_len) == 0) {
403
404                 /* Use the next table_bits of the input as an index into the
405                  * decode_table. */
406                 u16 key_bits = bitstream_peek_bits(stream, table_bits);
407
408                 u16 sym = decode_table[key_bits];
409
410                 /* If the entry in the decode table is not a valid symbol, it is
411                  * the offset of the root of its Huffman subtree. */
412                 if (sym >= num_symbols) {
413                         bitstream_remove_bits(stream, table_bits);
414                         do {
415                                 key_bits = sym + bitstream_peek_bits(stream, 1);
416                                 bitstream_remove_bits(stream, 1);
417
418                                 wimlib_assert(key_bits < num_symbols * 2 +
419                                                         (1 << table_bits));
420                         } while ((sym = decode_table[key_bits]) >= num_symbols);
421                 } else {
422                         wimlib_assert(lengths[sym] <= table_bits);
423                         bitstream_remove_bits(stream, lengths[sym]);
424                 }
425                 *n = sym;
426                 return 0;
427         } else {
428                 /* Otherwise, we must be careful to use only the bits that are
429                  * actually remaining.  */
430                 return read_huffsym_near_end_of_input(stream, decode_table,
431                                                       lengths, num_symbols,
432                                                       table_bits, n);
433         }
434 }