* and certain other details are quite similar, such as the method for storing
* Huffman codes. However, some of the main differences are:
*
- * - LZX preprocesses the data before attempting to compress it.
+ * - LZX preprocesses the data to attempt to make x86 machine code slightly more
+ * compressible before attempting to compress it further.
* - LZX uses a "main" alphabet which combines literals and matches, with the
* match symbols containing a "length header" (giving all or part of the match
* length) and a "position slot" (giving, roughly speaking, the order of
* dynamic Huffman blocks ("aligned offset" and "verbatim").
* - LZX has a minimum match length of 2 rather than 3.
* - In LZX, match offsets 0 through 2 actually represent entries in an LRU
- * queue of match offsets.
+ * queue of match offsets. This is very useful for certain types of files,
+ * such as binary files that have repeating records.
*
* Algorithms
* ==========
*
* The "slow" algorithm to generate LZX-compressed data is roughly as follows:
*
- * 1. Preprocess the input data to translate the targets of x86 call instructions
- * to absolute offsets.
+ * 1. Preprocess the input data to translate the targets of x86 call
+ * instructions to absolute offsets.
*
- * 2. Build the suffix array and inverse suffix array for the input data.
+ * 2. Build the suffix array and inverse suffix array for the input data. The
+ * suffix array contains the indices of all suffixes of the input data,
+ * sorted lexcographically by the corresponding suffixes. The "position" of
+ * a suffix is the index of that suffix in the original string, whereas the
+ * "rank" of a suffix is the index at which that suffix's position is found
+ * in the suffix array.
*
* 3. Build the longest common prefix array corresponding to the suffix array.
*
- * 4. For each suffix rank, find the highest lower suffix rank that has a
- * lower position, the lowest higher suffix rank that has a lower position,
- * and the length of the common prefix shared between each. (Position =
- * index of suffix in original string, rank = index of suffix in suffix
- * array.) This information is later used to link suffix ranks into a
- * doubly-linked list for searching the suffix array.
+ * 4. For each suffix, find the highest lower ranked suffix that has a lower
+ * position, the lowest higher ranked suffix that has a lower position, and
+ * the length of the common prefix shared between each. This information is
+ * later used to link suffix ranks into a doubly-linked list for searching
+ * the suffix array.
*
* 5. Set a default cost model for matches/literals.
*
- * 6. Determine the lowest cost sequence of LZ77 matches ((offset, length) pairs)
- * and literal bytes to divide the input into. Raw match-finding is done by
- * searching the suffix array using a linked list to avoid considering any
- * suffixes that start after the current position. Each run of the
- * match-finder returns the lowest-cost longest match as well as any shorter
- * matches that have even lower costs. Each such run also adds the suffix
- * rank of the current position into the linked list being used to search the
- * suffix array. Parsing, or match-choosing, is solved as a minimum-cost
- * path problem using a forward "optimal parsing" algorithm based on the
- * Deflate encoder from 7-Zip. This algorithm moves forward calculating the
- * minimum cost to reach each byte until either a very long match is found or
- * until a position is found at which no matches start or overlap.
+ * 6. Determine the lowest cost sequence of LZ77 matches ((offset, length)
+ * pairs) and literal bytes to divide the input into. Raw match-finding is
+ * done by searching the suffix array using a linked list to avoid
+ * considering any suffixes that start after the current position. Each run
+ * of the match-finder returns the approximate lowest-cost longest match as
+ * well as any shorter matches that have even lower approximate costs. Each
+ * such run also adds the suffix rank of the current position into the linked
+ * list being used to search the suffix array. Parsing, or match-choosing,
+ * is solved as a minimum-cost path problem using a forward "optimal parsing"
+ * algorithm based on the Deflate encoder from 7-Zip. This algorithm moves
+ * forward calculating the minimum cost to reach each byte until either a
+ * very long match is found or until a position is found at which no matches
+ * start or overlap.
*
* 7. Build the Huffman codes needed to output the matches/literals.
*
* 9. Output the resulting block using the match/literal sequences and the
* Huffman codes that were computed for the block.
*
+ * Note: the algorithm does not yet attempt to split the input into multiple LZX
+ * blocks; it instead uses a series of blocks of LZX_DIV_BLOCK_SIZE bytes.
+ *
* Fast algorithm
* --------------
*
* The fast algorithm (and the only one available in wimlib v1.5.1 and earlier)
* spends much less time on the main bottlenecks of the compression process ---
- * that is the match finding, match choosing, and block splitting. Matches are
- * found and chosen with hash chains using a greedy parse with one position of
- * look-ahead. No block splitting is done; only compressing the full input into
- * an aligned offset block is considered.
- *
- * API
- * ===
- *
- * The old API (retained for backward compatibility) consists of just one function:
- *
- * wimlib_lzx_compress()
- *
- * The new compressor has more potential parameters and needs more memory, so
- * the new API ties up memory allocations and compression parameters into a
- * context:
- *
- * wimlib_lzx_alloc_context()
- * wimlib_lzx_compress2()
- * wimlib_lzx_free_context()
- *
- * Both wimlib_lzx_compress() and wimlib_lzx_compress2() are designed to
- * compress an in-memory buffer of up to 32768 bytes. There is no sliding
- * window. This is suitable for the WIM format, which uses fixed-size chunks
- * that are seemingly always 32768 bytes. If needed, the compressor potentially
- * could be extended to support a larger and/or sliding window.
- *
- * Both wimlib_lzx_compress() and wimlib_lzx_compress2() return 0 if the data
- * could not be compressed to less than the size of the uncompressed data.
- * Again, this is suitable for the WIM format, which stores such data chunks
- * uncompressed.
- *
- * The functions in this API are exported from the library, although this is
- * only in case other programs happen to have uses for it other than WIM
- * reading/writing as already handled through the rest of the library.
+ * that is, the match finding and match choosing. Matches are found and chosen
+ * with hash chains using a greedy parse with one position of look-ahead. No
+ * block splitting is done; only compressing the full input into an aligned
+ * offset block is considered.
*
* Acknowledgments
* ===============
* Acknowledgments to several open-source projects and research papers that made
* it possible to implement this code:
*
- * - divsufsort (author: Yuta Mori), for the suffix array construction code.
+ * - divsufsort (author: Yuta Mori), for the suffix array construction code,
+ * located in a separate directory (divsufsort/).
*
* - "Linear-Time Longest-Common-Prefix Computation in Suffix Arrays and Its
* Applications" (Kasai et al. 2001), for the LCP array computation.
* (match-choosing).
*
* - zlib (author: Jean-loup Gailly and Mark Adler), for the hash table
- * match-finding algorithm.
+ * match-finding algorithm (used in lz77.c).
*
* - lzx-compress (author: Matthew T. Russotto), on which some parts of this
* code were originally based.
#endif
#include "wimlib.h"
-#include "wimlib/compress.h"
+#include "wimlib/compressor_ops.h"
+#include "wimlib/compress_common.h"
+#include "wimlib/endianness.h"
#include "wimlib/error.h"
+#include "wimlib/lz_hash.h"
+#include "wimlib/lz_sarray.h"
#include "wimlib/lzx.h"
#include "wimlib/util.h"
-#include <pthread.h>
-#include <math.h>
#include <string.h>
#ifdef ENABLE_LZX_DEBUG
-# include <wimlib/decompress.h>
+# include "wimlib/decompress_common.h"
#endif
-#include "divsufsort/divsufsort.h"
-
-typedef freq_t input_idx_t;
-typedef u32 sym_cost_t;
typedef u32 block_cost_t;
-#define INFINITE_SYM_COST ((sym_cost_t)~0U)
-#define INFINITE_BLOCK_COST ((block_cost_t)~0U)
+#define INFINITE_BLOCK_COST (~(block_cost_t)0)
#define LZX_OPTIM_ARRAY_SIZE 4096
-/* Currently, this constant can't simply be changed because the code currently
- * uses a static number of position slots (and may make other assumptions as
- * well). */
-#define LZX_MAX_WINDOW_SIZE 32768
-
-/* This may be WIM-specific */
-#define LZX_DEFAULT_BLOCK_SIZE 32768
+#define LZX_DIV_BLOCK_SIZE 32768
#define LZX_MAX_CACHE_PER_POS 10
/* Codewords for the LZX main, length, and aligned offset Huffman codes */
struct lzx_codewords {
- u16 main[LZX_MAINCODE_NUM_SYMBOLS];
+ u16 main[LZX_MAINCODE_MAX_NUM_SYMBOLS];
u16 len[LZX_LENCODE_NUM_SYMBOLS];
u16 aligned[LZX_ALIGNEDCODE_NUM_SYMBOLS];
};
* A 0 length means the codeword has zero frequency.
*/
struct lzx_lens {
- u8 main[LZX_MAINCODE_NUM_SYMBOLS];
+ u8 main[LZX_MAINCODE_MAX_NUM_SYMBOLS];
u8 len[LZX_LENCODE_NUM_SYMBOLS];
u8 aligned[LZX_ALIGNEDCODE_NUM_SYMBOLS];
};
* --- generally a high cost, since even if it gets used in the next iteration,
* it probably will not be used very times. */
struct lzx_costs {
- sym_cost_t main[LZX_MAINCODE_NUM_SYMBOLS];
- sym_cost_t len[LZX_LENCODE_NUM_SYMBOLS];
- sym_cost_t aligned[LZX_ALIGNEDCODE_NUM_SYMBOLS];
+ u8 main[LZX_MAINCODE_MAX_NUM_SYMBOLS];
+ u8 len[LZX_LENCODE_NUM_SYMBOLS];
+ u8 aligned[LZX_ALIGNEDCODE_NUM_SYMBOLS];
};
/* The LZX main, length, and aligned offset Huffman codes */
/* Tables for tallying symbol frequencies in the three LZX alphabets */
struct lzx_freqs {
- freq_t main[LZX_MAINCODE_NUM_SYMBOLS];
- freq_t len[LZX_LENCODE_NUM_SYMBOLS];
- freq_t aligned[LZX_ALIGNEDCODE_NUM_SYMBOLS];
+ input_idx_t main[LZX_MAINCODE_MAX_NUM_SYMBOLS];
+ input_idx_t len[LZX_LENCODE_NUM_SYMBOLS];
+ input_idx_t aligned[LZX_ALIGNEDCODE_NUM_SYMBOLS];
};
/* LZX intermediate match/literal format */
*
* 8-24 position footer. This is the offset of the real formatted
* offset from the position base. This can be at most 17 bits
- * (since lzx_extra_bits[LZX_NUM_POSITION_SLOTS - 1] is 17).
+ * (since lzx_extra_bits[LZX_MAX_POSITION_SLOTS - 1] is 17).
*
* 0-7 length of match, minus 2. This can be at most
* (LZX_MAX_MATCH_LEN - 2) == 255, so it will fit in 8 bits. */
u32 data;
};
-/* Raw LZ match/literal format: just a length and offset.
- *
- * The length is the number of bytes of the match, and the offset is the number
- * of bytes back in the input the match is from the current position.
- *
- * If @len < LZX_MIN_MATCH_LEN, then it's really just a literal byte and @offset is
- * meaningless. */
-struct raw_match {
- u16 len;
- input_idx_t offset;
-};
-
/* Specification for an LZX block. */
struct lzx_block_spec {
struct lzx_codes codes;
};
-/*
- * An array of these structures is used during the match-choosing algorithm.
- * They correspond to consecutive positions in the window and are used to keep
- * track of the cost to reach each position, and the match/literal choices that
- * need to be chosen to reach that position.
- */
-struct lzx_optimal {
- /* The approximate minimum cost, in bits, to reach this position in the
- * window which has been found so far. */
- block_cost_t cost;
-
- /* The union here is just for clarity, since the fields are used in two
- * slightly different ways. Initially, the @prev structure is filled in
- * first, and links go from later in the window to earlier in the
- * window. Later, @next structure is filled in and links go from
- * earlier in the window to later in the window. */
- union {
- struct {
- /* Position of the start of the match or literal that
- * was taken to get to this position in the approximate
- * minimum-cost parse. */
- input_idx_t link;
-
- /* Offset (as in an LZ (length, offset) pair) of the
- * match or literal that was taken to get to this
- * position in the approximate minimum-cost parse. */
- input_idx_t match_offset;
- } prev;
- struct {
- /* Position at which the match or literal starting at
- * this position ends in the minimum-cost parse. */
- input_idx_t link;
-
- /* Offset (as in an LZ (length, offset) pair) of the
- * match or literal starting at this position in the
- * approximate minimum-cost parse. */
- input_idx_t match_offset;
- } next;
- };
-
- /* The match offset LRU queue that will exist when the approximate
- * minimum-cost path to reach this position is taken. */
- struct lzx_lru_queue queue;
-};
-
-/* Suffix array link */
-struct salink {
- /* Rank of highest ranked suffix that has rank lower than the suffix
- * corresponding to this structure and either has a lower position
- * (initially) or has a position lower than the highest position at
- * which matches have been searched for so far, or -1 if there is no
- * such suffix. */
- input_idx_t prev;
-
- /* Rank of lowest ranked suffix that has rank greater than the suffix
- * corresponding to this structure and either has a lower position
- * (intially) or has a position lower than the highest position at which
- * matches have been searched for so far, or -1 if there is no such
- * suffix. */
- input_idx_t next;
-
- /* Length of longest common prefix between the suffix corresponding to
- * this structure and the suffix with rank @prev, or 0 if @prev is -1.
- */
- input_idx_t lcpprev;
-
- /* Length of longest common prefix between the suffix corresponding to
- * this structure and the suffix with rank @next, or 0 if @next is -1.
- */
- input_idx_t lcpnext;
-};
+/* Include template for the match-choosing algorithm. */
+#define LZ_COMPRESSOR struct lzx_compressor
+#define LZ_ADAPTIVE_STATE struct lzx_lru_queue
+struct lzx_compressor;
+#include "wimlib/lz_optimal.h"
/* State of the LZX compressor. */
struct lzx_compressor {
/* The parameters that were used to create the compressor. */
- struct wimlib_lzx_params params;
+ struct wimlib_lzx_compressor_params params;
/* The buffer of data to be compressed.
*
* 0xe8 byte preprocessing is done directly on the data here before
* further compression.
*
- * Note that this compressor does *not* use a sliding window!!!! It's
- * not needed in the WIM format, since every chunk is compressed
+ * Note that this compressor does *not* use a real sliding window!!!!
+ * It's not needed in the WIM format, since every chunk is compressed
* independently. This is by design, to allow random access to the
* chunks.
*
* We reserve a few extra bytes to potentially allow reading off the end
- * of the array in the match-finding code for optimization purposes.
- */
- u8 window[LZX_MAX_WINDOW_SIZE + 12];
+ * of the array in the match-finding code for optimization purposes
+ * (currently only needed for the hash chain match-finder). */
+ u8 *window;
/* Number of bytes of data to be compressed, which is the number of
* bytes of data in @window that are actually valid. */
input_idx_t window_size;
+ /* Allocated size of the @window. */
+ input_idx_t max_window_size;
+
+ /* Number of symbols in the main alphabet (depends on the
+ * @max_window_size since it determines the maximum allowed offset). */
+ unsigned num_main_syms;
+
/* The current match offset LRU queue. */
struct lzx_lru_queue queue;
* block. */
struct lzx_match *chosen_matches;
- struct raw_match *cached_matches;
- unsigned cached_matches_pos;
- bool matches_cached;
-
/* Information about the LZX blocks the preprocessed input was divided
* into. */
struct lzx_block_spec *block_specs;
* codewords. */
struct lzx_codes zero_codes;
- /* Slow algorithm only: The current cost model. */
+ /* The current cost model. */
struct lzx_costs costs;
- /* Slow algorithm only: Suffix array for window.
- * This is a mapping from suffix rank to suffix position.
- *
- * Suffix rank means the index of the suffix in the sorted list of
- * suffixes, whereas suffix position means the index in the string at
- * which the suffix starts.
- */
- input_idx_t *SA;
-
- /* Slow algorithm only: Inverse suffix array for window.
- * This is a mapping from suffix position to suffix rank.
- * In other words, if 0 <= r < window_size, then ISA[SA[r]] == r. */
- input_idx_t *ISA;
+ /* Fast algorithm only: Array of hash table links. */
+ input_idx_t *prev_tab;
- /* Slow algorithm only: Longest Common Prefix array. LCP[i] is the
- * number of initial bytes that the suffixes at positions SA[i - 1] and
- * SA[i] share. LCP[0] is undefined. */
- input_idx_t *LCP;
+ /* Slow algorithm only: Suffix array match-finder. */
+ struct lz_sarray lz_sarray;
- /* Slow algorithm only: Suffix array links.
- *
- * During a linear scan of the input string to find matches, this array
- * used to keep track of which rank suffixes in the suffix array appear
- * before the current position. Instead of searching in the original
- * suffix array, scans for matches at a given position traverse a linked
- * list containing only suffixes that appear before that position. */
- struct salink *salink;
-
- /* Slow algorithm only: Position in window of next match to return.
- * This cannot simply be modified, as the match-finder must still be
- * synchronized on the same position. To seek forwards or backwards,
- * use lzx_lz_skip_bytes() or lzx_lz_rewind_matchfinder(), respectively.
- */
+ /* Position in window of next match to return. */
input_idx_t match_window_pos;
- /* Slow algorithm only: The match-finder shall ensure the length of
- * matches does not exceed this position in the input. */
+ /* The match-finder shall ensure the length of matches does not exceed
+ * this position in the input. */
input_idx_t match_window_end;
- /* Slow algorithm only: Temporary space used for match-choosing
- * algorithm.
- *
- * The size of this array must be at least LZX_MAX_MATCH_LEN but
- * otherwise is arbitrary. More space simply allows the match-choosing
- * algorithm to potentially find better matches (depending on the input,
- * as always). */
- struct lzx_optimal *optimum;
+ /* Matches found by the match-finder are cached in the following array
+ * to achieve a slight speedup when the same matches are needed on
+ * subsequent passes. This is suboptimal because different matches may
+ * be preferred with different cost models, but seems to be a worthwhile
+ * speedup. */
+ struct raw_match *cached_matches;
+ unsigned cached_matches_pos;
+ bool matches_cached;
- /* Slow algorithm only: Variables used by the match-choosing algorithm.
- *
- * When matches have been chosen, optimum_cur_idx is set to the position
- * in the window of the next match/literal to return and optimum_end_idx
- * is set to the position in the window at the end of the last
- * match/literal to return. */
- u32 optimum_cur_idx;
- u32 optimum_end_idx;
+ /* Match chooser. */
+ struct lz_match_chooser mc;
};
-/* Returns the LZX position slot that corresponds to a given formatted offset.
- *
- * Logically, this returns the smallest i such that
- * formatted_offset >= lzx_position_base[i].
- *
- * The actual implementation below takes advantage of the regularity of the
- * numbers in the lzx_position_base array to calculate the slot directly from
- * the formatted offset without actually looking at the array.
- */
-static _always_inline_attribute unsigned
-lzx_get_position_slot_raw(unsigned formatted_offset)
-{
-#if 0
- /*
- * Slots 36-49 (formatted_offset >= 262144) can be found by
- * (formatted_offset/131072) + 34 == (formatted_offset >> 17) + 34;
- * however, this check for formatted_offset >= 262144 is commented out
- * because WIM chunks cannot be that large.
- */
- if (formatted_offset >= 262144) {
- return (formatted_offset >> 17) + 34;
- } else
-#endif
- {
- /* Note: this part here only works if:
- *
- * 2 <= formatted_offset < 655360
- *
- * It is < 655360 because the frequency of the position bases
- * increases starting at the 655360 entry, and it is >= 2
- * because the below calculation fails if the most significant
- * bit is lower than the 2's place. */
- LZX_ASSERT(2 <= formatted_offset && formatted_offset < 655360);
- unsigned mssb_idx = bsr32(formatted_offset);
- return (mssb_idx << 1) |
- ((formatted_offset >> (mssb_idx - 1)) & 1);
- }
-}
-
-
/* Returns the LZX position slot that corresponds to a given match offset,
- * taking into account the recent offset queue (and optionally updating it). */
-static _always_inline_attribute unsigned
+ * taking into account the recent offset queue and updating it if the offset is
+ * found in it. */
+static unsigned
lzx_get_position_slot(unsigned offset, struct lzx_lru_queue *queue)
{
unsigned position_slot;
* LRU queue because repeat matches are simply
* swapped to the front. */
swap(queue->R[0], queue->R[i]);
- /* For recent offsets, the position slot is simply the
- * index of the entry in the queue. */
+ /* The resulting position slot is simply the first index
+ * at which the offset was found in the queue. */
return i;
}
}
* a set of tables that map symbols to codewords and codeword lengths. */
static void
lzx_make_huffman_codes(const struct lzx_freqs *freqs,
- struct lzx_codes *codes)
+ struct lzx_codes *codes,
+ unsigned num_main_syms)
{
- make_canonical_huffman_code(LZX_MAINCODE_NUM_SYMBOLS,
+ make_canonical_huffman_code(num_main_syms,
LZX_MAX_MAIN_CODEWORD_LEN,
freqs->main,
codes->lens.main,
}
/*
- * Output an LZX match.
- *
- * @out: The bitstream to write the match to.
- * @block_type: The type of the LZX block (LZX_BLOCKTYPE_ALIGNED or LZX_BLOCKTYPE_VERBATIM)
- * @match: The match.
- * @codes: Pointer to a structure that contains the codewords for the
- * main, length, and aligned offset Huffman codes.
+ * Output a precomputed LZX match.
+ *
+ * @out:
+ * The bitstream to which to write the match.
+ * @block_type:
+ * The type of the LZX block (LZX_BLOCKTYPE_ALIGNED or
+ * LZX_BLOCKTYPE_VERBATIM)
+ * @match:
+ * The match, as a (length, offset) pair.
+ * @codes:
+ * Pointer to a structure that contains the codewords for the main, length,
+ * and aligned offset Huffman codes for the current LZX compressed block.
*/
static void
lzx_write_match(struct output_bitstream *out, int block_type,
}
/* Combine the position slot with the length header into a single symbol
- * that will be encoded with the main tree.
+ * that will be encoded with the main code.
*
* The actual main symbol is offset by LZX_NUM_CHARS because values
* under LZX_NUM_CHARS are used to indicate a literal byte rather than a
/* For aligned offset blocks with at least 3 extra bits, output the
* verbatim bits literally, then the aligned bits encoded using the
- * aligned offset tree. Otherwise, only the verbatim bits need to be
+ * aligned offset code. Otherwise, only the verbatim bits need to be
* output. */
if ((block_type == LZX_BLOCKTYPE_ALIGNED) && (num_extra_bits >= 3)) {
}
}
+/* Output an LZX literal (encoded with the main Huffman code). */
+static void
+lzx_write_literal(struct output_bitstream *out, u8 literal,
+ const struct lzx_codes *codes)
+{
+ bitstream_put_bits(out,
+ codes->codewords.main[literal],
+ codes->lens.main[literal]);
+}
+
static unsigned
lzx_build_precode(const u8 lens[restrict],
const u8 prev_lens[restrict],
const unsigned num_syms,
- freq_t precode_freqs[restrict LZX_PRECODE_NUM_SYMBOLS],
+ input_idx_t precode_freqs[restrict LZX_PRECODE_NUM_SYMBOLS],
u8 output_syms[restrict num_syms],
u8 precode_lens[restrict LZX_PRECODE_NUM_SYMBOLS],
u16 precode_codewords[restrict LZX_PRECODE_NUM_SYMBOLS],
* literally.
*
* output_syms[] will be filled in with the length symbols that will be
- * output, including RLE codes, not yet encoded using the pre-tree.
+ * output, including RLE codes, not yet encoded using the precode.
*
* cur_run_len keeps track of how many code word lengths are in the
* current run of identical lengths. */
*
* The extra length symbol is encoded as a difference
* from the length of the codeword for the first symbol
- * in the run in the previous tree.
+ * in the run in the previous code.
* */
while (cur_run_len >= 4) {
unsigned additional_bits;
/* Any remaining lengths in the run are outputted without RLE,
* as a difference from the length of that codeword in the
- * previous tree. */
+ * previous code. */
while (cur_run_len > 0) {
signed char delta;
}
/*
- * Writes a compressed Huffman code to the output, preceded by the precode for
- * it.
- *
- * The Huffman code is represented in the output as a series of path lengths
- * from which the canonical Huffman code can be reconstructed. The path lengths
- * themselves are compressed using a separate Huffman code, the precode, which
- * consists of LZX_PRECODE_NUM_SYMBOLS (= 20) symbols that cover all possible
- * code lengths, plus extra codes for repeated lengths. The path lengths of the
- * precode precede the path lengths of the larger code and are uncompressed,
- * consisting of 20 entries of 4 bits each.
- *
- * @out: Bitstream to write the code to.
- * @lens: The code lengths for the Huffman code, indexed by symbol.
- * @prev_lens: Code lengths for this Huffman code, indexed by symbol,
- * in the *previous block*, or all zeroes if this is the
- * first block.
- * @num_syms: The number of symbols in the code.
+ * Output a Huffman code in the compressed form used in LZX.
+ *
+ * The Huffman code is represented in the output as a logical series of codeword
+ * lengths from which the Huffman code, which must be in canonical form, can be
+ * reconstructed.
+ *
+ * The codeword lengths are themselves compressed using a separate Huffman code,
+ * the "precode", which contains a symbol for each possible codeword length in
+ * the larger code as well as several special symbols to represent repeated
+ * codeword lengths (a form of run-length encoding). The precode is itself
+ * constructed in canonical form, and its codeword lengths are represented
+ * literally in 20 4-bit fields that immediately precede the compressed codeword
+ * lengths of the larger code.
+ *
+ * Furthermore, the codeword lengths of the larger code are actually represented
+ * as deltas from the codeword lengths of the corresponding code in the previous
+ * block.
+ *
+ * @out:
+ * Bitstream to which to write the compressed Huffman code.
+ * @lens:
+ * The codeword lengths, indexed by symbol, in the Huffman code.
+ * @prev_lens:
+ * The codeword lengths, indexed by symbol, in the corresponding Huffman
+ * code in the previous block, or all zeroes if this is the first block.
+ * @num_syms:
+ * The number of symbols in the Huffman code.
*/
static void
lzx_write_compressed_code(struct output_bitstream *out,
const u8 prev_lens[restrict],
unsigned num_syms)
{
- freq_t precode_freqs[LZX_PRECODE_NUM_SYMBOLS];
+ input_idx_t precode_freqs[LZX_PRECODE_NUM_SYMBOLS];
u8 output_syms[num_syms];
u8 precode_lens[LZX_PRECODE_NUM_SYMBOLS];
u16 precode_codewords[LZX_PRECODE_NUM_SYMBOLS];
}
/*
- * Writes all compressed matches and literal bytes in an LZX block to the the
- * output bitstream.
+ * Write all matches and literal bytes (which were precomputed) in an LZX
+ * compressed block to the output bitstream in the final compressed
+ * representation.
*
* @ostream
* The output bitstream.
* @block_type
- * The type of the block (LZX_BLOCKTYPE_ALIGNED or LZX_BLOCKTYPE_VERBATIM).
+ * The chosen type of the LZX compressed block (LZX_BLOCKTYPE_ALIGNED or
+ * LZX_BLOCKTYPE_VERBATIM).
* @match_tab
- * The array of matches/literals that will be output (length @match_count).
+ * The array of matches/literals to output.
* @match_count
- * Number of matches/literals to be output.
+ * Number of matches/literals to output (length of @match_tab).
* @codes
- * Pointer to a structure that contains the codewords for the main, length,
- * and aligned offset Huffman codes.
+ * The main, length, and aligned offset Huffman codes for the current
+ * LZX compressed block.
*/
static void
lzx_write_matches_and_literals(struct output_bitstream *ostream,
for (unsigned i = 0; i < match_count; i++) {
struct lzx_match match = match_tab[i];
- /* High bit of the match indicates whether the match is an
- * actual match (1) or a literal uncompressed byte (0) */
- if (match.data & 0x80000000) {
- /* match */
- lzx_write_match(ostream, block_type,
- match, codes);
- } else {
- /* literal byte */
- bitstream_put_bits(ostream,
- codes->codewords.main[match.data],
- codes->lens.main[match.data]);
- }
+ /* The high bit of the 32-bit intermediate representation
+ * indicates whether the item is an actual LZ-style match (1) or
+ * a literal byte (0). */
+ if (match.data & 0x80000000)
+ lzx_write_match(ostream, block_type, match, codes);
+ else
+ lzx_write_literal(ostream, match.data, codes);
}
}
static void
-lzx_assert_codes_valid(const struct lzx_codes * codes)
+lzx_assert_codes_valid(const struct lzx_codes * codes, unsigned num_main_syms)
{
#ifdef ENABLE_LZX_DEBUG
unsigned i;
- for (i = 0; i < LZX_MAINCODE_NUM_SYMBOLS; i++)
+ for (i = 0; i < num_main_syms; i++)
LZX_ASSERT(codes->lens.main[i] <= LZX_MAX_MAIN_CODEWORD_LEN);
for (i = 0; i < LZX_LENCODE_NUM_SYMBOLS; i++)
const unsigned tablebits = 10;
u16 decode_table[(1 << tablebits) +
- (2 * max(LZX_MAINCODE_NUM_SYMBOLS, LZX_LENCODE_NUM_SYMBOLS))]
+ (2 * max(num_main_syms, LZX_LENCODE_NUM_SYMBOLS))]
_aligned_attribute(DECODE_TABLE_ALIGNMENT);
LZX_ASSERT(0 == make_huffman_decode_table(decode_table,
- LZX_MAINCODE_NUM_SYMBOLS,
+ num_main_syms,
min(tablebits, LZX_MAINCODE_TABLEBITS),
codes->lens.main,
LZX_MAX_MAIN_CODEWORD_LEN));
static void
lzx_write_compressed_block(int block_type,
unsigned block_size,
+ unsigned max_window_size,
+ unsigned num_main_syms,
struct lzx_match * chosen_matches,
unsigned num_chosen_matches,
const struct lzx_codes * codes,
LZX_ASSERT(block_type == LZX_BLOCKTYPE_ALIGNED ||
block_type == LZX_BLOCKTYPE_VERBATIM);
- LZX_ASSERT(block_size <= LZX_MAX_WINDOW_SIZE);
- LZX_ASSERT(num_chosen_matches <= LZX_MAX_WINDOW_SIZE);
- lzx_assert_codes_valid(codes);
+ lzx_assert_codes_valid(codes, num_main_syms);
/* The first three bits indicate the type of block and are one of the
* LZX_BLOCKTYPE_* constants. */
- bitstream_put_bits(ostream, block_type, LZX_BLOCKTYPE_NBITS);
+ bitstream_put_bits(ostream, block_type, 3);
- /* The next bit indicates whether the block size is the default (32768),
- * indicated by a 1 bit, or whether the block size is given by the next
- * 16 bits, indicated by a 0 bit. */
+ /* Output the block size.
+ *
+ * The original LZX format seemed to always encode the block size in 3
+ * bytes. However, the implementation in WIMGAPI, as used in WIM files,
+ * uses the first bit to indicate whether the block is the default size
+ * (32768) or a different size given explicitly by the next 16 bits.
+ *
+ * By default, this compressor uses a window size of 32768 and therefore
+ * follows the WIMGAPI behavior. However, this compressor also supports
+ * window sizes greater than 32768 bytes, which do not appear to be
+ * supported by WIMGAPI. In such cases, we retain the default size bit
+ * to mean a size of 32768 bytes but output non-default block size in 24
+ * bits rather than 16. The compatibility of this behavior is unknown
+ * because WIMs created with chunk size greater than 32768 can seemingly
+ * only be opened by wimlib anyway. */
if (block_size == LZX_DEFAULT_BLOCK_SIZE) {
bitstream_put_bits(ostream, 1, 1);
} else {
bitstream_put_bits(ostream, 0, 1);
- bitstream_put_bits(ostream, block_size, LZX_BLOCKSIZE_NBITS);
+
+ if (max_window_size >= 65536)
+ bitstream_put_bits(ostream, block_size >> 16, 8);
+
+ bitstream_put_bits(ostream, block_size, 16);
}
/* Write out lengths of the main code. Note that the LZX specification
* incorrectly states that the aligned offset code comes after the
- * length code, but in fact it is the very first tree to be written
+ * length code, but in fact it is the very first code to be written
* (before the main code). */
if (block_type == LZX_BLOCKTYPE_ALIGNED)
for (i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++)
LZX_DEBUG("Writing main code...");
- /* Write the pre-tree and lengths for the first LZX_NUM_CHARS symbols in
+ /* Write the precode and lengths for the first LZX_NUM_CHARS symbols in
* the main code, which are the codewords for literal bytes. */
lzx_write_compressed_code(ostream,
codes->lens.main,
prev_codes->lens.main,
LZX_NUM_CHARS);
- /* Write the pre-tree and lengths for the rest of the main code, which
+ /* Write the precode and lengths for the rest of the main code, which
* are the codewords for match headers. */
lzx_write_compressed_code(ostream,
codes->lens.main + LZX_NUM_CHARS,
prev_codes->lens.main + LZX_NUM_CHARS,
- LZX_MAINCODE_NUM_SYMBOLS - LZX_NUM_CHARS);
+ num_main_syms - LZX_NUM_CHARS);
LZX_DEBUG("Writing length code...");
- /* Write the pre-tree and lengths for the length code. */
+ /* Write the precode and lengths for the length code. */
lzx_write_compressed_code(ostream,
codes->lens.len,
prev_codes->lens.len,
static void
lzx_write_all_blocks(struct lzx_compressor *ctx, struct output_bitstream *ostream)
{
+
const struct lzx_codes *prev_codes = &ctx->zero_codes;
for (unsigned i = 0; i < ctx->num_blocks; i++) {
const struct lzx_block_spec *spec = &ctx->block_specs[i];
lzx_write_compressed_block(spec->block_type,
spec->block_size,
+ ctx->max_window_size,
+ ctx->num_main_syms,
&ctx->chosen_matches[spec->chosen_matches_start_pos],
spec->num_chosen_matches,
&spec->codes,
prev_codes,
ostream);
+
prev_codes = &spec->codes;
}
}
/* Constructs an LZX match from a literal byte and updates the main code symbol
* frequencies. */
static u32
-lzx_record_literal(u8 literal, void *_freqs)
+lzx_tally_literal(u8 lit, struct lzx_freqs *freqs)
{
- struct lzx_freqs *freqs = _freqs;
-
- freqs->main[literal]++;
-
- return (u32)literal;
+ freqs->main[lit]++;
+ return (u32)lit;
}
/* Constructs an LZX match from an offset and a length, and updates the LRU
* alphabets. The return value is a 32-bit number that provides the match in an
* intermediate representation documented below. */
static u32
-lzx_record_match(unsigned match_offset, unsigned match_len,
- void *_freqs, void *_queue)
+lzx_tally_match(unsigned match_len, unsigned match_offset,
+ struct lzx_freqs *freqs, struct lzx_lru_queue *queue)
{
- struct lzx_freqs *freqs = _freqs;
- struct lzx_lru_queue *queue = _queue;
unsigned position_slot;
unsigned position_footer;
u32 len_header;
freqs->aligned[position_footer & 7]++;
/* Pack the position slot, position footer, and match length into an
- * intermediate representation.
- *
- * bits description
- * ---- -----------------------------------------------------------
- *
- * 31 1 if a match, 0 if a literal.
- *
- * 30-25 position slot. This can be at most 50, so it will fit in 6
- * bits.
- *
- * 8-24 position footer. This is the offset of the real formatted
- * offset from the position base. This can be at most 17 bits
- * (since lzx_extra_bits[LZX_NUM_POSITION_SLOTS - 1] is 17).
- *
- * 0-7 length of match, offset by 2. This can be at most
- * (LZX_MAX_MATCH_LEN - 2) == 255, so it will fit in 8 bits. */
- BUILD_BUG_ON(LZX_NUM_POSITION_SLOTS > 64);
- LZX_ASSERT(lzx_get_num_extra_bits(LZX_NUM_POSITION_SLOTS - 1) <= 17);
- BUILD_BUG_ON(LZX_MAX_MATCH_LEN - LZX_MIN_MATCH_LEN + 1 > 256);
+ * intermediate representation. See `struct lzx_match' for details.
+ */
+ LZX_ASSERT(LZX_MAX_POSITION_SLOTS <= 64);
+ LZX_ASSERT(lzx_get_num_extra_bits(LZX_MAX_POSITION_SLOTS - 1) <= 17);
+ LZX_ASSERT(LZX_MAX_MATCH_LEN - LZX_MIN_MATCH_LEN + 1 <= 256);
+
+ LZX_ASSERT(position_slot <= (1U << (31 - 25)) - 1);
+ LZX_ASSERT(position_footer <= (1U << (25 - 8)) - 1);
+ LZX_ASSERT(adjusted_match_len <= (1U << (8 - 0)) - 1);
return 0x80000000 |
(position_slot << 25) |
(position_footer << 8) |
(adjusted_match_len);
}
+struct lzx_record_ctx {
+ struct lzx_freqs freqs;
+ struct lzx_lru_queue queue;
+ struct lzx_match *matches;
+};
+
+static void
+lzx_record_match(unsigned len, unsigned offset, void *_ctx)
+{
+ struct lzx_record_ctx *ctx = _ctx;
+
+ (ctx->matches++)->data = lzx_tally_match(len, offset, &ctx->freqs, &ctx->queue);
+}
+
+static void
+lzx_record_literal(u8 lit, void *_ctx)
+{
+ struct lzx_record_ctx *ctx = _ctx;
+
+ (ctx->matches++)->data = lzx_tally_literal(lit, &ctx->freqs);
+}
+
/* Returns the cost, in bits, to output a literal byte using the specified cost
* model. */
-static sym_cost_t
+static unsigned
lzx_literal_cost(u8 c, const struct lzx_costs * costs)
{
return costs->main[c];
* codes, return the approximate number of bits it will take to represent this
* match in the compressed output. Take into account the match offset LRU
* queue and optionally update it. */
-static sym_cost_t
+static unsigned
lzx_match_cost(unsigned length, unsigned offset, const struct lzx_costs *costs,
struct lzx_lru_queue *queue)
{
unsigned position_slot;
unsigned len_header, main_symbol;
- sym_cost_t cost = 0;
+ unsigned cost = 0;
position_slot = lzx_get_position_slot(offset, queue);
len_header = min(length - LZX_MIN_MATCH_LEN, LZX_NUM_PRIMARY_LENS);
- main_symbol = (position_slot << 3) | len_header | LZX_NUM_CHARS;
+ main_symbol = ((position_slot << 3) | len_header) + LZX_NUM_CHARS;
/* Account for main symbol. */
cost += costs->main[main_symbol];
}
-/* Very fast heuristic cost evaluation to use in the inner loop of the
- * match-finder. */
-static sym_cost_t
-lzx_match_cost_fast(unsigned offset, const struct lzx_lru_queue *queue)
+/* Fast heuristic cost evaluation to use in the inner loop of the match-finder.
+ * Unlike lzx_match_cost() which does a true cost evaluation, this simply
+ * prioritize matches based on their offset. */
+static input_idx_t
+lzx_match_cost_fast(input_idx_t length, input_idx_t offset, const void *_queue)
{
- for (unsigned i = 0; i < LZX_NUM_RECENT_OFFSETS; i++)
+ const struct lzx_lru_queue *queue = _queue;
+
+ /* It seems well worth it to take the time to give priority to recently
+ * used offsets. */
+ for (input_idx_t i = 0; i < LZX_NUM_RECENT_OFFSETS; i++)
if (offset == queue->R[i])
return i;
- BUILD_BUG_ON(LZX_MAX_WINDOW_SIZE >= (sym_cost_t)~0U);
return offset;
}
lzx_set_costs(struct lzx_compressor * ctx, const struct lzx_lens * lens)
{
unsigned i;
+ unsigned num_main_syms = ctx->num_main_syms;
/* Main code */
- for (i = 0; i < LZX_MAINCODE_NUM_SYMBOLS; i++) {
+ for (i = 0; i < num_main_syms; i++) {
ctx->costs.main[i] = lens->main[i];
if (ctx->costs.main[i] == 0)
ctx->costs.main[i] = ctx->params.alg_params.slow.main_nostat_cost;
}
}
-/* Advance the suffix array match-finder to the next position. */
-static void
-lzx_lz_update_salink(input_idx_t i,
- const input_idx_t SA[restrict],
- const input_idx_t ISA[restrict],
- struct salink link[restrict])
-{
- /* r = Rank of the suffix at the current position. */
- const input_idx_t r = ISA[i];
-
- /* next = rank of LOWEST ranked suffix that is ranked HIGHER than the
- * current suffix AND has a LOWER position, or -1 if none exists. */
- const input_idx_t next = link[r].next;
-
- /* prev = rank of HIGHEST ranked suffix that is ranked LOWER than the
- * current suffix AND has a LOWER position, or -1 if none exists. */
- const input_idx_t prev = link[r].prev;
-
- /* Link the suffix at the current position into the linked list that
- * contains all suffixes in the suffix array that are appear at or
- * before the current position, sorted by rank.
- *
- * Save the values of all fields we overwrite so that rollback is
- * possible. */
- if (next != (input_idx_t)~0U) {
-
- link[next].prev = r;
- link[next].lcpprev = link[r].lcpnext;
- }
-
- if (prev != (input_idx_t)~0U) {
-
- link[prev].next = r;
- link[prev].lcpnext = link[r].lcpprev;
- }
-}
-
-/* Rewind the suffix array match-finder to the specified position.
- *
- * This undoes a series of updates by lzx_lz_update_salink(). */
-static void
-lzx_lz_rewind_matchfinder(struct lzx_compressor *ctx,
- const unsigned orig_pos)
-{
- LZX_DEBUG("Rewind match-finder %u => %u", ctx->match_window_pos, orig_pos);
-
- if (ctx->match_window_pos == orig_pos)
- return;
-
- LZX_ASSERT(ctx->match_window_pos > orig_pos);
- LZX_ASSERT(orig_pos == 0);
- ctx->matches_cached = true;
- ctx->cached_matches_pos = 0;
- ctx->match_window_pos = orig_pos;
-}
-
-/*
- * Use the suffix array match-finder to retrieve a list of LZ matches at the
- * current position.
- *
- * [in] @i Current position in the window.
- * [in] @SA Suffix array for the window.
- * [in] @ISA Inverse suffix array for the window.
- * [inout] @link Suffix array links used internally by the match-finder.
- * [out] @matches The (length, offset) pairs of the resulting matches will
- * be written here, sorted in decreasing order by
- * length. All returned lengths will be unique.
- * [in] @queue Recently used match offsets, used when evaluating the
- * cost of matches.
- * [in] @min_match_len Minimum match length to return.
- * [in] @max_matches_to_consider Maximum number of matches to consider at
- * the position.
- * [in] @max_matches_to_return Maximum number of matches to return.
- *
- * The return value is the number of matches found and written to @matches.
- */
-static unsigned
-lzx_lz_get_matches(const input_idx_t i,
- const input_idx_t SA[const restrict],
- const input_idx_t ISA[const restrict],
- struct salink link[const restrict],
- struct raw_match matches[const restrict],
- const struct lzx_lru_queue * const restrict queue,
- const unsigned min_match_len,
- const uint32_t max_matches_to_consider,
- const uint32_t max_matches_to_return)
-{
- /* r = Rank of the suffix at the current position. */
- const input_idx_t r = ISA[i];
-
- /* Prepare for searching the current position. */
- lzx_lz_update_salink(i, SA, ISA, link);
-
- /* L = rank of next suffix to the left;
- * R = rank of next suffix to the right;
- * lenL = length of match between current position and the suffix with rank L;
- * lenR = length of match between current position and the suffix with rank R.
- *
- * This is left and right relative to the rank of the current suffix.
- * Since the suffixes in the suffix array are sorted, the longest
- * matches are immediately to the left and right (using the linked list
- * to ignore all suffixes that occur later in the window). The match
- * length decreases the farther left and right we go. We shall keep the
- * length on both sides in sync in order to choose the lowest-cost match
- * of each length.
- */
- input_idx_t L = link[r].prev;
- input_idx_t R = link[r].next;
- input_idx_t lenL = link[r].lcpprev;
- input_idx_t lenR = link[r].lcpnext;
-
- /* nmatches = number of matches found so far. */
- unsigned nmatches = 0;
-
- /* best_cost = cost of lowest-cost match found so far.
- *
- * We keep track of this so that we can ignore shorter matches that do
- * not have lower costs than a longer matches already found.
- */
- sym_cost_t best_cost = INFINITE_SYM_COST;
-
- /* count_remaining = maximum number of possible matches remaining to be
- * considered. */
- uint32_t count_remaining = max_matches_to_consider;
-
- /* pending = match currently being considered for a specific length. */
- struct raw_match pending;
-
- while (lenL >= min_match_len || lenR >= min_match_len)
- {
- pending.len = lenL;
- pending.offset = (input_idx_t)~0U;
- sym_cost_t pending_cost = INFINITE_SYM_COST;
- sym_cost_t cost;
-
- /* Extend left. */
- if (lenL >= min_match_len && lenL >= lenR) {
- for (;;) {
-
- if (--count_remaining == 0)
- goto out_save_pending;
-
- input_idx_t offset = i - SA[L];
-
- /* Save match if it has smaller cost. */
- cost = lzx_match_cost_fast(offset, queue);
- if (cost < pending_cost) {
- pending.offset = offset;
- pending_cost = cost;
- }
-
- if (link[L].lcpprev < lenL) {
- /* Match length decreased. */
-
- lenL = link[L].lcpprev;
-
- /* Save the pending match unless the
- * right side still may have matches of
- * this length to be scanned, or if a
- * previous (longer) match had lower
- * cost. */
- if (pending.len > lenR) {
- if (pending_cost < best_cost) {
- best_cost = pending_cost;
- matches[nmatches++] = pending;
- if (nmatches == max_matches_to_return)
- return nmatches;
- }
- pending.len = lenL;
- pending.offset = (input_idx_t)~0U;
- pending_cost = INFINITE_SYM_COST;
- }
- if (lenL < min_match_len || lenL < lenR)
- break;
- }
- L = link[L].prev;
- }
- }
-
- pending.len = lenR;
-
- /* Extend right. */
- if (lenR >= min_match_len && lenR > lenL) {
- for (;;) {
-
- if (--count_remaining == 0)
- goto out_save_pending;
-
- input_idx_t offset = i - SA[R];
-
- /* Save match if it has smaller cost. */
- cost = lzx_match_cost_fast(offset, queue);
- if (cost < pending_cost) {
- pending.offset = offset;
- pending_cost = cost;
- }
-
- if (link[R].lcpnext < lenR) {
- /* Match length decreased. */
-
- lenR = link[R].lcpnext;
-
- /* Save the pending match unless a
- * previous (longer) match had lower
- * cost. */
- if (pending_cost < best_cost) {
- matches[nmatches++] = pending;
- best_cost = pending_cost;
- if (nmatches == max_matches_to_return)
- return nmatches;
- }
-
- if (lenR < min_match_len || lenR <= lenL)
- break;
-
- pending.len = lenR;
- pending.offset = (input_idx_t)~0U;
- pending_cost = INFINITE_SYM_COST;
- }
- R = link[R].next;
- }
- }
- }
- goto out;
-
-out_save_pending:
- if (pending.offset != (input_idx_t)~0U)
- matches[nmatches++] = pending;
-
-out:
- return nmatches;
-}
-
-
/* Tell the match-finder to skip the specified number of bytes (@n) in the
* input. */
static void
-lzx_lz_skip_bytes(struct lzx_compressor *ctx, unsigned n)
+lzx_lz_skip_bytes(struct lzx_compressor *ctx, input_idx_t n)
{
LZX_ASSERT(n <= ctx->match_window_end - ctx->match_window_pos);
if (ctx->matches_cached) {
} else {
while (n--) {
ctx->cached_matches[ctx->cached_matches_pos++].len = 0;
- lzx_lz_update_salink(ctx->match_window_pos++, ctx->SA,
- ctx->ISA, ctx->salink);
+ lz_sarray_skip_position(&ctx->lz_sarray);
+ ctx->match_window_pos++;
}
+ LZX_ASSERT(lz_sarray_get_pos(&ctx->lz_sarray) == ctx->match_window_pos);
}
}
/* Retrieve a list of matches available at the next position in the input.
*
- * The matches are written to ctx->matches in decreasing order of length, and
- * the return value is the number of matches found. */
-static unsigned
+ * A pointer to the matches array is written into @matches_ret, and the return
+ * value is the number of matches found. */
+static u32
lzx_lz_get_matches_caching(struct lzx_compressor *ctx,
const struct lzx_lru_queue *queue,
struct raw_match **matches_ret)
{
- unsigned num_matches;
+ u32 num_matches;
struct raw_match *matches;
LZX_ASSERT(ctx->match_window_pos <= ctx->match_window_end);
if (ctx->matches_cached) {
num_matches = matches[-1].len;
} else {
- unsigned min_match_len = LZX_MIN_MATCH_LEN;
- if (min_match_len <= 2 && !ctx->params.alg_params.slow.use_len2_matches)
- min_match_len = 3;
- const uint32_t max_search_depth = ctx->params.alg_params.slow.max_search_depth;
- const uint32_t max_matches_per_pos = ctx->params.alg_params.slow.max_matches_per_pos;
-
- if (unlikely(max_search_depth == 0 || max_matches_per_pos == 0))
- num_matches = 0;
- else
- num_matches = lzx_lz_get_matches(ctx->match_window_pos,
- ctx->SA,
- ctx->ISA,
- ctx->salink,
- matches,
- queue,
- min_match_len,
- max_search_depth,
- max_matches_per_pos);
+ LZX_ASSERT(lz_sarray_get_pos(&ctx->lz_sarray) == ctx->match_window_pos);
+ num_matches = lz_sarray_get_matches(&ctx->lz_sarray,
+ matches,
+ lzx_match_cost_fast,
+ queue);
matches[-1].len = num_matches;
}
ctx->cached_matches_pos += num_matches + 1;
* if it is not the whole window. */
if (ctx->match_window_end < ctx->window_size) {
unsigned maxlen = ctx->match_window_end - ctx->match_window_pos;
- for (unsigned i = 0; i < num_matches; i++)
+ for (u32 i = 0; i < num_matches; i++)
if (matches[i].len > maxlen)
matches[i].len = maxlen;
}
#endif
#ifdef ENABLE_LZX_DEBUG
- for (unsigned i = 0; i < num_matches; i++) {
+ for (u32 i = 0; i < num_matches; i++) {
LZX_ASSERT(matches[i].len >= LZX_MIN_MATCH_LEN);
LZX_ASSERT(matches[i].len <= LZX_MAX_MATCH_LEN);
LZX_ASSERT(matches[i].len <= ctx->match_window_end - ctx->match_window_pos);
return num_matches;
}
-/*
- * Reverse the linked list of near-optimal matches so that they can be returned
- * in forwards order.
- *
- * Returns the first match in the list.
- */
-static struct raw_match
-lzx_lz_reverse_near_optimal_match_list(struct lzx_compressor *ctx,
- unsigned cur_pos)
+static u32
+lzx_get_prev_literal_cost(struct lzx_compressor *ctx,
+ struct lzx_lru_queue *queue)
{
- unsigned prev_link, saved_prev_link;
- unsigned prev_match_offset, saved_prev_match_offset;
-
- ctx->optimum_end_idx = cur_pos;
-
- saved_prev_link = ctx->optimum[cur_pos].prev.link;
- saved_prev_match_offset = ctx->optimum[cur_pos].prev.match_offset;
-
- do {
- prev_link = saved_prev_link;
- prev_match_offset = saved_prev_match_offset;
-
- saved_prev_link = ctx->optimum[prev_link].prev.link;
- saved_prev_match_offset = ctx->optimum[prev_link].prev.match_offset;
-
- ctx->optimum[prev_link].next.link = cur_pos;
- ctx->optimum[prev_link].next.match_offset = prev_match_offset;
-
- cur_pos = prev_link;
- } while (cur_pos != 0);
-
- ctx->optimum_cur_idx = ctx->optimum[0].next.link;
-
- return (struct raw_match)
- { .len = ctx->optimum_cur_idx,
- .offset = ctx->optimum[0].next.match_offset,
- };
+ return lzx_literal_cost(ctx->window[ctx->match_window_pos - 1],
+ &ctx->costs);
}
-#if 0
-static struct raw_match
-lzx_lz_get_greedy_match(struct lzx_compressor * ctx)
+static u32
+lzx_get_match_cost(struct lzx_compressor *ctx,
+ struct lzx_lru_queue *queue,
+ input_idx_t length, input_idx_t offset)
{
- struct raw_match *matches;
-
- if (!lzx_lz_get_matches_caching(ctx, &ctx->queue, &matches))
- return (struct raw_match) {.len = 0};
-
- lzx_lz_skip_bytes(ctx, matches[0].len - 1);
- return matches[0];
+ return lzx_match_cost(length, offset, &ctx->costs, queue);
}
-#endif
-#if 0
static struct raw_match
-lzx_lz_get_lazy_match(struct lzx_compressor * ctx)
+lzx_lz_get_near_optimal_match(struct lzx_compressor *ctx)
{
- unsigned num_matches;
- struct raw_match *matches;
- struct raw_match prev_match;
- struct lzx_lru_queue queue;
+ return lz_get_near_optimal_match(&ctx->mc,
+ lzx_lz_get_matches_caching,
+ lzx_lz_skip_bytes,
+ lzx_get_prev_literal_cost,
+ lzx_get_match_cost,
+ ctx,
+ &ctx->queue);
+}
- if (ctx->optimum_cur_idx != ctx->optimum_end_idx)
- goto retopt;
+/* Set default symbol costs for the LZX Huffman codes. */
+static void
+lzx_set_default_costs(struct lzx_costs * costs, unsigned num_main_syms)
+{
+ unsigned i;
- /* Check for matches at first position. */
- num_matches = lzx_lz_get_matches_caching(ctx, &ctx->queue, &matches);
+ /* Main code (part 1): Literal symbols */
+ for (i = 0; i < LZX_NUM_CHARS; i++)
+ costs->main[i] = 8;
- /* Return literal if no matches were found. */
- if (num_matches == 0)
- return (struct raw_match) { .len = 0 };
+ /* Main code (part 2): Match header symbols */
+ for (; i < num_main_syms; i++)
+ costs->main[i] = 10;
- /* Immediately choose match if longer than threshold. */
- if (matches[0].len > ctx->params.alg_params.slow.num_fast_bytes)
- goto savecur;
+ /* Length code */
+ for (i = 0; i < LZX_LENCODE_NUM_SYMBOLS; i++)
+ costs->len[i] = 8;
- ctx->optimum_cur_idx = ctx->optimum_end_idx = 0;
- for (;;) {
- prev_match = matches[0];
+ /* Aligned offset code */
+ for (i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++)
+ costs->aligned[i] = 3;
+}
- /* Check for matches at next position. */
- num_matches = lzx_lz_get_matches_caching(ctx, &ctx->queue, &matches);
+/* Given the frequencies of symbols in an LZX-compressed block and the
+ * corresponding Huffman codes, return LZX_BLOCKTYPE_ALIGNED or
+ * LZX_BLOCKTYPE_VERBATIM if an aligned offset or verbatim block, respectively,
+ * will take fewer bits to output. */
+static int
+lzx_choose_verbatim_or_aligned(const struct lzx_freqs * freqs,
+ const struct lzx_codes * codes)
+{
+ unsigned aligned_cost = 0;
+ unsigned verbatim_cost = 0;
- /* Choose previous match if there is not a match at this
- * position. */
- if (num_matches == 0)
- goto saveprev;
+ /* Verbatim blocks have a constant 3 bits per position footer. Aligned
+ * offset blocks have an aligned offset symbol per position footer, plus
+ * an extra 24 bits per block to output the lengths necessary to
+ * reconstruct the aligned offset code itself. */
+ for (unsigned i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++) {
+ verbatim_cost += 3 * freqs->aligned[i];
+ aligned_cost += codes->lens.aligned[i] * freqs->aligned[i];
+ }
+ aligned_cost += LZX_ALIGNEDCODE_ELEMENT_SIZE * LZX_ALIGNEDCODE_NUM_SYMBOLS;
+ if (aligned_cost < verbatim_cost)
+ return LZX_BLOCKTYPE_ALIGNED;
+ else
+ return LZX_BLOCKTYPE_VERBATIM;
+}
- /* Choose previous match the longest match at the next position
- * is the same place, just one character shifted over. */
- if (matches[0].offset == prev_match.offset ||
- matches[0].len < prev_match.len)
- goto saveprev;
+/* Find a near-optimal sequence of matches/literals with which to output the
+ * specified LZX block, then set the block's type to that which has the minimum
+ * cost to output (either verbatim or aligned). */
+static void
+lzx_optimize_block(struct lzx_compressor *ctx, struct lzx_block_spec *spec,
+ unsigned num_passes)
+{
+ const struct lzx_lru_queue orig_queue = ctx->queue;
+ struct lzx_freqs freqs;
- struct lzx_lru_queue q1 = ctx->queue, q2 = ctx->queue;
- double lazycost = lzx_literal_cost(ctx->window[ctx->match_window_pos - 2],
- &ctx->costs) +
- lzx_match_cost(matches[0].len, matches[0].offset,
- &ctx->costs, &q1);
- double greedycost = lzx_match_cost(prev_match.len, prev_match.offset,
- &ctx->costs, &q2);
- lazycost *= (double)prev_match.len / (1 + matches[0].len);
+ unsigned orig_window_pos = spec->window_pos;
+ unsigned orig_cached_pos = ctx->cached_matches_pos;
- /* Choose previous match if greedy cost was lower. */
- if (greedycost <= lazycost)
- goto saveprev;
+ LZX_ASSERT(ctx->match_window_pos == spec->window_pos);
- /* Choose literal at the previous position. */
- ctx->optimum[ctx->optimum_end_idx++].next.link = 0;
+ ctx->match_window_end = spec->window_pos + spec->block_size;
+ spec->chosen_matches_start_pos = spec->window_pos;
+ LZX_ASSERT(num_passes >= 1);
- /* Immediately choose match if longer than threshold. */
- if (matches[0].len > ctx->params.alg_params.slow.num_fast_bytes)
- goto savecur;
- }
+ /* The first optimal parsing pass is done using the cost model already
+ * set in ctx->costs. Each later pass is done using a cost model
+ * computed from the previous pass. */
+ for (unsigned pass = 0; pass < num_passes; pass++) {
-savecur:
- lzx_lz_skip_bytes(ctx, 1);
- prev_match = matches[0];
-
-saveprev:
- lzx_lz_skip_bytes(ctx, prev_match.len - 2);
- ctx->optimum[ctx->optimum_end_idx].next.link = prev_match.len;
- ctx->optimum[ctx->optimum_end_idx].next.match_offset = prev_match.offset;
- ctx->optimum_end_idx++;
-retopt:
- prev_match.len = ctx->optimum[ctx->optimum_cur_idx].next.link;
- prev_match.offset = ctx->optimum[ctx->optimum_cur_idx].next.match_offset;
- ctx->optimum_cur_idx++;
- return prev_match;
-}
-#endif
-
-
-/*
- * lzx_lz_get_near_optimal_match() -
- *
- * Choose the optimal match or literal to use at the next position in the input.
- *
- * Unlike a greedy parser that always takes the longest match, or even a
- * parser with one match/literal look-ahead like zlib, the algorithm used here
- * may look ahead many matches/literals to determine the optimal match/literal to
- * output next. The motivation is that the compression ratio is improved if the
- * compressor can do things like use a shorter-than-possible match in order to
- * allow a longer match later, and also take into account the Huffman code cost
- * model rather than simply assuming that longer is better.
- *
- * Still, this is not truly an optimal parser because very long matches are
- * taken immediately. This is done to avoid considering many different
- * alternatives that are unlikely to significantly be better.
- *
- * This algorithm is based on that used in 7-Zip's DEFLATE encoder.
- *
- * Each call to this function does one of two things:
- *
- * 1. Build a near-optimal sequence of matches/literals, up to some point, that
- * will be returned by subsequent calls to this function, then return the
- * first one.
- *
- * OR
- *
- * 2. Return the next match/literal previously computed by a call to this
- * function;
- *
- * This function relies on the following state in the compressor context:
- *
- * ctx->window (read-only: preprocessed data being compressed)
- * ctx->cost (read-only: cost model to use)
- * ctx->optimum (internal state; leave uninitialized)
- * ctx->optimum_cur_idx (must set to 0 before first call)
- * ctx->optimum_end_idx (must set to 0 before first call)
- * ctx->SA (must be built before first call)
- * ctx->ISA (must be built before first call)
- * ctx->salink (must be built before first call)
- * ctx->match_window_pos (must initialize to position of next match to
- * return; subsequent calls return subsequent
- * matches)
- * ctx->match_window_end (must initialize to limit of match-finding region;
- * subsequent calls use the same limit)
- *
- * The return value is a (length, offset) pair specifying the match or literal
- * chosen. For literals, the length is less than LZX_MIN_MATCH_LEN and the
- * offset is meaningless.
- */
-static struct raw_match
-lzx_lz_get_near_optimal_match(struct lzx_compressor * ctx)
-{
- unsigned num_possible_matches;
- struct raw_match *possible_matches;
- struct raw_match match;
- unsigned longest_match_len;
-
- if (ctx->optimum_cur_idx != ctx->optimum_end_idx) {
- /* Case 2: Return the next match/literal already found. */
- match.len = ctx->optimum[ctx->optimum_cur_idx].next.link -
- ctx->optimum_cur_idx;
- match.offset = ctx->optimum[ctx->optimum_cur_idx].next.match_offset;
-
- ctx->optimum_cur_idx = ctx->optimum[ctx->optimum_cur_idx].next.link;
- return match;
- }
-
- /* Case 1: Compute a new list of matches/literals to return. */
-
- ctx->optimum_cur_idx = 0;
- ctx->optimum_end_idx = 0;
-
- /* Get matches at this position. */
- num_possible_matches = lzx_lz_get_matches_caching(ctx, &ctx->queue, &possible_matches);
-
- /* If no matches found, return literal. */
- if (num_possible_matches == 0)
- return (struct raw_match){ .len = 0 };
-
- /* The matches that were found are sorted in decreasing order by length.
- * Get the length of the longest one. */
- longest_match_len = possible_matches[0].len;
-
- /* Greedy heuristic: if the longest match that was found is greater
- * than the number of fast bytes, return it immediately; don't both
- * doing more work. */
- if (longest_match_len > ctx->params.alg_params.slow.num_fast_bytes) {
- lzx_lz_skip_bytes(ctx, longest_match_len - 1);
- return possible_matches[0];
- }
-
- /* Calculate the cost to reach the next position by outputting a
- * literal. */
- ctx->optimum[0].queue = ctx->queue;
- ctx->optimum[1].queue = ctx->optimum[0].queue;
- ctx->optimum[1].cost = lzx_literal_cost(ctx->window[ctx->match_window_pos],
- &ctx->costs);
- ctx->optimum[1].prev.link = 0;
-
- /* Calculate the cost to reach any position up to and including that
- * reached by the longest match, using the shortest (i.e. closest) match
- * that reaches each position. */
- BUILD_BUG_ON(LZX_MIN_MATCH_LEN != 2);
- for (unsigned len = LZX_MIN_MATCH_LEN, match_idx = num_possible_matches - 1;
- len <= longest_match_len; len++) {
-
- LZX_ASSERT(match_idx < num_possible_matches);
-
- ctx->optimum[len].queue = ctx->optimum[0].queue;
- ctx->optimum[len].prev.link = 0;
- ctx->optimum[len].prev.match_offset = possible_matches[match_idx].offset;
- ctx->optimum[len].cost = lzx_match_cost(len,
- possible_matches[match_idx].offset,
- &ctx->costs,
- &ctx->optimum[len].queue);
- if (len == possible_matches[match_idx].len)
- match_idx--;
- }
-
- unsigned cur_pos = 0;
-
- /* len_end: greatest index forward at which costs have been calculated
- * so far */
- unsigned len_end = longest_match_len;
-
- for (;;) {
- /* Advance to next position. */
- cur_pos++;
-
- if (cur_pos == len_end || cur_pos == LZX_OPTIM_ARRAY_SIZE)
- return lzx_lz_reverse_near_optimal_match_list(ctx, cur_pos);
-
- /* retrieve the number of matches available at this position */
- num_possible_matches = lzx_lz_get_matches_caching(ctx, &ctx->optimum[cur_pos].queue,
- &possible_matches);
-
- unsigned new_len = 0;
-
- if (num_possible_matches != 0) {
- new_len = possible_matches[0].len;
-
- /* Greedy heuristic: if we found a match greater than
- * the number of fast bytes, stop immediately. */
- if (new_len > ctx->params.alg_params.slow.num_fast_bytes) {
-
- /* Build the list of matches to return and get
- * the first one. */
- match = lzx_lz_reverse_near_optimal_match_list(ctx, cur_pos);
-
- /* Append the long match to the end of the list. */
- ctx->optimum[cur_pos].next.match_offset =
- possible_matches[0].offset;
- ctx->optimum[cur_pos].next.link = cur_pos + new_len;
- ctx->optimum_end_idx = cur_pos + new_len;
-
- /* Skip over the remaining bytes of the long match. */
- lzx_lz_skip_bytes(ctx, new_len - 1);
-
- /* Return first match in the list */
- return match;
- }
- }
-
- /* Consider proceeding with a literal byte. */
- block_cost_t cur_cost = ctx->optimum[cur_pos].cost;
- block_cost_t cur_plus_literal_cost = cur_cost +
- lzx_literal_cost(ctx->window[ctx->match_window_pos - 1],
- &ctx->costs);
- if (cur_plus_literal_cost < ctx->optimum[cur_pos + 1].cost) {
- ctx->optimum[cur_pos + 1].cost = cur_plus_literal_cost;
- ctx->optimum[cur_pos + 1].prev.link = cur_pos;
- ctx->optimum[cur_pos + 1].queue = ctx->optimum[cur_pos].queue;
- }
-
- if (num_possible_matches == 0)
- continue;
-
- /* Consider proceeding with a match. */
-
- while (len_end < cur_pos + new_len)
- ctx->optimum[++len_end].cost = INFINITE_BLOCK_COST;
-
- for (unsigned len = LZX_MIN_MATCH_LEN, match_idx = num_possible_matches - 1;
- len <= new_len; len++) {
- LZX_ASSERT(match_idx < num_possible_matches);
- struct lzx_lru_queue q = ctx->optimum[cur_pos].queue;
- block_cost_t cost = cur_cost + lzx_match_cost(len,
- possible_matches[match_idx].offset,
- &ctx->costs,
- &q);
-
- if (cost < ctx->optimum[cur_pos + len].cost) {
- ctx->optimum[cur_pos + len].cost = cost;
- ctx->optimum[cur_pos + len].prev.link = cur_pos;
- ctx->optimum[cur_pos + len].prev.match_offset =
- possible_matches[match_idx].offset;
- ctx->optimum[cur_pos + len].queue = q;
- }
-
- if (len == possible_matches[match_idx].len)
- match_idx--;
- }
- }
-}
-
-/*
- * Set default symbol costs.
- */
-static void
-lzx_set_default_costs(struct lzx_costs * costs)
-{
- unsigned i;
-
- /* Literal symbols */
- for (i = 0; i < LZX_NUM_CHARS; i++)
- costs->main[i] = 8;
-
- /* Match header symbols */
- for (; i < LZX_MAINCODE_NUM_SYMBOLS; i++)
- costs->main[i] = 10;
-
- /* Length symbols */
- for (i = 0; i < LZX_LENCODE_NUM_SYMBOLS; i++)
- costs->len[i] = 8;
-
- /* Aligned offset symbols */
- for (i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++)
- costs->aligned[i] = 3;
-}
-
-/* Given the frequencies of symbols in a compressed block and the corresponding
- * Huffman codes, return LZX_BLOCKTYPE_ALIGNED or LZX_BLOCKTYPE_VERBATIM if an
- * aligned offset or verbatim block, respectively, will take fewer bits to
- * output. */
-static int
-lzx_choose_verbatim_or_aligned(const struct lzx_freqs * freqs,
- const struct lzx_codes * codes)
-{
- unsigned aligned_cost = 0;
- unsigned verbatim_cost = 0;
-
- /* Verbatim blocks have a constant 3 bits per position footer. Aligned
- * offset blocks have an aligned offset symbol per position footer, plus
- * an extra 24 bits to output the lengths necessary to reconstruct the
- * aligned offset code itself. */
- for (unsigned i = 0; i < LZX_ALIGNEDCODE_NUM_SYMBOLS; i++) {
- verbatim_cost += 3 * freqs->aligned[i];
- aligned_cost += codes->lens.aligned[i] * freqs->aligned[i];
- }
- aligned_cost += LZX_ALIGNEDCODE_ELEMENT_SIZE * LZX_ALIGNEDCODE_NUM_SYMBOLS;
- if (aligned_cost < verbatim_cost)
- return LZX_BLOCKTYPE_ALIGNED;
- else
- return LZX_BLOCKTYPE_VERBATIM;
-}
-
-/* Find a near-optimal sequence of matches/literals with which to output the
- * specified LZX block, and set its type to that which has the minimum cost to
- * output. */
-static void
-lzx_optimize_block(struct lzx_compressor *ctx, struct lzx_block_spec *spec,
- unsigned num_passes)
-{
- struct lzx_lru_queue orig_queue = ctx->queue;
- struct lzx_freqs freqs;
-
- ctx->match_window_end = spec->window_pos + spec->block_size;
- spec->chosen_matches_start_pos = spec->window_pos;
-
- LZX_ASSERT(num_passes >= 1);
-
- /* The first optimal parsing pass is done using the cost model already
- * set in ctx->costs. Each later pass is done using a cost model
- * computed from the previous pass. */
- for (unsigned pass = 0; pass < num_passes; pass++) {
-
- lzx_lz_rewind_matchfinder(ctx, spec->window_pos);
- ctx->queue = orig_queue;
- spec->num_chosen_matches = 0;
- memset(&freqs, 0, sizeof(freqs));
+ ctx->match_window_pos = orig_window_pos;
+ ctx->cached_matches_pos = orig_cached_pos;
+ ctx->queue = orig_queue;
+ spec->num_chosen_matches = 0;
+ memset(&freqs, 0, sizeof(freqs));
for (unsigned i = spec->window_pos; i < spec->window_pos + spec->block_size; ) {
struct raw_match raw_match;
raw_match = lzx_lz_get_near_optimal_match(ctx);
if (raw_match.len >= LZX_MIN_MATCH_LEN) {
- lzx_match.data = lzx_record_match(raw_match.offset, raw_match.len,
- &freqs, &ctx->queue);
- i += raw_match.len;
+ if (unlikely(raw_match.len == LZX_MIN_MATCH_LEN &&
+ raw_match.offset == ctx->max_window_size -
+ LZX_MIN_MATCH_LEN))
+ {
+ /* Degenerate case where the parser
+ * generated the minimum match length
+ * with the maximum offset. There
+ * aren't actually enough position slots
+ * to represent this offset, as noted in
+ * the comments in
+ * lzx_get_num_main_syms(), so we cannot
+ * allow it. Use literals instead.
+ *
+ * Note that this case only occurs if
+ * the match-finder can generate matches
+ * to the very start of the window. The
+ * suffix array match-finder can,
+ * although typical hash chain and
+ * binary tree match-finders use 0 as a
+ * null value and therefore cannot
+ * generate such matches. */
+ BUILD_BUG_ON(LZX_MIN_MATCH_LEN != 2);
+ lzx_match.data = lzx_tally_literal(ctx->window[i],
+ &freqs);
+ i += 1;
+ ctx->chosen_matches[spec->chosen_matches_start_pos +
+ spec->num_chosen_matches++]
+ = lzx_match;
+ lzx_match.data = lzx_tally_literal(ctx->window[i],
+ &freqs);
+ i += 1;
+ } else {
+ lzx_match.data = lzx_tally_match(raw_match.len,
+ raw_match.offset,
+ &freqs,
+ &ctx->queue);
+ i += raw_match.len;
+ }
} else {
- lzx_match.data = lzx_record_literal(ctx->window[i], &freqs);
+ lzx_match.data = lzx_tally_literal(ctx->window[i], &freqs);
i += 1;
}
ctx->chosen_matches[spec->chosen_matches_start_pos +
spec->num_chosen_matches++] = lzx_match;
}
- lzx_make_huffman_codes(&freqs, &spec->codes);
+ lzx_make_huffman_codes(&freqs, &spec->codes,
+ ctx->num_main_syms);
if (pass < num_passes - 1)
lzx_set_costs(ctx, &spec->codes.lens);
+ ctx->matches_cached = true;
}
spec->block_type = lzx_choose_verbatim_or_aligned(&freqs, &spec->codes);
+ ctx->matches_cached = false;
}
static void
lzx_optimize_blocks(struct lzx_compressor *ctx)
{
lzx_lru_queue_init(&ctx->queue);
- ctx->optimum_cur_idx = 0;
- ctx->optimum_end_idx = 0;
+ lz_match_chooser_begin(&ctx->mc);
const unsigned num_passes = ctx->params.alg_params.slow.num_optim_passes;
lzx_optimize_block(ctx, &ctx->block_specs[i], num_passes);
}
-static bool entropy_val_tab_inited = false;
-static double entropy_val_tab[LZX_MAX_WINDOW_SIZE];
-static pthread_mutex_t entropy_val_tab_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static double entropy_val(unsigned count)
-{
- /*return count * log(count);*/
- return entropy_val_tab[count];
-}
-
-/* Split a LZX block into several if it is advantageous to do so.
- *
- * TODO: This doesn't work very well yet. Should optimal parsing be done
- * before or after splitting? */
-static void
-lzx_block_split(const u32 matches[restrict],
- const input_idx_t n,
- const double epsilon,
- const unsigned max_num_blocks,
- const unsigned min_block_len,
- struct lzx_block_spec block_specs[restrict],
- unsigned * const restrict num_blocks_ret)
-{
- const double block_overhead = 1500;
-
- if (!entropy_val_tab_inited) {
- pthread_mutex_lock(&entropy_val_tab_mutex);
- if (!entropy_val_tab_inited) {
- entropy_val_tab[0] = 0;
- for (input_idx_t i = 1; i < LZX_MAX_WINDOW_SIZE; i++)
- entropy_val_tab[i] = i * log2(i);
- entropy_val_tab_inited = true;
- }
- pthread_mutex_unlock(&entropy_val_tab_mutex);
- }
-
- u16 main_syms[n];
- u8 len_syms[n];
- u8 aligned_syms[n];
- input_idx_t orig_input_indices[n + 1];
-
- LZX_ASSERT(epsilon >= 0);
- LZX_ASSERT(max_num_blocks >= 1);
-
- /* For convenience, extract the main, length, and aligned symbols from
- * the matches. Every position will have a main symbol, but not every
- * position will have a length and aligned symbol. Special values
- * larger than the valid symbols are used to indicate the absense of a
- * symbol. */
- orig_input_indices[0] = 0;
- for (input_idx_t i = 0, orig_input_idx = 0; i < n; i++) {
- u32 match = matches[i];
- u16 main_sym;
- u8 len_sym = LZX_LENCODE_NUM_SYMBOLS;
- u8 aligned_sym = LZX_ALIGNEDCODE_NUM_SYMBOLS;
- if (match & 0x80000000) {
- unsigned match_len_minus_2 = match & 0xff;
- unsigned position_footer = (match >> 8) & 0x1ffff;
- unsigned position_slot = (match >> 25) & 0x3f;
- unsigned len_header;
-
- if (match_len_minus_2 < LZX_NUM_PRIMARY_LENS) {
- len_header = match_len_minus_2;
- } else {
- len_header = LZX_NUM_PRIMARY_LENS;
- len_sym = match_len_minus_2 - LZX_NUM_PRIMARY_LENS;
- }
- main_sym = ((position_slot << 3) | len_header) + LZX_NUM_CHARS;
- if (position_slot >= 8)
- aligned_sym = position_footer & 7;
- orig_input_idx += match_len_minus_2 + 2;
- } else {
- main_sym = match;
- orig_input_idx++;
- }
- main_syms[i] = main_sym;
- len_syms[i] = len_sym;
- aligned_syms[i] = aligned_sym;
- orig_input_indices[i + 1] = orig_input_idx;
- }
-
- /* Compute the number of sliding windows that will be used for the
- * entropy calculations. */
- int num_windows = 0;
- unsigned window_len;
- {
- double e = min_block_len;
- do {
- window_len = e;
- num_windows++;
- e *= epsilon + 1;
- } while (window_len < n);
- }
-
- /* Compute the length of each sliding window. */
- unsigned window_lens[num_windows];
- {
- double e = min_block_len;
- unsigned window_idx = 0;
- do {
- window_len = e;
- window_lens[window_idx++] = min(window_len, n);
- e *= epsilon + 1;
- } while (window_len < n);
- }
-
- /* Best estimated compression size, in bits, found so far for the input
- * matches up to each position. */
- unsigned shortest_paths[n + 1];
-
- /* Pointers to follow to get the sequence of blocks that represents the
- * shortest path (in terms of estimated compressed size) up to each
- * position in the input matches. */
- input_idx_t back_ptrs[n + 1];
-
- for (input_idx_t i = 0; i < n + 1; i++) {
- shortest_paths[i] = ~0U;
- back_ptrs[i] = 0;
- }
- shortest_paths[0] = 0;
-
- {
- /* Initialize the per-window symbol and entropy counters */
- input_idx_t mainsym_ctrs[num_windows][LZX_MAINCODE_NUM_SYMBOLS];
- input_idx_t lensym_ctrs[num_windows][LZX_LENCODE_NUM_SYMBOLS + 1];
- input_idx_t alignedsym_ctrs[num_windows][LZX_ALIGNEDCODE_NUM_SYMBOLS + 1];
- ZERO_ARRAY(mainsym_ctrs);
- ZERO_ARRAY(lensym_ctrs);
- ZERO_ARRAY(alignedsym_ctrs);
-
- {
- int start_win_idx = 0;
- for (input_idx_t i = 0; i < n; i++) {
- while (i >= window_lens[start_win_idx])
- start_win_idx++;
- for (int j = start_win_idx; j < num_windows; j++) {
- mainsym_ctrs[j][main_syms[i]]++;
- lensym_ctrs[j][len_syms[i]]++;
- alignedsym_ctrs[j][aligned_syms[i]]++;
- }
- }
- }
-
- double entropy_ctrs[num_windows];
- for (int i = 0; i < num_windows; i++) {
- entropy_ctrs[i] = 0;
- for (unsigned j = 0; j < LZX_MAINCODE_NUM_SYMBOLS; j++)
- entropy_ctrs[i] += entropy_val(mainsym_ctrs[i][j]);
- for (unsigned j = 0; j < LZX_LENCODE_NUM_SYMBOLS; j++)
- entropy_ctrs[i] += entropy_val(lensym_ctrs[i][j]);
- for (unsigned j = 0; j < LZX_ALIGNEDCODE_NUM_SYMBOLS; j++)
- entropy_ctrs[i] += entropy_val(alignedsym_ctrs[i][j]);
- }
-
- /* Slide the windows along the input and compute the shortest
- * path to each position in the matches. */
- int end_window_idx = (int)num_windows - 1;
- for (input_idx_t i = 0; i < n; i++) {
- for (int j = 0; j <= end_window_idx; j++) {
- if (shortest_paths[i] == ~0U)
- continue;
- unsigned num_mainsyms = window_lens[j];
- unsigned num_lensyms = window_lens[j] -
- lensym_ctrs[j][LZX_LENCODE_NUM_SYMBOLS];
- unsigned num_alignedsyms = window_lens[j] -
- alignedsym_ctrs[j][LZX_ALIGNEDCODE_NUM_SYMBOLS];
- unsigned entropy = entropy_val(num_mainsyms) +
- entropy_val(num_lensyms) +
- entropy_val(num_alignedsyms) -
- entropy_ctrs[j];
- unsigned est_csize = entropy + block_overhead;
-
- unsigned end_idx = i + window_lens[j];
- if (est_csize + shortest_paths[i] < shortest_paths[end_idx]) {
- shortest_paths[end_idx] = est_csize + shortest_paths[i];
- back_ptrs[end_idx] = i;
- }
- }
- /* Remove left symbol from windows */
- for (int j = 0; j <= end_window_idx; j++) {
- input_idx_t orig_maincnt = mainsym_ctrs[j][main_syms[i]]--;
- entropy_ctrs[j] -= entropy_val(orig_maincnt);
- entropy_ctrs[j] += entropy_val(orig_maincnt - 1);
-
- input_idx_t orig_lencnt =
- lensym_ctrs[j][len_syms[i]]--;
- if (len_syms[i] != LZX_LENCODE_NUM_SYMBOLS) {
- entropy_ctrs[j] -= entropy_val(orig_lencnt);
- entropy_ctrs[j] += entropy_val(orig_lencnt - 1);
- }
-
- input_idx_t orig_alignedcnt =
- alignedsym_ctrs[j][aligned_syms[i]]--;
- if (aligned_syms[i] != LZX_ALIGNEDCODE_NUM_SYMBOLS) {
- entropy_ctrs[j] -= entropy_val(orig_alignedcnt);
- entropy_ctrs[j] += entropy_val(orig_alignedcnt - 1);
- }
- }
-
- /* Calculate index of longest window remaining */
- while (end_window_idx >= 0 && window_lens[end_window_idx] >= n - i)
- end_window_idx--;
-
- /* Append right symbol to windows */
- for (int j = 0; j <= end_window_idx; j++) {
- input_idx_t orig_maincnt = mainsym_ctrs[j][
- main_syms[i + window_lens[j]]]++;
- entropy_ctrs[j] -= entropy_val(orig_maincnt);
- entropy_ctrs[j] += entropy_val(orig_maincnt + 1);
-
- input_idx_t orig_lencnt =
- lensym_ctrs[j][len_syms[i + window_lens[j]]]++;
- if (len_syms[i + window_lens[j]] != LZX_LENCODE_NUM_SYMBOLS) {
- entropy_ctrs[j] -= entropy_val(orig_lencnt);
- entropy_ctrs[j] += entropy_val(orig_lencnt + 1);
- }
-
- input_idx_t orig_alignedcnt =
- alignedsym_ctrs[j][aligned_syms[i + window_lens[j]]]++;
- if (aligned_syms[i + window_lens[j]] != LZX_ALIGNEDCODE_NUM_SYMBOLS) {
- entropy_ctrs[j] -= entropy_val(orig_alignedcnt);
- entropy_ctrs[j] += entropy_val(orig_alignedcnt + 1);
- }
- }
- }
- }
-
-#if 0
- /* If no cost was computed for the first block (due to it being shorter
- * than all the windows), merge it with the second block. */
- for (input_idx_t i = n; i != 0; i = back_ptrs[i])
- if (back_ptrs[i] != 0 && shortest_paths[back_ptrs[i]] == ~0U)
- back_ptrs[i] = 0;
-#endif
-
- /* Calculate number of blocks */
- input_idx_t num_blocks = 0;
- for (input_idx_t i = n; i != 0; i = back_ptrs[i])
- num_blocks++;
-
- while (num_blocks > max_num_blocks) {
- LZX_DEBUG("Joining blocks to bring total under max_num_blucks=%u",
- max_num_blocks);
- back_ptrs[n] = back_ptrs[back_ptrs[n]];
- num_blocks--;
- }
-
- LZX_ASSERT(num_blocks != 0);
-
- /* fill in the 'struct lzx_block_spec' for each block */
- for (input_idx_t i = n, j = num_blocks - 1; i != 0; i = back_ptrs[i], j--) {
-
- block_specs[j].chosen_matches_start_pos = back_ptrs[i];
- block_specs[j].num_chosen_matches = i - back_ptrs[i];
- block_specs[j].window_pos = orig_input_indices[back_ptrs[i]];
- block_specs[j].block_size = orig_input_indices[i] -
- orig_input_indices[back_ptrs[i]];
- /*block_specs[j].est_csize = (shortest_paths[i] -*/
- /*shortest_paths[back_ptrs[i]]) / 8;*/
-
- LZX_DEBUG("block match_indices [%u, %u) est_csize %u bits\n",
- back_ptrs[i], i,
- shortest_paths[i] - shortest_paths[back_ptrs[i]]);
-
- struct lzx_freqs freqs = {};
-
- for (input_idx_t k = back_ptrs[i]; k < i; k++) {
- freqs.main[main_syms[k]]++;
- if (len_syms[k] != LZX_LENCODE_NUM_SYMBOLS)
- freqs.len[len_syms[k]]++;
- if (aligned_syms[k] != LZX_LENCODE_NUM_SYMBOLS)
- freqs.aligned[aligned_syms[k]]++;
- }
- lzx_make_huffman_codes(&freqs, &block_specs[j].codes);
-
- block_specs[j].block_type = lzx_choose_verbatim_or_aligned(&freqs,
- &block_specs[j].codes);
- }
- *num_blocks_ret = num_blocks;
-}
-
-
-/* Initialize the suffix array match-finder for the specified input. */
-static void
-lzx_lz_init_matchfinder(const u8 T[const restrict],
- const input_idx_t n,
- input_idx_t SA[const restrict],
- input_idx_t ISA[const restrict],
- input_idx_t LCP[const restrict],
- struct salink link[const restrict],
- const unsigned max_match_len)
-{
- /* Compute SA (Suffix Array). */
-
- {
- saidx_t sa[n];
- /* ISA and link are used as temporary space. */
- BUILD_BUG_ON(LZX_MAX_WINDOW_SIZE * sizeof(ISA[0]) < 256 * sizeof(saidx_t));
- BUILD_BUG_ON(LZX_MAX_WINDOW_SIZE * 2 * sizeof(link[0]) < 256 * 256 * sizeof(saidx_t));
- divsufsort(T, sa, n, (saidx_t*)ISA, (saidx_t*)link);
- for (input_idx_t i = 0; i < n; i++)
- SA[i] = sa[i];
- }
-
-#ifdef ENABLE_LZX_DEBUG
-
- LZX_ASSERT(n > 0);
-
- /* Verify suffix array. */
- {
- bool found[n];
- ZERO_ARRAY(found);
- for (input_idx_t r = 0; r < n; r++) {
- input_idx_t i = SA[r];
- LZX_ASSERT(i < n);
- LZX_ASSERT(!found[i]);
- found[i] = true;
- }
- }
-
- for (input_idx_t r = 0; r < n - 1; r++) {
-
- input_idx_t i1 = SA[r];
- input_idx_t i2 = SA[r + 1];
-
- input_idx_t n1 = n - i1;
- input_idx_t n2 = n - i2;
-
- LZX_ASSERT(memcmp(&T[i1], &T[i2], min(n1, n2)) <= 0);
- }
- LZX_DEBUG("Verified SA (len %u)", n);
-#endif /* ENABLE_LZX_DEBUG */
-
- /* Compute ISA (Inverse Suffix Array) */
- for (input_idx_t r = 0; r < n; r++)
- ISA[SA[r]] = r;
-
- /* Compute LCP (longest common prefix) array.
- *
- * Algorithm adapted from Kasai et al. 2001: "Linear-Time
- * Longest-Common-Prefix Computation in Suffix Arrays and Its
- * Applications". */
- {
- input_idx_t h = 0;
- for (input_idx_t i = 0; i < n; i++) {
- input_idx_t r = ISA[i];
- if (r > 0) {
- input_idx_t j = SA[r - 1];
-
- input_idx_t lim = min(n - i, n - j);
-
- while (h < lim && T[i + h] == T[j + h])
- h++;
- LCP[r] = h;
- if (h > 0)
- h--;
- }
- }
- }
-
-#ifdef ENABLE_LZX_DEBUG
- /* Verify LCP array. */
- for (input_idx_t r = 0; r < n - 1; r++) {
- LZX_ASSERT(ISA[SA[r]] == r);
- LZX_ASSERT(ISA[SA[r + 1]] == r + 1);
-
- input_idx_t i1 = SA[r];
- input_idx_t i2 = SA[r + 1];
- input_idx_t lcp = LCP[r + 1];
-
- input_idx_t n1 = n - i1;
- input_idx_t n2 = n - i2;
-
- LZX_ASSERT(lcp <= min(n1, n2));
-
- LZX_ASSERT(memcmp(&T[i1], &T[i2], lcp) == 0);
- if (lcp < min(n1, n2))
- LZX_ASSERT(T[i1 + lcp] != T[i2 + lcp]);
- }
-#endif /* ENABLE_LZX_DEBUG */
-
- /* Compute salink.next and salink.lcpnext.
- *
- * Algorithm adapted from Crochemore et al. 2009:
- * "LPF computation revisited".
- *
- * Note: we cap lcpnext to the maximum match length so that the
- * match-finder need not worry about it later. */
- link[n - 1].next = (input_idx_t)~0U;
- link[n - 1].prev = (input_idx_t)~0U;
- link[n - 1].lcpnext = 0;
- link[n - 1].lcpprev = 0;
- for (input_idx_t r = n - 2; r != (input_idx_t)~0U; r--) {
- input_idx_t t = r + 1;
- input_idx_t l = LCP[t];
- while (t != (input_idx_t)~0 && SA[t] > SA[r]) {
- l = min(l, link[t].lcpnext);
- t = link[t].next;
- }
- link[r].next = t;
- link[r].lcpnext = min(l, max_match_len);
- LZX_ASSERT(t == (input_idx_t)~0 || l <= n - SA[t]);
- LZX_ASSERT(l <= n - SA[r]);
- LZX_ASSERT(memcmp(&T[SA[r]], &T[SA[t]], l) == 0);
- }
-
- /* Compute salink.prev and salink.lcpprev.
- *
- * Algorithm adapted from Crochemore et al. 2009:
- * "LPF computation revisited".
- *
- * Note: we cap lcpprev to the maximum match length so that the
- * match-finder need not worry about it later. */
- link[0].prev = (input_idx_t)~0;
- link[0].next = (input_idx_t)~0;
- link[0].lcpprev = 0;
- link[0].lcpnext = 0;
- for (input_idx_t r = 1; r < n; r++) {
- input_idx_t t = r - 1;
- input_idx_t l = LCP[r];
- while (t != (input_idx_t)~0 && SA[t] > SA[r]) {
- l = min(l, link[t].lcpprev);
- t = link[t].prev;
- }
- link[r].prev = t;
- link[r].lcpprev = min(l, max_match_len);
- LZX_ASSERT(t == (input_idx_t)~0 || l <= n - SA[t]);
- LZX_ASSERT(l <= n - SA[r]);
- LZX_ASSERT(memcmp(&T[SA[r]], &T[SA[t]], l) == 0);
- }
-}
-
/* Prepare the input window into one or more LZX blocks ready to be output. */
static void
lzx_prepare_blocks(struct lzx_compressor * ctx)
{
/* Initialize the match-finder. */
- lzx_lz_init_matchfinder(ctx->window, ctx->window_size,
- ctx->SA, ctx->ISA, ctx->LCP, ctx->salink,
- LZX_MAX_MATCH_LEN);
+ lz_sarray_load_window(&ctx->lz_sarray, ctx->window, ctx->window_size);
ctx->cached_matches_pos = 0;
ctx->matches_cached = false;
ctx->match_window_pos = 0;
/* Set up a default cost model. */
- lzx_set_default_costs(&ctx->costs);
+ lzx_set_default_costs(&ctx->costs, ctx->num_main_syms);
- /* Initially assume that the entire input will be one LZX block. */
- ctx->block_specs[0].block_type = LZX_BLOCKTYPE_ALIGNED;
- ctx->block_specs[0].window_pos = 0;
- ctx->block_specs[0].block_size = ctx->window_size;
- ctx->num_blocks = 1;
+ /* TODO: The compression ratio could be slightly improved by performing
+ * data-dependent block splitting instead of using fixed-size blocks.
+ * Doing so well is a computationally hard problem, however. */
+ ctx->num_blocks = DIV_ROUND_UP(ctx->window_size, LZX_DIV_BLOCK_SIZE);
+ for (unsigned i = 0; i < ctx->num_blocks; i++) {
+ unsigned pos = LZX_DIV_BLOCK_SIZE * i;
+ ctx->block_specs[i].window_pos = pos;
+ ctx->block_specs[i].block_size = min(ctx->window_size - pos, LZX_DIV_BLOCK_SIZE);
+ }
- /* Perform near-optimal LZ parsing. */
+ /* Determine sequence of matches/literals to output for each block. */
lzx_optimize_blocks(ctx);
-
- /* Possibly divide up the LZX block. */
- const unsigned max_num_blocks = 1U << ctx->params.alg_params.slow.num_split_passes;
- if (max_num_blocks > 1) {
- const double epsilon = 0.2;
- const unsigned min_block_len = 500;
-
- lzx_block_split((const u32*)ctx->chosen_matches,
- ctx->block_specs[0].num_chosen_matches,
- epsilon, max_num_blocks, min_block_len,
- ctx->block_specs, &ctx->num_blocks);
- }
}
/*
* ctx->window[]
* ctx->window_size
*
- * Working space:
- * ctx->queue
- *
* Output --- the block specification and the corresponding match/literal data:
*
* ctx->block_specs[]
static void
lzx_prepare_block_fast(struct lzx_compressor * ctx)
{
- unsigned num_matches;
- struct lzx_freqs freqs;
+ struct lzx_record_ctx record_ctx;
struct lzx_block_spec *spec;
/* Parameters to hash chain LZ match finder
* aren't worth choosing when using greedy or lazy parsing. */
.min_match = 3,
.max_match = LZX_MAX_MATCH_LEN,
+ .max_offset = LZX_MAX_WINDOW_SIZE,
.good_match = LZX_MAX_MATCH_LEN,
.nice_match = LZX_MAX_MATCH_LEN,
.max_chain_len = LZX_MAX_MATCH_LEN,
};
/* Initialize symbol frequencies and match offset LRU queue. */
- memset(&freqs, 0, sizeof(struct lzx_freqs));
- lzx_lru_queue_init(&ctx->queue);
+ memset(&record_ctx.freqs, 0, sizeof(struct lzx_freqs));
+ lzx_lru_queue_init(&record_ctx.queue);
+ record_ctx.matches = ctx->chosen_matches;
/* Determine series of matches/literals to output. */
- num_matches = lz_analyze_block(ctx->window,
- ctx->window_size,
- (u32*)ctx->chosen_matches,
- lzx_record_match,
- lzx_record_literal,
- &freqs,
- &ctx->queue,
- &freqs,
- &lzx_lz_params);
-
+ lz_analyze_block(ctx->window,
+ ctx->window_size,
+ lzx_record_match,
+ lzx_record_literal,
+ &record_ctx,
+ &lzx_lz_params,
+ ctx->prev_tab);
/* Set up block specification. */
spec = &ctx->block_specs[0];
spec->block_type = LZX_BLOCKTYPE_ALIGNED;
spec->window_pos = 0;
spec->block_size = ctx->window_size;
- spec->num_chosen_matches = num_matches;
+ spec->num_chosen_matches = (record_ctx.matches - ctx->chosen_matches);
spec->chosen_matches_start_pos = 0;
- lzx_make_huffman_codes(&freqs, &spec->codes);
+ lzx_make_huffman_codes(&record_ctx.freqs, &spec->codes,
+ ctx->num_main_syms);
ctx->num_blocks = 1;
}
}
}
-/* API function documented in wimlib.h */
-WIMLIBAPI unsigned
-wimlib_lzx_compress2(const void * const restrict uncompressed_data,
- unsigned const uncompressed_len,
- void * const restrict compressed_data,
- struct wimlib_lzx_context * const restrict lzx_ctx)
+static size_t
+lzx_compress(const void *uncompressed_data, size_t uncompressed_size,
+ void *compressed_data, size_t compressed_size_avail, void *_ctx)
{
- struct lzx_compressor *ctx = (struct lzx_compressor*)lzx_ctx;
+ struct lzx_compressor *ctx = _ctx;
struct output_bitstream ostream;
- unsigned compressed_len;
+ size_t compressed_size;
- if (uncompressed_len < 100) {
+ if (uncompressed_size < 100) {
LZX_DEBUG("Too small to bother compressing.");
return 0;
}
- if (uncompressed_len > 32768) {
- LZX_DEBUG("Only up to 32768 bytes of uncompressed data are supported.");
+ if (uncompressed_size > ctx->max_window_size) {
+ LZX_DEBUG("Can't compress %zu bytes using window of %u bytes!",
+ uncompressed_size, ctx->max_window_size);
return 0;
}
- wimlib_assert(lzx_ctx != NULL);
-
- LZX_DEBUG("Attempting to compress %u bytes...", uncompressed_len);
+ LZX_DEBUG("Attempting to compress %zu bytes...",
+ uncompressed_size);
/* The input data must be preprocessed. To avoid changing the original
* input, copy it to a temporary buffer. */
- memcpy(ctx->window, uncompressed_data, uncompressed_len);
- ctx->window_size = uncompressed_len;
+ memcpy(ctx->window, uncompressed_data, uncompressed_size);
+ ctx->window_size = uncompressed_size;
/* This line is unnecessary; it just avoids inconsequential accesses of
* uninitialized memory that would show up in memory-checking tools such
LZX_DEBUG("Writing compressed blocks...");
/* Generate the compressed data. */
- init_output_bitstream(&ostream, compressed_data, ctx->window_size - 1);
+ init_output_bitstream(&ostream, compressed_data, compressed_size_avail);
lzx_write_all_blocks(ctx, &ostream);
LZX_DEBUG("Flushing bitstream...");
- if (flush_output_bitstream(&ostream)) {
- /* If the bitstream cannot be flushed, then the output space was
- * exhausted. */
- LZX_DEBUG("Data did not compress to less than original length!");
+ compressed_size = flush_output_bitstream(&ostream);
+ if (compressed_size == ~(input_idx_t)0) {
+ LZX_DEBUG("Data did not compress to %zu bytes or less!",
+ compressed_size_avail);
return 0;
}
- /* Compute the length of the compressed data. */
- compressed_len = ostream.bit_output - (u8*)compressed_data;
-
- LZX_DEBUG("Done: compressed %u => %u bytes.",
- uncompressed_len, compressed_len);
+ LZX_DEBUG("Done: compressed %zu => %zu bytes.",
+ uncompressed_size, compressed_size);
/* Verify that we really get the same thing back when decompressing.
- * TODO: Disable this check by default on the slow algorithm. */
+ * Although this could be disabled by default in all cases, it only
+ * takes around 2-3% of the running time of the slow algorithm to do the
+ * verification. */
if (ctx->params.algorithm == WIMLIB_LZX_ALGORITHM_SLOW
#if defined(ENABLE_LZX_DEBUG) || defined(ENABLE_VERIFY_COMPRESSION)
|| 1
#endif
)
{
- u8 buf[uncompressed_len];
- int ret;
-
- ret = wimlib_lzx_decompress(compressed_data, compressed_len,
- buf, uncompressed_len);
- if (ret) {
- ERROR("Failed to decompress data we "
- "compressed using LZX algorithm");
- wimlib_assert(0);
- return 0;
- }
+ struct wimlib_decompressor *decompressor;
- if (memcmp(uncompressed_data, buf, uncompressed_len)) {
- ERROR("Data we compressed using LZX algorithm "
- "didn't decompress to original");
- wimlib_assert(0);
- return 0;
+ if (0 == wimlib_create_decompressor(WIMLIB_COMPRESSION_TYPE_LZX,
+ ctx->max_window_size,
+ NULL,
+ &decompressor))
+ {
+ int ret;
+ ret = wimlib_decompress(compressed_data,
+ compressed_size,
+ ctx->window,
+ uncompressed_size,
+ decompressor);
+ wimlib_free_decompressor(decompressor);
+
+ if (ret) {
+ ERROR("Failed to decompress data we "
+ "compressed using LZX algorithm");
+ wimlib_assert(0);
+ return 0;
+ }
+ if (memcmp(uncompressed_data, ctx->window, uncompressed_size)) {
+ ERROR("Data we compressed using LZX algorithm "
+ "didn't decompress to original");
+ wimlib_assert(0);
+ return 0;
+ }
+ } else {
+ WARNING("Failed to create decompressor for "
+ "data verification!");
}
}
- return compressed_len;
+ return compressed_size;
}
-static bool
-lzx_params_compatible(const struct wimlib_lzx_params *oldparams,
- const struct wimlib_lzx_params *newparams)
-{
- return 0 == memcmp(oldparams, newparams, sizeof(struct wimlib_lzx_params));
-}
-
-static struct wimlib_lzx_params lzx_user_default_params;
-static struct wimlib_lzx_params *lzx_user_default_params_ptr;
-
-static bool
-lzx_params_valid(const struct wimlib_lzx_params *params)
+static void
+lzx_free_compressor(void *_ctx)
{
- /* Validate parameters. */
- if (params->size_of_this != sizeof(struct wimlib_lzx_params)) {
- LZX_DEBUG("Invalid parameter structure size!");
- return false;
- }
-
- if (params->algorithm != WIMLIB_LZX_ALGORITHM_SLOW &&
- params->algorithm != WIMLIB_LZX_ALGORITHM_FAST)
- {
- LZX_DEBUG("Invalid algorithm.");
- return false;
- }
-
- if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW) {
- if (params->alg_params.slow.num_optim_passes < 1)
- {
- LZX_DEBUG("Invalid number of optimization passes!");
- return false;
- }
-
- if (params->alg_params.slow.main_nostat_cost < 1 ||
- params->alg_params.slow.main_nostat_cost > 16)
- {
- LZX_DEBUG("Invalid main_nostat_cost!");
- return false;
- }
-
- if (params->alg_params.slow.len_nostat_cost < 1 ||
- params->alg_params.slow.len_nostat_cost > 16)
- {
- LZX_DEBUG("Invalid len_nostat_cost!");
- return false;
- }
-
- if (params->alg_params.slow.aligned_nostat_cost < 1 ||
- params->alg_params.slow.aligned_nostat_cost > 8)
- {
- LZX_DEBUG("Invalid aligned_nostat_cost!");
- return false;
- }
+ struct lzx_compressor *ctx = _ctx;
- if (params->alg_params.slow.num_split_passes > 31) {
- LZX_DEBUG("Invalid num_split_passes!");
- return false;
- }
+ if (ctx) {
+ FREE(ctx->chosen_matches);
+ FREE(ctx->cached_matches);
+ lz_match_chooser_destroy(&ctx->mc);
+ lz_sarray_destroy(&ctx->lz_sarray);
+ FREE(ctx->block_specs);
+ FREE(ctx->prev_tab);
+ FREE(ctx->window);
+ FREE(ctx);
}
- return true;
}
-WIMLIBAPI int
-wimlib_lzx_set_default_params(const struct wimlib_lzx_params * params)
+static const struct wimlib_lzx_compressor_params lzx_fast_default = {
+ .hdr = {
+ .size = sizeof(struct wimlib_lzx_compressor_params),
+ },
+ .algorithm = WIMLIB_LZX_ALGORITHM_FAST,
+ .use_defaults = 0,
+ .alg_params = {
+ .fast = {
+ },
+ },
+};
+static const struct wimlib_lzx_compressor_params lzx_slow_default = {
+ .hdr = {
+ .size = sizeof(struct wimlib_lzx_compressor_params),
+ },
+ .algorithm = WIMLIB_LZX_ALGORITHM_SLOW,
+ .use_defaults = 0,
+ .alg_params = {
+ .slow = {
+ .use_len2_matches = 1,
+ .nice_match_length = 32,
+ .num_optim_passes = 2,
+ .max_search_depth = 50,
+ .max_matches_per_pos = 3,
+ .main_nostat_cost = 15,
+ .len_nostat_cost = 15,
+ .aligned_nostat_cost = 7,
+ },
+ },
+};
+
+static const struct wimlib_lzx_compressor_params *
+lzx_get_params(const struct wimlib_compressor_params_header *_params)
{
- if (params) {
- if (!lzx_params_valid(params))
- return WIMLIB_ERR_INVALID_PARAM;
- lzx_user_default_params = *params;
- lzx_user_default_params_ptr = &lzx_user_default_params;
+ const struct wimlib_lzx_compressor_params *params =
+ (const struct wimlib_lzx_compressor_params*)_params;
+
+ if (params == NULL) {
+ LZX_DEBUG("Using default algorithm and parameters.");
+ params = &lzx_slow_default;
} else {
- lzx_user_default_params_ptr = NULL;
+ if (params->use_defaults) {
+ if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW)
+ params = &lzx_slow_default;
+ else
+ params = &lzx_fast_default;
+ }
}
- return 0;
+ return params;
}
-/* API function documented in wimlib.h */
-WIMLIBAPI int
-wimlib_lzx_alloc_context(const struct wimlib_lzx_params *params,
- struct wimlib_lzx_context **ctx_pp)
+static int
+lzx_create_compressor(size_t window_size,
+ const struct wimlib_compressor_params_header *_params,
+ void **ctx_ret)
{
-
- LZX_DEBUG("Allocating LZX context...");
-
+ const struct wimlib_lzx_compressor_params *params = lzx_get_params(_params);
struct lzx_compressor *ctx;
- static const struct wimlib_lzx_params fast_default = {
- .size_of_this = sizeof(struct wimlib_lzx_params),
- .algorithm = WIMLIB_LZX_ALGORITHM_FAST,
- .use_defaults = 0,
- .alg_params = {
- .fast = {
- },
- },
- };
- static const struct wimlib_lzx_params slow_default = {
- .size_of_this = sizeof(struct wimlib_lzx_params),
- .algorithm = WIMLIB_LZX_ALGORITHM_SLOW,
- .use_defaults = 0,
- .alg_params = {
- .slow = {
- .use_len2_matches = 1,
- .num_fast_bytes = 32,
- .num_optim_passes = 2,
- .num_split_passes = 0,
- .max_search_depth = 50,
- .max_matches_per_pos = 3,
- .main_nostat_cost = 15,
- .len_nostat_cost = 15,
- .aligned_nostat_cost = 7,
- },
- },
- };
-
- if (params) {
- if (!lzx_params_valid(params))
- return WIMLIB_ERR_INVALID_PARAM;
- } else {
- LZX_DEBUG("Using default algorithm and parameters.");
- if (lzx_user_default_params_ptr)
- params = lzx_user_default_params_ptr;
- else
- params = &slow_default;
- }
-
- if (params->use_defaults) {
- if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW)
- params = &slow_default;
- else
- params = &fast_default;
- }
-
- if (ctx_pp) {
- ctx = *(struct lzx_compressor**)ctx_pp;
+ LZX_DEBUG("Allocating LZX context...");
- if (ctx && lzx_params_compatible(&ctx->params, params))
- return 0;
- } else {
- LZX_DEBUG("Check parameters only.");
- return 0;
- }
+ if (!lzx_window_size_valid(window_size))
+ return WIMLIB_ERR_INVALID_PARAM;
LZX_DEBUG("Allocating memory.");
- ctx = MALLOC(sizeof(struct lzx_compressor));
+ ctx = CALLOC(1, sizeof(struct lzx_compressor));
if (ctx == NULL)
- goto err;
-
- size_t block_specs_length;
+ goto oom;
+
+ ctx->num_main_syms = lzx_get_num_main_syms(window_size);
+ ctx->max_window_size = window_size;
+ ctx->window = MALLOC(window_size + 12);
+ if (ctx->window == NULL)
+ goto oom;
+
+ if (params->algorithm == WIMLIB_LZX_ALGORITHM_FAST) {
+ ctx->prev_tab = MALLOC(window_size * sizeof(ctx->prev_tab[0]));
+ if (ctx->prev_tab == NULL)
+ goto oom;
+ }
- if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW)
- block_specs_length = 1U << params->alg_params.slow.num_split_passes;
- else
- block_specs_length = 1U;
+ size_t block_specs_length = DIV_ROUND_UP(window_size, LZX_DIV_BLOCK_SIZE);
ctx->block_specs = MALLOC(block_specs_length * sizeof(ctx->block_specs[0]));
if (ctx->block_specs == NULL)
- goto err_free_ctx;
+ goto oom;
if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW) {
- ctx->SA = MALLOC(3U * LZX_MAX_WINDOW_SIZE * sizeof(ctx->SA[0]));
- if (ctx->SA == NULL)
- goto err_free_block_specs;
- ctx->ISA = ctx->SA + LZX_MAX_WINDOW_SIZE;
- ctx->LCP = ctx->ISA + LZX_MAX_WINDOW_SIZE;
- ctx->salink = MALLOC(LZX_MAX_WINDOW_SIZE * sizeof(ctx->salink[0]));
- if (ctx->salink == NULL)
- goto err_free_SA;
- } else {
- ctx->SA = NULL;
- ctx->ISA = NULL;
- ctx->LCP = NULL;
- ctx->salink = NULL;
+ unsigned min_match_len = LZX_MIN_MATCH_LEN;
+ if (!params->alg_params.slow.use_len2_matches)
+ min_match_len = max(min_match_len, 3);
+
+ if (!lz_sarray_init(&ctx->lz_sarray,
+ window_size,
+ min_match_len,
+ LZX_MAX_MATCH_LEN,
+ params->alg_params.slow.max_search_depth,
+ params->alg_params.slow.max_matches_per_pos))
+ goto oom;
}
if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW) {
- ctx->optimum = MALLOC((LZX_OPTIM_ARRAY_SIZE + LZX_MAX_MATCH_LEN) *
- sizeof(ctx->optimum[0]));
- if (ctx->optimum == NULL)
- goto err_free_salink;
- } else {
- ctx->optimum = NULL;
+ if (!lz_match_chooser_init(&ctx->mc,
+ LZX_OPTIM_ARRAY_SIZE,
+ params->alg_params.slow.nice_match_length,
+ LZX_MAX_MATCH_LEN))
+ goto oom;
}
if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW) {
- uint32_t cache_per_pos;
+ u32 cache_per_pos;
cache_per_pos = params->alg_params.slow.max_matches_per_pos;
if (cache_per_pos > LZX_MAX_CACHE_PER_POS)
cache_per_pos = LZX_MAX_CACHE_PER_POS;
- ctx->cached_matches = MALLOC(LZX_MAX_WINDOW_SIZE * (cache_per_pos + 1) *
+ ctx->cached_matches = MALLOC(window_size * (cache_per_pos + 1) *
sizeof(ctx->cached_matches[0]));
if (ctx->cached_matches == NULL)
- goto err_free_optimum;
- } else {
- ctx->cached_matches = NULL;
+ goto oom;
}
- ctx->chosen_matches = MALLOC(LZX_MAX_WINDOW_SIZE *
- sizeof(ctx->chosen_matches[0]));
+ ctx->chosen_matches = MALLOC(window_size * sizeof(ctx->chosen_matches[0]));
if (ctx->chosen_matches == NULL)
- goto err_free_cached_matches;
+ goto oom;
- memcpy(&ctx->params, params, sizeof(struct wimlib_lzx_params));
+ memcpy(&ctx->params, params, sizeof(struct wimlib_lzx_compressor_params));
memset(&ctx->zero_codes, 0, sizeof(ctx->zero_codes));
LZX_DEBUG("Successfully allocated new LZX context.");
- wimlib_lzx_free_context(*ctx_pp);
- *ctx_pp = (struct wimlib_lzx_context*)ctx;
+ *ctx_ret = ctx;
return 0;
-err_free_cached_matches:
- FREE(ctx->cached_matches);
-err_free_optimum:
- FREE(ctx->optimum);
-err_free_salink:
- FREE(ctx->salink);
-err_free_SA:
- FREE(ctx->SA);
-err_free_block_specs:
- FREE(ctx->block_specs);
-err_free_ctx:
- FREE(ctx);
-err:
- LZX_DEBUG("Ran out of memory.");
+oom:
+ lzx_free_compressor(ctx);
return WIMLIB_ERR_NOMEM;
}
-/* API function documented in wimlib.h */
-WIMLIBAPI void
-wimlib_lzx_free_context(struct wimlib_lzx_context *_ctx)
+static u64
+lzx_get_needed_memory(size_t max_block_size,
+ const struct wimlib_compressor_params_header *_params)
{
- struct lzx_compressor *ctx = (struct lzx_compressor*)_ctx;
+ const struct wimlib_lzx_compressor_params *params = lzx_get_params(_params);
- if (ctx) {
- FREE(ctx->cached_matches);
- FREE(ctx->chosen_matches);
- FREE(ctx->optimum);
- FREE(ctx->SA);
- FREE(ctx->salink);
- FREE(ctx->block_specs);
- FREE(ctx);
+ u64 size = 0;
+
+ size += sizeof(struct lzx_compressor);
+
+ size += max_block_size + 12;
+
+ size += DIV_ROUND_UP(max_block_size, LZX_DIV_BLOCK_SIZE) *
+ sizeof(((struct lzx_compressor*)0)->block_specs[0]);
+
+ if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW) {
+ size += max_block_size * sizeof(((struct lzx_compressor*)0)->chosen_matches[0]);
+ size += lz_sarray_get_needed_memory(max_block_size);
+ size += lz_match_chooser_get_needed_memory(LZX_OPTIM_ARRAY_SIZE,
+ params->alg_params.slow.nice_match_length,
+ LZX_MAX_MATCH_LEN);
+ u32 cache_per_pos;
+
+ cache_per_pos = params->alg_params.slow.max_matches_per_pos;
+ if (cache_per_pos > LZX_MAX_CACHE_PER_POS)
+ cache_per_pos = LZX_MAX_CACHE_PER_POS;
+
+ size += max_block_size * (cache_per_pos + 1) *
+ sizeof(((struct lzx_compressor*)0)->cached_matches[0]);
+ } else {
+ size += max_block_size * sizeof(((struct lzx_compressor*)0)->prev_tab[0]);
}
+ return size;
}
-/* API function documented in wimlib.h */
-WIMLIBAPI unsigned
-wimlib_lzx_compress(const void * const restrict uncompressed_data,
- unsigned const uncompressed_len,
- void * const restrict compressed_data)
+static bool
+lzx_params_valid(const struct wimlib_compressor_params_header *_params)
{
- int ret;
- struct wimlib_lzx_context *ctx = NULL;
- unsigned compressed_len;
-
- ret = wimlib_lzx_alloc_context(NULL, &ctx);
- if (ret) {
- wimlib_assert(ret != WIMLIB_ERR_INVALID_PARAM);
- WARNING("Couldn't allocate LZX compression context: %"TS"",
- wimlib_get_error_string(ret));
- return 0;
+ const struct wimlib_lzx_compressor_params *params =
+ (const struct wimlib_lzx_compressor_params*)_params;
+
+ if (params->hdr.size != sizeof(struct wimlib_lzx_compressor_params)) {
+ LZX_DEBUG("Invalid parameter structure size!");
+ return false;
}
- compressed_len = wimlib_lzx_compress2(uncompressed_data,
- uncompressed_len,
- compressed_data,
- ctx);
+ if (params->algorithm != WIMLIB_LZX_ALGORITHM_SLOW &&
+ params->algorithm != WIMLIB_LZX_ALGORITHM_FAST)
+ {
+ LZX_DEBUG("Invalid algorithm.");
+ return false;
+ }
+
+ if (params->algorithm == WIMLIB_LZX_ALGORITHM_SLOW &&
+ !params->use_defaults)
+ {
+ if (params->alg_params.slow.num_optim_passes < 1)
+ {
+ LZX_DEBUG("Invalid number of optimization passes!");
+ return false;
+ }
+
+ if (params->alg_params.slow.main_nostat_cost < 1 ||
+ params->alg_params.slow.main_nostat_cost > 16)
+ {
+ LZX_DEBUG("Invalid main_nostat_cost!");
+ return false;
+ }
- wimlib_lzx_free_context(ctx);
+ if (params->alg_params.slow.len_nostat_cost < 1 ||
+ params->alg_params.slow.len_nostat_cost > 16)
+ {
+ LZX_DEBUG("Invalid len_nostat_cost!");
+ return false;
+ }
- return compressed_len;
+ if (params->alg_params.slow.aligned_nostat_cost < 1 ||
+ params->alg_params.slow.aligned_nostat_cost > 8)
+ {
+ LZX_DEBUG("Invalid aligned_nostat_cost!");
+ return false;
+ }
+ }
+ return true;
}
+
+const struct compressor_ops lzx_compressor_ops = {
+ .params_valid = lzx_params_valid,
+ .get_needed_memory = lzx_get_needed_memory,
+ .create_compressor = lzx_create_compressor,
+ .compress = lzx_compress,
+ .free_compressor = lzx_free_compressor,
+};