src/liblzma/lzma/lzma_encoder_private.h

   1 // SPDX-License-Identifier: 0BSD
   2
   3 ///////////////////////////////////////////////////////////////////////////////
   4 //
   5 /// \file       lzma_encoder_private.h
   6 /// \brief      Private definitions for LZMA encoder
   7 ///
   8 //  Authors:    Igor Pavlov
   9 //              Lasse Collin
  10 //
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef LZMA_LZMA_ENCODER_PRIVATE_H
  14 #define LZMA_LZMA_ENCODER_PRIVATE_H
  15
  16 #include "lz_encoder.h"
  17 #include "range_encoder.h"
  18 #include "lzma_common.h"
  19 #include "lzma_encoder.h"
  20
  21
  22 // Macro to compare if the first two bytes in two buffers differ. This is
  23 // needed in lzma_lzma_optimum_*() to test if the match is at least
  24 // MATCH_LEN_MIN bytes. Unaligned access gives tiny gain so there's no
  25 // reason to not use it when it is supported.
  26 #ifdef TUKLIB_FAST_UNALIGNED_ACCESS
  27 #       define not_equal_16(a, b) (read16ne(a) != read16ne(b))
  28 #else
  29 #       define not_equal_16(a, b) \
  30                 ((a)[0] != (b)[0] || (a)[1] != (b)[1])
  31 #endif
  32
  33
  34 // Optimal - Number of entries in the optimum array.
  35 #define OPTS (1 << 12)
  36
  37
  38 typedef struct {
  39         probability choice;
  40         probability choice2;
  41         probability low[POS_STATES_MAX][LEN_LOW_SYMBOLS];
  42         probability mid[POS_STATES_MAX][LEN_MID_SYMBOLS];
  43         probability high[LEN_HIGH_SYMBOLS];
  44
  45         uint32_t prices[POS_STATES_MAX][LEN_SYMBOLS];
  46         uint32_t table_size;
  47         uint32_t counters[POS_STATES_MAX];
  48
  49 } lzma_length_encoder;
  50
  51
  52 typedef struct {
  53         lzma_lzma_state state;
  54
  55         bool prev_1_is_literal;
  56         bool prev_2;
  57
  58         uint32_t pos_prev_2;
  59         uint32_t back_prev_2;
  60
  61         uint32_t price;
  62         uint32_t pos_prev;  // pos_next;
  63         uint32_t back_prev;
  64
  65         uint32_t backs[REPS];
  66
  67 } lzma_optimal;
  68
  69
  70 struct lzma_lzma1_encoder_s {
  71         /// Range encoder
  72         lzma_range_encoder rc;
  73
  74         /// Uncompressed size (doesn't include possible preset dictionary)
  75         uint64_t uncomp_size;
  76
  77         /// If non-zero, produce at most this much output.
  78         /// Some input may then be missing from the output.
  79         uint64_t out_limit;
  80
  81         /// If the above out_limit is non-zero, *uncomp_size_ptr is set to
  82         /// the amount of uncompressed data that we were able to fit
  83         /// in the output buffer.
  84         uint64_t *uncomp_size_ptr;
  85
  86         /// State
  87         lzma_lzma_state state;
  88
  89         /// The four most recent match distances
  90         uint32_t reps[REPS];
  91
  92         /// Array of match candidates
  93         lzma_match matches[MATCH_LEN_MAX + 1];
  94
  95         /// Number of match candidates in matches[]
  96         uint32_t matches_count;
  97
  98         /// Variable to hold the length of the longest match between calls
  99         /// to lzma_lzma_optimum_*().
 100         uint32_t longest_match_length;
 101
 102         /// True if using getoptimumfast
 103         bool fast_mode;
 104
 105         /// True if the encoder has been initialized by encoding the first
 106         /// byte as a literal.
 107         bool is_initialized;
 108
 109         /// True if the range encoder has been flushed, but not all bytes
 110         /// have been written to the output buffer yet.
 111         bool is_flushed;
 112
 113         /// True if end of payload marker will be written.
 114         bool use_eopm;
 115
 116         uint32_t pos_mask;         ///< (1 << pos_bits) - 1
 117         uint32_t literal_context_bits;
 118         uint32_t literal_mask;
 119
 120         // These are the same as in lzma_decoder.c. See comments there.
 121         probability literal[LITERAL_CODERS_MAX * LITERAL_CODER_SIZE];
 122         probability is_match[STATES][POS_STATES_MAX];
 123         probability is_rep[STATES];
 124         probability is_rep0[STATES];
 125         probability is_rep1[STATES];
 126         probability is_rep2[STATES];
 127         probability is_rep0_long[STATES][POS_STATES_MAX];
 128         probability dist_slot[DIST_STATES][DIST_SLOTS];
 129         probability dist_special[FULL_DISTANCES - DIST_MODEL_END];
 130         probability dist_align[ALIGN_SIZE];
 131
 132         // These are the same as in lzma_decoder.c except that the encoders
 133         // include also price tables.
 134         lzma_length_encoder match_len_encoder;
 135         lzma_length_encoder rep_len_encoder;
 136
 137         // Price tables
 138         uint32_t dist_slot_prices[DIST_STATES][DIST_SLOTS];
 139         uint32_t dist_prices[DIST_STATES][FULL_DISTANCES];
 140         uint32_t dist_table_size;
 141         uint32_t match_price_count;
 142
 143         uint32_t align_prices[ALIGN_SIZE];
 144         uint32_t align_price_count;
 145
 146         // Optimal
 147         uint32_t opts_end_index;
 148         uint32_t opts_current_index;
 149         lzma_optimal opts[OPTS];
 150 };
 151
 152
 153 extern void lzma_lzma_optimum_fast(
 154                 lzma_lzma1_encoder *restrict coder, lzma_mf *restrict mf,
 155                 uint32_t *restrict back_res, uint32_t *restrict len_res);
 156
 157 extern void lzma_lzma_optimum_normal(lzma_lzma1_encoder *restrict coder,
 158                 lzma_mf *restrict mf, uint32_t *restrict back_res,
 159                 uint32_t *restrict len_res, uint32_t position);
 160
 161 #endif