node-liblzma 1.0.4 → 1.1.6

package/deps/xz/src/liblzma/lzma/lzma_encoder_presets.c

@@ -1,63 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       lzma_encoder_presets.c
-/// \brief      Encoder presets
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-extern LZMA_API(lzma_bool)
-lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset)
-{
-	const uint32_t level = preset & LZMA_PRESET_LEVEL_MASK;
-	const uint32_t flags = preset & ~LZMA_PRESET_LEVEL_MASK;
-	const uint32_t supported_flags = LZMA_PRESET_EXTREME;
-
-	if (level > 9 || (flags & ~supported_flags))
-		return true;
-
-	options->preset_dict = NULL;
-	options->preset_dict_size = 0;
-
-	options->lc = LZMA_LC_DEFAULT;
-	options->lp = LZMA_LP_DEFAULT;
-	options->pb = LZMA_PB_DEFAULT;
-
-	static const uint8_t dict_pow2[]
-			= { 18, 20, 21, 22, 22, 23, 23, 24, 25, 26 };
-	options->dict_size = UINT32_C(1) << dict_pow2[level];
-
-	if (level <= 3) {
-		options->mode = LZMA_MODE_FAST;
-		options->mf = level == 0 ? LZMA_MF_HC3 : LZMA_MF_HC4;
-		options->nice_len = level <= 1 ? 128 : 273;
-		static const uint8_t depths[] = { 4, 8, 24, 48 };
-		options->depth = depths[level];
-	} else {
-		options->mode = LZMA_MODE_NORMAL;
-		options->mf = LZMA_MF_BT4;
-		options->nice_len = level == 4 ? 16 : level == 5 ? 32 : 64;
-		options->depth = 0;
-	}
-
-	if (flags & LZMA_PRESET_EXTREME) {
-		options->mode = LZMA_MODE_NORMAL;
-		options->mf = LZMA_MF_BT4;
-		if (level == 3 || level == 5) {
-			options->nice_len = 192;
-			options->depth = 0;
-		} else {
-			options->nice_len = 273;
-			options->depth = 512;
-		}
-	}
-
-	return false;
-}

package/deps/xz/src/liblzma/lzma/lzma_encoder_private.h

@@ -1,148 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       lzma_encoder_private.h
-/// \brief      Private definitions for LZMA encoder
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_LZMA_ENCODER_PRIVATE_H
-#define LZMA_LZMA_ENCODER_PRIVATE_H
-
-#include "lz_encoder.h"
-#include "range_encoder.h"
-#include "lzma_common.h"
-#include "lzma_encoder.h"
-
-
-// Macro to compare if the first two bytes in two buffers differ. This is
-// needed in lzma_lzma_optimum_*() to test if the match is at least
-// MATCH_LEN_MIN bytes. Unaligned access gives tiny gain so there's no
-// reason to not use it when it is supported.
-#ifdef TUKLIB_FAST_UNALIGNED_ACCESS
-#	define not_equal_16(a, b) \
-		(*(const uint16_t *)(a) != *(const uint16_t *)(b))
-#else
-#	define not_equal_16(a, b) \
-		((a)[0] != (b)[0] || (a)[1] != (b)[1])
-#endif
-
-
-// Optimal - Number of entries in the optimum array.
-#define OPTS (1 << 12)
-
-
-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 {
-	lzma_lzma_state state;
-
-	bool prev_1_is_literal;
-	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[REPS];
-
-} lzma_optimal;
-
-
-struct lzma_coder_s {
-	/// Range encoder
-	lzma_range_encoder rc;
-
-	/// State
-	lzma_lzma_state state;
-
-	/// The four most recent match distances
-	uint32_t reps[REPS];
-
-	/// Array of match candidates
-	lzma_match matches[MATCH_LEN_MAX + 1];
-
-	/// Number of match candidates in matches[]
-	uint32_t matches_count;
-
-	/// Variable to hold the length of the longest match between calls
-	/// to lzma_lzma_optimum_*().
-	uint32_t longest_match_length;
-
-	/// True if using getoptimumfast
-	bool fast_mode;
-
-	/// True if the encoder has been initialized by encoding the first
-	/// byte as a literal.
-	bool is_initialized;
-
-	/// True if the range encoder has been flushed, but not all bytes
-	/// have been written to the output buffer yet.
-	bool is_flushed;
-
-	uint32_t pos_mask;         ///< (1 << pos_bits) - 1
-	uint32_t literal_context_bits;
-	uint32_t literal_pos_mask;
-
-	// These are the same as in lzma_decoder.c. See comments there.
-	probability literal[LITERAL_CODERS_MAX][LITERAL_CODER_SIZE];
-	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 dist_slot[DIST_STATES][DIST_SLOTS];
-	probability dist_special[FULL_DISTANCES - DIST_MODEL_END];
-	probability dist_align[ALIGN_SIZE];
-
-	// These are the same as in lzma_decoder.c except that the encoders
-	// include also price tables.
-	lzma_length_encoder match_len_encoder;
-	lzma_length_encoder rep_len_encoder;
-
-	// Price tables
-	uint32_t dist_slot_prices[DIST_STATES][DIST_SLOTS];
-	uint32_t dist_prices[DIST_STATES][FULL_DISTANCES];
-	uint32_t dist_table_size;
-	uint32_t match_price_count;
-
-	uint32_t align_prices[ALIGN_SIZE];
-	uint32_t align_price_count;
-
-	// Optimal
-	uint32_t opts_end_index;
-	uint32_t opts_current_index;
-	lzma_optimal opts[OPTS];
-};
-
-
-extern void lzma_lzma_optimum_fast(
-		lzma_coder *restrict coder, lzma_mf *restrict mf,
-		uint32_t *restrict back_res, uint32_t *restrict len_res);
-
-extern void lzma_lzma_optimum_normal(lzma_coder *restrict coder,
-		lzma_mf *restrict mf, uint32_t *restrict back_res,
-		uint32_t *restrict len_res, uint32_t position);
-
-#endif

package/deps/xz/src/liblzma/rangecoder/Makefile.inc

@@ -1,21 +0,0 @@
-##
-## Author: Lasse Collin
-##
-## This file has been put into the public domain.
-## You can do whatever you want with this file.
-##
-
-EXTRA_DIST += rangecoder/price_tablegen.c
-
-liblzma_la_SOURCES += rangecoder/range_common.h
-
-if COND_ENCODER_LZMA1
-liblzma_la_SOURCES += \
-	rangecoder/range_encoder.h \
-	rangecoder/price.h \
-	rangecoder/price_table.c
-endif
-
-if COND_DECODER_LZMA1
-liblzma_la_SOURCES += rangecoder/range_decoder.h
-endif

package/deps/xz/src/liblzma/rangecoder/price.h

@@ -1,92 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       price.h
-/// \brief      Probability price calculation
-//
-//  Author:     Igor Pavlov
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_PRICE_H
-#define LZMA_PRICE_H
-
-
-#define RC_MOVE_REDUCING_BITS 4
-#define RC_BIT_PRICE_SHIFT_BITS 4
-#define RC_PRICE_TABLE_SIZE (RC_BIT_MODEL_TOTAL >> RC_MOVE_REDUCING_BITS)
-
-#define RC_INFINITY_PRICE (UINT32_C(1) << 30)
-
-
-/// Lookup table for the inline functions defined in this file.
-extern const uint8_t lzma_rc_prices[RC_PRICE_TABLE_SIZE];
-
-
-static inline uint32_t
-rc_bit_price(const probability prob, const uint32_t bit)
-{
-	return lzma_rc_prices[(prob ^ ((UINT32_C(0) - bit)
-			& (RC_BIT_MODEL_TOTAL - 1))) >> RC_MOVE_REDUCING_BITS];
-}
-
-
-static inline uint32_t
-rc_bit_0_price(const probability prob)
-{
-	return lzma_rc_prices[prob >> RC_MOVE_REDUCING_BITS];
-}
-
-
-static inline uint32_t
-rc_bit_1_price(const probability prob)
-{
-	return lzma_rc_prices[(prob ^ (RC_BIT_MODEL_TOTAL - 1))
-			>> RC_MOVE_REDUCING_BITS];
-}
-
-
-static inline uint32_t
-rc_bittree_price(const probability *const probs,
-		const uint32_t bit_levels, uint32_t symbol)
-{
-	uint32_t price = 0;
-	symbol += UINT32_C(1) << bit_levels;
-
-	do {
-		const uint32_t bit = symbol & 1;
-		symbol >>= 1;
-		price += rc_bit_price(probs[symbol], bit);
-	} while (symbol != 1);
-
-	return price;
-}
-
-
-static inline uint32_t
-rc_bittree_reverse_price(const probability *const probs,
-		uint32_t bit_levels, uint32_t symbol)
-{
-	uint32_t price = 0;
-	uint32_t model_index = 1;
-
-	do {
-		const uint32_t bit = symbol & 1;
-		symbol >>= 1;
-		price += rc_bit_price(probs[model_index], bit);
-		model_index = (model_index << 1) + bit;
-	} while (--bit_levels != 0);
-
-	return price;
-}
-
-
-static inline uint32_t
-rc_direct_price(const uint32_t bits)
-{
-	 return bits << RC_BIT_PRICE_SHIFT_BITS;
-}
-
-#endif

package/deps/xz/src/liblzma/rangecoder/price_table.c

@@ -1,22 +0,0 @@
-/* This file has been automatically generated by price_tablegen.c. */
-
-#include "range_encoder.h"
-
-const uint8_t lzma_rc_prices[RC_PRICE_TABLE_SIZE] = {
-	 128, 103,  91,  84,  78,  73,  69,  66,
-	  63,  61,  58,  56,  54,  52,  51,  49,
-	  48,  46,  45,  44,  43,  42,  41,  40,
-	  39,  38,  37,  36,  35,  34,  34,  33,
-	  32,  31,  31,  30,  29,  29,  28,  28,
-	  27,  26,  26,  25,  25,  24,  24,  23,
-	  23,  22,  22,  22,  21,  21,  20,  20,
-	  19,  19,  19,  18,  18,  17,  17,  17,
-	  16,  16,  16,  15,  15,  15,  14,  14,
-	  14,  13,  13,  13,  12,  12,  12,  11,
-	  11,  11,  11,  10,  10,  10,  10,   9,
-	   9,   9,   9,   8,   8,   8,   8,   7,
-	   7,   7,   7,   6,   6,   6,   6,   5,
-	   5,   5,   5,   5,   4,   4,   4,   4,
-	   3,   3,   3,   3,   3,   2,   2,   2,
-	   2,   2,   2,   1,   1,   1,   1,   1
-};

package/deps/xz/src/liblzma/rangecoder/price_tablegen.c

@@ -1,87 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       price_tablegen.c
-/// \brief      Probability price table generator
-///
-/// Compiling: gcc -std=c99 -o price_tablegen price_tablegen.c
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include <inttypes.h>
-#include <stdio.h>
-#include "range_common.h"
-#include "price.h"
-
-
-static uint32_t rc_prices[RC_PRICE_TABLE_SIZE];
-
-
-static void
-init_price_table(void)
-{
-	for (uint32_t i = (UINT32_C(1) << RC_MOVE_REDUCING_BITS) / 2;
-			i < RC_BIT_MODEL_TOTAL;
-			i += (UINT32_C(1) << RC_MOVE_REDUCING_BITS)) {
-		const uint32_t cycles_bits = RC_BIT_PRICE_SHIFT_BITS;
-		uint32_t w = i;
-		uint32_t bit_count = 0;
-
-		for (uint32_t j = 0; j < cycles_bits; ++j) {
-			w *= w;
-			bit_count <<= 1;
-
-			while (w >= (UINT32_C(1) << 16)) {
-				w >>= 1;
-				++bit_count;
-			}
-		}
-
-		rc_prices[i >> RC_MOVE_REDUCING_BITS]
-				= (RC_BIT_MODEL_TOTAL_BITS << cycles_bits)
-				- 15 - bit_count;
-	}
-
-	return;
-}
-
-
-static void
-print_price_table(void)
-{
-	printf("/* This file has been automatically generated by "
-			"price_tablegen.c. */\n\n"
-			"#include \"range_encoder.h\"\n\n"
-			"const uint8_t lzma_rc_prices["
-			"RC_PRICE_TABLE_SIZE] = {");
-
-	const size_t array_size = sizeof(lzma_rc_prices)
-			/ sizeof(lzma_rc_prices[0]);
-	for (size_t i = 0; i < array_size; ++i) {
-		if (i % 8 == 0)
-			printf("\n\t");
-
-		printf("%4" PRIu32, rc_prices[i]);
-
-		if (i != array_size - 1)
-			printf(",");
-	}
-
-	printf("\n};\n");
-
-	return;
-}
-
-
-int
-main(void)
-{
-	init_price_table();
-	print_price_table();
-	return 0;
-}

package/deps/xz/src/liblzma/rangecoder/range_common.h

@@ -1,73 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       range_common.h
-/// \brief      Common things for range encoder and decoder
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_RANGE_COMMON_H
-#define LZMA_RANGE_COMMON_H
-
-#ifdef HAVE_CONFIG_H
-#	include "common.h"
-#endif
-
-
-///////////////
-// Constants //
-///////////////
-
-#define RC_SHIFT_BITS 8
-#define RC_TOP_BITS 24
-#define RC_TOP_VALUE (UINT32_C(1) << RC_TOP_BITS)
-#define RC_BIT_MODEL_TOTAL_BITS 11
-#define RC_BIT_MODEL_TOTAL (UINT32_C(1) << RC_BIT_MODEL_TOTAL_BITS)
-#define RC_MOVE_BITS 5
-
-
-////////////
-// Macros //
-////////////
-
-// Resets the probability so that both 0 and 1 have probability of 50 %
-#define bit_reset(prob) \
-	prob = RC_BIT_MODEL_TOTAL >> 1
-
-// This does the same for a complete bit tree.
-// (A tree represented as an array.)
-#define bittree_reset(probs, bit_levels) \
-	for (uint32_t bt_i = 0; bt_i < (1 << (bit_levels)); ++bt_i) \
-		bit_reset((probs)[bt_i])
-
-
-//////////////////////
-// Type definitions //
-//////////////////////
-
-/// \brief      Type of probabilities used with range coder
-///
-/// This needs to be at least 12-bit integer, so uint16_t is a logical choice.
-/// However, on some architecture and compiler combinations, a bigger type
-/// may give better speed, because the probability variables are accessed
-/// a lot. On the other hand, bigger probability type increases cache
-/// footprint, since there are 2 to 14 thousand probability variables in
-/// LZMA (assuming the limit of lc + lp <= 4; with lc + lp <= 12 there
-/// would be about 1.5 million variables).
-///
-/// With malicious files, the initialization speed of the LZMA decoder can
-/// become important. In that case, smaller probability variables mean that
-/// there is less bytes to write to RAM, which makes initialization faster.
-/// With big probability type, the initialization can become so slow that it
-/// can be a problem e.g. for email servers doing virus scanning.
-///
-/// I will be sticking to uint16_t unless some specific architectures
-/// are *much* faster (20-50 %) with uint32_t.
-typedef uint16_t probability;
-
-#endif

package/deps/xz/src/liblzma/rangecoder/range_decoder.h

@@ -1,185 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       range_decoder.h
-/// \brief      Range Decoder
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef LZMA_RANGE_DECODER_H
-#define LZMA_RANGE_DECODER_H
-
-#include "range_common.h"
-
-
-typedef struct {
-	uint32_t range;
-	uint32_t code;
-	uint32_t init_bytes_left;
-} lzma_range_decoder;
-
-
-/// Reads the first five bytes to initialize the range decoder.
-static inline lzma_ret
-rc_read_init(lzma_range_decoder *rc, const uint8_t *restrict in,
-		size_t *restrict in_pos, size_t in_size)
-{
-	while (rc->init_bytes_left > 0) {
-		if (*in_pos == in_size)
-			return LZMA_OK;
-
-		// The first byte is always 0x00. It could have been omitted
-		// in LZMA2 but it wasn't, so one byte is wasted in every
-		// LZMA2 chunk.
-		if (rc->init_bytes_left == 5 && in[*in_pos] != 0x00)
-			return LZMA_DATA_ERROR;
-
-		rc->code = (rc->code << 8) | in[*in_pos];
-		++*in_pos;
-		--rc->init_bytes_left;
-	}
-
-	return LZMA_STREAM_END;
-}
-
-
-/// Makes local copies of range decoder and *in_pos variables. Doing this
-/// improves speed significantly. The range decoder macros expect also
-/// variables `in' and `in_size' to be defined.
-#define rc_to_local(range_decoder, in_pos) \
-	lzma_range_decoder rc = range_decoder; \
-	size_t rc_in_pos = (in_pos); \
-	uint32_t rc_bound
-
-
-/// Stores the local copes back to the range decoder structure.
-#define rc_from_local(range_decoder, in_pos) \
-do { \
-	range_decoder = rc; \
-	in_pos = rc_in_pos; \
-} while (0)
-
-
-/// Resets the range decoder structure.
-#define rc_reset(range_decoder) \
-do { \
-	(range_decoder).range = UINT32_MAX; \
-	(range_decoder).code = 0; \
-	(range_decoder).init_bytes_left = 5; \
-} while (0)
-
-
-/// When decoding has been properly finished, rc.code is always zero unless
-/// the input stream is corrupt. So checking this can catch some corrupt
-/// files especially if they don't have any other integrity check.
-#define rc_is_finished(range_decoder) \
-	((range_decoder).code == 0)
-
-
-/// Read the next input byte if needed. If more input is needed but there is
-/// no more input available, "goto out" is used to jump out of the main
-/// decoder loop.
-#define rc_normalize(seq) \
-do { \
-	if (rc.range < RC_TOP_VALUE) { \
-		if (unlikely(rc_in_pos == in_size)) { \
-			coder->sequence = seq; \
-			goto out; \
-		} \
-		rc.range <<= RC_SHIFT_BITS; \
-		rc.code = (rc.code << RC_SHIFT_BITS) | in[rc_in_pos++]; \
-	} \
-} while (0)
-
-
-/// Start decoding a bit. This must be used together with rc_update_0()
-/// and rc_update_1():
-///
-///     rc_if_0(prob, seq) {
-///         rc_update_0(prob);
-///         // Do something
-///     } else {
-///         rc_update_1(prob);
-///         // Do something else
-///     }
-///
-#define rc_if_0(prob, seq) \
-	rc_normalize(seq); \
-	rc_bound = (rc.range >> RC_BIT_MODEL_TOTAL_BITS) * (prob); \
-	if (rc.code < rc_bound)
-
-
-/// Update the range decoder state and the used probability variable to
-/// match a decoded bit of 0.
-#define rc_update_0(prob) \
-do { \
-	rc.range = rc_bound; \
-	prob += (RC_BIT_MODEL_TOTAL - (prob)) >> RC_MOVE_BITS; \
-} while (0)
-
-
-/// Update the range decoder state and the used probability variable to
-/// match a decoded bit of 1.
-#define rc_update_1(prob) \
-do { \
-	rc.range -= rc_bound; \
-	rc.code -= rc_bound; \
-	prob -= (prob) >> RC_MOVE_BITS; \
-} while (0)
-
-
-/// Decodes one bit and runs action0 or action1 depending on the decoded bit.
-/// This macro is used as the last step in bittree reverse decoders since
-/// those don't use "symbol" for anything else than indexing the probability
-/// arrays.
-#define rc_bit_last(prob, action0, action1, seq) \
-do { \
-	rc_if_0(prob, seq) { \
-		rc_update_0(prob); \
-		action0; \
-	} else { \
-		rc_update_1(prob); \
-		action1; \
-	} \
-} while (0)
-
-
-/// Decodes one bit, updates "symbol", and runs action0 or action1 depending
-/// on the decoded bit.
-#define rc_bit(prob, action0, action1, seq) \
-	rc_bit_last(prob, \
-		symbol <<= 1; action0, \
-		symbol = (symbol << 1) + 1; action1, \
-		seq);
-
-
-/// Like rc_bit() but add "case seq:" as a prefix. This makes the unrolled
-/// loops more readable because the code isn't littered with "case"
-/// statements. On the other hand this also makes it less readable, since
-/// spotting the places where the decoder loop may be restarted is less
-/// obvious.
-#define rc_bit_case(prob, action0, action1, seq) \
-	case seq: rc_bit(prob, action0, action1, seq)
-
-
-/// Decode a bit without using a probability.
-#define rc_direct(dest, seq) \
-do { \
-	rc_normalize(seq); \
-	rc.range >>= 1; \
-	rc.code -= rc.range; \
-	rc_bound = UINT32_C(0) - (rc.code >> 31); \
-	rc.code += rc.range & rc_bound; \
-	dest = (dest << 1) + (rc_bound + 1); \
-} while (0)
-
-
-// NOTE: No macros are provided for bittree decoding. It seems to be simpler
-// to just write them open in the code.
-
-#endif