add a new arm lzma kernel decompressor based on rewritten (and much more readable...
[openwrt/openwrt.git] / target / linux / generic-2.6 / patches-2.6.30 / 960-arm_lzma_loader.patch
1 --- a/arch/arm/boot/compressed/Makefile
2 +++ b/arch/arm/boot/compressed/Makefile
3 @@ -63,7 +63,7 @@ endif
4
5 SEDFLAGS = s/TEXT_START/$(ZTEXTADDR)/;s/BSS_START/$(ZBSSADDR)/
6
7 -targets := vmlinux vmlinux.lds piggy.gz piggy.o font.o font.c \
8 +targets := vmlinux vmlinux.lds piggy.lzma piggy.o font.o font.c \
9 head.o misc.o $(OBJS)
10
11 ifeq ($(CONFIG_FUNCTION_TRACER),y)
12 @@ -96,10 +96,10 @@ $(obj)/vmlinux: $(obj)/vmlinux.lds $(obj
13 $(call if_changed,ld)
14 @:
15
16 -$(obj)/piggy.gz: $(obj)/../Image FORCE
17 - $(call if_changed,gzip)
18 +$(obj)/piggy.lzma: $(obj)/../Image FORCE
19 + $(call if_changed,lzma)
20
21 -$(obj)/piggy.o: $(obj)/piggy.gz FORCE
22 +$(obj)/piggy.o: $(obj)/piggy.lzma FORCE
23
24 CFLAGS_font.o := -Dstatic=
25
26 --- a/arch/arm/boot/compressed/misc.c
27 +++ b/arch/arm/boot/compressed/misc.c
28 @@ -186,36 +186,10 @@ static inline __ptr_t memcpy(__ptr_t __d
29 return __dest;
30 }
31
32 -/*
33 - * gzip delarations
34 - */
35 -#define OF(args) args
36 -#define STATIC static
37 -
38 -typedef unsigned char uch;
39 -typedef unsigned short ush;
40 -typedef unsigned long ulg;
41 -
42 -#define WSIZE 0x8000 /* Window size must be at least 32k, */
43 +#define WSIZE 0x20000 /* Window size must be at least 128k, */
44 /* and a power of two */
45
46 -static uch *inbuf; /* input buffer */
47 -static uch window[WSIZE]; /* Sliding window buffer */
48 -
49 -static unsigned insize; /* valid bytes in inbuf */
50 -static unsigned inptr; /* index of next byte to be processed in inbuf */
51 -static unsigned outcnt; /* bytes in output buffer */
52 -
53 -/* gzip flag byte */
54 -#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
55 -#define CONTINUATION 0x02 /* bit 1 set: continuation of multi-part gzip file */
56 -#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
57 -#define ORIG_NAME 0x08 /* bit 3 set: original file name present */
58 -#define COMMENT 0x10 /* bit 4 set: file comment present */
59 -#define ENCRYPTED 0x20 /* bit 5 set: file is encrypted */
60 -#define RESERVED 0xC0 /* bit 6,7: reserved */
61 -
62 -#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf())
63 +static u8 window[WSIZE]; /* Sliding window buffer */
64
65 /* Diagnostic functions */
66 #ifdef DEBUG
67 @@ -234,24 +208,21 @@ static unsigned outcnt; /* bytes in out
68 # define Tracecv(c,x)
69 #endif
70
71 -static int fill_inbuf(void);
72 -static void flush_window(void);
73 static void error(char *m);
74
75 extern char input_data[];
76 extern char input_data_end[];
77
78 -static uch *output_data;
79 -static ulg output_ptr;
80 -static ulg bytes_out;
81 +static unsigned long output_ptr;
82 +static unsigned long bytes_out;
83
84 static void error(char *m);
85
86 static void putstr(const char *);
87
88 extern int end;
89 -static ulg free_mem_ptr;
90 -static ulg free_mem_end_ptr;
91 +static unsigned long free_mem_ptr;
92 +static unsigned long free_mem_end_ptr;
93
94 #ifdef STANDALONE_DEBUG
95 #define NO_INFLATE_MALLOC
96 @@ -259,50 +230,10 @@ static ulg free_mem_end_ptr;
97
98 #define ARCH_HAS_DECOMP_WDOG
99
100 -#include "../../../../lib/inflate.c"
101 -
102 -/* ===========================================================================
103 - * Fill the input buffer. This is called only when the buffer is empty
104 - * and at least one byte is really needed.
105 - */
106 -int fill_inbuf(void)
107 -{
108 - if (insize != 0)
109 - error("ran out of input data");
110 -
111 - inbuf = input_data;
112 - insize = &input_data_end[0] - &input_data[0];
113 -
114 - inptr = 1;
115 - return inbuf[0];
116 -}
117 -
118 -/* ===========================================================================
119 - * Write the output window window[0..outcnt-1] and update crc and bytes_out.
120 - * (Used for the decompressed data only.)
121 - */
122 -void flush_window(void)
123 -{
124 - ulg c = crc;
125 - unsigned n;
126 - uch *in, *out, ch;
127 -
128 - in = window;
129 - out = &output_data[output_ptr];
130 - for (n = 0; n < outcnt; n++) {
131 - ch = *out++ = *in++;
132 - c = crc_32_tab[((int)c ^ ch) & 0xff] ^ (c >> 8);
133 - }
134 - crc = c;
135 - bytes_out += (ulg)outcnt;
136 - output_ptr += (ulg)outcnt;
137 - outcnt = 0;
138 - putstr(".");
139 -}
140 -
141 #ifndef arch_error
142 #define arch_error(x)
143 #endif
144 +#include "unlzma.c"
145
146 static void error(char *x)
147 {
148 @@ -317,20 +248,16 @@ static void error(char *x)
149
150 #ifndef STANDALONE_DEBUG
151
152 -ulg
153 -decompress_kernel(ulg output_start, ulg free_mem_ptr_p, ulg free_mem_ptr_end_p,
154 +unsigned long
155 +decompress_kernel(unsigned long output_start, unsigned long free_mem_ptr_p, unsigned long free_mem_ptr_end_p,
156 int arch_id)
157 {
158 - output_data = (uch *)output_start; /* Points to kernel start */
159 - free_mem_ptr = free_mem_ptr_p;
160 - free_mem_end_ptr = free_mem_ptr_end_p;
161 __machine_arch_type = arch_id;
162
163 arch_decomp_setup();
164
165 - makecrc();
166 putstr("Uncompressing Linux...");
167 - gunzip();
168 + output_ptr += unlzma((u8 *) output_start, input_data, window);
169 putstr(" done, booting the kernel.\n");
170 return output_ptr;
171 }
172 @@ -340,11 +267,8 @@ char output_buffer[1500*1024];
173
174 int main()
175 {
176 - output_data = output_buffer;
177 -
178 - makecrc();
179 putstr("Uncompressing Linux...");
180 - gunzip();
181 + unlzma((u8 *) output_buffer, input_data, window);
182 putstr("done.\n");
183 return 0;
184 }
185 --- a/arch/arm/boot/compressed/piggy.S
186 +++ b/arch/arm/boot/compressed/piggy.S
187 @@ -1,6 +1,6 @@
188 .section .piggydata,#alloc
189 .globl input_data
190 input_data:
191 - .incbin "arch/arm/boot/compressed/piggy.gz"
192 + .incbin "arch/arm/boot/compressed/piggy.lzma"
193 .globl input_data_end
194 input_data_end:
195 --- /dev/null
196 +++ b/arch/arm/boot/compressed/unlzma.c
197 @@ -0,0 +1,429 @@
198 +/*
199 + * Copyright (c) 2009 Felix Fietkau <nbd@openwrt.org>
200 + *
201 + * This program is free software; you can redistribute it and/or
202 + * modify it under the terms of the GNU General Public License
203 + * as published by the Free Software Foundation; either version 2,
204 + * or (at your option) any later version.
205 + *
206 + * This program is distributed in the hope that it will be useful,
207 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
208 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
209 + * GNU General Public License for more details.
210 + *
211 + * You should have received a copy of the GNU General Public License
212 + * along with this program; if not, write to the Free Software
213 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
214 + *
215 + * uncompress.c
216 + */
217 +
218 +#include <linux/types.h>
219 +#include <asm/byteorder.h>
220 +#include "unlzma.h"
221 +
222 +struct unlzma_ctx {
223 + const u8 *next_in;
224 + u8 *next_out;
225 + u8 *outbuf;
226 +
227 + /* reader state */
228 + u32 code;
229 + u32 range;
230 + u32 bound;
231 +
232 + /* writer state */
233 + u8 previous_byte;
234 + ssize_t pos;
235 +
236 + /* cstate */
237 + int state;
238 + u32 rep0, rep1, rep2, rep3;
239 +
240 + void *workspace;
241 +} ctx;
242 +
243 +static int inbs = 0;
244 +static inline u8
245 +rc_read(void)
246 +{
247 +#if 0
248 + if (unlikely(++inbs > 16 * 1024)) {
249 + putstr(".");
250 + inbs = 0;
251 + }
252 +#endif
253 + return *(ctx.next_in++);
254 +}
255 +
256 +
257 +static inline void
258 +rc_get_code(void)
259 +{
260 + ctx.code = (ctx.code << 8) | rc_read();
261 +}
262 +
263 +static inline void
264 +rc_normalize(void)
265 +{
266 + if (ctx.range < (1 << RC_TOP_BITS)) {
267 + ctx.range <<= 8;
268 + rc_get_code();
269 + }
270 +}
271 +
272 +static inline int
273 +rc_is_bit_0(u16 *p)
274 +{
275 + rc_normalize();
276 + ctx.bound = *p * (ctx.range >> RC_MODEL_TOTAL_BITS);
277 + return ctx.code < ctx.bound;
278 +}
279 +
280 +static inline void
281 +rc_update_bit_0(u16 *p)
282 +{
283 + ctx.range = ctx.bound;
284 + *p += ((1 << RC_MODEL_TOTAL_BITS) - *p) >> RC_MOVE_BITS;
285 +}
286 +
287 +static inline void
288 +rc_update_bit_1(u16 *p)
289 +{
290 + ctx.range -= ctx.bound;
291 + ctx.code -= ctx.bound;
292 + *p -= *p >> RC_MOVE_BITS;
293 +}
294 +
295 +static inline bool
296 +rc_get_bit(u16 *p, int *symbol)
297 +{
298 + if (rc_is_bit_0(p)) {
299 + rc_update_bit_0(p);
300 + *symbol *= 2;
301 + return 0;
302 + } else {
303 + rc_update_bit_1(p);
304 + *symbol = *symbol * 2 + 1;
305 + return 1;
306 + }
307 +}
308 +
309 +static inline int
310 +rc_direct_bit(void)
311 +{
312 + rc_normalize();
313 + ctx.range >>= 1;
314 + if (ctx.code >= ctx.range) {
315 + ctx.code -= ctx.range;
316 + return 1;
317 + }
318 + return 0;
319 +}
320 +
321 +static inline void
322 +rc_bit_tree_decode(u16 *p, int num_levels, int *symbol)
323 +{
324 + int i = num_levels;
325 +
326 + *symbol = 1;
327 + while (i--)
328 + rc_get_bit(p + *symbol, symbol);
329 + *symbol -= 1 << num_levels;
330 +}
331 +
332 +static inline u8
333 +peek_old_byte(u32 offs)
334 +{
335 + u32 pos = ctx.pos - offs;
336 + return ctx.outbuf[pos];
337 +}
338 +
339 +static inline void
340 +write_byte(u8 byte)
341 +{
342 + ctx.previous_byte = byte;
343 + *(ctx.next_out++) = byte;
344 + ctx.pos++;
345 +}
346 +
347 +
348 +static inline void
349 +copy_byte(u32 offs)
350 +{
351 + write_byte(peek_old_byte(offs));
352 +}
353 +
354 +static inline void
355 +copy_bytes(u32 rep0, int len)
356 +{
357 + do {
358 + copy_byte(rep0);
359 + len--;
360 + } while (len != 0);
361 +}
362 +
363 +static inline void
364 +process_bit0(u16 *p, int pos_state, u16 *prob,
365 + int lc, u32 literal_pos_mask)
366 +{
367 + int mi = 1;
368 + rc_update_bit_0(prob);
369 + prob = (p + LZMA_LITERAL +
370 + (LZMA_LIT_SIZE
371 + * (((ctx.pos & literal_pos_mask) << lc)
372 + + (ctx.previous_byte >> (8 - lc))))
373 + );
374 +
375 + if (ctx.state >= LZMA_NUM_LIT_STATES) {
376 + int match_byte = peek_old_byte(ctx.rep0);
377 + do {
378 + u16 bit;
379 + u16 *prob_lit;
380 +
381 + match_byte <<= 1;
382 + bit = match_byte & 0x100;
383 + prob_lit = prob + 0x100 + bit + mi;
384 + if (rc_get_bit(prob_lit, &mi) != !!bit)
385 + break;
386 + } while (mi < 0x100);
387 + }
388 + while (mi < 0x100) {
389 + u16 *prob_lit = prob + mi;
390 + rc_get_bit(prob_lit, &mi);
391 + }
392 + write_byte(mi);
393 + if (ctx.state < 4)
394 + ctx.state = 0;
395 + else if (ctx.state < 10)
396 + ctx.state -= 3;
397 + else
398 + ctx.state -= 6;
399 +}
400 +
401 +static inline void
402 +process_bit1(u16 *p, int pos_state, u16 *prob)
403 +{
404 + int offset;
405 + u16 *prob_len;
406 + int num_bits;
407 + int len;
408 +
409 + rc_update_bit_1(prob);
410 + prob = p + LZMA_IS_REP + ctx.state;
411 + if (rc_is_bit_0(prob)) {
412 + rc_update_bit_0(prob);
413 + ctx.rep3 = ctx.rep2;
414 + ctx.rep2 = ctx.rep1;
415 + ctx.rep1 = ctx.rep0;
416 + ctx.state = ctx.state < LZMA_NUM_LIT_STATES ? 0 : 3;
417 + prob = p + LZMA_LEN_CODER;
418 + } else {
419 + rc_update_bit_1(prob);
420 + prob = p + LZMA_IS_REP_G0 + ctx.state;
421 + if (rc_is_bit_0(prob)) {
422 + rc_update_bit_0(prob);
423 + prob = (p + LZMA_IS_REP_0_LONG
424 + + (ctx.state <<
425 + LZMA_NUM_POS_BITS_MAX) +
426 + pos_state);
427 + if (rc_is_bit_0(prob)) {
428 + rc_update_bit_0(prob);
429 +
430 + ctx.state = ctx.state < LZMA_NUM_LIT_STATES ?
431 + 9 : 11;
432 + copy_byte(ctx.rep0);
433 + return;
434 + } else {
435 + rc_update_bit_1(prob);
436 + }
437 + } else {
438 + u32 distance;
439 +
440 + rc_update_bit_1(prob);
441 + prob = p + LZMA_IS_REP_G1 + ctx.state;
442 + if (rc_is_bit_0(prob)) {
443 + rc_update_bit_0(prob);
444 + distance = ctx.rep1;
445 + } else {
446 + rc_update_bit_1(prob);
447 + prob = p + LZMA_IS_REP_G2 + ctx.state;
448 + if (rc_is_bit_0(prob)) {
449 + rc_update_bit_0(prob);
450 + distance = ctx.rep2;
451 + } else {
452 + rc_update_bit_1(prob);
453 + distance = ctx.rep3;
454 + ctx.rep3 = ctx.rep2;
455 + }
456 + ctx.rep2 = ctx.rep1;
457 + }
458 + ctx.rep1 = ctx.rep0;
459 + ctx.rep0 = distance;
460 + }
461 + ctx.state = ctx.state < LZMA_NUM_LIT_STATES ? 8 : 11;
462 + prob = p + LZMA_REP_LEN_CODER;
463 + }
464 +
465 + prob_len = prob + LZMA_LEN_CHOICE;
466 + if (rc_is_bit_0(prob_len)) {
467 + rc_update_bit_0(prob_len);
468 + prob_len = (prob + LZMA_LEN_LOW
469 + + (pos_state <<
470 + LZMA_LEN_NUM_LOW_BITS));
471 + offset = 0;
472 + num_bits = LZMA_LEN_NUM_LOW_BITS;
473 + } else {
474 + rc_update_bit_1(prob_len);
475 + prob_len = prob + LZMA_LEN_CHOICE_2;
476 + if (rc_is_bit_0(prob_len)) {
477 + rc_update_bit_0(prob_len);
478 + prob_len = (prob + LZMA_LEN_MID
479 + + (pos_state <<
480 + LZMA_LEN_NUM_MID_BITS));
481 + offset = 1 << LZMA_LEN_NUM_LOW_BITS;
482 + num_bits = LZMA_LEN_NUM_MID_BITS;
483 + } else {
484 + rc_update_bit_1(prob_len);
485 + prob_len = prob + LZMA_LEN_HIGH;
486 + offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
487 + + (1 << LZMA_LEN_NUM_MID_BITS));
488 + num_bits = LZMA_LEN_NUM_HIGH_BITS;
489 + }
490 + }
491 +
492 + rc_bit_tree_decode(prob_len, num_bits, &len);
493 + len += offset;
494 +
495 + if (ctx.state < 4) {
496 + int pos_slot;
497 +
498 + ctx.state += LZMA_NUM_LIT_STATES;
499 + prob =
500 + p + LZMA_POS_SLOT +
501 + ((len <
502 + LZMA_NUM_LEN_TO_POS_STATES ? len :
503 + LZMA_NUM_LEN_TO_POS_STATES - 1)
504 + << LZMA_NUM_POS_SLOT_BITS);
505 + rc_bit_tree_decode(prob,
506 + LZMA_NUM_POS_SLOT_BITS,
507 + &pos_slot);
508 + if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
509 + int i, mi;
510 + num_bits = (pos_slot >> 1) - 1;
511 + ctx.rep0 = 2 | (pos_slot & 1);
512 + if (pos_slot < LZMA_END_POS_MODEL_INDEX) {
513 + ctx.rep0 <<= num_bits;
514 + prob = p + LZMA_SPEC_POS +
515 + ctx.rep0 - pos_slot - 1;
516 + } else {
517 + num_bits -= LZMA_NUM_ALIGN_BITS;
518 + while (num_bits--)
519 + ctx.rep0 = (ctx.rep0 << 1) |
520 + rc_direct_bit();
521 + prob = p + LZMA_ALIGN;
522 + ctx.rep0 <<= LZMA_NUM_ALIGN_BITS;
523 + num_bits = LZMA_NUM_ALIGN_BITS;
524 + }
525 + i = 1;
526 + mi = 1;
527 + while (num_bits--) {
528 + if (rc_get_bit(prob + mi, &mi))
529 + ctx.rep0 |= i;
530 + i <<= 1;
531 + }
532 + } else
533 + ctx.rep0 = pos_slot;
534 + if (++(ctx.rep0) == 0)
535 + return;
536 + }
537 +
538 + len += LZMA_MATCH_MIN_LEN;
539 +
540 + copy_bytes(ctx.rep0, len);
541 +}
542 +
543 +
544 +static int
545 +do_unlzma(void)
546 +{
547 + u8 hdr_buf[sizeof(struct lzma_header)];
548 + struct lzma_header *header = (struct lzma_header *)hdr_buf;
549 + u32 pos_state_mask;
550 + u32 literal_pos_mask;
551 + int lc, pb, lp;
552 + int num_probs;
553 + int i, mi;
554 + u16 *p;
555 +
556 + for (i = 0; i < sizeof(struct lzma_header); i++) {
557 + hdr_buf[i] = rc_read();
558 + }
559 +
560 + ctx.pos = 0;
561 + ctx.state = 0;
562 + ctx.rep0 = ctx.rep1 = ctx.rep2 = ctx.rep3 = 1;
563 +
564 + ctx.previous_byte = 0;
565 + ctx.code = 0;
566 + ctx.range = 0xFFFFFFFF;
567 +
568 + if (header->pos >= (9 * 5 * 5))
569 + return -1;
570 +
571 + mi = 0;
572 + lc = header->pos;
573 + while (lc >= 9) {
574 + mi++;
575 + lc -= 9;
576 + }
577 + pb = 0;
578 + lp = mi;
579 + while (lp >= 5) {
580 + pb++;
581 + lp -= 5;
582 + }
583 + pos_state_mask = (1 << pb) - 1;
584 + literal_pos_mask = (1 << lp) - 1;
585 +
586 + p = (u16 *) ctx.workspace;
587 + if (!p)
588 + return -1;
589 +
590 + num_probs = LZMA_LITERAL + (LZMA_LIT_SIZE << (lc + lp));
591 + for (i = 0; i < num_probs; i++)
592 + p[i] = (1 << RC_MODEL_TOTAL_BITS) >> 1;
593 +
594 + for (i = 0; i < 5; i++)
595 + rc_get_code();
596 +
597 + while (1) {
598 + int pos_state = ctx.pos & pos_state_mask;
599 + u16 *prob = p + LZMA_IS_MATCH +
600 + (ctx.state << LZMA_NUM_POS_BITS_MAX) + pos_state;
601 + if (rc_is_bit_0(prob))
602 + process_bit0(p, pos_state, prob,
603 + lc, literal_pos_mask);
604 + else {
605 + process_bit1(p, pos_state, prob);
606 + if (ctx.rep0 == 0)
607 + break;
608 + }
609 + }
610 +
611 + return ctx.pos;
612 +}
613 +
614 +
615 +static int unlzma(unsigned char *dest, const unsigned char *src, unsigned char *workspace)
616 +{
617 + memset(&ctx, 0, sizeof(ctx));
618 + ctx.outbuf = dest;
619 + ctx.next_in = src;
620 + ctx.next_out = dest;
621 + ctx.workspace = workspace;
622 +
623 + return do_unlzma();
624 +}
625 +
626 +
627 --- /dev/null
628 +++ b/arch/arm/boot/compressed/unlzma.h
629 @@ -0,0 +1,81 @@
630 +/* LZMA uncompresion module for pcomp
631 + * Copyright (C) 2009 Felix Fietkau <nbd@openwrt.org>
632 + *
633 + * Based on:
634 + * Initial Linux kernel adaptation
635 + * Copyright (C) 2006 Alain < alain@knaff.lu >
636 + *
637 + * Based on small lzma deflate implementation/Small range coder
638 + * implementation for lzma.
639 + * Copyright (C) 2006 Aurelien Jacobs < aurel@gnuage.org >
640 + *
641 + * Based on LzmaDecode.c from the LZMA SDK 4.22 (http://www.7-zip.org/)
642 + * Copyright (C) 1999-2005 Igor Pavlov
643 + *
644 + * This program is free software; you can redistribute it and/or modify it
645 + * under the terms of the GNU General Public License version 2 as published
646 + * by the Free Software Foundation.
647 + */
648 +#ifndef __UNLZMA_H
649 +#define __UNLZMA_H
650 +
651 +struct lzma_header {
652 + __u8 pos;
653 + __le32 dict_size;
654 + __le64 uncompr_size;
655 +} __attribute__ ((packed));
656 +
657 +
658 +#define RC_TOP_BITS 24
659 +#define RC_MOVE_BITS 5
660 +#define RC_MODEL_TOTAL_BITS 11
661 +
662 +#define LZMA_BASE_SIZE 1846
663 +#define LZMA_LIT_SIZE 768
664 +
665 +#define LZMA_NUM_POS_BITS_MAX 4
666 +
667 +#define LZMA_LEN_NUM_LOW_BITS 3
668 +#define LZMA_LEN_NUM_MID_BITS 3
669 +#define LZMA_LEN_NUM_HIGH_BITS 8
670 +
671 +#define LZMA_LEN_CHOICE 0
672 +#define LZMA_LEN_CHOICE_2 (LZMA_LEN_CHOICE + 1)
673 +#define LZMA_LEN_LOW (LZMA_LEN_CHOICE_2 + 1)
674 +#define LZMA_LEN_MID (LZMA_LEN_LOW \
675 + + (1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_LOW_BITS)))
676 +#define LZMA_LEN_HIGH (LZMA_LEN_MID \
677 + +(1 << (LZMA_NUM_POS_BITS_MAX + LZMA_LEN_NUM_MID_BITS)))
678 +#define LZMA_NUM_LEN_PROBS (LZMA_LEN_HIGH + (1 << LZMA_LEN_NUM_HIGH_BITS))
679 +
680 +#define LZMA_NUM_STATES 12
681 +#define LZMA_NUM_LIT_STATES 7
682 +
683 +#define LZMA_START_POS_MODEL_INDEX 4
684 +#define LZMA_END_POS_MODEL_INDEX 14
685 +#define LZMA_NUM_FULL_DISTANCES (1 << (LZMA_END_POS_MODEL_INDEX >> 1))
686 +
687 +#define LZMA_NUM_POS_SLOT_BITS 6
688 +#define LZMA_NUM_LEN_TO_POS_STATES 4
689 +
690 +#define LZMA_NUM_ALIGN_BITS 4
691 +
692 +#define LZMA_MATCH_MIN_LEN 2
693 +
694 +#define LZMA_IS_MATCH 0
695 +#define LZMA_IS_REP (LZMA_IS_MATCH + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
696 +#define LZMA_IS_REP_G0 (LZMA_IS_REP + LZMA_NUM_STATES)
697 +#define LZMA_IS_REP_G1 (LZMA_IS_REP_G0 + LZMA_NUM_STATES)
698 +#define LZMA_IS_REP_G2 (LZMA_IS_REP_G1 + LZMA_NUM_STATES)
699 +#define LZMA_IS_REP_0_LONG (LZMA_IS_REP_G2 + LZMA_NUM_STATES)
700 +#define LZMA_POS_SLOT (LZMA_IS_REP_0_LONG \
701 + + (LZMA_NUM_STATES << LZMA_NUM_POS_BITS_MAX))
702 +#define LZMA_SPEC_POS (LZMA_POS_SLOT \
703 + +(LZMA_NUM_LEN_TO_POS_STATES << LZMA_NUM_POS_SLOT_BITS))
704 +#define LZMA_ALIGN (LZMA_SPEC_POS \
705 + + LZMA_NUM_FULL_DISTANCES - LZMA_END_POS_MODEL_INDEX)
706 +#define LZMA_LEN_CODER (LZMA_ALIGN + (1 << LZMA_NUM_ALIGN_BITS))
707 +#define LZMA_REP_LEN_CODER (LZMA_LEN_CODER + LZMA_NUM_LEN_PROBS)
708 +#define LZMA_LITERAL (LZMA_REP_LEN_CODER + LZMA_NUM_LEN_PROBS)
709 +
710 +#endif