node-liblzma 1.0.4 → 1.1.4

package/deps/xz/src/liblzma/common/outqueue.h

@@ -1,156 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       outqueue.h
-/// \brief      Output queue handling in multithreaded coding
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "common.h"
-
-
-/// Output buffer for a single thread
-typedef struct {
-	/// Pointer to the output buffer of lzma_outq.buf_size_max bytes
-	uint8_t *buf;
-
-	/// Amount of data written to buf
-	size_t size;
-
-	/// Additional size information
-	lzma_vli unpadded_size;
-	lzma_vli uncompressed_size;
-
-	/// True when no more data will be written into this buffer.
-	///
-	/// \note       This is read by another thread and thus access
-	///             to this variable needs a mutex.
-	bool finished;
-
-} lzma_outbuf;
-
-
-typedef struct {
-	/// Array of buffers that are used cyclically.
-	lzma_outbuf *bufs;
-
-	/// Memory allocated for all the buffers
-	uint8_t *bufs_mem;
-
-	/// Amount of buffer space available in each buffer
-	size_t buf_size_max;
-
-	/// Number of buffers allocated
-	uint32_t bufs_allocated;
-
-	/// Position in the bufs array. The next buffer to be taken
-	/// into use is bufs[bufs_pos].
-	uint32_t bufs_pos;
-
-	/// Number of buffers in use
-	uint32_t bufs_used;
-
-	/// Position in the buffer in lzma_outq_read()
-	size_t read_pos;
-
-} lzma_outq;
-
-
-/**
- * \brief       Calculate the memory usage of an output queue
- *
- * \return      Approximate memory usage in bytes or UINT64_MAX on error.
- */
-extern uint64_t lzma_outq_memusage(uint64_t buf_size_max, uint32_t threads);
-
-
-/// \brief      Initialize an output queue
-///
-/// \param      outq            Pointer to an output queue. Before calling
-///                             this function the first time, *outq should
-///                             have been zeroed with memzero() so that this
-///                             function knows that there are no previous
-///                             allocations to free.
-/// \param      allocator       Pointer to allocator or NULL
-/// \param      buf_size_max    Maximum amount of data that a single buffer
-///                             in the queue may need to store.
-/// \param      threads         Number of buffers that may be in use
-///                             concurrently. Note that more than this number
-///                             of buffers will actually get allocated to
-///                             improve performance when buffers finish
-///                             out of order.
-///
-/// \return     - LZMA_OK
-///             - LZMA_MEM_ERROR
-///
-extern lzma_ret lzma_outq_init(
-		lzma_outq *outq, const lzma_allocator *allocator,
-		uint64_t buf_size_max, uint32_t threads);
-
-
-/// \brief      Free the memory associated with the output queue
-extern void lzma_outq_end(lzma_outq *outq, const lzma_allocator *allocator);
-
-
-/// \brief      Get a new buffer
-///
-/// lzma_outq_has_buf() must be used to check that there is a buffer
-/// available before calling lzma_outq_get_buf().
-///
-extern lzma_outbuf *lzma_outq_get_buf(lzma_outq *outq);
-
-
-/// \brief      Test if there is data ready to be read
-///
-/// Call to this function must be protected with the same mutex that
-/// is used to protect lzma_outbuf.finished.
-///
-extern bool lzma_outq_is_readable(const lzma_outq *outq);
-
-
-/// \brief      Read finished data
-///
-/// \param      outq            Pointer to an output queue
-/// \param      out             Beginning of the output buffer
-/// \param      out_pos         The next byte will be written to
-///                             out[*out_pos].
-/// \param      out_size        Size of the out buffer; the first byte into
-///                             which no data is written to is out[out_size].
-/// \param      unpadded_size   Unpadded Size from the Block encoder
-/// \param      uncompressed_size Uncompressed Size from the Block encoder
-///
-/// \return     - LZMA: All OK. Either no data was available or the buffer
-///               being read didn't become empty yet.
-///             - LZMA_STREAM_END: The buffer being read was finished.
-///               *unpadded_size and *uncompressed_size were set.
-///
-/// \note       This reads lzma_outbuf.finished variables and thus call
-///             to this function needs to be protected with a mutex.
-///
-extern lzma_ret lzma_outq_read(lzma_outq *restrict outq,
-		uint8_t *restrict out, size_t *restrict out_pos,
-		size_t out_size, lzma_vli *restrict unpadded_size,
-		lzma_vli *restrict uncompressed_size);
-
-
-/// \brief      Test if there is at least one buffer free
-///
-/// This must be used before getting a new buffer with lzma_outq_get_buf().
-///
-static inline bool
-lzma_outq_has_buf(const lzma_outq *outq)
-{
-	return outq->bufs_used < outq->bufs_allocated;
-}
-
-
-/// \brief      Test if the queue is completely empty
-static inline bool
-lzma_outq_is_empty(const lzma_outq *outq)
-{
-	return outq->bufs_used == 0;
-}

package/deps/xz/src/liblzma/common/stream_buffer_decoder.c

@@ -1,91 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_buffer_decoder.c
-/// \brief      Single-call .xz Stream decoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "stream_decoder.h"
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_buffer_decode(uint64_t *memlimit, uint32_t flags,
-		const lzma_allocator *allocator,
-		const uint8_t *in, size_t *in_pos, size_t in_size,
-		uint8_t *out, size_t *out_pos, size_t out_size)
-{
-	// Sanity checks
-	if (in_pos == NULL || (in == NULL && *in_pos != in_size)
-			|| *in_pos > in_size || out_pos == NULL
-			|| (out == NULL && *out_pos != out_size)
-			|| *out_pos > out_size)
-		return LZMA_PROG_ERROR;
-
-	// Catch flags that are not allowed in buffer-to-buffer decoding.
-	if (flags & LZMA_TELL_ANY_CHECK)
-		return LZMA_PROG_ERROR;
-
-	// Initialize the Stream decoder.
-	// TODO: We need something to tell the decoder that it can use the
-	// output buffer as workspace, and thus save significant amount of RAM.
-	lzma_next_coder stream_decoder = LZMA_NEXT_CODER_INIT;
-	lzma_ret ret = lzma_stream_decoder_init(
-			&stream_decoder, allocator, *memlimit, flags);
-
-	if (ret == LZMA_OK) {
-		// Save the positions so that we can restore them in case
-		// an error occurs.
-		const size_t in_start = *in_pos;
-		const size_t out_start = *out_pos;
-
-		// Do the actual decoding.
-		ret = stream_decoder.code(stream_decoder.coder, allocator,
-				in, in_pos, in_size, out, out_pos, out_size,
-				LZMA_FINISH);
-
-		if (ret == LZMA_STREAM_END) {
-			ret = LZMA_OK;
-		} else {
-			// Something went wrong, restore the positions.
-			*in_pos = in_start;
-			*out_pos = out_start;
-
-			if (ret == LZMA_OK) {
-				// Either the input was truncated or the
-				// output buffer was too small.
-				assert(*in_pos == in_size
-						|| *out_pos == out_size);
-
-				// If all the input was consumed, then the
-				// input is truncated, even if the output
-				// buffer is also full. This is because
-				// processing the last byte of the Stream
-				// never produces output.
-				if (*in_pos == in_size)
-					ret = LZMA_DATA_ERROR;
-				else
-					ret = LZMA_BUF_ERROR;
-
-			} else if (ret == LZMA_MEMLIMIT_ERROR) {
-				// Let the caller know how much memory would
-				// have been needed.
-				uint64_t memusage;
-				(void)stream_decoder.memconfig(
-						stream_decoder.coder,
-						memlimit, &memusage, 0);
-			}
-		}
-	}
-
-	// Free the decoder memory. This needs to be done even if
-	// initialization fails, because the internal API doesn't
-	// require the initialization function to free its memory on error.
-	lzma_next_end(&stream_decoder, allocator);
-
-	return ret;
-}

package/deps/xz/src/liblzma/common/stream_buffer_encoder.c

@@ -1,141 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_buffer_encoder.c
-/// \brief      Single-call .xz Stream encoder
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "index.h"
-
-
-/// Maximum size of Index that has exactly one Record.
-/// Index Indicator + Number of Records + Record + CRC32 rounded up to
-/// the next multiple of four.
-#define INDEX_BOUND ((1 + 1 + 2 * LZMA_VLI_BYTES_MAX + 4 + 3) & ~3)
-
-/// Stream Header, Stream Footer, and Index
-#define HEADERS_BOUND (2 * LZMA_STREAM_HEADER_SIZE + INDEX_BOUND)
-
-
-extern LZMA_API(size_t)
-lzma_stream_buffer_bound(size_t uncompressed_size)
-{
-	// Get the maximum possible size of a Block.
-	const size_t block_bound = lzma_block_buffer_bound(uncompressed_size);
-	if (block_bound == 0)
-		return 0;
-
-	// Catch the possible integer overflow and also prevent the size of
-	// the Stream exceeding LZMA_VLI_MAX (theoretically possible on
-	// 64-bit systems).
-	if (my_min(SIZE_MAX, LZMA_VLI_MAX) - block_bound < HEADERS_BOUND)
-		return 0;
-
-	return block_bound + HEADERS_BOUND;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_buffer_encode(lzma_filter *filters, lzma_check check,
-		const lzma_allocator *allocator,
-		const uint8_t *in, size_t in_size,
-		uint8_t *out, size_t *out_pos_ptr, size_t out_size)
-{
-	// Sanity checks
-	if (filters == NULL || (unsigned int)(check) > LZMA_CHECK_ID_MAX
-			|| (in == NULL && in_size != 0) || out == NULL
-			|| out_pos_ptr == NULL || *out_pos_ptr > out_size)
-		return LZMA_PROG_ERROR;
-
-	if (!lzma_check_is_supported(check))
-		return LZMA_UNSUPPORTED_CHECK;
-
-	// Note for the paranoids: Index encoder prevents the Stream from
-	// getting too big and still being accepted with LZMA_OK, and Block
-	// encoder catches if the input is too big. So we don't need to
-	// separately check if the buffers are too big.
-
-	// Use a local copy. We update *out_pos_ptr only if everything
-	// succeeds.
-	size_t out_pos = *out_pos_ptr;
-
-	// Check that there's enough space for both Stream Header and
-	// Stream Footer.
-	if (out_size - out_pos <= 2 * LZMA_STREAM_HEADER_SIZE)
-		return LZMA_BUF_ERROR;
-
-	// Reserve space for Stream Footer so we don't need to check for
-	// available space again before encoding Stream Footer.
-	out_size -= LZMA_STREAM_HEADER_SIZE;
-
-	// Encode the Stream Header.
-	lzma_stream_flags stream_flags = {
-		.version = 0,
-		.check = check,
-	};
-
-	if (lzma_stream_header_encode(&stream_flags, out + out_pos)
-			!= LZMA_OK)
-		return LZMA_PROG_ERROR;
-
-	out_pos += LZMA_STREAM_HEADER_SIZE;
-
-	// Encode a Block but only if there is at least one byte of input.
-	lzma_block block = {
-		.version = 0,
-		.check = check,
-		.filters = filters,
-	};
-
-	if (in_size > 0)
-		return_if_error(lzma_block_buffer_encode(&block, allocator,
-				in, in_size, out, &out_pos, out_size));
-
-	// Index
-	{
-		// Create an Index. It will have one Record if there was
-		// at least one byte of input to encode. Otherwise the
-		// Index will be empty.
-		lzma_index *i = lzma_index_init(allocator);
-		if (i == NULL)
-			return LZMA_MEM_ERROR;
-
-		lzma_ret ret = LZMA_OK;
-
-		if (in_size > 0)
-			ret = lzma_index_append(i, allocator,
-					lzma_block_unpadded_size(&block),
-					block.uncompressed_size);
-
-		// If adding the Record was successful, encode the Index
-		// and get its size which will be stored into Stream Footer.
-		if (ret == LZMA_OK) {
-			ret = lzma_index_buffer_encode(
-					i, out, &out_pos, out_size);
-
-			stream_flags.backward_size = lzma_index_size(i);
-		}
-
-		lzma_index_end(i, allocator);
-
-		if (ret != LZMA_OK)
-			return ret;
-	}
-
-	// Stream Footer. We have already reserved space for this.
-	if (lzma_stream_footer_encode(&stream_flags, out + out_pos)
-			!= LZMA_OK)
-		return LZMA_PROG_ERROR;
-
-	out_pos += LZMA_STREAM_HEADER_SIZE;
-
-	// Everything went fine, make the new output position available
-	// to the application.
-	*out_pos_ptr = out_pos;
-	return LZMA_OK;
-}