node-liblzma 1.0.4 → 1.1.6

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

@@ -1,403 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       lzma2_encoder.c
-/// \brief      LZMA2 encoder
-///
-//  Authors:    Igor Pavlov
-//              Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "lz_encoder.h"
-#include "lzma_encoder.h"
-#include "fastpos.h"
-#include "lzma2_encoder.h"
-
-
-struct lzma_coder_s {
-	enum {
-		SEQ_INIT,
-		SEQ_LZMA_ENCODE,
-		SEQ_LZMA_COPY,
-		SEQ_UNCOMPRESSED_HEADER,
-		SEQ_UNCOMPRESSED_COPY,
-	} sequence;
-
-	/// LZMA encoder
-	lzma_coder *lzma;
-
-	/// LZMA options currently in use.
-	lzma_options_lzma opt_cur;
-
-	bool need_properties;
-	bool need_state_reset;
-	bool need_dictionary_reset;
-
-	/// Uncompressed size of a chunk
-	size_t uncompressed_size;
-
-	/// Compressed size of a chunk (excluding headers); this is also used
-	/// to indicate the end of buf[] in SEQ_LZMA_COPY.
-	size_t compressed_size;
-
-	/// Read position in buf[]
-	size_t buf_pos;
-
-	/// Buffer to hold the chunk header and LZMA compressed data
-	uint8_t buf[LZMA2_HEADER_MAX + LZMA2_CHUNK_MAX];
-};
-
-
-static void
-lzma2_header_lzma(lzma_coder *coder)
-{
-	assert(coder->uncompressed_size > 0);
-	assert(coder->uncompressed_size <= LZMA2_UNCOMPRESSED_MAX);
-	assert(coder->compressed_size > 0);
-	assert(coder->compressed_size <= LZMA2_CHUNK_MAX);
-
-	size_t pos;
-
-	if (coder->need_properties) {
-		pos = 0;
-
-		if (coder->need_dictionary_reset)
-			coder->buf[pos] = 0x80 + (3 << 5);
-		else
-			coder->buf[pos] = 0x80 + (2 << 5);
-	} else {
-		pos = 1;
-
-		if (coder->need_state_reset)
-			coder->buf[pos] = 0x80 + (1 << 5);
-		else
-			coder->buf[pos] = 0x80;
-	}
-
-	// Set the start position for copying.
-	coder->buf_pos = pos;
-
-	// Uncompressed size
-	size_t size = coder->uncompressed_size - 1;
-	coder->buf[pos++] += size >> 16;
-	coder->buf[pos++] = (size >> 8) & 0xFF;
-	coder->buf[pos++] = size & 0xFF;
-
-	// Compressed size
-	size = coder->compressed_size - 1;
-	coder->buf[pos++] = size >> 8;
-	coder->buf[pos++] = size & 0xFF;
-
-	// Properties, if needed
-	if (coder->need_properties)
-		lzma_lzma_lclppb_encode(&coder->opt_cur, coder->buf + pos);
-
-	coder->need_properties = false;
-	coder->need_state_reset = false;
-	coder->need_dictionary_reset = false;
-
-	// The copying code uses coder->compressed_size to indicate the end
-	// of coder->buf[], so we need add the maximum size of the header here.
-	coder->compressed_size += LZMA2_HEADER_MAX;
-
-	return;
-}
-
-
-static void
-lzma2_header_uncompressed(lzma_coder *coder)
-{
-	assert(coder->uncompressed_size > 0);
-	assert(coder->uncompressed_size <= LZMA2_CHUNK_MAX);
-
-	// If this is the first chunk, we need to include dictionary
-	// reset indicator.
-	if (coder->need_dictionary_reset)
-		coder->buf[0] = 1;
-	else
-		coder->buf[0] = 2;
-
-	coder->need_dictionary_reset = false;
-
-	// "Compressed" size
-	coder->buf[1] = (coder->uncompressed_size - 1) >> 8;
-	coder->buf[2] = (coder->uncompressed_size - 1) & 0xFF;
-
-	// Set the start position for copying.
-	coder->buf_pos = 0;
-	return;
-}
-
-
-static lzma_ret
-lzma2_encode(lzma_coder *restrict coder, lzma_mf *restrict mf,
-		uint8_t *restrict out, size_t *restrict out_pos,
-		size_t out_size)
-{
-	while (*out_pos < out_size)
-	switch (coder->sequence) {
-	case SEQ_INIT:
-		// If there's no input left and we are flushing or finishing,
-		// don't start a new chunk.
-		if (mf_unencoded(mf) == 0) {
-			// Write end of payload marker if finishing.
-			if (mf->action == LZMA_FINISH)
-				out[(*out_pos)++] = 0;
-
-			return mf->action == LZMA_RUN
-					? LZMA_OK : LZMA_STREAM_END;
-		}
-
-		if (coder->need_state_reset)
-			return_if_error(lzma_lzma_encoder_reset(
-					coder->lzma, &coder->opt_cur));
-
-		coder->uncompressed_size = 0;
-		coder->compressed_size = 0;
-		coder->sequence = SEQ_LZMA_ENCODE;
-
-	// Fall through
-
-	case SEQ_LZMA_ENCODE: {
-		// Calculate how much more uncompressed data this chunk
-		// could accept.
-		const uint32_t left = LZMA2_UNCOMPRESSED_MAX
-				- coder->uncompressed_size;
-		uint32_t limit;
-
-		if (left < mf->match_len_max) {
-			// Must flush immediately since the next LZMA symbol
-			// could make the uncompressed size of the chunk too
-			// big.
-			limit = 0;
-		} else {
-			// Calculate maximum read_limit that is OK from point
-			// of view of LZMA2 chunk size.
-			limit = mf->read_pos - mf->read_ahead
-					+ left - mf->match_len_max;
-		}
-
-		// Save the start position so that we can update
-		// coder->uncompressed_size.
-		const uint32_t read_start = mf->read_pos - mf->read_ahead;
-
-		// Call the LZMA encoder until the chunk is finished.
-		const lzma_ret ret = lzma_lzma_encode(coder->lzma, mf,
-				coder->buf + LZMA2_HEADER_MAX,
-				&coder->compressed_size,
-				LZMA2_CHUNK_MAX, limit);
-
-		coder->uncompressed_size += mf->read_pos - mf->read_ahead
-				- read_start;
-
-		assert(coder->compressed_size <= LZMA2_CHUNK_MAX);
-		assert(coder->uncompressed_size <= LZMA2_UNCOMPRESSED_MAX);
-
-		if (ret != LZMA_STREAM_END)
-			return LZMA_OK;
-
-		// See if the chunk compressed. If it didn't, we encode it
-		// as uncompressed chunk. This saves a few bytes of space
-		// and makes decoding faster.
-		if (coder->compressed_size >= coder->uncompressed_size) {
-			coder->uncompressed_size += mf->read_ahead;
-			assert(coder->uncompressed_size
-					<= LZMA2_UNCOMPRESSED_MAX);
-			mf->read_ahead = 0;
-			lzma2_header_uncompressed(coder);
-			coder->need_state_reset = true;
-			coder->sequence = SEQ_UNCOMPRESSED_HEADER;
-			break;
-		}
-
-		// The chunk did compress at least by one byte, so we store
-		// the chunk as LZMA.
-		lzma2_header_lzma(coder);
-
-		coder->sequence = SEQ_LZMA_COPY;
-	}
-
-	// Fall through
-
-	case SEQ_LZMA_COPY:
-		// Copy the compressed chunk along its headers to the
-		// output buffer.
-		lzma_bufcpy(coder->buf, &coder->buf_pos,
-				coder->compressed_size,
-				out, out_pos, out_size);
-		if (coder->buf_pos != coder->compressed_size)
-			return LZMA_OK;
-
-		coder->sequence = SEQ_INIT;
-		break;
-
-	case SEQ_UNCOMPRESSED_HEADER:
-		// Copy the three-byte header to indicate uncompressed chunk.
-		lzma_bufcpy(coder->buf, &coder->buf_pos,
-				LZMA2_HEADER_UNCOMPRESSED,
-				out, out_pos, out_size);
-		if (coder->buf_pos != LZMA2_HEADER_UNCOMPRESSED)
-			return LZMA_OK;
-
-		coder->sequence = SEQ_UNCOMPRESSED_COPY;
-
-	// Fall through
-
-	case SEQ_UNCOMPRESSED_COPY:
-		// Copy the uncompressed data as is from the dictionary
-		// to the output buffer.
-		mf_read(mf, out, out_pos, out_size, &coder->uncompressed_size);
-		if (coder->uncompressed_size != 0)
-			return LZMA_OK;
-
-		coder->sequence = SEQ_INIT;
-		break;
-	}
-
-	return LZMA_OK;
-}
-
-
-static void
-lzma2_encoder_end(lzma_coder *coder, const lzma_allocator *allocator)
-{
-	lzma_free(coder->lzma, allocator);
-	lzma_free(coder, allocator);
-	return;
-}
-
-
-static lzma_ret
-lzma2_encoder_options_update(lzma_coder *coder, const lzma_filter *filter)
-{
-	// New options can be set only when there is no incomplete chunk.
-	// This is the case at the beginning of the raw stream and right
-	// after LZMA_SYNC_FLUSH.
-	if (filter->options == NULL || coder->sequence != SEQ_INIT)
-		return LZMA_PROG_ERROR;
-
-	// Look if there are new options. At least for now,
-	// only lc/lp/pb can be changed.
-	const lzma_options_lzma *opt = filter->options;
-	if (coder->opt_cur.lc != opt->lc || coder->opt_cur.lp != opt->lp
-			|| coder->opt_cur.pb != opt->pb) {
-		// Validate the options.
-		if (opt->lc > LZMA_LCLP_MAX || opt->lp > LZMA_LCLP_MAX
-				|| opt->lc + opt->lp > LZMA_LCLP_MAX
-				|| opt->pb > LZMA_PB_MAX)
-			return LZMA_OPTIONS_ERROR;
-
-		// The new options will be used when the encoder starts
-		// a new LZMA2 chunk.
-		coder->opt_cur.lc = opt->lc;
-		coder->opt_cur.lp = opt->lp;
-		coder->opt_cur.pb = opt->pb;
-		coder->need_properties = true;
-		coder->need_state_reset = true;
-	}
-
-	return LZMA_OK;
-}
-
-
-static lzma_ret
-lzma2_encoder_init(lzma_lz_encoder *lz, const lzma_allocator *allocator,
-		const void *options, lzma_lz_options *lz_options)
-{
-	if (options == NULL)
-		return LZMA_PROG_ERROR;
-
-	if (lz->coder == NULL) {
-		lz->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-		if (lz->coder == NULL)
-			return LZMA_MEM_ERROR;
-
-		lz->code = &lzma2_encode;
-		lz->end = &lzma2_encoder_end;
-		lz->options_update = &lzma2_encoder_options_update;
-
-		lz->coder->lzma = NULL;
-	}
-
-	lz->coder->opt_cur = *(const lzma_options_lzma *)(options);
-
-	lz->coder->sequence = SEQ_INIT;
-	lz->coder->need_properties = true;
-	lz->coder->need_state_reset = false;
-	lz->coder->need_dictionary_reset
-			= lz->coder->opt_cur.preset_dict == NULL
-			|| lz->coder->opt_cur.preset_dict_size == 0;
-
-	// Initialize LZMA encoder
-	return_if_error(lzma_lzma_encoder_create(&lz->coder->lzma, allocator,
-			&lz->coder->opt_cur, lz_options));
-
-	// Make sure that we will always have enough history available in
-	// case we need to use uncompressed chunks. They are used when the
-	// compressed size of a chunk is not smaller than the uncompressed
-	// size, so we need to have at least LZMA2_COMPRESSED_MAX bytes
-	// history available.
-	if (lz_options->before_size + lz_options->dict_size < LZMA2_CHUNK_MAX)
-		lz_options->before_size
-				= LZMA2_CHUNK_MAX - lz_options->dict_size;
-
-	return LZMA_OK;
-}
-
-
-extern lzma_ret
-lzma_lzma2_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters)
-{
-	return lzma_lz_encoder_init(
-			next, allocator, filters, &lzma2_encoder_init);
-}
-
-
-extern uint64_t
-lzma_lzma2_encoder_memusage(const void *options)
-{
-	const uint64_t lzma_mem = lzma_lzma_encoder_memusage(options);
-	if (lzma_mem == UINT64_MAX)
-		return UINT64_MAX;
-
-	return sizeof(lzma_coder) + lzma_mem;
-}
-
-
-extern lzma_ret
-lzma_lzma2_props_encode(const void *options, uint8_t *out)
-{
-	const lzma_options_lzma *const opt = options;
-	uint32_t d = my_max(opt->dict_size, LZMA_DICT_SIZE_MIN);
-
-	// Round up to the next 2^n - 1 or 2^n + 2^(n - 1) - 1 depending
-	// on which one is the next:
-	--d;
-	d |= d >> 2;
-	d |= d >> 3;
-	d |= d >> 4;
-	d |= d >> 8;
-	d |= d >> 16;
-
-	// Get the highest two bits using the proper encoding:
-	if (d == UINT32_MAX)
-		out[0] = 40;
-	else
-		out[0] = get_dist_slot(d + 1) - 24;
-
-	return LZMA_OK;
-}
-
-
-extern uint64_t
-lzma_lzma2_block_size(const void *options)
-{
-	const lzma_options_lzma *const opt = options;
-
-	// Use at least 1 MiB to keep compression ratio better.
-	return my_max((uint64_t)(opt->dict_size) * 3, UINT64_C(1) << 20);
-}

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

@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       lzma2_encoder.h
-/// \brief      LZMA2 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_LZMA2_ENCODER_H
-#define LZMA_LZMA2_ENCODER_H
-
-#include "common.h"
-
-
-/// Maximum number of bytes of actual data per chunk (no headers)
-#define LZMA2_CHUNK_MAX (UINT32_C(1) << 16)
-
-/// Maximum uncompressed size of LZMA chunk (no headers)
-#define LZMA2_UNCOMPRESSED_MAX (UINT32_C(1) << 21)
-
-/// Maximum size of LZMA2 headers
-#define LZMA2_HEADER_MAX 6
-
-/// Size of a header for uncompressed chunk
-#define LZMA2_HEADER_UNCOMPRESSED 3
-
-
-extern lzma_ret lzma_lzma2_encoder_init(
-		lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_filter_info *filters);
-
-extern uint64_t lzma_lzma2_encoder_memusage(const void *options);
-
-extern lzma_ret lzma_lzma2_props_encode(const void *options, uint8_t *out);
-
-extern uint64_t lzma_lzma2_block_size(const void *options);
-
-#endif

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

@@ -1,224 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       lzma_common.h
-/// \brief      Private definitions common to LZMA 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_LZMA_COMMON_H
-#define LZMA_LZMA_COMMON_H
-
-#include "common.h"
-#include "range_common.h"
-
-
-///////////////////
-// Miscellaneous //
-///////////////////
-
-/// Maximum number of position states. A position state is the lowest pos bits
-/// number of bits of the current uncompressed offset. In some places there
-/// are different sets of probabilities for different pos states.
-#define POS_STATES_MAX (1 << LZMA_PB_MAX)
-
-
-/// Validates lc, lp, and pb.
-static inline bool
-is_lclppb_valid(const lzma_options_lzma *options)
-{
-	return options->lc <= LZMA_LCLP_MAX && options->lp <= LZMA_LCLP_MAX
-			&& options->lc + options->lp <= LZMA_LCLP_MAX
-			&& options->pb <= LZMA_PB_MAX;
-}
-
-
-///////////
-// State //
-///////////
-
-/// This enum is used to track which events have occurred most recently and
-/// in which order. This information is used to predict the next event.
-///
-/// Events:
-///  - Literal: One 8-bit byte
-///  - Match: Repeat a chunk of data at some distance
-///  - Long repeat: Multi-byte match at a recently seen distance
-///  - Short repeat: One-byte repeat at a recently seen distance
-///
-/// The event names are in from STATE_oldest_older_previous. REP means
-/// either short or long repeated match, and NONLIT means any non-literal.
-typedef enum {
-	STATE_LIT_LIT,
-	STATE_MATCH_LIT_LIT,
-	STATE_REP_LIT_LIT,
-	STATE_SHORTREP_LIT_LIT,
-	STATE_MATCH_LIT,
-	STATE_REP_LIT,
-	STATE_SHORTREP_LIT,
-	STATE_LIT_MATCH,
-	STATE_LIT_LONGREP,
-	STATE_LIT_SHORTREP,
-	STATE_NONLIT_MATCH,
-	STATE_NONLIT_REP,
-} lzma_lzma_state;
-
-
-/// Total number of states
-#define STATES 12
-
-/// The lowest 7 states indicate that the previous state was a literal.
-#define LIT_STATES 7
-
-
-/// Indicate that the latest state was a literal.
-#define update_literal(state) \
-	state = ((state) <= STATE_SHORTREP_LIT_LIT \
-			? STATE_LIT_LIT \
-			: ((state) <= STATE_LIT_SHORTREP \
-				? (state) - 3 \
-				: (state) - 6))
-
-/// Indicate that the latest state was a match.
-#define update_match(state) \
-	state = ((state) < LIT_STATES ? STATE_LIT_MATCH : STATE_NONLIT_MATCH)
-
-/// Indicate that the latest state was a long repeated match.
-#define update_long_rep(state) \
-	state = ((state) < LIT_STATES ? STATE_LIT_LONGREP : STATE_NONLIT_REP)
-
-/// Indicate that the latest state was a short match.
-#define update_short_rep(state) \
-	state = ((state) < LIT_STATES ? STATE_LIT_SHORTREP : STATE_NONLIT_REP)
-
-/// Test if the previous state was a literal.
-#define is_literal_state(state) \
-	((state) < LIT_STATES)
-
-
-/////////////
-// Literal //
-/////////////
-
-/// Each literal coder is divided in three sections:
-///   - 0x001-0x0FF: Without match byte
-///   - 0x101-0x1FF: With match byte; match bit is 0
-///   - 0x201-0x2FF: With match byte; match bit is 1
-///
-/// Match byte is used when the previous LZMA symbol was something else than
-/// a literal (that is, it was some kind of match).
-#define LITERAL_CODER_SIZE 0x300
-
-/// Maximum number of literal coders
-#define LITERAL_CODERS_MAX (1 << LZMA_LCLP_MAX)
-
-/// Locate the literal coder for the next literal byte. The choice depends on
-///   - the lowest literal_pos_bits bits of the position of the current
-///     byte; and
-///   - the highest literal_context_bits bits of the previous byte.
-#define literal_subcoder(probs, lc, lp_mask, pos, prev_byte) \
-	((probs)[(((pos) & lp_mask) << lc) + ((prev_byte) >> (8 - lc))])
-
-
-static inline void
-literal_init(probability (*probs)[LITERAL_CODER_SIZE],
-		uint32_t lc, uint32_t lp)
-{
-	assert(lc + lp <= LZMA_LCLP_MAX);
-
-	const uint32_t coders = 1U << (lc + lp);
-
-	for (uint32_t i = 0; i < coders; ++i)
-		for (uint32_t j = 0; j < LITERAL_CODER_SIZE; ++j)
-			bit_reset(probs[i][j]);
-
-	return;
-}
-
-
-//////////////////
-// Match length //
-//////////////////
-
-// Minimum length of a match is two bytes.
-#define MATCH_LEN_MIN 2
-
-// Match length is encoded with 4, 5, or 10 bits.
-//
-// Length   Bits
-//  2-9      4 = Choice=0 + 3 bits
-// 10-17     5 = Choice=1 + Choice2=0 + 3 bits
-// 18-273   10 = Choice=1 + Choice2=1 + 8 bits
-#define LEN_LOW_BITS 3
-#define LEN_LOW_SYMBOLS (1 << LEN_LOW_BITS)
-#define LEN_MID_BITS 3
-#define LEN_MID_SYMBOLS (1 << LEN_MID_BITS)
-#define LEN_HIGH_BITS 8
-#define LEN_HIGH_SYMBOLS (1 << LEN_HIGH_BITS)
-#define LEN_SYMBOLS (LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS + LEN_HIGH_SYMBOLS)
-
-// Maximum length of a match is 273 which is a result of the encoding
-// described above.
-#define MATCH_LEN_MAX (MATCH_LEN_MIN + LEN_SYMBOLS - 1)
-
-
-////////////////////
-// Match distance //
-////////////////////
-
-// Different sets of probabilities are used for match distances that have very
-// short match length: Lengths of 2, 3, and 4 bytes have a separate set of
-// probabilities for each length. The matches with longer length use a shared
-// set of probabilities.
-#define DIST_STATES 4
-
-// Macro to get the index of the appropriate probability array.
-#define get_dist_state(len) \
-	((len) < DIST_STATES + MATCH_LEN_MIN \
-		? (len) - MATCH_LEN_MIN \
-		: DIST_STATES - 1)
-
-// The highest two bits of a match distance (distance slot) are encoded
-// using six bits. See fastpos.h for more explanation.
-#define DIST_SLOT_BITS 6
-#define DIST_SLOTS (1 << DIST_SLOT_BITS)
-
-// Match distances up to 127 are fully encoded using probabilities. Since
-// the highest two bits (distance slot) are always encoded using six bits,
-// the distances 0-3 don't need any additional bits to encode, since the
-// distance slot itself is the same as the actual distance. DIST_MODEL_START
-// indicates the first distance slot where at least one additional bit is
-// needed.
-#define DIST_MODEL_START 4
-
-// Match distances greater than 127 are encoded in three pieces:
-//   - distance slot: the highest two bits
-//   - direct bits: 2-26 bits below the highest two bits
-//   - alignment bits: four lowest bits
-//
-// Direct bits don't use any probabilities.
-//
-// The distance slot value of 14 is for distances 128-191 (see the table in
-// fastpos.h to understand why).
-#define DIST_MODEL_END 14
-
-// Distance slots that indicate a distance <= 127.
-#define FULL_DISTANCES_BITS (DIST_MODEL_END / 2)
-#define FULL_DISTANCES (1 << FULL_DISTANCES_BITS)
-
-// For match distances greater than 127, only the highest two bits and the
-// lowest four bits (alignment) is encoded using probabilities.
-#define ALIGN_BITS 4
-#define ALIGN_SIZE (1 << ALIGN_BITS)
-#define ALIGN_MASK (ALIGN_SIZE - 1)
-
-// LZMA remembers the four most recent match distances. Reusing these distances
-// tends to take less space than re-encoding the actual distance value.
-#define REPS 4
-
-#endif