aboutsummaryrefslogtreecommitdiff
path: root/src/liblzma/common/metadata_encoder.c
diff options
context:
space:
mode:
authorLasse Collin <lasse.collin@tukaani.org>2007-12-09 00:42:33 +0200
committerLasse Collin <lasse.collin@tukaani.org>2007-12-09 00:42:33 +0200
commit5d018dc03549c1ee4958364712fb0c94e1bf2741 (patch)
tree1b211911fb33fddb3f04b77f99e81df23623ffc4 /src/liblzma/common/metadata_encoder.c
downloadxz-5d018dc03549c1ee4958364712fb0c94e1bf2741.tar.xz
Imported to git.
Diffstat (limited to 'src/liblzma/common/metadata_encoder.c')
-rw-r--r--src/liblzma/common/metadata_encoder.c436
1 files changed, 436 insertions, 0 deletions
diff --git a/src/liblzma/common/metadata_encoder.c b/src/liblzma/common/metadata_encoder.c
new file mode 100644
index 00000000..17587c5c
--- /dev/null
+++ b/src/liblzma/common/metadata_encoder.c
@@ -0,0 +1,436 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+/// \file metadata_encoder.c
+/// \brief Encodes metadata to be stored into Metadata Blocks
+//
+// Copyright (C) 2007 Lasse Collin
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "metadata_encoder.h"
+#include "block_encoder.h"
+
+
+struct lzma_coder_s {
+ enum {
+ SEQ_FLAGS,
+ SEQ_HEADER_METADATA_SIZE,
+ SEQ_TOTAL_SIZE,
+ SEQ_UNCOMPRESSED_SIZE,
+ SEQ_INDEX_COUNT,
+ SEQ_INDEX_TOTAL,
+ SEQ_INDEX_UNCOMPRESSED,
+ SEQ_EXTRA_ID,
+ SEQ_EXTRA_SIZE,
+ SEQ_EXTRA_DATA,
+ SEQ_END,
+ } sequence;
+
+ /// Position in variable-length integers
+ size_t pos;
+
+ /// Local copy of the Metadata structure. Note that we keep
+ /// a copy only of the main structure, not Index or Extra Records.
+ lzma_metadata metadata;
+
+ /// Number of Records in Index
+ size_t index_count;
+
+ /// Index Record currently being processed
+ const lzma_index *index_current;
+
+ /// Block encoder for the encoded Metadata
+ lzma_next_coder block_encoder;
+
+ /// True once everything except compression has been done.
+ bool end_was_reached;
+
+ /// buffer[buffer_pos] is the first byte that needs to be compressed.
+ size_t buffer_pos;
+
+ /// buffer[buffer_size] is the next position where a byte will be
+ /// written by process().
+ size_t buffer_size;
+
+ /// Temporary buffer to which encoded Metadata is written before
+ /// it is compressed.
+ uint8_t buffer[LZMA_BUFFER_SIZE];
+};
+
+
+#define write_vli(num) \
+do { \
+ const lzma_ret ret = lzma_vli_encode(num, &coder->pos, 1, \
+ coder->buffer, &coder->buffer_size, \
+ LZMA_BUFFER_SIZE); \
+ if (ret != LZMA_STREAM_END) \
+ return ret; \
+ coder->pos = 0; \
+} while (0)
+
+
+static lzma_ret
+process(lzma_coder *coder)
+{
+ while (coder->buffer_size < LZMA_BUFFER_SIZE)
+ switch (coder->sequence) {
+ case SEQ_FLAGS:
+ coder->buffer[coder->buffer_size] = 0;
+
+ if (coder->metadata.header_metadata_size
+ != LZMA_VLI_VALUE_UNKNOWN)
+ coder->buffer[coder->buffer_size] |= 0x01;
+
+ if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
+ coder->buffer[coder->buffer_size] |= 0x02;
+
+ if (coder->metadata.uncompressed_size
+ != LZMA_VLI_VALUE_UNKNOWN)
+ coder->buffer[coder->buffer_size] |= 0x04;
+
+ if (coder->index_count > 0)
+ coder->buffer[coder->buffer_size] |= 0x08;
+
+ if (coder->metadata.extra != NULL)
+ coder->buffer[coder->buffer_size] |= 0x80;
+
+ ++coder->buffer_size;
+ coder->sequence = SEQ_HEADER_METADATA_SIZE;
+ break;
+
+ case SEQ_HEADER_METADATA_SIZE:
+ if (coder->metadata.header_metadata_size
+ != LZMA_VLI_VALUE_UNKNOWN)
+ write_vli(coder->metadata.header_metadata_size);
+
+ coder->sequence = SEQ_TOTAL_SIZE;
+ break;
+
+ case SEQ_TOTAL_SIZE:
+ if (coder->metadata.total_size != LZMA_VLI_VALUE_UNKNOWN)
+ write_vli(coder->metadata.total_size);
+
+ coder->sequence = SEQ_UNCOMPRESSED_SIZE;
+ break;
+
+ case SEQ_UNCOMPRESSED_SIZE:
+ if (coder->metadata.uncompressed_size
+ != LZMA_VLI_VALUE_UNKNOWN)
+ write_vli(coder->metadata.uncompressed_size);
+
+ coder->sequence = SEQ_INDEX_COUNT;
+ break;
+
+ case SEQ_INDEX_COUNT:
+ if (coder->index_count == 0) {
+ if (coder->metadata.extra == NULL) {
+ coder->sequence = SEQ_END;
+ return LZMA_STREAM_END;
+ }
+
+ coder->sequence = SEQ_EXTRA_ID;
+ break;
+ }
+
+ write_vli(coder->index_count);
+ coder->sequence = SEQ_INDEX_TOTAL;
+ break;
+
+ case SEQ_INDEX_TOTAL:
+ write_vli(coder->index_current->total_size);
+
+ coder->index_current = coder->index_current->next;
+ if (coder->index_current == NULL) {
+ coder->index_current = coder->metadata.index;
+ coder->sequence = SEQ_INDEX_UNCOMPRESSED;
+ }
+
+ break;
+
+ case SEQ_INDEX_UNCOMPRESSED:
+ write_vli(coder->index_current->uncompressed_size);
+
+ coder->index_current = coder->index_current->next;
+ if (coder->index_current != NULL)
+ break;
+
+ if (coder->metadata.extra != NULL) {
+ coder->sequence = SEQ_EXTRA_ID;
+ break;
+ }
+
+ coder->sequence = SEQ_END;
+ return LZMA_STREAM_END;
+
+ case SEQ_EXTRA_ID: {
+ const lzma_ret ret = lzma_vli_encode(
+ coder->metadata.extra->id, &coder->pos, 1,
+ coder->buffer, &coder->buffer_size,
+ LZMA_BUFFER_SIZE);
+ switch (ret) {
+ case LZMA_OK:
+ break;
+
+ case LZMA_STREAM_END:
+ coder->pos = 0;
+
+ // Handle the special ID 0.
+ if (coder->metadata.extra->id == 0) {
+ coder->metadata.extra
+ = coder->metadata.extra->next;
+ if (coder->metadata.extra == NULL) {
+ coder->sequence = SEQ_END;
+ return LZMA_STREAM_END;
+ }
+
+ coder->sequence = SEQ_EXTRA_ID;
+
+ } else {
+ coder->sequence = SEQ_EXTRA_SIZE;
+ }
+
+ break;
+
+ default:
+ return ret;
+ }
+
+ break;
+ }
+
+ case SEQ_EXTRA_SIZE:
+ if (coder->metadata.extra->size >= (lzma_vli)(SIZE_MAX))
+ return LZMA_HEADER_ERROR;
+
+ write_vli(coder->metadata.extra->size);
+ coder->sequence = SEQ_EXTRA_DATA;
+ break;
+
+ case SEQ_EXTRA_DATA:
+ bufcpy(coder->metadata.extra->data, &coder->pos,
+ coder->metadata.extra->size,
+ coder->buffer, &coder->buffer_size,
+ LZMA_BUFFER_SIZE);
+
+ if ((size_t)(coder->metadata.extra->size) == coder->pos) {
+ coder->metadata.extra = coder->metadata.extra->next;
+ if (coder->metadata.extra == NULL) {
+ coder->sequence = SEQ_END;
+ return LZMA_STREAM_END;
+ }
+
+ coder->pos = 0;
+ coder->sequence = SEQ_EXTRA_ID;
+ }
+
+ break;
+
+ case SEQ_END:
+ // Everything is encoded. Let the compression code finish
+ // its work now.
+ return LZMA_STREAM_END;
+ }
+
+ return LZMA_OK;
+}
+
+
+static lzma_ret
+metadata_encode(lzma_coder *coder, lzma_allocator *allocator,
+ const uint8_t *restrict in lzma_attribute((unused)),
+ size_t *restrict in_pos lzma_attribute((unused)),
+ size_t in_size lzma_attribute((unused)), uint8_t *restrict out,
+ size_t *restrict out_pos, size_t out_size,
+ lzma_action action lzma_attribute((unused)))
+{
+ while (!coder->end_was_reached) {
+ // Flush coder->buffer if it isn't empty.
+ if (coder->buffer_size > 0) {
+ const lzma_ret ret = coder->block_encoder.code(
+ coder->block_encoder.coder, allocator,
+ coder->buffer, &coder->buffer_pos,
+ coder->buffer_size,
+ out, out_pos, out_size, LZMA_RUN);
+ if (coder->buffer_pos < coder->buffer_size
+ || ret != LZMA_OK)
+ return ret;
+
+ coder->buffer_pos = 0;
+ coder->buffer_size = 0;
+ }
+
+ const lzma_ret ret = process(coder);
+
+ switch (ret) {
+ case LZMA_OK:
+ break;
+
+ case LZMA_STREAM_END:
+ coder->end_was_reached = true;
+ break;
+
+ default:
+ return ret;
+ }
+ }
+
+ // Finish
+ return coder->block_encoder.code(coder->block_encoder.coder, allocator,
+ coder->buffer, &coder->buffer_pos, coder->buffer_size,
+ out, out_pos, out_size, LZMA_FINISH);
+}
+
+
+static void
+metadata_encoder_end(lzma_coder *coder, lzma_allocator *allocator)
+{
+ lzma_next_coder_end(&coder->block_encoder, allocator);
+ lzma_free(coder, allocator);
+ return;
+}
+
+
+static lzma_ret
+metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
+ lzma_options_block *options, const lzma_metadata *metadata)
+{
+ if (options == NULL || metadata == NULL)
+ return LZMA_PROG_ERROR;
+
+ if (next->coder == NULL) {
+ next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
+ if (next->coder == NULL)
+ return LZMA_MEM_ERROR;
+
+ next->code = &metadata_encode;
+ next->end = &metadata_encoder_end;
+ next->coder->block_encoder = LZMA_NEXT_CODER_INIT;
+ }
+
+ next->coder->sequence = SEQ_FLAGS;
+ next->coder->pos = 0;
+ next->coder->metadata = *metadata;
+ next->coder->index_count = 0;
+ next->coder->index_current = metadata->index;
+ next->coder->end_was_reached = false;
+ next->coder->buffer_pos = 0;
+ next->coder->buffer_size = 0;
+
+ // Count and validate the Index Records.
+ {
+ const lzma_index *i = metadata->index;
+ while (i != NULL) {
+ if (i->total_size > LZMA_VLI_VALUE_MAX
+ || i->uncompressed_size
+ > LZMA_VLI_VALUE_MAX)
+ return LZMA_PROG_ERROR;
+
+ ++next->coder->index_count;
+ i = i->next;
+ }
+ }
+
+ // Initialize the Block encoder.
+ return lzma_block_encoder_init(
+ &next->coder->block_encoder, allocator, options);
+}
+
+
+extern lzma_ret
+lzma_metadata_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
+ lzma_options_block *options, const lzma_metadata *metadata)
+{
+ lzma_next_coder_init(metadata_encoder_init, next, allocator,
+ options, metadata);
+}
+
+
+extern LZMA_API lzma_ret
+lzma_metadata_encoder(lzma_stream *strm, lzma_options_block *options,
+ const lzma_metadata *metadata)
+{
+ lzma_next_strm_init(strm, metadata_encoder_init, options, metadata);
+
+ strm->internal->supported_actions[LZMA_FINISH] = true;
+
+ return LZMA_OK;
+}
+
+
+extern LZMA_API lzma_vli
+lzma_metadata_size(const lzma_metadata *metadata)
+{
+ lzma_vli size = 1; // Metadata Flags
+
+ // Validate header_metadata_size, total_size, and uncompressed_size.
+ if (!lzma_vli_is_valid(metadata->header_metadata_size)
+ || !lzma_vli_is_valid(metadata->total_size)
+ || !lzma_vli_is_valid(metadata->uncompressed_size))
+ return 0;
+
+ // Add the sizes of these three fields.
+ if (metadata->header_metadata_size != LZMA_VLI_VALUE_UNKNOWN)
+ size += lzma_vli_size(metadata->header_metadata_size);
+
+ if (metadata->total_size != LZMA_VLI_VALUE_UNKNOWN)
+ size += lzma_vli_size(metadata->total_size);
+
+ if (metadata->uncompressed_size != LZMA_VLI_VALUE_UNKNOWN)
+ size += lzma_vli_size(metadata->uncompressed_size);
+
+ // Index
+ if (metadata->index != NULL) {
+ const lzma_index *i = metadata->index;
+ size_t count = 1;
+
+ do {
+ const size_t x = lzma_vli_size(i->total_size);
+ const size_t y = lzma_vli_size(i->uncompressed_size);
+ if (x == 0 || y == 0)
+ return 0;
+
+ size += x + y;
+ ++count;
+ i = i->next;
+
+ } while (i != NULL);
+
+ const size_t tmp = lzma_vli_size(count);
+ if (tmp == 0)
+ return 0;
+
+ size += tmp;
+ }
+
+ // Extra
+ {
+ const lzma_extra *e = metadata->extra;
+ while (e != NULL) {
+ // Validate the numbers.
+ if (e->id > LZMA_VLI_VALUE_MAX
+ || e->size >= (lzma_vli)(SIZE_MAX))
+ return 0;
+
+ // Add the sizes.
+ size += lzma_vli_size(e->id);
+ if (e->id != 0) {
+ size += lzma_vli_size(e->size);
+ size += e->size;
+ }
+
+ e = e->next;
+ }
+ }
+
+ return size;
+}