aboutsummaryrefslogtreecommitdiff
path: root/src/liblzma/lzma/lzma_encoder_private.h
diff options
context:
space:
mode:
authorLasse Collin <lasse.collin@tukaani.org>2007-12-09 00:42:33 +0200
committerLasse Collin <lasse.collin@tukaani.org>2007-12-09 00:42:33 +0200
commit5d018dc03549c1ee4958364712fb0c94e1bf2741 (patch)
tree1b211911fb33fddb3f04b77f99e81df23623ffc4 /src/liblzma/lzma/lzma_encoder_private.h
downloadxz-5d018dc03549c1ee4958364712fb0c94e1bf2741.tar.xz
Imported to git.
Diffstat (limited to 'src/liblzma/lzma/lzma_encoder_private.h')
-rw-r--r--src/liblzma/lzma/lzma_encoder_private.h225
1 files changed, 225 insertions, 0 deletions
diff --git a/src/liblzma/lzma/lzma_encoder_private.h b/src/liblzma/lzma/lzma_encoder_private.h
new file mode 100644
index 00000000..7fb1566a
--- /dev/null
+++ b/src/liblzma/lzma/lzma_encoder_private.h
@@ -0,0 +1,225 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file lzma_encoder_private.h
+/// \brief Private definitions for LZMA encoder
+//
+// Copyright (C) 1999-2006 Igor Pavlov
+// Copyright (C) 2007 Lasse Collin
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef LZMA_LZMA_ENCODER_PRIVATE_H
+#define LZMA_LZMA_ENCODER_PRIVATE_H
+
+#include "lzma_encoder.h"
+#include "lzma_common.h"
+#include "lz_encoder.h"
+
+// We need space for about two encoding loops, because there is no check
+// for available buffer space before end of payload marker gets written.
+// 2*26 bytes should be enough for this... but Lasse isn't very sure about
+// the exact value. 64 bytes certainly is enough. :-)
+#define RC_BUFFER_SIZE 64
+#include "range_encoder.h"
+
+
+#define move_pos(num) \
+do { \
+ assert((int32_t)(num) >= 0); \
+ if ((num) != 0) { \
+ coder->additional_offset += num; \
+ coder->lz.skip(&coder->lz, num); \
+ } \
+} while (0)
+
+
+#define get_pos_slot(pos) \
+ ((pos) < (1 << 11) \
+ ? lzma_fastpos[pos] \
+ : ((pos) < (1 << 21) \
+ ? lzma_fastpos[(pos) >> 10] + 20 \
+ : lzma_fastpos[(pos) >> 20] + 40))
+
+
+#define get_pos_slot_2(pos) \
+ ((pos) < (1 << 17) \
+ ? lzma_fastpos[(pos) >> 6] + 12 \
+ : ((pos) < (1 << 27) \
+ ? lzma_fastpos[(pos) >> 16] + 32 \
+ : lzma_fastpos[(pos) >> 26] + 52))
+
+
+/// This isn't modified once its contents have been
+/// initialized by lzma_fastpos_init().
+extern uint8_t lzma_fastpos[1 << 11];
+
+
+typedef struct {
+ probability choice;
+ probability choice2;
+ probability low[POS_STATES_MAX][LEN_LOW_SYMBOLS];
+ probability mid[POS_STATES_MAX][LEN_MID_SYMBOLS];
+ probability high[LEN_HIGH_SYMBOLS];
+
+ uint32_t prices[POS_STATES_MAX][LEN_SYMBOLS];
+ uint32_t table_size;
+ uint32_t counters[POS_STATES_MAX];
+
+} lzma_length_encoder;
+
+
+typedef struct {
+ uint32_t state;
+
+ bool prev_1_is_char;
+ bool prev_2;
+
+ uint32_t pos_prev_2;
+ uint32_t back_prev_2;
+
+ uint32_t price;
+ uint32_t pos_prev; // pos_next;
+ uint32_t back_prev;
+
+ uint32_t backs[4];
+
+} lzma_optimal;
+
+
+struct lzma_coder_s {
+ // Next coder in the chain
+ lzma_next_coder next;
+
+ // In window and match finder
+ lzma_lz_encoder lz;
+
+ // Range encoder
+ lzma_range_encoder rc;
+
+ // State
+ uint32_t state;
+ uint8_t previous_byte;
+ uint32_t rep_distances[REP_DISTANCES];
+
+ // Misc
+ uint32_t match_distances[MATCH_MAX_LEN * 2 + 2 + 1];
+ uint32_t num_distance_pairs;
+ uint32_t additional_offset;
+ uint32_t now_pos; // Lowest 32 bits are enough here.
+ bool best_compression; ///< True when LZMA_MODE_BEST is used
+ bool is_initialized;
+
+ // Literal encoder
+ lzma_literal_coder *literal_coder;
+
+ // Bit encoders
+ probability is_match[STATES][POS_STATES_MAX];
+ probability is_rep[STATES];
+ probability is_rep0[STATES];
+ probability is_rep1[STATES];
+ probability is_rep2[STATES];
+ probability is_rep0_long[STATES][POS_STATES_MAX];
+ probability pos_encoders[FULL_DISTANCES - END_POS_MODEL_INDEX];
+
+ // Bit Tree Encoders
+ probability pos_slot_encoder[LEN_TO_POS_STATES][1 << POS_SLOT_BITS];
+ probability pos_align_encoder[1 << ALIGN_BITS];
+
+ // Length encoders
+ lzma_length_encoder len_encoder;
+ lzma_length_encoder rep_match_len_encoder;
+
+ // Optimal
+ lzma_optimal optimum[OPTS];
+ uint32_t optimum_end_index;
+ uint32_t optimum_current_index;
+ uint32_t longest_match_length;
+ bool longest_match_was_found;
+
+ // Prices
+ uint32_t pos_slot_prices[LEN_TO_POS_STATES][DIST_TABLE_SIZE_MAX];
+ uint32_t distances_prices[LEN_TO_POS_STATES][FULL_DISTANCES];
+ uint32_t align_prices[ALIGN_TABLE_SIZE];
+ uint32_t align_price_count;
+ uint32_t dist_table_size;
+ uint32_t match_price_count;
+
+ // LZMA specific settings
+ uint32_t dictionary_size; ///< Size in bytes
+ uint32_t fast_bytes;
+ uint32_t pos_state_bits;
+ uint32_t pos_mask; ///< (1 << pos_state_bits) - 1
+};
+
+
+extern void lzma_length_encoder_update_table(lzma_length_encoder *lencoder,
+ const uint32_t pos_state);
+
+extern bool lzma_lzma_encode(lzma_coder *coder, uint8_t *restrict out,
+ size_t *restrict out_pos, size_t out_size);
+
+extern void lzma_get_optimum(lzma_coder *restrict coder,
+ uint32_t *restrict back_res, uint32_t *restrict len_res);
+
+extern void lzma_get_optimum_fast(lzma_coder *restrict coder,
+ uint32_t *restrict back_res, uint32_t *restrict len_res);
+
+
+// NOTE: Don't add 'restrict'.
+static inline void
+lzma_read_match_distances(lzma_coder *coder,
+ uint32_t *len_res, uint32_t *num_distance_pairs)
+{
+ *len_res = 0;
+
+ coder->lz.get_matches(&coder->lz, coder->match_distances);
+
+ *num_distance_pairs = coder->match_distances[0];
+
+ if (*num_distance_pairs > 0) {
+ *len_res = coder->match_distances[*num_distance_pairs - 1];
+ assert(*len_res <= MATCH_MAX_LEN);
+
+ if (*len_res == coder->fast_bytes) {
+ uint32_t offset = *len_res - 1;
+ const uint32_t distance = coder->match_distances[
+ *num_distance_pairs] + 1;
+ uint32_t limit = MATCH_MAX_LEN - *len_res;
+
+ assert(offset + limit < coder->lz.keep_size_after);
+
+ // If we are close to end of the stream, we may need
+ // to limit the length of the match.
+ if (coder->lz.stream_end_was_reached
+ && coder->lz.write_pos
+ < coder->lz.read_pos + offset + limit)
+ limit = coder->lz.write_pos
+ - (coder->lz.read_pos + offset);
+
+ offset += coder->lz.read_pos;
+ uint32_t i = 0;
+ while (i < limit && coder->lz.buffer[offset + i]
+ == coder->lz.buffer[
+ offset + i - distance])
+ ++i;
+
+ *len_res += i;
+ }
+ }
+
+ ++coder->additional_offset;
+
+ return;
+}
+
+#endif