1 /////////////////////////////////////////////////////////////////////////////// 2 // 3 /// \file lzma_encoder.c 4 /// \brief LZMA encoder 5 /// 6 // Authors: Igor Pavlov 7 // Lasse Collin 8 // 9 // This file has been put into the public domain. 10 // You can do whatever you want with this file. 11 // 12 /////////////////////////////////////////////////////////////////////////////// 13 14 #include "lzma2_encoder.h" 15 #include "lzma_encoder_private.h" 16 #include "fastpos.h" 17 18 19 ///////////// 20 // Literal // 21 ///////////// 22 23 static inline void 24 literal_matched(lzma_range_encoder *rc, probability *subcoder, 25 uint32_t match_byte, uint32_t symbol) 26 { 27 uint32_t offset = 0x100; 28 symbol += UINT32_C(1) << 8; 29 30 do { 31 match_byte <<= 1; 32 const uint32_t match_bit = match_byte & offset; 33 const uint32_t subcoder_index 34 = offset + match_bit + (symbol >> 8); 35 const uint32_t bit = (symbol >> 7) & 1; 36 rc_bit(rc, &subcoder[subcoder_index], bit); 37 38 symbol <<= 1; 39 offset &= ~(match_byte ^ symbol); 40 41 } while (symbol < (UINT32_C(1) << 16)); 42 } 43 44 45 static inline void 46 literal(lzma_lzma1_encoder *coder, lzma_mf *mf, uint32_t position) 47 { 48 // Locate the literal byte to be encoded and the subcoder. 49 const uint8_t cur_byte = mf->buffer[ 50 mf->read_pos - mf->read_ahead]; 51 probability *subcoder = literal_subcoder(coder->literal, 52 coder->literal_context_bits, coder->literal_pos_mask, 53 position, mf->buffer[mf->read_pos - mf->read_ahead - 1]); 54 55 if (is_literal_state(coder->state)) { 56 // Previous LZMA-symbol was a literal. Encode a normal 57 // literal without a match byte. 58 rc_bittree(&coder->rc, subcoder, 8, cur_byte); 59 } else { 60 // Previous LZMA-symbol was a match. Use the last byte of 61 // the match as a "match byte". That is, compare the bits 62 // of the current literal and the match byte. 63 const uint8_t match_byte = mf->buffer[ 64 mf->read_pos - coder->reps[0] - 1 65 - mf->read_ahead]; 66 literal_matched(&coder->rc, subcoder, match_byte, cur_byte); 67 } 68 69 update_literal(coder->state); 70 } 71 72 73 ////////////////// 74 // Match length // 75 ////////////////// 76 77 static void 78 length_update_prices(lzma_length_encoder *lc, const uint32_t pos_state) 79 { 80 const uint32_t table_size = lc->table_size; 81 lc->counters[pos_state] = table_size; 82 83 const uint32_t a0 = rc_bit_0_price(lc->choice); 84 const uint32_t a1 = rc_bit_1_price(lc->choice); 85 const uint32_t b0 = a1 + rc_bit_0_price(lc->choice2); 86 const uint32_t b1 = a1 + rc_bit_1_price(lc->choice2); 87 uint32_t *const prices = lc->prices[pos_state]; 88 89 uint32_t i; 90 for (i = 0; i < table_size && i < LEN_LOW_SYMBOLS; ++i) 91 prices[i] = a0 + rc_bittree_price(lc->low[pos_state], 92 LEN_LOW_BITS, i); 93 94 for (; i < table_size && i < LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS; ++i) 95 prices[i] = b0 + rc_bittree_price(lc->mid[pos_state], 96 LEN_MID_BITS, i - LEN_LOW_SYMBOLS); 97 98 for (; i < table_size; ++i) 99 prices[i] = b1 + rc_bittree_price(lc->high, LEN_HIGH_BITS, 100 i - LEN_LOW_SYMBOLS - LEN_MID_SYMBOLS); 101 102 return; 103 } 104 105 106 static inline void 107 length(lzma_range_encoder *rc, lzma_length_encoder *lc, 108 const uint32_t pos_state, uint32_t len, const bool fast_mode) 109 { 110 assert(len <= MATCH_LEN_MAX); 111 len -= MATCH_LEN_MIN; 112 113 if (len < LEN_LOW_SYMBOLS) { 114 rc_bit(rc, &lc->choice, 0); 115 rc_bittree(rc, lc->low[pos_state], LEN_LOW_BITS, len); 116 } else { 117 rc_bit(rc, &lc->choice, 1); 118 len -= LEN_LOW_SYMBOLS; 119 120 if (len < LEN_MID_SYMBOLS) { 121 rc_bit(rc, &lc->choice2, 0); 122 rc_bittree(rc, lc->mid[pos_state], LEN_MID_BITS, len); 123 } else { 124 rc_bit(rc, &lc->choice2, 1); 125 len -= LEN_MID_SYMBOLS; 126 rc_bittree(rc, lc->high, LEN_HIGH_BITS, len); 127 } 128 } 129 130 // Only getoptimum uses the prices so don't update the table when 131 // in fast mode. 132 if (!fast_mode) 133 if (--lc->counters[pos_state] == 0) 134 length_update_prices(lc, pos_state); 135 } 136 137 138 /////////// 139 // Match // 140 /////////// 141 142 static inline void 143 match(lzma_lzma1_encoder *coder, const uint32_t pos_state, 144 const uint32_t distance, const uint32_t len) 145 { 146 update_match(coder->state); 147 148 length(&coder->rc, &coder->match_len_encoder, pos_state, len, 149 coder->fast_mode); 150 151 const uint32_t dist_slot = get_dist_slot(distance); 152 const uint32_t dist_state = get_dist_state(len); 153 rc_bittree(&coder->rc, coder->dist_slot[dist_state], 154 DIST_SLOT_BITS, dist_slot); 155 156 if (dist_slot >= DIST_MODEL_START) { 157 const uint32_t footer_bits = (dist_slot >> 1) - 1; 158 const uint32_t base = (2 | (dist_slot & 1)) << footer_bits; 159 const uint32_t dist_reduced = distance - base; 160 161 if (dist_slot < DIST_MODEL_END) { 162 // Careful here: base - dist_slot - 1 can be -1, but 163 // rc_bittree_reverse starts at probs[1], not probs[0]. 164 rc_bittree_reverse(&coder->rc, 165 coder->dist_special + base - dist_slot - 1, 166 footer_bits, dist_reduced); 167 } else { 168 rc_direct(&coder->rc, dist_reduced >> ALIGN_BITS, 169 footer_bits - ALIGN_BITS); 170 rc_bittree_reverse( 171 &coder->rc, coder->dist_align, 172 ALIGN_BITS, dist_reduced & ALIGN_MASK); 173 ++coder->align_price_count; 174 } 175 } 176 177 coder->reps[3] = coder->reps[2]; 178 coder->reps[2] = coder->reps[1]; 179 coder->reps[1] = coder->reps[0]; 180 coder->reps[0] = distance; 181 ++coder->match_price_count; 182 } 183 184 185 //////////////////// 186 // Repeated match // 187 //////////////////// 188 189 static inline void 190 rep_match(lzma_lzma1_encoder *coder, const uint32_t pos_state, 191 const uint32_t rep, const uint32_t len) 192 { 193 if (rep == 0) { 194 rc_bit(&coder->rc, &coder->is_rep0[coder->state], 0); 195 rc_bit(&coder->rc, 196 &coder->is_rep0_long[coder->state][pos_state], 197 len != 1); 198 } else { 199 const uint32_t distance = coder->reps[rep]; 200 rc_bit(&coder->rc, &coder->is_rep0[coder->state], 1); 201 202 if (rep == 1) { 203 rc_bit(&coder->rc, &coder->is_rep1[coder->state], 0); 204 } else { 205 rc_bit(&coder->rc, &coder->is_rep1[coder->state], 1); 206 rc_bit(&coder->rc, &coder->is_rep2[coder->state], 207 rep - 2); 208 209 if (rep == 3) 210 coder->reps[3] = coder->reps[2]; 211 212 coder->reps[2] = coder->reps[1]; 213 } 214 215 coder->reps[1] = coder->reps[0]; 216 coder->reps[0] = distance; 217 } 218 219 if (len == 1) { 220 update_short_rep(coder->state); 221 } else { 222 length(&coder->rc, &coder->rep_len_encoder, pos_state, len, 223 coder->fast_mode); 224 update_long_rep(coder->state); 225 } 226 } 227 228 229 ////////// 230 // Main // 231 ////////// 232 233 static void 234 encode_symbol(lzma_lzma1_encoder *coder, lzma_mf *mf, 235 uint32_t back, uint32_t len, uint32_t position) 236 { 237 const uint32_t pos_state = position & coder->pos_mask; 238 239 if (back == UINT32_MAX) { 240 // Literal i.e. eight-bit byte 241 assert(len == 1); 242 rc_bit(&coder->rc, 243 &coder->is_match[coder->state][pos_state], 0); 244 literal(coder, mf, position); 245 } else { 246 // Some type of match 247 rc_bit(&coder->rc, 248 &coder->is_match[coder->state][pos_state], 1); 249 250 if (back < REPS) { 251 // It's a repeated match i.e. the same distance 252 // has been used earlier. 253 rc_bit(&coder->rc, &coder->is_rep[coder->state], 1); 254 rep_match(coder, pos_state, back, len); 255 } else { 256 // Normal match 257 rc_bit(&coder->rc, &coder->is_rep[coder->state], 0); 258 match(coder, pos_state, back - REPS, len); 259 } 260 } 261 262 assert(mf->read_ahead >= len); 263 mf->read_ahead -= len; 264 } 265 266 267 static bool 268 encode_init(lzma_lzma1_encoder *coder, lzma_mf *mf) 269 { 270 assert(mf_position(mf) == 0); 271 assert(coder->uncomp_size == 0); 272 273 if (mf->read_pos == mf->read_limit) { 274 if (mf->action == LZMA_RUN) 275 return false; // We cannot do anything. 276 277 // We are finishing (we cannot get here when flushing). 278 assert(mf->write_pos == mf->read_pos); 279 assert(mf->action == LZMA_FINISH); 280 } else { 281 // Do the actual initialization. The first LZMA symbol must 282 // always be a literal. 283 mf_skip(mf, 1); 284 mf->read_ahead = 0; 285 rc_bit(&coder->rc, &coder->is_match[0][0], 0); 286 rc_bittree(&coder->rc, coder->literal[0], 8, mf->buffer[0]); 287 ++coder->uncomp_size; 288 } 289 290 // Initialization is done (except if empty file). 291 coder->is_initialized = true; 292 293 return true; 294 } 295 296 297 static void 298 encode_eopm(lzma_lzma1_encoder *coder, uint32_t position) 299 { 300 const uint32_t pos_state = position & coder->pos_mask; 301 rc_bit(&coder->rc, &coder->is_match[coder->state][pos_state], 1); 302 rc_bit(&coder->rc, &coder->is_rep[coder->state], 0); 303 match(coder, pos_state, UINT32_MAX, MATCH_LEN_MIN); 304 } 305 306 307 /// Number of bytes that a single encoding loop in lzma_lzma_encode() can 308 /// consume from the dictionary. This limit comes from lzma_lzma_optimum() 309 /// and may need to be updated if that function is significantly modified. 310 #define LOOP_INPUT_MAX (OPTS + 1) 311 312 313 extern lzma_ret 314 lzma_lzma_encode(lzma_lzma1_encoder *restrict coder, lzma_mf *restrict mf, 315 uint8_t *restrict out, size_t *restrict out_pos, 316 size_t out_size, uint32_t limit) 317 { 318 // Initialize the stream if no data has been encoded yet. 319 if (!coder->is_initialized && !encode_init(coder, mf)) 320 return LZMA_OK; 321 322 // Encode pending output bytes from the range encoder. 323 // At the start of the stream, encode_init() encodes one literal. 324 // Later there can be pending output only with LZMA1 because LZMA2 325 // ensures that there is always enough output space. Thus when using 326 // LZMA2, rc_encode() calls in this function will always return false. 327 if (rc_encode(&coder->rc, out, out_pos, out_size)) { 328 // We don't get here with LZMA2. 329 assert(limit == UINT32_MAX); 330 return LZMA_OK; 331 } 332 333 // If the range encoder was flushed in an earlier call to this 334 // function but there wasn't enough output buffer space, those 335 // bytes would have now been encoded by the above rc_encode() call 336 // and the stream has now been finished. This can only happen with 337 // LZMA1 as LZMA2 always provides enough output buffer space. 338 if (coder->is_flushed) { 339 assert(limit == UINT32_MAX); 340 return LZMA_STREAM_END; 341 } 342 343 while (true) { 344 // With LZMA2 we need to take care that compressed size of 345 // a chunk doesn't get too big. 346 // FIXME? Check if this could be improved. 347 if (limit != UINT32_MAX 348 && (mf->read_pos - mf->read_ahead >= limit 349 || *out_pos + rc_pending(&coder->rc) 350 >= LZMA2_CHUNK_MAX 351 - LOOP_INPUT_MAX)) 352 break; 353 354 // Check that there is some input to process. 355 if (mf->read_pos >= mf->read_limit) { 356 if (mf->action == LZMA_RUN) 357 return LZMA_OK; 358 359 if (mf->read_ahead == 0) 360 break; 361 } 362 363 // Get optimal match (repeat position and length). 364 // Value ranges for pos: 365 // - [0, REPS): repeated match 366 // - [REPS, UINT32_MAX): 367 // match at (pos - REPS) 368 // - UINT32_MAX: not a match but a literal 369 // Value ranges for len: 370 // - [MATCH_LEN_MIN, MATCH_LEN_MAX] 371 uint32_t len; 372 uint32_t back; 373 374 if (coder->fast_mode) 375 lzma_lzma_optimum_fast(coder, mf, &back, &len); 376 else 377 lzma_lzma_optimum_normal(coder, mf, &back, &len, 378 (uint32_t)(coder->uncomp_size)); 379 380 encode_symbol(coder, mf, back, len, 381 (uint32_t)(coder->uncomp_size)); 382 383 // If output size limiting is active (out_limit != 0), check 384 // if encoding this LZMA symbol would make the output size 385 // exceed the specified limit. 386 if (coder->out_limit != 0 && rc_encode_dummy( 387 &coder->rc, coder->out_limit)) { 388 // The most recent LZMA symbol would make the output 389 // too big. Throw it away. 390 rc_forget(&coder->rc); 391 392 // FIXME: Tell the LZ layer to not read more input as 393 // it would be waste of time. This doesn't matter if 394 // output-size-limited encoding is done with a single 395 // call though. 396 397 break; 398 } 399 400 // This symbol will be encoded so update the uncompressed size. 401 coder->uncomp_size += len; 402 403 // Encode the LZMA symbol. 404 if (rc_encode(&coder->rc, out, out_pos, out_size)) { 405 // Once again, this can only happen with LZMA1. 406 assert(limit == UINT32_MAX); 407 return LZMA_OK; 408 } 409 } 410 411 // Make the uncompressed size available to the application. 412 if (coder->uncomp_size_ptr != NULL) 413 *coder->uncomp_size_ptr = coder->uncomp_size; 414 415 // LZMA2 doesn't use EOPM at LZMA level. 416 // 417 // Plain LZMA streams without EOPM aren't supported except when 418 // output size limiting is enabled. 419 if (coder->use_eopm) 420 encode_eopm(coder, (uint32_t)(coder->uncomp_size)); 421 422 // Flush the remaining bytes from the range encoder. 423 rc_flush(&coder->rc); 424 425 // Copy the remaining bytes to the output buffer. If there 426 // isn't enough output space, we will copy out the remaining 427 // bytes on the next call to this function. 428 if (rc_encode(&coder->rc, out, out_pos, out_size)) { 429 // This cannot happen with LZMA2. 430 assert(limit == UINT32_MAX); 431 432 coder->is_flushed = true; 433 return LZMA_OK; 434 } 435 436 return LZMA_STREAM_END; 437 } 438 439 440 static lzma_ret 441 lzma_encode(void *coder, lzma_mf *restrict mf, 442 uint8_t *restrict out, size_t *restrict out_pos, 443 size_t out_size) 444 { 445 // Plain LZMA has no support for sync-flushing. 446 if (unlikely(mf->action == LZMA_SYNC_FLUSH)) 447 return LZMA_OPTIONS_ERROR; 448 449 return lzma_lzma_encode(coder, mf, out, out_pos, out_size, UINT32_MAX); 450 } 451 452 453 static lzma_ret 454 lzma_lzma_set_out_limit( 455 void *coder_ptr, uint64_t *uncomp_size, uint64_t out_limit) 456 { 457 // Minimum output size is 5 bytes but that cannot hold any output 458 // so we use 6 bytes. 459 if (out_limit < 6) 460 return LZMA_BUF_ERROR; 461 462 lzma_lzma1_encoder *coder = coder_ptr; 463 coder->out_limit = out_limit; 464 coder->uncomp_size_ptr = uncomp_size; 465 coder->use_eopm = false; 466 return LZMA_OK; 467 } 468 469 470 //////////////////// 471 // Initialization // 472 //////////////////// 473 474 static bool 475 is_options_valid(const lzma_options_lzma *options) 476 { 477 // Validate some of the options. LZ encoder validates nice_len too 478 // but we need a valid value here earlier. 479 return is_lclppb_valid(options) 480 && options->nice_len >= MATCH_LEN_MIN 481 && options->nice_len <= MATCH_LEN_MAX 482 && (options->mode == LZMA_MODE_FAST 483 || options->mode == LZMA_MODE_NORMAL); 484 } 485 486 487 static void 488 set_lz_options(lzma_lz_options *lz_options, const lzma_options_lzma *options) 489 { 490 // LZ encoder initialization does the validation for these so we 491 // don't need to validate here. 492 lz_options->before_size = OPTS; 493 lz_options->dict_size = options->dict_size; 494 lz_options->after_size = LOOP_INPUT_MAX; 495 lz_options->match_len_max = MATCH_LEN_MAX; 496 lz_options->nice_len = my_max(mf_get_hash_bytes(options->mf), 497 options->nice_len); 498 lz_options->match_finder = options->mf; 499 lz_options->depth = options->depth; 500 lz_options->preset_dict = options->preset_dict; 501 lz_options->preset_dict_size = options->preset_dict_size; 502 return; 503 } 504 505 506 static void 507 length_encoder_reset(lzma_length_encoder *lencoder, 508 const uint32_t num_pos_states, const bool fast_mode) 509 { 510 bit_reset(lencoder->choice); 511 bit_reset(lencoder->choice2); 512 513 for (size_t pos_state = 0; pos_state < num_pos_states; ++pos_state) { 514 bittree_reset(lencoder->low[pos_state], LEN_LOW_BITS); 515 bittree_reset(lencoder->mid[pos_state], LEN_MID_BITS); 516 } 517 518 bittree_reset(lencoder->high, LEN_HIGH_BITS); 519 520 if (!fast_mode) 521 for (uint32_t pos_state = 0; pos_state < num_pos_states; 522 ++pos_state) 523 length_update_prices(lencoder, pos_state); 524 525 return; 526 } 527 528 529 extern lzma_ret 530 lzma_lzma_encoder_reset(lzma_lzma1_encoder *coder, 531 const lzma_options_lzma *options) 532 { 533 if (!is_options_valid(options)) 534 return LZMA_OPTIONS_ERROR; 535 536 coder->pos_mask = (1U << options->pb) - 1; 537 coder->literal_context_bits = options->lc; 538 coder->literal_pos_mask = (1U << options->lp) - 1; 539 540 // Range coder 541 rc_reset(&coder->rc); 542 543 // State 544 coder->state = STATE_LIT_LIT; 545 for (size_t i = 0; i < REPS; ++i) 546 coder->reps[i] = 0; 547 548 literal_init(coder->literal, options->lc, options->lp); 549 550 // Bit encoders 551 for (size_t i = 0; i < STATES; ++i) { 552 for (size_t j = 0; j <= coder->pos_mask; ++j) { 553 bit_reset(coder->is_match[i][j]); 554 bit_reset(coder->is_rep0_long[i][j]); 555 } 556 557 bit_reset(coder->is_rep[i]); 558 bit_reset(coder->is_rep0[i]); 559 bit_reset(coder->is_rep1[i]); 560 bit_reset(coder->is_rep2[i]); 561 } 562 563 for (size_t i = 0; i < FULL_DISTANCES - DIST_MODEL_END; ++i) 564 bit_reset(coder->dist_special[i]); 565 566 // Bit tree encoders 567 for (size_t i = 0; i < DIST_STATES; ++i) 568 bittree_reset(coder->dist_slot[i], DIST_SLOT_BITS); 569 570 bittree_reset(coder->dist_align, ALIGN_BITS); 571 572 // Length encoders 573 length_encoder_reset(&coder->match_len_encoder, 574 1U << options->pb, coder->fast_mode); 575 576 length_encoder_reset(&coder->rep_len_encoder, 577 1U << options->pb, coder->fast_mode); 578 579 // Price counts are incremented every time appropriate probabilities 580 // are changed. price counts are set to zero when the price tables 581 // are updated, which is done when the appropriate price counts have 582 // big enough value, and lzma_mf.read_ahead == 0 which happens at 583 // least every OPTS (a few thousand) possible price count increments. 584 // 585 // By resetting price counts to UINT32_MAX / 2, we make sure that the 586 // price tables will be initialized before they will be used (since 587 // the value is definitely big enough), and that it is OK to increment 588 // price counts without risk of integer overflow (since UINT32_MAX / 2 589 // is small enough). The current code doesn't increment price counts 590 // before initializing price tables, but it maybe done in future if 591 // we add support for saving the state between LZMA2 chunks. 592 coder->match_price_count = UINT32_MAX / 2; 593 coder->align_price_count = UINT32_MAX / 2; 594 595 coder->opts_end_index = 0; 596 coder->opts_current_index = 0; 597 598 return LZMA_OK; 599 } 600 601 602 extern lzma_ret 603 lzma_lzma_encoder_create(void **coder_ptr, const lzma_allocator *allocator, 604 lzma_vli id, const lzma_options_lzma *options, 605 lzma_lz_options *lz_options) 606 { 607 assert(id == LZMA_FILTER_LZMA1 || id == LZMA_FILTER_LZMA1EXT 608 || id == LZMA_FILTER_LZMA2); 609 610 // Allocate lzma_lzma1_encoder if it wasn't already allocated. 611 if (*coder_ptr == NULL) { 612 *coder_ptr = lzma_alloc(sizeof(lzma_lzma1_encoder), allocator); 613 if (*coder_ptr == NULL) 614 return LZMA_MEM_ERROR; 615 } 616 617 lzma_lzma1_encoder *coder = *coder_ptr; 618 619 // Set compression mode. Note that we haven't validated the options 620 // yet. Invalid options will get rejected by lzma_lzma_encoder_reset() 621 // call at the end of this function. 622 switch (options->mode) { 623 case LZMA_MODE_FAST: 624 coder->fast_mode = true; 625 break; 626 627 case LZMA_MODE_NORMAL: { 628 coder->fast_mode = false; 629 630 // Set dist_table_size. 631 // Round the dictionary size up to next 2^n. 632 // 633 // Currently the maximum encoder dictionary size 634 // is 1.5 GiB due to lz_encoder.c and here we need 635 // to be below 2 GiB to make the rounded up value 636 // fit in an uint32_t and avoid an infite while-loop 637 // (and undefined behavior due to a too large shift). 638 // So do the same check as in LZ encoder, 639 // limiting to 1.5 GiB. 640 if (options->dict_size > (UINT32_C(1) << 30) 641 + (UINT32_C(1) << 29)) 642 return LZMA_OPTIONS_ERROR; 643 644 uint32_t log_size = 0; 645 while ((UINT32_C(1) << log_size) < options->dict_size) 646 ++log_size; 647 648 coder->dist_table_size = log_size * 2; 649 650 // Length encoders' price table size 651 const uint32_t nice_len = my_max( 652 mf_get_hash_bytes(options->mf), 653 options->nice_len); 654 655 coder->match_len_encoder.table_size 656 = nice_len + 1 - MATCH_LEN_MIN; 657 coder->rep_len_encoder.table_size 658 = nice_len + 1 - MATCH_LEN_MIN; 659 break; 660 } 661 662 default: 663 return LZMA_OPTIONS_ERROR; 664 } 665 666 // We don't need to write the first byte as literal if there is 667 // a non-empty preset dictionary. encode_init() wouldn't even work 668 // if there is a non-empty preset dictionary, because encode_init() 669 // assumes that position is zero and previous byte is also zero. 670 coder->is_initialized = options->preset_dict != NULL 671 && options->preset_dict_size > 0; 672 coder->is_flushed = false; 673 coder->uncomp_size = 0; 674 coder->uncomp_size_ptr = NULL; 675 676 // Output size limitting is disabled by default. 677 coder->out_limit = 0; 678 679 // Determine if end marker is wanted: 680 // - It is never used with LZMA2. 681 // - It is always used with LZMA_FILTER_LZMA1 (unless 682 // lzma_lzma_set_out_limit() is called later). 683 // - LZMA_FILTER_LZMA1EXT has a flag for it in the options. 684 coder->use_eopm = (id == LZMA_FILTER_LZMA1); 685 if (id == LZMA_FILTER_LZMA1EXT) { 686 // Check if unsupported flags are present. 687 if (options->ext_flags & ~LZMA_LZMA1EXT_ALLOW_EOPM) 688 return LZMA_OPTIONS_ERROR; 689 690 coder->use_eopm = (options->ext_flags 691 & LZMA_LZMA1EXT_ALLOW_EOPM) != 0; 692 693 // TODO? As long as there are no filters that change the size 694 // of the data, it is enough to look at lzma_stream.total_in 695 // after encoding has been finished to know the uncompressed 696 // size of the LZMA1 stream. But in the future there could be 697 // filters that change the size of the data and then total_in 698 // doesn't work as the LZMA1 stream size might be different 699 // due to another filter in the chain. The problem is simple 700 // to solve: Add another flag to ext_flags and then set 701 // coder->uncomp_size_ptr to the address stored in 702 // lzma_options_lzma.reserved_ptr2 (or _ptr1). 703 } 704 705 set_lz_options(lz_options, options); 706 707 return lzma_lzma_encoder_reset(coder, options); 708 } 709 710 711 static lzma_ret 712 lzma_encoder_init(lzma_lz_encoder *lz, const lzma_allocator *allocator, 713 lzma_vli id, const void *options, lzma_lz_options *lz_options) 714 { 715 lz->code = &lzma_encode; 716 lz->set_out_limit = &lzma_lzma_set_out_limit; 717 return lzma_lzma_encoder_create( 718 &lz->coder, allocator, id, options, lz_options); 719 } 720 721 722 extern lzma_ret 723 lzma_lzma_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator, 724 const lzma_filter_info *filters) 725 { 726 return lzma_lz_encoder_init( 727 next, allocator, filters, &lzma_encoder_init); 728 } 729 730 731 extern uint64_t 732 lzma_lzma_encoder_memusage(const void *options) 733 { 734 if (!is_options_valid(options)) 735 return UINT64_MAX; 736 737 lzma_lz_options lz_options; 738 set_lz_options(&lz_options, options); 739 740 const uint64_t lz_memusage = lzma_lz_encoder_memusage(&lz_options); 741 if (lz_memusage == UINT64_MAX) 742 return UINT64_MAX; 743 744 return (uint64_t)(sizeof(lzma_lzma1_encoder)) + lz_memusage; 745 } 746 747 748 extern bool 749 lzma_lzma_lclppb_encode(const lzma_options_lzma *options, uint8_t *byte) 750 { 751 if (!is_lclppb_valid(options)) 752 return true; 753 754 *byte = (options->pb * 5 + options->lp) * 9 + options->lc; 755 assert(*byte <= (4 * 5 + 4) * 9 + 8); 756 757 return false; 758 } 759 760 761 #ifdef HAVE_ENCODER_LZMA1 762 extern lzma_ret 763 lzma_lzma_props_encode(const void *options, uint8_t *out) 764 { 765 if (options == NULL) 766 return LZMA_PROG_ERROR; 767 768 const lzma_options_lzma *const opt = options; 769 770 if (lzma_lzma_lclppb_encode(opt, out)) 771 return LZMA_PROG_ERROR; 772 773 write32le(out + 1, opt->dict_size); 774 775 return LZMA_OK; 776 } 777 #endif 778 779 780 extern LZMA_API(lzma_bool) 781 lzma_mode_is_supported(lzma_mode mode) 782 { 783 return mode == LZMA_MODE_FAST || mode == LZMA_MODE_NORMAL; 784 } 785