};
/* LZX intermediate match/literal format */
-struct lzx_match {
+struct lzx_item {
/* Bit Description
*
* 31 1 if a match, 0 if a literal.
input_idx_t block_size;
/* The match/literal sequence for this block. */
- struct lzx_match *chosen_matches;
+ struct lzx_item *chosen_items;
- /* The length of the @chosen_matches sequence. */
- input_idx_t num_chosen_matches;
+ /* The length of the @chosen_items sequence. */
+ input_idx_t num_chosen_items;
/* Huffman codes for this block. */
struct lzx_codes codes;
/* Space for the sequences of matches/literals that were chosen for each
* block. */
- struct lzx_match *chosen_matches;
+ struct lzx_item *chosen_items;
/* Information about the LZX blocks the preprocessed input was divided
* into. */
*/
static void
lzx_write_match(struct output_bitstream *out, int block_type,
- struct lzx_match match, const struct lzx_codes *codes)
+ struct lzx_item match, const struct lzx_codes *codes)
{
/* low 8 bits are the match length minus 2 */
unsigned match_len_minus_2 = match.data & 0xff;
static void
lzx_write_matches_and_literals(struct output_bitstream *ostream,
int block_type,
- const struct lzx_match match_tab[],
+ const struct lzx_item match_tab[],
unsigned match_count,
const struct lzx_codes *codes)
{
for (unsigned i = 0; i < match_count; i++) {
- struct lzx_match match = match_tab[i];
+ struct lzx_item match = match_tab[i];
/* The high bit of the 32-bit intermediate representation
* indicates whether the item is an actual LZ-style match (1) or
unsigned block_size,
unsigned max_window_size,
unsigned num_main_syms,
- struct lzx_match * chosen_matches,
- unsigned num_chosen_matches,
+ struct lzx_item * chosen_items,
+ unsigned num_chosen_items,
const struct lzx_codes * codes,
const struct lzx_codes * prev_codes,
struct output_bitstream * ostream)
/* Write the actual matches and literals. */
lzx_write_matches_and_literals(ostream, block_type,
- chosen_matches, num_chosen_matches,
+ chosen_items, num_chosen_items,
codes);
LZX_DEBUG("Done writing block.");
for (unsigned i = 0; i < ctx->num_blocks; i++) {
const struct lzx_block_spec *spec = &ctx->block_specs[i];
- LZX_DEBUG("Writing block %u/%u (type=%d, size=%u, num_chosen_matches=%u)...",
+ LZX_DEBUG("Writing block %u/%u (type=%d, size=%u, num_chosen_items=%u)...",
i + 1, ctx->num_blocks,
spec->block_type, spec->block_size,
- spec->num_chosen_matches);
+ spec->num_chosen_items);
lzx_write_compressed_block(spec->block_type,
spec->block_size,
ctx->max_window_size,
ctx->num_main_syms,
- spec->chosen_matches,
- spec->num_chosen_matches,
+ spec->chosen_items,
+ spec->num_chosen_items,
&spec->codes,
prev_codes,
ostream);
freqs->aligned[position_footer & 7]++;
/* Pack the position slot, position footer, and match length into an
- * intermediate representation. See `struct lzx_match' for details.
+ * intermediate representation. See `struct lzx_item' for details.
*/
LZX_ASSERT(LZX_MAX_POSITION_SLOTS <= 64);
LZX_ASSERT(lzx_get_num_extra_bits(LZX_MAX_POSITION_SLOTS - 1) <= 17);
struct lzx_record_ctx {
struct lzx_freqs freqs;
struct lzx_lru_queue queue;
- struct lzx_match *matches;
+ struct lzx_item *matches;
};
static void
struct lzx_freqs freqs;
const u8 *window_ptr;
const u8 *window_end;
- struct lzx_match *next_chosen_match;
+ struct lzx_item *next_chosen_match;
struct raw_match raw_match;
- struct lzx_match lzx_match;
+ struct lzx_item lzx_item;
LZX_ASSERT(num_passes >= 1);
LZX_ASSERT(lz_bt_get_position(&ctx->mf) == spec->window_pos);
window_ptr = &ctx->window[spec->window_pos];
window_end = window_ptr + spec->block_size;
- spec->chosen_matches = &ctx->chosen_matches[spec->window_pos];
- next_chosen_match = spec->chosen_matches;
+ spec->chosen_items = &ctx->chosen_items[spec->window_pos];
+ next_chosen_match = spec->chosen_items;
while (window_ptr != window_end) {
raw_match = lzx_get_near_optimal_match(ctx);
raw_match.offset == ctx->max_window_size -
LZX_MIN_MATCH_LEN));
if (raw_match.len >= LZX_MIN_MATCH_LEN) {
- lzx_match.data = lzx_tally_match(raw_match.len,
+ lzx_item.data = lzx_tally_match(raw_match.len,
raw_match.offset,
&freqs, &ctx->queue);
window_ptr += raw_match.len;
} else {
- lzx_match.data = lzx_tally_literal(*window_ptr, &freqs);
+ lzx_item.data = lzx_tally_literal(*window_ptr, &freqs);
window_ptr += 1;
}
- *next_chosen_match++ = lzx_match;
+ *next_chosen_match++ = lzx_item;
}
- spec->num_chosen_matches = next_chosen_match - spec->chosen_matches;
+ spec->num_chosen_items = next_chosen_match - spec->chosen_items;
lzx_make_huffman_codes(&freqs, &spec->codes, ctx->num_main_syms);
spec->block_type = lzx_choose_verbatim_or_aligned(&freqs, &spec->codes);
}
*
* ctx->block_specs[]
* ctx->num_blocks
- * ctx->chosen_matches[]
+ * ctx->chosen_items[]
*/
static void
lzx_prepare_block_fast(struct lzx_compressor * ctx)
/* Initialize symbol frequencies and match offset LRU queue. */
memset(&record_ctx.freqs, 0, sizeof(struct lzx_freqs));
lzx_lru_queue_init(&record_ctx.queue);
- record_ctx.matches = ctx->chosen_matches;
+ record_ctx.matches = ctx->chosen_items;
/* Determine series of matches/literals to output. */
lz_analyze_block(ctx->window,
spec->block_type = LZX_BLOCKTYPE_ALIGNED;
spec->window_pos = 0;
spec->block_size = ctx->window_size;
- spec->num_chosen_matches = (record_ctx.matches - ctx->chosen_matches);
- spec->chosen_matches = ctx->chosen_matches;
+ spec->num_chosen_items = (record_ctx.matches - ctx->chosen_items);
+ spec->chosen_items = ctx->chosen_items;
lzx_make_huffman_codes(&record_ctx.freqs, &spec->codes,
ctx->num_main_syms);
ctx->num_blocks = 1;
struct lzx_compressor *ctx = _ctx;
if (ctx) {
- FREE(ctx->chosen_matches);
+ FREE(ctx->chosen_items);
FREE(ctx->cached_matches);
FREE(ctx->optimum);
lz_bt_destroy(&ctx->mf);
LZX_CACHE_LEN - (LZX_MAX_MATCHES_PER_POS + 1);
}
- ctx->chosen_matches = MALLOC(window_size * sizeof(ctx->chosen_matches[0]));
- if (ctx->chosen_matches == NULL)
+ ctx->chosen_items = MALLOC(window_size * sizeof(ctx->chosen_items[0]));
+ if (ctx->chosen_items == NULL)
goto oom;
memcpy(&ctx->params, params, sizeof(struct wimlib_lzx_compressor_params));
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 += max_block_size * sizeof(((struct lzx_compressor*)0)->chosen_items[0]);
size += lz_bt_get_needed_memory(max_block_size);
size += (LZX_OPTIM_ARRAY_SIZE +
min(params->alg_params.slow.nice_match_length,
git://wimlib.net / wimlib / blobdiff