Lines Matching +full:full +full:- +full:size
5 * Igor Pavlov <https://7-zip.org/>
32 * start <= pos <= full <= end
35 * In multi-call mode, also these are true:
36 * end == size
37 * size <= size_max
38 * allocated <= size
40 * Most of these variables are size_t to support single-call mode,
55 * How full dictionary is. This is used to detect corrupt input that
58 size_t full; member
64 * End of the dictionary buffer. In multi-call mode, this is
65 * the same as the dictionary size. In single-call mode, this
66 * indicates the size of the output buffer.
71 * Size of the dictionary as specified in Block Header. This is used
72 * together with "full" to detect corrupt input that would make us
75 uint32_t size; member
78 * Maximum allowed dictionary size in multi-call mode.
79 * This is ignored in single-call mode.
86 * size_max is always the same as the allocated size.)
107 * temp.buf or the caller-provided input buffer.
122 /* Probabilities for match lengths 2-9 */
125 /* Probabilities for match lengths 10-17 */
128 /* Probabilities for match lengths 18-273 */
155 uint32_t literal_pos_mask; /* (1 << lp) - 1 */
156 uint32_t pos_mask; /* (1 << pb) - 1 */
158 /* If 1, it's a match. Otherwise it's a single 8-bit literal. */
196 uint16_t dist_special[FULL_DISTANCES - DIST_MODEL_END];
228 /* Next position after decoding the compressed size of the chunk. */
231 /* Uncompressed size of LZMA chunk (2 MiB at maximum) */
235 * Compressed size of LZMA chunk or compressed/uncompressed
236 * size of uncompressed chunk (64 KiB at maximum)
259 * The order below is important on x86 to reduce code size and
261 * including lzma.pos_mask are in the first 128 bytes on x86-32,
263 * variables. On x86-64, fewer variables fit into the first 128
277 uint32_t size; member
287 * Reset the dictionary state. When in single-call mode, set up the beginning
292 if (DEC_IS_SINGLE(dict->mode)) { in dict_reset()
293 dict->buf = b->out + b->out_pos; in dict_reset()
294 dict->end = b->out_size - b->out_pos; in dict_reset()
297 dict->start = 0; in dict_reset()
298 dict->pos = 0; in dict_reset()
299 dict->limit = 0; in dict_reset()
300 dict->full = 0; in dict_reset()
306 if (dict->end - dict->pos <= out_max) in dict_limit()
307 dict->limit = dict->end; in dict_limit()
309 dict->limit = dict->pos + out_max; in dict_limit()
315 return dict->pos < dict->limit; in dict_has_space()
321 * still empty. This special case is needed for single-call decoding to
326 size_t offset = dict->pos - dist - 1; in dict_get()
328 if (dist >= dict->pos) in dict_get()
329 offset += dict->end; in dict_get()
331 return dict->full > 0 ? dict->buf[offset] : 0; in dict_get()
339 dict->buf[dict->pos++] = byte; in dict_put()
341 if (dict->full < dict->pos) in dict_put()
342 dict->full = dict->pos; in dict_put()
355 if (dist >= dict->full || dist >= dict->size) in dict_repeat()
358 left = min_t(size_t, dict->limit - dict->pos, *len); in dict_repeat()
359 *len -= left; in dict_repeat()
361 back = dict->pos - dist - 1; in dict_repeat()
362 if (dist >= dict->pos) in dict_repeat()
363 back += dict->end; in dict_repeat()
366 dict->buf[dict->pos++] = dict->buf[back++]; in dict_repeat()
367 if (back == dict->end) in dict_repeat()
369 } while (--left > 0); in dict_repeat()
371 if (dict->full < dict->pos) in dict_repeat()
372 dict->full = dict->pos; in dict_repeat()
383 while (*left > 0 && b->in_pos < b->in_size in dict_uncompressed()
384 && b->out_pos < b->out_size) { in dict_uncompressed()
385 copy_size = min(b->in_size - b->in_pos, in dict_uncompressed()
386 b->out_size - b->out_pos); in dict_uncompressed()
387 if (copy_size > dict->end - dict->pos) in dict_uncompressed()
388 copy_size = dict->end - dict->pos; in dict_uncompressed()
392 *left -= copy_size; in dict_uncompressed()
395 * If doing in-place decompression in single-call mode and the in dict_uncompressed()
396 * uncompressed size of the file is larger than the caller in dict_uncompressed()
401 memmove(dict->buf + dict->pos, b->in + b->in_pos, copy_size); in dict_uncompressed()
402 dict->pos += copy_size; in dict_uncompressed()
404 if (dict->full < dict->pos) in dict_uncompressed()
405 dict->full = dict->pos; in dict_uncompressed()
407 if (DEC_IS_MULTI(dict->mode)) { in dict_uncompressed()
408 if (dict->pos == dict->end) in dict_uncompressed()
409 dict->pos = 0; in dict_uncompressed()
412 * Like above but for multi-call mode: use memmove() in dict_uncompressed()
415 memmove(b->out + b->out_pos, b->in + b->in_pos, in dict_uncompressed()
419 dict->start = dict->pos; in dict_uncompressed()
421 b->out_pos += copy_size; in dict_uncompressed()
422 b->in_pos += copy_size; in dict_uncompressed()
433 * Flush pending data from dictionary to b->out. It is assumed that there is
434 * enough space in b->out. This is guaranteed because caller uses dict_limit()
439 size_t copy_size = dict->pos - dict->start; in dict_flush()
441 if (DEC_IS_MULTI(dict->mode)) { in dict_flush()
442 if (dict->pos == dict->end) in dict_flush()
443 dict->pos = 0; in dict_flush()
446 * These buffers cannot overlap even if doing in-place in dict_flush()
447 * decompression because in multi-call mode dict->buf in dict_flush()
449 * provided by the caller like in single-call mode. in dict_flush()
451 * With MicroLZMA, b->out can be NULL to skip bytes that in dict_flush()
455 if (!DICT_FLUSH_SUPPORTS_SKIPPING || b->out != NULL) in dict_flush()
456 memcpy(b->out + b->out_pos, dict->buf + dict->start, in dict_flush()
460 dict->start = dict->pos; in dict_flush()
461 b->out_pos += copy_size; in dict_flush()
472 rc->range = (uint32_t)-1; in rc_reset()
473 rc->code = 0; in rc_reset()
474 rc->init_bytes_left = RC_INIT_BYTES; in rc_reset()
478 * Read the first five initial bytes into rc->code if they haven't been
483 while (rc->init_bytes_left > 0) { in rc_read_init()
484 if (b->in_pos == b->in_size) in rc_read_init()
487 rc->code = (rc->code << 8) + b->in[b->in_pos++]; in rc_read_init()
488 --rc->init_bytes_left; in rc_read_init()
497 return rc->in_pos > rc->in_limit; in rc_limit_exceeded()
506 return rc->code == 0; in rc_is_finished()
512 if (rc->range < RC_TOP_VALUE) { in rc_normalize()
513 rc->range <<= RC_SHIFT_BITS; in rc_normalize()
514 rc->code = (rc->code << RC_SHIFT_BITS) + rc->in[rc->in_pos++]; in rc_normalize()
523 * on x86). Using a non-split version results in nicer looking code too.
526 * of the code generated by GCC 3.x decreases 10-15 %. (GCC 4.3 doesn't care,
527 * and it generates 10-20 % faster code than GCC 3.x from this file anyway.)
535 bound = (rc->range >> RC_BIT_MODEL_TOTAL_BITS) * *prob; in rc_bit()
536 if (rc->code < bound) { in rc_bit()
537 rc->range = bound; in rc_bit()
538 *prob += (RC_BIT_MODEL_TOTAL - *prob) >> RC_MOVE_BITS; in rc_bit()
541 rc->range -= bound; in rc_bit()
542 rc->code -= bound; in rc_bit()
543 *prob -= *prob >> RC_MOVE_BITS; in rc_bit()
584 /* Decode direct bits (fixed fifty-fifty probability) */
591 rc->range >>= 1; in rc_direct()
592 rc->code -= rc->range; in rc_direct()
593 mask = (uint32_t)0 - (rc->code >> 31); in rc_direct()
594 rc->code += rc->range & mask; in rc_direct()
596 } while (--limit > 0); in rc_direct()
606 uint32_t prev_byte = dict_get(&s->dict, 0); in lzma_literal_probs()
607 uint32_t low = prev_byte >> (8 - s->lzma.lc); in lzma_literal_probs()
608 uint32_t high = (s->dict.pos & s->lzma.literal_pos_mask) << s->lzma.lc; in lzma_literal_probs()
609 return s->lzma.literal[low + high]; in lzma_literal_probs()
612 /* Decode a literal (one 8-bit byte) */
624 if (lzma_state_is_literal(s->lzma.state)) { in lzma_literal()
625 symbol = rc_bittree(&s->rc, probs, 0x100); in lzma_literal()
628 match_byte = dict_get(&s->dict, s->lzma.rep0) << 1; in lzma_literal()
636 if (rc_bit(&s->rc, &probs[i])) { in lzma_literal()
646 dict_put(&s->dict, (uint8_t)symbol); in lzma_literal()
647 lzma_state_literal(&s->lzma.state); in lzma_literal()
650 /* Decode the length of the match into s->lzma.len. */
657 if (!rc_bit(&s->rc, &l->choice)) { in lzma_len()
658 probs = l->low[pos_state]; in lzma_len()
660 s->lzma.len = MATCH_LEN_MIN; in lzma_len()
662 if (!rc_bit(&s->rc, &l->choice2)) { in lzma_len()
663 probs = l->mid[pos_state]; in lzma_len()
665 s->lzma.len = MATCH_LEN_MIN + LEN_LOW_SYMBOLS; in lzma_len()
667 probs = l->high; in lzma_len()
669 s->lzma.len = MATCH_LEN_MIN + LEN_LOW_SYMBOLS in lzma_len()
674 s->lzma.len += rc_bittree(&s->rc, probs, limit) - limit; in lzma_len()
677 /* Decode a match. The distance will be stored in s->lzma.rep0. */
684 lzma_state_match(&s->lzma.state); in lzma_match()
686 s->lzma.rep3 = s->lzma.rep2; in lzma_match()
687 s->lzma.rep2 = s->lzma.rep1; in lzma_match()
688 s->lzma.rep1 = s->lzma.rep0; in lzma_match()
690 lzma_len(s, &s->lzma.match_len_dec, pos_state); in lzma_match()
692 probs = s->lzma.dist_slot[lzma_get_dist_state(s->lzma.len)]; in lzma_match()
693 dist_slot = rc_bittree(&s->rc, probs, DIST_SLOTS) - DIST_SLOTS; in lzma_match()
696 s->lzma.rep0 = dist_slot; in lzma_match()
698 limit = (dist_slot >> 1) - 1; in lzma_match()
699 s->lzma.rep0 = 2 + (dist_slot & 1); in lzma_match()
702 s->lzma.rep0 <<= limit; in lzma_match()
703 probs = s->lzma.dist_special + s->lzma.rep0 in lzma_match()
704 - dist_slot - 1; in lzma_match()
705 rc_bittree_reverse(&s->rc, probs, in lzma_match()
706 &s->lzma.rep0, limit); in lzma_match()
708 rc_direct(&s->rc, &s->lzma.rep0, limit - ALIGN_BITS); in lzma_match()
709 s->lzma.rep0 <<= ALIGN_BITS; in lzma_match()
710 rc_bittree_reverse(&s->rc, s->lzma.dist_align, in lzma_match()
711 &s->lzma.rep0, ALIGN_BITS); in lzma_match()
718 * seen matches. The distance will be stored in s->lzma.rep0.
724 if (!rc_bit(&s->rc, &s->lzma.is_rep0[s->lzma.state])) { in lzma_rep_match()
725 if (!rc_bit(&s->rc, &s->lzma.is_rep0_long[ in lzma_rep_match()
726 s->lzma.state][pos_state])) { in lzma_rep_match()
727 lzma_state_short_rep(&s->lzma.state); in lzma_rep_match()
728 s->lzma.len = 1; in lzma_rep_match()
732 if (!rc_bit(&s->rc, &s->lzma.is_rep1[s->lzma.state])) { in lzma_rep_match()
733 tmp = s->lzma.rep1; in lzma_rep_match()
735 if (!rc_bit(&s->rc, &s->lzma.is_rep2[s->lzma.state])) { in lzma_rep_match()
736 tmp = s->lzma.rep2; in lzma_rep_match()
738 tmp = s->lzma.rep3; in lzma_rep_match()
739 s->lzma.rep3 = s->lzma.rep2; in lzma_rep_match()
742 s->lzma.rep2 = s->lzma.rep1; in lzma_rep_match()
745 s->lzma.rep1 = s->lzma.rep0; in lzma_rep_match()
746 s->lzma.rep0 = tmp; in lzma_rep_match()
749 lzma_state_long_rep(&s->lzma.state); in lzma_rep_match()
750 lzma_len(s, &s->lzma.rep_len_dec, pos_state); in lzma_rep_match()
762 if (dict_has_space(&s->dict) && s->lzma.len > 0) in lzma_main()
763 dict_repeat(&s->dict, &s->lzma.len, s->lzma.rep0); in lzma_main()
767 * LZMA_IN_REQUIRED - 1 bytes. in lzma_main()
769 while (dict_has_space(&s->dict) && !rc_limit_exceeded(&s->rc)) { in lzma_main()
770 pos_state = s->dict.pos & s->lzma.pos_mask; in lzma_main()
772 if (!rc_bit(&s->rc, &s->lzma.is_match[ in lzma_main()
773 s->lzma.state][pos_state])) { in lzma_main()
776 if (rc_bit(&s->rc, &s->lzma.is_rep[s->lzma.state])) in lzma_main()
781 if (!dict_repeat(&s->dict, &s->lzma.len, s->lzma.rep0)) in lzma_main()
790 rc_normalize(&s->rc); in lzma_main()
804 s->lzma.state = STATE_LIT_LIT; in lzma_reset()
805 s->lzma.rep0 = 0; in lzma_reset()
806 s->lzma.rep1 = 0; in lzma_reset()
807 s->lzma.rep2 = 0; in lzma_reset()
808 s->lzma.rep3 = 0; in lzma_reset()
809 s->lzma.len = 0; in lzma_reset()
820 probs = s->lzma.is_match[0]; in lzma_reset()
824 rc_reset(&s->rc); in lzma_reset()
837 s->lzma.pos_mask = 0; in lzma_props()
839 props -= 9 * 5; in lzma_props()
840 ++s->lzma.pos_mask; in lzma_props()
843 s->lzma.pos_mask = (1 << s->lzma.pos_mask) - 1; in lzma_props()
845 s->lzma.literal_pos_mask = 0; in lzma_props()
847 props -= 9; in lzma_props()
848 ++s->lzma.literal_pos_mask; in lzma_props()
851 s->lzma.lc = props; in lzma_props()
853 if (s->lzma.lc + s->lzma.literal_pos_mask > 4) in lzma_props()
856 s->lzma.literal_pos_mask = (1 << s->lzma.literal_pos_mask) - 1; in lzma_props()
868 * The LZMA decoder assumes that if the input limit (s->rc.in_limit) hasn't
873 * chunk, we decode directly from the caller-supplied input buffer until
875 * s->temp.buf, which (hopefully) gets filled on the next call to this
877 * continue decoding from the caller-supplied input buffer again.
884 in_avail = b->in_size - b->in_pos; in lzma2_lzma()
885 if (s->temp.size > 0 || s->lzma2.compressed == 0) { in lzma2_lzma()
886 tmp = 2 * LZMA_IN_REQUIRED - s->temp.size; in lzma2_lzma()
887 if (tmp > s->lzma2.compressed - s->temp.size) in lzma2_lzma()
888 tmp = s->lzma2.compressed - s->temp.size; in lzma2_lzma()
892 memcpy(s->temp.buf + s->temp.size, b->in + b->in_pos, tmp); in lzma2_lzma()
894 if (s->temp.size + tmp == s->lzma2.compressed) { in lzma2_lzma()
895 memzero(s->temp.buf + s->temp.size + tmp, in lzma2_lzma()
896 sizeof(s->temp.buf) in lzma2_lzma()
897 - s->temp.size - tmp); in lzma2_lzma()
898 s->rc.in_limit = s->temp.size + tmp; in lzma2_lzma()
899 } else if (s->temp.size + tmp < LZMA_IN_REQUIRED) { in lzma2_lzma()
900 s->temp.size += tmp; in lzma2_lzma()
901 b->in_pos += tmp; in lzma2_lzma()
904 s->rc.in_limit = s->temp.size + tmp - LZMA_IN_REQUIRED; in lzma2_lzma()
907 s->rc.in = s->temp.buf; in lzma2_lzma()
908 s->rc.in_pos = 0; in lzma2_lzma()
910 if (!lzma_main(s) || s->rc.in_pos > s->temp.size + tmp) in lzma2_lzma()
913 s->lzma2.compressed -= s->rc.in_pos; in lzma2_lzma()
915 if (s->rc.in_pos < s->temp.size) { in lzma2_lzma()
916 s->temp.size -= s->rc.in_pos; in lzma2_lzma()
917 memmove(s->temp.buf, s->temp.buf + s->rc.in_pos, in lzma2_lzma()
918 s->temp.size); in lzma2_lzma()
922 b->in_pos += s->rc.in_pos - s->temp.size; in lzma2_lzma()
923 s->temp.size = 0; in lzma2_lzma()
926 in_avail = b->in_size - b->in_pos; in lzma2_lzma()
928 s->rc.in = b->in; in lzma2_lzma()
929 s->rc.in_pos = b->in_pos; in lzma2_lzma()
931 if (in_avail >= s->lzma2.compressed + LZMA_IN_REQUIRED) in lzma2_lzma()
932 s->rc.in_limit = b->in_pos + s->lzma2.compressed; in lzma2_lzma()
934 s->rc.in_limit = b->in_size - LZMA_IN_REQUIRED; in lzma2_lzma()
939 in_avail = s->rc.in_pos - b->in_pos; in lzma2_lzma()
940 if (in_avail > s->lzma2.compressed) in lzma2_lzma()
943 s->lzma2.compressed -= in_avail; in lzma2_lzma()
944 b->in_pos = s->rc.in_pos; in lzma2_lzma()
947 in_avail = b->in_size - b->in_pos; in lzma2_lzma()
949 if (in_avail > s->lzma2.compressed) in lzma2_lzma()
950 in_avail = s->lzma2.compressed; in lzma2_lzma()
952 memcpy(s->temp.buf, b->in + b->in_pos, in_avail); in lzma2_lzma()
953 s->temp.size = in_avail; in lzma2_lzma()
954 b->in_pos += in_avail; in lzma2_lzma()
969 while (b->in_pos < b->in_size || s->lzma2.sequence == SEQ_LZMA_RUN) { in xz_dec_lzma2_run()
970 switch (s->lzma2.sequence) { in xz_dec_lzma2_run()
981 * Highest three bits (s->control & 0xE0): in xz_dec_lzma2_run()
993 * (s->control & 1F) are the highest bits of the in xz_dec_lzma2_run()
994 * uncompressed size (bits 16-20). in xz_dec_lzma2_run()
1003 tmp = b->in[b->in_pos++]; in xz_dec_lzma2_run()
1009 s->lzma2.need_props = true; in xz_dec_lzma2_run()
1010 s->lzma2.need_dict_reset = false; in xz_dec_lzma2_run()
1011 dict_reset(&s->dict, b); in xz_dec_lzma2_run()
1012 } else if (s->lzma2.need_dict_reset) { in xz_dec_lzma2_run()
1017 s->lzma2.uncompressed = (tmp & 0x1F) << 16; in xz_dec_lzma2_run()
1018 s->lzma2.sequence = SEQ_UNCOMPRESSED_1; in xz_dec_lzma2_run()
1026 s->lzma2.need_props = false; in xz_dec_lzma2_run()
1027 s->lzma2.next_sequence in xz_dec_lzma2_run()
1030 } else if (s->lzma2.need_props) { in xz_dec_lzma2_run()
1034 s->lzma2.next_sequence in xz_dec_lzma2_run()
1043 s->lzma2.sequence = SEQ_COMPRESSED_0; in xz_dec_lzma2_run()
1044 s->lzma2.next_sequence = SEQ_COPY; in xz_dec_lzma2_run()
1050 s->lzma2.uncompressed in xz_dec_lzma2_run()
1051 += (uint32_t)b->in[b->in_pos++] << 8; in xz_dec_lzma2_run()
1052 s->lzma2.sequence = SEQ_UNCOMPRESSED_2; in xz_dec_lzma2_run()
1056 s->lzma2.uncompressed in xz_dec_lzma2_run()
1057 += (uint32_t)b->in[b->in_pos++] + 1; in xz_dec_lzma2_run()
1058 s->lzma2.sequence = SEQ_COMPRESSED_0; in xz_dec_lzma2_run()
1062 s->lzma2.compressed in xz_dec_lzma2_run()
1063 = (uint32_t)b->in[b->in_pos++] << 8; in xz_dec_lzma2_run()
1064 s->lzma2.sequence = SEQ_COMPRESSED_1; in xz_dec_lzma2_run()
1068 s->lzma2.compressed in xz_dec_lzma2_run()
1069 += (uint32_t)b->in[b->in_pos++] + 1; in xz_dec_lzma2_run()
1070 s->lzma2.sequence = s->lzma2.next_sequence; in xz_dec_lzma2_run()
1074 if (!lzma_props(s, b->in[b->in_pos++])) in xz_dec_lzma2_run()
1077 s->lzma2.sequence = SEQ_LZMA_PREPARE; in xz_dec_lzma2_run()
1082 if (s->lzma2.compressed < RC_INIT_BYTES) in xz_dec_lzma2_run()
1085 if (!rc_read_init(&s->rc, b)) in xz_dec_lzma2_run()
1088 s->lzma2.compressed -= RC_INIT_BYTES; in xz_dec_lzma2_run()
1089 s->lzma2.sequence = SEQ_LZMA_RUN; in xz_dec_lzma2_run()
1098 * b->out. Check if we finished decoding this chunk. in xz_dec_lzma2_run()
1099 * In case the dictionary got full but we didn't fill in xz_dec_lzma2_run()
1101 * multiple times without changing s->lzma2.sequence. in xz_dec_lzma2_run()
1103 dict_limit(&s->dict, min_t(size_t, in xz_dec_lzma2_run()
1104 b->out_size - b->out_pos, in xz_dec_lzma2_run()
1105 s->lzma2.uncompressed)); in xz_dec_lzma2_run()
1109 s->lzma2.uncompressed -= dict_flush(&s->dict, b); in xz_dec_lzma2_run()
1111 if (s->lzma2.uncompressed == 0) { in xz_dec_lzma2_run()
1112 if (s->lzma2.compressed > 0 || s->lzma.len > 0 in xz_dec_lzma2_run()
1113 || !rc_is_finished(&s->rc)) in xz_dec_lzma2_run()
1116 rc_reset(&s->rc); in xz_dec_lzma2_run()
1117 s->lzma2.sequence = SEQ_CONTROL; in xz_dec_lzma2_run()
1119 } else if (b->out_pos == b->out_size in xz_dec_lzma2_run()
1120 || (b->in_pos == b->in_size in xz_dec_lzma2_run()
1121 && s->temp.size in xz_dec_lzma2_run()
1122 < s->lzma2.compressed)) { in xz_dec_lzma2_run()
1129 dict_uncompressed(&s->dict, b, &s->lzma2.compressed); in xz_dec_lzma2_run()
1130 if (s->lzma2.compressed > 0) in xz_dec_lzma2_run()
1133 s->lzma2.sequence = SEQ_CONTROL; in xz_dec_lzma2_run()
1148 s->dict.mode = mode; in xz_dec_lzma2_create()
1149 s->dict.size_max = dict_max; in xz_dec_lzma2_create()
1152 s->dict.buf = vmalloc(dict_max); in xz_dec_lzma2_create()
1153 if (s->dict.buf == NULL) { in xz_dec_lzma2_create()
1158 s->dict.buf = NULL; in xz_dec_lzma2_create()
1159 s->dict.allocated = 0; in xz_dec_lzma2_create()
1167 /* This limits dictionary size to 3 GiB to keep parsing simpler. */ in xz_dec_lzma2_reset()
1171 s->dict.size = 2 + (props & 1); in xz_dec_lzma2_reset()
1172 s->dict.size <<= (props >> 1) + 11; in xz_dec_lzma2_reset()
1174 if (DEC_IS_MULTI(s->dict.mode)) { in xz_dec_lzma2_reset()
1175 if (s->dict.size > s->dict.size_max) in xz_dec_lzma2_reset()
1178 s->dict.end = s->dict.size; in xz_dec_lzma2_reset()
1180 if (DEC_IS_DYNALLOC(s->dict.mode)) { in xz_dec_lzma2_reset()
1181 if (s->dict.allocated < s->dict.size) { in xz_dec_lzma2_reset()
1182 s->dict.allocated = s->dict.size; in xz_dec_lzma2_reset()
1183 vfree(s->dict.buf); in xz_dec_lzma2_reset()
1184 s->dict.buf = vmalloc(s->dict.size); in xz_dec_lzma2_reset()
1185 if (s->dict.buf == NULL) { in xz_dec_lzma2_reset()
1186 s->dict.allocated = 0; in xz_dec_lzma2_reset()
1193 s->lzma2.sequence = SEQ_CONTROL; in xz_dec_lzma2_reset()
1194 s->lzma2.need_dict_reset = true; in xz_dec_lzma2_reset()
1196 s->temp.size = 0; in xz_dec_lzma2_reset()
1203 if (DEC_IS_MULTI(s->dict.mode)) in xz_dec_lzma2_end()
1204 vfree(s->dict.buf); in xz_dec_lzma2_end()
1218 struct xz_dec_lzma2 *s = &s_ptr->s; in xz_dec_microlzma_run()
1225 if (s->lzma2.sequence != SEQ_LZMA_RUN) { in xz_dec_microlzma_run()
1226 if (s->lzma2.sequence == SEQ_PROPERTIES) { in xz_dec_microlzma_run()
1228 if (b->in_pos >= b->in_size) in xz_dec_microlzma_run()
1232 * Don't increment b->in_pos here. The same byte is in xz_dec_microlzma_run()
1235 if (!lzma_props(s, ~b->in[b->in_pos])) in xz_dec_microlzma_run()
1238 s->lzma2.sequence = SEQ_LZMA_PREPARE; in xz_dec_microlzma_run()
1243 * size so we do it here. We have to limit the maximum size in xz_dec_microlzma_run()
1248 if (s->lzma2.compressed < RC_INIT_BYTES in xz_dec_microlzma_run()
1249 || s->lzma2.compressed > (3U << 30)) in xz_dec_microlzma_run()
1252 if (!rc_read_init(&s->rc, b)) in xz_dec_microlzma_run()
1255 s->lzma2.compressed -= RC_INIT_BYTES; in xz_dec_microlzma_run()
1256 s->lzma2.sequence = SEQ_LZMA_RUN; in xz_dec_microlzma_run()
1258 dict_reset(&s->dict, b); in xz_dec_microlzma_run()
1261 /* This is to allow increasing b->out_size between calls. */ in xz_dec_microlzma_run()
1262 if (DEC_IS_SINGLE(s->dict.mode)) in xz_dec_microlzma_run()
1263 s->dict.end = b->out_size - b->out_pos; in xz_dec_microlzma_run()
1266 dict_limit(&s->dict, min_t(size_t, b->out_size - b->out_pos, in xz_dec_microlzma_run()
1267 s->lzma2.uncompressed)); in xz_dec_microlzma_run()
1272 s->lzma2.uncompressed -= dict_flush(&s->dict, b); in xz_dec_microlzma_run()
1274 if (s->lzma2.uncompressed == 0) { in xz_dec_microlzma_run()
1275 if (s->lzma2.pedantic_microlzma) { in xz_dec_microlzma_run()
1276 if (s->lzma2.compressed > 0 || s->lzma.len > 0 in xz_dec_microlzma_run()
1277 || !rc_is_finished(&s->rc)) in xz_dec_microlzma_run()
1284 if (b->out_pos == b->out_size) in xz_dec_microlzma_run()
1287 if (b->in_pos == b->in_size in xz_dec_microlzma_run()
1288 && s->temp.size < s->lzma2.compressed) in xz_dec_microlzma_run()
1306 s->s.dict.mode = mode; in xz_dec_microlzma_alloc()
1307 s->s.dict.size = dict_size; in xz_dec_microlzma_alloc()
1310 s->s.dict.end = dict_size; in xz_dec_microlzma_alloc()
1312 s->s.dict.buf = vmalloc(dict_size); in xz_dec_microlzma_alloc()
1313 if (s->s.dict.buf == NULL) { in xz_dec_microlzma_alloc()
1329 s->s.lzma2.compressed = comp_size; in xz_dec_microlzma_reset()
1330 s->s.lzma2.uncompressed = uncomp_size; in xz_dec_microlzma_reset()
1331 s->s.lzma2.pedantic_microlzma = uncomp_size_is_exact; in xz_dec_microlzma_reset()
1333 s->s.lzma2.sequence = SEQ_PROPERTIES; in xz_dec_microlzma_reset()
1334 s->s.temp.size = 0; in xz_dec_microlzma_reset()
1339 if (DEC_IS_MULTI(s->s.dict.mode)) in xz_dec_microlzma_end()
1340 vfree(s->s.dict.buf); in xz_dec_microlzma_end()