node-liblzma 1.0.4 → 1.1.4

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

@@ -1,1131 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       stream_encoder_mt.c
-/// \brief      Multithreaded .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 "filter_encoder.h"
-#include "easy_preset.h"
-#include "block_encoder.h"
-#include "block_buffer_encoder.h"
-#include "index_encoder.h"
-#include "outqueue.h"
-
-
-/// Maximum supported block size. This makes it simpler to prevent integer
-/// overflows if we are given unusually large block size.
-#define BLOCK_SIZE_MAX (UINT64_MAX / LZMA_THREADS_MAX)
-
-
-typedef enum {
-	/// Waiting for work.
-	THR_IDLE,
-
-	/// Encoding is in progress.
-	THR_RUN,
-
-	/// Encoding is in progress but no more input data will
-	/// be read.
-	THR_FINISH,
-
-	/// The main thread wants the thread to stop whatever it was doing
-	/// but not exit.
-	THR_STOP,
-
-	/// The main thread wants the thread to exit. We could use
-	/// cancellation but since there's stopped anyway, this is lazier.
-	THR_EXIT,
-
-} worker_state;
-
-
-typedef struct worker_thread_s worker_thread;
-struct worker_thread_s {
-	worker_state state;
-
-	/// Input buffer of coder->block_size bytes. The main thread will
-	/// put new input into this and update in_size accordingly. Once
-	/// no more input is coming, state will be set to THR_FINISH.
-	uint8_t *in;
-
-	/// Amount of data available in the input buffer. This is modified
-	/// only by the main thread.
-	size_t in_size;
-
-	/// Output buffer for this thread. This is set by the main
-	/// thread every time a new Block is started with this thread
-	/// structure.
-	lzma_outbuf *outbuf;
-
-	/// Pointer to the main structure is needed when putting this
-	/// thread back to the stack of free threads.
-	lzma_coder *coder;
-
-	/// The allocator is set by the main thread. Since a copy of the
-	/// pointer is kept here, the application must not change the
-	/// allocator before calling lzma_end().
-	const lzma_allocator *allocator;
-
-	/// Amount of uncompressed data that has already been compressed.
-	uint64_t progress_in;
-
-	/// Amount of compressed data that is ready.
-	uint64_t progress_out;
-
-	/// Block encoder
-	lzma_next_coder block_encoder;
-
-	/// Compression options for this Block
-	lzma_block block_options;
-
-	/// Next structure in the stack of free worker threads.
-	worker_thread *next;
-
-	mythread_mutex mutex;
-	mythread_cond cond;
-
-	/// The ID of this thread is used to join the thread
-	/// when it's not needed anymore.
-	mythread thread_id;
-};
-
-
-struct lzma_coder_s {
-	enum {
-		SEQ_STREAM_HEADER,
-		SEQ_BLOCK,
-		SEQ_INDEX,
-		SEQ_STREAM_FOOTER,
-	} sequence;
-
-	/// Start a new Block every block_size bytes of input unless
-	/// LZMA_FULL_FLUSH or LZMA_FULL_BARRIER is used earlier.
-	size_t block_size;
-
-	/// The filter chain currently in use
-	lzma_filter filters[LZMA_FILTERS_MAX + 1];
-
-
-	/// Index to hold sizes of the Blocks
-	lzma_index *index;
-
-	/// Index encoder
-	lzma_next_coder index_encoder;
-
-
-	/// Stream Flags for encoding the Stream Header and Stream Footer.
-	lzma_stream_flags stream_flags;
-
-	/// Buffer to hold Stream Header and Stream Footer.
-	uint8_t header[LZMA_STREAM_HEADER_SIZE];
-
-	/// Read position in header[]
-	size_t header_pos;
-
-
-	/// Output buffer queue for compressed data
-	lzma_outq outq;
-
-
-	/// Maximum wait time if cannot use all the input and cannot
-	/// fill the output buffer. This is in milliseconds.
-	uint32_t timeout;
-
-
-	/// Error code from a worker thread
-	lzma_ret thread_error;
-
-	/// Array of allocated thread-specific structures
-	worker_thread *threads;
-
-	/// Number of structures in "threads" above. This is also the
-	/// number of threads that will be created at maximum.
-	uint32_t threads_max;
-
-	/// Number of thread structures that have been initialized, and
-	/// thus the number of worker threads actually created so far.
-	uint32_t threads_initialized;
-
-	/// Stack of free threads. When a thread finishes, it puts itself
-	/// back into this stack. This starts as empty because threads
-	/// are created only when actually needed.
-	worker_thread *threads_free;
-
-	/// The most recent worker thread to which the main thread writes
-	/// the new input from the application.
-	worker_thread *thr;
-
-
-	/// Amount of uncompressed data in Blocks that have already
-	/// been finished.
-	uint64_t progress_in;
-
-	/// Amount of compressed data in Stream Header + Blocks that
-	/// have already been finished.
-	uint64_t progress_out;
-
-
-	mythread_mutex mutex;
-	mythread_cond cond;
-};
-
-
-/// Tell the main thread that something has gone wrong.
-static void
-worker_error(worker_thread *thr, lzma_ret ret)
-{
-	assert(ret != LZMA_OK);
-	assert(ret != LZMA_STREAM_END);
-
-	mythread_sync(thr->coder->mutex) {
-		if (thr->coder->thread_error == LZMA_OK)
-			thr->coder->thread_error = ret;
-
-		mythread_cond_signal(&thr->coder->cond);
-	}
-
-	return;
-}
-
-
-static worker_state
-worker_encode(worker_thread *thr, worker_state state)
-{
-	assert(thr->progress_in == 0);
-	assert(thr->progress_out == 0);
-
-	// Set the Block options.
-	thr->block_options = (lzma_block){
-		.version = 0,
-		.check = thr->coder->stream_flags.check,
-		.compressed_size = thr->coder->outq.buf_size_max,
-		.uncompressed_size = thr->coder->block_size,
-
-		// TODO: To allow changing the filter chain, the filters
-		// array must be copied to each worker_thread.
-		.filters = thr->coder->filters,
-	};
-
-	// Calculate maximum size of the Block Header. This amount is
-	// reserved in the beginning of the buffer so that Block Header
-	// along with Compressed Size and Uncompressed Size can be
-	// written there.
-	lzma_ret ret = lzma_block_header_size(&thr->block_options);
-	if (ret != LZMA_OK) {
-		worker_error(thr, ret);
-		return THR_STOP;
-	}
-
-	// Initialize the Block encoder.
-	ret = lzma_block_encoder_init(&thr->block_encoder,
-			thr->allocator, &thr->block_options);
-	if (ret != LZMA_OK) {
-		worker_error(thr, ret);
-		return THR_STOP;
-	}
-
-	size_t in_pos = 0;
-	size_t in_size = 0;
-
-	thr->outbuf->size = thr->block_options.header_size;
-	const size_t out_size = thr->coder->outq.buf_size_max;
-
-	do {
-		mythread_sync(thr->mutex) {
-			// Store in_pos and out_pos into *thr so that
-			// an application may read them via
-			// lzma_get_progress() to get progress information.
-			//
-			// NOTE: These aren't updated when the encoding
-			// finishes. Instead, the final values are taken
-			// later from thr->outbuf.
-			thr->progress_in = in_pos;
-			thr->progress_out = thr->outbuf->size;
-
-			while (in_size == thr->in_size
-					&& thr->state == THR_RUN)
-				mythread_cond_wait(&thr->cond, &thr->mutex);
-
-			state = thr->state;
-			in_size = thr->in_size;
-		}
-
-		// Return if we were asked to stop or exit.
-		if (state >= THR_STOP)
-			return state;
-
-		lzma_action action = state == THR_FINISH
-				? LZMA_FINISH : LZMA_RUN;
-
-		// Limit the amount of input given to the Block encoder
-		// at once. This way this thread can react fairly quickly
-		// if the main thread wants us to stop or exit.
-		static const size_t in_chunk_max = 16384;
-		size_t in_limit = in_size;
-		if (in_size - in_pos > in_chunk_max) {
-			in_limit = in_pos + in_chunk_max;
-			action = LZMA_RUN;
-		}
-
-		ret = thr->block_encoder.code(
-				thr->block_encoder.coder, thr->allocator,
-				thr->in, &in_pos, in_limit, thr->outbuf->buf,
-				&thr->outbuf->size, out_size, action);
-	} while (ret == LZMA_OK && thr->outbuf->size < out_size);
-
-	switch (ret) {
-	case LZMA_STREAM_END:
-		assert(state == THR_FINISH);
-
-		// Encode the Block Header. By doing it after
-		// the compression, we can store the Compressed Size
-		// and Uncompressed Size fields.
-		ret = lzma_block_header_encode(&thr->block_options,
-				thr->outbuf->buf);
-		if (ret != LZMA_OK) {
-			worker_error(thr, ret);
-			return THR_STOP;
-		}
-
-		break;
-
-	case LZMA_OK:
-		// The data was incompressible. Encode it using uncompressed
-		// LZMA2 chunks.
-		//
-		// First wait that we have gotten all the input.
-		mythread_sync(thr->mutex) {
-			while (thr->state == THR_RUN)
-				mythread_cond_wait(&thr->cond, &thr->mutex);
-
-			state = thr->state;
-			in_size = thr->in_size;
-		}
-
-		if (state >= THR_STOP)
-			return state;
-
-		// Do the encoding. This takes care of the Block Header too.
-		thr->outbuf->size = 0;
-		ret = lzma_block_uncomp_encode(&thr->block_options,
-				thr->in, in_size, thr->outbuf->buf,
-				&thr->outbuf->size, out_size);
-
-		// It shouldn't fail.
-		if (ret != LZMA_OK) {
-			worker_error(thr, LZMA_PROG_ERROR);
-			return THR_STOP;
-		}
-
-		break;
-
-	default:
-		worker_error(thr, ret);
-		return THR_STOP;
-	}
-
-	// Set the size information that will be read by the main thread
-	// to write the Index field.
-	thr->outbuf->unpadded_size
-			= lzma_block_unpadded_size(&thr->block_options);
-	assert(thr->outbuf->unpadded_size != 0);
-	thr->outbuf->uncompressed_size = thr->block_options.uncompressed_size;
-
-	return THR_FINISH;
-}
-
-
-static MYTHREAD_RET_TYPE
-worker_start(void *thr_ptr)
-{
-	worker_thread *thr = thr_ptr;
-	worker_state state = THR_IDLE; // Init to silence a warning
-
-	while (true) {
-		// Wait for work.
-		mythread_sync(thr->mutex) {
-			while (true) {
-				// The thread is already idle so if we are
-				// requested to stop, just set the state.
-				if (thr->state == THR_STOP) {
-					thr->state = THR_IDLE;
-					mythread_cond_signal(&thr->cond);
-				}
-
-				state = thr->state;
-				if (state != THR_IDLE)
-					break;
-
-				mythread_cond_wait(&thr->cond, &thr->mutex);
-			}
-		}
-
-		assert(state != THR_IDLE);
-		assert(state != THR_STOP);
-
-		if (state <= THR_FINISH)
-			state = worker_encode(thr, state);
-
-		if (state == THR_EXIT)
-			break;
-
-		// Mark the thread as idle unless the main thread has
-		// told us to exit. Signal is needed for the case
-		// where the main thread is waiting for the threads to stop.
-		mythread_sync(thr->mutex) {
-			if (thr->state != THR_EXIT) {
-				thr->state = THR_IDLE;
-				mythread_cond_signal(&thr->cond);
-			}
-		}
-
-		mythread_sync(thr->coder->mutex) {
-			// Mark the output buffer as finished if
-			// no errors occurred.
-			thr->outbuf->finished = state == THR_FINISH;
-
-			// Update the main progress info.
-			thr->coder->progress_in
-					+= thr->outbuf->uncompressed_size;
-			thr->coder->progress_out += thr->outbuf->size;
-			thr->progress_in = 0;
-			thr->progress_out = 0;
-
-			// Return this thread to the stack of free threads.
-			thr->next = thr->coder->threads_free;
-			thr->coder->threads_free = thr;
-
-			mythread_cond_signal(&thr->coder->cond);
-		}
-	}
-
-	// Exiting, free the resources.
-	mythread_mutex_destroy(&thr->mutex);
-	mythread_cond_destroy(&thr->cond);
-
-	lzma_next_end(&thr->block_encoder, thr->allocator);
-	lzma_free(thr->in, thr->allocator);
-	return MYTHREAD_RET_VALUE;
-}
-
-
-/// Make the threads stop but not exit. Optionally wait for them to stop.
-static void
-threads_stop(lzma_coder *coder, bool wait_for_threads)
-{
-	// Tell the threads to stop.
-	for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
-		mythread_sync(coder->threads[i].mutex) {
-			coder->threads[i].state = THR_STOP;
-			mythread_cond_signal(&coder->threads[i].cond);
-		}
-	}
-
-	if (!wait_for_threads)
-		return;
-
-	// Wait for the threads to settle in the idle state.
-	for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
-		mythread_sync(coder->threads[i].mutex) {
-			while (coder->threads[i].state != THR_IDLE)
-				mythread_cond_wait(&coder->threads[i].cond,
-						&coder->threads[i].mutex);
-		}
-	}
-
-	return;
-}
-
-
-/// Stop the threads and free the resources associated with them.
-/// Wait until the threads have exited.
-static void
-threads_end(lzma_coder *coder, const lzma_allocator *allocator)
-{
-	for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
-		mythread_sync(coder->threads[i].mutex) {
-			coder->threads[i].state = THR_EXIT;
-			mythread_cond_signal(&coder->threads[i].cond);
-		}
-	}
-
-	for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
-		int ret = mythread_join(coder->threads[i].thread_id);
-		assert(ret == 0);
-		(void)ret;
-	}
-
-	lzma_free(coder->threads, allocator);
-	return;
-}
-
-
-/// Initialize a new worker_thread structure and create a new thread.
-static lzma_ret
-initialize_new_thread(lzma_coder *coder, const lzma_allocator *allocator)
-{
-	worker_thread *thr = &coder->threads[coder->threads_initialized];
-
-	thr->in = lzma_alloc(coder->block_size, allocator);
-	if (thr->in == NULL)
-		return LZMA_MEM_ERROR;
-
-	if (mythread_mutex_init(&thr->mutex))
-		goto error_mutex;
-
-	if (mythread_cond_init(&thr->cond))
-		goto error_cond;
-
-	thr->state = THR_IDLE;
-	thr->allocator = allocator;
-	thr->coder = coder;
-	thr->progress_in = 0;
-	thr->progress_out = 0;
-	thr->block_encoder = LZMA_NEXT_CODER_INIT;
-
-	if (mythread_create(&thr->thread_id, &worker_start, thr))
-		goto error_thread;
-
-	++coder->threads_initialized;
-	coder->thr = thr;
-
-	return LZMA_OK;
-
-error_thread:
-	mythread_cond_destroy(&thr->cond);
-
-error_cond:
-	mythread_mutex_destroy(&thr->mutex);
-
-error_mutex:
-	lzma_free(thr->in, allocator);
-	return LZMA_MEM_ERROR;
-}
-
-
-static lzma_ret
-get_thread(lzma_coder *coder, const lzma_allocator *allocator)
-{
-	// If there are no free output subqueues, there is no
-	// point to try getting a thread.
-	if (!lzma_outq_has_buf(&coder->outq))
-		return LZMA_OK;
-
-	// If there is a free structure on the stack, use it.
-	mythread_sync(coder->mutex) {
-		if (coder->threads_free != NULL) {
-			coder->thr = coder->threads_free;
-			coder->threads_free = coder->threads_free->next;
-		}
-	}
-
-	if (coder->thr == NULL) {
-		// If there are no uninitialized structures left, return.
-		if (coder->threads_initialized == coder->threads_max)
-			return LZMA_OK;
-
-		// Initialize a new thread.
-		return_if_error(initialize_new_thread(coder, allocator));
-	}
-
-	// Reset the parts of the thread state that have to be done
-	// in the main thread.
-	mythread_sync(coder->thr->mutex) {
-		coder->thr->state = THR_RUN;
-		coder->thr->in_size = 0;
-		coder->thr->outbuf = lzma_outq_get_buf(&coder->outq);
-		mythread_cond_signal(&coder->thr->cond);
-	}
-
-	return LZMA_OK;
-}
-
-
-static lzma_ret
-stream_encode_in(lzma_coder *coder, const lzma_allocator *allocator,
-		const uint8_t *restrict in, size_t *restrict in_pos,
-		size_t in_size, lzma_action action)
-{
-	while (*in_pos < in_size
-			|| (coder->thr != NULL && action != LZMA_RUN)) {
-		if (coder->thr == NULL) {
-			// Get a new thread.
-			const lzma_ret ret = get_thread(coder, allocator);
-			if (coder->thr == NULL)
-				return ret;
-		}
-
-		// Copy the input data to thread's buffer.
-		size_t thr_in_size = coder->thr->in_size;
-		lzma_bufcpy(in, in_pos, in_size, coder->thr->in,
-				&thr_in_size, coder->block_size);
-
-		// Tell the Block encoder to finish if
-		//  - it has got block_size bytes of input; or
-		//  - all input was used and LZMA_FINISH, LZMA_FULL_FLUSH,
-		//    or LZMA_FULL_BARRIER was used.
-		//
-		// TODO: LZMA_SYNC_FLUSH and LZMA_SYNC_BARRIER.
-		const bool finish = thr_in_size == coder->block_size
-				|| (*in_pos == in_size && action != LZMA_RUN);
-
-		bool block_error = false;
-
-		mythread_sync(coder->thr->mutex) {
-			if (coder->thr->state == THR_IDLE) {
-				// Something has gone wrong with the Block
-				// encoder. It has set coder->thread_error
-				// which we will read a few lines later.
-				block_error = true;
-			} else {
-				// Tell the Block encoder its new amount
-				// of input and update the state if needed.
-				coder->thr->in_size = thr_in_size;
-
-				if (finish)
-					coder->thr->state = THR_FINISH;
-
-				mythread_cond_signal(&coder->thr->cond);
-			}
-		}
-
-		if (block_error) {
-			lzma_ret ret;
-
-			mythread_sync(coder->mutex) {
-				ret = coder->thread_error;
-			}
-
-			return ret;
-		}
-
-		if (finish)
-			coder->thr = NULL;
-	}
-
-	return LZMA_OK;
-}
-
-
-/// Wait until more input can be consumed, more output can be read, or
-/// an optional timeout is reached.
-static bool
-wait_for_work(lzma_coder *coder, mythread_condtime *wait_abs,
-		bool *has_blocked, bool has_input)
-{
-	if (coder->timeout != 0 && !*has_blocked) {
-		// Every time when stream_encode_mt() is called via
-		// lzma_code(), *has_blocked starts as false. We set it
-		// to true here and calculate the absolute time when
-		// we must return if there's nothing to do.
-		//
-		// The idea of *has_blocked is to avoid unneeded calls
-		// to mythread_condtime_set(), which may do a syscall
-		// depending on the operating system.
-		*has_blocked = true;
-		mythread_condtime_set(wait_abs, &coder->cond, coder->timeout);
-	}
-
-	bool timed_out = false;
-
-	mythread_sync(coder->mutex) {
-		// There are four things that we wait. If one of them
-		// becomes possible, we return.
-		//  - If there is input left, we need to get a free
-		//    worker thread and an output buffer for it.
-		//  - Data ready to be read from the output queue.
-		//  - A worker thread indicates an error.
-		//  - Time out occurs.
-		while ((!has_input || coder->threads_free == NULL
-					|| !lzma_outq_has_buf(&coder->outq))
-				&& !lzma_outq_is_readable(&coder->outq)
-				&& coder->thread_error == LZMA_OK
-				&& !timed_out) {
-			if (coder->timeout != 0)
-				timed_out = mythread_cond_timedwait(
-						&coder->cond, &coder->mutex,
-						wait_abs) != 0;
-			else
-				mythread_cond_wait(&coder->cond,
-						&coder->mutex);
-		}
-	}
-
-	return timed_out;
-}
-
-
-static lzma_ret
-stream_encode_mt(lzma_coder *coder, const lzma_allocator *allocator,
-		const uint8_t *restrict in, size_t *restrict in_pos,
-		size_t in_size, uint8_t *restrict out,
-		size_t *restrict out_pos, size_t out_size, lzma_action action)
-{
-	switch (coder->sequence) {
-	case SEQ_STREAM_HEADER:
-		lzma_bufcpy(coder->header, &coder->header_pos,
-				sizeof(coder->header),
-				out, out_pos, out_size);
-		if (coder->header_pos < sizeof(coder->header))
-			return LZMA_OK;
-
-		coder->header_pos = 0;
-		coder->sequence = SEQ_BLOCK;
-
-	// Fall through
-
-	case SEQ_BLOCK: {
-		// Initialized to silence warnings.
-		lzma_vli unpadded_size = 0;
-		lzma_vli uncompressed_size = 0;
-		lzma_ret ret = LZMA_OK;
-
-		// These are for wait_for_work().
-		bool has_blocked = false;
-		mythread_condtime wait_abs;
-
-		while (true) {
-			mythread_sync(coder->mutex) {
-				// Check for Block encoder errors.
-				ret = coder->thread_error;
-				if (ret != LZMA_OK) {
-					assert(ret != LZMA_STREAM_END);
-					break;
-				}
-
-				// Try to read compressed data to out[].
-				ret = lzma_outq_read(&coder->outq,
-						out, out_pos, out_size,
-						&unpadded_size,
-						&uncompressed_size);
-			}
-
-			if (ret == LZMA_STREAM_END) {
-				// End of Block. Add it to the Index.
-				ret = lzma_index_append(coder->index,
-						allocator, unpadded_size,
-						uncompressed_size);
-
-				// If we didn't fill the output buffer yet,
-				// try to read more data. Maybe the next
-				// outbuf has been finished already too.
-				if (*out_pos < out_size)
-					continue;
-			}
-
-			if (ret != LZMA_OK) {
-				// coder->thread_error was set or
-				// lzma_index_append() failed.
-				threads_stop(coder, false);
-				return ret;
-			}
-
-			// Try to give uncompressed data to a worker thread.
-			ret = stream_encode_in(coder, allocator,
-					in, in_pos, in_size, action);
-			if (ret != LZMA_OK) {
-				threads_stop(coder, false);
-				return ret;
-			}
-
-			// See if we should wait or return.
-			//
-			// TODO: LZMA_SYNC_FLUSH and LZMA_SYNC_BARRIER.
-			if (*in_pos == in_size) {
-				// LZMA_RUN: More data is probably coming
-				// so return to let the caller fill the
-				// input buffer.
-				if (action == LZMA_RUN)
-					return LZMA_OK;
-
-				// LZMA_FULL_BARRIER: The same as with
-				// LZMA_RUN but tell the caller that the
-				// barrier was completed.
-				if (action == LZMA_FULL_BARRIER)
-					return LZMA_STREAM_END;
-
-				// Finishing or flushing isn't completed until
-				// all input data has been encoded and copied
-				// to the output buffer.
-				if (lzma_outq_is_empty(&coder->outq)) {
-					// LZMA_FINISH: Continue to encode
-					// the Index field.
-					if (action == LZMA_FINISH)
-						break;
-
-					// LZMA_FULL_FLUSH: Return to tell
-					// the caller that flushing was
-					// completed.
-					if (action == LZMA_FULL_FLUSH)
-						return LZMA_STREAM_END;
-				}
-			}
-
-			// Return if there is no output space left.
-			// This check must be done after testing the input
-			// buffer, because we might want to use a different
-			// return code.
-			if (*out_pos == out_size)
-				return LZMA_OK;
-
-			// Neither in nor out has been used completely.
-			// Wait until there's something we can do.
-			if (wait_for_work(coder, &wait_abs, &has_blocked,
-					*in_pos < in_size))
-				return LZMA_TIMED_OUT;
-		}
-
-		// All Blocks have been encoded and the threads have stopped.
-		// Prepare to encode the Index field.
-		return_if_error(lzma_index_encoder_init(
-				&coder->index_encoder, allocator,
-				coder->index));
-		coder->sequence = SEQ_INDEX;
-
-		// Update the progress info to take the Index and
-		// Stream Footer into account. Those are very fast to encode
-		// so in terms of progress information they can be thought
-		// to be ready to be copied out.
-		coder->progress_out += lzma_index_size(coder->index)
-				+ LZMA_STREAM_HEADER_SIZE;
-	}
-
-	// Fall through
-
-	case SEQ_INDEX: {
-		// Call the Index encoder. It doesn't take any input, so
-		// those pointers can be NULL.
-		const lzma_ret ret = coder->index_encoder.code(
-				coder->index_encoder.coder, allocator,
-				NULL, NULL, 0,
-				out, out_pos, out_size, LZMA_RUN);
-		if (ret != LZMA_STREAM_END)
-			return ret;
-
-		// Encode the Stream Footer into coder->buffer.
-		coder->stream_flags.backward_size
-				= lzma_index_size(coder->index);
-		if (lzma_stream_footer_encode(&coder->stream_flags,
-				coder->header) != LZMA_OK)
-			return LZMA_PROG_ERROR;
-
-		coder->sequence = SEQ_STREAM_FOOTER;
-	}
-
-	// Fall through
-
-	case SEQ_STREAM_FOOTER:
-		lzma_bufcpy(coder->header, &coder->header_pos,
-				sizeof(coder->header),
-				out, out_pos, out_size);
-		return coder->header_pos < sizeof(coder->header)
-				? LZMA_OK : LZMA_STREAM_END;
-	}
-
-	assert(0);
-	return LZMA_PROG_ERROR;
-}
-
-
-static void
-stream_encoder_mt_end(lzma_coder *coder, const lzma_allocator *allocator)
-{
-	// Threads must be killed before the output queue can be freed.
-	threads_end(coder, allocator);
-	lzma_outq_end(&coder->outq, allocator);
-
-	for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
-		lzma_free(coder->filters[i].options, allocator);
-
-	lzma_next_end(&coder->index_encoder, allocator);
-	lzma_index_end(coder->index, allocator);
-
-	mythread_cond_destroy(&coder->cond);
-	mythread_mutex_destroy(&coder->mutex);
-
-	lzma_free(coder, allocator);
-	return;
-}
-
-
-/// Options handling for lzma_stream_encoder_mt_init() and
-/// lzma_stream_encoder_mt_memusage()
-static lzma_ret
-get_options(const lzma_mt *options, lzma_options_easy *opt_easy,
-		const lzma_filter **filters, uint64_t *block_size,
-		uint64_t *outbuf_size_max)
-{
-	// Validate some of the options.
-	if (options == NULL)
-		return LZMA_PROG_ERROR;
-
-	if (options->flags != 0 || options->threads == 0
-			|| options->threads > LZMA_THREADS_MAX)
-		return LZMA_OPTIONS_ERROR;
-
-	if (options->filters != NULL) {
-		// Filter chain was given, use it as is.
-		*filters = options->filters;
-	} else {
-		// Use a preset.
-		if (lzma_easy_preset(opt_easy, options->preset))
-			return LZMA_OPTIONS_ERROR;
-
-		*filters = opt_easy->filters;
-	}
-
-	// Block size
-	if (options->block_size > 0) {
-		if (options->block_size > BLOCK_SIZE_MAX)
-			return LZMA_OPTIONS_ERROR;
-
-		*block_size = options->block_size;
-	} else {
-		// Determine the Block size from the filter chain.
-		*block_size = lzma_mt_block_size(*filters);
-		if (*block_size == 0)
-			return LZMA_OPTIONS_ERROR;
-
-		assert(*block_size <= BLOCK_SIZE_MAX);
-	}
-
-	// Calculate the maximum amount output that a single output buffer
-	// may need to hold. This is the same as the maximum total size of
-	// a Block.
-	*outbuf_size_max = lzma_block_buffer_bound64(*block_size);
-	if (*outbuf_size_max == 0)
-		return LZMA_MEM_ERROR;
-
-	return LZMA_OK;
-}
-
-
-static void
-get_progress(lzma_coder *coder, uint64_t *progress_in, uint64_t *progress_out)
-{
-	// Lock coder->mutex to prevent finishing threads from moving their
-	// progress info from the worker_thread structure to lzma_coder.
-	mythread_sync(coder->mutex) {
-		*progress_in = coder->progress_in;
-		*progress_out = coder->progress_out;
-
-		for (size_t i = 0; i < coder->threads_initialized; ++i) {
-			mythread_sync(coder->threads[i].mutex) {
-				*progress_in += coder->threads[i].progress_in;
-				*progress_out += coder->threads[i]
-						.progress_out;
-			}
-		}
-	}
-
-	return;
-}
-
-
-static lzma_ret
-stream_encoder_mt_init(lzma_next_coder *next, const lzma_allocator *allocator,
-		const lzma_mt *options)
-{
-	lzma_next_coder_init(&stream_encoder_mt_init, next, allocator);
-
-	// Get the filter chain.
-	lzma_options_easy easy;
-	const lzma_filter *filters;
-	uint64_t block_size;
-	uint64_t outbuf_size_max;
-	return_if_error(get_options(options, &easy, &filters,
-			&block_size, &outbuf_size_max));
-
-#if SIZE_MAX < UINT64_MAX
-	if (block_size > SIZE_MAX)
-		return LZMA_MEM_ERROR;
-#endif
-
-	// Validate the filter chain so that we can give an error in this
-	// function instead of delaying it to the first call to lzma_code().
-	// The memory usage calculation verifies the filter chain as
-	// a side effect so we take advatange of that.
-	if (lzma_raw_encoder_memusage(filters) == UINT64_MAX)
-		return LZMA_OPTIONS_ERROR;
-
-	// Validate the Check ID.
-	if ((unsigned int)(options->check) > LZMA_CHECK_ID_MAX)
-		return LZMA_PROG_ERROR;
-
-	if (!lzma_check_is_supported(options->check))
-		return LZMA_UNSUPPORTED_CHECK;
-
-	// Allocate and initialize the base structure if needed.
-	if (next->coder == NULL) {
-		next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-		if (next->coder == NULL)
-			return LZMA_MEM_ERROR;
-
-		// For the mutex and condition variable initializations
-		// the error handling has to be done here because
-		// stream_encoder_mt_end() doesn't know if they have
-		// already been initialized or not.
-		if (mythread_mutex_init(&next->coder->mutex)) {
-			lzma_free(next->coder, allocator);
-			next->coder = NULL;
-			return LZMA_MEM_ERROR;
-		}
-
-		if (mythread_cond_init(&next->coder->cond)) {
-			mythread_mutex_destroy(&next->coder->mutex);
-			lzma_free(next->coder, allocator);
-			next->coder = NULL;
-			return LZMA_MEM_ERROR;
-		}
-
-		next->code = &stream_encode_mt;
-		next->end = &stream_encoder_mt_end;
-		next->get_progress = &get_progress;
-// 		next->update = &stream_encoder_mt_update;
-
-		next->coder->filters[0].id = LZMA_VLI_UNKNOWN;
-		next->coder->index_encoder = LZMA_NEXT_CODER_INIT;
-		next->coder->index = NULL;
-		memzero(&next->coder->outq, sizeof(next->coder->outq));
-		next->coder->threads = NULL;
-		next->coder->threads_max = 0;
-		next->coder->threads_initialized = 0;
-	}
-
-	// Basic initializations
-	next->coder->sequence = SEQ_STREAM_HEADER;
-	next->coder->block_size = (size_t)(block_size);
-	next->coder->thread_error = LZMA_OK;
-	next->coder->thr = NULL;
-
-	// Allocate the thread-specific base structures.
-	assert(options->threads > 0);
-	if (next->coder->threads_max != options->threads) {
-		threads_end(next->coder, allocator);
-
-		next->coder->threads = NULL;
-		next->coder->threads_max = 0;
-
-		next->coder->threads_initialized = 0;
-		next->coder->threads_free = NULL;
-
-		next->coder->threads = lzma_alloc(
-				options->threads * sizeof(worker_thread),
-				allocator);
-		if (next->coder->threads == NULL)
-			return LZMA_MEM_ERROR;
-
-		next->coder->threads_max = options->threads;
-	} else {
-		// Reuse the old structures and threads. Tell the running
-		// threads to stop and wait until they have stopped.
-		threads_stop(next->coder, true);
-	}
-
-	// Output queue
-	return_if_error(lzma_outq_init(&next->coder->outq, allocator,
-			outbuf_size_max, options->threads));
-
-	// Timeout
-	next->coder->timeout = options->timeout;
-
-	// Free the old filter chain and copy the new one.
-	for (size_t i = 0; next->coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
-		lzma_free(next->coder->filters[i].options, allocator);
-
-	return_if_error(lzma_filters_copy(
-			filters, next->coder->filters, allocator));
-
-	// Index
-	lzma_index_end(next->coder->index, allocator);
-	next->coder->index = lzma_index_init(allocator);
-	if (next->coder->index == NULL)
-		return LZMA_MEM_ERROR;
-
-	// Stream Header
-	next->coder->stream_flags.version = 0;
-	next->coder->stream_flags.check = options->check;
-	return_if_error(lzma_stream_header_encode(
-			&next->coder->stream_flags, next->coder->header));
-
-	next->coder->header_pos = 0;
-
-	// Progress info
-	next->coder->progress_in = 0;
-	next->coder->progress_out = LZMA_STREAM_HEADER_SIZE;
-
-	return LZMA_OK;
-}
-
-
-extern LZMA_API(lzma_ret)
-lzma_stream_encoder_mt(lzma_stream *strm, const lzma_mt *options)
-{
-	lzma_next_strm_init(stream_encoder_mt_init, strm, options);
-
-	strm->internal->supported_actions[LZMA_RUN] = true;
-// 	strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
-	strm->internal->supported_actions[LZMA_FULL_FLUSH] = true;
-	strm->internal->supported_actions[LZMA_FULL_BARRIER] = true;
-	strm->internal->supported_actions[LZMA_FINISH] = true;
-
-	return LZMA_OK;
-}
-
-
-// This function name is a monster but it's consistent with the older
-// monster names. :-( 31 chars is the max that C99 requires so in that
-// sense it's not too long. ;-)
-extern LZMA_API(uint64_t)
-lzma_stream_encoder_mt_memusage(const lzma_mt *options)
-{
-	lzma_options_easy easy;
-	const lzma_filter *filters;
-	uint64_t block_size;
-	uint64_t outbuf_size_max;
-
-	if (get_options(options, &easy, &filters, &block_size,
-			&outbuf_size_max) != LZMA_OK)
-		return UINT64_MAX;
-
-	// Memory usage of the input buffers
-	const uint64_t inbuf_memusage = options->threads * block_size;
-
-	// Memory usage of the filter encoders
-	uint64_t filters_memusage = lzma_raw_encoder_memusage(filters);
-	if (filters_memusage == UINT64_MAX)
-		return UINT64_MAX;
-
-	filters_memusage *= options->threads;
-
-	// Memory usage of the output queue
-	const uint64_t outq_memusage = lzma_outq_memusage(
-			outbuf_size_max, options->threads);
-	if (outq_memusage == UINT64_MAX)
-		return UINT64_MAX;
-
-	// Sum them with overflow checking.
-	uint64_t total_memusage = LZMA_MEMUSAGE_BASE + sizeof(lzma_coder)
-			+ options->threads * sizeof(worker_thread);
-
-	if (UINT64_MAX - total_memusage < inbuf_memusage)
-		return UINT64_MAX;
-
-	total_memusage += inbuf_memusage;
-
-	if (UINT64_MAX - total_memusage < filters_memusage)
-		return UINT64_MAX;
-
-	total_memusage += filters_memusage;
-
-	if (UINT64_MAX - total_memusage < outq_memusage)
-		return UINT64_MAX;
-
-	return total_memusage + outq_memusage;
-}