1 |
/////////////////////////////////////////////////////////////////////////////// |
2 |
// |
3 |
/// \file lzma_decoder.c |
4 |
/// \brief LZMA decoder |
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 "lz_decoder.h" |
15 |
#include "lzma_common.h" |
16 |
#include "lzma_decoder.h" |
17 |
#include "range_decoder.h" |
18 |
|
19 |
|
20 |
#ifdef HAVE_SMALL |
21 |
|
22 |
// Macros for (somewhat) size-optimized code. |
23 |
#define seq_4(seq) seq |
24 |
|
25 |
#define seq_6(seq) seq |
26 |
|
27 |
#define seq_8(seq) seq |
28 |
|
29 |
#define seq_len(seq) \ |
30 |
seq ## _CHOICE, \ |
31 |
seq ## _CHOICE2, \ |
32 |
seq ## _BITTREE |
33 |
|
34 |
#define len_decode(target, ld, pos_state, seq) \ |
35 |
do { \ |
36 |
case seq ## _CHOICE: \ |
37 |
rc_if_0(ld.choice, seq ## _CHOICE) { \ |
38 |
rc_update_0(ld.choice); \ |
39 |
probs = ld.low[pos_state];\ |
40 |
limit = LEN_LOW_SYMBOLS; \ |
41 |
target = MATCH_LEN_MIN; \ |
42 |
} else { \ |
43 |
rc_update_1(ld.choice); \ |
44 |
case seq ## _CHOICE2: \ |
45 |
rc_if_0(ld.choice2, seq ## _CHOICE2) { \ |
46 |
rc_update_0(ld.choice2); \ |
47 |
probs = ld.mid[pos_state]; \ |
48 |
limit = LEN_MID_SYMBOLS; \ |
49 |
target = MATCH_LEN_MIN + LEN_LOW_SYMBOLS; \ |
50 |
} else { \ |
51 |
rc_update_1(ld.choice2); \ |
52 |
probs = ld.high; \ |
53 |
limit = LEN_HIGH_SYMBOLS; \ |
54 |
target = MATCH_LEN_MIN + LEN_LOW_SYMBOLS \ |
55 |
+ LEN_MID_SYMBOLS; \ |
56 |
} \ |
57 |
} \ |
58 |
symbol = 1; \ |
59 |
case seq ## _BITTREE: \ |
60 |
do { \ |
61 |
rc_bit(probs[symbol], , , seq ## _BITTREE); \ |
62 |
} while (symbol < limit); \ |
63 |
target += symbol - limit; \ |
64 |
} while (0) |
65 |
|
66 |
#else // HAVE_SMALL |
67 |
|
68 |
// Unrolled versions |
69 |
#define seq_4(seq) \ |
70 |
seq ## 0, \ |
71 |
seq ## 1, \ |
72 |
seq ## 2, \ |
73 |
seq ## 3 |
74 |
|
75 |
#define seq_6(seq) \ |
76 |
seq ## 0, \ |
77 |
seq ## 1, \ |
78 |
seq ## 2, \ |
79 |
seq ## 3, \ |
80 |
seq ## 4, \ |
81 |
seq ## 5 |
82 |
|
83 |
#define seq_8(seq) \ |
84 |
seq ## 0, \ |
85 |
seq ## 1, \ |
86 |
seq ## 2, \ |
87 |
seq ## 3, \ |
88 |
seq ## 4, \ |
89 |
seq ## 5, \ |
90 |
seq ## 6, \ |
91 |
seq ## 7 |
92 |
|
93 |
#define seq_len(seq) \ |
94 |
seq ## _CHOICE, \ |
95 |
seq ## _LOW0, \ |
96 |
seq ## _LOW1, \ |
97 |
seq ## _LOW2, \ |
98 |
seq ## _CHOICE2, \ |
99 |
seq ## _MID0, \ |
100 |
seq ## _MID1, \ |
101 |
seq ## _MID2, \ |
102 |
seq ## _HIGH0, \ |
103 |
seq ## _HIGH1, \ |
104 |
seq ## _HIGH2, \ |
105 |
seq ## _HIGH3, \ |
106 |
seq ## _HIGH4, \ |
107 |
seq ## _HIGH5, \ |
108 |
seq ## _HIGH6, \ |
109 |
seq ## _HIGH7 |
110 |
|
111 |
#define len_decode(target, ld, pos_state, seq) \ |
112 |
do { \ |
113 |
symbol = 1; \ |
114 |
case seq ## _CHOICE: \ |
115 |
rc_if_0(ld.choice, seq ## _CHOICE) { \ |
116 |
rc_update_0(ld.choice); \ |
117 |
rc_bit_case(ld.low[pos_state][symbol], , , seq ## _LOW0); \ |
118 |
rc_bit_case(ld.low[pos_state][symbol], , , seq ## _LOW1); \ |
119 |
rc_bit_case(ld.low[pos_state][symbol], , , seq ## _LOW2); \ |
120 |
target = symbol - LEN_LOW_SYMBOLS + MATCH_LEN_MIN; \ |
121 |
} else { \ |
122 |
rc_update_1(ld.choice); \ |
123 |
case seq ## _CHOICE2: \ |
124 |
rc_if_0(ld.choice2, seq ## _CHOICE2) { \ |
125 |
rc_update_0(ld.choice2); \ |
126 |
rc_bit_case(ld.mid[pos_state][symbol], , , \ |
127 |
seq ## _MID0); \ |
128 |
rc_bit_case(ld.mid[pos_state][symbol], , , \ |
129 |
seq ## _MID1); \ |
130 |
rc_bit_case(ld.mid[pos_state][symbol], , , \ |
131 |
seq ## _MID2); \ |
132 |
target = symbol - LEN_MID_SYMBOLS \ |
133 |
+ MATCH_LEN_MIN + LEN_LOW_SYMBOLS; \ |
134 |
} else { \ |
135 |
rc_update_1(ld.choice2); \ |
136 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH0); \ |
137 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH1); \ |
138 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH2); \ |
139 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH3); \ |
140 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH4); \ |
141 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH5); \ |
142 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH6); \ |
143 |
rc_bit_case(ld.high[symbol], , , seq ## _HIGH7); \ |
144 |
target = symbol - LEN_HIGH_SYMBOLS \ |
145 |
+ MATCH_LEN_MIN \ |
146 |
+ LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS; \ |
147 |
} \ |
148 |
} \ |
149 |
} while (0) |
150 |
|
151 |
#endif // HAVE_SMALL |
152 |
|
153 |
|
154 |
/// Length decoder probabilities; see comments in lzma_common.h. |
155 |
typedef struct { |
156 |
probability choice; |
157 |
probability choice2; |
158 |
probability low[POS_STATES_MAX][LEN_LOW_SYMBOLS]; |
159 |
probability mid[POS_STATES_MAX][LEN_MID_SYMBOLS]; |
160 |
probability high[LEN_HIGH_SYMBOLS]; |
161 |
} lzma_length_decoder; |
162 |
|
163 |
|
164 |
typedef struct { |
165 |
/////////////////// |
166 |
// Probabilities // |
167 |
/////////////////// |
168 |
|
169 |
/// Literals; see comments in lzma_common.h. |
170 |
probability literal[LITERAL_CODERS_MAX][LITERAL_CODER_SIZE]; |
171 |
|
172 |
/// If 1, it's a match. Otherwise it's a single 8-bit literal. |
173 |
probability is_match[STATES][POS_STATES_MAX]; |
174 |
|
175 |
/// If 1, it's a repeated match. The distance is one of rep0 .. rep3. |
176 |
probability is_rep[STATES]; |
177 |
|
178 |
/// If 0, distance of a repeated match is rep0. |
179 |
/// Otherwise check is_rep1. |
180 |
probability is_rep0[STATES]; |
181 |
|
182 |
/// If 0, distance of a repeated match is rep1. |
183 |
/// Otherwise check is_rep2. |
184 |
probability is_rep1[STATES]; |
185 |
|
186 |
/// If 0, distance of a repeated match is rep2. Otherwise it is rep3. |
187 |
probability is_rep2[STATES]; |
188 |
|
189 |
/// If 1, the repeated match has length of one byte. Otherwise |
190 |
/// the length is decoded from rep_len_decoder. |
191 |
probability is_rep0_long[STATES][POS_STATES_MAX]; |
192 |
|
193 |
/// Probability tree for the highest two bits of the match distance. |
194 |
/// There is a separate probability tree for match lengths of |
195 |
/// 2 (i.e. MATCH_LEN_MIN), 3, 4, and [5, 273]. |
196 |
probability dist_slot[DIST_STATES][DIST_SLOTS]; |
197 |
|
198 |
/// Probability trees for additional bits for match distance when the |
199 |
/// distance is in the range [4, 127]. |
200 |
probability pos_special[FULL_DISTANCES - DIST_MODEL_END]; |
201 |
|
202 |
/// Probability tree for the lowest four bits of a match distance |
203 |
/// that is equal to or greater than 128. |
204 |
probability pos_align[ALIGN_SIZE]; |
205 |
|
206 |
/// Length of a normal match |
207 |
lzma_length_decoder match_len_decoder; |
208 |
|
209 |
/// Length of a repeated match |
210 |
lzma_length_decoder rep_len_decoder; |
211 |
|
212 |
/////////////////// |
213 |
// Decoder state // |
214 |
/////////////////// |
215 |
|
216 |
// Range coder |
217 |
lzma_range_decoder rc; |
218 |
|
219 |
// Types of the most recently seen LZMA symbols |
220 |
lzma_lzma_state state; |
221 |
|
222 |
uint32_t rep0; ///< Distance of the latest match |
223 |
uint32_t rep1; ///< Distance of second latest match |
224 |
uint32_t rep2; ///< Distance of third latest match |
225 |
uint32_t rep3; ///< Distance of fourth latest match |
226 |
|
227 |
uint32_t pos_mask; // (1U << pb) - 1 |
228 |
uint32_t literal_context_bits; |
229 |
uint32_t literal_pos_mask; |
230 |
|
231 |
/// Uncompressed size as bytes, or LZMA_VLI_UNKNOWN if end of |
232 |
/// payload marker is expected. |
233 |
lzma_vli uncompressed_size; |
234 |
|
235 |
//////////////////////////////// |
236 |
// State of incomplete symbol // |
237 |
//////////////////////////////// |
238 |
|
239 |
/// Position where to continue the decoder loop |
240 |
enum { |
241 |
SEQ_NORMALIZE, |
242 |
SEQ_IS_MATCH, |
243 |
seq_8(SEQ_LITERAL), |
244 |
seq_8(SEQ_LITERAL_MATCHED), |
245 |
SEQ_LITERAL_WRITE, |
246 |
SEQ_IS_REP, |
247 |
seq_len(SEQ_MATCH_LEN), |
248 |
seq_6(SEQ_DIST_SLOT), |
249 |
SEQ_DIST_MODEL, |
250 |
SEQ_DIRECT, |
251 |
seq_4(SEQ_ALIGN), |
252 |
SEQ_EOPM, |
253 |
SEQ_IS_REP0, |
254 |
SEQ_SHORTREP, |
255 |
SEQ_IS_REP0_LONG, |
256 |
SEQ_IS_REP1, |
257 |
SEQ_IS_REP2, |
258 |
seq_len(SEQ_REP_LEN), |
259 |
SEQ_COPY, |
260 |
} sequence; |
261 |
|
262 |
/// Base of the current probability tree |
263 |
probability *probs; |
264 |
|
265 |
/// Symbol being decoded. This is also used as an index variable in |
266 |
/// bittree decoders: probs[symbol] |
267 |
uint32_t symbol; |
268 |
|
269 |
/// Used as a loop termination condition on bittree decoders and |
270 |
/// direct bits decoder. |
271 |
uint32_t limit; |
272 |
|
273 |
/// Matched literal decoder: 0x100 or 0 to help avoiding branches. |
274 |
/// Bittree reverse decoders: Offset of the next bit: 1 << offset |
275 |
uint32_t offset; |
276 |
|
277 |
/// If decoding a literal: match byte. |
278 |
/// If decoding a match: length of the match. |
279 |
uint32_t len; |
280 |
} lzma_lzma1_decoder; |
281 |
|
282 |
|
283 |
static lzma_ret |
284 |
lzma_decode(void *coder_ptr, lzma_dict *restrict dictptr, |
285 |
const uint8_t *restrict in, |
286 |
size_t *restrict in_pos, size_t in_size) |
287 |
{ |
288 |
lzma_lzma1_decoder *restrict coder = coder_ptr; |
289 |
|
290 |
//////////////////// |
291 |
// Initialization // |
292 |
//////////////////// |
293 |
|
294 |
{ |
295 |
const lzma_ret ret = rc_read_init( |
296 |
&coder->rc, in, in_pos, in_size); |
297 |
if (ret != LZMA_STREAM_END) |
298 |
return ret; |
299 |
} |
300 |
|
301 |
/////////////// |
302 |
// Variables // |
303 |
/////////////// |
304 |
|
305 |
// Making local copies of often-used variables improves both |
306 |
// speed and readability. |
307 |
|
308 |
lzma_dict dict = *dictptr; |
309 |
|
310 |
const size_t dict_start = dict.pos; |
311 |
|
312 |
// Range decoder |
313 |
rc_to_local(coder->rc, *in_pos); |
314 |
|
315 |
// State |
316 |
uint32_t state = coder->state; |
317 |
uint32_t rep0 = coder->rep0; |
318 |
uint32_t rep1 = coder->rep1; |
319 |
uint32_t rep2 = coder->rep2; |
320 |
uint32_t rep3 = coder->rep3; |
321 |
|
322 |
const uint32_t pos_mask = coder->pos_mask; |
323 |
|
324 |
// These variables are actually needed only if we last time ran |
325 |
// out of input in the middle of the decoder loop. |
326 |
probability *probs = coder->probs; |
327 |
uint32_t symbol = coder->symbol; |
328 |
uint32_t limit = coder->limit; |
329 |
uint32_t offset = coder->offset; |
330 |
uint32_t len = coder->len; |
331 |
|
332 |
const uint32_t literal_pos_mask = coder->literal_pos_mask; |
333 |
const uint32_t literal_context_bits = coder->literal_context_bits; |
334 |
|
335 |
// Temporary variables |
336 |
uint32_t pos_state = dict.pos & pos_mask; |
337 |
|
338 |
lzma_ret ret = LZMA_OK; |
339 |
|
340 |
// If uncompressed size is known, there must be no end of payload |
341 |
// marker. |
342 |
const bool no_eopm = coder->uncompressed_size |
343 |
!= LZMA_VLI_UNKNOWN; |
344 |
if (no_eopm && coder->uncompressed_size < dict.limit - dict.pos) |
345 |
dict.limit = dict.pos + (size_t)(coder->uncompressed_size); |
346 |
|
347 |
// The main decoder loop. The "switch" is used to restart the decoder at |
348 |
// correct location. Once restarted, the "switch" is no longer used. |
349 |
switch (coder->sequence) |
350 |
while (true) { |
351 |
// Calculate new pos_state. This is skipped on the first loop |
352 |
// since we already calculated it when setting up the local |
353 |
// variables. |
354 |
pos_state = dict.pos & pos_mask; |
355 |
|
356 |
case SEQ_NORMALIZE: |
357 |
case SEQ_IS_MATCH: |
358 |
if (unlikely(no_eopm && dict.pos == dict.limit)) |
359 |
break; |
360 |
|
361 |
rc_if_0(coder->is_match[state][pos_state], SEQ_IS_MATCH) { |
362 |
rc_update_0(coder->is_match[state][pos_state]); |
363 |
|
364 |
// It's a literal i.e. a single 8-bit byte. |
365 |
|
366 |
probs = literal_subcoder(coder->literal, |
367 |
literal_context_bits, literal_pos_mask, |
368 |
dict.pos, dict_get(&dict, 0)); |
369 |
symbol = 1; |
370 |
|
371 |
if (is_literal_state(state)) { |
372 |
// Decode literal without match byte. |
373 |
#ifdef HAVE_SMALL |
374 |
case SEQ_LITERAL: |
375 |
do { |
376 |
rc_bit(probs[symbol], , , SEQ_LITERAL); |
377 |
} while (symbol < (1 << 8)); |
378 |
#else |
379 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL0); |
380 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL1); |
381 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL2); |
382 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL3); |
383 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL4); |
384 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL5); |
385 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL6); |
386 |
rc_bit_case(probs[symbol], , , SEQ_LITERAL7); |
387 |
#endif |
388 |
} else { |
389 |
// Decode literal with match byte. |
390 |
// |
391 |
// We store the byte we compare against |
392 |
// ("match byte") to "len" to minimize the |
393 |
// number of variables we need to store |
394 |
// between decoder calls. |
395 |
len = dict_get(&dict, rep0) << 1; |
396 |
|
397 |
// The usage of "offset" allows omitting some |
398 |
// branches, which should give tiny speed |
399 |
// improvement on some CPUs. "offset" gets |
400 |
// set to zero if match_bit didn't match. |
401 |
offset = 0x100; |
402 |
|
403 |
#ifdef HAVE_SMALL |
404 |
case SEQ_LITERAL_MATCHED: |
405 |
do { |
406 |
const uint32_t match_bit |
407 |
= len & offset; |
408 |
const uint32_t subcoder_index |
409 |
= offset + match_bit |
410 |
+ symbol; |
411 |
|
412 |
rc_bit(probs[subcoder_index], |
413 |
offset &= ~match_bit, |
414 |
offset &= match_bit, |
415 |
SEQ_LITERAL_MATCHED); |
416 |
|
417 |
// It seems to be faster to do this |
418 |
// here instead of putting it to the |
419 |
// beginning of the loop and then |
420 |
// putting the "case" in the middle |
421 |
// of the loop. |
422 |
len <<= 1; |
423 |
|
424 |
} while (symbol < (1 << 8)); |
425 |
#else |
426 |
// Unroll the loop. |
427 |
uint32_t match_bit; |
428 |
uint32_t subcoder_index; |
429 |
|
430 |
# define d(seq) \ |
431 |
case seq: \ |
432 |
match_bit = len & offset; \ |
433 |
subcoder_index = offset + match_bit + symbol; \ |
434 |
rc_bit(probs[subcoder_index], \ |
435 |
offset &= ~match_bit, \ |
436 |
offset &= match_bit, \ |
437 |
seq) |
438 |
|
439 |
d(SEQ_LITERAL_MATCHED0); |
440 |
len <<= 1; |
441 |
d(SEQ_LITERAL_MATCHED1); |
442 |
len <<= 1; |
443 |
d(SEQ_LITERAL_MATCHED2); |
444 |
len <<= 1; |
445 |
d(SEQ_LITERAL_MATCHED3); |
446 |
len <<= 1; |
447 |
d(SEQ_LITERAL_MATCHED4); |
448 |
len <<= 1; |
449 |
d(SEQ_LITERAL_MATCHED5); |
450 |
len <<= 1; |
451 |
d(SEQ_LITERAL_MATCHED6); |
452 |
len <<= 1; |
453 |
d(SEQ_LITERAL_MATCHED7); |
454 |
# undef d |
455 |
#endif |
456 |
} |
457 |
|
458 |
//update_literal(state); |
459 |
// Use a lookup table to update to literal state, |
460 |
// since compared to other state updates, this would |
461 |
// need two branches. |
462 |
static const lzma_lzma_state next_state[] = { |
463 |
STATE_LIT_LIT, |
464 |
STATE_LIT_LIT, |
465 |
STATE_LIT_LIT, |
466 |
STATE_LIT_LIT, |
467 |
STATE_MATCH_LIT_LIT, |
468 |
STATE_REP_LIT_LIT, |
469 |
STATE_SHORTREP_LIT_LIT, |
470 |
STATE_MATCH_LIT, |
471 |
STATE_REP_LIT, |
472 |
STATE_SHORTREP_LIT, |
473 |
STATE_MATCH_LIT, |
474 |
STATE_REP_LIT |
475 |
}; |
476 |
state = next_state[state]; |
477 |
|
478 |
case SEQ_LITERAL_WRITE: |
479 |
if (unlikely(dict_put(&dict, symbol))) { |
480 |
coder->sequence = SEQ_LITERAL_WRITE; |
481 |
goto out; |
482 |
} |
483 |
|
484 |
continue; |
485 |
} |
486 |
|
487 |
// Instead of a new byte we are going to get a byte range |
488 |
// (distance and length) which will be repeated from our |
489 |
// output history. |
490 |
|
491 |
rc_update_1(coder->is_match[state][pos_state]); |
492 |
|
493 |
case SEQ_IS_REP: |
494 |
rc_if_0(coder->is_rep[state], SEQ_IS_REP) { |
495 |
// Not a repeated match |
496 |
rc_update_0(coder->is_rep[state]); |
497 |
update_match(state); |
498 |
|
499 |
// The latest three match distances are kept in |
500 |
// memory in case there are repeated matches. |
501 |
rep3 = rep2; |
502 |
rep2 = rep1; |
503 |
rep1 = rep0; |
504 |
|
505 |
// Decode the length of the match. |
506 |
len_decode(len, coder->match_len_decoder, |
507 |
pos_state, SEQ_MATCH_LEN); |
508 |
|
509 |
// Prepare to decode the highest two bits of the |
510 |
// match distance. |
511 |
probs = coder->dist_slot[get_dist_state(len)]; |
512 |
symbol = 1; |
513 |
|
514 |
#ifdef HAVE_SMALL |
515 |
case SEQ_DIST_SLOT: |
516 |
do { |
517 |
rc_bit(probs[symbol], , , SEQ_DIST_SLOT); |
518 |
} while (symbol < DIST_SLOTS); |
519 |
#else |
520 |
rc_bit_case(probs[symbol], , , SEQ_DIST_SLOT0); |
521 |
rc_bit_case(probs[symbol], , , SEQ_DIST_SLOT1); |
522 |
rc_bit_case(probs[symbol], , , SEQ_DIST_SLOT2); |
523 |
rc_bit_case(probs[symbol], , , SEQ_DIST_SLOT3); |
524 |
rc_bit_case(probs[symbol], , , SEQ_DIST_SLOT4); |
525 |
rc_bit_case(probs[symbol], , , SEQ_DIST_SLOT5); |
526 |
#endif |
527 |
// Get rid of the highest bit that was needed for |
528 |
// indexing of the probability array. |
529 |
symbol -= DIST_SLOTS; |
530 |
assert(symbol <= 63); |
531 |
|
532 |
if (symbol < DIST_MODEL_START) { |
533 |
// Match distances [0, 3] have only two bits. |
534 |
rep0 = symbol; |
535 |
} else { |
536 |
// Decode the lowest [1, 29] bits of |
537 |
// the match distance. |
538 |
limit = (symbol >> 1) - 1; |
539 |
assert(limit >= 1 && limit <= 30); |
540 |
rep0 = 2 + (symbol & 1); |
541 |
|
542 |
if (symbol < DIST_MODEL_END) { |
543 |
// Prepare to decode the low bits for |
544 |
// a distance of [4, 127]. |
545 |
assert(limit <= 5); |
546 |
rep0 <<= limit; |
547 |
assert(rep0 <= 96); |
548 |
// -1 is fine, because we start |
549 |
// decoding at probs[1], not probs[0]. |
550 |
// NOTE: This violates the C standard, |
551 |
// since we are doing pointer |
552 |
// arithmetic past the beginning of |
553 |
// the array. |
554 |
assert((int32_t)(rep0 - symbol - 1) |
555 |
>= -1); |
556 |
assert((int32_t)(rep0 - symbol - 1) |
557 |
<= 82); |
558 |
probs = coder->pos_special + rep0 |
559 |
- symbol - 1; |
560 |
symbol = 1; |
561 |
offset = 0; |
562 |
case SEQ_DIST_MODEL: |
563 |
#ifdef HAVE_SMALL |
564 |
do { |
565 |
rc_bit(probs[symbol], , |
566 |
rep0 += 1 << offset, |
567 |
SEQ_DIST_MODEL); |
568 |
} while (++offset < limit); |
569 |
#else |
570 |
switch (limit) { |
571 |
case 5: |
572 |
assert(offset == 0); |
573 |
rc_bit(probs[symbol], , |
574 |
rep0 += 1, |
575 |
SEQ_DIST_MODEL); |
576 |
++offset; |
577 |
--limit; |
578 |
case 4: |
579 |
rc_bit(probs[symbol], , |
580 |
rep0 += 1 << offset, |
581 |
SEQ_DIST_MODEL); |
582 |
++offset; |
583 |
--limit; |
584 |
case 3: |
585 |
rc_bit(probs[symbol], , |
586 |
rep0 += 1 << offset, |
587 |
SEQ_DIST_MODEL); |
588 |
++offset; |
589 |
--limit; |
590 |
case 2: |
591 |
rc_bit(probs[symbol], , |
592 |
rep0 += 1 << offset, |
593 |
SEQ_DIST_MODEL); |
594 |
++offset; |
595 |
--limit; |
596 |
case 1: |
597 |
// We need "symbol" only for |
598 |
// indexing the probability |
599 |
// array, thus we can use |
600 |
// rc_bit_last() here to omit |
601 |
// the unneeded updating of |
602 |
// "symbol". |
603 |
rc_bit_last(probs[symbol], , |
604 |
rep0 += 1 << offset, |
605 |
SEQ_DIST_MODEL); |
606 |
} |
607 |
#endif |
608 |
} else { |
609 |
// The distance is >= 128. Decode the |
610 |
// lower bits without probabilities |
611 |
// except the lowest four bits. |
612 |
assert(symbol >= 14); |
613 |
assert(limit >= 6); |
614 |
limit -= ALIGN_BITS; |
615 |
assert(limit >= 2); |
616 |
case SEQ_DIRECT: |
617 |
// Not worth manual unrolling |
618 |
do { |
619 |
rc_direct(rep0, SEQ_DIRECT); |
620 |
} while (--limit > 0); |
621 |
|
622 |
// Decode the lowest four bits using |
623 |
// probabilities. |
624 |
rep0 <<= ALIGN_BITS; |
625 |
symbol = 1; |
626 |
#ifdef HAVE_SMALL |
627 |
offset = 0; |
628 |
case SEQ_ALIGN: |
629 |
do { |
630 |
rc_bit(coder->pos_align[ |
631 |
symbol], , |
632 |
rep0 += 1 << offset, |
633 |
SEQ_ALIGN); |
634 |
} while (++offset < ALIGN_BITS); |
635 |
#else |
636 |
case SEQ_ALIGN0: |
637 |
rc_bit(coder->pos_align[symbol], , |
638 |
rep0 += 1, SEQ_ALIGN0); |
639 |
case SEQ_ALIGN1: |
640 |
rc_bit(coder->pos_align[symbol], , |
641 |
rep0 += 2, SEQ_ALIGN1); |
642 |
case SEQ_ALIGN2: |
643 |
rc_bit(coder->pos_align[symbol], , |
644 |
rep0 += 4, SEQ_ALIGN2); |
645 |
case SEQ_ALIGN3: |
646 |
// Like in SEQ_DIST_MODEL, we don't |
647 |
// need "symbol" for anything else |
648 |
// than indexing the probability array. |
649 |
rc_bit_last(coder->pos_align[symbol], , |
650 |
rep0 += 8, SEQ_ALIGN3); |
651 |
#endif |
652 |
|
653 |
if (rep0 == UINT32_MAX) { |
654 |
// End of payload marker was |
655 |
// found. It must not be |
656 |
// present if uncompressed |
657 |
// size is known. |
658 |
if (coder->uncompressed_size |
659 |
!= LZMA_VLI_UNKNOWN) { |
660 |
ret = LZMA_DATA_ERROR; |
661 |
goto out; |
662 |
} |
663 |
|
664 |
case SEQ_EOPM: |
665 |
// LZMA1 stream with |
666 |
// end-of-payload marker. |
667 |
rc_normalize(SEQ_EOPM); |
668 |
ret = LZMA_STREAM_END; |
669 |
goto out; |
670 |
} |
671 |
} |
672 |
} |
673 |
|
674 |
// Validate the distance we just decoded. |
675 |
if (unlikely(!dict_is_distance_valid(&dict, rep0))) { |
676 |
ret = LZMA_DATA_ERROR; |
677 |
goto out; |
678 |
} |
679 |
|
680 |
} else { |
681 |
rc_update_1(coder->is_rep[state]); |
682 |
|
683 |
// Repeated match |
684 |
// |
685 |
// The match distance is a value that we have had |
686 |
// earlier. The latest four match distances are |
687 |
// available as rep0, rep1, rep2 and rep3. We will |
688 |
// now decode which of them is the new distance. |
689 |
// |
690 |
// There cannot be a match if we haven't produced |
691 |
// any output, so check that first. |
692 |
if (unlikely(!dict_is_distance_valid(&dict, 0))) { |
693 |
ret = LZMA_DATA_ERROR; |
694 |
goto out; |
695 |
} |
696 |
|
697 |
case SEQ_IS_REP0: |
698 |
rc_if_0(coder->is_rep0[state], SEQ_IS_REP0) { |
699 |
rc_update_0(coder->is_rep0[state]); |
700 |
// The distance is rep0. |
701 |
|
702 |
case SEQ_IS_REP0_LONG: |
703 |
rc_if_0(coder->is_rep0_long[state][pos_state], |
704 |
SEQ_IS_REP0_LONG) { |
705 |
rc_update_0(coder->is_rep0_long[ |
706 |
state][pos_state]); |
707 |
|
708 |
update_short_rep(state); |
709 |
|
710 |
case SEQ_SHORTREP: |
711 |
if (unlikely(dict_put(&dict, dict_get( |
712 |
&dict, rep0)))) { |
713 |
coder->sequence = SEQ_SHORTREP; |
714 |
goto out; |
715 |
} |
716 |
|
717 |
continue; |
718 |
} |
719 |
|
720 |
// Repeating more than one byte at |
721 |
// distance of rep0. |
722 |
rc_update_1(coder->is_rep0_long[ |
723 |
state][pos_state]); |
724 |
|
725 |
} else { |
726 |
rc_update_1(coder->is_rep0[state]); |
727 |
|
728 |
case SEQ_IS_REP1: |
729 |
// The distance is rep1, rep2 or rep3. Once |
730 |
// we find out which one of these three, it |
731 |
// is stored to rep0 and rep1, rep2 and rep3 |
732 |
// are updated accordingly. |
733 |
rc_if_0(coder->is_rep1[state], SEQ_IS_REP1) { |
734 |
rc_update_0(coder->is_rep1[state]); |
735 |
|
736 |
const uint32_t distance = rep1; |
737 |
rep1 = rep0; |
738 |
rep0 = distance; |
739 |
|
740 |
} else { |
741 |
rc_update_1(coder->is_rep1[state]); |
742 |
case SEQ_IS_REP2: |
743 |
rc_if_0(coder->is_rep2[state], |
744 |
SEQ_IS_REP2) { |
745 |
rc_update_0(coder->is_rep2[ |
746 |
state]); |
747 |
|
748 |
const uint32_t distance = rep2; |
749 |
rep2 = rep1; |
750 |
rep1 = rep0; |
751 |
rep0 = distance; |
752 |
|
753 |
} else { |
754 |
rc_update_1(coder->is_rep2[ |
755 |
state]); |
756 |
|
757 |
const uint32_t distance = rep3; |
758 |
rep3 = rep2; |
759 |
rep2 = rep1; |
760 |
rep1 = rep0; |
761 |
rep0 = distance; |
762 |
} |
763 |
} |
764 |
} |
765 |
|
766 |
update_long_rep(state); |
767 |
|
768 |
// Decode the length of the repeated match. |
769 |
len_decode(len, coder->rep_len_decoder, |
770 |
pos_state, SEQ_REP_LEN); |
771 |
} |
772 |
|
773 |
///////////////////////////////// |
774 |
// Repeat from history buffer. // |
775 |
///////////////////////////////// |
776 |
|
777 |
// The length is always between these limits. There is no way |
778 |
// to trigger the algorithm to set len outside this range. |
779 |
assert(len >= MATCH_LEN_MIN); |
780 |
assert(len <= MATCH_LEN_MAX); |
781 |
|
782 |
case SEQ_COPY: |
783 |
// Repeat len bytes from distance of rep0. |
784 |
if (unlikely(dict_repeat(&dict, rep0, &len))) { |
785 |
coder->sequence = SEQ_COPY; |
786 |
goto out; |
787 |
} |
788 |
} |
789 |
|
790 |
rc_normalize(SEQ_NORMALIZE); |
791 |
coder->sequence = SEQ_IS_MATCH; |
792 |
|
793 |
out: |
794 |
// Save state |
795 |
|
796 |
// NOTE: Must not copy dict.limit. |
797 |
dictptr->pos = dict.pos; |
798 |
dictptr->full = dict.full; |
799 |
|
800 |
rc_from_local(coder->rc, *in_pos); |
801 |
|
802 |
coder->state = state; |
803 |
coder->rep0 = rep0; |
804 |
coder->rep1 = rep1; |
805 |
coder->rep2 = rep2; |
806 |
coder->rep3 = rep3; |
807 |
|
808 |
coder->probs = probs; |
809 |
coder->symbol = symbol; |
810 |
coder->limit = limit; |
811 |
coder->offset = offset; |
812 |
coder->len = len; |
813 |
|
814 |
// Update the remaining amount of uncompressed data if uncompressed |
815 |
// size was known. |
816 |
if (coder->uncompressed_size != LZMA_VLI_UNKNOWN) { |
817 |
coder->uncompressed_size -= dict.pos - dict_start; |
818 |
|
819 |
// Since there cannot be end of payload marker if the |
820 |
// uncompressed size was known, we check here if we |
821 |
// finished decoding. |
822 |
if (coder->uncompressed_size == 0 && ret == LZMA_OK |
823 |
&& coder->sequence != SEQ_NORMALIZE) |
824 |
ret = coder->sequence == SEQ_IS_MATCH |
825 |
? LZMA_STREAM_END : LZMA_DATA_ERROR; |
826 |
} |
827 |
|
828 |
// We can do an additional check in the range decoder to catch some |
829 |
// corrupted files. |
830 |
if (ret == LZMA_STREAM_END) { |
831 |
if (!rc_is_finished(coder->rc)) |
832 |
ret = LZMA_DATA_ERROR; |
833 |
|
834 |
// Reset the range decoder so that it is ready to reinitialize |
835 |
// for a new LZMA2 chunk. |
836 |
rc_reset(coder->rc); |
837 |
} |
838 |
|
839 |
return ret; |
840 |
} |
841 |
|
842 |
|
843 |
|
844 |
static void |
845 |
lzma_decoder_uncompressed(void *coder_ptr, lzma_vli uncompressed_size) |
846 |
{ |
847 |
lzma_lzma1_decoder *coder = coder_ptr; |
848 |
coder->uncompressed_size = uncompressed_size; |
849 |
} |
850 |
|
851 |
|
852 |
static void |
853 |
lzma_decoder_reset(void *coder_ptr, const void *opt) |
854 |
{ |
855 |
lzma_lzma1_decoder *coder = coder_ptr; |
856 |
const lzma_options_lzma *options = opt; |
857 |
|
858 |
// NOTE: We assume that lc/lp/pb are valid since they were |
859 |
// successfully decoded with lzma_lzma_decode_properties(). |
860 |
|
861 |
// Calculate pos_mask. We don't need pos_bits as is for anything. |
862 |
coder->pos_mask = (1U << options->pb) - 1; |
863 |
|
864 |
// Initialize the literal decoder. |
865 |
literal_init(coder->literal, options->lc, options->lp); |
866 |
|
867 |
coder->literal_context_bits = options->lc; |
868 |
coder->literal_pos_mask = (1U << options->lp) - 1; |
869 |
|
870 |
// State |
871 |
coder->state = STATE_LIT_LIT; |
872 |
coder->rep0 = 0; |
873 |
coder->rep1 = 0; |
874 |
coder->rep2 = 0; |
875 |
coder->rep3 = 0; |
876 |
coder->pos_mask = (1U << options->pb) - 1; |
877 |
|
878 |
// Range decoder |
879 |
rc_reset(coder->rc); |
880 |
|
881 |
// Bit and bittree decoders |
882 |
for (uint32_t i = 0; i < STATES; ++i) { |
883 |
for (uint32_t j = 0; j <= coder->pos_mask; ++j) { |
884 |
bit_reset(coder->is_match[i][j]); |
885 |
bit_reset(coder->is_rep0_long[i][j]); |
886 |
} |
887 |
|
888 |
bit_reset(coder->is_rep[i]); |
889 |
bit_reset(coder->is_rep0[i]); |
890 |
bit_reset(coder->is_rep1[i]); |
891 |
bit_reset(coder->is_rep2[i]); |
892 |
} |
893 |
|
894 |
for (uint32_t i = 0; i < DIST_STATES; ++i) |
895 |
bittree_reset(coder->dist_slot[i], DIST_SLOT_BITS); |
896 |
|
897 |
for (uint32_t i = 0; i < FULL_DISTANCES - DIST_MODEL_END; ++i) |
898 |
bit_reset(coder->pos_special[i]); |
899 |
|
900 |
bittree_reset(coder->pos_align, ALIGN_BITS); |
901 |
|
902 |
// Len decoders (also bit/bittree) |
903 |
const uint32_t num_pos_states = 1U << options->pb; |
904 |
bit_reset(coder->match_len_decoder.choice); |
905 |
bit_reset(coder->match_len_decoder.choice2); |
906 |
bit_reset(coder->rep_len_decoder.choice); |
907 |
bit_reset(coder->rep_len_decoder.choice2); |
908 |
|
909 |
for (uint32_t pos_state = 0; pos_state < num_pos_states; ++pos_state) { |
910 |
bittree_reset(coder->match_len_decoder.low[pos_state], |
911 |
LEN_LOW_BITS); |
912 |
bittree_reset(coder->match_len_decoder.mid[pos_state], |
913 |
LEN_MID_BITS); |
914 |
|
915 |
bittree_reset(coder->rep_len_decoder.low[pos_state], |
916 |
LEN_LOW_BITS); |
917 |
bittree_reset(coder->rep_len_decoder.mid[pos_state], |
918 |
LEN_MID_BITS); |
919 |
} |
920 |
|
921 |
bittree_reset(coder->match_len_decoder.high, LEN_HIGH_BITS); |
922 |
bittree_reset(coder->rep_len_decoder.high, LEN_HIGH_BITS); |
923 |
|
924 |
coder->sequence = SEQ_IS_MATCH; |
925 |
coder->probs = NULL; |
926 |
coder->symbol = 0; |
927 |
coder->limit = 0; |
928 |
coder->offset = 0; |
929 |
coder->len = 0; |
930 |
|
931 |
return; |
932 |
} |
933 |
|
934 |
|
935 |
extern lzma_ret |
936 |
lzma_lzma_decoder_create(lzma_lz_decoder *lz, const lzma_allocator *allocator, |
937 |
const void *opt, lzma_lz_options *lz_options) |
938 |
{ |
939 |
if (lz->coder == NULL) { |
940 |
lz->coder = lzma_alloc(sizeof(lzma_lzma1_decoder), allocator); |
941 |
if (lz->coder == NULL) |
942 |
return LZMA_MEM_ERROR; |
943 |
|
944 |
lz->code = &lzma_decode; |
945 |
lz->reset = &lzma_decoder_reset; |
946 |
lz->set_uncompressed = &lzma_decoder_uncompressed; |
947 |
} |
948 |
|
949 |
// All dictionary sizes are OK here. LZ decoder will take care of |
950 |
// the special cases. |
951 |
const lzma_options_lzma *options = opt; |
952 |
lz_options->dict_size = options->dict_size; |
953 |
lz_options->preset_dict = options->preset_dict; |
954 |
lz_options->preset_dict_size = options->preset_dict_size; |
955 |
|
956 |
return LZMA_OK; |
957 |
} |
958 |
|
959 |
|
960 |
/// Allocate and initialize LZMA decoder. This is used only via LZ |
961 |
/// initialization (lzma_lzma_decoder_init() passes function pointer to |
962 |
/// the LZ initialization). |
963 |
static lzma_ret |
964 |
lzma_decoder_init(lzma_lz_decoder *lz, const lzma_allocator *allocator, |
965 |
const void *options, lzma_lz_options *lz_options) |
966 |
{ |
967 |
if (!is_lclppb_valid(options)) |
968 |
return LZMA_PROG_ERROR; |
969 |
|
970 |
return_if_error(lzma_lzma_decoder_create( |
971 |
lz, allocator, options, lz_options)); |
972 |
|
973 |
lzma_decoder_reset(lz->coder, options); |
974 |
lzma_decoder_uncompressed(lz->coder, LZMA_VLI_UNKNOWN); |
975 |
|
976 |
return LZMA_OK; |
977 |
} |
978 |
|
979 |
|
980 |
extern lzma_ret |
981 |
lzma_lzma_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator, |
982 |
const lzma_filter_info *filters) |
983 |
{ |
984 |
// LZMA can only be the last filter in the chain. This is enforced |
985 |
// by the raw_decoder initialization. |
986 |
assert(filters[1].init == NULL); |
987 |
|
988 |
return lzma_lz_decoder_init(next, allocator, filters, |
989 |
&lzma_decoder_init); |
990 |
} |
991 |
|
992 |
|
993 |
extern bool |
994 |
lzma_lzma_lclppb_decode(lzma_options_lzma *options, uint8_t byte) |
995 |
{ |
996 |
if (byte > (4 * 5 + 4) * 9 + 8) |
997 |
return true; |
998 |
|
999 |
// See the file format specification to understand this. |
1000 |
options->pb = byte / (9 * 5); |
1001 |
byte -= options->pb * 9 * 5; |
1002 |
options->lp = byte / 9; |
1003 |
options->lc = byte - options->lp * 9; |
1004 |
|
1005 |
return options->lc + options->lp > LZMA_LCLP_MAX; |
1006 |
} |
1007 |
|
1008 |
|
1009 |
extern uint64_t |
1010 |
lzma_lzma_decoder_memusage_nocheck(const void *options) |
1011 |
{ |
1012 |
const lzma_options_lzma *const opt = options; |
1013 |
return sizeof(lzma_lzma1_decoder) |
1014 |
+ lzma_lz_decoder_memusage(opt->dict_size); |
1015 |
} |
1016 |
|
1017 |
|
1018 |
extern uint64_t |
1019 |
lzma_lzma_decoder_memusage(const void *options) |
1020 |
{ |
1021 |
if (!is_lclppb_valid(options)) |
1022 |
return UINT64_MAX; |
1023 |
|
1024 |
return lzma_lzma_decoder_memusage_nocheck(options); |
1025 |
} |
1026 |
|
1027 |
|
1028 |
extern lzma_ret |
1029 |
lzma_lzma_props_decode(void **options, const lzma_allocator *allocator, |
1030 |
const uint8_t *props, size_t props_size) |
1031 |
{ |
1032 |
if (props_size != 5) |
1033 |
return LZMA_OPTIONS_ERROR; |
1034 |
|
1035 |
lzma_options_lzma *opt |
1036 |
= lzma_alloc(sizeof(lzma_options_lzma), allocator); |
1037 |
if (opt == NULL) |
1038 |
return LZMA_MEM_ERROR; |
1039 |
|
1040 |
if (lzma_lzma_lclppb_decode(opt, props[0])) |
1041 |
goto error; |
1042 |
|
1043 |
// All dictionary sizes are accepted, including zero. LZ decoder |
1044 |
// will automatically use a dictionary at least a few KiB even if |
1045 |
// a smaller dictionary is requested. |
1046 |
opt->dict_size = unaligned_read32le(props + 1); |
1047 |
|
1048 |
opt->preset_dict = NULL; |
1049 |
opt->preset_dict_size = 0; |
1050 |
|
1051 |
*options = opt; |
1052 |
|
1053 |
return LZMA_OK; |
1054 |
|
1055 |
error: |
1056 |
lzma_free(opt, allocator); |
1057 |
return LZMA_OPTIONS_ERROR; |
1058 |
} |