src/liblzma/lzma/lzma_encoder_private.h

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