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 struct lzma_coder_s { 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 }; 59 60 61 static lzma_ret 62 block_encoder_init(lzma_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(lzma_coder *coder, 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 // Main loop 87 while (*out_pos < out_size) 88 switch (coder->sequence) { 89 case SEQ_STREAM_HEADER: 90 case SEQ_BLOCK_HEADER: 91 case SEQ_STREAM_FOOTER: 92 lzma_bufcpy(coder->buffer, &coder->buffer_pos, 93 coder->buffer_size, out, out_pos, out_size); 94 if (coder->buffer_pos < coder->buffer_size) 95 return LZMA_OK; 96 97 if (coder->sequence == SEQ_STREAM_FOOTER) 98 return LZMA_STREAM_END; 99 100 coder->buffer_pos = 0; 101 ++coder->sequence; 102 break; 103 104 case SEQ_BLOCK_INIT: { 105 if (*in_pos == in_size) { 106 // If we are requested to flush or finish the current 107 // Block, return LZMA_STREAM_END immediately since 108 // there's nothing to do. 109 if (action != LZMA_FINISH) 110 return action == LZMA_RUN 111 ? LZMA_OK : LZMA_STREAM_END; 112 113 // The application had used LZMA_FULL_FLUSH to finish 114 // the previous Block, but now wants to finish without 115 // encoding new data, or it is simply creating an 116 // empty Stream with no Blocks. 117 // 118 // Initialize the Index encoder, and continue to 119 // actually encoding the Index. 120 return_if_error(lzma_index_encoder_init( 121 &coder->index_encoder, allocator, 122 coder->index)); 123 coder->sequence = SEQ_INDEX_ENCODE; 124 break; 125 } 126 127 // Initialize the Block encoder unless it was already 128 // initialized by stream_encoder_init() or 129 // stream_encoder_update(). 130 if (!coder->block_encoder_is_initialized) 131 return_if_error(block_encoder_init(coder, allocator)); 132 133 // Make it false so that we don't skip the initialization 134 // with the next Block. 135 coder->block_encoder_is_initialized = false; 136 137 // Encode the Block Header. This shouldn't fail since we have 138 // already initialized the Block encoder. 139 if (lzma_block_header_encode(&coder->block_options, 140 coder->buffer) != LZMA_OK) 141 return LZMA_PROG_ERROR; 142 143 coder->buffer_size = coder->block_options.header_size; 144 coder->sequence = SEQ_BLOCK_HEADER; 145 break; 146 } 147 148 case SEQ_BLOCK_ENCODE: { 149 static const lzma_action convert[LZMA_ACTION_MAX + 1] = { 150 LZMA_RUN, 151 LZMA_SYNC_FLUSH, 152 LZMA_FINISH, 153 LZMA_FINISH, 154 LZMA_FINISH, 155 }; 156 157 const lzma_ret ret = coder->block_encoder.code( 158 coder->block_encoder.coder, allocator, 159 in, in_pos, in_size, 160 out, out_pos, out_size, convert[action]); 161 if (ret != LZMA_STREAM_END || action == LZMA_SYNC_FLUSH) 162 return ret; 163 164 // Add a new Index Record. 165 const lzma_vli unpadded_size = lzma_block_unpadded_size( 166 &coder->block_options); 167 assert(unpadded_size != 0); 168 return_if_error(lzma_index_append(coder->index, allocator, 169 unpadded_size, 170 coder->block_options.uncompressed_size)); 171 172 coder->sequence = SEQ_BLOCK_INIT; 173 break; 174 } 175 176 case SEQ_INDEX_ENCODE: { 177 // Call the Index encoder. It doesn't take any input, so 178 // those pointers can be NULL. 179 const lzma_ret ret = coder->index_encoder.code( 180 coder->index_encoder.coder, allocator, 181 NULL, NULL, 0, 182 out, out_pos, out_size, LZMA_RUN); 183 if (ret != LZMA_STREAM_END) 184 return ret; 185 186 // Encode the Stream Footer into coder->buffer. 187 const lzma_stream_flags stream_flags = { 188 .version = 0, 189 .backward_size = lzma_index_size(coder->index), 190 .check = coder->block_options.check, 191 }; 192 193 if (lzma_stream_footer_encode(&stream_flags, coder->buffer) 194 != LZMA_OK) 195 return LZMA_PROG_ERROR; 196 197 coder->buffer_size = LZMA_STREAM_HEADER_SIZE; 198 coder->sequence = SEQ_STREAM_FOOTER; 199 break; 200 } 201 202 default: 203 assert(0); 204 return LZMA_PROG_ERROR; 205 } 206 207 return LZMA_OK; 208 } 209 210 211 static void 212 stream_encoder_end(lzma_coder *coder, const lzma_allocator *allocator) 213 { 214 lzma_next_end(&coder->block_encoder, allocator); 215 lzma_next_end(&coder->index_encoder, allocator); 216 lzma_index_end(coder->index, allocator); 217 218 for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i) 219 lzma_free(coder->filters[i].options, allocator); 220 221 lzma_free(coder, allocator); 222 return; 223 } 224 225 226 static lzma_ret 227 stream_encoder_update(lzma_coder *coder, const lzma_allocator *allocator, 228 const lzma_filter *filters, 229 const lzma_filter *reversed_filters) 230 { 231 if (coder->sequence <= SEQ_BLOCK_INIT) { 232 // There is no incomplete Block waiting to be finished, 233 // thus we can change the whole filter chain. Start by 234 // trying to initialize the Block encoder with the new 235 // chain. This way we detect if the chain is valid. 236 coder->block_encoder_is_initialized = false; 237 coder->block_options.filters = (lzma_filter *)(filters); 238 const lzma_ret ret = block_encoder_init(coder, allocator); 239 coder->block_options.filters = coder->filters; 240 if (ret != LZMA_OK) 241 return ret; 242 243 coder->block_encoder_is_initialized = true; 244 245 } else if (coder->sequence <= SEQ_BLOCK_ENCODE) { 246 // We are in the middle of a Block. Try to update only 247 // the filter-specific options. 248 return_if_error(coder->block_encoder.update( 249 coder->block_encoder.coder, allocator, 250 filters, reversed_filters)); 251 } else { 252 // Trying to update the filter chain when we are already 253 // encoding Index or Stream Footer. 254 return LZMA_PROG_ERROR; 255 } 256 257 // Free the copy of the old chain and make a copy of the new chain. 258 for (size_t i = 0; coder->filters[i].id != LZMA_VLI_UNKNOWN; ++i) 259 lzma_free(coder->filters[i].options, allocator); 260 261 return lzma_filters_copy(filters, coder->filters, allocator); 262 } 263 264 265 static lzma_ret 266 stream_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator, 267 const lzma_filter *filters, lzma_check check) 268 { 269 lzma_next_coder_init(&stream_encoder_init, next, allocator); 270 271 if (filters == NULL) 272 return LZMA_PROG_ERROR; 273 274 if (next->coder == NULL) { 275 next->coder = lzma_alloc(sizeof(lzma_coder), allocator); 276 if (next->coder == NULL) 277 return LZMA_MEM_ERROR; 278 279 next->code = &stream_encode; 280 next->end = &stream_encoder_end; 281 next->update = &stream_encoder_update; 282 283 next->coder->filters[0].id = LZMA_VLI_UNKNOWN; 284 next->coder->block_encoder = LZMA_NEXT_CODER_INIT; 285 next->coder->index_encoder = LZMA_NEXT_CODER_INIT; 286 next->coder->index = NULL; 287 } 288 289 // Basic initializations 290 next->coder->sequence = SEQ_STREAM_HEADER; 291 next->coder->block_options.version = 0; 292 next->coder->block_options.check = check; 293 294 // Initialize the Index 295 lzma_index_end(next->coder->index, allocator); 296 next->coder->index = lzma_index_init(allocator); 297 if (next->coder->index == NULL) 298 return LZMA_MEM_ERROR; 299 300 // Encode the Stream Header 301 lzma_stream_flags stream_flags = { 302 .version = 0, 303 .check = check, 304 }; 305 return_if_error(lzma_stream_header_encode( 306 &stream_flags, next->coder->buffer)); 307 308 next->coder->buffer_pos = 0; 309 next->coder->buffer_size = LZMA_STREAM_HEADER_SIZE; 310 311 // Initialize the Block encoder. This way we detect unsupported 312 // filter chains when initializing the Stream encoder instead of 313 // giving an error after Stream Header has already written out. 314 return stream_encoder_update( 315 next->coder, allocator, filters, NULL); 316 } 317 318 319 extern LZMA_API(lzma_ret) 320 lzma_stream_encoder(lzma_stream *strm, 321 const lzma_filter *filters, lzma_check check) 322 { 323 lzma_next_strm_init(stream_encoder_init, strm, filters, check); 324 325 strm->internal->supported_actions[LZMA_RUN] = true; 326 strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true; 327 strm->internal->supported_actions[LZMA_FULL_FLUSH] = true; 328 strm->internal->supported_actions[LZMA_FULL_BARRIER] = true; 329 strm->internal->supported_actions[LZMA_FINISH] = true; 330 331 return LZMA_OK; 332 } 333