Update the code to mostly match the new simpler file format

specification. Simplify things by removing most of the
support for known uncompressed size in most places.
There are some miscellaneous changes here and there too.

The API of liblzma has got many changes and still some
more will be done soon. While most of the code has been
updated, some things are not fixed (the command line tool
will choke with invalid filter chain, if nothing else).

Subblock filter is somewhat broken for now. It will be
updated once the encoded format of the Subblock filter
has been decided.

1 files changed, 16 insertions, 85 deletions

diff --git a/src/liblzma/common/raw_encoder.c b/src/liblzma/common/raw_encoder.c
index fb12862b..9b8cbfae 100644
--- a/src/liblzma/common/raw_encoder.c
+++ b/src/liblzma/common/raw_encoder.c
@@ -18,28 +18,16 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "raw_encoder.h"
-#include "copy_coder.h"
 #include "simple_coder.h"
 #include "subblock_encoder.h"
 #include "delta_encoder.h"
 #include "lzma_encoder.h"
 
 
-struct lzma_coder_s {
-	lzma_next_coder next;
-	lzma_vli uncompressed_size;
-};
-
-
 static lzma_init_function
 get_function(lzma_vli id)
 {
 	switch (id) {
-#ifdef HAVE_FILTER_COPY
-	case LZMA_FILTER_COPY:
-		return &lzma_copy_encoder_init;
-#endif
-
 #ifdef HAVE_FILTER_SUBBLOCK
 	case LZMA_FILTER_SUBBLOCK:
 		return &lzma_subblock_encoder_init;
@@ -90,91 +78,34 @@ get_function(lzma_vli id)
 }
 
 
-static lzma_ret
-raw_encode(lzma_coder *coder, 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)
+extern lzma_ret
+lzma_raw_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
+		const lzma_options_filter *options)
 {
-	// Check that our amount of input stays in proper limits.
-	if (coder->uncompressed_size != LZMA_VLI_VALUE_UNKNOWN) {
-		if (action == LZMA_FINISH) {
-			if (coder->uncompressed_size != in_size - *in_pos)
-				return LZMA_PROG_ERROR;
-		} else {
-			if (coder->uncompressed_size < in_size - *in_pos)
-				return LZMA_PROG_ERROR;
-		}
-	}
-
-	const size_t in_start = *in_pos;
+	const lzma_ret ret = lzma_raw_coder_init(next, allocator,
+			options, &get_function, true);
 
-	const lzma_ret ret = coder->next.code(coder->next.coder, allocator,
-			in, in_pos, in_size, out, out_pos, out_size, action);
-
-	if (coder->uncompressed_size != LZMA_VLI_VALUE_UNKNOWN)
-		coder->uncompressed_size -= *in_pos - in_start;
+	if (ret != LZMA_OK)
+		lzma_next_coder_end(next, allocator);
 
 	return ret;
 }
 
 
-static void
-raw_encoder_end(lzma_coder *coder, lzma_allocator *allocator)
-{
-	lzma_next_coder_end(&coder->next, allocator);
-	lzma_free(coder, allocator);
-	return;
-}
-
-
-static lzma_ret
-raw_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
-		const lzma_options_filter *options,
-		lzma_vli uncompressed_size, bool allow_implicit)
-{
-	if (next->coder == NULL) {
-		next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-		if (next->coder == NULL)
-			return LZMA_MEM_ERROR;
-
-		next->code = &raw_encode;
-		next->end = &raw_encoder_end;
-
-		next->coder->next = LZMA_NEXT_CODER_INIT;
-	}
-
-	next->coder->uncompressed_size = uncompressed_size;
-
-	// lzma_raw_coder_init() accesses get_function() via function pointer,
-	// because this way linker doesn't statically link both encoder and
-	// decoder functions if user needs only encoder or decoder.
-	return lzma_raw_coder_init(&next->coder->next, allocator,
-			options, uncompressed_size,
-			&get_function, allow_implicit, true);
-}
-
-
-extern lzma_ret
-lzma_raw_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
-		const lzma_options_filter *options,
-		lzma_vli uncompressed_size, bool allow_implicit)
-{
-	lzma_next_coder_init(raw_encoder_init, next, allocator,
-			options, uncompressed_size, allow_implicit);
-}
-
-
 extern LZMA_API lzma_ret
-lzma_raw_encoder(lzma_stream *strm, const lzma_options_filter *options,
-		lzma_vli uncompressed_size, lzma_bool allow_implicit)
+lzma_raw_encoder(lzma_stream *strm, const lzma_options_filter *options)
 {
-	lzma_next_strm_init(strm, raw_encoder_init,
-			options, uncompressed_size, allow_implicit);
+	return_if_error(lzma_strm_init(strm));
 
 	strm->internal->supported_actions[LZMA_RUN] = true;
 	strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
 	strm->internal->supported_actions[LZMA_FINISH] = true;
 
-	return LZMA_OK;
+	const lzma_ret ret = lzma_raw_coder_init(&strm->internal->next,
+			strm->allocator, options, &get_function, true);
+
+	if (ret != LZMA_OK)
+		lzma_end(strm);
+
+	return ret;
 }