320 lines
12 KiB
C
320 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* decompress_common.c - Code shared by the XPRESS and LZX decompressors
|
|
*
|
|
* Copyright (C) 2015 Eric Biggers
|
|
*/
|
|
|
|
#include "decompress_common.h"
|
|
|
|
/*
|
|
* make_huffman_decode_table() -
|
|
*
|
|
* Build a decoding table for a canonical prefix code, or "Huffman code".
|
|
*
|
|
* This is an internal function, not part of the library API!
|
|
*
|
|
* This takes as input the length of the codeword for each symbol in the
|
|
* alphabet and produces as output a table that can be used for fast
|
|
* decoding of prefix-encoded symbols using read_huffsym().
|
|
*
|
|
* Strictly speaking, a canonical prefix code might not be a Huffman
|
|
* code. But this algorithm will work either way; and in fact, since
|
|
* Huffman codes are defined in terms of symbol frequencies, there is no
|
|
* way for the decompressor to know whether the code is a true Huffman
|
|
* code or not until all symbols have been decoded.
|
|
*
|
|
* Because the prefix code is assumed to be "canonical", it can be
|
|
* reconstructed directly from the codeword lengths. A prefix code is
|
|
* canonical if and only if a longer codeword never lexicographically
|
|
* precedes a shorter codeword, and the lexicographic ordering of
|
|
* codewords of the same length is the same as the lexicographic ordering
|
|
* of the corresponding symbols. Consequently, we can sort the symbols
|
|
* primarily by codeword length and secondarily by symbol value, then
|
|
* reconstruct the prefix code by generating codewords lexicographically
|
|
* in that order.
|
|
*
|
|
* This function does not, however, generate the prefix code explicitly.
|
|
* Instead, it directly builds a table for decoding symbols using the
|
|
* code. The basic idea is this: given the next 'max_codeword_len' bits
|
|
* in the input, we can look up the decoded symbol by indexing a table
|
|
* containing 2**max_codeword_len entries. A codeword with length
|
|
* 'max_codeword_len' will have exactly one entry in this table, whereas
|
|
* a codeword shorter than 'max_codeword_len' will have multiple entries
|
|
* in this table. Precisely, a codeword of length n will be represented
|
|
* by 2**(max_codeword_len - n) entries in this table. The 0-based index
|
|
* of each such entry will contain the corresponding codeword as a prefix
|
|
* when zero-padded on the left to 'max_codeword_len' binary digits.
|
|
*
|
|
* That's the basic idea, but we implement two optimizations regarding
|
|
* the format of the decode table itself:
|
|
*
|
|
* - For many compression formats, the maximum codeword length is too
|
|
* long for it to be efficient to build the full decoding table
|
|
* whenever a new prefix code is used. Instead, we can build the table
|
|
* using only 2**table_bits entries, where 'table_bits' is some number
|
|
* less than or equal to 'max_codeword_len'. Then, only codewords of
|
|
* length 'table_bits' and shorter can be directly looked up. For
|
|
* longer codewords, the direct lookup instead produces the root of a
|
|
* binary tree. Using this tree, the decoder can do traditional
|
|
* bit-by-bit decoding of the remainder of the codeword. Child nodes
|
|
* are allocated in extra entries at the end of the table; leaf nodes
|
|
* contain symbols. Note that the long-codeword case is, in general,
|
|
* not performance critical, since in Huffman codes the most frequently
|
|
* used symbols are assigned the shortest codeword lengths.
|
|
*
|
|
* - When we decode a symbol using a direct lookup of the table, we still
|
|
* need to know its length so that the bitstream can be advanced by the
|
|
* appropriate number of bits. The simple solution is to simply retain
|
|
* the 'lens' array and use the decoded symbol as an index into it.
|
|
* However, this requires two separate array accesses in the fast path.
|
|
* The optimization is to store the length directly in the decode
|
|
* table. We use the bottom 11 bits for the symbol and the top 5 bits
|
|
* for the length. In addition, to combine this optimization with the
|
|
* previous one, we introduce a special case where the top 2 bits of
|
|
* the length are both set if the entry is actually the root of a
|
|
* binary tree.
|
|
*
|
|
* @decode_table:
|
|
* The array in which to create the decoding table. This must have
|
|
* a length of at least ((2**table_bits) + 2 * num_syms) entries.
|
|
*
|
|
* @num_syms:
|
|
* The number of symbols in the alphabet; also, the length of the
|
|
* 'lens' array. Must be less than or equal to 2048.
|
|
*
|
|
* @table_bits:
|
|
* The order of the decode table size, as explained above. Must be
|
|
* less than or equal to 13.
|
|
*
|
|
* @lens:
|
|
* An array of length @num_syms, indexable by symbol, that gives the
|
|
* length of the codeword, in bits, for that symbol. The length can
|
|
* be 0, which means that the symbol does not have a codeword
|
|
* assigned.
|
|
*
|
|
* @max_codeword_len:
|
|
* The longest codeword length allowed in the compression format.
|
|
* All entries in 'lens' must be less than or equal to this value.
|
|
* This must be less than or equal to 23.
|
|
*
|
|
* @working_space
|
|
* A temporary array of length '2 * (max_codeword_len + 1) +
|
|
* num_syms'.
|
|
*
|
|
* Returns 0 on success, or -1 if the lengths do not form a valid prefix
|
|
* code.
|
|
*/
|
|
int make_huffman_decode_table(u16 decode_table[], const u32 num_syms,
|
|
const u32 table_bits, const u8 lens[],
|
|
const u32 max_codeword_len,
|
|
u16 working_space[])
|
|
{
|
|
const u32 table_num_entries = 1 << table_bits;
|
|
u16 * const len_counts = &working_space[0];
|
|
u16 * const offsets = &working_space[1 * (max_codeword_len + 1)];
|
|
u16 * const sorted_syms = &working_space[2 * (max_codeword_len + 1)];
|
|
int left;
|
|
void *decode_table_ptr;
|
|
u32 sym_idx;
|
|
u32 codeword_len;
|
|
u32 stores_per_loop;
|
|
u32 decode_table_pos;
|
|
u32 len;
|
|
u32 sym;
|
|
|
|
/* Count how many symbols have each possible codeword length.
|
|
* Note that a length of 0 indicates the corresponding symbol is not
|
|
* used in the code and therefore does not have a codeword.
|
|
*/
|
|
for (len = 0; len <= max_codeword_len; len++)
|
|
len_counts[len] = 0;
|
|
for (sym = 0; sym < num_syms; sym++)
|
|
len_counts[lens[sym]]++;
|
|
|
|
/* We can assume all lengths are <= max_codeword_len, but we
|
|
* cannot assume they form a valid prefix code. A codeword of
|
|
* length n should require a proportion of the codespace equaling
|
|
* (1/2)^n. The code is valid if and only if the codespace is
|
|
* exactly filled by the lengths, by this measure.
|
|
*/
|
|
left = 1;
|
|
for (len = 1; len <= max_codeword_len; len++) {
|
|
left <<= 1;
|
|
left -= len_counts[len];
|
|
if (left < 0) {
|
|
/* The lengths overflow the codespace; that is, the code
|
|
* is over-subscribed.
|
|
*/
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (left) {
|
|
/* The lengths do not fill the codespace; that is, they form an
|
|
* incomplete set.
|
|
*/
|
|
if (left == (1 << max_codeword_len)) {
|
|
/* The code is completely empty. This is arguably
|
|
* invalid, but in fact it is valid in LZX and XPRESS,
|
|
* so we must allow it. By definition, no symbols can
|
|
* be decoded with an empty code. Consequently, we
|
|
* technically don't even need to fill in the decode
|
|
* table. However, to avoid accessing uninitialized
|
|
* memory if the algorithm nevertheless attempts to
|
|
* decode symbols using such a code, we zero out the
|
|
* decode table.
|
|
*/
|
|
memset(decode_table, 0,
|
|
table_num_entries * sizeof(decode_table[0]));
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/* Sort the symbols primarily by length and secondarily by symbol order.
|
|
*/
|
|
|
|
/* Initialize 'offsets' so that offsets[len] for 1 <= len <=
|
|
* max_codeword_len is the number of codewords shorter than 'len' bits.
|
|
*/
|
|
offsets[1] = 0;
|
|
for (len = 1; len < max_codeword_len; len++)
|
|
offsets[len + 1] = offsets[len] + len_counts[len];
|
|
|
|
/* Use the 'offsets' array to sort the symbols. Note that we do not
|
|
* include symbols that are not used in the code. Consequently, fewer
|
|
* than 'num_syms' entries in 'sorted_syms' may be filled.
|
|
*/
|
|
for (sym = 0; sym < num_syms; sym++)
|
|
if (lens[sym])
|
|
sorted_syms[offsets[lens[sym]]++] = sym;
|
|
|
|
/* Fill entries for codewords with length <= table_bits
|
|
* --- that is, those short enough for a direct mapping.
|
|
*
|
|
* The table will start with entries for the shortest codeword(s), which
|
|
* have the most entries. From there, the number of entries per
|
|
* codeword will decrease.
|
|
*/
|
|
decode_table_ptr = decode_table;
|
|
sym_idx = 0;
|
|
codeword_len = 1;
|
|
stores_per_loop = (1 << (table_bits - codeword_len));
|
|
for (; stores_per_loop != 0; codeword_len++, stores_per_loop >>= 1) {
|
|
u32 end_sym_idx = sym_idx + len_counts[codeword_len];
|
|
|
|
for (; sym_idx < end_sym_idx; sym_idx++) {
|
|
u16 entry;
|
|
u16 *p;
|
|
u32 n;
|
|
|
|
entry = ((u32)codeword_len << 11) | sorted_syms[sym_idx];
|
|
p = (u16 *)decode_table_ptr;
|
|
n = stores_per_loop;
|
|
|
|
do {
|
|
*p++ = entry;
|
|
} while (--n);
|
|
|
|
decode_table_ptr = p;
|
|
}
|
|
}
|
|
|
|
/* If we've filled in the entire table, we are done. Otherwise,
|
|
* there are codewords longer than table_bits for which we must
|
|
* generate binary trees.
|
|
*/
|
|
decode_table_pos = (u16 *)decode_table_ptr - decode_table;
|
|
if (decode_table_pos != table_num_entries) {
|
|
u32 j;
|
|
u32 next_free_tree_slot;
|
|
u32 cur_codeword;
|
|
|
|
/* First, zero out the remaining entries. This is
|
|
* necessary so that these entries appear as
|
|
* "unallocated" in the next part. Each of these entries
|
|
* will eventually be filled with the representation of
|
|
* the root node of a binary tree.
|
|
*/
|
|
j = decode_table_pos;
|
|
do {
|
|
decode_table[j] = 0;
|
|
} while (++j != table_num_entries);
|
|
|
|
/* We allocate child nodes starting at the end of the
|
|
* direct lookup table. Note that there should be
|
|
* 2*num_syms extra entries for this purpose, although
|
|
* fewer than this may actually be needed.
|
|
*/
|
|
next_free_tree_slot = table_num_entries;
|
|
|
|
/* Iterate through each codeword with length greater than
|
|
* 'table_bits', primarily in order of codeword length
|
|
* and secondarily in order of symbol.
|
|
*/
|
|
for (cur_codeword = decode_table_pos << 1;
|
|
codeword_len <= max_codeword_len;
|
|
codeword_len++, cur_codeword <<= 1) {
|
|
u32 end_sym_idx = sym_idx + len_counts[codeword_len];
|
|
|
|
for (; sym_idx < end_sym_idx; sym_idx++, cur_codeword++) {
|
|
/* 'sorted_sym' is the symbol represented by the
|
|
* codeword.
|
|
*/
|
|
u32 sorted_sym = sorted_syms[sym_idx];
|
|
u32 extra_bits = codeword_len - table_bits;
|
|
u32 node_idx = cur_codeword >> extra_bits;
|
|
|
|
/* Go through each bit of the current codeword
|
|
* beyond the prefix of length @table_bits and
|
|
* walk the appropriate binary tree, allocating
|
|
* any slots that have not yet been allocated.
|
|
*
|
|
* Note that the 'pointer' entry to the binary
|
|
* tree, which is stored in the direct lookup
|
|
* portion of the table, is represented
|
|
* identically to other internal (non-leaf)
|
|
* nodes of the binary tree; it can be thought
|
|
* of as simply the root of the tree. The
|
|
* representation of these internal nodes is
|
|
* simply the index of the left child combined
|
|
* with the special bits 0xC000 to distinguish
|
|
* the entry from direct mapping and leaf node
|
|
* entries.
|
|
*/
|
|
do {
|
|
/* At least one bit remains in the
|
|
* codeword, but the current node is an
|
|
* unallocated leaf. Change it to an
|
|
* internal node.
|
|
*/
|
|
if (decode_table[node_idx] == 0) {
|
|
decode_table[node_idx] =
|
|
next_free_tree_slot | 0xC000;
|
|
decode_table[next_free_tree_slot++] = 0;
|
|
decode_table[next_free_tree_slot++] = 0;
|
|
}
|
|
|
|
/* Go to the left child if the next bit
|
|
* in the codeword is 0; otherwise go to
|
|
* the right child.
|
|
*/
|
|
node_idx = decode_table[node_idx] & 0x3FFF;
|
|
--extra_bits;
|
|
node_idx += (cur_codeword >> extra_bits) & 1;
|
|
} while (extra_bits != 0);
|
|
|
|
/* We've traversed the tree using the entire
|
|
* codeword, and we're now at the entry where
|
|
* the actual symbol will be stored. This is
|
|
* distinguished from internal nodes by not
|
|
* having its high two bits set.
|
|
*/
|
|
decode_table[node_idx] = sorted_sym;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|