android-kvm / linux / 72641d8d60401a5f1e1a0431ceaf928680d34418 / . / fs / ntfs3 / lib / decompress_common.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; | |

} |