Root/target/linux/generic/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
711

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive