pd.if.org Git - zpackage/blob - lzma/common/stream_encoder.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       stream_encoder.c
   4 /// \brief      Encodes .xz Streams
   5 //
   6 //  Author:     Lasse Collin
   7 //
   8 //  This file has been put into the public domain.
   9 //  You can do whatever you want with this file.
  10 //
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #include "block_encoder.h"
  14 #include "index_encoder.h"
  15
  16
  17 typedef struct {
  18         enum {
  19                 SEQ_STREAM_HEADER,
  20                 SEQ_BLOCK_INIT,
  21                 SEQ_BLOCK_HEADER,
  22                 SEQ_BLOCK_ENCODE,
  23                 SEQ_INDEX_ENCODE,
  24                 SEQ_STREAM_FOOTER,
  25         } sequence;
  26
  27         /// True if Block encoder has been initialized by
  28         /// stream_encoder_init() or stream_encoder_update()
  29         /// and thus doesn't need to be initialized in stream_encode().
  30         bool block_encoder_is_initialized;
  31
  32         /// Block
  33         lzma_next_coder block_encoder;
  34
  35         /// Options for the Block encoder
  36         lzma_block block_options;
  37
  38         /// The filter chain currently in use
  39         lzma_filter filters[LZMA_FILTERS_MAX + 1];
  40
  41         /// Index encoder. This is separate from Block encoder, because this
  42         /// doesn't take much memory, and when encoding multiple Streams
  43         /// with the same encoding options we avoid reallocating memory.
  44         lzma_next_coder index_encoder;
  45
  46         /// Index to hold sizes of the Blocks
  47         lzma_index *index;
  48
  49         /// Read position in buffer[]
  50         size_t buffer_pos;
  51
  52         /// Total number of bytes in buffer[]
  53         size_t buffer_size;
  54
  55         /// Buffer to hold Stream Header, Block Header, and Stream Footer.
  56         /// Block Header has biggest maximum size.
  57         uint8_t buffer[LZMA_BLOCK_HEADER_SIZE_MAX];
  58 } lzma_stream_coder;
  59
  60
  61 static lzma_ret
  62 block_encoder_init(lzma_stream_coder *coder, const lzma_allocator *allocator)
  63 {
  64         // Prepare the Block options. Even though Block encoder doesn't need
  65         // compressed_size, uncompressed_size, and header_size to be
  66         // initialized, it is a good idea to do it here, because this way
  67         // we catch if someone gave us Filter ID that cannot be used in
  68         // Blocks/Streams.
  69         coder->block_options.compressed_size = LZMA_VLI_UNKNOWN;
  70         coder->block_options.uncompressed_size = LZMA_VLI_UNKNOWN;
  71
  72         return_if_error(lzma_block_header_size(&coder->block_options));
  73
  74         // Initialize the actual Block encoder.
  75         return lzma_block_encoder_init(&coder->block_encoder, allocator,
  76                         &coder->block_options);
  77 }
  78
  79
  80 static lzma_ret
  81 stream_encode(void *coder_ptr, const lzma_allocator *allocator,
  82                 const uint8_t *restrict in, size_t *restrict in_pos,
  83                 size_t in_size, uint8_t *restrict out,
  84                 size_t *restrict out_pos, size_t out_size, lzma_action action)
  85 {
  86         lzma_stream_coder *coder = coder_ptr;
  87
  88         // Main loop
  89         while (*out_pos < out_size)
  90         switch (coder->sequence) {
  91         case SEQ_STREAM_HEADER:
  92         case SEQ_BLOCK_HEADER:
  93         case SEQ_STREAM_FOOTER:
  94                 lzma_bufcpy(coder->buffer, &coder->buffer_pos,
  95                                 coder->buffer_size, out, out_pos, out_size);
  96                 if (coder->buffer_pos < coder->buffer_size)
  97                         return LZMA_OK;
  98
  99                 if (coder->sequence == SEQ_STREAM_FOOTER)
 100                         return LZMA_STREAM_END;
 101
 102                 coder->buffer_pos = 0;
 103                 ++coder->sequence;
 104                 break;
 105
 106         case SEQ_BLOCK_INIT: {
 107                 if (*in_pos == in_size) {
 108                         // If we are requested to flush or finish the current
 109                         // Block, return LZMA_STREAM_END immediately since
 110                         // there's nothing to do.
 111                         if (action != LZMA_FINISH)
 112                                 return action == LZMA_RUN
 113                                                 ? LZMA_OK : LZMA_STREAM_END;
 114
 115                         // The application had used LZMA_FULL_FLUSH to finish
 116                         // the previous Block, but now wants to finish without
 117                         // encoding new data, or it is simply creating an
 118                         // empty Stream with no Blocks.
 119                         //
 120                         // Initialize the Index encoder, and continue to
 121                         // actually encoding the Index.
 122                         return_if_error(lzma_index_encoder_init(
 123                                         &coder->index_encoder, allocator,
 124                                         coder->index));
 125                         coder->sequence = SEQ_INDEX_ENCODE;
 126                         break;
 127                 }
 128
 129                 // Initialize the Block encoder unless it was already
 130                 // initialized by stream_encoder_init() or
 131                 // stream_encoder_update().
 132                 if (!coder->block_encoder_is_initialized)
 133                         return_if_error(block_encoder_init(coder, allocator));
 134
 135                 // Make it false so that we don't skip the initialization
 136                 // with the next Block.
 137                 coder->block_encoder_is_initialized = false;
 138
 139                 // Encode the Block Header. This shouldn't fail since we have
 140                 // already initialized the Block encoder.
 141                 if (lzma_block_header_encode(&coder->block_options,
 142                                 coder->buffer) != LZMA_OK)
 143                         return LZMA_PROG_ERROR;
 144
 145                 coder->buffer_size = coder->block_options.header_size;
 146                 coder->sequence = SEQ_BLOCK_HEADER;
 147                 break;
 148         }
 149
 150         case SEQ_BLOCK_ENCODE: {
 151                 static const lzma_action convert[LZMA_ACTION_MAX + 1] = {
 152                         LZMA_RUN,
 153                         LZMA_SYNC_FLUSH,
 154                         LZMA_FINISH,
 155                         LZMA_FINISH,
 156                         LZMA_FINISH,
 157                 };
 158
 159                 const lzma_ret ret = coder->block_encoder.code(
 160                                 coder->block_encoder.coder, allocator,
 161                                 in, in_pos, in_size,
 162                                 out, out_pos, out_size, convert[action]);
 163                 if (ret != LZMA_STREAM_END || action == LZMA_SYNC_FLUSH)
 164                         return ret;
 165
 166                 // Add a new Index Record.
 167                 const lzma_vli unpadded_size = lzma_block_unpadded_size(
 168                                 &coder->block_options);
 169                 assert(unpadded_size != 0);
 170                 return_if_error(lzma_index_append(coder->index, allocator,
 171                                 unpadded_size,
 172                                 coder->block_options.uncompressed_size));
 173
 174                 coder->sequence = SEQ_BLOCK_INIT;
 175                 break;
 176         }
 177
 178         case SEQ_INDEX_ENCODE: {
 179                 // Call the Index encoder. It doesn't take any input, so
 180                 // those pointers can be NULL.
 181                 const lzma_ret ret = coder->index_encoder.code(
 182                                 coder->index_encoder.coder, allocator,
 183                                 NULL, NULL, 0,
 184                                 out, out_pos, out_size, LZMA_RUN);
 185                 if (ret != LZMA_STREAM_END)
 186                         return ret;
 187
 188                 // Encode the Stream Footer into coder->buffer.
 189                 const lzma_stream_flags stream_flags = {
 190                         .version = 0,
 191                         .backward_size = lzma_index_size(coder->index),
 192                         .check = coder->block_options.check,
 193                 };
 194
 195                 if (lzma_stream_footer_encode(&stream_flags, coder->buffer)
 196                                 != LZMA_OK)
 197                         return LZMA_PROG_ERROR;
 198
 199                 coder->buffer_size = LZMA_STREAM_HEADER_SIZE;
 200                 coder->sequence = SEQ_STREAM_FOOTER;
 201                 break;
 202         }
 203
 204         default:
 205                 assert(0);
 206                 return LZMA_PROG_ERROR;
 207         }
 208
 209         return LZMA_OK;
 210 }
 211
 212
 213 static void
 214 stream_encoder_end(void *coder_ptr, const lzma_allocator *allocator)
 215 {
 216         lzma_stream_coder *coder = coder_ptr;
 217
 218         lzma_next_end(&coder->block_encoder, allocator);
 219         lzma_next_end(&coder->index_encoder, allocator);
 220         lzma_index_end(coder->index, allocator);
 221
 222         for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
 223                 lzma_free(coder->filters[i].options, allocator);
 224
 225         lzma_free(coder, allocator);
 226         return;
 227 }
 228
 229
 230 static lzma_ret
 231 stream_encoder_update(void *coder_ptr, const lzma_allocator *allocator,
 232                 const lzma_filter *filters,
 233                 const lzma_filter *reversed_filters)
 234 {
 235         lzma_stream_coder *coder = coder_ptr;
 236
 237         if (coder->sequence <= SEQ_BLOCK_INIT) {
 238                 // There is no incomplete Block waiting to be finished,
 239                 // thus we can change the whole filter chain. Start by
 240                 // trying to initialize the Block encoder with the new
 241                 // chain. This way we detect if the chain is valid.
 242                 coder->block_encoder_is_initialized = false;
 243                 coder->block_options.filters = (lzma_filter *)(filters);
 244                 const lzma_ret ret = block_encoder_init(coder, allocator);
 245                 coder->block_options.filters = coder->filters;
 246                 if (ret != LZMA_OK)
 247                         return ret;
 248
 249                 coder->block_encoder_is_initialized = true;
 250
 251         } else if (coder->sequence <= SEQ_BLOCK_ENCODE) {
 252                 // We are in the middle of a Block. Try to update only
 253                 // the filter-specific options.
 254                 return_if_error(coder->block_encoder.update(
 255                                 coder->block_encoder.coder, allocator,
 256                                 filters, reversed_filters));
 257         } else {
 258                 // Trying to update the filter chain when we are already
 259                 // encoding Index or Stream Footer.
 260                 return LZMA_PROG_ERROR;
 261         }
 262
 263         // Free the copy of the old chain and make a copy of the new chain.
 264         for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i)
 265                 lzma_free(coder->filters[i].options, allocator);
 266
 267         return lzma_filters_copy(filters, coder->filters, allocator);
 268 }
 269
 270
 271 static lzma_ret
 272 stream_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
 273                 const lzma_filter *filters, lzma_check check)
 274 {
 275         lzma_next_coder_init(&stream_encoder_init, next, allocator);
 276
 277         if (filters == NULL)
 278                 return LZMA_PROG_ERROR;
 279
 280         lzma_stream_coder *coder = next->coder;
 281
 282         if (coder == NULL) {
 283                 coder = lzma_alloc(sizeof(lzma_stream_coder), allocator);
 284                 if (coder == NULL)
 285                         return LZMA_MEM_ERROR;
 286
 287                 next->coder = coder;
 288                 next->code = &stream_encode;
 289                 next->end = &stream_encoder_end;
 290                 next->update = &stream_encoder_update;
 291
 292                 coder->filters[0].id = LZMA_VLI_UNKNOWN;
 293                 coder->block_encoder = LZMA_NEXT_CODER_INIT;
 294                 coder->index_encoder = LZMA_NEXT_CODER_INIT;
 295                 coder->index = NULL;
 296         }
 297
 298         // Basic initializations
 299         coder->sequence = SEQ_STREAM_HEADER;
 300         coder->block_options.version = 0;
 301         coder->block_options.check = check;
 302
 303         // Initialize the Index
 304         lzma_index_end(coder->index, allocator);
 305         coder->index = lzma_index_init(allocator);
 306         if (coder->index == NULL)
 307                 return LZMA_MEM_ERROR;
 308
 309         // Encode the Stream Header
 310         lzma_stream_flags stream_flags = {
 311                 .version = 0,
 312                 .check = check,
 313         };
 314         return_if_error(lzma_stream_header_encode(
 315                         &stream_flags, coder->buffer));
 316
 317         coder->buffer_pos = 0;
 318         coder->buffer_size = LZMA_STREAM_HEADER_SIZE;
 319
 320         // Initialize the Block encoder. This way we detect unsupported
 321         // filter chains when initializing the Stream encoder instead of
 322         // giving an error after Stream Header has already written out.
 323         return stream_encoder_update(coder, allocator, filters, NULL);
 324 }
 325
 326
 327 extern LZMA_API(lzma_ret)
 328 lzma_stream_encoder(lzma_stream *strm,
 329                 const lzma_filter *filters, lzma_check check)
 330 {
 331         lzma_next_strm_init(stream_encoder_init, strm, filters, check);
 332
 333         strm->internal->supported_actions[LZMA_RUN] = true;
 334         strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
 335         strm->internal->supported_actions[LZMA_FULL_FLUSH] = true;
 336         strm->internal->supported_actions[LZMA_FULL_BARRIER] = true;
 337         strm->internal->supported_actions[LZMA_FINISH] = true;
 338
 339         return LZMA_OK;
 340 }