1229159Sadrian/* 2229159Sadrian * LZMA2 decoder 3229159Sadrian * 4229159Sadrian * Authors: Lasse Collin <lasse.collin@tukaani.org> 5229159Sadrian * Igor Pavlov <http://7-zip.org/> 6229159Sadrian * 7229159Sadrian * This file has been put into the public domain. 8229159Sadrian * You can do whatever you want with this file. 9229159Sadrian */ 10229159Sadrian 11229159Sadrian#include "xz_private.h" 12229159Sadrian#include "xz_lzma2.h" 13229159Sadrian 14229159Sadrian/* 15229159Sadrian * Range decoder initialization eats the first five bytes of each LZMA chunk. 16229159Sadrian */ 17229159Sadrian#define RC_INIT_BYTES 5 18229159Sadrian 19229159Sadrian/* 20229159Sadrian * Minimum number of usable input buffer to safely decode one LZMA symbol. 21229159Sadrian * The worst case is that we decode 22 bits using probabilities and 26 22229159Sadrian * direct bits. This may decode at maximum of 20 bytes of input. However, 23229159Sadrian * lzma_main() does an extra normalization before returning, thus we 24229159Sadrian * need to put 21 here. 25229159Sadrian */ 26229159Sadrian#define LZMA_IN_REQUIRED 21 27229159Sadrian 28229159Sadrian/* 29229159Sadrian * Dictionary (history buffer) 30229159Sadrian * 31229159Sadrian * These are always true: 32229159Sadrian * start <= pos <= full <= end 33229159Sadrian * pos <= limit <= end 34229159Sadrian * 35229159Sadrian * In multi-call mode, also these are true: 36229159Sadrian * end == size 37229159Sadrian * size <= size_max 38229159Sadrian * allocated <= size 39229159Sadrian * 40229159Sadrian * Most of these variables are size_t to support single-call mode, 41229159Sadrian * in which the dictionary variables address the actual output 42229159Sadrian * buffer directly. 43229159Sadrian */ 44229159Sadrianstruct dictionary { 45229159Sadrian /* Beginning of the history buffer */ 46229159Sadrian uint8_t *buf; 47229159Sadrian 48229159Sadrian /* Old position in buf (before decoding more data) */ 49229159Sadrian size_t start; 50229159Sadrian 51229159Sadrian /* Position in buf */ 52229159Sadrian size_t pos; 53229159Sadrian 54229159Sadrian /* 55229159Sadrian * How full dictionary is. This is used to detect corrupt input that 56229159Sadrian * would read beyond the beginning of the uncompressed stream. 57229159Sadrian */ 58229159Sadrian size_t full; 59229159Sadrian 60229159Sadrian /* Write limit; we don't write to buf[limit] or later bytes. */ 61229159Sadrian size_t limit; 62229159Sadrian 63229159Sadrian /* 64229159Sadrian * End of the dictionary buffer. In multi-call mode, this is 65229159Sadrian * the same as the dictionary size. In single-call mode, this 66229159Sadrian * indicates the size of the output buffer. 67229159Sadrian */ 68229159Sadrian size_t end; 69229159Sadrian 70229159Sadrian /* 71229159Sadrian * Size of the dictionary as specified in Block Header. This is used 72229159Sadrian * together with "full" to detect corrupt input that would make us 73229159Sadrian * read beyond the beginning of the uncompressed stream. 74229159Sadrian */ 75229159Sadrian uint32_t size; 76229159Sadrian 77229159Sadrian /* 78229159Sadrian * Maximum allowed dictionary size in multi-call mode. 79229159Sadrian * This is ignored in single-call mode. 80229159Sadrian */ 81229159Sadrian uint32_t size_max; 82229159Sadrian 83229159Sadrian /* 84229159Sadrian * Amount of memory currently allocated for the dictionary. 85229159Sadrian * This is used only with XZ_DYNALLOC. (With XZ_PREALLOC, 86229159Sadrian * size_max is always the same as the allocated size.) 87229159Sadrian */ 88229159Sadrian uint32_t allocated; 89229159Sadrian 90229159Sadrian /* Operation mode */ 91229159Sadrian enum xz_mode mode; 92229159Sadrian}; 93229159Sadrian 94229159Sadrian/* Range decoder */ 95229159Sadrianstruct rc_dec { 96229159Sadrian uint32_t range; 97229159Sadrian uint32_t code; 98229159Sadrian 99229159Sadrian /* 100229159Sadrian * Number of initializing bytes remaining to be read 101229159Sadrian * by rc_read_init(). 102229159Sadrian */ 103229159Sadrian uint32_t init_bytes_left; 104229159Sadrian 105229159Sadrian /* 106229159Sadrian * Buffer from which we read our input. It can be either 107229159Sadrian * temp.buf or the caller-provided input buffer. 108229159Sadrian */ 109229159Sadrian const uint8_t *in; 110229159Sadrian size_t in_pos; 111229159Sadrian size_t in_limit; 112229159Sadrian}; 113229159Sadrian 114229159Sadrian/* Probabilities for a length decoder. */ 115229159Sadrianstruct lzma_len_dec { 116229159Sadrian /* Probability of match length being at least 10 */ 117229159Sadrian uint16_t choice; 118229159Sadrian 119229159Sadrian /* Probability of match length being at least 18 */ 120229159Sadrian uint16_t choice2; 121229159Sadrian 122229159Sadrian /* Probabilities for match lengths 2-9 */ 123229159Sadrian uint16_t low[POS_STATES_MAX][LEN_LOW_SYMBOLS]; 124229159Sadrian 125229159Sadrian /* Probabilities for match lengths 10-17 */ 126229159Sadrian uint16_t mid[POS_STATES_MAX][LEN_MID_SYMBOLS]; 127229159Sadrian 128229159Sadrian /* Probabilities for match lengths 18-273 */ 129229159Sadrian uint16_t high[LEN_HIGH_SYMBOLS]; 130229159Sadrian}; 131229159Sadrian 132229159Sadrianstruct lzma_dec { 133229159Sadrian /* Distances of latest four matches */ 134229159Sadrian uint32_t rep0; 135229159Sadrian uint32_t rep1; 136229159Sadrian uint32_t rep2; 137229159Sadrian uint32_t rep3; 138229159Sadrian 139229159Sadrian /* Types of the most recently seen LZMA symbols */ 140229159Sadrian enum lzma_state state; 141229159Sadrian 142229159Sadrian /* 143229159Sadrian * Length of a match. This is updated so that dict_repeat can 144229159Sadrian * be called again to finish repeating the whole match. 145229159Sadrian */ 146229159Sadrian uint32_t len; 147229159Sadrian 148229159Sadrian /* 149229159Sadrian * LZMA properties or related bit masks (number of literal 150229159Sadrian * context bits, a mask dervied from the number of literal 151229159Sadrian * position bits, and a mask dervied from the number 152229159Sadrian * position bits) 153229159Sadrian */ 154229159Sadrian uint32_t lc; 155229159Sadrian uint32_t literal_pos_mask; /* (1 << lp) - 1 */ 156229159Sadrian uint32_t pos_mask; /* (1 << pb) - 1 */ 157229159Sadrian 158229159Sadrian /* If 1, it's a match. Otherwise it's a single 8-bit literal. */ 159229159Sadrian uint16_t is_match[STATES][POS_STATES_MAX]; 160229159Sadrian 161229159Sadrian /* If 1, it's a repeated match. The distance is one of rep0 .. rep3. */ 162229159Sadrian uint16_t is_rep[STATES]; 163229159Sadrian 164229159Sadrian /* 165229159Sadrian * If 0, distance of a repeated match is rep0. 166229159Sadrian * Otherwise check is_rep1. 167229159Sadrian */ 168229159Sadrian uint16_t is_rep0[STATES]; 169229159Sadrian 170229159Sadrian /* 171229159Sadrian * If 0, distance of a repeated match is rep1. 172229159Sadrian * Otherwise check is_rep2. 173229159Sadrian */ 174229159Sadrian uint16_t is_rep1[STATES]; 175229159Sadrian 176229159Sadrian /* If 0, distance of a repeated match is rep2. Otherwise it is rep3. */ 177229159Sadrian uint16_t is_rep2[STATES]; 178229159Sadrian 179229159Sadrian /* 180229159Sadrian * If 1, the repeated match has length of one byte. Otherwise 181229159Sadrian * the length is decoded from rep_len_decoder. 182229159Sadrian */ 183229159Sadrian uint16_t is_rep0_long[STATES][POS_STATES_MAX]; 184229159Sadrian 185229159Sadrian /* 186229159Sadrian * Probability tree for the highest two bits of the match 187229159Sadrian * distance. There is a separate probability tree for match 188229159Sadrian * lengths of 2 (i.e. MATCH_LEN_MIN), 3, 4, and [5, 273]. 189229159Sadrian */ 190229159Sadrian uint16_t dist_slot[DIST_STATES][DIST_SLOTS]; 191229159Sadrian 192229159Sadrian /* 193229159Sadrian * Probility trees for additional bits for match distance 194229159Sadrian * when the distance is in the range [4, 127]. 195229159Sadrian */ 196229159Sadrian uint16_t dist_special[FULL_DISTANCES - DIST_MODEL_END]; 197229159Sadrian 198229159Sadrian /* 199229159Sadrian * Probability tree for the lowest four bits of a match 200229159Sadrian * distance that is equal to or greater than 128. 201229159Sadrian */ 202229159Sadrian uint16_t dist_align[ALIGN_SIZE]; 203229159Sadrian 204229159Sadrian /* Length of a normal match */ 205229159Sadrian struct lzma_len_dec match_len_dec; 206229159Sadrian 207229159Sadrian /* Length of a repeated match */ 208229159Sadrian struct lzma_len_dec rep_len_dec; 209229159Sadrian 210229159Sadrian /* Probabilities of literals */ 211229159Sadrian uint16_t literal[LITERAL_CODERS_MAX][LITERAL_CODER_SIZE]; 212229159Sadrian}; 213229159Sadrian 214229159Sadrianstruct lzma2_dec { 215229159Sadrian /* Position in xz_dec_lzma2_run(). */ 216229159Sadrian enum lzma2_seq { 217229159Sadrian SEQ_CONTROL, 218229159Sadrian SEQ_UNCOMPRESSED_1, 219229159Sadrian SEQ_UNCOMPRESSED_2, 220229159Sadrian SEQ_COMPRESSED_0, 221229159Sadrian SEQ_COMPRESSED_1, 222229159Sadrian SEQ_PROPERTIES, 223229159Sadrian SEQ_LZMA_PREPARE, 224229159Sadrian SEQ_LZMA_RUN, 225229159Sadrian SEQ_COPY 226229159Sadrian } sequence; 227229159Sadrian 228229159Sadrian /* Next position after decoding the compressed size of the chunk. */ 229229159Sadrian enum lzma2_seq next_sequence; 230229159Sadrian 231229159Sadrian /* Uncompressed size of LZMA chunk (2 MiB at maximum) */ 232229159Sadrian uint32_t uncompressed; 233229159Sadrian 234229159Sadrian /* 235229159Sadrian * Compressed size of LZMA chunk or compressed/uncompressed 236229159Sadrian * size of uncompressed chunk (64 KiB at maximum) 237229159Sadrian */ 238229159Sadrian uint32_t compressed; 239229159Sadrian 240229159Sadrian /* 241229159Sadrian * True if dictionary reset is needed. This is false before 242229159Sadrian * the first chunk (LZMA or uncompressed). 243229159Sadrian */ 244229159Sadrian bool need_dict_reset; 245229159Sadrian 246229159Sadrian /* 247229159Sadrian * True if new LZMA properties are needed. This is false 248229159Sadrian * before the first LZMA chunk. 249229159Sadrian */ 250229159Sadrian bool need_props; 251229159Sadrian}; 252229159Sadrian 253229159Sadrianstruct xz_dec_lzma2 { 254229159Sadrian /* 255229159Sadrian * The order below is important on x86 to reduce code size and 256229159Sadrian * it shouldn't hurt on other platforms. Everything up to and 257229159Sadrian * including lzma.pos_mask are in the first 128 bytes on x86-32, 258229159Sadrian * which allows using smaller instructions to access those 259229159Sadrian * variables. On x86-64, fewer variables fit into the first 128 260229159Sadrian * bytes, but this is still the best order without sacrificing 261229159Sadrian * the readability by splitting the structures. 262229159Sadrian */ 263229159Sadrian struct rc_dec rc; 264229159Sadrian struct dictionary dict; 265229159Sadrian struct lzma2_dec lzma2; 266229159Sadrian struct lzma_dec lzma; 267229159Sadrian 268229159Sadrian /* 269229159Sadrian * Temporary buffer which holds small number of input bytes between 270229159Sadrian * decoder calls. See lzma2_lzma() for details. 271229159Sadrian */ 272229159Sadrian struct { 273229159Sadrian uint32_t size; 274229159Sadrian uint8_t buf[3 * LZMA_IN_REQUIRED]; 275229159Sadrian } temp; 276229159Sadrian}; 277229159Sadrian 278229159Sadrian/************** 279229159Sadrian * Dictionary * 280229159Sadrian **************/ 281229159Sadrian 282229159Sadrian/* 283229159Sadrian * Reset the dictionary state. When in single-call mode, set up the beginning 284229159Sadrian * of the dictionary to point to the actual output buffer. 285229159Sadrian */ 286229159Sadrianstatic void dict_reset(struct dictionary *dict, struct xz_buf *b) 287229159Sadrian{ 288229159Sadrian if (DEC_IS_SINGLE(dict->mode)) { 289229159Sadrian dict->buf = b->out + b->out_pos; 290229159Sadrian dict->end = b->out_size - b->out_pos; 291229159Sadrian } 292229159Sadrian 293229159Sadrian dict->start = 0; 294229159Sadrian dict->pos = 0; 295229159Sadrian dict->limit = 0; 296229159Sadrian dict->full = 0; 297229159Sadrian} 298229159Sadrian 299229159Sadrian/* Set dictionary write limit */ 300229159Sadrianstatic void dict_limit(struct dictionary *dict, size_t out_max) 301229159Sadrian{ 302229159Sadrian if (dict->end - dict->pos <= out_max) 303229159Sadrian dict->limit = dict->end; 304229159Sadrian else 305229159Sadrian dict->limit = dict->pos + out_max; 306229159Sadrian} 307229159Sadrian 308229159Sadrian/* Return true if at least one byte can be written into the dictionary. */ 309229159Sadrianstatic inline bool dict_has_space(const struct dictionary *dict) 310229159Sadrian{ 311229159Sadrian return dict->pos < dict->limit; 312229159Sadrian} 313229159Sadrian 314229159Sadrian/* 315229159Sadrian * Get a byte from the dictionary at the given distance. The distance is 316229159Sadrian * assumed to valid, or as a special case, zero when the dictionary is 317229159Sadrian * still empty. This special case is needed for single-call decoding to 318229159Sadrian * avoid writing a '\0' to the end of the destination buffer. 319229159Sadrian */ 320229159Sadrianstatic inline uint32_t dict_get(const struct dictionary *dict, uint32_t dist) 321229159Sadrian{ 322229159Sadrian size_t offset = dict->pos - dist - 1; 323229159Sadrian 324229159Sadrian if (dist >= dict->pos) 325229159Sadrian offset += dict->end; 326229159Sadrian 327229159Sadrian return dict->full > 0 ? dict->buf[offset] : 0; 328229159Sadrian} 329229159Sadrian 330229159Sadrian/* 331229159Sadrian * Put one byte into the dictionary. It is assumed that there is space for it. 332229159Sadrian */ 333229159Sadrianstatic inline void dict_put(struct dictionary *dict, uint8_t byte) 334229159Sadrian{ 335229159Sadrian dict->buf[dict->pos++] = byte; 336229159Sadrian 337229159Sadrian if (dict->full < dict->pos) 338229159Sadrian dict->full = dict->pos; 339229159Sadrian} 340229159Sadrian 341229159Sadrian/* 342229159Sadrian * Repeat given number of bytes from the given distance. If the distance is 343229159Sadrian * invalid, false is returned. On success, true is returned and *len is 344229159Sadrian * updated to indicate how many bytes were left to be repeated. 345229159Sadrian */ 346229159Sadrianstatic bool dict_repeat(struct dictionary *dict, uint32_t *len, uint32_t dist) 347229159Sadrian{ 348229159Sadrian size_t back; 349229159Sadrian uint32_t left; 350229159Sadrian 351229159Sadrian if (dist >= dict->full || dist >= dict->size) 352229159Sadrian return false; 353229159Sadrian 354229159Sadrian left = min_t(size_t, dict->limit - dict->pos, *len); 355229159Sadrian *len -= left; 356229159Sadrian 357229159Sadrian back = dict->pos - dist - 1; 358229159Sadrian if (dist >= dict->pos) 359229159Sadrian back += dict->end; 360229159Sadrian 361229159Sadrian do { 362229159Sadrian dict->buf[dict->pos++] = dict->buf[back++]; 363229159Sadrian if (back == dict->end) 364229159Sadrian back = 0; 365229159Sadrian } while (--left > 0); 366229159Sadrian 367229159Sadrian if (dict->full < dict->pos) 368229159Sadrian dict->full = dict->pos; 369229159Sadrian 370229159Sadrian return true; 371229159Sadrian} 372229159Sadrian 373229159Sadrian/* Copy uncompressed data as is from input to dictionary and output buffers. */ 374229159Sadrianstatic void dict_uncompressed(struct dictionary *dict, struct xz_buf *b, 375229159Sadrian uint32_t *left) 376229159Sadrian{ 377229159Sadrian size_t copy_size; 378229159Sadrian 379229159Sadrian while (*left > 0 && b->in_pos < b->in_size 380229159Sadrian && b->out_pos < b->out_size) { 381229159Sadrian copy_size = min(b->in_size - b->in_pos, 382229159Sadrian b->out_size - b->out_pos); 383229159Sadrian if (copy_size > dict->end - dict->pos) 384229159Sadrian copy_size = dict->end - dict->pos; 385229159Sadrian if (copy_size > *left) 386229159Sadrian copy_size = *left; 387229159Sadrian 388229159Sadrian *left -= copy_size; 389229159Sadrian 390229159Sadrian memcpy(dict->buf + dict->pos, b->in + b->in_pos, copy_size); 391229159Sadrian dict->pos += copy_size; 392229159Sadrian 393229159Sadrian if (dict->full < dict->pos) 394229159Sadrian dict->full = dict->pos; 395229159Sadrian 396229159Sadrian if (DEC_IS_MULTI(dict->mode)) { 397229159Sadrian if (dict->pos == dict->end) 398229159Sadrian dict->pos = 0; 399229159Sadrian 400229159Sadrian memcpy(b->out + b->out_pos, b->in + b->in_pos, 401229159Sadrian copy_size); 402229159Sadrian } 403229159Sadrian 404229159Sadrian dict->start = dict->pos; 405229159Sadrian 406229159Sadrian b->out_pos += copy_size; 407229159Sadrian b->in_pos += copy_size; 408229159Sadrian } 409229159Sadrian} 410229159Sadrian 411229159Sadrian/* 412229159Sadrian * Flush pending data from dictionary to b->out. It is assumed that there is 413229159Sadrian * enough space in b->out. This is guaranteed because caller uses dict_limit() 414229159Sadrian * before decoding data into the dictionary. 415229159Sadrian */ 416229159Sadrianstatic uint32_t dict_flush(struct dictionary *dict, struct xz_buf *b) 417229159Sadrian{ 418229159Sadrian size_t copy_size = dict->pos - dict->start; 419229159Sadrian 420229159Sadrian if (DEC_IS_MULTI(dict->mode)) { 421229159Sadrian if (dict->pos == dict->end) 422229159Sadrian dict->pos = 0; 423229159Sadrian 424229159Sadrian memcpy(b->out + b->out_pos, dict->buf + dict->start, 425229159Sadrian copy_size); 426229159Sadrian } 427229159Sadrian 428229159Sadrian dict->start = dict->pos; 429229159Sadrian b->out_pos += copy_size; 430229159Sadrian return copy_size; 431229159Sadrian} 432229159Sadrian 433229159Sadrian/***************** 434229159Sadrian * Range decoder * 435229159Sadrian *****************/ 436229159Sadrian 437229159Sadrian/* Reset the range decoder. */ 438229159Sadrianstatic void rc_reset(struct rc_dec *rc) 439229159Sadrian{ 440229159Sadrian rc->range = (uint32_t)-1; 441229159Sadrian rc->code = 0; 442229159Sadrian rc->init_bytes_left = RC_INIT_BYTES; 443229159Sadrian} 444229159Sadrian 445229159Sadrian/* 446229159Sadrian * Read the first five initial bytes into rc->code if they haven't been 447229159Sadrian * read already. (Yes, the first byte gets completely ignored.) 448229159Sadrian */ 449229159Sadrianstatic bool rc_read_init(struct rc_dec *rc, struct xz_buf *b) 450229159Sadrian{ 451229159Sadrian while (rc->init_bytes_left > 0) { 452229159Sadrian if (b->in_pos == b->in_size) 453229159Sadrian return false; 454229159Sadrian 455229159Sadrian rc->code = (rc->code << 8) + b->in[b->in_pos++]; 456229159Sadrian --rc->init_bytes_left; 457229159Sadrian } 458229159Sadrian 459229159Sadrian return true; 460229159Sadrian} 461229159Sadrian 462229159Sadrian/* Return true if there may not be enough input for the next decoding loop. */ 463229159Sadrianstatic inline bool rc_limit_exceeded(const struct rc_dec *rc) 464229159Sadrian{ 465229159Sadrian return rc->in_pos > rc->in_limit; 466229159Sadrian} 467229159Sadrian 468229159Sadrian/* 469229159Sadrian * Return true if it is possible (from point of view of range decoder) that 470229159Sadrian * we have reached the end of the LZMA chunk. 471229159Sadrian */ 472229159Sadrianstatic inline bool rc_is_finished(const struct rc_dec *rc) 473229159Sadrian{ 474229159Sadrian return rc->code == 0; 475229159Sadrian} 476229159Sadrian 477229159Sadrian/* Read the next input byte if needed. */ 478229159Sadrianstatic __always_inline void rc_normalize(struct rc_dec *rc) 479229159Sadrian{ 480229159Sadrian if (rc->range < RC_TOP_VALUE) { 481229159Sadrian rc->range <<= RC_SHIFT_BITS; 482229159Sadrian rc->code = (rc->code << RC_SHIFT_BITS) + rc->in[rc->in_pos++]; 483229159Sadrian } 484229159Sadrian} 485229159Sadrian 486229159Sadrian/* 487229159Sadrian * Decode one bit. In some versions, this function has been splitted in three 488229159Sadrian * functions so that the compiler is supposed to be able to more easily avoid 489229159Sadrian * an extra branch. In this particular version of the LZMA decoder, this 490229159Sadrian * doesn't seem to be a good idea (tested with GCC 3.3.6, 3.4.6, and 4.3.3 491229159Sadrian * on x86). Using a non-splitted version results in nicer looking code too. 492229159Sadrian * 493229159Sadrian * NOTE: This must return an int. Do not make it return a bool or the speed 494229159Sadrian * of the code generated by GCC 3.x decreases 10-15 %. (GCC 4.3 doesn't care, 495229159Sadrian * and it generates 10-20 % faster code than GCC 3.x from this file anyway.) 496229159Sadrian */ 497229159Sadrianstatic __always_inline int rc_bit(struct rc_dec *rc, uint16_t *prob) 498229159Sadrian{ 499229159Sadrian uint32_t bound; 500229159Sadrian int bit; 501229159Sadrian 502229159Sadrian rc_normalize(rc); 503229159Sadrian bound = (rc->range >> RC_BIT_MODEL_TOTAL_BITS) * *prob; 504229159Sadrian if (rc->code < bound) { 505229159Sadrian rc->range = bound; 506229159Sadrian *prob += (RC_BIT_MODEL_TOTAL - *prob) >> RC_MOVE_BITS; 507229159Sadrian bit = 0; 508229159Sadrian } else { 509229159Sadrian rc->range -= bound; 510229159Sadrian rc->code -= bound; 511229159Sadrian *prob -= *prob >> RC_MOVE_BITS; 512229159Sadrian bit = 1; 513229159Sadrian } 514229159Sadrian 515229159Sadrian return bit; 516229159Sadrian} 517229159Sadrian 518229159Sadrian/* Decode a bittree starting from the most significant bit. */ 519229159Sadrianstatic __always_inline uint32_t rc_bittree(struct rc_dec *rc, 520229159Sadrian uint16_t *probs, uint32_t limit) 521229159Sadrian{ 522229159Sadrian uint32_t symbol = 1; 523229159Sadrian 524229159Sadrian do { 525229159Sadrian if (rc_bit(rc, &probs[symbol])) 526229159Sadrian symbol = (symbol << 1) + 1; 527229159Sadrian else 528229159Sadrian symbol <<= 1; 529229159Sadrian } while (symbol < limit); 530229159Sadrian 531229159Sadrian return symbol; 532229159Sadrian} 533229159Sadrian 534229159Sadrian/* Decode a bittree starting from the least significant bit. */ 535229159Sadrianstatic __always_inline void rc_bittree_reverse(struct rc_dec *rc, 536229159Sadrian uint16_t *probs, 537229159Sadrian uint32_t *dest, uint32_t limit) 538229159Sadrian{ 539229159Sadrian uint32_t symbol = 1; 540229159Sadrian uint32_t i = 0; 541229159Sadrian 542229159Sadrian do { 543229159Sadrian if (rc_bit(rc, &probs[symbol])) { 544229159Sadrian symbol = (symbol << 1) + 1; 545229159Sadrian *dest += 1 << i; 546229159Sadrian } else { 547229159Sadrian symbol <<= 1; 548229159Sadrian } 549229159Sadrian } while (++i < limit); 550229159Sadrian} 551229159Sadrian 552229159Sadrian/* Decode direct bits (fixed fifty-fifty probability) */ 553229159Sadrianstatic inline void rc_direct(struct rc_dec *rc, uint32_t *dest, uint32_t limit) 554229159Sadrian{ 555229159Sadrian uint32_t mask; 556229159Sadrian 557229159Sadrian do { 558229159Sadrian rc_normalize(rc); 559229159Sadrian rc->range >>= 1; 560229159Sadrian rc->code -= rc->range; 561229159Sadrian mask = (uint32_t)0 - (rc->code >> 31); 562229159Sadrian rc->code += rc->range & mask; 563229159Sadrian *dest = (*dest << 1) + (mask + 1); 564229159Sadrian } while (--limit > 0); 565229159Sadrian} 566229159Sadrian 567229159Sadrian/******** 568229159Sadrian * LZMA * 569229159Sadrian ********/ 570229159Sadrian 571229159Sadrian/* Get pointer to literal coder probability array. */ 572229159Sadrianstatic uint16_t *lzma_literal_probs(struct xz_dec_lzma2 *s) 573229159Sadrian{ 574229159Sadrian uint32_t prev_byte = dict_get(&s->dict, 0); 575229159Sadrian uint32_t low = prev_byte >> (8 - s->lzma.lc); 576229159Sadrian uint32_t high = (s->dict.pos & s->lzma.literal_pos_mask) << s->lzma.lc; 577229159Sadrian return s->lzma.literal[low + high]; 578229159Sadrian} 579229159Sadrian 580229159Sadrian/* Decode a literal (one 8-bit byte) */ 581229159Sadrianstatic void lzma_literal(struct xz_dec_lzma2 *s) 582229159Sadrian{ 583229159Sadrian uint16_t *probs; 584229159Sadrian uint32_t symbol; 585229159Sadrian uint32_t match_byte; 586229159Sadrian uint32_t match_bit; 587229159Sadrian uint32_t offset; 588229159Sadrian uint32_t i; 589229159Sadrian 590229159Sadrian probs = lzma_literal_probs(s); 591229159Sadrian 592229159Sadrian if (lzma_state_is_literal(s->lzma.state)) { 593229159Sadrian symbol = rc_bittree(&s->rc, probs, 0x100); 594229159Sadrian } else { 595229159Sadrian symbol = 1; 596229159Sadrian match_byte = dict_get(&s->dict, s->lzma.rep0) << 1; 597229159Sadrian offset = 0x100; 598229159Sadrian 599229159Sadrian do { 600229159Sadrian match_bit = match_byte & offset; 601229159Sadrian match_byte <<= 1; 602229159Sadrian i = offset + match_bit + symbol; 603229159Sadrian 604229159Sadrian if (rc_bit(&s->rc, &probs[i])) { 605229159Sadrian symbol = (symbol << 1) + 1; 606229159Sadrian offset &= match_bit; 607229159Sadrian } else { 608229159Sadrian symbol <<= 1; 609229159Sadrian offset &= ~match_bit; 610229159Sadrian } 611229159Sadrian } while (symbol < 0x100); 612229159Sadrian } 613229159Sadrian 614229159Sadrian dict_put(&s->dict, (uint8_t)symbol); 615229159Sadrian lzma_state_literal(&s->lzma.state); 616229159Sadrian} 617229159Sadrian 618229159Sadrian/* Decode the length of the match into s->lzma.len. */ 619229159Sadrianstatic void lzma_len(struct xz_dec_lzma2 *s, struct lzma_len_dec *l, 620229159Sadrian uint32_t pos_state) 621229159Sadrian{ 622229159Sadrian uint16_t *probs; 623229159Sadrian uint32_t limit; 624229159Sadrian 625229159Sadrian if (!rc_bit(&s->rc, &l->choice)) { 626229159Sadrian probs = l->low[pos_state]; 627229159Sadrian limit = LEN_LOW_SYMBOLS; 628229159Sadrian s->lzma.len = MATCH_LEN_MIN; 629229159Sadrian } else { 630229159Sadrian if (!rc_bit(&s->rc, &l->choice2)) { 631229159Sadrian probs = l->mid[pos_state]; 632229159Sadrian limit = LEN_MID_SYMBOLS; 633229159Sadrian s->lzma.len = MATCH_LEN_MIN + LEN_LOW_SYMBOLS; 634229159Sadrian } else { 635229159Sadrian probs = l->high; 636229159Sadrian limit = LEN_HIGH_SYMBOLS; 637229159Sadrian s->lzma.len = MATCH_LEN_MIN + LEN_LOW_SYMBOLS 638229159Sadrian + LEN_MID_SYMBOLS; 639229159Sadrian } 640229159Sadrian } 641229159Sadrian 642229159Sadrian s->lzma.len += rc_bittree(&s->rc, probs, limit) - limit; 643229159Sadrian} 644229159Sadrian 645229159Sadrian/* Decode a match. The distance will be stored in s->lzma.rep0. */ 646229159Sadrianstatic void lzma_match(struct xz_dec_lzma2 *s, uint32_t pos_state) 647229159Sadrian{ 648229159Sadrian uint16_t *probs; 649229159Sadrian uint32_t dist_slot; 650229159Sadrian uint32_t limit; 651229159Sadrian 652229159Sadrian lzma_state_match(&s->lzma.state); 653229159Sadrian 654229159Sadrian s->lzma.rep3 = s->lzma.rep2; 655229159Sadrian s->lzma.rep2 = s->lzma.rep1; 656229159Sadrian s->lzma.rep1 = s->lzma.rep0; 657229159Sadrian 658229159Sadrian lzma_len(s, &s->lzma.match_len_dec, pos_state); 659229159Sadrian 660229159Sadrian probs = s->lzma.dist_slot[lzma_get_dist_state(s->lzma.len)]; 661229159Sadrian dist_slot = rc_bittree(&s->rc, probs, DIST_SLOTS) - DIST_SLOTS; 662229159Sadrian 663229159Sadrian if (dist_slot < DIST_MODEL_START) { 664229159Sadrian s->lzma.rep0 = dist_slot; 665229159Sadrian } else { 666229159Sadrian limit = (dist_slot >> 1) - 1; 667229159Sadrian s->lzma.rep0 = 2 + (dist_slot & 1); 668229159Sadrian 669229159Sadrian if (dist_slot < DIST_MODEL_END) { 670229159Sadrian s->lzma.rep0 <<= limit; 671229159Sadrian probs = s->lzma.dist_special + s->lzma.rep0 672229159Sadrian - dist_slot - 1; 673229159Sadrian rc_bittree_reverse(&s->rc, probs, 674229159Sadrian &s->lzma.rep0, limit); 675229159Sadrian } else { 676229159Sadrian rc_direct(&s->rc, &s->lzma.rep0, limit - ALIGN_BITS); 677229159Sadrian s->lzma.rep0 <<= ALIGN_BITS; 678229159Sadrian rc_bittree_reverse(&s->rc, s->lzma.dist_align, 679229159Sadrian &s->lzma.rep0, ALIGN_BITS); 680229159Sadrian } 681229159Sadrian } 682229159Sadrian} 683229159Sadrian 684229159Sadrian/* 685229159Sadrian * Decode a repeated match. The distance is one of the four most recently 686229159Sadrian * seen matches. The distance will be stored in s->lzma.rep0. 687229159Sadrian */ 688229159Sadrianstatic void lzma_rep_match(struct xz_dec_lzma2 *s, uint32_t pos_state) 689229159Sadrian{ 690229159Sadrian uint32_t tmp; 691229159Sadrian 692229159Sadrian if (!rc_bit(&s->rc, &s->lzma.is_rep0[s->lzma.state])) { 693229159Sadrian if (!rc_bit(&s->rc, &s->lzma.is_rep0_long[ 694229159Sadrian s->lzma.state][pos_state])) { 695229159Sadrian lzma_state_short_rep(&s->lzma.state); 696229159Sadrian s->lzma.len = 1; 697229159Sadrian return; 698229159Sadrian } 699229159Sadrian } else { 700229159Sadrian if (!rc_bit(&s->rc, &s->lzma.is_rep1[s->lzma.state])) { 701229159Sadrian tmp = s->lzma.rep1; 702229159Sadrian } else { 703229159Sadrian if (!rc_bit(&s->rc, &s->lzma.is_rep2[s->lzma.state])) { 704229159Sadrian tmp = s->lzma.rep2; 705229159Sadrian } else { 706229159Sadrian tmp = s->lzma.rep3; 707229159Sadrian s->lzma.rep3 = s->lzma.rep2; 708229159Sadrian } 709229159Sadrian 710229159Sadrian s->lzma.rep2 = s->lzma.rep1; 711229159Sadrian } 712229159Sadrian 713229159Sadrian s->lzma.rep1 = s->lzma.rep0; 714229159Sadrian s->lzma.rep0 = tmp; 715229159Sadrian } 716229159Sadrian 717229159Sadrian lzma_state_long_rep(&s->lzma.state); 718229159Sadrian lzma_len(s, &s->lzma.rep_len_dec, pos_state); 719229159Sadrian} 720229159Sadrian 721229159Sadrian/* LZMA decoder core */ 722229159Sadrianstatic bool lzma_main(struct xz_dec_lzma2 *s) 723229159Sadrian{ 724229159Sadrian uint32_t pos_state; 725229159Sadrian 726229159Sadrian /* 727229159Sadrian * If the dictionary was reached during the previous call, try to 728229159Sadrian * finish the possibly pending repeat in the dictionary. 729229159Sadrian */ 730229159Sadrian if (dict_has_space(&s->dict) && s->lzma.len > 0) 731229159Sadrian dict_repeat(&s->dict, &s->lzma.len, s->lzma.rep0); 732229159Sadrian 733229159Sadrian /* 734229159Sadrian * Decode more LZMA symbols. One iteration may consume up to 735229159Sadrian * LZMA_IN_REQUIRED - 1 bytes. 736229159Sadrian */ 737229159Sadrian while (dict_has_space(&s->dict) && !rc_limit_exceeded(&s->rc)) { 738229159Sadrian pos_state = s->dict.pos & s->lzma.pos_mask; 739229159Sadrian 740229159Sadrian if (!rc_bit(&s->rc, &s->lzma.is_match[ 741229159Sadrian s->lzma.state][pos_state])) { 742229159Sadrian lzma_literal(s); 743229159Sadrian } else { 744229159Sadrian if (rc_bit(&s->rc, &s->lzma.is_rep[s->lzma.state])) 745229159Sadrian lzma_rep_match(s, pos_state); 746229159Sadrian else 747229159Sadrian lzma_match(s, pos_state); 748229159Sadrian 749229159Sadrian if (!dict_repeat(&s->dict, &s->lzma.len, s->lzma.rep0)) 750229159Sadrian return false; 751229159Sadrian } 752229159Sadrian } 753229159Sadrian 754229159Sadrian /* 755229159Sadrian * Having the range decoder always normalized when we are outside 756229159Sadrian * this function makes it easier to correctly handle end of the chunk. 757229159Sadrian */ 758229159Sadrian rc_normalize(&s->rc); 759229159Sadrian 760229159Sadrian return true; 761229159Sadrian} 762229159Sadrian 763229159Sadrian/* 764229159Sadrian * Reset the LZMA decoder and range decoder state. Dictionary is nore reset 765229159Sadrian * here, because LZMA state may be reset without resetting the dictionary. 766229159Sadrian */ 767229159Sadrianstatic void lzma_reset(struct xz_dec_lzma2 *s) 768229159Sadrian{ 769229159Sadrian uint16_t *probs; 770229159Sadrian size_t i; 771229159Sadrian 772229159Sadrian s->lzma.state = STATE_LIT_LIT; 773229159Sadrian s->lzma.rep0 = 0; 774229159Sadrian s->lzma.rep1 = 0; 775229159Sadrian s->lzma.rep2 = 0; 776229159Sadrian s->lzma.rep3 = 0; 777229159Sadrian 778229159Sadrian /* 779229159Sadrian * All probabilities are initialized to the same value. This hack 780229159Sadrian * makes the code smaller by avoiding a separate loop for each 781229159Sadrian * probability array. 782229159Sadrian * 783229159Sadrian * This could be optimized so that only that part of literal 784229159Sadrian * probabilities that are actually required. In the common case 785229159Sadrian * we would write 12 KiB less. 786229159Sadrian */ 787229159Sadrian probs = s->lzma.is_match[0]; 788229159Sadrian for (i = 0; i < PROBS_TOTAL; ++i) 789229159Sadrian probs[i] = RC_BIT_MODEL_TOTAL / 2; 790229159Sadrian 791229159Sadrian rc_reset(&s->rc); 792229159Sadrian} 793229159Sadrian 794229159Sadrian/* 795229159Sadrian * Decode and validate LZMA properties (lc/lp/pb) and calculate the bit masks 796229159Sadrian * from the decoded lp and pb values. On success, the LZMA decoder state is 797229159Sadrian * reset and true is returned. 798229159Sadrian */ 799229159Sadrianstatic bool lzma_props(struct xz_dec_lzma2 *s, uint8_t props) 800229159Sadrian{ 801229159Sadrian if (props > (4 * 5 + 4) * 9 + 8) 802229159Sadrian return false; 803229159Sadrian 804229159Sadrian s->lzma.pos_mask = 0; 805229159Sadrian while (props >= 9 * 5) { 806229159Sadrian props -= 9 * 5; 807229159Sadrian ++s->lzma.pos_mask; 808229159Sadrian } 809229159Sadrian 810229159Sadrian s->lzma.pos_mask = (1 << s->lzma.pos_mask) - 1; 811229159Sadrian 812229159Sadrian s->lzma.literal_pos_mask = 0; 813229159Sadrian while (props >= 9) { 814229159Sadrian props -= 9; 815229159Sadrian ++s->lzma.literal_pos_mask; 816229159Sadrian } 817229159Sadrian 818229159Sadrian s->lzma.lc = props; 819229159Sadrian 820229159Sadrian if (s->lzma.lc + s->lzma.literal_pos_mask > 4) 821229159Sadrian return false; 822229159Sadrian 823229159Sadrian s->lzma.literal_pos_mask = (1 << s->lzma.literal_pos_mask) - 1; 824229159Sadrian 825229159Sadrian lzma_reset(s); 826229159Sadrian 827229159Sadrian return true; 828229159Sadrian} 829229159Sadrian 830229159Sadrian/********* 831229159Sadrian * LZMA2 * 832229159Sadrian *********/ 833229159Sadrian 834229159Sadrian/* 835229159Sadrian * The LZMA decoder assumes that if the input limit (s->rc.in_limit) hasn't 836229159Sadrian * been exceeded, it is safe to read up to LZMA_IN_REQUIRED bytes. This 837229159Sadrian * wrapper function takes care of making the LZMA decoder's assumption safe. 838229159Sadrian * 839229159Sadrian * As long as there is plenty of input left to be decoded in the current LZMA 840229159Sadrian * chunk, we decode directly from the caller-supplied input buffer until 841229159Sadrian * there's LZMA_IN_REQUIRED bytes left. Those remaining bytes are copied into 842229159Sadrian * s->temp.buf, which (hopefully) gets filled on the next call to this 843229159Sadrian * function. We decode a few bytes from the temporary buffer so that we can 844229159Sadrian * continue decoding from the caller-supplied input buffer again. 845229159Sadrian */ 846229159Sadrianstatic bool lzma2_lzma(struct xz_dec_lzma2 *s, struct xz_buf *b) 847229159Sadrian{ 848229159Sadrian size_t in_avail; 849229159Sadrian uint32_t tmp; 850229159Sadrian 851229159Sadrian in_avail = b->in_size - b->in_pos; 852229159Sadrian if (s->temp.size > 0 || s->lzma2.compressed == 0) { 853229159Sadrian tmp = 2 * LZMA_IN_REQUIRED - s->temp.size; 854229159Sadrian if (tmp > s->lzma2.compressed - s->temp.size) 855229159Sadrian tmp = s->lzma2.compressed - s->temp.size; 856229159Sadrian if (tmp > in_avail) 857229159Sadrian tmp = in_avail; 858229159Sadrian 859229159Sadrian memcpy(s->temp.buf + s->temp.size, b->in + b->in_pos, tmp); 860229159Sadrian 861229159Sadrian if (s->temp.size + tmp == s->lzma2.compressed) { 862229159Sadrian memzero(s->temp.buf + s->temp.size + tmp, 863229159Sadrian sizeof(s->temp.buf) 864229159Sadrian - s->temp.size - tmp); 865229159Sadrian s->rc.in_limit = s->temp.size + tmp; 866229159Sadrian } else if (s->temp.size + tmp < LZMA_IN_REQUIRED) { 867229159Sadrian s->temp.size += tmp; 868229159Sadrian b->in_pos += tmp; 869229159Sadrian return true; 870229159Sadrian } else { 871229159Sadrian s->rc.in_limit = s->temp.size + tmp - LZMA_IN_REQUIRED; 872229159Sadrian } 873229159Sadrian 874229159Sadrian s->rc.in = s->temp.buf; 875229159Sadrian s->rc.in_pos = 0; 876229159Sadrian 877229159Sadrian if (!lzma_main(s) || s->rc.in_pos > s->temp.size + tmp) 878229159Sadrian return false; 879229159Sadrian 880229159Sadrian s->lzma2.compressed -= s->rc.in_pos; 881229159Sadrian 882229159Sadrian if (s->rc.in_pos < s->temp.size) { 883229159Sadrian s->temp.size -= s->rc.in_pos; 884229159Sadrian memmove(s->temp.buf, s->temp.buf + s->rc.in_pos, 885229159Sadrian s->temp.size); 886229159Sadrian return true; 887229159Sadrian } 888229159Sadrian 889229159Sadrian b->in_pos += s->rc.in_pos - s->temp.size; 890229159Sadrian s->temp.size = 0; 891229159Sadrian } 892229159Sadrian 893229159Sadrian in_avail = b->in_size - b->in_pos; 894229159Sadrian if (in_avail >= LZMA_IN_REQUIRED) { 895229159Sadrian s->rc.in = b->in; 896229159Sadrian s->rc.in_pos = b->in_pos; 897229159Sadrian 898229159Sadrian if (in_avail >= s->lzma2.compressed + LZMA_IN_REQUIRED) 899229159Sadrian s->rc.in_limit = b->in_pos + s->lzma2.compressed; 900229159Sadrian else 901229159Sadrian s->rc.in_limit = b->in_size - LZMA_IN_REQUIRED; 902229159Sadrian 903229159Sadrian if (!lzma_main(s)) 904229159Sadrian return false; 905229159Sadrian 906229159Sadrian in_avail = s->rc.in_pos - b->in_pos; 907229159Sadrian if (in_avail > s->lzma2.compressed) 908229159Sadrian return false; 909229159Sadrian 910229159Sadrian s->lzma2.compressed -= in_avail; 911229159Sadrian b->in_pos = s->rc.in_pos; 912229159Sadrian } 913229159Sadrian 914229159Sadrian in_avail = b->in_size - b->in_pos; 915229159Sadrian if (in_avail < LZMA_IN_REQUIRED) { 916229159Sadrian if (in_avail > s->lzma2.compressed) 917229159Sadrian in_avail = s->lzma2.compressed; 918229159Sadrian 919229159Sadrian memcpy(s->temp.buf, b->in + b->in_pos, in_avail); 920229159Sadrian s->temp.size = in_avail; 921229159Sadrian b->in_pos += in_avail; 922229159Sadrian } 923229159Sadrian 924229159Sadrian return true; 925229159Sadrian} 926229159Sadrian 927229159Sadrian/* 928229159Sadrian * Take care of the LZMA2 control layer, and forward the job of actual LZMA 929229159Sadrian * decoding or copying of uncompressed chunks to other functions. 930229159Sadrian */ 931229159SadrianXZ_EXTERN enum xz_ret xz_dec_lzma2_run(struct xz_dec_lzma2 *s, 932229159Sadrian struct xz_buf *b) 933229159Sadrian{ 934229159Sadrian uint32_t tmp; 935229159Sadrian 936229159Sadrian while (b->in_pos < b->in_size || s->lzma2.sequence == SEQ_LZMA_RUN) { 937229159Sadrian switch (s->lzma2.sequence) { 938229159Sadrian case SEQ_CONTROL: 939229159Sadrian /* 940229159Sadrian * LZMA2 control byte 941229159Sadrian * 942229159Sadrian * Exact values: 943229159Sadrian * 0x00 End marker 944229159Sadrian * 0x01 Dictionary reset followed by 945229159Sadrian * an uncompressed chunk 946229159Sadrian * 0x02 Uncompressed chunk (no dictionary reset) 947229159Sadrian * 948229159Sadrian * Highest three bits (s->control & 0xE0): 949229159Sadrian * 0xE0 Dictionary reset, new properties and state 950229159Sadrian * reset, followed by LZMA compressed chunk 951229159Sadrian * 0xC0 New properties and state reset, followed 952229159Sadrian * by LZMA compressed chunk (no dictionary 953229159Sadrian * reset) 954229159Sadrian * 0xA0 State reset using old properties, 955229159Sadrian * followed by LZMA compressed chunk (no 956229159Sadrian * dictionary reset) 957229159Sadrian * 0x80 LZMA chunk (no dictionary or state reset) 958229159Sadrian * 959229159Sadrian * For LZMA compressed chunks, the lowest five bits 960229159Sadrian * (s->control & 1F) are the highest bits of the 961229159Sadrian * uncompressed size (bits 16-20). 962229159Sadrian * 963229159Sadrian * A new LZMA2 stream must begin with a dictionary 964229159Sadrian * reset. The first LZMA chunk must set new 965229159Sadrian * properties and reset the LZMA state. 966229159Sadrian * 967229159Sadrian * Values that don't match anything described above 968229159Sadrian * are invalid and we return XZ_DATA_ERROR. 969229159Sadrian */ 970229159Sadrian tmp = b->in[b->in_pos++]; 971229159Sadrian 972229159Sadrian if (tmp == 0x00) 973229159Sadrian return XZ_STREAM_END; 974229159Sadrian 975229159Sadrian if (tmp >= 0xE0 || tmp == 0x01) { 976229159Sadrian s->lzma2.need_props = true; 977229159Sadrian s->lzma2.need_dict_reset = false; 978229159Sadrian dict_reset(&s->dict, b); 979229159Sadrian } else if (s->lzma2.need_dict_reset) { 980229159Sadrian return XZ_DATA_ERROR; 981229159Sadrian } 982229159Sadrian 983229159Sadrian if (tmp >= 0x80) { 984229159Sadrian s->lzma2.uncompressed = (tmp & 0x1F) << 16; 985229159Sadrian s->lzma2.sequence = SEQ_UNCOMPRESSED_1; 986229159Sadrian 987229159Sadrian if (tmp >= 0xC0) { 988229159Sadrian /* 989229159Sadrian * When there are new properties, 990229159Sadrian * state reset is done at 991229159Sadrian * SEQ_PROPERTIES. 992229159Sadrian */ 993229159Sadrian s->lzma2.need_props = false; 994229159Sadrian s->lzma2.next_sequence 995229159Sadrian = SEQ_PROPERTIES; 996229159Sadrian 997229159Sadrian } else if (s->lzma2.need_props) { 998229159Sadrian return XZ_DATA_ERROR; 999229159Sadrian 1000229159Sadrian } else { 1001229159Sadrian s->lzma2.next_sequence 1002229159Sadrian = SEQ_LZMA_PREPARE; 1003229159Sadrian if (tmp >= 0xA0) 1004229159Sadrian lzma_reset(s); 1005229159Sadrian } 1006229159Sadrian } else { 1007229159Sadrian if (tmp > 0x02) 1008229159Sadrian return XZ_DATA_ERROR; 1009229159Sadrian 1010229159Sadrian s->lzma2.sequence = SEQ_COMPRESSED_0; 1011229159Sadrian s->lzma2.next_sequence = SEQ_COPY; 1012229159Sadrian } 1013229159Sadrian 1014229159Sadrian break; 1015229159Sadrian 1016229159Sadrian case SEQ_UNCOMPRESSED_1: 1017229159Sadrian s->lzma2.uncompressed 1018229159Sadrian += (uint32_t)b->in[b->in_pos++] << 8; 1019229159Sadrian s->lzma2.sequence = SEQ_UNCOMPRESSED_2; 1020229159Sadrian break; 1021229159Sadrian 1022229159Sadrian case SEQ_UNCOMPRESSED_2: 1023229159Sadrian s->lzma2.uncompressed 1024229159Sadrian += (uint32_t)b->in[b->in_pos++] + 1; 1025229159Sadrian s->lzma2.sequence = SEQ_COMPRESSED_0; 1026229159Sadrian break; 1027229159Sadrian 1028229159Sadrian case SEQ_COMPRESSED_0: 1029229159Sadrian s->lzma2.compressed 1030229159Sadrian = (uint32_t)b->in[b->in_pos++] << 8; 1031229159Sadrian s->lzma2.sequence = SEQ_COMPRESSED_1; 1032229159Sadrian break; 1033229159Sadrian 1034229159Sadrian case SEQ_COMPRESSED_1: 1035229159Sadrian s->lzma2.compressed 1036229159Sadrian += (uint32_t)b->in[b->in_pos++] + 1; 1037229159Sadrian s->lzma2.sequence = s->lzma2.next_sequence; 1038229159Sadrian break; 1039229159Sadrian 1040229159Sadrian case SEQ_PROPERTIES: 1041229159Sadrian if (!lzma_props(s, b->in[b->in_pos++])) 1042229159Sadrian return XZ_DATA_ERROR; 1043229159Sadrian 1044229159Sadrian s->lzma2.sequence = SEQ_LZMA_PREPARE; 1045229159Sadrian 1046229159Sadrian case SEQ_LZMA_PREPARE: 1047229159Sadrian if (s->lzma2.compressed < RC_INIT_BYTES) 1048229159Sadrian return XZ_DATA_ERROR; 1049229159Sadrian 1050229159Sadrian if (!rc_read_init(&s->rc, b)) 1051229159Sadrian return XZ_OK; 1052229159Sadrian 1053229159Sadrian s->lzma2.compressed -= RC_INIT_BYTES; 1054229159Sadrian s->lzma2.sequence = SEQ_LZMA_RUN; 1055229159Sadrian 1056229159Sadrian case SEQ_LZMA_RUN: 1057229159Sadrian /* 1058229159Sadrian * Set dictionary limit to indicate how much we want 1059229159Sadrian * to be encoded at maximum. Decode new data into the 1060229159Sadrian * dictionary. Flush the new data from dictionary to 1061229159Sadrian * b->out. Check if we finished decoding this chunk. 1062229159Sadrian * In case the dictionary got full but we didn't fill 1063229159Sadrian * the output buffer yet, we may run this loop 1064229159Sadrian * multiple times without changing s->lzma2.sequence. 1065229159Sadrian */ 1066229159Sadrian dict_limit(&s->dict, min_t(size_t, 1067229159Sadrian b->out_size - b->out_pos, 1068229159Sadrian s->lzma2.uncompressed)); 1069229159Sadrian if (!lzma2_lzma(s, b)) 1070229159Sadrian return XZ_DATA_ERROR; 1071229159Sadrian 1072229159Sadrian s->lzma2.uncompressed -= dict_flush(&s->dict, b); 1073229159Sadrian 1074229159Sadrian if (s->lzma2.uncompressed == 0) { 1075229159Sadrian if (s->lzma2.compressed > 0 || s->lzma.len > 0 1076229159Sadrian || !rc_is_finished(&s->rc)) 1077229159Sadrian return XZ_DATA_ERROR; 1078229159Sadrian 1079229159Sadrian rc_reset(&s->rc); 1080229159Sadrian s->lzma2.sequence = SEQ_CONTROL; 1081229159Sadrian 1082229159Sadrian } else if (b->out_pos == b->out_size 1083229159Sadrian || (b->in_pos == b->in_size 1084229159Sadrian && s->temp.size 1085229159Sadrian < s->lzma2.compressed)) { 1086229159Sadrian return XZ_OK; 1087229159Sadrian } 1088229159Sadrian 1089229159Sadrian break; 1090229159Sadrian 1091229159Sadrian case SEQ_COPY: 1092229159Sadrian dict_uncompressed(&s->dict, b, &s->lzma2.compressed); 1093229159Sadrian if (s->lzma2.compressed > 0) 1094229159Sadrian return XZ_OK; 1095229159Sadrian 1096229159Sadrian s->lzma2.sequence = SEQ_CONTROL; 1097229159Sadrian break; 1098229159Sadrian } 1099229159Sadrian } 1100229159Sadrian 1101229159Sadrian return XZ_OK; 1102229159Sadrian} 1103229159Sadrian 1104229159SadrianXZ_EXTERN struct xz_dec_lzma2 *xz_dec_lzma2_create(enum xz_mode mode, 1105229159Sadrian uint32_t dict_max) 1106229159Sadrian{ 1107229159Sadrian struct xz_dec_lzma2 *s = kmalloc(sizeof(*s), GFP_KERNEL); 1108229159Sadrian if (s == NULL) 1109229159Sadrian return NULL; 1110229159Sadrian 1111229159Sadrian s->dict.mode = mode; 1112229159Sadrian s->dict.size_max = dict_max; 1113229159Sadrian 1114229159Sadrian if (DEC_IS_PREALLOC(mode)) { 1115229159Sadrian s->dict.buf = vmalloc(dict_max); 1116229159Sadrian if (s->dict.buf == NULL) { 1117229159Sadrian kfree(s); 1118229159Sadrian return NULL; 1119229159Sadrian } 1120229159Sadrian } else if (DEC_IS_DYNALLOC(mode)) { 1121229159Sadrian s->dict.buf = NULL; 1122229159Sadrian s->dict.allocated = 0; 1123229159Sadrian } 1124229159Sadrian 1125229159Sadrian return s; 1126229159Sadrian} 1127229159Sadrian 1128229159SadrianXZ_EXTERN enum xz_ret xz_dec_lzma2_reset(struct xz_dec_lzma2 *s, uint8_t props) 1129229159Sadrian{ 1130229159Sadrian /* This limits dictionary size to 3 GiB to keep parsing simpler. */ 1131229159Sadrian if (props > 39) 1132229159Sadrian return XZ_OPTIONS_ERROR; 1133229159Sadrian 1134229159Sadrian s->dict.size = 2 + (props & 1); 1135229159Sadrian s->dict.size <<= (props >> 1) + 11; 1136229159Sadrian 1137229159Sadrian if (DEC_IS_MULTI(s->dict.mode)) { 1138229159Sadrian if (s->dict.size > s->dict.size_max) 1139229159Sadrian return XZ_MEMLIMIT_ERROR; 1140229159Sadrian 1141229159Sadrian s->dict.end = s->dict.size; 1142229159Sadrian 1143229159Sadrian if (DEC_IS_DYNALLOC(s->dict.mode)) { 1144229159Sadrian if (s->dict.allocated < s->dict.size) { 1145229159Sadrian vfree(s->dict.buf); 1146229159Sadrian s->dict.buf = vmalloc(s->dict.size); 1147229159Sadrian if (s->dict.buf == NULL) { 1148229159Sadrian s->dict.allocated = 0; 1149229159Sadrian return XZ_MEM_ERROR; 1150229159Sadrian } 1151229159Sadrian } 1152229159Sadrian } 1153229159Sadrian } 1154229159Sadrian 1155229159Sadrian s->lzma.len = 0; 1156229159Sadrian 1157229159Sadrian s->lzma2.sequence = SEQ_CONTROL; 1158229159Sadrian s->lzma2.need_dict_reset = true; 1159229159Sadrian 1160229159Sadrian s->temp.size = 0; 1161229159Sadrian 1162229159Sadrian return XZ_OK; 1163229159Sadrian} 1164229159Sadrian 1165229159SadrianXZ_EXTERN void xz_dec_lzma2_end(struct xz_dec_lzma2 *s) 1166229159Sadrian{ 1167229159Sadrian if (DEC_IS_MULTI(s->dict.mode)) 1168229159Sadrian vfree(s->dict.buf); 1169229159Sadrian 1170229159Sadrian kfree(s); 1171229159Sadrian} 1172