Root/target/linux/generic-2.4/patches/003-jffs2_compression.patch

1--- a/Documentation/Configure.help
2+++ b/Documentation/Configure.help
3@@ -17592,6 +17592,32 @@ CONFIG_JFFS2_FS_DEBUG
4   If reporting bugs, please try to have available a full dump of the
5   messages at debug level 1 while the misbehaviour was occurring.
6 
7+ARMLIB compression support for BBC (EXPERIMENTAL)
8+CONFIG_JFFS2_BBC_ARMLIB
9+ This enables ARMLIB support for BBC.
10+
11+LZO1X-* compression support for BBC (EXPERIMENTAL)
12+CONFIG_JFFS2_BBC_LZO
13+ This enables LZO1X-1 and LZO1X-999 support for BBC. (fast & good
14+ compressor, beats ZLIB in everything)
15+
16+LZARI compression support for BBC (EXPERIMENTAL)
17+CONFIG_JFFS2_BBC_LZARI
18+ This enables LempelZiv-Storer-Szymanski compression for BBC with
19+ additional arithmetic coding (damn slow, but best compresor).
20+
21+LZHD compression support for BBC (EXPERIMENTAL)
22+CONFIG_JFFS2_BBC_LZHD
23+ This enables LempelZiv-Storer-Szymanski compression for BBC with
24+ additional dynamic Huffman coding (a little faster than LZARI, and
25+ it's compression ratio is a little worse than LZARI's)
26+
27+LZSS compression support for BBC (EXPERIMENTAL)
28+CONFIG_JFFS2_BBC_LZSS
29+ This enables simple LempelZiv-Storer-Szymanski compression for BBC
30+ (faster than LZHD, and, and has a not-so-good compression ratio,
31+ was included just for testing)
32+
33 JFFS stats available in /proc filesystem
34 CONFIG_JFFS_PROC_FS
35   Enabling this option will cause statistics from mounted JFFS file systems
36--- a/fs/Config.in
37+++ b/fs/Config.in
38@@ -50,6 +50,12 @@ dep_tristate 'Journalling Flash File Sys
39 if [ "$CONFIG_JFFS2_FS" = "y" -o "$CONFIG_JFFS2_FS" = "m" ] ; then
40    int 'JFFS2 debugging verbosity (0 = quiet, 2 = noisy)' CONFIG_JFFS2_FS_DEBUG 0
41 fi
42+dep_mbool ' ARMLIB compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_ARMLIB $CONFIG_JFFS2_FS
43+dep_mbool ' LZO1X-* compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZO $CONFIG_JFFS2_FS
44+dep_mbool ' LZARI compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZARI $CONFIG_JFFS2_FS
45+dep_mbool ' LZHD compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZHD $CONFIG_JFFS2_FS
46+dep_mbool ' LZSS compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZSS $CONFIG_JFFS2_FS
47+
48 tristate 'Compressed ROM file system support' CONFIG_CRAMFS
49 tristate 'Squashed file system support' CONFIG_SQUASHFS
50 if [ "$CONFIG_SQUASHFS" = "y" -o "$CONFIG_SQUASHFS" = "m" ] ; then
51--- /dev/null
52+++ b/fs/jffs2/Config.in.bbc.inc
53@@ -0,0 +1,5 @@
54+dep_mbool ' ARMLIB compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_ARMLIB $CONFIG_JFFS2_FS
55+dep_mbool ' LZO1X-* compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZO $CONFIG_JFFS2_FS
56+dep_mbool ' LZARI compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZARI $CONFIG_JFFS2_FS
57+dep_mbool ' LZHD compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZHD $CONFIG_JFFS2_FS
58+dep_mbool ' LZSS compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZSS $CONFIG_JFFS2_FS
59--- /dev/null
60+++ b/fs/jffs2/Configure.help.bbc.inc
61@@ -0,0 +1,25 @@
62+ARMLIB compression support for BBC (EXPERIMENTAL)
63+CONFIG_JFFS2_BBC_ARMLIB
64+ This enables ARMLIB support for BBC.
65+
66+LZO1X-* compression support for BBC (EXPERIMENTAL)
67+CONFIG_JFFS2_BBC_LZO
68+ This enables LZO1X-1 and LZO1X-999 support for BBC. (fast & good
69+ compressor, beats ZLIB in everything)
70+
71+LZARI compression support for BBC (EXPERIMENTAL)
72+CONFIG_JFFS2_BBC_LZARI
73+ This enables LempelZiv-Storer-Szymanski compression for BBC with
74+ additional arithmetic coding (damn slow, but best compresor).
75+
76+LZHD compression support for BBC (EXPERIMENTAL)
77+CONFIG_JFFS2_BBC_LZHD
78+ This enables LempelZiv-Storer-Szymanski compression for BBC with
79+ additional dynamic Huffman coding (a little faster than LZARI, and
80+ it's compression ratio is a little worse than LZARI's)
81+
82+LZSS compression support for BBC (EXPERIMENTAL)
83+CONFIG_JFFS2_BBC_LZSS
84+ This enables simple LempelZiv-Storer-Szymanski compression for BBC
85+ (faster than LZHD, and, and has a not-so-good compression ratio,
86+ was included just for testing)
87--- /dev/null
88+++ b/fs/jffs2/Kconfig.bbc.inc
89@@ -0,0 +1,40 @@
90+config JFFS2_BBC_ARMLIB
91+ bool "ARMLIB compression support for BBC (EXPERIMENTAL)"
92+ depends on JFFS2_FS && EXPERIMENTAL
93+ default y
94+ help
95+ This enables ARMLIB support for BBC.
96+
97+config JFFS2_BBC_LZO
98+ bool "LZO1X-* compression support for BBC (EXPERIMENTAL)"
99+ depends on JFFS2_FS && EXPERIMENTAL
100+ default y
101+ help
102+ This enables LZO1X-1 and LZO1X-999 support for BBC. (fast & good
103+ compressor)
104+
105+config JFFS2_BBC_LZARI
106+ bool "LZARI compression support for BBC (EXPERIMENTAL)"
107+ depends on JFFS2_FS && EXPERIMENTAL
108+ default y
109+ help
110+ This enables LempelZiv-Storer-Szymanski compression for BBC with
111+ additional arithmetic coding (damn slow, but best compresor).
112+
113+config JFFS2_BBC_LZHD
114+ bool "LZHD compression support for BBC (EXPERIMENTAL)"
115+ depends on JFFS2_FS && EXPERIMENTAL
116+ default y
117+ help
118+ This enables LempelZiv-Storer-Szymanski compression for BBC with
119+ additional dynamic Huffman coding (a little faster than LZARI, and
120+ it's compression ratio is a little worse than LZARI's)
121+
122+config JFFS2_BBC_LZSS
123+ bool "LZSS compression support for BBC (EXPERIMENTAL)"
124+ depends on JFFS2_FS && EXPERIMENTAL
125+ default y
126+ help
127+ This enables simple LempelZiv-Storer-Szymanski compression for BBC
128+ (faster than LZHD, and, and has a not-so-good compression ratio,
129+ was included just for testing)
130--- a/fs/jffs2/Makefile
131+++ b/fs/jffs2/Makefile
132@@ -10,9 +10,23 @@
133 # Note 2! The CFLAGS definitions are now in the main makefile...
134 
135 
136+JFFS2_BBC_KERNEL_OBJS-y = jffs2_bbc_framework.o jffs2_bbc_fs.o
137+
138+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_ARMLIB) += jffs2_bbc_armlib_comp.o
139+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZO) += jffs2_bbc_lzo_comp.o
140+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZSS) += jffs2_bbc_lzss_comp.o
141+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZARI) += jffs2_bbc_lzari_comp.o
142+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZHD) += jffs2_bbc_lzhd_comp.o
143+
144+JFFS2_BBC_KERNEL_OBJS := $(JFFS2_BBC_KERNEL_OBJS-y)
145+
146+JFFS2_BBC_MKFS_OBJS = jffs2_bbc_mkfs.o jffs2_bbc_framework.o jffs2_bbc_armlib_comp.o jffs2_bbc_lzo_comp.o\
147+ jffs2_bbc_lzss_comp.o jffs2_bbc_lzari_comp.o jffs2_bbc_lzhd_comp.o
148+
149 COMPR_OBJS := compr.o compr_rubin.o compr_rtime.o pushpull.o \
150             compr_zlib.o
151 JFFS2_OBJS := dir.o file.o ioctl.o nodelist.o malloc.o \
152+ $(JFFS2_BBC_KERNEL_OBJS) \
153     read.o nodemgmt.o readinode.o super.o write.o scan.o gc.o \
154     symlink.o build.o erase.o background.o
155 
156--- /dev/null
157+++ b/fs/jffs2/Makefile.bbc.inc
158@@ -0,0 +1,12 @@
159+JFFS2_BBC_KERNEL_OBJS-y = jffs2_bbc_framework.o jffs2_bbc_fs.o
160+
161+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_ARMLIB) += jffs2_bbc_armlib_comp.o
162+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZO) += jffs2_bbc_lzo_comp.o
163+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZSS) += jffs2_bbc_lzss_comp.o
164+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZARI) += jffs2_bbc_lzari_comp.o
165+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZHD) += jffs2_bbc_lzhd_comp.o
166+
167+JFFS2_BBC_KERNEL_OBJS := $(JFFS2_BBC_KERNEL_OBJS-y)
168+
169+JFFS2_BBC_MKFS_OBJS = jffs2_bbc_mkfs.o jffs2_bbc_framework.o jffs2_bbc_armlib_comp.o jffs2_bbc_lzo_comp.o\
170+ jffs2_bbc_lzss_comp.o jffs2_bbc_lzari_comp.o jffs2_bbc_lzhd_comp.o
171--- a/fs/jffs2/compr_zlib.c
172+++ b/fs/jffs2/compr_zlib.c
173@@ -85,7 +85,7 @@ void jffs2_zlib_exit(void)
174     vfree(inflate_workspace);
175 }
176 
177-int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
178+int jffs2_zlib_compress2(unsigned char *data_in, unsigned char *cpage_out,
179            __u32 *sourcelen, __u32 *dstlen)
180 {
181     z_stream strm;
182@@ -145,7 +145,7 @@ int zlib_compress(unsigned char *data_in
183     return 0;
184 }
185 
186-void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
187+void jffs2_zlib_decompress2(unsigned char *data_in, unsigned char *cpage_out,
188               __u32 srclen, __u32 destlen)
189 {
190     z_stream strm;
191@@ -175,3 +175,19 @@ void zlib_decompress(unsigned char *data
192     zlib_inflateEnd(&strm);
193     up(&inflate_sem);
194 }
195+
196+extern int jffs2_zlib_compress(unsigned char *data_in, unsigned char *cpage_out, __u32 * sourcelen, __u32 * dstlen);
197+extern void jffs2_zlib_decompress(unsigned char *data_in, unsigned char *cpage_out, __u32 srclen, __u32 destlen);
198+
199+int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
200+ __u32 *sourcelen, __u32 *dstlen)
201+{
202+ return jffs2_zlib_compress(data_in,cpage_out,sourcelen,dstlen);
203+}
204+
205+void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
206+ __u32 srclen, __u32 destlen)
207+{
208+ jffs2_zlib_decompress(data_in,cpage_out,srclen,destlen);
209+}
210+
211--- a/fs/jffs2/file.c
212+++ b/fs/jffs2/file.c
213@@ -35,6 +35,7 @@
214  *
215  */
216 
217+#include "jffs2_bbc_framework.h" /**BBC**/
218 #include <linux/kernel.h>
219 #include <linux/mtd/compatmac.h> /* for min() */
220 #include <linux/slab.h>
221@@ -459,6 +460,7 @@ int jffs2_commit_write (struct file *fil
222 
223         comprbuf = kmalloc(cdatalen, GFP_KERNEL);
224         if (comprbuf) {
225+ jffs2_bbc_model_set_act_sb(c); /**BBC**/
226             comprtype = jffs2_compress(page_address(pg)+ (file_ofs & (PAGE_CACHE_SIZE-1)), comprbuf, &datalen, &cdatalen);
227         }
228         if (comprtype == JFFS2_COMPR_NONE) {
229--- a/fs/jffs2/gc.c
230+++ b/fs/jffs2/gc.c
231@@ -35,6 +35,7 @@
232  *
233  */
234 
235+#include "jffs2_bbc_framework.h" /**BBC**/
236 #include <linux/kernel.h>
237 #include <linux/mtd/mtd.h>
238 #include <linux/slab.h>
239@@ -651,6 +652,7 @@ static int jffs2_garbage_collect_dnode(s
240         writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1));
241 
242         if (comprbuf) {
243+ jffs2_bbc_model_set_act_sb(c); /**BBC**/
244             comprtype = jffs2_compress(writebuf, comprbuf, &datalen, &cdatalen);
245         }
246         if (comprtype) {
247--- /dev/null
248+++ b/fs/jffs2/hpatch
249@@ -0,0 +1,191 @@
250+#!/usr/bin/perl
251+# A patch-like utility
252+# Designed for patching different version of jffs2 with the same hpatch file
253+#
254+# Copyright (C) 2004, Ferenc Havasi
255+#
256+# This program is free software; you can redistribute it and/or
257+# modify it under the terms of the GNU General Public License
258+# as published by the Free Software Foundation; either version 2
259+# of the License, or (at your option) any later version.
260+#
261+# This program is distributed in the hope that it will be useful,
262+# but WITHOUT ANY WARRANTY; without even the implied warranty of
263+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
264+# GNU General Public License for more details.
265+#
266+# You should have received a copy of the GNU General Public License
267+# along with this program; if not, write to the Free Software
268+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
269+
270+$filename_tmp1="file1.tmp";
271+$filename_tmp2="file2.tmp";
272+
273+$filename_in="";
274+$filename_out=$filename_tmp1;
275+$filename_cnt=0;
276+
277+# Modes:
278+# 0: expecting =
279+# 1: normal_cmd
280+# 2: skip until =
281+# 3: expecting F (first state)
282+$mode=3;
283+
284+%rules = ();
285+
286+sub file_end {
287+ if (($mode!=2)&&($modified==1)) {
288+ while (<SRC>) {
289+ print DST $_;
290+ }
291+ close(SRC);
292+ close(DST);
293+ if ($cmd_name ne "") { $rules{"$cmd_name"}=1; }
294+ $filename_result=$filename_out;
295+ if ($filename_result ne $filename_in_save) {
296+ open(RES,"<$filename_result") or die "Cannot open $filename_result.\n";
297+ open(DST,">$filename_in_save") or die "Cannot open $filename_in_save.\n";
298+ while (<RES>) {
299+ print DST $_;
300+ }
301+ close(DST);
302+ close(RES);
303+ }
304+ unlink($filename_tmp1) && unlink($filename_tmp2);
305+ }
306+ else {
307+ close(SRC);
308+ close(DST);
309+ $filename_result=$filename_in;
310+ if ($filename_result ne $filename_in_save) {
311+ open(RES,"<$filename_result") or die "Cannot open $filename_result.\n";
312+ open(DST,">$filename_in_save") or die "Cannot open $filename_in_save.\n";
313+ while (<RES>) {
314+ print DST $_;
315+ }
316+ close(DST);
317+ close(RES);
318+ }
319+ unlink($filename_tmp1);
320+ }
321+ $modified=0;
322+ foreach $rulename (keys %rules) {
323+ if ($rules{"$rulename"}==0) { print(STDERR "On $filename_in_save error applying rule $rulename.\n"); }
324+ }
325+ %rules = ();
326+}
327+
328+if ($#ARGV<0) {
329+ print ("usage: hpatch hpatch_file\n");
330+ exit;
331+}
332+
333+open(CMD,"<$ARGV[0]") or die "Cannot open $ARGV[0].\n";
334+$cmd_linenum=0;
335+
336+while (chomp($cmd_line=<CMD>)) {
337+ $cmd_linenum++;
338+ if ($cmd_line eq "") {next;}
339+ #$cmd_line =~ s/\#.*//;
340+ $cmd_line =~ s/\ *$//;
341+ if ($cmd_line eq "") {next;}
342+ if ($cmd_line =~ /^F(.*)/) {
343+ $tmp_filename_in=$1;
344+ if ($mode!=3) {
345+ file_end();
346+ }
347+ $filename_in=$tmp_filename_in;
348+ $filename_in_save=$filename_in;
349+ open(SRC,"<$filename_in") or die "Cannot open $filename_in.\n";
350+ open(DST,">$filename_out") or die "Cannot open $filename_out.\n";;
351+ $modified=0;
352+ $mode=0;
353+ next;
354+ }
355+ if ($mode==3) {die "error: F expression expected in line $cmd_linenum\n";}
356+ if ($cmd_line =~ /^=(.*)/) {
357+ $tmp_cmd_name=$1;
358+ if (($mode!=2)&&($modified==1)) {
359+ while (<SRC>) {
360+ print DST $_;
361+ }
362+ close(SRC);
363+ close(DST);
364+ if (($cmd_name ne "")) {$rules{"$cmd_name"}=1;};
365+ $filename_cnt++;
366+ if ($filename_cnt%2==1) {
367+ $filename_in=$filename_tmp1;
368+ $filename_out=$filename_tmp2;
369+ }
370+ else {
371+ $filename_in=$filename_tmp2;
372+ $filename_out=$filename_tmp1;
373+ }
374+ }
375+ else {
376+ close(SRC);
377+ close(DST);
378+ }
379+ $mode=1;
380+ $cmd_name=$tmp_cmd_name;
381+ if (($cmd_name ne "")) {
382+ if ($rules{"$cmd_name"}==1) {
383+ $mode=2;
384+ }
385+ else {
386+ $rules{"$cmd_name"}=0;
387+ }
388+ }
389+ open(SRC,"<$filename_in") or die "Cannot open $filename_in.\n";
390+ open(DST,">$filename_out") or die "Cannot open $filename_out.\n";
391+ $modified=0;
392+ next;
393+ }
394+ if ($mode == 0) {die "error: = expression expected in line $cmd_linenum\n";}
395+ if ($mode == 2) {next;}
396+ if ($cmd_line =~ /^!(.*)/) {
397+ print "$1\n";
398+ $modified=1;
399+ next;
400+ }
401+ if ($cmd_line =~ /^\?(.*)/) {
402+ $search_str=$1;
403+ $found=0;
404+ while (<SRC>) {
405+ print DST $_;
406+ if (index($_,$search_str)>=0) {$found=1; last;}
407+ }
408+ if ($found==0) { $mode=2; }
409+ next;
410+ }
411+ if ($cmd_line =~ /^\+(.*)/) {
412+ print DST "$1\n";
413+ $modified=1;
414+ next;
415+ }
416+ if ($cmd_line =~ /^\-(.*)/) {
417+ $search_str=$1;
418+ $found=0;
419+ while (<SRC>) {
420+ if (index($_,$search_str)>=0) {$saved_line=$_; $found=1; $modified=1; last;}
421+ print DST $_;
422+ }
423+ if ($found==0) { $mode=2; }
424+ next;
425+ }
426+ if ($cmd_line =~ /^i(.*)/) {
427+ $filename_inc=$1;
428+ open(INCSRC,"<$filename_inc") or die "Cannot open $filename_inc.\n";
429+ while (<INCSRC>) {
430+ print DST $_;
431+ }
432+ next;
433+ }
434+ if ($cmd_line =~ /^I/) {
435+ print DST $saved_line;
436+ next;
437+ }
438+}
439+file_end();
440+close(CMD);
441--- /dev/null
442+++ b/fs/jffs2/jffs2_bbc_armlib_comp.c
443@@ -0,0 +1,2224 @@
444+/*
445+ * JFFS2-BBC: armlib compressor plugin
446+ *
447+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
448+ *
449+ * Copyright (C) 2004, Ferenc Havasi & Tamas Gergely
450+ *
451+ * This program is free software; you can redistribute it and/or
452+ * modify it under the terms of the GNU General Public License
453+ * as published by the Free Software Foundation; either version 2
454+ * of the License, or (at your option) any later version.
455+ *
456+ * This program is distributed in the hope that it will be useful,
457+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
458+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
459+ * GNU General Public License for more details.
460+ *
461+ * You should have received a copy of the GNU General Public License
462+ * along with this program; if not, write to the Free Software
463+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
464+ *
465+ */
466+
467+#include "jffs2_bbc_framework.h"
468+
469+#ifdef __KERNEL__
470+#include <linux/string.h>
471+#else
472+#include <string.h>
473+#endif
474+
475+//ORIGIN: include/DataStructures/TypeDefs.h
476+
477+/*******************************************************************************
478+* FILE: TypeDefs.h
479+* AUTHOR: Tamás Gergely
480+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
481+*******************************************************************************/
482+
483+#ifndef TYPEDEFS_H
484+#define TYPEDEFS_H
485+
486+#pragma pack(4)
487+
488+#ifndef bool
489+#define bool char
490+#define true 1
491+#define false 0
492+#endif
493+
494+#ifndef u8
495+#define u8 unsigned char
496+#endif
497+#ifndef u16
498+#define u16 unsigned short
499+#endif
500+#ifndef u32
501+#define u32 unsigned long
502+#endif
503+#ifndef s8
504+#define s8 signed char
505+#endif
506+#ifndef s16
507+#define s16 signed short
508+#endif
509+#ifndef s32
510+#define s32 signed long
511+#endif
512+
513+typedef struct
514+{
515+ u32 capacity;
516+ u32 size;
517+ u32 alloc_size;
518+ void *ptr;
519+} vector;
520+
521+#define VECTOR_P_END(vct) ((void*)(((char*)((vct)->ptr)) + (vct)->size))
522+#define VECTOR_S_END(vct) ((void*)(((char*)((vct).ptr)) + (vct).size))
523+
524+static void vector_clear(vector *);
525+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
526+static void vector_reset(vector *);
527+static void vector_clr_ptr(vector *);
528+static void vector_add_u8(vector *, u8);
529+static void vector_add_u16(vector *, u16);
530+static void vector_add_u32(vector *, u32);
531+static void vector_add_s8(vector *, s8);
532+static void vector_add_s16(vector *, s16);
533+static void vector_add_s32(vector *, s32);
534+static void vector_add_ptr(vector *, void *);
535+static void vector_concat(vector *, vector *);
536+#endif
537+
538+#endif
539+
540+//ORIGIN: include/DataStructures/DataTypes.h
541+
542+/*******************************************************************************
543+* FILE: DataTypes.h
544+* AUTHOR: Tamás Gergely
545+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
546+*******************************************************************************/
547+
548+#ifndef DATATYPES_H
549+#define DATATYPES_H
550+
551+//#include "DataStructures/TypeDefs.h"
552+
553+typedef u16 THUMB_DataType;
554+typedef u32 ARM_DataType;
555+typedef u8 TokenType;
556+typedef u8 PredictorType;
557+typedef u8 *ProbDist;
558+
559+typedef vector RawData;
560+typedef vector RawBlocks;
561+typedef vector TokenStream;
562+typedef vector TokenBlocks;
563+typedef vector LatType;
564+
565+#define THUMB_DATA_LENGTH 16
566+#define ARM_DATA_LENGTH 32
567+#define TOKEN_LENGTH 8
568+#define TOKEN_MAXVALUE 0xff
569+#define PREDICTOR_LENGTH 8
570+#define PREDICTOR_MAXVALUE 0xff
571+
572+#endif
573+
574+//ORIGIN: include/DataStructures/BitVector.h
575+
576+/*******************************************************************************
577+* FILE: BitVector.h
578+* AUTHOR: Tamás Gergely
579+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
580+*******************************************************************************/
581+
582+#ifndef BITVECTOR_H
583+#define BITVECTOR_H
584+
585+//#include "DataStructures/TypeDefs.h"
586+
587+typedef vector BitBlocks;
588+
589+#pragma pack(4)
590+
591+typedef struct
592+{
593+ u32 freebits;
594+ u32 capacity;
595+ u32 size;
596+ u8 *base;
597+ u8 *ptr;
598+} BitVector;
599+
600+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
601+static void bitblocks_clear(BitBlocks *);
602+static void bitvector_clear(BitVector *);
603+static void bitvector_W_reset(BitVector *);
604+static void bitvector_W_add0(BitVector *);
605+static void bitvector_W_add1(BitVector *);
606+static void bitvector_W_concat_b(BitVector *, BitVector *);
607+static void bitvector_W_concat_v(BitVector *, vector *);
608+static void bitvector_W_flush(BitVector *);
609+static void bitvector_R_reset(BitVector *);
610+static u8 bitvector_R_get1(BitVector *);
611+static u8 bitvector_R_get8(BitVector *);
612+#endif
613+
614+#define BITVECTOR_P_END(bv) ((void*)(((bv)->base)+((bv)->size)))
615+#define BITVECTOR_S_END(bv) ((void*)( ((bv).base)+ ((bv).size)))
616+#define BITVECTOR_SKIP(bv,num) ((bv)->ptr) += (num)
617+
618+#endif
619+
620+//ORIGIN: include/DataStructures/DecisionTree.h
621+
622+/*******************************************************************************
623+* FILE: DecisionTree.h
624+* AUTHOR: Tamás Gergely
625+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
626+*******************************************************************************/
627+
628+#ifndef DECISIONTREE_H
629+#define DECISIONTREE_H
630+
631+//#include "DataStructures/DataTypes.h"
632+
633+#pragma pack(4)
634+
635+#define TREENODETYPE_NULLNODE 0
636+#define TREENODETYPE_NODE_BINARY_EQ 1
637+#define TREENODETYPE_LEAF_P 2
638+#define TREENODETYPE_LEAF_C 3
639+#define TREENODETYPE_NODE_BINARY_LT 5
640+#define TREENODETYPE_IS_NODE(n) (((n) == TREENODETYPE_NODE_BINARY_EQ) || \
641+ ((n) == TREENODETYPE_NODE_BINARY_LT))
642+#define TREENODETYPE_IS_NODE_BINARY(n) (((n) == TREENODETYPE_NODE_BINARY_EQ) || \
643+ ((n) == TREENODETYPE_NODE_BINARY_LT))
644+
645+#define TREENODETYPE_IS_LEAF(n) (((n) == TREENODETYPE_LEAF_P) || \
646+ ((n) == TREENODETYPE_LEAF_C))
647+
648+
649+#define TREE_SUBTREE_RELATION_LEFT_EQ !=
650+#define TREE_SUBTREE_RELATION_RIGHT_EQ ==
651+#define TREE_SUBTREE_RELATION_LEFT_LT <
652+#define TREE_SUBTREE_RELATION_RIGHT_LT >=
653+
654+#define GET_NODE_PTR_TYPE(n) (((TreeNodeDummy*)(n))->type)
655+
656+typedef struct
657+{
658+ u8 type;
659+} TreeNodeDummy;
660+
661+typedef struct
662+{
663+ u8 type; // [TREENODETYPE_NODE_BINARY]
664+ u8 attribute;
665+ PredictorType value;
666+ void *left;
667+ void *right;
668+} TreeNodeBinary;
669+
670+typedef struct
671+{
672+ u8 type; // [TREENODETYPE_LEAF_P]
673+ u16 pairs;
674+ PredictorType *probabilities;
675+} TreeLeafP;
676+
677+typedef struct
678+{
679+ u8 type; // [TREENODETYPE_LEAF_C]
680+ PredictorType predicted_class;
681+} TreeLeafC;
682+
683+typedef struct
684+{
685+ u32 high;
686+ u32 low;
687+ u32 max;
688+} ProbabilityType;
689+
690+
691+typedef struct
692+{
693+ void *root;
694+ u16 number_of_classes;
695+ u16 number_of_predictors;
696+ PredictorType *predictor_max_values;
697+} DecisionTree;
698+
699+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
700+static void decisiontree_delete(DecisionTree *);
701+static void decisiontree_get_probability_for_token(void *, PredictorType *, TokenType, ProbabilityType *);
702+static TokenType decisiontree_get_token_for_range(void *, PredictorType *, u32, u32, ProbabilityType *);
703+#endif
704+
705+#endif
706+
707+//ORIGIN: include/DataStructures/PredictorTable.h
708+
709+/*******************************************************************************
710+* FILE: PredictorTable.h
711+* AUTHOR: Tamás Gergely
712+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
713+*******************************************************************************/
714+
715+#ifndef PREDICTORTABLE_H
716+#define PREDICTORTABLE_H
717+
718+//#include "DataStructures/TypeDefs.h"
719+//#include "DataStructures/DataTypes.h"
720+////#include "DataStructures/Filter.h"
721+////#include "DataStructures/Converter.h"
722+////#include "DataStructures/Manipulator.h"
723+
724+#define NUMBER_OF_PREDICTORS_ARM 17
725+
726+#ifndef __KERNEL__
727+#define NUMBER_OF_PREDICTORS_TXT 2
728+#else
729+#undef TXT_TOKENS
730+#endif // __KERNEL__
731+
732+#ifdef TXT_TOKENS
733+#define NUMBER_OF_PREDICTORS NUMBER_OF_PREDICTORS_TXT
734+#define predictortable_reset predictortable_resetTXT
735+#define predictortable_update predictortable_updateTXT
736+#define predictortable_minvalue predictortable_minvalueTXT
737+#define predictortable_maxvalue predictortable_maxvalueTXT
738+#else
739+#define NUMBER_OF_PREDICTORS NUMBER_OF_PREDICTORS_ARM
740+#define predictortable_reset predictortable_resetARM
741+#define predictortable_update predictortable_updateARM
742+#define predictortable_minvalue predictortable_minvalueARM
743+#define predictortable_maxvalue predictortable_maxvalueARM
744+#endif
745+
746+
747+#pragma pack(4)
748+
749+typedef struct
750+{
751+ PredictorType *predictors;
752+} PredictorTable;
753+
754+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
755+static void predictortable_clear(PredictorTable *);
756+static void predictortable_free(PredictorTable *);
757+static void predictortable_resetARM(PredictorTable *);
758+static void predictortable_updateARM(PredictorTable *, TokenType);
759+static PredictorType predictortable_minvalueARM(PredictorTable *, u32);
760+static PredictorType predictortable_maxvalueARM(PredictorTable *, u32);
761+#endif
762+
763+#ifndef __KERNEL__
764+/*
765+static void predictortable_resetTXT(PredictorTable *);
766+static void predictortable_updateTXT(PredictorTable *, TokenType);
767+static PredictorType predictortable_minvalueTXT(PredictorTable *, u32);
768+static PredictorType predictortable_maxvalueTXT(PredictorTable *, u32);
769+*/
770+#endif // __KERNEL__
771+
772+#endif
773+
774+//ORIGIN: include/DataStructures/ipack_model.h
775+
776+/*******************************************************************************
777+* FILE: ipack_model.h
778+* AUTHOR: Tamás Gergely
779+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
780+*******************************************************************************/
781+
782+#ifndef IPACK_MODEL_H
783+#define IPACK_MODEL_H
784+
785+//#include "DataStructures/DataTypes.h"
786+//#include "DataStructures/DecisionTree.h"
787+//#include "DataStructures/PredictorTable.h"
788+
789+#define PROBABILITY_SHIFT 12
790+#define PROBABILITY_MAX 0x00001000l
791+
792+#define NUMBER_OF_TOKENS_ARM 16
793+#define NUMBER_OF_TOKENS_PER_INSTRUCTION_ARM 8
794+
795+#ifndef __KERNEL__
796+#define NUMBER_OF_TOKENS_TXT 256
797+#define NUMBER_OF_TOKENS_PER_INSTRUCTION_TXT 4
798+#else
799+#undef TXT_TOKENS
800+#endif // __KERNEL__
801+
802+#ifdef TXT_TOKENS
803+#define NUMBER_OF_TOKENS NUMBER_OF_TOKENS_TXT
804+#define NUMBER_OF_TOKENS_PER_INSTRUCTION NUMBER_OF_TOKENS_PER_INSTRUCTION_TXT
805+#else
806+#define NUMBER_OF_TOKENS NUMBER_OF_TOKENS_ARM
807+#define NUMBER_OF_TOKENS_PER_INSTRUCTION NUMBER_OF_TOKENS_PER_INSTRUCTION_ARM
808+#endif
809+
810+#pragma pack(4)
811+
812+/*
813+ Data structure of an internal node of the tree
814+*/
815+typedef struct
816+{
817+ PredictorType *attribute_ptr;
818+ u32 value; // PredictorType
819+ void *right_child_ptr;
820+} ipack_treenodeBin;
821+/*
822+ Data structure of a leaf with probabilities
823+*/
824+typedef struct
825+{
826+ u16 probabilities[0]; // PredictorType[0]
827+} ipack_treeleafP;
828+/*
829+ Data structure of a leaf with class prediction
830+*/
831+typedef struct
832+{
833+ PredictorType predicted_class; // PredictorType
834+} ipack_treeleafC;
835+/*
836+ Possible data structures of a tree node
837+*/
838+typedef union
839+{
840+ ipack_treenodeBin nodeBin;
841+ ipack_treeleafP leafP;
842+ ipack_treeleafC leafC;
843+} ipack_node_data;
844+/*
845+ Tree node
846+*/
847+typedef struct
848+{
849+ u32 type; // u8
850+ ipack_node_data data; // ipack_node_data
851+} ipack_nodetype;
852+/*
853+ Nullnode
854+*/
855+typedef struct
856+{
857+ u32 type;
858+ u16 probabilities[NUMBER_OF_TOKENS];
859+} ipack_nullnode;
860+/*
861+ Model for ipack project
862+*/
863+typedef struct
864+{
865+ char ID[4]; // char[4]
866+ char block_sign[4]; // only the first 2 are used!
867+ void *tree_root_ptr; // void*
868+ void *tree_code; // generated ARM code
869+ PredictorType *predictors_ptr; // PredictorType*
870+ ipack_nullnode nullnode;
871+} ipack_model_type;
872+
873+typedef struct
874+{
875+ u32 high;
876+ u32 low;
877+} ipack_probability_type;
878+
879+
880+static void ipack_model_get_probability_for_token(ipack_nodetype *, TokenType, ipack_probability_type *);
881+static TokenType ipack_model_get_token_for_range(ipack_nodetype *, u32, u32, ipack_probability_type *);
882+/*void ipack_model_predictortable_reset (PredictorType*);
883+void ipack_model_predictortable_update (PredictorType*, TokenType);*/
884+
885+#ifndef __KERNEL__
886+/*static void ipack_model_printinfo(ipack_model_type *);
887+static void ipack_dumpmodel(void *);*/
888+#endif
889+
890+#endif
891+
892+//ORIGIN: include/Builders/PredictorGenerator.h
893+
894+/*******************************************************************************
895+* FILE: PredictorGenerator.h
896+* AUTHOR: Tamás Gergely
897+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
898+*******************************************************************************/
899+
900+#ifndef PREDICTORGENERATOR_H
901+#define PREDICTORGENERATOR_H
902+
903+//#include "DataStructures.h"
904+
905+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
906+static PredictorTable *predictorgenerator_generate(void);
907+#endif
908+
909+#endif
910+
911+//ORIGIN: include/Builders/Coder.h
912+
913+/*******************************************************************************
914+* FILE: Coder.h
915+* AUTHOR: Tamás Gergely
916+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
917+*******************************************************************************/
918+
919+#ifndef CODER_H
920+#define CODER_H
921+
922+#define CODER_VALUEBITS 16
923+#define CODER_VALUEMAX 0x00010000l
924+#define CODER_VALUE3RD 0x0000c000l
925+#define CODER_VALUEHLF 0x00008000l
926+#define CODER_VALUE1ST 0x00004000l
927+
928+#endif
929+
930+//ORIGIN: DataStructures/src/TypeDefs.c
931+
932+/*******************************************************************************
933+* FILE: TypeDefs.c
934+* AUTHOR: Tamás Gergely
935+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
936+*******************************************************************************/
937+
938+//#include "ipack_common.h"
939+//#include "DataStructures/TypeDefs.h"
940+#ifndef __KERNEL__
941+#include <memory.h>
942+#endif
943+
944+#define VECTOR_ALLOC_SIZE 0x00001000
945+
946+static void vector_clear(vector * vct)
947+{
948+ if (vct->ptr)
949+ jffs2_bbc_free(vct->ptr);
950+ vct->capacity = 0;
951+ vct->size = 0;
952+ vct->ptr = 0;
953+}
954+
955+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
956+static void vector_extend(vector * vct)
957+{
958+ void *tmp;
959+ vct->capacity += vct->alloc_size;
960+ tmp = jffs2_bbc_malloc(vct->capacity);
961+ if (vct->ptr) {
962+ memcpy(tmp, vct->ptr, vct->size);
963+ jffs2_bbc_free(vct->ptr);
964+ }
965+ vct->ptr = tmp;
966+}
967+
968+static void vector_reset(vector * vct)
969+{
970+ vct->capacity = 0;
971+ vct->size = 0;
972+ vct->alloc_size = VECTOR_ALLOC_SIZE;
973+ vct->ptr = 0;
974+}
975+
976+static void vector_clr_ptr(vector * vct)
977+{
978+ void **it;
979+ void *end_it;
980+ for (it = vct->ptr, end_it = (((char *) (vct->ptr)) + vct->size); it != end_it; it++) {
981+ vector_clear(*it);
982+ jffs2_bbc_free(*it);
983+ }
984+ if (vct->ptr)
985+ jffs2_bbc_free(vct->ptr);
986+ vct->capacity = 0;
987+ vct->size = 0;
988+ vct->ptr = 0;
989+}
990+
991+static void vector_add_u8(vector * vct, u8 val)
992+{
993+ if ((vct->size) + sizeof(u8) > (vct->capacity)) {
994+ vector_extend(vct);
995+ }
996+ *(u8 *) ((char *) (vct->ptr) + (vct->size)) = val;
997+ vct->size += sizeof(u8);
998+};
999+
1000+static void vector_add_u16(vector * vct, u16 val)
1001+{
1002+ if ((vct->size) + sizeof(u16) > (vct->capacity)) {
1003+ vector_extend(vct);
1004+ }
1005+ *(u16 *) ((char *) (vct->ptr) + (vct->size)) = val;
1006+ vct->size += sizeof(u16);
1007+};
1008+
1009+static void vector_add_u32(vector * vct, u32 val)
1010+{
1011+ if ((vct->size) + sizeof(u32) > (vct->capacity)) {
1012+ vector_extend(vct);
1013+ }
1014+ *(u32 *) ((char *) (vct->ptr) + (vct->size)) = val;
1015+ vct->size += sizeof(u32);
1016+};
1017+
1018+static void vector_add_s8(vector * vct, s8 val)
1019+{
1020+ if ((vct->size) + sizeof(s8) > (vct->capacity)) {
1021+ vector_extend(vct);
1022+ }
1023+ *(s8 *) ((char *) (vct->ptr) + (vct->size)) = val;
1024+ vct->size += sizeof(s8);
1025+};
1026+
1027+static void vector_add_s16(vector * vct, s16 val)
1028+{
1029+ if ((vct->size) + sizeof(s16) > (vct->capacity)) {
1030+ vector_extend(vct);
1031+ }
1032+ *(s16 *) ((char *) (vct->ptr) + (vct->size)) = val;
1033+ vct->size += sizeof(s16);
1034+};
1035+
1036+static void vector_add_s32(vector * vct, s32 val)
1037+{
1038+ if ((vct->size) + sizeof(s32) > (vct->capacity)) {
1039+ vector_extend(vct);
1040+ }
1041+ *(s32 *) ((char *) (vct->ptr) + (vct->size)) = val;
1042+ vct->size += sizeof(s32);
1043+};
1044+
1045+static void vector_add_ptr(vector * vct, void *ptr)
1046+{
1047+ if ((vct->size) + sizeof(void *) > (vct->capacity)) {
1048+ vector_extend(vct);
1049+ }
1050+ *(void **) ((char *) (vct->ptr) + (vct->size)) = ptr;
1051+ vct->size += sizeof(void *);
1052+}
1053+
1054+static void vector_concat(vector * lhs, vector * rhs)
1055+{
1056+ void *tmp;
1057+ if (!(rhs->size)) {
1058+ return;
1059+ }
1060+ tmp = lhs->ptr;
1061+ lhs->capacity = (lhs->size) + (rhs->size);
1062+ lhs->ptr = jffs2_bbc_malloc(lhs->capacity);
1063+ if (tmp) {
1064+ memcpy(lhs->ptr, tmp, lhs->size);
1065+ jffs2_bbc_free(tmp);
1066+ }
1067+ memcpy((((u8 *) lhs->ptr) + lhs->size), rhs->ptr, rhs->size);
1068+ lhs->size += rhs->size;
1069+}
1070+
1071+#endif
1072+
1073+//ORIGIN: DataStructures/src/BitVector.c
1074+
1075+/*******************************************************************************
1076+* FILE: BitVector.c
1077+* AUTHOR: Tamás Gergely
1078+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
1079+*******************************************************************************/
1080+
1081+//#include "ipack_common.h"
1082+//#include "DataStructures/BitVector.h"
1083+#ifndef __KERNEL__
1084+#include <memory.h>
1085+#endif
1086+
1087+#define VECTOR_ALLOC_SIZE 0x00001000
1088+
1089+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
1090+
1091+static void bitblocks_clear(BitBlocks * this)
1092+{
1093+ BitVector **it;
1094+ void *end_it;
1095+ for (it = this->ptr, end_it = VECTOR_P_END(this); it != end_it; it++) {
1096+ bitvector_clear(*it);
1097+ jffs2_bbc_free(*it);
1098+ }
1099+ jffs2_bbc_free(this->ptr);
1100+ this->ptr = 0;
1101+}
1102+
1103+static void bitvector_clear(BitVector * this)
1104+{
1105+ if (this->base) {
1106+ jffs2_bbc_free(this->base);
1107+ }
1108+ this->freebits = 0;
1109+ this->capacity = 0;
1110+ this->size = 0;
1111+ this->base = 0;
1112+ this->ptr = 0;
1113+}
1114+
1115+static void bitvector_W_reset(BitVector * this)
1116+{
1117+ this->freebits = 0;
1118+ this->capacity = 0;
1119+ this->size = 0;
1120+ this->base = 0;
1121+ this->ptr = 0;
1122+}
1123+
1124+static void bitvector_W_add0(BitVector * this)
1125+{
1126+ if (!(this->freebits)) {
1127+ if (this->size == this->capacity) {
1128+ void *tmp = this->base;
1129+ this->capacity += VECTOR_ALLOC_SIZE;
1130+ this->base = jffs2_bbc_malloc(this->capacity);
1131+ this->ptr = ((u8 *) (this->base)) + this->size;
1132+ memcpy(this->base, tmp, this->size);
1133+ jffs2_bbc_free(tmp);
1134+ }
1135+ else {
1136+ this->ptr++;
1137+ }
1138+ this->size++;
1139+ this->freebits = 7;
1140+ *(this->ptr) = 0x00;
1141+ }
1142+ else {
1143+ this->freebits--;
1144+ (*(this->ptr)) <<= 1;
1145+ }
1146+}
1147+
1148+static void bitvector_W_add1(BitVector * this)
1149+{
1150+ if (!(this->freebits)) {
1151+ if (this->size == this->capacity) {
1152+ void *tmp = this->base;
1153+ this->capacity += VECTOR_ALLOC_SIZE;
1154+ this->base = jffs2_bbc_malloc(this->capacity);
1155+ this->ptr = ((u8 *) (this->base)) + this->size;
1156+ memcpy(this->base, tmp, this->size);
1157+ jffs2_bbc_free(tmp);
1158+ }
1159+ else {
1160+ this->ptr++;
1161+ }
1162+ this->size++;
1163+ this->freebits = 7;
1164+ *(this->ptr) = 0x01;
1165+ }
1166+ else {
1167+ this->freebits--;
1168+ (*(this->ptr)) <<= 1;
1169+ (*(this->ptr)) |= 0x01;
1170+ }
1171+}
1172+
1173+static void bitvector_W_concat_b(BitVector * lhs, BitVector * rhs)
1174+{
1175+ void *tmp;
1176+ if (!(rhs->size)) {
1177+ return;
1178+ }
1179+ tmp = lhs->base;
1180+ lhs->capacity = ((((lhs->size) + (rhs->size) - 1) / VECTOR_ALLOC_SIZE) + 1) * VECTOR_ALLOC_SIZE;
1181+ lhs->base = jffs2_bbc_malloc(lhs->capacity);
1182+ if (tmp) {
1183+ memcpy(lhs->base, tmp, lhs->size);
1184+ jffs2_bbc_free(tmp);
1185+ }
1186+ memcpy((((u8 *) (lhs->base)) + lhs->size), rhs->base, rhs->size);
1187+ lhs->freebits = 0;
1188+ lhs->size += rhs->size;
1189+ lhs->ptr = ((u8 *) (lhs->base)) + lhs->size;
1190+}
1191+
1192+static void bitvector_W_concat_v(BitVector * lhs, vector * rhs)
1193+{
1194+ void *tmp;
1195+ if (!(rhs->size)) {
1196+ return;
1197+ }
1198+ tmp = lhs->base;
1199+ lhs->capacity = ((((lhs->size) + (rhs->size) - 1) / VECTOR_ALLOC_SIZE) + 1) * VECTOR_ALLOC_SIZE;
1200+ lhs->base = jffs2_bbc_malloc(lhs->capacity);
1201+ if (tmp) {
1202+ memcpy(lhs->base, tmp, lhs->size);
1203+ jffs2_bbc_free(tmp);
1204+ }
1205+ memcpy((((u8 *) (lhs->base)) + lhs->size), rhs->ptr, rhs->size);
1206+ lhs->freebits = 0;
1207+ lhs->size += rhs->size;
1208+ lhs->ptr = ((u8 *) (lhs->base)) + lhs->size;
1209+}
1210+
1211+static void bitvector_W_flush(BitVector * this)
1212+{
1213+ (*(this->ptr)) <<= this->freebits;
1214+ this->freebits = 0;
1215+}
1216+
1217+static void bitvector_R_reset(BitVector * this)
1218+{
1219+ this->freebits = 7;
1220+ this->ptr = this->base;
1221+}
1222+
1223+static u8 bitvector_R_get1(BitVector * this)
1224+{
1225+ u8 tmp = ((*(this->ptr)) >> this->freebits) & 0x01;
1226+ if (!(this->freebits)) {
1227+ this->freebits = 7;
1228+ this->ptr++;
1229+ }
1230+ else {
1231+ this->freebits--;
1232+ }
1233+ return tmp;
1234+}
1235+
1236+static u8 bitvector_R_get8(BitVector * this)
1237+{
1238+ u8 tmp = (*(this->ptr));
1239+ this->ptr++;
1240+ return tmp;
1241+}
1242+
1243+#endif
1244+
1245+//ORIGIN: DataStructures/src/DecisionTree.c
1246+
1247+/*******************************************************************************
1248+* FILE: DecisionTree.c
1249+* AUTHOR: Tamás Gergely
1250+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
1251+*******************************************************************************/
1252+
1253+//#include "ipack_common.h"
1254+//#include "DataStructures/DecisionTree.h"
1255+
1256+static void decisiontree_delete_node(void *root)
1257+{
1258+ u8 tmp = GET_NODE_PTR_TYPE(root);
1259+ if (TREENODETYPE_IS_NODE_BINARY(tmp)) {
1260+ decisiontree_delete_node(((TreeNodeBinary *) root)->left);
1261+ decisiontree_delete_node(((TreeNodeBinary *) root)->right);
1262+ }
1263+ else if ((tmp) == TREENODETYPE_LEAF_P) {
1264+ if (((TreeLeafP *) root)->probabilities) {
1265+ jffs2_bbc_free(((TreeLeafP *) root)->probabilities);
1266+ }
1267+ }
1268+ else if ((tmp) == TREENODETYPE_LEAF_C) {
1269+ }
1270+ jffs2_bbc_free(root);
1271+}
1272+
1273+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
1274+
1275+static void decisiontree_delete(DecisionTree * dt)
1276+{
1277+ decisiontree_delete_node(dt->root);
1278+ jffs2_bbc_free(dt->predictor_max_values);
1279+}
1280+
1281+static void decisiontree_get_probability_for_token(void *root, PredictorType * preds, TokenType token, ProbabilityType * prob)
1282+{
1283+ void *tmp = root;
1284+ while (TREENODETYPE_IS_NODE(((TreeNodeBinary *) tmp)->type)) {
1285+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_EQ) {
1286+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_EQ((TreeNodeBinary *) tmp)->value) {
1287+ tmp = ((TreeNodeBinary *) tmp)->left;
1288+ }
1289+ else {
1290+ tmp = ((TreeNodeBinary *) tmp)->right;
1291+ }
1292+ }
1293+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_LT) {
1294+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_LT((TreeNodeBinary *) tmp)->value) {
1295+ tmp = ((TreeNodeBinary *) tmp)->left;
1296+ }
1297+ else {
1298+ tmp = ((TreeNodeBinary *) tmp)->right;
1299+ }
1300+ }
1301+ }
1302+ prob->high = 0;
1303+ prob->low = 0;
1304+ prob->max = 0;
1305+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_P) {
1306+ u32 i;
1307+ u32 lngth = ((TreeLeafP *) tmp)->pairs << 1;
1308+ for (i = 0; i < lngth;) {
1309+ TokenType at = ((TreeLeafP *) tmp)->probabilities[i++];
1310+ TokenType av = ((TreeLeafP *) tmp)->probabilities[i++];
1311+ if (token > at)
1312+ prob->low += av;
1313+ if (token >= at)
1314+ prob->high += av;
1315+ prob->max += av;
1316+ }
1317+ }
1318+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_C) {
1319+ if (((TreeLeafC *) tmp)->predicted_class == token) {
1320+ prob->high = TOKEN_MAXVALUE;
1321+ prob->max = TOKEN_MAXVALUE;
1322+ }
1323+ }
1324+}
1325+
1326+static TokenType decisiontree_get_token_for_range(void *root, PredictorType * preds, u32 value, u32 range, ProbabilityType * prob)
1327+{
1328+ void *tmp = root;
1329+ TokenType token = 0;
1330+ while (TREENODETYPE_IS_NODE(((TreeNodeBinary *) tmp)->type)) {
1331+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_EQ) {
1332+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_EQ((TreeNodeBinary *) tmp)->value) {
1333+ tmp = ((TreeNodeBinary *) tmp)->left;
1334+ }
1335+ else {
1336+ tmp = ((TreeNodeBinary *) tmp)->right;
1337+ }
1338+ }
1339+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_LT) {
1340+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_LT((TreeNodeBinary *) tmp)->value) {
1341+ tmp = ((TreeNodeBinary *) tmp)->left;
1342+ }
1343+ else {
1344+ tmp = ((TreeNodeBinary *) tmp)->right;
1345+ }
1346+ }
1347+ }
1348+ prob->high = 0;
1349+ prob->low = 0;
1350+ prob->max = 0;
1351+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_P) {
1352+ u32 i;
1353+ u32 norm;
1354+ TokenType at = 0;
1355+ TokenType av;
1356+ u32 lngth = ((TreeLeafP *) tmp)->pairs << 1;
1357+ for (i = 0; i < lngth;) {
1358+ i++;
1359+ prob->max += ((TreeLeafP *) tmp)->probabilities[i++];
1360+ }
1361+ norm = (value * prob->max - 1) / range;
1362+ for (i = 0; prob->high <= norm;) {
1363+ at = ((TreeLeafP *) tmp)->probabilities[i++];
1364+ av = ((TreeLeafP *) tmp)->probabilities[i++];
1365+ prob->high += av;
1366+ if (prob->high <= norm)
1367+ prob->low += av;
1368+ }
1369+ token = at;
1370+ }
1371+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_C) {
1372+ token = ((TreeLeafC *) tmp)->predicted_class;
1373+ prob->high = TOKEN_MAXVALUE;
1374+ prob->max = TOKEN_MAXVALUE;
1375+ }
1376+ return token;
1377+}
1378+#endif
1379+
1380+//ORIGIN: DataStructures/src/PredictorTable.c
1381+
1382+/*******************************************************************************
1383+* FILE: PredictorTable.c
1384+* AUTHOR: Tamás Gergely
1385+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
1386+*******************************************************************************/
1387+
1388+//#include "ipack_common.h"
1389+//#include "DataStructures/PredictorTable.h"
1390+
1391+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
1392+
1393+static void predictortable_clear(PredictorTable * table)
1394+{
1395+ table->predictors = 0;
1396+}
1397+
1398+static void predictortable_free(PredictorTable * table)
1399+{
1400+ if (table->predictors) {
1401+ jffs2_bbc_free(table->predictors);
1402+ table->predictors = 0;
1403+ }
1404+}
1405+
1406+static void predictortable_resetARM(PredictorTable * table)
1407+{
1408+ register PredictorType *ptr = table->predictors;
1409+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS_ARM;
1410+ while (ptr < end) {
1411+ *(ptr++) = 0;
1412+ }
1413+}
1414+
1415+static void predictortable_updateARM(PredictorTable * table, TokenType token)
1416+{
1417+ register PredictorType *ptr = table->predictors;
1418+ register u32 ndx = ptr[0] + 1;
1419+ ptr[ndx + 8] = ptr[ndx];
1420+ ptr[ndx] = token;
1421+ if (ndx == 8) {
1422+ ptr[0] = 0;
1423+ }
1424+ else {
1425+ ++ptr[0];
1426+ }
1427+}
1428+
1429+static PredictorType predictortable_minvalueARM(PredictorTable * table, u32 index)
1430+{
1431+ return 0;
1432+}
1433+
1434+static PredictorType predictortable_maxvalueARM(PredictorTable * table, u32 index)
1435+{
1436+ if (index == 0) {
1437+ return 7;
1438+ }
1439+ else {
1440+ return 15;
1441+ }
1442+}
1443+
1444+#endif
1445+
1446+#ifndef __KERNEL__
1447+
1448+/*static void predictortable_resetTXT(PredictorTable * table)
1449+{
1450+ register PredictorType *ptr = table->predictors;
1451+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS_TXT;
1452+ while (ptr < end) {
1453+ *(ptr++) = 0;
1454+ }
1455+}
1456+
1457+static void predictortable_updateTXT(PredictorTable * table, TokenType token)
1458+{ //TODO: modify
1459+ register PredictorType *ptr = table->predictors;
1460+// register u32 ndx;
1461+ ptr[0] = token;
1462+ if ((('a' <= token) && (token <= 'z')) || (('A' <= token) && (token <= 'Z'))) {
1463+ ++(ptr[1]);
1464+ }
1465+ else {
1466+ ptr[1] = 0;
1467+ }
1468+}
1469+
1470+static PredictorType predictortable_minvalueTXT(PredictorTable * table, u32 index)
1471+{
1472+ return 0;
1473+}
1474+
1475+static PredictorType predictortable_maxvalueTXT(PredictorTable * table, u32 index)
1476+{ //TODO: modify
1477+ return 254;
1478+}*/
1479+
1480+#endif // __KERNEL__
1481+
1482+//ORIGIN: DataStructures/src/ipack_model.c
1483+
1484+/*******************************************************************************
1485+* FILE: ipack_model.c
1486+* AUTHOR: Tamás Gergely
1487+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
1488+*******************************************************************************/
1489+
1490+//#include "DataStructures/ipack_model.h"
1491+//#include "measuredef.h"
1492+//#include "ipack_common.h"
1493+
1494+#ifdef __MEASURE_TIME_MODEL_GETPROB
1495+#define __MT_P_MAX 256
1496+#define __MT_P_DIV 128
1497+#define __MT_P_MIN 0
1498+#endif
1499+
1500+static void ipack_model_get_probability_for_token(ipack_nodetype * tmp, TokenType token, ipack_probability_type * prob)
1501+{
1502+// register ipack_nodetype* tmp = model->tree_root_ptr;
1503+// register ipack_nodetype* tmp = root;
1504+ while (TREENODETYPE_IS_NODE(tmp->type)) {
1505+ if (tmp->type == TREENODETYPE_NODE_BINARY_EQ) {
1506+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_EQ tmp->data.nodeBin.value) {
1507+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
1508+ }
1509+ else {
1510+ tmp = tmp->data.nodeBin.right_child_ptr;
1511+ }
1512+ }
1513+ else if (tmp->type == TREENODETYPE_NODE_BINARY_LT) {
1514+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_LT tmp->data.nodeBin.value) {
1515+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
1516+ }
1517+ else {
1518+ tmp = tmp->data.nodeBin.right_child_ptr;
1519+ }
1520+ }
1521+ }
1522+ prob->high = 0;
1523+ prob->low = 0;
1524+// prob->max = 0;
1525+ if (tmp->type == TREENODETYPE_LEAF_P) {
1526+ if (token) {
1527+ prob->low = tmp->data.leafP.probabilities[token - 1];
1528+ }
1529+ prob->high = tmp->data.leafP.probabilities[token];
1530+// prob->max = tmp->data.leafP.probabilities[15];
1531+ }
1532+ else if (tmp->type == TREENODETYPE_LEAF_C) {
1533+ if (tmp->data.leafC.predicted_class == token) {
1534+ prob->high = TOKEN_MAXVALUE;
1535+// prob->max = TOKEN_MAXVALUE;
1536+ }
1537+ }
1538+}
1539+
1540+#ifndef IPACK_ARM_ASM
1541+
1542+//return ipack_model_get_token_for_range2(tmp,value,range,prob);
1543+
1544+static TokenType ipack_model_get_token_for_range(ipack_nodetype * tmp, u32 value, u32 range, ipack_probability_type * prob)
1545+{
1546+// register ipack_nodetype* tmp = model->tree_root_ptr;
1547+// register ipack_nodetype* tmp = root;
1548+ register TokenType token = 0;
1549+ while (TREENODETYPE_IS_NODE(tmp->type)) {
1550+ if (tmp->type == TREENODETYPE_NODE_BINARY_EQ) {
1551+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_EQ tmp->data.nodeBin.value) {
1552+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
1553+ }
1554+ else {
1555+ tmp = tmp->data.nodeBin.right_child_ptr;
1556+ }
1557+ }
1558+ else if (tmp->type == TREENODETYPE_NODE_BINARY_LT) {
1559+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_LT tmp->data.nodeBin.value) {
1560+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
1561+ }
1562+ else {
1563+ tmp = tmp->data.nodeBin.right_child_ptr;
1564+ }
1565+ }
1566+ }
1567+ prob->high = 0;
1568+ prob->low = 0;
1569+// prob->max = 0;
1570+ if (tmp->type == TREENODETYPE_LEAF_P) {
1571+ u32 i;
1572+ u32 norm;
1573+// prob->max = tmp->data.leafP.probabilities[15];
1574+/* norm = (value * prob->max -1)/range;
1575+ for(i = 0; i < 15; ++i) {
1576+ if(tmp->data.leafP.probabilities[i] > norm) {
1577+ break;
1578+ }
1579+ }*/
1580+ norm = ((value << PROBABILITY_SHIFT) - 1);
1581+ for (i = 0; i < NUMBER_OF_TOKENS; ++i) {
1582+ if (range * tmp->data.leafP.probabilities[i] > norm) {
1583+ break;
1584+ }
1585+ }
1586+ token = (TokenType) i;
1587+ prob->high = tmp->data.leafP.probabilities[i];
1588+ if (token) {
1589+ prob->low = tmp->data.leafP.probabilities[token - 1];
1590+ }
1591+ }
1592+ else if (tmp->type == TREENODETYPE_LEAF_C) {
1593+ token = tmp->data.leafC.predicted_class;
1594+ prob->high = PROBABILITY_MAX;
1595+// prob->max = PROBABILITY_MAX;
1596+ }
1597+ return token;
1598+}
1599+#endif
1600+/*
1601+void ipack_model_predictortable_reset(PredictorType* ptr)
1602+{
1603+// register PredictorType* ptr = model->predictors_ptr;
1604+// register PredictorType* ptr = preds;
1605+ register PredictorType* end = ptr + NUMBER_OF_PREDICTORS;
1606+ while(ptr < end) {
1607+ *(ptr++) = 0;
1608+ }
1609+}
1610+
1611+void ipack_model_predictortable_update(PredictorType* ptr, TokenType token)
1612+{
1613+// register PredictorType* ptr = model->predictors_ptr;
1614+// register PredictorType* ptr = preds;
1615+ register u32 ndx = ptr[0] + 1;
1616+ ptr[ndx + 8] = ptr[ndx];
1617+ ptr[ndx] = token;
1618+ if(ndx == 8) {
1619+ ptr[0] = 0;
1620+ } else {
1621+ ++ ptr[0];
1622+ }
1623+}*/
1624+/****************************************************************************/
1625+
1626+#ifndef __KERNEL__
1627+static void ipack_model_countpreds(void *ptr, ipack_nodetype * node, double *table, double val)
1628+{
1629+ if ((node->type == TREENODETYPE_NODE_BINARY_EQ) || (node->type == TREENODETYPE_NODE_BINARY_LT)) {
1630+ table[(u32) (node->data.nodeBin.attribute_ptr) - (u32) (ptr)] += val;
1631+ ipack_model_countpreds(ptr, (void *) (((u8 *) (node)) + sizeof(node->type) + sizeof(ipack_treenodeBin)), table, val / 2);
1632+ ipack_model_countpreds(ptr, node->data.nodeBin.right_child_ptr, table, val / 2);
1633+ }
1634+ else {
1635+ }
1636+}
1637+
1638+/*static void ipack_model_printinfo(ipack_model_type * model)
1639+{
1640+ double *prcnt = jffs2_bbc_malloc(sizeof(double) * NUMBER_OF_PREDICTORS);
1641+ u32 i;
1642+ for (i = 0; i < NUMBER_OF_PREDICTORS; i++) {
1643+ prcnt[i] = 0.0;
1644+ }
1645+ ipack_model_countpreds(model->predictors_ptr, model->tree_root_ptr, prcnt, 100);
1646+ for (i = 0; i < NUMBER_OF_PREDICTORS; i++) {
1647+ jffs2_bbc_print3(" p[%3d] = %10.6lf\n", (int) i, prcnt[i]);
1648+ }
1649+ jffs2_bbc_free(prcnt);
1650+}*/
1651+
1652+static void ipack_dumpnode(unsigned char **ptr, FILE * file, char *prefs)
1653+{
1654+ switch (*((*ptr)++)) {
1655+ u32 i;
1656+ u32 j;
1657+ u32 x;
1658+ u32 y;
1659+ case TREENODETYPE_NODE_BINARY_EQ:
1660+ x = *((*ptr)++);
1661+ y = *((*ptr)++);
1662+ fprintf(file, "%s+->\tBinary node: P[%u] equals %u\n", prefs, (unsigned int)x, (unsigned int)y);
1663+ for (j = 0; j < 4096 && prefs[j]; ++j);
1664+ prefs[j] = '\t';
1665+ prefs[++j] = '|';
1666+ ipack_dumpnode(ptr, file, prefs);
1667+ prefs[j--] = 0;
1668+ ipack_dumpnode(ptr, file, prefs);
1669+ prefs[j] = 0;
1670+ break;
1671+ case TREENODETYPE_NODE_BINARY_LT:
1672+ x = *((*ptr)++);
1673+ y = *((*ptr)++);
1674+ fprintf(file, "%s+->\tBinary node: P[%u] greater than %u\n", prefs, (unsigned int)x, (unsigned int)y);
1675+ for (j = 0; j < 4096 && prefs[j]; ++j);
1676+ prefs[j] = '\t';
1677+ prefs[++j] = '|';
1678+ ipack_dumpnode(ptr, file, prefs);
1679+ prefs[j--] = 0;
1680+ ipack_dumpnode(ptr, file, prefs);
1681+ prefs[j] = 0;
1682+ break;
1683+ case TREENODETYPE_LEAF_P:
1684+ x = *((*ptr)++);
1685+ fprintf(file, "%s+->\tLeaf: %u pairs\n", prefs, (unsigned int)x);
1686+ (*ptr) += (x << 1);
1687+ break;
1688+ case TREENODETYPE_LEAF_C:
1689+ x = *((*ptr)++);
1690+ fprintf(file, "%s+->\tLeaf: class %u\n", prefs, (unsigned int)x);
1691+ break;
1692+ default:
1693+ fprintf(file, "%s+->\tLeaf: nullnode\n", prefs);
1694+ }
1695+}
1696+
1697+/*static void ipack_dumpmodel(void *model)
1698+{
1699+ unsigned char *tmp_ptr = model;
1700+ FILE *file;
1701+ char C[4096];
1702+ if ((file = fopen("DUMPED_MODEL", "wa"))) {
1703+ int i;
1704+ for (i = 0; i < 4096; C[i++] = 0);
1705+ tmp_ptr += 8;
1706+ tmp_ptr += sizeof(u32);
1707+ ipack_dumpnode(&tmp_ptr, file, C);
1708+ fclose(file);
1709+ }
1710+}*/
1711+
1712+#endif
1713+
1714+//ORIGIN: Builders/src/PredictorGenerator.c
1715+
1716+/*******************************************************************************
1717+* FILE: PredictorGenerator.c
1718+* AUTHOR: Tamás Gergely
1719+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
1720+*******************************************************************************/
1721+
1722+//#include "ipack_common.h"
1723+//#include "Builders/PredictorGenerator.h"
1724+
1725+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
1726+static PredictorTable *predictorgenerator_generate( /*PredictorGeneratorSettings* settings */ )
1727+{
1728+ PredictorTable *ptr = jffs2_bbc_malloc(sizeof(PredictorTable));
1729+ predictortable_clear(ptr);
1730+ ptr->predictors = jffs2_bbc_malloc(NUMBER_OF_PREDICTORS * sizeof(PredictorType));
1731+ return ptr;
1732+}
1733+#endif
1734+
1735+//ORIGIN: Builders/src/ipack_armlib_compressor.c
1736+
1737+/*******************************************************************************
1738+* FILE: ipack_armlim_compressor.c
1739+* AUTHOR: Tamás Gergely
1740+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
1741+*******************************************************************************/
1742+
1743+//#include "ipack_common.h"
1744+//#include "DataStructures.h"
1745+//#include "Builders/PredictorGenerator.h"
1746+//#include "Builders/Tokenizer.h"
1747+//#include "Builders/Coder.h"
1748+
1749+#define EC_NO_ERROR 0
1750+#define EC_NOT_IPMF_FILE -1
1751+#define EC_NOT_IPMF_MODEL -2
1752+#define EC_NOT_HG_BLOCK -3
1753+#define EC_WRONG_INPUT_LENGTH -501
1754+#define EC_CODER_WRONG_PROBABILITY 1
1755+#define EC_CODER_WRONG_RANGE 2
1756+#define EC_BUFFER_OVERFLOW 501
1757+#define EC_BUFFER_UNDERFLOW 502
1758+#define EC_UNKNOWN_TOKEN_TYPE 1001
1759+#define EC_UNKNOWN_FILTER 1002
1760+#define EC_UNKNOWN_CONVERTER 1003
1761+#define EC_UNKNOWN_MANIPULATOR 1004
1762+
1763+/*******************************************************************************
1764+
1765+ COMPRESSOR INIT FUNCTIONS
1766+
1767+*******************************************************************************/
1768+
1769+#define ROUND_UP_TO_DWORD(val) ( ( (val) + 3 ) & 0xfffffffc )
1770+
1771+#ifndef __KERNEL__
1772+int ipack_glb_endian_X;
1773+#endif
1774+
1775+static int ipack_compressor_init_tree(unsigned char **ptr, ipack_model_type * model, ipack_nodetype * node, void *nullnode)
1776+{
1777+ int retval = 0;
1778+ node->type = *((*ptr)++);
1779+ switch (node->type) {
1780+ u32 i;
1781+ u32 j;
1782+ u32 lngth;
1783+ u32 tmpret;
1784+ TokenType at;
1785+ u16 av;
1786+ case TREENODETYPE_NODE_BINARY_EQ:
1787+ case TREENODETYPE_NODE_BINARY_LT:
1788+ node->data.nodeBin.attribute_ptr = (model->predictors_ptr) + (*((*ptr)++));
1789+ node->data.nodeBin.value = *((*ptr)++);
1790+ retval = sizeof(node->data.nodeBin);
1791+ retval += ipack_compressor_init_tree(ptr, model, (void *) ROUND_UP_TO_DWORD(((u32) node) + sizeof(node->type) + sizeof(node->data.nodeBin)), nullnode);
1792+ node->data.nodeBin.right_child_ptr = (void *) ROUND_UP_TO_DWORD(((u32) node) + retval + sizeof(node->type));
1793+ retval += ipack_compressor_init_tree(ptr, model, node->data.nodeBin.right_child_ptr, nullnode);
1794+ break;
1795+ case TREENODETYPE_LEAF_P:
1796+ lngth = *((*ptr)++);
1797+ av = 0;
1798+ for (i = 0, j = 0; i < lngth; ++i) {
1799+ at = *((*ptr)++);
1800+ while (j < at) {
1801+ node->data.leafP.probabilities[j++] = av;
1802+ }
1803+ av += *((*ptr)++);
1804+ }
1805+ while (j < NUMBER_OF_TOKENS) {
1806+ node->data.leafP.probabilities[j++] = av;
1807+ }
1808+ for (i = 0; i < NUMBER_OF_TOKENS; ++i) {
1809+ node->data.leafP.probabilities[i] = ((node->data.leafP.probabilities[i] << PROBABILITY_SHIFT) / node->data.leafP.probabilities[NUMBER_OF_TOKENS - 1]);
1810+ }
1811+ retval = ROUND_UP_TO_DWORD(NUMBER_OF_TOKENS * sizeof(u16));
1812+ break;
1813+ case TREENODETYPE_LEAF_C:
1814+ node->data.leafC.predicted_class = *((*ptr)++);
1815+ retval = sizeof(node->data.leafC);
1816+ retval = ROUND_UP_TO_DWORD(retval);
1817+ break;
1818+ default:
1819+ return 0;
1820+ }
1821+ return retval + sizeof(node->type);
1822+}
1823+
1824+#define IPACK_TREE_CONVERT_REPLACE 0
1825+#define IPACK_TREE_CONVERT_KEEP 1
1826+
1827+static void *ipack_tree_to_code(ipack_model_type * model, int *code_size);
1828+
1829+static int ipack_armlib_convert_tree_to_code(ipack_model_type * model_img, int mode)
1830+{
1831+#ifdef IPACK_TREE_TO_CODE
1832+ int tree_size;
1833+
1834+ model_img->tree_code = ipack_tree_to_code(model_img, &tree_size);
1835+ jffs2_bbc_print2("Convertation done. Code size=%d\n", tree_size);
1836+ if (mode == IPACK_TREE_CONVERT_REPLACE) {
1837+ jffs2_bbc_print1("Freeing original tree.\n");
1838+ jffs2_bbc_free(model_img->tree_root_ptr);
1839+ model_img->tree_root_ptr = NULL;
1840+ }
1841+#endif
1842+ return 0;
1843+}
1844+
1845+
1846+static int ipack_armlib_compressor_init(void **model)
1847+{
1848+ int retval = EC_NO_ERROR;
1849+ unsigned char *tmp_ptr = *model;
1850+ u32 i;
1851+ ipack_model_type *model_img;
1852+ char tmp_c[2];
1853+
1854+ if (*(tmp_ptr++) != 'i') {
1855+ return EC_NOT_IPMF_FILE;
1856+ }
1857+ else if (*(tmp_ptr++) != 'P') {
1858+ return EC_NOT_IPMF_FILE;
1859+ }
1860+ else if (*(tmp_ptr++) != 'M') {
1861+ return EC_NOT_IPMF_FILE;
1862+ }
1863+ else if (*(tmp_ptr++) != 'F') {
1864+ return EC_NOT_IPMF_FILE;
1865+ }
1866+ tmp_c[0] = *(tmp_ptr++);
1867+ tmp_c[1] = *(tmp_ptr++);
1868+ tmp_ptr += 2;
1869+
1870+ //model_img = jffs2_bbc_malloc(*((u32*)tmp_ptr));
1871+ model_img = jffs2_bbc_malloc(sizeof(ipack_model_type) + ROUND_UP_TO_DWORD(NUMBER_OF_PREDICTORS));
1872+ model_img->tree_root_ptr = jffs2_bbc_malloc(*((u32 *) tmp_ptr)); //it is smaller a little but, but...
1873+
1874+ tmp_ptr += sizeof(u32);
1875+
1876+ model_img->ID[0] = 'i';
1877+ model_img->ID[1] = 'P';
1878+ model_img->ID[2] = 'M';
1879+ model_img->ID[3] = 'F';
1880+
1881+ model_img->block_sign[0] = tmp_c[0];
1882+ model_img->block_sign[1] = tmp_c[1];
1883+
1884+ model_img->nullnode.type = TREENODETYPE_LEAF_P;
1885+ for (i = 0; i < NUMBER_OF_TOKENS; ++i) {
1886+ model_img->nullnode.probabilities[i] = 0;
1887+ }
1888+ model_img->predictors_ptr = (void *) (((u32) model_img) + sizeof(ipack_model_type));
1889+ //model_img->tree_root_ptr = (void*)ROUND_UP_TO_DWORD(((u32)(model_img->predictors_ptr)) + NUMBER_OF_PREDICTORS);//ALIGN
1890+
1891+ ipack_compressor_init_tree(&tmp_ptr, model_img, model_img->tree_root_ptr, &(model_img->nullnode));
1892+
1893+#ifdef IPACK_TREE_TO_CODE
1894+#ifdef IPACK_AUTO_TREE_TO_CODE
1895+ jffs2_bbc_print1("Automatically converting tree to ARM code...\n");
1896+ ipack_armlib_convert_tree_to_code(model_img, IPACK_TREE_CONVERT_REPLACE);
1897+#else
1898+ model_img->tree_code = NULL;
1899+#endif
1900+#else
1901+ model_img->tree_code = NULL;
1902+#endif
1903+
1904+ jffs2_bbc_free(*model);
1905+ *model = model_img;
1906+ return retval;
1907+}
1908+
1909+/*******************************************************************************
1910+
1911+ COMPRESSOR DEINIT FUNCTIONS
1912+
1913+*******************************************************************************/
1914+
1915+
1916+/* Descructor of compressor (model will be freed with jffs2_bbc_free() after it)*/
1917+static void ipack_armlib_compressor_deinit(void)
1918+{
1919+}
1920+
1921+/*******************************************************************************
1922+
1923+ COMPRESS FUNCTIONS
1924+
1925+*******************************************************************************/
1926+
1927+static int writebits0(unsigned char **dest, u8 * freebits, u32 * opposite, unsigned char *end)
1928+{
1929+ if (!(*freebits)) {
1930+ ++(*dest);
1931+ *freebits = 7;
1932+ **dest = 0x00;
1933+ }
1934+ else {
1935+ --(*freebits);
1936+ (**dest) <<= 1;
1937+ }
1938+ if ((*dest == end) && !(*freebits)) {
1939+ return EC_BUFFER_OVERFLOW;
1940+ }
1941+ while (*opposite) {
1942+ --(*opposite);
1943+ if (!(*freebits)) {
1944+ ++(*dest);
1945+ *freebits = 7;
1946+ **dest = 0x01;
1947+ }
1948+ else {
1949+ --(*freebits);
1950+ (**dest) <<= 1;
1951+ (**dest) |= 0x01;
1952+ }
1953+ if ((*dest == end) && !(*freebits)) {
1954+ return EC_BUFFER_OVERFLOW;
1955+ }
1956+ }
1957+ return 0;
1958+}
1959+
1960+static int writebits1(unsigned char **dest, u8 * freebits, u32 * opposite, unsigned char *end)
1961+{
1962+ if (!(*freebits)) {
1963+ ++(*dest);
1964+ *freebits = 7;
1965+ **dest = 0x01;
1966+ }
1967+ else {
1968+ --(*freebits);
1969+ (**dest) <<= 1;
1970+ (**dest) |= 0x01;
1971+ }
1972+ if ((*dest == end) && !(*freebits)) {
1973+ return EC_BUFFER_OVERFLOW;
1974+ }
1975+ while (*opposite) {
1976+ --(*opposite);
1977+ if (!(*freebits)) {
1978+ ++(*dest);
1979+ *freebits = 7;
1980+ **dest = 0x00;
1981+ }
1982+ else {
1983+ --(*freebits);
1984+ (**dest) <<= 1;
1985+ }
1986+ if ((*dest == end) && !(*freebits)) {
1987+ return EC_BUFFER_OVERFLOW;
1988+ }
1989+ }
1990+ return 0;
1991+}
1992+
1993+
1994+
1995+
1996+/* Compress block
1997+ * *dstlen bytes are allocated.
1998+ * if it is not enough write *sourcelen over to the processed amount of data
1999+ * returns non zero if fails
2000+ */
2001+static int ipack_armlib_compress(void *model, unsigned char *input, unsigned char *output, unsigned long *sourcelen, unsigned long *dstlen)
2002+{
2003+ register u32 coder_high = CODER_VALUEMAX - 1;
2004+ register u32 coder_low = 0;
2005+ u32 coder_opbits = 0;
2006+ u8 bitvector_freebits = 8;
2007+ unsigned char *bitvector_ptr = output;
2008+ unsigned char *bitvector_end = output + (*dstlen - 1);
2009+ ARM_DataType *tmpp;
2010+ TokenStream tmpv;
2011+ TokenType *it;
2012+ void *end_it;
2013+
2014+ ipack_nodetype *treeroot = ((ipack_model_type *) model)->tree_root_ptr;
2015+ PredictorType *predctrs = ((ipack_model_type *) model)->predictors_ptr;
2016+
2017+#ifdef IPACK_TREE_TO_CODE
2018+ void (*treefunc) (ipack_nodetype *, TokenType, ipack_probability_type *);
2019+
2020+ treefunc = ((ipack_model_type *) model)->tree_code;
2021+ if (treefunc != NULL)
2022+ treefunc += 4;
2023+#endif
2024+
2025+ if ((*sourcelen % 4) != 0) {
2026+ return EC_WRONG_INPUT_LENGTH;
2027+ }
2028+ if (*dstlen <= 4) {
2029+ return EC_BUFFER_OVERFLOW;
2030+ }
2031+
2032+ if (((ipack_model_type *) model)->ID[0] != 'i') {
2033+ return EC_NOT_IPMF_MODEL;
2034+ }
2035+ else if (((ipack_model_type *) model)->ID[1] != 'P') {
2036+ return EC_NOT_IPMF_MODEL;
2037+ }
2038+ else if (((ipack_model_type *) model)->ID[2] != 'M') {
2039+ return EC_NOT_IPMF_MODEL;
2040+ }
2041+ else if (((ipack_model_type *) model)->ID[3] != 'F') {
2042+ return EC_NOT_IPMF_MODEL;
2043+ }
2044+#ifdef TXT_TOKENS
2045+ tmpv.capacity = (*sourcelen);
2046+#else
2047+ tmpv.capacity = (*sourcelen) << 1;
2048+#endif
2049+ tmpv.size = tmpv.capacity;
2050+ tmpv.ptr = jffs2_bbc_malloc(tmpv.size);
2051+ it = tmpv.ptr;
2052+
2053+#ifndef __KERNEL__
2054+ if (ipack_glb_endian_X) {
2055+ for (tmpp = (void *) input; (u32) tmpp < (u32) (input + *sourcelen); ++tmpp) {
2056+#ifdef TXT_TOKENS
2057+ *(it++) = (u8) ((*tmpp & 0xff000000) >> 24);
2058+ *(it++) = (u8) ((*tmpp & 0x00ff0000) >> 16);
2059+ *(it++) = (u8) ((*tmpp & 0x0000ff00) >> 8);
2060+ *(it++) = (u8) ((*tmpp & 0x000000ff));
2061+#else
2062+ *(it++) = (u8) ((*tmpp & 0x0000f000) >> 12);
2063+ *(it++) = (u8) ((*tmpp & 0x0000000f));
2064+ *(it++) = (u8) ((*tmpp & 0xf0000000) >> 28);
2065+ *(it++) = (u8) ((*tmpp & 0x000f0000) >> 16);
2066+ *(it++) = (u8) ((*tmpp & 0x00000f00) >> 8);
2067+ *(it++) = (u8) ((*tmpp & 0x00f00000) >> 20);
2068+ *(it++) = (u8) ((*tmpp & 0x0f000000) >> 24);
2069+ *(it++) = (u8) ((*tmpp & 0x000000f0) >> 4);
2070+#endif //TXT_TOKENS
2071+ }
2072+ }
2073+ else {
2074+#endif
2075+ for (tmpp = (void *) input; (u32) tmpp < (u32) (input + *sourcelen); ++tmpp) {
2076+#ifdef TXT_TOKENS
2077+ *(it++) = (u8) ((*tmpp & 0x000000ff));
2078+ *(it++) = (u8) ((*tmpp & 0x0000ff00) >> 8);
2079+ *(it++) = (u8) ((*tmpp & 0x00ff0000) >> 16);
2080+ *(it++) = (u8) ((*tmpp & 0xff000000) >> 24);
2081+#else
2082+ *(it++) = (u8) ((*tmpp & 0x00f00000) >> 20);
2083+ *(it++) = (u8) ((*tmpp & 0x0f000000) >> 24);
2084+ *(it++) = (u8) ((*tmpp & 0x000000f0) >> 4);
2085+ *(it++) = (u8) ((*tmpp & 0x00000f00) >> 8);
2086+ *(it++) = (u8) ((*tmpp & 0x000f0000) >> 16);
2087+ *(it++) = (u8) ((*tmpp & 0x0000f000) >> 12);
2088+ *(it++) = (u8) ((*tmpp & 0x0000000f));
2089+ *(it++) = (u8) ((*tmpp & 0xf0000000) >> 28);
2090+#endif //TXT_TOKENS
2091+ }
2092+#ifndef __KERNEL__
2093+ }
2094+#endif
2095+/*
2096+ ENCODE
2097+*/
2098+ { //predictor reset
2099+ register PredictorType *ptr = predctrs;
2100+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS;
2101+ while (ptr < end) {
2102+ *(ptr++) = 0;
2103+ }
2104+ }
2105+
2106+ //*(bitvector_ptr++) = 'H';
2107+ //*(bitvector_ptr++) = 'G';
2108+ *(bitvector_ptr++) = ((ipack_model_type *) model)->block_sign[0];
2109+ *(bitvector_ptr++) = ((ipack_model_type *) model)->block_sign[1];
2110+
2111+ *(bitvector_ptr++) = (unsigned char) (((*sourcelen) >> 8) & 0xff);
2112+ *(bitvector_ptr++) = (unsigned char) ((*sourcelen) & 0xff);
2113+ for (it = tmpv.ptr, end_it = VECTOR_S_END(tmpv); it != end_it; ++it) {
2114+ ipack_probability_type prob;
2115+ u32 range;
2116+
2117+#ifdef IPACK_TREE_TO_CODE
2118+ if (treefunc != NULL)
2119+ (*treefunc) (treeroot, *it, &prob);
2120+ else
2121+ ipack_model_get_probability_for_token(treeroot, *it, &prob);
2122+#else
2123+ ipack_model_get_probability_for_token(treeroot, *it, &prob);
2124+#endif
2125+
2126+ if (prob.high == prob.low) {
2127+ vector_clear(&tmpv);
2128+ return EC_CODER_WRONG_PROBABILITY;
2129+ }
2130+ range = coder_high - coder_low + 1;
2131+ coder_high = coder_low + ((range * prob.high) >> PROBABILITY_SHIFT) - 1;
2132+ coder_low += ((range * prob.low) >> PROBABILITY_SHIFT);
2133+ for (;;) {
2134+ if (coder_high < CODER_VALUEHLF) {
2135+ if (writebits0(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
2136+ vector_clear(&tmpv);
2137+ return EC_BUFFER_OVERFLOW;
2138+ }
2139+ }
2140+ else if (coder_low >= CODER_VALUEHLF) {
2141+ if (writebits1(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
2142+ vector_clear(&tmpv);
2143+ return EC_BUFFER_OVERFLOW;
2144+ }
2145+ coder_high -= CODER_VALUEHLF;
2146+ coder_low -= CODER_VALUEHLF;
2147+ }
2148+ else if ((CODER_VALUE1ST <= coder_low) && (coder_high < CODER_VALUE3RD)) {
2149+ ++coder_opbits;
2150+ coder_high -= CODER_VALUE1ST;
2151+ coder_low -= CODER_VALUE1ST;
2152+ }
2153+ else {
2154+ break;
2155+ }
2156+ coder_high <<= 1;
2157+ ++coder_high;
2158+ coder_low <<= 1;
2159+ if (coder_high < coder_low) {
2160+ vector_clear(&tmpv);
2161+ return EC_CODER_WRONG_RANGE;
2162+ }
2163+ }
2164+ {
2165+#ifdef TXT_TOKENS
2166+// register u32 ndx;
2167+ predctrs[0] = *it;
2168+ if ((('a' <= *it) && (*it <= 'z')) || (('A' <= *it) && (*it <= 'Z'))) {
2169+ ++(predctrs[1]);
2170+ }
2171+ else {
2172+ predctrs[1] = 0;
2173+ }
2174+#else
2175+ register u32 ndx = predctrs[0] + 1;
2176+ predctrs[ndx + 8] = predctrs[ndx];
2177+ predctrs[ndx] = *it;
2178+ if (ndx == 8) {
2179+ predctrs[0] = 0;
2180+ }
2181+ else {
2182+ ++predctrs[0];
2183+ }
2184+#endif
2185+ }
2186+
2187+ }
2188+ vector_clear(&tmpv);
2189+ ++coder_opbits;
2190+ if (coder_low < CODER_VALUE1ST) {
2191+ if (writebits0(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
2192+ return EC_BUFFER_OVERFLOW;
2193+ }
2194+ }
2195+ else {
2196+ if (writebits1(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
2197+ return EC_BUFFER_OVERFLOW;
2198+ }
2199+ }
2200+ (*(bitvector_ptr)) <<= bitvector_freebits;
2201+ *dstlen = ((u32) bitvector_ptr - (u32) output + 1);
2202+ return EC_NO_ERROR;
2203+}
2204+
2205+/*******************************************************************************
2206+
2207+ DECOMPRESS FUNCTIONS
2208+
2209+*******************************************************************************/
2210+
2211+typedef struct
2212+{
2213+ u32 high;
2214+ u32 low;
2215+ u32 value;
2216+ u32 overread;
2217+} ipack_decompressor_values;
2218+
2219+typedef struct
2220+{
2221+ u8 freebits;
2222+ unsigned char *ptr;
2223+ unsigned char *end;
2224+} ipack_decompressor_bitvector;
2225+
2226+static u8 ipack_bitvector_R_get1(ipack_decompressor_bitvector * bv)
2227+{
2228+ u8 tmp;
2229+ if (bv->ptr == bv->end) {
2230+ bv->freebits = 0;
2231+ return 0;
2232+ }
2233+ tmp = (*(bv->ptr) >> bv->freebits) & 0x01;
2234+ if (!(bv->freebits)) {
2235+ bv->freebits = 7;
2236+ ++(bv->ptr);
2237+ }
2238+ else {
2239+ --(bv->freebits);
2240+ }
2241+ return tmp;
2242+}
2243+
2244+/* Decompress block
2245+ * returns non zero if fails
2246+ */
2247+static int ipack_armlib_decompress(void *model, unsigned char *input, unsigned char *output, unsigned long sourcelen, unsigned long dstlen)
2248+{
2249+ ARM_DataType *data;
2250+ register u32 coder_high = CODER_VALUEMAX - 1;
2251+ register u32 coder_low = 0;
2252+ register u32 coder_value = 0;
2253+ u32 coder_overread = 0;
2254+ ipack_decompressor_bitvector bitvector;
2255+ u32 lngth;
2256+ u32 i;
2257+ u32 cntbytes;
2258+ TokenType tkns[8];
2259+ TokenType *tptr;
2260+
2261+ ipack_nodetype *treeroot = ((ipack_model_type *) model)->tree_root_ptr;
2262+ PredictorType *predctrs = ((ipack_model_type *) model)->predictors_ptr;
2263+
2264+#ifdef IPACK_TREE_TO_CODE
2265+ TokenType(*treefunc) (ipack_nodetype *, u32, u32, ipack_probability_type *);
2266+
2267+ treefunc = ((ipack_model_type *) model)->tree_code;
2268+#endif
2269+
2270+
2271+ if (((ipack_model_type *) model)->ID[0] != 'i') {
2272+ return EC_NOT_IPMF_MODEL;
2273+ }
2274+ else if (((ipack_model_type *) model)->ID[1] != 'P') {
2275+ return EC_NOT_IPMF_MODEL;
2276+ }
2277+ else if (((ipack_model_type *) model)->ID[2] != 'M') {
2278+ return EC_NOT_IPMF_MODEL;
2279+ }
2280+ else if (((ipack_model_type *) model)->ID[3] != 'F') {
2281+ return EC_NOT_IPMF_MODEL;
2282+ }
2283+
2284+ bitvector.freebits = 7;
2285+ bitvector.ptr = input;
2286+ bitvector.end = input + sourcelen;
2287+
2288+ /*if(*(bitvector.ptr++) != 'H') {
2289+ return EC_NOT_HG_BLOCK;
2290+ } else if(*(bitvector.ptr++) != 'G') {
2291+ return EC_NOT_HG_BLOCK;
2292+ } */
2293+ bitvector.ptr++;
2294+ bitvector.ptr++;
2295+
2296+ data = (void *) output;
2297+ cntbytes = *(bitvector.ptr++);
2298+ cntbytes <<= 8;
2299+ cntbytes += *(bitvector.ptr++);
2300+
2301+ { //predictor reset
2302+ register PredictorType *ptr = predctrs;
2303+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS;
2304+ while (ptr < end) {
2305+ *(ptr++) = 0;
2306+ }
2307+ }
2308+ for (i = 0; i < CODER_VALUEBITS; ++i) {
2309+ coder_value <<= 1;
2310+ coder_value += ipack_bitvector_R_get1(&bitvector);
2311+ }
2312+ lngth = dstlen >> 2;
2313+ if (lngth > (cntbytes >> 2)) {
2314+ lngth = cntbytes >> 2;
2315+ }
2316+ for (i = 0; (i < lngth); ++i) {
2317+ TokenType itoken;
2318+ u32 j;
2319+ tptr = tkns;
2320+ for (j = 0; j < NUMBER_OF_TOKENS_PER_INSTRUCTION; ++j) {
2321+ ipack_probability_type prob;
2322+ u32 range = coder_high - coder_low + 1;
2323+
2324+#ifdef IPACK_TREE_TO_CODE
2325+ if (treefunc != NULL)
2326+ itoken = (*treefunc) (treeroot, coder_value - coder_low + 1, range, &prob);
2327+ else
2328+#endif
2329+ itoken = ipack_model_get_token_for_range(treeroot, coder_value - coder_low + 1, range, &prob);
2330+
2331+
2332+ if (prob.high == prob.low) {
2333+ return EC_CODER_WRONG_PROBABILITY;
2334+ }
2335+ coder_high = coder_low + ((range * prob.high) >> PROBABILITY_SHIFT) - 1;
2336+ coder_low += ((range * prob.low) >> PROBABILITY_SHIFT);
2337+ for (;;) {
2338+ if (coder_high < CODER_VALUEHLF) {
2339+ }
2340+ else if (CODER_VALUEHLF <= coder_low) {
2341+ coder_value -= CODER_VALUEHLF;
2342+ coder_high -= CODER_VALUEHLF;
2343+ coder_low -= CODER_VALUEHLF;
2344+ }
2345+ else if ((CODER_VALUE1ST <= coder_low) && (coder_high < CODER_VALUE3RD)) {
2346+ coder_value -= CODER_VALUE1ST;
2347+ coder_high -= CODER_VALUE1ST;
2348+ coder_low -= CODER_VALUE1ST;
2349+ }
2350+ else {
2351+ break;
2352+ }
2353+ coder_low <<= 1;
2354+ coder_high <<= 1;
2355+ ++(coder_high);
2356+ coder_value <<= 1;
2357+ if (bitvector.ptr == bitvector.end) {
2358+ bitvector.freebits = 0;
2359+ }
2360+ coder_value += ((*(bitvector.ptr) >> bitvector.freebits) & 0x01);
2361+ if (bitvector.freebits) {
2362+ --bitvector.freebits;
2363+ }
2364+ else {
2365+ bitvector.freebits = 7;
2366+ ++bitvector.ptr;
2367+ }
2368+ if (coder_high < coder_low) {
2369+ return EC_CODER_WRONG_RANGE;
2370+ }
2371+ if ((bitvector.ptr == bitvector.end) && !(bitvector.freebits)) {
2372+ if ((coder_overread++) > CODER_VALUEBITS) {
2373+ return EC_BUFFER_UNDERFLOW;
2374+ }
2375+ }
2376+ }
2377+ {
2378+#ifdef TXT_TOKENS
2379+// register u32 ndx;
2380+ predctrs[0] = itoken;
2381+ if ((('a' <= itoken) && (itoken <= 'z')) || (('A' <= itoken) && (itoken <= 'Z'))) {
2382+ ++(predctrs[1]);
2383+ }
2384+ else {
2385+ predctrs[1] = 0;
2386+ }
2387+
2388+#else
2389+ register u32 ndx = predctrs[0] + 1;
2390+ predctrs[ndx + 8] = predctrs[ndx];
2391+ predctrs[ndx] = itoken;
2392+ if (ndx == 8) {
2393+ predctrs[0] = 0;
2394+ }
2395+ else {
2396+ ++predctrs[0];
2397+ }
2398+#endif
2399+ }
2400+
2401+ (*(tptr++)) = itoken;
2402+ }
2403+ tptr = tkns;
2404+#ifndef __KERNEL__
2405+ if (ipack_glb_endian_X) {
2406+#ifdef TXT_TOKENS
2407+ (*data) = ((*tptr) << 24);
2408+ ++tptr;
2409+ (*data) |= ((*tptr) << 16);
2410+ ++tptr;
2411+ (*data) |= ((*tptr) << 8);
2412+ ++tptr;
2413+ (*data) |= (*tptr);
2414+ ++data;
2415+#else
2416+ (*data) = (((*tptr) & 0xf) << 12);
2417+ ++tptr;
2418+ (*data) |= ((*tptr) & 0xf);
2419+ ++tptr;
2420+ (*data) |= (((*tptr) & 0xf) << 28);
2421+ ++tptr;
2422+ (*data) |= (((*tptr) & 0xf) << 16);
2423+ ++tptr;
2424+ (*data) |= (((*tptr) & 0xf) << 8);
2425+ ++tptr;
2426+ (*data) |= (((*tptr) & 0xf) << 20);
2427+ ++tptr;
2428+ (*data) |= (((*tptr) & 0xf) << 24);
2429+ ++tptr;
2430+ (*data) |= (((*tptr) & 0xf) << 4);
2431+ ++data;
2432+#endif
2433+ }
2434+ else {
2435+#endif
2436+#ifdef TXT_TOKENS
2437+ (*data) = (*tptr);
2438+ ++tptr;
2439+ (*data) |= ((*tptr) << 8);
2440+ ++tptr;
2441+ (*data) |= ((*tptr) << 16);
2442+ ++tptr;
2443+ (*data) |= ((*tptr) << 24);
2444+ ++data;
2445+#else
2446+ (*data) = (((*tptr) & 0xf) << 20);
2447+ ++tptr;
2448+ (*data) |= (((*tptr) & 0xf) << 24);
2449+ ++tptr;
2450+ (*data) |= (((*tptr) & 0xf) << 4);
2451+ ++tptr;
2452+ (*data) |= (((*tptr) & 0xf) << 8);
2453+ ++tptr;
2454+ (*data) |= (((*tptr) & 0xf) << 16);
2455+ ++tptr;
2456+ (*data) |= (((*tptr) & 0xf) << 12);
2457+ ++tptr;
2458+ (*data) |= ((*tptr) & 0xf);
2459+ ++tptr;
2460+ (*data) |= (((*tptr) & 0xf) << 28);
2461+ ++data;
2462+#endif
2463+#ifndef __KERNEL__
2464+ }
2465+#endif
2466+ }
2467+ return EC_NO_ERROR;
2468+}
2469+
2470+static int ipack_armlib_estimate(void *model, unsigned char *input, unsigned long sourcelen, unsigned long *dstlen, unsigned long *readtime, unsigned long *writetime)
2471+{
2472+ int i, tmp, tmp2, max, maxi;
2473+ int cnt_cond[] = { 0, 0, 0, 0 };
2474+ int cnt_inst[] = { 0, 0, 0, 0 };
2475+
2476+ // TODO: make a more precise estimation!!!
2477+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 6;
2478+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 2;
2479+
2480+ if (sourcelen % 4 != 0) {
2481+ *dstlen = sourcelen;
2482+ return 0;
2483+ }
2484+ for (i = 0; i < sourcelen; i++, input++) {
2485+ tmp2 = tmp = *input;
2486+ tmp = ((tmp) & 0xf0) >> 4;
2487+ tmp2 = tmp2 & 0xf;
2488+ if (tmp == 14)
2489+ cnt_cond[i % 4]++;
2490+ if ((tmp2 == 2) || (tmp2 == 3))
2491+ cnt_inst[i % 4]++;
2492+ }
2493+ maxi = -1;
2494+ max = -1;
2495+ for (i = 0; i < 4; i++)
2496+ if (max < cnt_cond[i]) {
2497+ max = cnt_cond[i];
2498+ maxi = i;
2499+ }
2500+ /*jffs2_bbc_print("armlib_EST: %d/%d : %d/%d %d/%d %d/%d %d/%d",
2501+ cnt_cond[maxi],cnt_inst[maxi],
2502+ cnt_cond[0],cnt_inst[0],
2503+ cnt_cond[1],cnt_inst[1],
2504+ cnt_cond[2],cnt_inst[2],
2505+ cnt_cond[3],cnt_inst[3]); */
2506+
2507+ if (cnt_cond[maxi] < (sourcelen >> 4)) {
2508+ *dstlen = sourcelen;
2509+ }
2510+ else {
2511+ *dstlen = sourcelen / 3;
2512+ }
2513+
2514+ return 0;
2515+}
2516+
2517+static char *ipack_armlib_proc_info(void);
2518+static int ipack_armlib_proc_command(char *command);
2519+static void ipack_armlib_destroy_model(void **model);
2520+
2521+struct jffs2_bbc_compressor_type jffs2_bbc_armlib = {
2522+ "armlib",
2523+ 0x464d5069,
2524+ {0, 0, 0, 0},
2525+ NULL, // init
2526+ ipack_armlib_compressor_init, // init_model
2527+ ipack_armlib_destroy_model, // destroy_model
2528+ ipack_armlib_compressor_deinit, // deinit
2529+ ipack_armlib_compress,
2530+ ipack_armlib_estimate,
2531+ ipack_armlib_decompress,
2532+ ipack_armlib_proc_info,
2533+ ipack_armlib_proc_command
2534+};
2535+
2536+
2537+static char *ipack_armlib_proc_info()
2538+{
2539+#ifdef IPACK_TREE_TO_CODE
2540+#ifdef IPACK_AUTO_TREE_TO_CODE
2541+ return "automatic tree to code conversion";
2542+#else
2543+ return "manual tree to code conversion possibility";
2544+#endif
2545+#else
2546+ return "tree in memory version";
2547+#endif
2548+}
2549+
2550+static int ipack_armlib_proc_command(char *command)
2551+{
2552+ struct jffs2_bbc_model_list_node *model;
2553+ ipack_model_type *armlib_model;
2554+
2555+ if ((*command == 'g') || (*command == 'G')) {
2556+ jffs2_bbc_print1("Converting tree(s) to ARM code... (keeping original)\n");
2557+ model = jffs2_bbc_armlib.models;
2558+ if (model == NULL)
2559+ jffs2_bbc_print1("no model found!\n");
2560+ while (model != NULL) {
2561+ armlib_model = model->model;
2562+ if (armlib_model == NULL) {
2563+ jffs2_bbc_print1("Error: NULL model!\n");
2564+ }
2565+ else {
2566+ ipack_armlib_convert_tree_to_code(armlib_model, IPACK_TREE_CONVERT_KEEP);
2567+ }
2568+ model = model->next_compr_model;
2569+ }
2570+ }
2571+ else if ((*command == 'r') || (*command == 'R')) {
2572+ jffs2_bbc_print1("Converting tree(s) to ARM code... (deleting original)\n");
2573+ model = jffs2_bbc_armlib.models;
2574+ if (model == NULL)
2575+ jffs2_bbc_print1("no model found!\n");
2576+ while (model != NULL) {
2577+ armlib_model = model->model;
2578+ if (armlib_model == NULL) {
2579+ jffs2_bbc_print1("Error: NULL model!\n");
2580+ }
2581+ else {
2582+ //armlib_model->tree_code = ipack_tree_to_code(armlib_model, &tree_size);
2583+ //jffs2_bbc_print("Convertation done. Code size=%d\n",tree_size);
2584+ ipack_armlib_convert_tree_to_code(armlib_model, IPACK_TREE_CONVERT_REPLACE);
2585+ }
2586+ model = model->next_compr_model;
2587+ }
2588+ }
2589+ else if ((*command == 'c') || (*command == 'C')) {
2590+ jffs2_bbc_print1("Deleting ARM representation of the tree(s)...\n");
2591+ model = jffs2_bbc_armlib.models;
2592+ if (model == NULL)
2593+ jffs2_bbc_print1("no model found!\n");
2594+ while (model != NULL) {
2595+ armlib_model = model->model;
2596+ if (armlib_model == NULL) {
2597+ jffs2_bbc_print1("Error: NULL model!\n");
2598+ }
2599+ else {
2600+ if (armlib_model->tree_code == NULL) {
2601+ jffs2_bbc_print1("already deleted.\n");
2602+ }
2603+ else {
2604+ if (armlib_model->tree_root_ptr == NULL) {
2605+ jffs2_bbc_print1("cannot delete this ARM tree - original tree has deleted\n");
2606+ }
2607+ else {
2608+ jffs2_bbc_print1("deleting...");
2609+ jffs2_bbc_free(armlib_model->tree_code);
2610+ armlib_model->tree_code = NULL;
2611+ jffs2_bbc_print1("done.\n");
2612+ }
2613+ }
2614+ }
2615+ model = model->next_compr_model;
2616+ }
2617+ }
2618+ else if (*command == '?') {
2619+ jffs2_bbc_print1("ARMLIB commands:\n");
2620+ jffs2_bbc_print1(" g: convert TREEs to ARM code and keep the original\n");
2621+ jffs2_bbc_print1(" r: convert TREEs to ARM code and remove the original\n");
2622+ jffs2_bbc_print1(" c: delete the original TREEs - if there is any\n");
2623+ }
2624+ else {
2625+ jffs2_bbc_print1("Unknown command.\n");
2626+ }
2627+ return 0;
2628+}
2629+
2630+static void ipack_armlib_destroy_model(void **model)
2631+{
2632+ ipack_model_type *model_img;
2633+
2634+ model_img = *model;
2635+ if (model_img == NULL) {
2636+ jffs2_bbc_print1("jffs2.bbc: armlib: NULL model at destoying model!\n");
2637+ return;
2638+ }
2639+ if (model_img->tree_code != NULL) {
2640+ //jffs2_bbc_print1("jffs2.bbc: armlib: debug: freeing code...\n");
2641+ jffs2_bbc_free(model_img->tree_code);
2642+ model_img->tree_code = NULL;
2643+ }
2644+ if (model_img->tree_root_ptr != NULL) {
2645+ //jffs2_bbc_print1("jffs2.bbc: armlib: debug: freeing tree...\n");
2646+ jffs2_bbc_free(model_img->tree_root_ptr);
2647+ model_img->tree_root_ptr = NULL;
2648+ }
2649+
2650+ jffs2_bbc_free(model_img);
2651+ *model = NULL;
2652+}
2653+
2654+struct jffs2_bbc_compressor_type *jffs2_bbc_armlib_init(int mode)
2655+{
2656+ if (jffs2_bbc_register_compressor(&jffs2_bbc_armlib) == 0)
2657+ return &jffs2_bbc_armlib;
2658+ else
2659+ return NULL;
2660+}
2661+
2662+void jffs2_bbc_armlib_deinit(void)
2663+{
2664+ jffs2_bbc_unregister_compressor(&jffs2_bbc_armlib);
2665+}
2666+
2667+/*END OF ARMLIB*/
2668--- /dev/null
2669+++ b/fs/jffs2/jffs2_bbc_framework.c
2670@@ -0,0 +1,1324 @@
2671+/*
2672+ * JFFS2-BBC: Compression Framework
2673+ *
2674+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
2675+ *
2676+ * Copyright (C) 2004, Ferenc Havasi
2677+ *
2678+ * This program is free software; you can redistribute it and/or
2679+ * modify it under the terms of the GNU General Public License
2680+ * as published by the Free Software Foundation; either version 2
2681+ * of the License, or (at your option) any later version.
2682+ *
2683+ * This program is distributed in the hope that it will be useful,
2684+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
2685+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2686+ * GNU General Public License for more details.
2687+ *
2688+ * You should have received a copy of the GNU General Public License
2689+ * along with this program; if not, write to the Free Software
2690+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
2691+ *
2692+ */
2693+
2694+/* USE JFFS2_BBC_STANDALONE define if you don't want to compile without JFFS2 */
2695+
2696+//#define DEBUG_COMPRESSORS
2697+//#define DEBUG_SHOW_BLOCK_SIZES
2698+
2699+#define JFFS2_BBC_STAT_BUFF_SIZE 8000
2700+
2701+#ifndef __KERNEL__
2702+
2703+#include <stdio.h>
2704+#include <malloc.h>
2705+typedef unsigned long uint32_t;
2706+
2707+#else
2708+
2709+#include <linux/kernel.h>
2710+#include <linux/slab.h>
2711+#include <linux/vmalloc.h>
2712+
2713+#endif
2714+
2715+#define JFFS2_BBC_ZLIB_BLOCK_SIGN_0 (120)
2716+#define JFFS2_BBC_ZLIB_BLOCK_SIGN_1 (94)
2717+
2718+#define JFFS2_BBC_DUMMY_BLOCKSIGN_0 (0x54)
2719+#define JFFS2_BBC_DUMMY_BLOCKSIGN_1 (0x01)
2720+
2721+#ifndef NULL
2722+#define NULL ((void*)(0))
2723+#endif
2724+
2725+#include "jffs2_bbc_framework.h"
2726+
2727+/*********************************************************************
2728+ * Global data *
2729+ *********************************************************************/
2730+
2731+static int jffs2_bbc_compression_mode = JFFS2_BBC_ZLIB_MODE;
2732+static struct jffs2_bbc_compressor_type *jffs2_bbc_manual_compressor = NULL;
2733+static struct jffs2_bbc_compressor_type *jffs2_bbc_compressors = NULL;
2734+static struct jffs2_bbc_model_list_node *jffs2_bbc_model_list = NULL;
2735+static void *last_sb = NULL; /* previously activated sb */
2736+
2737+/*********************************************************************
2738+ * Compressor initialization *
2739+ *********************************************************************/
2740+
2741+#ifndef JFFS2_BBC_STANDALONE
2742+
2743+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_ARMLIB)
2744+struct jffs2_bbc_compressor_type *jffs2_bbc_armlib_init(void);
2745+void jffs2_bbc_armlib_deinit(void);
2746+#endif
2747+
2748+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZO)
2749+struct jffs2_bbc_compressor_type *jffs2_bbc_lzo_init(void);
2750+void jffs2_bbc_lzo_deinit(void);
2751+#endif
2752+
2753+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZSS)
2754+struct jffs2_bbc_compressor_type *jffs2_bbc_lzss_init(void);
2755+void jffs2_bbc_lzss_deinit(void);
2756+#endif
2757+
2758+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZARI)
2759+struct jffs2_bbc_compressor_type *jffs2_bbc_lzari_init(void);
2760+void jffs2_bbc_lzari_deinit(void);
2761+#endif
2762+
2763+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZHD)
2764+struct jffs2_bbc_compressor_type *jffs2_bbc_lzhd_init(void);
2765+void jffs2_bbc_lzhd_deinit(void);
2766+#endif
2767+
2768+void jffs2_bbc_compressor_init()
2769+{
2770+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_ARMLIB)
2771+ jffs2_bbc_armlib_init();
2772+#endif
2773+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZO)
2774+ jffs2_bbc_lzo_init();
2775+#endif
2776+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZSS)
2777+ jffs2_bbc_lzss_init();
2778+#endif
2779+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZARI)
2780+ jffs2_bbc_lzari_init();
2781+#endif
2782+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZHD)
2783+ jffs2_bbc_lzhd_init();
2784+#endif
2785+}
2786+
2787+void jffs2_bbc_compressor_deinit()
2788+{
2789+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZHD)
2790+ jffs2_bbc_lzhd_deinit();
2791+#endif
2792+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZARI)
2793+ jffs2_bbc_lzari_deinit();
2794+#endif
2795+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZSS)
2796+ jffs2_bbc_lzss_deinit();
2797+#endif
2798+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZO)
2799+ jffs2_bbc_lzo_deinit();
2800+#endif
2801+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_ARMLIB)
2802+ jffs2_bbc_armlib_deinit();
2803+#endif
2804+}
2805+
2806+#endif
2807+
2808+#ifndef JFFS2_BBC_STANDALONE
2809+
2810+/*********************************************************************
2811+ * ZLIB COMPRESSOR *
2812+ *********************************************************************/
2813+
2814+extern int jffs2_zlib_compress2(unsigned char *data_in, unsigned char *cpage_out, uint32_t * sourcelen, uint32_t * dstlen);
2815+extern void jffs2_zlib_decompress2(unsigned char *data_in, unsigned char *cpage_out, uint32_t srclen, uint32_t destlen);
2816+
2817+static int jffs2_bbc_zlib_compress(void *model, unsigned char *input, unsigned char *output, unsigned long *sourcelen, unsigned long *dstlen)
2818+{
2819+ return jffs2_zlib_compress2(input, output, sourcelen, dstlen);
2820+}
2821+
2822+static int jffs2_bbc_zlib_decompress(void *model, unsigned char *input, unsigned char *output, unsigned long sourcelen, unsigned long dstlen)
2823+{
2824+ jffs2_zlib_decompress2(input, output, sourcelen, dstlen);
2825+ return 0;
2826+}
2827+
2828+static int jffs2_bbc_zlib_estimate(void *model, unsigned char *input, unsigned long sourcelen, unsigned long *dstlen, unsigned long *readtime, unsigned long *writetime)
2829+{
2830+ *dstlen = sourcelen * 65 / 100;
2831+ *readtime = JFFS2_BBC_ZLIB_READ_TIME;
2832+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME;
2833+ return 0;
2834+}
2835+
2836+static struct jffs2_bbc_compressor_type jffs2_bbc_zlib = {
2837+ "zlib",
2838+ 0,
2839+ {JFFS2_BBC_ZLIB_BLOCK_SIGN_0, JFFS2_BBC_ZLIB_BLOCK_SIGN_1, 0, 0},
2840+ NULL,
2841+ NULL,
2842+ NULL,
2843+ NULL,
2844+ jffs2_bbc_zlib_compress,
2845+ jffs2_bbc_zlib_estimate,
2846+ jffs2_bbc_zlib_decompress,
2847+ NULL,
2848+ NULL,
2849+ 1
2850+};
2851+
2852+static struct jffs2_bbc_compressor_type *jffs2_bbc_original_compressor = &jffs2_bbc_zlib;
2853+
2854+#endif
2855+
2856+/*********************************************************************
2857+ * Compression mode handling *
2858+ *********************************************************************/
2859+
2860+int jffs2_bbc_get_compression_mode(void)
2861+{
2862+ return jffs2_bbc_compression_mode;
2863+}
2864+
2865+void jffs2_bbc_set_compression_mode(int mode)
2866+{
2867+ jffs2_bbc_compression_mode = mode;
2868+}
2869+
2870+void jffs2_bbc_set_manual_compressor(struct jffs2_bbc_compressor_type *c)
2871+{
2872+ jffs2_bbc_manual_compressor = c;
2873+ jffs2_bbc_set_compression_mode(JFFS2_BBC_MANUAL_MODE);
2874+}
2875+
2876+int jffs2_bbc_set_manual_compressor_by_name(char *name)
2877+{
2878+ struct jffs2_bbc_compressor_type *l;
2879+ int i;
2880+
2881+ l = jffs2_bbc_compressors;
2882+ while (l != NULL) {
2883+ for (i = 0; i < 1000; i++) {
2884+ if (l->name[i] == 0) {
2885+ jffs2_bbc_set_manual_compressor(l);
2886+ return 0;
2887+ }
2888+ else if (name[i] == 0)
2889+ i = 1000;
2890+ else if (name[i] != l->name[i])
2891+ i = 1000;
2892+ }
2893+ l = l->next;
2894+ }
2895+ jffs2_bbc_set_manual_compressor(NULL);
2896+ return 1;
2897+}
2898+
2899+static struct jffs2_bbc_compressor_type *jffs2_bbc_get_compressor_by_name(char *name)
2900+{
2901+ struct jffs2_bbc_compressor_type *l;
2902+ int i;
2903+
2904+#ifndef JFFS2_BBC_STANDALONE
2905+ l = jffs2_bbc_original_compressor;
2906+ for (i = 0; i < 1000; i++) {
2907+ if (l->name[i] == 0) {
2908+ return l;
2909+ }
2910+ else if (name[i] == 0)
2911+ i = 1000;
2912+ else if (name[i] != l->name[i])
2913+ i = 1000;
2914+ }
2915+#endif
2916+
2917+ l = jffs2_bbc_compressors;
2918+ while (l != NULL) {
2919+ for (i = 0; i < 1000; i++) {
2920+ if (l->name[i] == 0) {
2921+ return l;
2922+ }
2923+ else if (name[i] == 0)
2924+ i = 1000;
2925+ else if (name[i] != l->name[i])
2926+ i = 1000;
2927+ }
2928+ l = l->next;
2929+ }
2930+
2931+ return NULL;
2932+}
2933+
2934+int jffs2_bbc_disable_compressor_by_name(char *name)
2935+{
2936+ struct jffs2_bbc_compressor_type *l;
2937+
2938+ l = jffs2_bbc_get_compressor_by_name(name);
2939+ if (l == NULL) return 1;
2940+ l->enabled = 0;
2941+ return 0;
2942+}
2943+
2944+int jffs2_bbc_enable_compressor_by_name(char *name)
2945+{
2946+ struct jffs2_bbc_compressor_type *l;
2947+
2948+ l = jffs2_bbc_get_compressor_by_name(name);
2949+ if (l == NULL) return 1;
2950+ l->enabled = 1;
2951+ return 0;
2952+}
2953+
2954+void jffs2_bbc_compressor_command_by_name(char *name_and_command)
2955+{
2956+ struct jffs2_bbc_compressor_type *l;
2957+ int i;
2958+
2959+ l = jffs2_bbc_compressors;
2960+ while (l != NULL) {
2961+ for (i = 0; i < 1000; i++) {
2962+ if (l->name[i] == 0) {
2963+ if (name_and_command[i] != ':') {
2964+ jffs2_bbc_print1("jffs2.bbc: ':' missing after compressor name\n");
2965+ }
2966+ else {
2967+ if (l->proc_command != NULL)
2968+ l->proc_command(name_and_command + i + 1);
2969+ }
2970+ i = 1000;
2971+ return;
2972+ }
2973+ else if (name_and_command[i] == 0) {
2974+ i = 1000;
2975+ }
2976+ else if (name_and_command[i] != l->name[i]) {
2977+ i = 1000;
2978+ }
2979+ }
2980+ l = l->next;
2981+ }
2982+}
2983+
2984+struct jffs2_bbc_compressor_type *jffs2_bbc_get_manual_compressor(void)
2985+{
2986+ if (jffs2_bbc_get_compression_mode() != JFFS2_BBC_MANUAL_MODE) {
2987+ jffs2_bbc_manual_compressor = NULL;
2988+ }
2989+ return jffs2_bbc_manual_compressor;
2990+}
2991+
2992+/*********************************************************************
2993+ * Compressor handling *
2994+ *********************************************************************/
2995+
2996+struct jffs2_bbc_compressor_type *jffs2_bbc_get_compressor_list(void)
2997+{
2998+ return jffs2_bbc_compressors;
2999+}
3000+
3001+struct jffs2_bbc_model_list_node *jffs2_bbc_get_model_list(void)
3002+{
3003+ return jffs2_bbc_model_list;
3004+}
3005+
3006+int jffs2_bbc_register_compressor(struct jffs2_bbc_compressor_type *c)
3007+{
3008+ struct jffs2_bbc_compressor_type *l;
3009+ struct jffs2_bbc_model_list_node *l2;
3010+ int model_found = 0;
3011+
3012+ l = jffs2_bbc_compressors;
3013+ /* Check for confilcts */
3014+ while (l != NULL) {
3015+ c->name[15] = 0;
3016+ /*if (strcmp(c->name,l->name)==0) {
3017+ jffs2_bbc_print1("jffs2.bbc: compressor is already loaded.");
3018+ return -1;
3019+ } */
3020+ if ((l->model_file_sign == c->model_file_sign) && (c->model_file_sign != 0)) {
3021+ jffs2_bbc_print1("jffs2.bbc: already used model file sign. fail.");
3022+ return -1;
3023+ }
3024+ l = l->next;
3025+ }
3026+ /* Search and initialize model */
3027+ c->models = NULL;
3028+ c->mounted = 0;
3029+ if (c->init != NULL) {
3030+ if (c->init() != 0) {
3031+ jffs2_bbc_print2("jffs2.bbc: cannot initialize compressor %s.\n", c->name);
3032+ return -1;
3033+ }
3034+ }
3035+ if (c->model_file_sign != 0) {
3036+ l2 = jffs2_bbc_model_list;
3037+ while (1) {
3038+ if (l2 == NULL)
3039+ break;
3040+ if (c->model_file_sign == l2->sign) {
3041+ if (l2->compressor != NULL) {
3042+ jffs2_bbc_print2("jffs2.bbc: register for %s: BUG, model file already reserved!!!!\n", c->name);
3043+ }
3044+ else {
3045+ if (c->init_model(&(l2->model)) != 0) {
3046+ jffs2_bbc_print2("jffs2.bbc: cannot initialize compressor %s for a model", c->name);
3047+ }
3048+ else {
3049+ l2->compressor = c;
3050+ l2->next_compr_model = c->models;
3051+ c->models = l2;
3052+ c->mounted++;
3053+ model_found++;
3054+ }
3055+ }
3056+ }
3057+ l2 = l2->next_model;
3058+ }
3059+ /*if (model_found==0) {
3060+ jffs2_bbc_print2("jffs2.bbc: no macthing model file found for %s at this time (maybe later)\n",c->name);
3061+ } */
3062+ }
3063+ /* Insert to the end of the compressor list */
3064+ c->enabled = 1;
3065+ c->buffer = NULL;
3066+ c->buffer_size = 0;
3067+ c->stat_compr_orig = c->stat_compr_new = c->stat_decompr = 0;
3068+ c->next = NULL;
3069+ if (jffs2_bbc_compressors == NULL) {
3070+ jffs2_bbc_compressors = c;
3071+ }
3072+ else {
3073+ l = jffs2_bbc_compressors;
3074+ while (l->next != NULL)
3075+ l = l->next;
3076+ l->next = c;
3077+ }
3078+ return 0;
3079+}
3080+
3081+int jffs2_bbc_unregister_compressor(struct jffs2_bbc_compressor_type *c)
3082+{
3083+ struct jffs2_bbc_compressor_type *l;
3084+ struct jffs2_bbc_model_list_node *l2;
3085+
3086+ if (c->mounted != 0) {
3087+ jffs2_bbc_print1("jffs2.bbc: Compressor is in use. Sorry.");
3088+ return -1;
3089+ }
3090+ if (jffs2_bbc_compressors == NULL) {
3091+ jffs2_bbc_print1("jffs2.bbc: unregister: empty list.");
3092+ return -1;
3093+ }
3094+ else if (jffs2_bbc_compressors == c) {
3095+ if (c->deinit != NULL)
3096+ c->deinit();
3097+ jffs2_bbc_compressors = c->next;
3098+ }
3099+ else {
3100+ l = jffs2_bbc_compressors;
3101+ while (l->next != c) {
3102+ if (l->next == NULL) {
3103+ jffs2_bbc_print2("jffs2.bbc: unregister: cannot find compressor %s in the list.", c->name);
3104+ return -1;
3105+ }
3106+ l = l->next;
3107+ }
3108+ if (c->deinit != NULL)
3109+ c->deinit();
3110+ l->next = c->next;
3111+ }
3112+ if (c->buffer != NULL) {
3113+ jffs2_bbc_free(c->buffer);
3114+ c->buffer = NULL;
3115+ c->buffer_size = 0;
3116+ }
3117+
3118+ l2 = jffs2_bbc_model_list;
3119+ while (l2 != NULL) {
3120+ if (l2->compressor == c) {
3121+ jffs2_bbc_print1("jffs2.bbc: unregister: BUG: model found!!!");
3122+ l2->compressor = NULL;
3123+ l2->next_compr_model = NULL;
3124+ }
3125+ l2 = l2->next_model;
3126+ }
3127+
3128+ return 0;
3129+}
3130+
3131+int jffs2_bbc_model_new(void *sb, int i_num, void *model)
3132+{
3133+ struct jffs2_bbc_model_list_node *node;
3134+ struct jffs2_bbc_compressor_type *l;
3135+ char block_sign[2];
3136+
3137+ int sign;
3138+
3139+ /* check for conflicts... */
3140+ sign = *((int *) model);
3141+ block_sign[0] = *(((char *) model) + 4);
3142+ block_sign[1] = *(((char *) model) + 5);
3143+ node = jffs2_bbc_model_list;
3144+ while (node != NULL) {
3145+ if ((node->block_sign[0] == block_sign[0]) && (node->block_sign[1] == block_sign[1]) && (node->sb == sb)) {
3146+ //jffs2_bbc_print2("jffs2.bbc: model_new: model conflict (inode=%d)!\n",i_num);
3147+ return -1;
3148+ }
3149+ node = node->next_model;
3150+ }
3151+
3152+ /* insertion */
3153+ node = jffs2_bbc_malloc_small((long)sizeof(struct jffs2_bbc_model_list_node));
3154+ node->sb = sb;
3155+ node->model = model;
3156+ node->sign = *((int *) model);
3157+ node->block_sign[0] = *(((char *) model) + 4);
3158+ node->block_sign[1] = *(((char *) model) + 5);
3159+ node->inode = i_num;
3160+ node->next_model = jffs2_bbc_model_list;
3161+ node->compressor = NULL;
3162+ node->stat_decompr = 0;
3163+ node->next_compr_model = NULL;
3164+ jffs2_bbc_model_list = node;
3165+
3166+ /* search for matching compressor */
3167+ l = jffs2_bbc_compressors;
3168+ while (l != NULL) {
3169+ if (l->model_file_sign == sign) {
3170+ //jffs2_bbc_print2("jffs2.bbc: compressor for model found: %s ",l->name);
3171+ if (l->init_model(&(node->model)) != 0) {
3172+ jffs2_bbc_print1("jffs2.bbc: cannot initialize compressor for a model");
3173+ }
3174+ else {
3175+ l->mounted++;
3176+ node->compressor = l;
3177+ node->next_compr_model = l->models;
3178+ l->models = node;
3179+ }
3180+ break;
3181+ }
3182+ l = l->next;
3183+ }
3184+ return 0;
3185+}
3186+
3187+static void jffs2_bbc_model_del_from_compressor(struct jffs2_bbc_model_list_node *node)
3188+{
3189+ struct jffs2_bbc_model_list_node *l;
3190+
3191+ if (node->model != NULL) {
3192+ if (node->compressor != NULL) {
3193+ if (node->compressor->destroy_model == NULL) {
3194+ jffs2_bbc_free(node->model);
3195+ node->model = NULL;
3196+ }
3197+ else {
3198+ node->compressor->destroy_model(&(node->model));
3199+ if (node->model != NULL)
3200+ jffs2_bbc_print1("jffs2.bbc: warning: not NULL model after destroying!\n");
3201+ }
3202+ }
3203+ }
3204+
3205+ if (node->compressor == NULL) {
3206+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_del_from_compressor: no compressor!\n");
3207+ return;
3208+ }
3209+ l = node->compressor->models;
3210+ if (l == NULL) {
3211+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_del_from_compressor error, models=NULL!\n");
3212+ return;
3213+ }
3214+ if (l == node) {
3215+ node->compressor->models = node->next_compr_model;
3216+ node->compressor->mounted--;
3217+ return;
3218+ }
3219+ while (1) {
3220+ if (l->next_compr_model == node) {
3221+ l->next_compr_model = node->next_compr_model;
3222+ node->compressor->mounted--;
3223+ return;
3224+ }
3225+ l = l->next_compr_model;
3226+ if (l == NULL) {
3227+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_del_from_compressor: not found\n");
3228+ return;
3229+ }
3230+ }
3231+}
3232+
3233+void jffs2_bbc_model_del(void *sb)
3234+{
3235+ struct jffs2_bbc_model_list_node *l, *l2;
3236+
3237+ l = jffs2_bbc_model_list;
3238+ if (l == NULL)
3239+ return;
3240+ if (l->sb == sb) {
3241+ jffs2_bbc_model_list = l->next_model;
3242+ jffs2_bbc_model_del_from_compressor(l);
3243+ jffs2_bbc_free_small(l);
3244+ jffs2_bbc_model_del(sb);
3245+ return;
3246+ }
3247+ while (1) {
3248+ if (l->next_model == NULL) {
3249+ break;
3250+ }
3251+ if (l->next_model->sb == sb) {
3252+ l2 = l->next_model;
3253+ l->next_model = l->next_model->next_model;
3254+ jffs2_bbc_model_del_from_compressor(l2);
3255+ jffs2_bbc_free_small(l2);
3256+ jffs2_bbc_model_del(sb);
3257+ return;
3258+ }
3259+ l = l->next_model;
3260+ }
3261+ last_sb = NULL;
3262+}
3263+
3264+void jffs2_bbc_model_set_act_sb(void *sb)
3265+{
3266+ last_sb = sb;
3267+}
3268+
3269+void *jffs2_bbc_model_get_act_sb(void)
3270+{
3271+ return last_sb;
3272+}
3273+
3274+void *jffs2_bbc_model_get_newest(struct jffs2_bbc_compressor_type *compressor)
3275+{
3276+ struct jffs2_bbc_model_list_node *m, *best_m;
3277+ int max_sign, sign;
3278+
3279+ if (compressor == NULL) {
3280+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_get: NULL!!\n");
3281+ return NULL;
3282+ }
3283+
3284+ best_m = NULL;
3285+ max_sign = -1;
3286+ m = compressor->models;
3287+ while (m != NULL) {
3288+ if (m->sb == last_sb) {
3289+ sign = (int) (m->block_sign[0]) * 256 + (int) (m->block_sign[1]);
3290+ if (sign > max_sign) {
3291+ max_sign = sign;
3292+ best_m = m;
3293+ }
3294+ }
3295+ m = m->next_compr_model;
3296+ }
3297+ if (best_m != NULL)
3298+ return best_m->model;
3299+ else
3300+ return NULL;
3301+}
3302+
3303+/*********************************************************************
3304+ * Statistics *
3305+ *********************************************************************/
3306+
3307+static char *jffs2_bbc_stat_buff = NULL;
3308+
3309+char *jffs2_bbc_get_model_stats(void)
3310+{
3311+ char *b;
3312+ struct jffs2_bbc_model_list_node *m;
3313+ struct jffs2_bbc_compressor_type *c;
3314+
3315+ if (jffs2_bbc_stat_buff == NULL)
3316+ jffs2_bbc_stat_buff = jffs2_bbc_malloc(8000);
3317+
3318+ b = jffs2_bbc_stat_buff;
3319+
3320+ b += sprintf(b, "Loaded compressors:");
3321+ c = jffs2_bbc_compressors;
3322+ while (c != NULL) {
3323+ b += sprintf(b, "\n %s (%d) ", c->name, c->enabled);
3324+ if (c->model_file_sign != 0) {
3325+ b += sprintf(b, "m_sign=%d ", c->model_file_sign);
3326+ b += sprintf(b, "models=");
3327+ m = c->models;
3328+ while (m != NULL) {
3329+ b += sprintf(b, "(inode=%d)", m->inode);
3330+ m = m->next_compr_model;
3331+ }
3332+ }
3333+ else {
3334+ b += sprintf(b, "b_sign=(%d,%d) nomodel", (int) (c->block_sign[0]), (int) (c->block_sign[1]));
3335+ }
3336+ if (c->proc_info != NULL) {
3337+ b += sprintf(b, "\n %s", c->proc_info());
3338+ }
3339+ c = c->next;
3340+ }
3341+
3342+ m = jffs2_bbc_model_list;
3343+
3344+ if (m == NULL) {
3345+ b += sprintf(b, "\nPresent models: NONE\n");
3346+ }
3347+ else {
3348+ b += sprintf(b, "\nPresent models:\n");
3349+ while (m != NULL) {
3350+ b += sprintf(b, " b_sign=(%d,%d),inode=%d,decompr=%d", (int) (m->block_sign[0]), (int) (m->block_sign[1]), m->inode, m->stat_decompr);
3351+ if (m->compressor == NULL)
3352+ b += sprintf(b, ",compressor=NULL\n");
3353+ else
3354+ b += sprintf(b, ",compressor=%s\n", m->compressor->name);
3355+ m = m->next_model;
3356+ }
3357+ }
3358+
3359+ return jffs2_bbc_stat_buff;
3360+}
3361+
3362+/*********************************************************************
3363+ * Memory handling, debug *
3364+ *********************************************************************/
3365+
3366+static int jffs2_bbc_mem_counter = 0;
3367+
3368+#ifdef __KERNEL__
3369+
3370+void *jffs2_bbc_malloc(long size)
3371+{
3372+ void *addr = vmalloc(size);
3373+ if (addr != NULL)
3374+ jffs2_bbc_mem_counter++;
3375+ else {
3376+ jffs2_bbc_print2("DEBUG: not enough memory (%ld)\n", size);
3377+ }
3378+ return addr;
3379+}
3380+
3381+void jffs2_bbc_free(void *addr)
3382+{
3383+ jffs2_bbc_mem_counter--;
3384+ vfree(addr);
3385+}
3386+
3387+void *jffs2_bbc_malloc_small(long size)
3388+{
3389+ void *addr;
3390+ addr = kmalloc(size, 0);
3391+ if (addr != NULL)
3392+ jffs2_bbc_mem_counter++;
3393+ return addr;
3394+}
3395+
3396+void jffs2_bbc_free_small(void *addr)
3397+{
3398+ jffs2_bbc_mem_counter--;
3399+ kfree(addr);
3400+}
3401+
3402+#else
3403+
3404+void *jffs2_bbc_malloc(long size)
3405+{
3406+ void *addr = malloc(size);
3407+ if (addr != NULL)
3408+ jffs2_bbc_mem_counter++;
3409+ return addr;
3410+}
3411+
3412+void jffs2_bbc_free(void *addr)
3413+{
3414+ jffs2_bbc_mem_counter--;
3415+ free(addr);
3416+}
3417+
3418+void *jffs2_bbc_malloc_small(long size)
3419+{
3420+ return jffs2_bbc_malloc(size);
3421+}
3422+
3423+void jffs2_bbc_free_small(void *addr)
3424+{
3425+ jffs2_bbc_free(addr);
3426+}
3427+
3428+#endif
3429+
3430+int jffs2_bbc_test_memory_counter(int verbose)
3431+{
3432+ if (verbose > 0) {
3433+ jffs2_bbc_print2("jffs2.bbc: mem_counter=%d!\n", jffs2_bbc_mem_counter);
3434+ }
3435+ return jffs2_bbc_mem_counter;
3436+}
3437+
3438+int jffs2_bbc_get_memory_counter(void)
3439+{
3440+ return jffs2_bbc_mem_counter;
3441+}
3442+
3443+static char mem_stat[200];
3444+
3445+char *jffs2_bbc_get_mem_stats(void)
3446+{
3447+ sprintf(mem_stat, "Memcounter=%d\n", jffs2_bbc_mem_counter);
3448+ return mem_stat;
3449+}
3450+
3451+void jffs2_bbc_print_flush(void)
3452+{
3453+#ifdef __KERNEL__
3454+ return;
3455+#else
3456+ fflush(stdout);
3457+ fflush(stderr);
3458+#endif
3459+}
3460+
3461+/*********************************************************************
3462+ * FRAMEWORK - ZLIB REPLACEMENT *
3463+ *********************************************************************/
3464+
3465+#ifndef JFFS2_BBC_STANDALONE
3466+
3467+/* Temorary buffers */
3468+static char stat_str[JFFS2_BBC_STAT_BUFF_SIZE];
3469+static int tmp_buffer_size = 0;
3470+static char *tmp_buffer = NULL;
3471+
3472+/* Statistic - used by /proc/jffs2_bbc and mkfs.jffs2 */
3473+char *jffs2_bbc_get_compr_stats(void)
3474+{
3475+ struct jffs2_bbc_compressor_type *l;
3476+ char *s = stat_str;
3477+
3478+ s += sprintf(s, "Compression statistics:\n");
3479+ l = jffs2_bbc_original_compressor;
3480+ //s += sprintf(s, " zlib: compr=%d/%d decompr=%d\n", stat_zlib_compr_new, stat_zlib_compr_orig, stat_zlib_decompr);
3481+ s += sprintf(s, " %s: compr=%d/%d decompr=%d\n", l->name, l->stat_compr_new, l->stat_compr_orig, l->stat_decompr);
3482+ l = jffs2_bbc_get_compressor_list();
3483+ while (l != NULL) {
3484+ s += sprintf(s, " %s: compr=%d/%d decompr=%d\n", l->name, l->stat_compr_new, l->stat_compr_orig, l->stat_decompr);
3485+ l = l->next;
3486+ }
3487+ return stat_str;
3488+}
3489+
3490+static void jffs2_bbc_buffer_fill(unsigned char *buff, int size)
3491+{
3492+ for (; size > 0; size--, buff++)
3493+ *buff = 255;
3494+}
3495+
3496+
3497+static int jffs2_bbc_update_compr_buf(unsigned long size)
3498+{
3499+ struct jffs2_bbc_compressor_type *l;
3500+
3501+ if (size < 5000)
3502+ size = 5000;
3503+ if (tmp_buffer == NULL) {
3504+ tmp_buffer = jffs2_bbc_malloc(size);
3505+ jffs2_bbc_buffer_fill(tmp_buffer, size);
3506+ tmp_buffer_size = size;
3507+ }
3508+ else if (tmp_buffer_size < size) {
3509+ jffs2_bbc_free(tmp_buffer);
3510+ tmp_buffer = jffs2_bbc_malloc(size);
3511+ jffs2_bbc_buffer_fill(tmp_buffer, size);
3512+ tmp_buffer_size = size;
3513+ }
3514+ l = jffs2_bbc_get_compressor_list();
3515+ while (l != NULL) {
3516+ if (l->buffer == NULL) {
3517+ l->buffer_size = size;
3518+ l->buffer = jffs2_bbc_malloc(size);
3519+ jffs2_bbc_buffer_fill(l->buffer, size);
3520+ }
3521+ else if (l->buffer_size < size) {
3522+ jffs2_bbc_free(l->buffer);
3523+ l->buffer_size = size;
3524+ l->buffer = jffs2_bbc_malloc(size);
3525+ jffs2_bbc_buffer_fill(l->buffer, size);
3526+ }
3527+ l = l->next;
3528+ }
3529+ return 0;
3530+}
3531+
3532+#ifdef DEBUG_COMPRESSORS
3533+
3534+static unsigned char *debug_tmp_buff = NULL;
3535+static long debug_orig_srclen = -1;
3536+static long debug_orig_dstlen = -1;
3537+static int debug_mem_counter = -1;
3538+
3539+
3540+void debug_before_compress(struct jffs2_bbc_compressor_type *c, void *model, unsigned char *input, unsigned char *output, long *sourcelen, long *dstlen)
3541+{
3542+
3543+ debug_orig_srclen = *sourcelen; // for buffer overflow test
3544+ debug_orig_dstlen = *dstlen; // for buffer overflow test
3545+ output[debug_orig_dstlen + 1] = 255;
3546+
3547+ debug_mem_counter = jffs2_bbc_get_memory_counter(); // for memory guard
3548+}
3549+
3550+void debug_after_compress(struct jffs2_bbc_compressor_type *c, int back, void *model, unsigned char *input, unsigned char *output, long *sourcelen, long *dstlen)
3551+{
3552+ long dst_len = *dstlen;
3553+ long src_len = *sourcelen;
3554+ int i;
3555+
3556+ // Memory guard
3557+ if (debug_mem_counter != jffs2_bbc_get_memory_counter()) {
3558+ jffs2_bbc_print4("!!!!!!!! %s error: possible COMPRESSOR MEMORY LEAK: %d->%d\n", c->name, debug_mem_counter, jffs2_bbc_get_memory_counter());
3559+ debug_mem_counter = jffs2_bbc_get_memory_counter();
3560+ }
3561+
3562+ // Buffer overflow test
3563+ if (output[debug_orig_dstlen + 1] != 255) {
3564+ jffs2_bbc_print7("!!!!!!!! %s error: BUFFER OVERFLOW !!!!!!!!!!!! b[%d]=%d (srclen=%d dstlen=%d, back=%d)\n", c->name, (int) (debug_orig_dstlen + 1), (int) (output[debug_orig_dstlen + 1]), (int) (debug_orig_srclen), (int) (*dstlen), back);
3565+ }
3566+
3567+ // Decompression check
3568+ if (back == 0) {
3569+ if (debug_tmp_buff == NULL)
3570+ debug_tmp_buff = jffs2_bbc_malloc(17000);
3571+ for (i = 0; i < src_len; i++) debug_tmp_buff[i] = 0xf6;
3572+ c->decompress(model, output, debug_tmp_buff, dst_len, src_len);
3573+ // Memory guard for decompressor
3574+ if (debug_mem_counter != jffs2_bbc_get_memory_counter()) {
3575+ jffs2_bbc_print4("!!!!!!!! %s error: possible DECOMPRESSOR MEMORY LEAK: %d->%d\n", c->name, debug_mem_counter, jffs2_bbc_get_memory_counter());
3576+ debug_mem_counter = jffs2_bbc_get_memory_counter();
3577+ }
3578+
3579+ for (i = 0; i < src_len; i++)
3580+ if (input[i] != debug_tmp_buff[i]) {
3581+ jffs2_bbc_print7("!!!!!!!! %s error: BLOCK DECOMPRESSED BADLY (first bad: %d in %d: %d!=%d (compressed size=%d)) !!!!!!!!!!!!\n", c->name, i, src_len, (int)input[i], (int)debug_tmp_buff[i], dst_len);
3582+ break;
3583+ }
3584+ return;
3585+ }
3586+
3587+ // Return value test
3588+ //jffs2_bbc_print3("!!!!!!!! %s error: %d !!!!!!!!!!!!\n", c->name, back);
3589+}
3590+
3591+#endif
3592+
3593+int jffs2_zlib_compress(unsigned char *data_in, unsigned char *cpage_out, uint32_t * sourcelen, uint32_t * dstlen)
3594+{
3595+ struct jffs2_bbc_compressor_type *c;
3596+ int back, back_zlib, mode, min, i, i2;
3597+ long tmp = 0, tmp_read_time = 1000, tmp_write_time = 1000, orig_src, orig_dest, src, dest;
3598+ struct jffs2_bbc_model_list_node *m;
3599+ void *sb;
3600+ unsigned char *tmp_p = NULL;
3601+
3602+ sb = jffs2_bbc_model_get_act_sb();
3603+
3604+ orig_src = *sourcelen;
3605+ orig_dest = *dstlen;
3606+
3607+ mode = jffs2_bbc_get_compression_mode();
3608+
3609+ if (mode == JFFS2_BBC_DUMMY_MODE) {
3610+ i=0; i2=0;
3611+ if (*dstlen>2) {
3612+ cpage_out[i++]=JFFS2_BBC_DUMMY_BLOCKSIGN_0;
3613+ cpage_out[i++]=JFFS2_BBC_DUMMY_BLOCKSIGN_1;
3614+ i2=i;
3615+ }
3616+ for (;((i < *dstlen) && (i < (*sourcelen)+i2));i++) {
3617+ cpage_out[i] = data_in[i-i2];
3618+ }
3619+ *sourcelen=i-i2;
3620+ *dstlen=i;
3621+ return 0;
3622+ }
3623+
3624+ if (mode == JFFS2_BBC_ZLIB_MODE) {
3625+ /*if (!jffs2_bbc_original_compressor->enabled) {
3626+ jffs2_bbc_print2("jffs2.bbc: WARNING: ZLIB mode but %s disabled! Enabling for this procedure...\n",jffs2_bbc_original_compressor->name);
3627+ }*/
3628+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
3629+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
3630+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
3631+ return back;
3632+ }
3633+
3634+ jffs2_bbc_update_compr_buf(orig_dest);
3635+
3636+ if (mode == JFFS2_BBC_SIZE_MODE) {
3637+ // Testing all compressors
3638+ if (!jffs2_bbc_original_compressor->enabled) {
3639+ min = -1;
3640+ }
3641+ else {
3642+ back_zlib = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
3643+ min = *dstlen;
3644+ }
3645+ c = jffs2_bbc_get_compressor_list();
3646+ while (c != NULL) {
3647+ c->buffer_cnt = -1;
3648+ if (c->enabled == 0) {
3649+ c = c->next;
3650+ continue;
3651+ }
3652+ if (c->model_file_sign == 0) {
3653+ src = orig_src;
3654+ dest = orig_dest;
3655+#ifdef DEBUG_COMPRESSORS
3656+ debug_before_compress(c, NULL, data_in, c->buffer, &src, &dest);
3657+#endif
3658+ back = c->compress(NULL, data_in, c->buffer, &src, &dest);
3659+#ifdef DEBUG_COMPRESSORS
3660+ debug_after_compress(c, back, NULL, data_in, c->buffer, &src, &dest);
3661+#endif
3662+ if (back == 0) {
3663+ c->buffer_cnt = dest;
3664+ if ((min < 0) || (min > dest))
3665+ min = dest;
3666+ }
3667+ }
3668+ else {
3669+ m = c->models;
3670+ while (m != NULL) {
3671+ src = orig_src;
3672+ dest = orig_dest;
3673+ if (m->sb == sb) {
3674+ if (c->buffer_cnt == -1) {
3675+#ifdef DEBUG_COMPRESSORS
3676+ debug_before_compress(c, m->model, data_in, c->buffer, (long *) (&src), (long *) (&dest));
3677+#endif
3678+ back = c->compress(m->model, data_in, c->buffer, (long *) (&src), (long *) (&dest));
3679+#ifdef DEBUG_COMPRESSORS
3680+ debug_after_compress(c, back, m->model, data_in, c->buffer, (long *) (&src), (long *) (&dest));
3681+#endif
3682+ if (back == 0) {
3683+ c->buffer_cnt = dest;
3684+ if ((min < 0) || (min > dest))
3685+ min = dest;
3686+ }
3687+ }
3688+ else {
3689+#ifdef DEBUG_COMPRESSORS
3690+ debug_before_compress(c, m->model, data_in, tmp_buffer, &src, &dest);
3691+#endif
3692+ back = c->compress(m->model, data_in, tmp_buffer, &src, &dest);
3693+#ifdef DEBUG_COMPRESSORS
3694+ debug_after_compress(c, back, m->model, data_in, tmp_buffer, &src, &dest);
3695+#endif
3696+ if (back == 0) {
3697+ if (c->buffer_cnt > dest) {
3698+ c->buffer_cnt = dest;
3699+ tmp_p = c->buffer;
3700+ c->buffer = tmp_buffer;
3701+ tmp_buffer = tmp_p;
3702+ if ((min < 0) || (min > dest))
3703+ min = dest;
3704+ }
3705+ }
3706+ }
3707+ }
3708+ m = m->next_compr_model;
3709+ }
3710+ }
3711+ c = c->next;
3712+ }
3713+ //Finding the best and copy its result
3714+
3715+#ifdef DEBUG_SHOW_BLOCK_SIZES
3716+ jffs2_bbc_print1("\n");
3717+ if (jffs2_bbc_original_compressor->enabled) {
3718+ if (min == *dstlen) {
3719+ jffs2_bbc_print3("%s:%d* ", jffs2_bbc_original_compressor->name, (int) (*dstlen));
3720+ }
3721+ else {
3722+ jffs2_bbc_print3("%s:%d ", jffs2_bbc_original_compressor->name, (int) (*dstlen));
3723+ }
3724+ }
3725+ c = jffs2_bbc_get_compressor_list();
3726+ while (c != NULL) {
3727+ if (c->enabled == 0) {
3728+ c = c->next;
3729+ continue;
3730+ }
3731+ if (c->buffer_cnt == min)
3732+ jffs2_bbc_print3("%s:%d* ", c->name, c->buffer_cnt);
3733+ else
3734+ jffs2_bbc_print3("%s:%d ", c->name, c->buffer_cnt);
3735+ c = c->next;
3736+ }
3737+#endif
3738+
3739+ if (min == -1) {
3740+ return -1; // none of compressors work (maybe too short output buffer)
3741+ }
3742+
3743+ if (jffs2_bbc_original_compressor->enabled) {
3744+ if (min == *dstlen) {
3745+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
3746+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
3747+ return back_zlib;
3748+ }
3749+ }
3750+
3751+ c = jffs2_bbc_get_compressor_list();
3752+ while (c != NULL) {
3753+ if (c->enabled == 0) {
3754+ c = c->next;
3755+ continue;
3756+ }
3757+ if (c->buffer_cnt == min) {
3758+ *dstlen = c->buffer_cnt;
3759+ *sourcelen = orig_src;
3760+ for (i = 0; i < *dstlen; i++) {
3761+ cpage_out[i] = c->buffer[i];
3762+ }
3763+ c->stat_compr_orig += *sourcelen;
3764+ c->stat_compr_new += *dstlen;
3765+ return 0;
3766+ }
3767+ c = c->next;
3768+ }
3769+ jffs2_bbc_print1("jffs2.bbc: compr (full): BUG!!!\n");
3770+ return 0;
3771+ }
3772+
3773+ if ((mode == JFFS2_BBC_FASTR_MODE)||(mode == JFFS2_BBC_FASTW_MODE)||(mode == JFFS2_BBC_FASTS_MODE)) {
3774+ // Estimating all compressors
3775+ if (jffs2_bbc_original_compressor->enabled) {
3776+ back = jffs2_bbc_original_compressor->estimate(NULL, data_in, *sourcelen, &tmp, &tmp_read_time, &tmp_write_time);
3777+ }
3778+ else {
3779+ tmp = -1;
3780+ tmp_read_time = -1;
3781+ tmp_write_time = -1;
3782+ }
3783+ if (mode == JFFS2_BBC_FASTR_MODE) tmp = tmp_read_time;
3784+ if (mode == JFFS2_BBC_FASTW_MODE) tmp = tmp_write_time;
3785+ min = tmp;
3786+ c = jffs2_bbc_get_compressor_list();
3787+ while (c != NULL) {
3788+ src = orig_src;
3789+ dest = orig_dest;
3790+ c->buffer_cnt = -1;
3791+ if (c->enabled == 0) {
3792+ c = c->next;
3793+ continue;
3794+ }
3795+ if ((c->model_file_sign == 0) || (jffs2_bbc_model_get_newest(c) != NULL)) {
3796+ back = c->estimate(jffs2_bbc_model_get_newest(c), data_in, src, &dest, &tmp_read_time, &tmp_write_time);
3797+ if (mode == JFFS2_BBC_FASTR_MODE) dest = tmp_read_time;
3798+ if (mode == JFFS2_BBC_FASTW_MODE) dest = tmp_write_time;
3799+ if (back == 0) {
3800+ c->buffer_cnt = dest;
3801+ if ((min < 0) || (min > dest))
3802+ min = dest;
3803+ }
3804+ else {
3805+ c->buffer_cnt = -1;
3806+ }
3807+ }
3808+ c = c->next;
3809+ }
3810+ // Finding the best and compress with it
3811+ if (min == -1) {
3812+ return -1;
3813+ }
3814+ if (jffs2_bbc_original_compressor->enabled) {
3815+ if (min == tmp) {
3816+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
3817+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
3818+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
3819+ return back;
3820+ }
3821+ }
3822+ c = jffs2_bbc_get_compressor_list();
3823+ while (c != NULL) {
3824+ if (c->enabled == 0) {
3825+ c = c->next;
3826+ continue;
3827+ }
3828+ if (c->buffer_cnt == min) {
3829+ back = c->compress(jffs2_bbc_model_get_newest(c), data_in, cpage_out, (unsigned long*)sourcelen, (unsigned long*)dstlen);
3830+ if ((back == 0) && (*dstlen < orig_dest) && (*dstlen > 4)) {
3831+ c->stat_compr_orig += *sourcelen;
3832+ c->stat_compr_new += *dstlen;
3833+ }
3834+ else { // fallback will always be available
3835+ *sourcelen = orig_src;
3836+ *dstlen = orig_dest;
3837+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
3838+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
3839+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
3840+ return back;
3841+ }
3842+ return 0;
3843+ }
3844+ c = c->next;
3845+ }
3846+ jffs2_bbc_print1("jffs2.bbc: compress (fastX mode): BUG!!!\n");
3847+ return 0;
3848+ }
3849+
3850+ if (mode == JFFS2_BBC_MANUAL_MODE) {
3851+ c = jffs2_bbc_get_manual_compressor();
3852+ if (c != NULL) {
3853+ if (c->model_file_sign == 0) {
3854+ src = orig_src;
3855+ dest = orig_dest;
3856+ back = c->compress(NULL, data_in, cpage_out, &src, &dest);
3857+ if (back == 0) {
3858+ *dstlen = dest;
3859+ *sourcelen = src;
3860+ c->stat_compr_orig += *sourcelen;
3861+ c->stat_compr_new += *dstlen;
3862+ return 0;
3863+ }
3864+ }
3865+ else {
3866+ c->buffer_cnt = -1;
3867+ m = c->models;
3868+ min = -1;
3869+ while (m != NULL) {
3870+ src = orig_src;
3871+ dest = orig_dest;
3872+ if (m->sb == sb) {
3873+ if (min == -1) {
3874+ back = c->compress(m->model, data_in, cpage_out, (unsigned long*)sourcelen, (unsigned long*)dstlen);
3875+ if ((back == 0) && (*dstlen < orig_dest) && (*dstlen > 4)) {
3876+ min = dest;
3877+ tmp_p = cpage_out;
3878+ }
3879+ }
3880+ else {
3881+ back = c->compress(m->model, data_in, tmp_buffer, &src, &dest);
3882+ if ((back == 0) && (dest < orig_dest) && (dest > 4)) {
3883+ if (c->buffer_cnt > dest) {
3884+ if (min > dest) {
3885+ min = dest;
3886+ tmp_p = tmp_buffer;
3887+ }
3888+ }
3889+ }
3890+ }
3891+ }
3892+ m = m->next_compr_model;
3893+ }
3894+ if (min != -1) {
3895+ if (tmp_p != cpage_out) {
3896+ for (i = 0; i < min; i++)
3897+ cpage_out[i] = tmp_p[i];
3898+ *sourcelen = orig_src;
3899+ *dstlen = min;
3900+ }
3901+ c->stat_compr_orig += *sourcelen;
3902+ c->stat_compr_new += *dstlen;
3903+ return 0;
3904+ }
3905+ }
3906+ }
3907+ /*else {
3908+ jffs2_bbc_print1("iPack: manual mode without selected compressor!\n");
3909+ } */
3910+
3911+ /*if (!jffs2_bbc_original_compressor->enabled) {
3912+ jffs2_bbc_print2("jffs2.bbc: WARNING: %s must be enabled! Enabling for this procedure...\n",jffs2_bbc_original_compressor->name);
3913+ }*/
3914+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
3915+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
3916+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
3917+ return back;
3918+
3919+
3920+ }
3921+
3922+ jffs2_bbc_print1("jffs2.bbc: compress: unimlemented compress mode!!!\n");
3923+ return 0;
3924+}
3925+
3926+void jffs2_zlib_decompress(unsigned char *data_in, unsigned char *cpage_out, uint32_t srclen, uint32_t destlen)
3927+{
3928+ struct jffs2_bbc_model_list_node *m;
3929+ struct jffs2_bbc_compressor_type *c;
3930+ char d[2];
3931+ void *sb;
3932+ int i;
3933+
3934+ /* If the input too small... */
3935+ if (destlen<=2) {
3936+ cpage_out[0]=data_in[0];
3937+ if (destlen==2) cpage_out[1]=data_in[1];
3938+ return;
3939+ }
3940+
3941+ sb = jffs2_bbc_model_get_act_sb();
3942+ d[0] = *(data_in);
3943+ d[1] = *(data_in + 1);
3944+
3945+ d[0] &= 0x7f; // Variants support...
3946+
3947+ /* Search for model based decompressors... */
3948+ m = jffs2_bbc_get_model_list();
3949+ while (m != NULL) {
3950+ if ((d[0] == m->block_sign[0]) && (d[1] == m->block_sign[1]) && (sb == m->sb)) {
3951+ if (m->compressor == NULL) {
3952+ jffs2_bbc_print3("jffs2.bbc: decompressor for block_sign (%d,%d) not loaded!\n", (int) (d[0]), (int) (d[1]));
3953+ }
3954+ else {
3955+ m->compressor->decompress(m->model, data_in, cpage_out, srclen, destlen);
3956+ m->compressor->stat_decompr++;
3957+ m->stat_decompr++;
3958+ }
3959+ return;
3960+ }
3961+ m = m->next_model;
3962+ }
3963+ /* Is it ZLIB? */
3964+ if ((((int) d[0]) == (int)(jffs2_bbc_original_compressor->block_sign[0])) && (((int) d[1]) == (int)(jffs2_bbc_original_compressor->block_sign[1]))) {
3965+ jffs2_bbc_original_compressor->decompress(NULL, data_in, cpage_out, srclen, destlen);
3966+ jffs2_bbc_original_compressor->stat_decompr++;
3967+ return;
3968+ }
3969+ /* Search for non model based decompressors... */
3970+ c = jffs2_bbc_get_compressor_list();
3971+ while (c != NULL) {
3972+ if (c->model_file_sign == 0) {
3973+ if (((int) (d[0]) == (int) (c->block_sign[0])) && ((int) (d[1]) == (int) (c->block_sign[1]))) {
3974+ c->decompress(NULL, data_in, cpage_out, srclen, destlen);
3975+ c->stat_decompr++;
3976+ return;
3977+ }
3978+ }
3979+ c = c->next;
3980+ }
3981+ /* Is it DUMMY? */
3982+ if ((((int) d[0]) == JFFS2_BBC_DUMMY_BLOCKSIGN_0) && (((int) d[1]) == JFFS2_BBC_DUMMY_BLOCKSIGN_1)) {
3983+ for (i=0;i<destlen;i++) {
3984+ cpage_out[i]=data_in[i+2];
3985+ }
3986+ return;
3987+ }
3988+ /* No matching decompressor found... */
3989+ jffs2_bbc_print4("jffs2.bbc: cannot find model for decompress: bsign=(%d,%d),sb=%d. Using zlib.\n", (int) d[0], (int) d[1], (int) sb);
3990+ jffs2_bbc_original_compressor->decompress(NULL, data_in, cpage_out, srclen, destlen);
3991+ jffs2_bbc_original_compressor->stat_decompr++;
3992+}
3993+
3994+#endif
3995--- /dev/null
3996+++ b/fs/jffs2/jffs2_bbc_framework.h
3997@@ -0,0 +1,202 @@
3998+/*
3999+ * JFFS2-BBC: Compression Framework - headers
4000+ *
4001+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
4002+ *
4003+ * Copyright (C) 2004, Ferenc Havasi
4004+ *
4005+ * This program is free software; you can redistribute it and/or
4006+ * modify it under the terms of the GNU General Public License
4007+ * as published by the Free Software Foundation; either version 2
4008+ * of the License, or (at your option) any later version.
4009+ *
4010+ * This program is distributed in the hope that it will be useful,
4011+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
4012+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4013+ * GNU General Public License for more details.
4014+ *
4015+ * You should have received a copy of the GNU General Public License
4016+ * along with this program; if not, write to the Free Software
4017+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
4018+ *
4019+ */
4020+
4021+#ifndef __JFFS2_BBC_FRAMEWORK_H__
4022+
4023+#define __JFFS2_BBC_FRAMEWORK_H__
4024+
4025+#define JFFS2_BBC_VERSION "0.54.3"
4026+
4027+#define JFFS2_BBC_CONFIG_FILE "bbc.conf"
4028+
4029+/*********************************************************************
4030+ * Compression mode handling *
4031+ *********************************************************************/
4032+
4033+#define JFFS2_BBC_ZLIB_MODE 1
4034+#define JFFS2_BBC_SIZE_MODE 2
4035+#define JFFS2_BBC_FASTR_MODE 3
4036+#define JFFS2_BBC_FASTW_MODE 4
4037+#define JFFS2_BBC_FASTS_MODE 5
4038+#define JFFS2_BBC_MANUAL_MODE 6
4039+#define JFFS2_BBC_DUMMY_MODE 7
4040+
4041+int jffs2_bbc_get_compression_mode(void);
4042+void jffs2_bbc_set_compression_mode(int mode);
4043+
4044+/*********************************************************************
4045+ * Read/write speed unit *
4046+ * everything is relative to the speed of zlib *
4047+ * bigger number means slower speed! *
4048+ *********************************************************************/
4049+
4050+#define JFFS2_BBC_ZLIB_READ_TIME 10000
4051+#define JFFS2_BBC_ZLIB_WRITE_TIME 10000
4052+
4053+/*********************************************************************
4054+ * Compressor handling *
4055+ *********************************************************************/
4056+
4057+struct jffs2_bbc_compressor_type
4058+{
4059+ char name[16];
4060+ int model_file_sign; /* 0 for no model file needed */
4061+ char block_sign[4]; /* only nomodel compressors, and only the first 2 _bytes are used! */
4062+ int (*init)(void);
4063+ int (*init_model)(void **model);
4064+ void (*destroy_model)(void **model);
4065+ void (*deinit)(void);
4066+ /* Compress block
4067+ * *dstlen bytes are allocated.
4068+ * if it is not enough write *sourcelen over to the processed amount of data
4069+ * returns non zero if fails
4070+ */
4071+ int (*compress)(void *model, unsigned char *input, unsigned char *output, unsigned long *sourcelen, unsigned long *dstlen);
4072+ int (*estimate)(void *model, unsigned char *input, unsigned long sourcelen,
4073+ unsigned long *dstlen, unsigned long *readtime, unsigned long *writetime);
4074+ /* Decompress block
4075+ * returns non zero if fails
4076+ */
4077+ int (*decompress)(void *model, unsigned char *input, unsigned char *output, unsigned long sourcelen, unsigned long dstlen);
4078+ char *(*proc_info)(void);
4079+ int (*proc_command)(char *command);
4080+ int enabled; /* filled by BBC */
4081+ int mounted; /* filled by BBC */
4082+ void *models; /* filled by BBC */
4083+ char *buffer; /* filled by BBC */
4084+ int buffer_size; /* filled by BBC */
4085+ int buffer_cnt; /* filled by BBC */
4086+ int buffer_tmp; /* filled by BBC */
4087+ int stat_compr_orig; /* filled by BBC */
4088+ int stat_compr_new; /* filled by BBC */
4089+ int stat_decompr; /* filled by BBC */
4090+ struct jffs2_bbc_compressor_type *next; /* filled by BBC */
4091+};
4092+
4093+/* It sets the compression mode to JFFS2_BBC_MANUAL_MODE */
4094+
4095+void jffs2_bbc_set_manual_compressor(struct jffs2_bbc_compressor_type *c); /* NULL = ZLIB */
4096+int jffs2_bbc_set_manual_compressor_by_name(char *name);
4097+int jffs2_bbc_disable_compressor_by_name(char *name);
4098+int jffs2_bbc_enable_compressor_by_name(char *name);
4099+void jffs2_bbc_compressor_command_by_name(char *name_and_command);
4100+
4101+/* If the compression mode is JFFS2_BCC_MANUAL_MODE the manually setted
4102+ compressor can be get using it. Otherwise it returns with NULL. */
4103+
4104+struct jffs2_bbc_compressor_type *jffs2_bbc_get_manual_compressor(void);
4105+
4106+struct jffs2_bbc_model_list_node
4107+{
4108+ void *sb; /* FS idendifier (JFFS2_SB_INFO(sb) at this moment) */
4109+ void *model; /* model data */
4110+ int sign; /* sign of the model (first 4 bytes) */
4111+ char block_sign[4]; /* block sign - only the first 2 bytes are used! */
4112+ int inode; /* inode number of the model file */
4113+ int stat_decompr;
4114+ struct jffs2_bbc_compressor_type *compressor;
4115+ struct jffs2_bbc_model_list_node *next_model;
4116+ struct jffs2_bbc_model_list_node *next_compr_model;
4117+};
4118+
4119+struct jffs2_bbc_compressor_type *jffs2_bbc_get_compressor_list(void);
4120+struct jffs2_bbc_model_list_node *jffs2_bbc_get_model_list(void);
4121+
4122+int jffs2_bbc_register_compressor(struct jffs2_bbc_compressor_type *c);
4123+int jffs2_bbc_unregister_compressor(struct jffs2_bbc_compressor_type *c);
4124+
4125+int jffs2_bbc_model_new(void *sb, int i_num, void *model);
4126+void jffs2_bbc_model_del(void *sb);
4127+void jffs2_bbc_model_set_act_sb(void *sb);
4128+void *jffs2_bbc_model_get_act_sb(void);
4129+void *jffs2_bbc_model_get_newest(struct jffs2_bbc_compressor_type *compressor);
4130+
4131+/*********************************************************************
4132+ * Compressor init function *
4133+ *********************************************************************/
4134+
4135+void jffs2_bbc_compressor_init(void);
4136+void jffs2_bbc_compressor_deinit(void);
4137+
4138+/*********************************************************************
4139+ * Statistics *
4140+ *********************************************************************/
4141+
4142+char *jffs2_bbc_get_compr_stats(void);
4143+char *jffs2_bbc_get_model_stats(void);
4144+
4145+/*********************************************************************
4146+ * Other *
4147+ *********************************************************************/
4148+
4149+
4150+void jffs2_bbc_print_flush(void);
4151+
4152+#ifdef __KERNEL__
4153+#include <linux/kernel.h>
4154+#define jffs2_bbc_print1(a) printk(a)
4155+#define jffs2_bbc_print2(a,b) printk(a,b)
4156+#define jffs2_bbc_print3(a,b,c) printk(a,b,c)
4157+#define jffs2_bbc_print4(a,b,c,d) printk(a,b,c,d)
4158+#define jffs2_bbc_print5(a,b,c,d,e) printk(a,b,c,d,e)
4159+#define jffs2_bbc_print6(a,b,c,d,e,f) printk(a,b,c,d,e,f)
4160+#define jffs2_bbc_print7(a,b,c,d,e,f,g) printk(a,b,c,d,e,f,g)
4161+#define jffs2_bbc_print8(a,b,c,d,e,f,g,h) printk(a,b,c,d,e,f,g,h)
4162+#define jffs2_bbc_print9(a,b,c,d,e,f,g,h,i) printk(a,b,c,d,e,f,g,h,i)
4163+#else
4164+#include <stdio.h>
4165+#define jffs2_bbc_print1(a) fprintf(stderr,a)
4166+#define jffs2_bbc_print2(a,b) fprintf(stderr,a,b)
4167+#define jffs2_bbc_print3(a,b,c) fprintf(stderr,a,b,c)
4168+#define jffs2_bbc_print4(a,b,c,d) fprintf(stderr,a,b,c,d)
4169+#define jffs2_bbc_print5(a,b,c,d,e) fprintf(stderr,a,b,c,d,e)
4170+#define jffs2_bbc_print6(a,b,c,d,e,f) fprintf(stderr,a,b,c,d,e,f)
4171+#define jffs2_bbc_print7(a,b,c,d,e,f,g) fprintf(stderr,a,b,c,d,e,f,g)
4172+#define jffs2_bbc_print8(a,b,c,d,e,f,g,h) fprintf(stderr,a,b,c,d,e,f,g,h)
4173+#define jffs2_bbc_print9(a,b,c,d,e,f,g,h,i) fprintf(stderr,a,b,c,d,e,f,g,h,i)
4174+#endif
4175+
4176+/* Handle endianness */
4177+#ifndef __KERNEL__
4178+
4179+#define ENDIAN_HOST_AND_TARGET_SAME 0
4180+#define ENDIAN_HOST_AND_TARGET_DIFFERENT 1
4181+
4182+extern int jffs2_bbc_glb_endian_X;
4183+
4184+#endif
4185+
4186+/* Allocating more than one page (tip. 4096 byte) */
4187+void *jffs2_bbc_malloc(long size);
4188+void jffs2_bbc_free(void *addr);
4189+
4190+/* Allocating less than one page (tip. 4096 byte) */
4191+void *jffs2_bbc_malloc_small(long size);
4192+void jffs2_bbc_free_small(void *addr);
4193+
4194+/* Memory guarding */
4195+int jffs2_bbc_test_memory_counter(int verbose);
4196+char *jffs2_bbc_get_mem_stats(void);
4197+int jffs2_bbc_get_memory_counter(void);
4198+
4199+#endif
4200--- /dev/null
4201+++ b/fs/jffs2/jffs2_bbc_fs.c
4202@@ -0,0 +1,331 @@
4203+/*
4204+ * JFFS2-BBC: File System Extension for Linux Kernel
4205+ *
4206+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
4207+ *
4208+ * Copyright (C) 2004, Ferenc Havasi
4209+ *
4210+ * This program is free software; you can redistribute it and/or
4211+ * modify it under the terms of the GNU General Public License
4212+ * as published by the Free Software Foundation; either version 2
4213+ * of the License, or (at your option) any later version.
4214+ *
4215+ * This program is distributed in the hope that it will be useful,
4216+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
4217+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4218+ * GNU General Public License for more details.
4219+ *
4220+ * You should have received a copy of the GNU General Public License
4221+ * along with this program; if not, write to the Free Software
4222+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
4223+ *
4224+ */
4225+
4226+#include <linux/kernel.h>
4227+#include <linux/fs.h>
4228+#include <linux/jffs2.h>
4229+#include <linux/proc_fs.h>
4230+#include <linux/version.h>
4231+
4232+#include "nodelist.h"
4233+
4234+#include "jffs2_bbc_framework.h"
4235+
4236+struct jffs2_bbc_fs_sb_list {
4237+ struct super_block *sb;
4238+ struct jffs2_bbc_fs_sb_list *next;
4239+};
4240+
4241+static struct jffs2_bbc_fs_sb_list *sb_list = NULL;
4242+
4243+void jffs2_bbc_proc_init(void);
4244+void jffs2_bbc_proc_deinit(void);
4245+
4246+void jffs2_bbc_load_model(void *sb_par) {
4247+ struct jffs2_sb_info *c;
4248+ //struct jffs2_inode_info *f;
4249+ struct dentry *config_dentry,*model_dentry;
4250+ struct qstr config_name,model_name;
4251+ struct file *config_file,*model_file;
4252+ char *buff=NULL,*model_buff;
4253+ int config_size,model_size;
4254+ int i,prev_i;
4255+ struct super_block *sb;
4256+ struct jffs2_bbc_fs_sb_list *sb_l;
4257+
4258+ sb = sb_par;
4259+ sb_l = jffs2_bbc_malloc_small(sizeof(struct jffs2_bbc_fs_sb_list));
4260+ sb_l->sb = sb;
4261+ sb_l->next = sb_list;
4262+ sb_list = sb_l;
4263+ config_name.name = JFFS2_BBC_CONFIG_FILE;
4264+ config_name.len = strlen(config_name.name);
4265+ config_name.hash = full_name_hash(config_name.name,config_name.len);
4266+ config_dentry = d_alloc(sb->s_root,&config_name);
4267+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4268+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,config_dentry);
4269+#else
4270+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,config_dentry,NULL);
4271+#endif
4272+
4273+ if (config_dentry->d_inode != NULL) {
4274+ config_size = config_dentry->d_inode->i_size;
4275+ //printk("config_file_size=%d\n",config_size);
4276+ if (config_size > 0) {
4277+ buff = jffs2_bbc_malloc(config_size+1);
4278+ config_file = dentry_open(config_dentry,NULL,O_RDONLY);
4279+ kernel_read(config_file,0,buff,config_size);
4280+ buff[config_size] = 0;
4281+ for (prev_i = i = 0 ; i < config_size+1 ; i++) {
4282+ if (buff[i] == '\n') buff[i]=0;
4283+ if (buff[i] == 0) {
4284+ if (prev_i != i) {
4285+ if ((buff[prev_i] == '-') && (buff[prev_i+1] == 0)) break;
4286+ printk("reading model file %s... ",buff+prev_i);
4287+ model_name.name = buff+prev_i;
4288+ model_name.len = strlen(buff+prev_i);
4289+ model_name.hash = full_name_hash(model_name.name,model_name.len);
4290+ model_dentry = d_alloc(sb->s_root,&model_name);
4291+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4292+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,model_dentry);
4293+#else
4294+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,model_dentry,NULL);
4295+#endif
4296+ if (model_dentry->d_inode != NULL) {
4297+ c = JFFS2_SB_INFO(model_dentry->d_inode->i_sb);
4298+ //f = JFFS2_INODE_INFO(model_dentry->d_inode);
4299+ model_size = model_dentry->d_inode->i_size;
4300+ model_buff = jffs2_bbc_malloc(model_size);
4301+ model_file = dentry_open(model_dentry,NULL,O_RDONLY);
4302+ kernel_read(model_file,0,model_buff,model_size);
4303+ if (jffs2_bbc_model_new(c,model_dentry->d_inode->i_ino,model_buff) != 0) {
4304+ printk("already loaded.\n");
4305+ jffs2_bbc_free(model_buff);
4306+ }
4307+ else {
4308+ printk("done (%d bytes readed from inode %d).\n",model_size,(int)(model_dentry->d_inode->i_ino));
4309+ }
4310+ }
4311+ else {
4312+ printk("not found.\n");
4313+ }
4314+ dput(model_dentry);
4315+ }
4316+ prev_i = i+1;
4317+ }
4318+ }
4319+ }
4320+ }
4321+ dput(config_dentry);
4322+ if (buff != NULL) jffs2_bbc_free(buff);
4323+}
4324+
4325+void jffs2_bbc_unload_model(void *sb_par)
4326+{
4327+ struct jffs2_sb_info *c;
4328+ struct super_block *sb = sb_par;
4329+ struct jffs2_bbc_fs_sb_list *sb_l,*sb_l2;
4330+ int done = 0;
4331+
4332+ c = JFFS2_SB_INFO(sb);
4333+ jffs2_bbc_model_del(c);
4334+ if (sb_list == NULL) printk("jffs2.bbc: error! NULL sb list!\n");
4335+ else {
4336+ if (sb_list->sb == sb) {
4337+ jffs2_bbc_free_small(sb_list);
4338+ sb_list = NULL;
4339+ done = 1;
4340+ }
4341+ else {
4342+ sb_l = sb_list;
4343+ while (sb_l->next != NULL) {
4344+ if (sb_l->next->sb == sb) {
4345+ sb_l2 = sb_l->next->next;
4346+ jffs2_bbc_free_small(sb_l->next);
4347+ sb_l->next = sb_l2;
4348+ done = 1;
4349+ }
4350+ sb_l = sb_l->next;
4351+ }
4352+
4353+ }
4354+ if (done == 0) {
4355+ printk("jffs2.bbc: cannot delete sb from sblist!\n");
4356+ }
4357+ }
4358+}
4359+
4360+static int jffs2_bbc_get_mounted(void) {
4361+ struct jffs2_bbc_fs_sb_list *sb_l;
4362+ int num = 0;
4363+
4364+ sb_l = sb_list;
4365+ while (sb_l != NULL) {
4366+ num++;
4367+ sb_l = sb_l->next;
4368+ }
4369+ return num;
4370+
4371+}
4372+
4373+int jffs2_bbc_proc_read(char *buf, char **start, off_t offset, int count, int *eof, void *data)
4374+{
4375+ int len = 0, mode;
4376+
4377+ mode = jffs2_bbc_get_compression_mode();
4378+ len += sprintf(buf + len, "BBC version: %s\n", JFFS2_BBC_VERSION);
4379+ len += sprintf(buf+len,"Mounted jffs2 filesystems: %d\n",jffs2_bbc_get_mounted());
4380+ //len += sprintf(buf+len,"actual model file inode: %d\n",jffs2_bbc_model_get_inum());
4381+ len += sprintf(buf + len, "Compression mode: ");
4382+ if (mode == JFFS2_BBC_ZLIB_MODE)
4383+ len += sprintf(buf + len, "ZLIB mode");
4384+ else if (mode == JFFS2_BBC_SIZE_MODE)
4385+ len += sprintf(buf + len, "SIZE mode");
4386+ else if (mode == JFFS2_BBC_FASTR_MODE)
4387+ len += sprintf(buf + len, "FASTR mode");
4388+ else if (mode == JFFS2_BBC_FASTW_MODE)
4389+ len += sprintf(buf + len, "FASTW mode");
4390+ else if (mode == JFFS2_BBC_FASTS_MODE)
4391+ len += sprintf(buf + len, "FASTS mode");
4392+ else if (mode == JFFS2_BBC_DUMMY_MODE)
4393+ len += sprintf(buf + len, "DUMMY mode");
4394+ else if (mode == JFFS2_BBC_MANUAL_MODE) {
4395+ len += sprintf(buf + len, "MANUAL mode (");
4396+ if (jffs2_bbc_get_manual_compressor() != NULL)
4397+ len += sprintf(buf + len, "%s)", jffs2_bbc_get_manual_compressor()->name);
4398+ else
4399+ len += sprintf(buf + len, "ZLIB)");
4400+ }
4401+ else
4402+ len += sprintf(buf + len, "unknown mode");
4403+ len += sprintf(buf + len, "\n");
4404+ len += sprintf(buf + len, "%s", jffs2_bbc_get_compr_stats());
4405+ len += sprintf(buf + len, "%s", jffs2_bbc_get_model_stats());
4406+ len += sprintf(buf + len, "%s", jffs2_bbc_get_mem_stats());
4407+ *eof = 1;
4408+ return len;
4409+}
4410+
4411+int jffs2_bbc_proc_write(struct file *file, const char *buffer_orig, unsigned long count, void *data)
4412+{
4413+ char *buffer;
4414+ int i;
4415+ struct jffs2_bbc_fs_sb_list *sb_l;
4416+
4417+ if (buffer_orig == NULL) return 0;
4418+
4419+ buffer = jffs2_bbc_malloc(count+2);
4420+ for (i=0;i<count;i++) buffer[i]=buffer_orig[i];
4421+ buffer[count] = 0;
4422+ if ((*buffer == 'z') || (*buffer == 'Z')) {
4423+ jffs2_bbc_set_compression_mode(JFFS2_BBC_ZLIB_MODE);
4424+ jffs2_bbc_print1("jffs2.bbc: ZLIB compression mode activated.\n");
4425+ jffs2_bbc_free(buffer);
4426+ return count;
4427+ }
4428+ else if ((*buffer == 's') || (*buffer == 'S')) {
4429+ jffs2_bbc_set_compression_mode(JFFS2_BBC_SIZE_MODE);
4430+ jffs2_bbc_print1("jffs2.bbc: SIZE compression mode activated.\n");
4431+ jffs2_bbc_free(buffer);
4432+ return count;
4433+ }
4434+ else if ((*buffer == 'd') || (*buffer == 'D')) {
4435+ jffs2_bbc_set_compression_mode(JFFS2_BBC_DUMMY_MODE);
4436+ jffs2_bbc_print1("jffs2.bbc: DUMMY compression mode activated.\n");
4437+ jffs2_bbc_free(buffer);
4438+ return count;
4439+ }
4440+ else if (((*buffer == 'm') || (*buffer == 'M')) && (count >= 3) && (buffer[1] == ':')) {
4441+ jffs2_bbc_print1("jffs2.bbc: activating MANUAL mode.\n");
4442+ jffs2_bbc_set_manual_compressor_by_name(buffer + 2);
4443+ jffs2_bbc_free(buffer);
4444+ return count;
4445+ }
4446+ else if (((*buffer == '0')) && (count >= 3) && (buffer[1] == ':')) {
4447+ jffs2_bbc_print1("jffs2.bbc: disabling a compressor... ");
4448+ if (jffs2_bbc_disable_compressor_by_name(buffer + 2) == 0) {
4449+ jffs2_bbc_print1("done.\n");
4450+ }
4451+ else {
4452+ jffs2_bbc_print1("not found.\n");
4453+ }
4454+ jffs2_bbc_free(buffer);
4455+ return count;
4456+ }
4457+ else if (((*buffer == '1')) && (count >= 3) && (buffer[1] == ':')) {
4458+ jffs2_bbc_print1("jffs2.bbc: enabling a compressor... ");
4459+ if (jffs2_bbc_enable_compressor_by_name(buffer + 2) == 0) {
4460+ jffs2_bbc_print1("done.\n");
4461+ }
4462+ else {
4463+ jffs2_bbc_print1("not found.\n");
4464+ }
4465+ jffs2_bbc_free(buffer);
4466+ return count;
4467+ }
4468+ else if (((*buffer == 'c') || (*buffer == 'C')) && (count >= 3) && (buffer[1] == ':')) {
4469+ jffs2_bbc_compressor_command_by_name(buffer + 2);
4470+ jffs2_bbc_free(buffer);
4471+ return count;
4472+ }
4473+ else if ((*buffer == 'r') || (*buffer == 'R')) {
4474+ jffs2_bbc_print1("jffs2.bbc: reloading model files:\n");
4475+ sb_l = sb_list;
4476+ while (sb_l != NULL) {
4477+ jffs2_bbc_unload_model(sb_l->sb);
4478+ jffs2_bbc_load_model(sb_l->sb);
4479+ sb_l = sb_l->next;
4480+ }
4481+ jffs2_bbc_free(buffer);
4482+ return count;
4483+ }
4484+ else if (((buffer[0] == 'f') || (buffer[0] == 'F'))&&((buffer[1] == 'r') || (buffer[1] == 'R'))) {
4485+ jffs2_bbc_set_compression_mode(JFFS2_BBC_FASTR_MODE);
4486+ jffs2_bbc_print1("jffs2.bbc: FASTR compression mode activated.\n");
4487+ jffs2_bbc_free(buffer);
4488+ return count;
4489+ }
4490+ else if (((buffer[0] == 'f') || (buffer[0] == 'F'))&&((buffer[1] == 'w') || (buffer[1] == 'W'))) {
4491+ jffs2_bbc_set_compression_mode(JFFS2_BBC_FASTW_MODE);
4492+ jffs2_bbc_print1("jffs2.bbc: FASTW compression mode activated.\n");
4493+ jffs2_bbc_free(buffer);
4494+ return count;
4495+ }
4496+ else if (((buffer[0] == 'f') || (buffer[0] == 'F'))&&((buffer[1] == 's') || (buffer[1] == 'S'))) {
4497+ jffs2_bbc_set_compression_mode(JFFS2_BBC_FASTS_MODE);
4498+ jffs2_bbc_print1("jffs2.bbc: FASTS compression mode activated.\n");
4499+ jffs2_bbc_free(buffer);
4500+ return count;
4501+ }
4502+
4503+ jffs2_bbc_print1("jffs2.bbc: unkown command. Valid commands are:\n"
4504+ " z = switch to ZLIB compression mode\n"
4505+ " s = switch to SIZE compression mode\n"
4506+ " d = switch to DUMMY compression mode\n"
4507+ " fr = switch to FASTR compression mode\n"
4508+ " fw = switch to FASTW compression mode\n"
4509+ " fs = switch to FASTS compression mode\n"
4510+ " r = reread model files from actual file system\n"
4511+ " m:compressor_name = switch to MANUAL compression mode\n"
4512+ " 0:compressor_name = disable a compressor\n"
4513+ " 1:compressor_name = enable a compressor\n"
4514+ " c:compressor_name:command = enable a compressor\n");
4515+ jffs2_bbc_free(buffer);
4516+ return count;
4517+}
4518+
4519+void jffs2_bbc_proc_init()
4520+{
4521+ struct proc_dir_entry *res = create_proc_entry("jffs2_bbc", 0, NULL);
4522+ jffs2_bbc_compressor_init();
4523+ if (res) {
4524+ res->read_proc = jffs2_bbc_proc_read;
4525+ res->write_proc = jffs2_bbc_proc_write;
4526+ }
4527+}
4528+
4529+void jffs2_bbc_proc_deinit()
4530+{
4531+ jffs2_bbc_compressor_deinit();
4532+ remove_proc_entry("jffs2_bbc", NULL);
4533+}
4534--- /dev/null
4535+++ b/fs/jffs2/jffs2_bbc_fs.h
4536@@ -0,0 +1,30 @@
4537+/*
4538+ * JFFS2 BBC: File System Extension for Linux Kernel - headers
4539+ *
4540+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
4541+ *
4542+ * Copyright (C) 2004, Ferenc Havasi
4543+ *
4544+ * This program is free software; you can redistribute it and/or
4545+ * modify it under the terms of the GNU General Public License
4546+ * as published by the Free Software Foundation; either version 2
4547+ * of the License, or (at your option) any later version.
4548+ *
4549+ * This program is distributed in the hope that it will be useful,
4550+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
4551+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4552+ * GNU General Public License for more details.
4553+ *
4554+ * You should have received a copy of the GNU General Public License
4555+ * along with this program; if not, write to the Free Software
4556+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
4557+ *
4558+ */
4559+
4560+extern int jffs2_bbc_inode_not_found;
4561+
4562+void jffs2_bbc_load_model(void *sb);
4563+void jffs2_bbc_unload_model(void *sb);
4564+
4565+void jffs2_bbc_proc_init(void);
4566+void jffs2_bbc_proc_deinit(void);
4567--- /dev/null
4568+++ b/fs/jffs2/jffs2_bbc_lzari_comp.c
4569@@ -0,0 +1,788 @@
4570+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
4571+
4572+/*
4573+ jffs2_bbc_lzari_comp.c -- Lempel-Ziv-Arithmetic coding compression module for jffs2
4574+ Copyright (C) 2004 Patrik Kluba
4575+ Based on the LZARI source included in LDS (lossless datacompression sources)
4576+ Block-compression and bitstream modifications by Patrik Kluba
4577+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
4578+*/
4579+
4580+/*
4581+Original copyright follows:
4582+
4583+**************************************************************
4584+ LZARI.C -- A Data Compression Program
4585+ (tab = 4 spaces)
4586+**************************************************************
4587+ 4/7/1989 Haruhiko Okumura
4588+ Use, distribute, and modify this program freely.
4589+ Please send me your improved versions.
4590+ PC-VAN SCIENCE
4591+ NIFTY-Serve PAF01022
4592+ CompuServe 74050,1022
4593+**************************************************************
4594+
4595+LZARI.C (c)1989 by Haruyasu Yoshizaki, Haruhiko Okumura, and Kenji Rikitake.
4596+All rights reserved. Permission granted for non-commercial use.
4597+
4598+*/
4599+
4600+/*
4601+
4602+ 2004-02-18 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
4603+ Removed unused variables and fixed no return value
4604+
4605+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
4606+ Initial release
4607+
4608+*/
4609+
4610+/* lzari.c */
4611+
4612+#define N 4096 /* size of ring buffer */
4613+#define F 60 /* upper limit for match_length */
4614+#define THRESHOLD 2 /* encode string into position and length
4615+ if match_length is greater than this */
4616+#define NIL N /* index for root of binary search trees */
4617+
4618+static unsigned char
4619+ text_buf[N + F - 1]; /* ring buffer of size N,
4620+ with extra F-1 bytes to facilitate string comparison */
4621+static unsigned long match_position, match_length, /* of longest match. These are
4622+ set by the InsertNode() procedure. */
4623+ lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
4624+ parents -- These constitute binary search trees. */
4625+
4626+static void InitTree(void) /* Initialize trees */
4627+{
4628+ unsigned long i;
4629+
4630+ /* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
4631+ left children of node i. These nodes need not be initialized.
4632+ Also, dad[i] is the parent of node i. These are initialized to
4633+ NIL (= N), which stands for 'not used.'
4634+ For i = 0 to 255, rson[N + i + 1] is the root of the tree
4635+ for strings that begin with character i. These are initialized
4636+ to NIL. Note there are 256 trees. */
4637+
4638+ for (i = N + 1; i <= N + 256; i++) rson[i] = NIL; /* root */
4639+ for (i = 0; i < N; i++) dad[i] = NIL; /* node */
4640+}
4641+
4642+static void InsertNode(unsigned long r)
4643+ /* Inserts string of length F, text_buf[r..r+F-1], into one of the
4644+ trees (text_buf[r]'th tree) and returns the longest-match position
4645+ and length via the global variables match_position and match_length.
4646+ If match_length = F, then removes the old node in favor of the new
4647+ one, because the old one will be deleted sooner.
4648+ Note r plays double role, as tree node and position in buffer. */
4649+{
4650+ unsigned long i, p, temp;
4651+ unsigned char *key;
4652+ signed long cmp;
4653+
4654+ cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
4655+ rson[r] = lson[r] = NIL; match_length = 0;
4656+ for ( ; ; ) {
4657+ if (cmp >= 0) {
4658+ if (rson[p] != NIL) p = rson[p];
4659+ else { rson[p] = r; dad[r] = p; return; }
4660+ } else {
4661+ if (lson[p] != NIL) p = lson[p];
4662+ else { lson[p] = r; dad[r] = p; return; }
4663+ }
4664+ for (i = 1; i < F; i++)
4665+ if ((cmp = key[i] - text_buf[p + i]) != 0) break;
4666+ if (i > THRESHOLD) {
4667+ if (i > match_length) {
4668+ match_position = (r - p) & (N - 1);
4669+ if ((match_length = i) >= F) break;
4670+ } else if (i == match_length) {
4671+ if ((temp = (r - p) & (N - 1)) < match_position)
4672+ match_position = temp;
4673+ }
4674+ }
4675+ }
4676+ dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
4677+ dad[lson[p]] = r; dad[rson[p]] = r;
4678+ if (rson[dad[p]] == p) rson[dad[p]] = r;
4679+ else lson[dad[p]] = r;
4680+ dad[p] = NIL; /* remove p */
4681+}
4682+
4683+static void DeleteNode(unsigned long p) /* Delete node p from tree */
4684+{
4685+ unsigned long q;
4686+
4687+ if (dad[p] == NIL) return; /* not in tree */
4688+ if (rson[p] == NIL) q = lson[p];
4689+ else if (lson[p] == NIL) q = rson[p];
4690+ else {
4691+ q = lson[p];
4692+ if (rson[q] != NIL) {
4693+ do { q = rson[q]; } while (rson[q] != NIL);
4694+ rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
4695+ lson[q] = lson[p]; dad[lson[p]] = q;
4696+ }
4697+ rson[q] = rson[p]; dad[rson[p]] = q;
4698+ }
4699+ dad[q] = dad[p];
4700+ if (rson[dad[p]] == p) rson[dad[p]] = q;
4701+ else lson[dad[p]] = q;
4702+ dad[p] = NIL;
4703+}
4704+
4705+/********** Arithmetic Compression **********/
4706+
4707+/* If you are not familiar with arithmetic compression, you should read
4708+ I. E. Witten, R. M. Neal, and J. G. Cleary,
4709+ Communications of the ACM, Vol. 30, pp. 520-540 (1987),
4710+ from which much have been borrowed. */
4711+
4712+#define M 15
4713+
4714+/* Q1 (= 2 to the M) must be sufficiently large, but not so
4715+ large as the unsigned long 4 * Q1 * (Q1 - 1) overflows. */
4716+
4717+#define Q1 (1UL << M)
4718+#define Q2 (2 * Q1)
4719+#define Q3 (3 * Q1)
4720+#define Q4 (4 * Q1)
4721+#define MAX_CUM (Q1 - 1)
4722+
4723+#define N_CHAR (256 - THRESHOLD + F)
4724+ /* character code = 0, 1, ..., N_CHAR - 1 */
4725+
4726+static unsigned long char_to_sym[N_CHAR], sym_to_char[N_CHAR + 1];
4727+static unsigned long
4728+ sym_freq[N_CHAR + 1], /* frequency for symbols */
4729+ sym_cum[N_CHAR + 1], /* cumulative freq for symbols */
4730+ position_cum[N + 1]; /* cumulative freq for positions */
4731+
4732+static void StartModel(void) /* Initialize model */
4733+{
4734+ unsigned long ch, sym, i;
4735+
4736+ sym_cum[N_CHAR] = 0;
4737+ for (sym = N_CHAR; sym >= 1; sym--) {
4738+ ch = sym - 1;
4739+ char_to_sym[ch] = sym; sym_to_char[sym] = ch;
4740+ sym_freq[sym] = 1;
4741+ sym_cum[sym - 1] = sym_cum[sym] + sym_freq[sym];
4742+ }
4743+ sym_freq[0] = 0; /* sentinel (!= sym_freq[1]) */
4744+ position_cum[N] = 0;
4745+ for (i = N; i >= 1; i--)
4746+ position_cum[i - 1] = position_cum[i] + 10000 / (i + 200);
4747+ /* empirical distribution function (quite tentative) */
4748+ /* Please devise a better mechanism! */
4749+}
4750+
4751+static void UpdateModel(unsigned long sym)
4752+{
4753+ unsigned long c, ch_i, ch_sym;
4754+ unsigned long i;
4755+ if (sym_cum[0] >= MAX_CUM) {
4756+ c = 0;
4757+ for (i = N_CHAR; i > 0; i--) {
4758+ sym_cum[i] = c;
4759+ c += (sym_freq[i] = (sym_freq[i] + 1) >> 1);
4760+ }
4761+ sym_cum[0] = c;
4762+ }
4763+ for (i = sym; sym_freq[i] == sym_freq[i - 1]; i--) ;
4764+ if (i < sym) {
4765+ ch_i = sym_to_char[i]; ch_sym = sym_to_char[sym];
4766+ sym_to_char[i] = ch_sym; sym_to_char[sym] = ch_i;
4767+ char_to_sym[ch_i] = sym; char_to_sym[ch_sym] = i;
4768+ }
4769+ sym_freq[i]++;
4770+ while (--i > 0) sym_cum[i]++;
4771+ sym_cum[0]++;
4772+}
4773+
4774+static unsigned long BinarySearchSym(unsigned long x)
4775+ /* 1 if x >= sym_cum[1],
4776+ N_CHAR if sym_cum[N_CHAR] > x,
4777+ i such that sym_cum[i - 1] > x >= sym_cum[i] otherwise */
4778+{
4779+ unsigned long i, j, k;
4780+
4781+ i = 1; j = N_CHAR;
4782+ while (i < j) {
4783+ k = (i + j) / 2;
4784+ if (sym_cum[k] > x) i = k + 1; else j = k;
4785+ }
4786+ return i;
4787+}
4788+
4789+unsigned long BinarySearchPos(unsigned long x)
4790+ /* 0 if x >= position_cum[1],
4791+ N - 1 if position_cum[N] > x,
4792+ i such that position_cum[i] > x >= position_cum[i + 1] otherwise */
4793+{
4794+ unsigned long i, j, k;
4795+
4796+ i = 1; j = N;
4797+ while (i < j) {
4798+ k = (i + j) / 2;
4799+ if (position_cum[k] > x) i = k + 1; else j = k;
4800+ }
4801+ return i - 1;
4802+}
4803+
4804+/* modified for block compression */
4805+/* on return, srclen will contain the number of successfully compressed bytes
4806+ and dstlen will contain completed compressed bytes */
4807+
4808+static int Encode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long *srclen,
4809+ unsigned long *dstlen)
4810+{
4811+ unsigned long c, i, len, r, s, last_match_length, sym, range;
4812+ unsigned long low = 0;
4813+ unsigned long high = Q4;
4814+ unsigned long shifts = 0; /* counts for magnifying low and high around Q2 */
4815+ unsigned char *ip, *op;
4816+ unsigned long written = 0;
4817+ unsigned long read = 0;
4818+ unsigned char buffer = 0;
4819+ unsigned char mask = 128;
4820+ unsigned char *srcend = srcbuf + *srclen;
4821+ unsigned char *dstend = dstbuf + *dstlen;
4822+ ip = srcbuf;
4823+ op = dstbuf;
4824+ StartModel();
4825+ InitTree(); /* initialize trees */
4826+ s = 0; r = N - F;
4827+ for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
4828+ any character that will appear often. */
4829+ for (len = 0; (len < F) && (ip < srcend); len++)
4830+ text_buf[r + len] = *(ip++); /* Read F bytes into the last F bytes of
4831+ the buffer */
4832+ read = len;
4833+ for (i = 1; i <= F; i++) InsertNode(r - i); /* Insert the F strings,
4834+ each of which begins with one or more 'space' characters. Note
4835+ the order in which these strings are inserted. This way,
4836+ degenerate trees will be less likely to occur. */
4837+ InsertNode(r); /* Finally, insert the whole string just read. The
4838+ global variables match_length and match_position are set. */
4839+ do {
4840+ if (match_length > len) match_length = len; /* match_length
4841+ may be spuriously long near the end of text. */
4842+ if (match_length <= THRESHOLD) {
4843+ match_length = 1; /* Not long enough match. Send one byte. */
4844+ sym = char_to_sym[text_buf[r]];
4845+ range = high - low;
4846+ high = low + (range * sym_cum[sym - 1]) / sym_cum[0];
4847+ low += (range * sym_cum[sym ]) / sym_cum[0];
4848+ for ( ; ; ) {
4849+ if (high <= Q2) {
4850+ if ((mask >>= 1) == 0) {
4851+ if (op >= dstend) {
4852+ *dstlen = written;
4853+ return -1;
4854+ }
4855+ *(op++) = buffer;
4856+ buffer = 0;
4857+ mask = 128;
4858+ written++;
4859+ *srclen = read;
4860+ }
4861+ for ( ; shifts > 0; shifts--) {
4862+ buffer |= mask;
4863+ if ((mask >>= 1) == 0) {
4864+ if (op >= dstend) {
4865+ *dstlen = written;
4866+ return -1;
4867+ }
4868+ *(op++) = buffer;
4869+ buffer = 0;
4870+ mask = 128;
4871+ written++;
4872+ *srclen = read;
4873+ }
4874+ }
4875+ } else if (low >= Q2) {
4876+ buffer |= mask;
4877+ if ((mask >>= 1) == 0) {
4878+ if (op >= dstend) {
4879+ *dstlen = written;
4880+ return -1;
4881+ }
4882+ *(op++) = buffer;
4883+ buffer = 0;
4884+ mask = 128;
4885+ written++;
4886+ *srclen = read;
4887+ }
4888+ for ( ; shifts > 0; shifts--) {
4889+ if ((mask >>= 1) == 0) {
4890+ if (op >= dstend) {
4891+ *dstlen = written;
4892+ return -1;
4893+ }
4894+ *(op++) = buffer;
4895+ buffer = 0;
4896+ mask = 128;
4897+ written++;
4898+ *srclen = read;
4899+ }
4900+ }
4901+ low -= Q2;
4902+ high -= Q2;
4903+ } else if (low >= Q1 && high <= Q3) {
4904+ shifts++;
4905+ low -= Q1;
4906+ high -= Q1;
4907+ } else break;
4908+ low += low; high += high;
4909+ }
4910+ UpdateModel(sym);
4911+ } else {
4912+ sym = char_to_sym[255 - THRESHOLD + match_length];
4913+ range = high - low;
4914+ high = low + (range * sym_cum[sym - 1]) / sym_cum[0];
4915+ low += (range * sym_cum[sym ]) / sym_cum[0];
4916+ for ( ; ; ) {
4917+ if (high <= Q2) {
4918+ if ((mask >>= 1) == 0) {
4919+ if (op >= dstend) {
4920+ *dstlen = written;
4921+ return -1;
4922+ }
4923+ *(op++) = buffer;
4924+ buffer = 0;
4925+ mask = 128;
4926+ written++;
4927+ *srclen = read;
4928+ }
4929+ for ( ; shifts > 0; shifts--) {
4930+ buffer |= mask;
4931+ if ((mask >>= 1) == 0) {
4932+ if (op >= dstend) {
4933+ *dstlen = written;
4934+ return -1;
4935+ }
4936+ *(op++) = buffer;
4937+ buffer = 0;
4938+ mask = 128;
4939+ written++;
4940+ *srclen = read;
4941+ }
4942+ }
4943+ } else if (low >= Q2) {
4944+ buffer |= mask;
4945+ if ((mask >>= 1) == 0) {
4946+ if (op >= dstend) {
4947+ *dstlen = written;
4948+ return -1;
4949+ }
4950+ *(op++) = buffer;
4951+ buffer = 0;
4952+ mask = 128;
4953+ written++;
4954+ *srclen = read;
4955+ }
4956+ for ( ; shifts > 0; shifts--) {
4957+ if ((mask >>= 1) == 0) {
4958+ if (op >= dstend) {
4959+ *dstlen = written;
4960+ return -1;
4961+ }
4962+ *(op++) = buffer;
4963+ buffer = 0;
4964+ mask = 128;
4965+ written++;
4966+ *srclen = read;
4967+ }
4968+ }
4969+ low -= Q2;
4970+ high -= Q2;
4971+ } else if (low >= Q1 && high <= Q3) {
4972+ shifts++;
4973+ low -= Q1;
4974+ high -= Q1;
4975+ } else break;
4976+ low += low; high += high;
4977+ }
4978+ UpdateModel(sym);
4979+ range = high - low;
4980+ high = low + (range * position_cum[match_position - 1]) / position_cum[0];
4981+ low += (range * position_cum[match_position ]) / position_cum[0];
4982+ for ( ; ; ) {
4983+ if (high <= Q2) {
4984+ if ((mask >>= 1) == 0) {
4985+ if (op >= dstend) {
4986+ *dstlen = written;
4987+ return -1;
4988+ }
4989+ *(op++) = buffer;
4990+ buffer = 0;
4991+ mask = 128;
4992+ written++;
4993+ *srclen = read;
4994+ }
4995+ for ( ; shifts > 0; shifts--) {
4996+ buffer |= mask;
4997+ if ((mask >>= 1) == 0) {
4998+ if (op >= dstend) {
4999+ *dstlen = written;
5000+ return -1;
5001+ }
5002+ *(op++) = buffer;
5003+ buffer = 0;
5004+ mask = 128;
5005+ written++;
5006+ *srclen = read;
5007+ }
5008+ }
5009+ } else {
5010+ if (low >= Q2) {
5011+ buffer |= mask;
5012+ if ((mask >>= 1) == 0) {
5013+ if (op >= dstend) {
5014+ *dstlen = written;
5015+ return -1;
5016+ }
5017+ *(op++) = buffer;
5018+ buffer = 0;
5019+ mask = 128;
5020+ written++;
5021+ *srclen = read;
5022+ }
5023+ for ( ; shifts > 0; shifts--) {
5024+ if ((mask >>= 1) == 0) {
5025+ if (op >= dstend) {
5026+ *dstlen = written;
5027+ return -1;
5028+ }
5029+ *(op++) = buffer;
5030+ buffer = 0;
5031+ mask = 128;
5032+ written++;
5033+ *srclen = read;
5034+ }
5035+ }
5036+ low -= Q2;
5037+ high -= Q2;
5038+ } else {
5039+ if ((low >= Q1) && (high <= Q3)) {
5040+ shifts++;
5041+ low -= Q1;
5042+ high -= Q1;
5043+ } else {
5044+ break;
5045+ }
5046+ }
5047+ }
5048+ low += low;
5049+ high += high;
5050+ }
5051+ }
5052+ last_match_length = match_length;
5053+ for (i = 0; (i < last_match_length) && (ip < srcend); i++) {
5054+ c = *(ip++);
5055+ DeleteNode(s);
5056+ text_buf[s] = c;
5057+ if (s < F - 1)
5058+ text_buf[s + N] = c;
5059+ s = (s + 1) & (N - 1);
5060+ r = (r + 1) & (N - 1);
5061+ InsertNode(r);
5062+ }
5063+ read += i;
5064+ while (i++ < last_match_length) {
5065+ DeleteNode(s);
5066+ s = (s + 1) & (N - 1);
5067+ r = (r + 1) & (N - 1);
5068+ if (--len) InsertNode(r);
5069+ }
5070+ } while (len > 0);
5071+ shifts++;
5072+ if (low < Q1) {
5073+ if ((mask >>= 1) == 0) {
5074+ if (op >= dstend) {
5075+ *dstlen = written;
5076+ return -1;
5077+ }
5078+ *(op++) = buffer;
5079+ buffer = 0;
5080+ mask = 128;
5081+ written++;
5082+ *srclen = read;
5083+ }
5084+ for ( ; shifts > 0; shifts--) {
5085+ buffer |= mask;
5086+ if ((mask >>= 1) == 0) {
5087+ if (op >= dstend) {
5088+ *dstlen = written;
5089+ return -1;
5090+ }
5091+ *(op++) = buffer;
5092+ buffer = 0;
5093+ mask = 128;
5094+ written++;
5095+ *srclen = read;
5096+ }
5097+ }
5098+ } else {
5099+ buffer |= mask;
5100+ if ((mask >>= 1) == 0) {
5101+ if (op >= dstend) {
5102+ *dstlen = written;
5103+ return -1;
5104+ }
5105+ *(op++) = buffer;
5106+ buffer = 0;
5107+ mask = 128;
5108+ written++;
5109+ *srclen = read;
5110+ }
5111+ for ( ; shifts > 0; shifts--) {
5112+ if ((mask >>= 1) == 0) {
5113+ if (op >= dstend) {
5114+ *dstlen = written;
5115+ return -1;
5116+ }
5117+ *(op++) = buffer;
5118+ buffer = 0;
5119+ mask = 128;
5120+ written++;
5121+ *srclen = read;
5122+ }
5123+ }
5124+ }
5125+ for (i = 0; i < 7; i++) {
5126+ if ((mask >>= 1) == 0) {
5127+ if (op >= dstend) {
5128+ *dstlen = written;
5129+ return -1;
5130+ }
5131+ *(op++) = buffer;
5132+ buffer = 0;
5133+ mask = 128;
5134+ written++;
5135+ *srclen = read;
5136+ }
5137+ }
5138+ *dstlen = written;
5139+ return 0;
5140+}
5141+
5142+static int Decode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long srclen,
5143+ unsigned long dstlen) /* Just the reverse of Encode(). */
5144+{
5145+ unsigned long i, r, j, k, c, range, sym;
5146+ unsigned char *ip, *op;
5147+ unsigned char *srcend = srcbuf + srclen;
5148+ unsigned char *dstend = dstbuf + dstlen;
5149+ unsigned char buffer = 0;
5150+ unsigned char mask = 0;
5151+ unsigned long low = 0;
5152+ unsigned long high = Q4;
5153+ unsigned long value = 0;
5154+ ip = srcbuf;
5155+ op = dstbuf;
5156+ for (i = 0; i < M + 2; i++) {
5157+ value *= 2;
5158+ if ((mask >>= 1) == 0) {
5159+ buffer = (ip >= srcend) ? 0 : *(ip++);
5160+ mask = 128;
5161+ }
5162+ value += ((buffer & mask) != 0);
5163+ }
5164+ StartModel();
5165+ for (i = 0; i < N - F; i++) text_buf[i] = ' ';
5166+ r = N - F;
5167+ while (op < dstend) {
5168+ range = high - low;
5169+ sym = BinarySearchSym((unsigned long)
5170+ (((value - low + 1) * sym_cum[0] - 1) / range));
5171+ high = low + (range * sym_cum[sym - 1]) / sym_cum[0];
5172+ low += (range * sym_cum[sym ]) / sym_cum[0];
5173+ for ( ; ; ) {
5174+ if (low >= Q2) {
5175+ value -= Q2; low -= Q2; high -= Q2;
5176+ } else if (low >= Q1 && high <= Q3) {
5177+ value -= Q1; low -= Q1; high -= Q1;
5178+ } else if (high > Q2) break;
5179+ low += low; high += high;
5180+ value *= 2;
5181+ if ((mask >>= 1) == 0) {
5182+ buffer = (ip >= srcend) ? 0 : *(ip++);
5183+ mask = 128;
5184+ }
5185+ value += ((buffer & mask) != 0);
5186+ }
5187+ c = sym_to_char[sym];
5188+ UpdateModel(sym);
5189+ if (c < 256) {
5190+ if (op >= dstend) return -1;
5191+ *(op++) = c;
5192+ text_buf[r++] = c;
5193+ r &= (N - 1);
5194+ } else {
5195+ j = c - 255 + THRESHOLD;
5196+ range = high - low;
5197+ i = BinarySearchPos((unsigned long)
5198+ (((value - low + 1) * position_cum[0] - 1) / range));
5199+ high = low + (range * position_cum[i ]) / position_cum[0];
5200+ low += (range * position_cum[i + 1]) / position_cum[0];
5201+ for ( ; ; ) {
5202+ if (low >= Q2) {
5203+ value -= Q2; low -= Q2; high -= Q2;
5204+ } else if (low >= Q1 && high <= Q3) {
5205+ value -= Q1; low -= Q1; high -= Q1;
5206+ } else if (high > Q2) break;
5207+ low += low; high += high;
5208+ value *= 2;
5209+ if ((mask >>= 1) == 0) {
5210+ buffer = (ip >= srcend) ? 0 : *(ip++);
5211+ mask = 128;
5212+ }
5213+ value += ((buffer & mask) != 0);
5214+ }
5215+ i = (r - i - 1) & (N - 1);
5216+ for (k = 0; k < j; k++) {
5217+ c = text_buf[(i + k) & (N - 1)];
5218+ if (op >= dstend) return -1;
5219+ *(op++) = c;
5220+ text_buf[r++] = c;
5221+ r &= (N - 1);
5222+ }
5223+ }
5224+ }
5225+ return 0;
5226+}
5227+
5228+/* interface to jffs2 bbc follows */
5229+
5230+#include "jffs2_bbc_framework.h"
5231+
5232+#define JFFS2_BBC_LZARI_BLOCK_SIGN {0x73, 0x9a, 0x1c, 0x4d}
5233+
5234+static int
5235+jffs2_bbc_lzari_compressor_init (void);
5236+
5237+static void
5238+jffs2_bbc_lzari_compressor_deinit (void);
5239+
5240+static int
5241+jffs2_bbc_lzari_compress (void *model, unsigned char *input,
5242+ unsigned char *output, unsigned long *sourcelen,
5243+ unsigned long *dstlen);
5244+
5245+static int
5246+jffs2_bbc_lzari_estimate (void *model, unsigned char *input,
5247+ unsigned long sourcelen, unsigned long *dstlen,
5248+ unsigned long *readtime, unsigned long *writetime);
5249+
5250+static int
5251+jffs2_bbc_lzari_decompress (void *model, unsigned char *input,
5252+ unsigned char *output, unsigned long sourcelen,
5253+ unsigned long dstlen);
5254+
5255+static char *
5256+jffs2_bbc_lzari_proc_info (void);
5257+
5258+static int
5259+jffs2_bbc_lzari_proc_command (char *command);
5260+
5261+struct jffs2_bbc_compressor_type jffs2_bbc_lzari = {
5262+ "lzari",
5263+ 0,
5264+ JFFS2_BBC_LZARI_BLOCK_SIGN,
5265+ jffs2_bbc_lzari_compressor_init,
5266+ NULL,
5267+ NULL,
5268+ jffs2_bbc_lzari_compressor_deinit,
5269+ jffs2_bbc_lzari_compress,
5270+ jffs2_bbc_lzari_estimate,
5271+ jffs2_bbc_lzari_decompress,
5272+ jffs2_bbc_lzari_proc_info,
5273+ jffs2_bbc_lzari_proc_command
5274+};
5275+
5276+static int
5277+jffs2_bbc_lzari_compressor_init (void)
5278+{
5279+ return 0;
5280+}
5281+
5282+static void
5283+jffs2_bbc_lzari_compressor_deinit (void)
5284+{
5285+}
5286+
5287+static int
5288+jffs2_bbc_lzari_compress (void *model, unsigned char *input,
5289+ unsigned char *output, unsigned long *sourcelen,
5290+ unsigned long *dstlen)
5291+{
5292+ int retval;
5293+ unsigned long dst = *dstlen;
5294+ *(output++) = jffs2_bbc_lzari.block_sign[0];
5295+ *(output++) = jffs2_bbc_lzari.block_sign[1];
5296+ dst -= 2;
5297+ retval = Encode(input, output, sourcelen, &dst);
5298+ dst += 2;
5299+ *dstlen = dst;
5300+ return retval;
5301+}
5302+
5303+static int
5304+jffs2_bbc_lzari_estimate (void *model, unsigned char *input,
5305+ unsigned long sourcelen, unsigned long *dstlen,
5306+ unsigned long *readtime, unsigned long *writetime)
5307+{
5308+ *dstlen = sourcelen / 2;
5309+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 15;
5310+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 7;
5311+ return 0;
5312+}
5313+
5314+static int
5315+jffs2_bbc_lzari_decompress (void *model, unsigned char *input,
5316+ unsigned char *output, unsigned long sourcelen,
5317+ unsigned long dstlen)
5318+{
5319+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzari.block_sign[0] ) ||
5320+ ( *(input++) != (unsigned char)jffs2_bbc_lzari.block_sign[1] )
5321+ ) {
5322+ return -1;
5323+ } else {
5324+ return Decode(input, output, sourcelen - 2, dstlen);
5325+ }
5326+}
5327+
5328+static char *
5329+jffs2_bbc_lzari_proc_info (void)
5330+{
5331+ return "Lempel-Ziv-Arithmetic coding compression module";
5332+}
5333+
5334+static int
5335+jffs2_bbc_lzari_proc_command (char *command)
5336+{
5337+ return 0;
5338+}
5339+
5340+struct jffs2_bbc_compressor_type *
5341+jffs2_bbc_lzari_init (int mode)
5342+{
5343+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzari) == 0)
5344+ {
5345+ return &jffs2_bbc_lzari;
5346+ }
5347+ else
5348+ {
5349+ return NULL;
5350+ }
5351+}
5352+
5353+void
5354+jffs2_bbc_lzari_deinit (void)
5355+{
5356+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzari);
5357+}
5358--- /dev/null
5359+++ b/fs/jffs2/jffs2_bbc_lzhd_comp.c
5360@@ -0,0 +1,747 @@
5361+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
5362+
5363+/*
5364+ jffs2_bbc_lzhd_comp.c -- Lempel-Ziv-(dynamic) Huffman compression module for jffs2
5365+ Copyright (C) 2004 Patrik Kluba
5366+ Based on the LZHUF source included in LDS (lossless datacompression sources)
5367+ Block-compression and bitstream modifications by Patrik Kluba
5368+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
5369+*/
5370+
5371+/*
5372+Original copyright follows:
5373+
5374+**************************************************************
5375+ lzhuf.c
5376+ written by Haruyasu Yoshizaki 11/20/1988
5377+ some minor changes 4/6/1989
5378+ comments translated by Haruhiko Okumura 4/7/1989
5379+**************************************************************
5380+
5381+LZHUF.C (c)1989 by Haruyasu Yoshizaki, Haruhiko Okumura, and Kenji Rikitake.
5382+All rights reserved. Permission granted for non-commercial use.
5383+
5384+*/
5385+
5386+/*
5387+
5388+ 2004-02-18 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
5389+ Replaced name lzh-d with lzhd
5390+ Fixed no return value
5391+
5392+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
5393+ Initial release
5394+
5395+*/
5396+
5397+/* required because of memmove */
5398+#ifndef __KERNEL__
5399+ #include <string.h>
5400+#else
5401+ #include <linux/string.h>
5402+#endif
5403+
5404+/* lzhuf.c */
5405+
5406+#define N 4096 /* size of ring buffer */
5407+#define F 60 /* upper limit for match_length */
5408+#define THRESHOLD 2 /* encode string into position and length
5409+ if match_length is greater than this */
5410+#define NIL N /* index for root of binary search trees */
5411+
5412+static unsigned char
5413+ text_buf[N + F - 1]; /* ring buffer of size N,
5414+ with extra F-1 bytes to facilitate string comparison */
5415+static unsigned long match_position, match_length, /* of longest match. These are
5416+ set by the InsertNode() procedure. */
5417+ lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
5418+ parents -- These constitute binary search trees. */
5419+
5420+static void InitTree(void) /* initialize trees */
5421+{
5422+ unsigned long i;
5423+
5424+ /* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
5425+ left children of node i. These nodes need not be initialized.
5426+ Also, dad[i] is the parent of node i. These are initialized to
5427+ NIL (= N), which stands for 'not used.'
5428+ For i = 0 to 255, rson[N + i + 1] is the root of the tree
5429+ for strings that begin with character i. These are initialized
5430+ to NIL. Note there are 256 trees. */
5431+
5432+ for (i = N + 1; i <= N + 256; i++) rson[i] = NIL;
5433+ for (i = 0; i < N; i++) dad[i] = NIL;
5434+}
5435+
5436+static void InsertNode(unsigned long r)
5437+ /* Inserts string of length F, text_buf[r..r+F-1], into one of the
5438+ trees (text_buf[r]'th tree) and returns the longest-match position
5439+ and length via the global variables match_position and match_length.
5440+ If match_length = F, then removes the old node in favor of the new
5441+ one, because the old one will be deleted sooner.
5442+ Note r plays double role, as tree node and position in buffer. */
5443+{
5444+ unsigned long i, p, c;
5445+ signed long cmp;
5446+ unsigned char *key;
5447+
5448+ cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
5449+ rson[r] = lson[r] = NIL; match_length = 0;
5450+ for ( ; ; ) {
5451+ if (cmp >= 0) {
5452+ if (rson[p] != NIL) p = rson[p];
5453+ else { rson[p] = r; dad[r] = p; return; }
5454+ } else {
5455+ if (lson[p] != NIL) p = lson[p];
5456+ else { lson[p] = r; dad[r] = p; return; }
5457+ }
5458+ for (i = 1; i < F; i++)
5459+ if ((cmp = key[i] - text_buf[p + i]) != 0) break;
5460+ if (i > THRESHOLD) {
5461+ if (i > match_length) {
5462+ match_position = ((r - p) & (N - 1)) - 1;
5463+ if ((match_length = i) >= F) break;
5464+ }
5465+ if (i == match_length) {
5466+ if ((c = ((r - p) & (N - 1)) - 1) < match_position) {
5467+ match_position = c;
5468+ }
5469+ }
5470+ }
5471+ }
5472+ dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
5473+ dad[lson[p]] = r; dad[rson[p]] = r;
5474+ if (rson[dad[p]] == p) rson[dad[p]] = r;
5475+ else lson[dad[p]] = r;
5476+ dad[p] = NIL; /* remove p */
5477+}
5478+
5479+static void DeleteNode(unsigned long p) /* deletes node p from tree */
5480+{
5481+ unsigned long q;
5482+
5483+ if (dad[p] == NIL) return; /* not in tree */
5484+ if (rson[p] == NIL) q = lson[p];
5485+ else if (lson[p] == NIL) q = rson[p];
5486+ else {
5487+ q = lson[p];
5488+ if (rson[q] != NIL) {
5489+ do { q = rson[q]; } while (rson[q] != NIL);
5490+ rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
5491+ lson[q] = lson[p]; dad[lson[p]] = q;
5492+ }
5493+ rson[q] = rson[p]; dad[rson[p]] = q;
5494+ }
5495+ dad[q] = dad[p];
5496+ if (rson[dad[p]] == p) rson[dad[p]] = q; else lson[dad[p]] = q;
5497+ dad[p] = NIL;
5498+}
5499+
5500+/* Huffman coding */
5501+
5502+#define N_CHAR (256 - THRESHOLD + F)
5503+ /* kinds of characters (character code = 0..N_CHAR-1) */
5504+#define T (N_CHAR * 2 - 1) /* size of table */
5505+#define R (T - 1) /* position of root */
5506+#define MAX_FREQ 0x8000 /* updates tree when the */
5507+ /* root frequency comes to this value. */
5508+
5509+typedef unsigned long uchar; // much-much faster
5510+
5511+/* table for encoding and decoding the upper 6 bits of position */
5512+
5513+/* for encoding */
5514+static uchar p_len[64] = {
5515+ 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
5516+ 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06,
5517+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5518+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5519+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5520+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5521+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
5522+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
5523+};
5524+
5525+static uchar p_code[64] = {
5526+ 0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x68,
5527+ 0x70, 0x78, 0x80, 0x88, 0x90, 0x94, 0x98, 0x9C,
5528+ 0xA0, 0xA4, 0xA8, 0xAC, 0xB0, 0xB4, 0xB8, 0xBC,
5529+ 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE,
5530+ 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE,
5531+ 0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE,
5532+ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
5533+ 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
5534+};
5535+
5536+/* for decoding */
5537+static uchar d_code[256] = {
5538+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5539+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5540+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5541+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5542+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
5543+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
5544+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
5545+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
5546+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
5547+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
5548+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5549+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5550+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5551+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5552+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
5553+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
5554+ 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
5555+ 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
5556+ 0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
5557+ 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
5558+ 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
5559+ 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
5560+ 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
5561+ 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
5562+ 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B,
5563+ 0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F,
5564+ 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23,
5565+ 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
5566+ 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B,
5567+ 0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F,
5568+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
5569+ 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
5570+};
5571+
5572+static uchar d_len[256] = {
5573+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
5574+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
5575+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
5576+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
5577+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5578+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5579+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5580+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5581+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5582+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
5583+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5584+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5585+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5586+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5587+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5588+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5589+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5590+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
5591+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5592+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5593+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5594+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5595+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5596+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
5597+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5598+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5599+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5600+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5601+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5602+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
5603+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
5604+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
5605+};
5606+
5607+static unsigned long freq[T + 1]; /* frequency table */
5608+
5609+static unsigned long prnt[T + N_CHAR]; /* pointers to parent nodes, except for the */
5610+ /* elements [T..T + N_CHAR - 1] which are used to get */
5611+ /* the positions of leaves corresponding to the codes. */
5612+
5613+static unsigned long son[T]; /* pointers to child nodes (son[], son[] + 1) */
5614+
5615+/* initialization of tree */
5616+
5617+static void StartHuff(void)
5618+{
5619+ unsigned long i, j;
5620+
5621+ for (i = 0; i < N_CHAR; i++) {
5622+ freq[i] = 1;
5623+ son[i] = i + T;
5624+ prnt[i + T] = i;
5625+ }
5626+ i = 0; j = N_CHAR;
5627+ while (j <= R) {
5628+ freq[j] = freq[i] + freq[i + 1];
5629+ son[j] = i;
5630+ prnt[i] = prnt[i + 1] = j;
5631+ i += 2; j++;
5632+ }
5633+ freq[T] = 0xffff;
5634+ prnt[R] = 0;
5635+}
5636+
5637+/* reconstruction of tree */
5638+
5639+static void reconst(void)
5640+{
5641+ unsigned long f, l, i, j, k;
5642+
5643+ /* collect leaf nodes in the first half of the table */
5644+ /* and replace the freq by (freq + 1) / 2. */
5645+ j = 0;
5646+ for (i = 0; i < T; i++) {
5647+ if (son[i] >= T) {
5648+ freq[j] = (freq[i] + 1) / 2;
5649+ son[j] = son[i];
5650+ j++;
5651+ }
5652+ }
5653+ /* begin constructing tree by connecting sons */
5654+ for (i = 0, j = N_CHAR; j < T; i += 2, j++) {
5655+ k = i + 1;
5656+ f = freq[j] = freq[i] + freq[k];
5657+ for (k = j - 1; f < freq[k]; k--);
5658+ k++;
5659+ l = (j - k) * 2;
5660+ memmove(&freq[k + 1], &freq[k], l*sizeof(unsigned long));
5661+ freq[k] = f;
5662+ memmove(&son[k + 1], &son[k], l*sizeof(unsigned long));
5663+ son[k] = i;
5664+ }
5665+ /* connect prnt */
5666+ for (i = 0; i < T; i++) {
5667+ if ((k = son[i]) >= T) {
5668+ prnt[k] = i;
5669+ } else {
5670+ prnt[k] = prnt[k + 1] = i;
5671+ }
5672+ }
5673+}
5674+
5675+/* increment frequency of given code by one, and update tree */
5676+
5677+static void update(unsigned long c)
5678+{
5679+ unsigned long i, j, k, l;
5680+
5681+ if (freq[R] == MAX_FREQ) {
5682+ reconst();
5683+ }
5684+ c = prnt[c + T];
5685+ do {
5686+ k = ++freq[c];
5687+
5688+ /* if the order is disturbed, exchange nodes */
5689+ if (k > freq[l = c + 1]) {
5690+ while (k > freq[++l]);
5691+ l--;
5692+ freq[c] = freq[l];
5693+ freq[l] = k;
5694+
5695+ i = son[c];
5696+ prnt[i] = l;
5697+ if (i < T) prnt[i + 1] = l;
5698+
5699+ j = son[l];
5700+ son[l] = i;
5701+
5702+ prnt[j] = c;
5703+ if (j < T) prnt[j + 1] = c;
5704+ son[c] = j;
5705+
5706+ c = l;
5707+ }
5708+ } while (c = prnt[c]); /* repeat up to root */
5709+}
5710+
5711+/* modified for block compression */
5712+/* on return, srclen will contain the number of successfully compressed bytes
5713+ and dstlen will contain completed compressed bytes */
5714+
5715+static int Encode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long *srclen,
5716+ unsigned long *dstlen)
5717+{
5718+ unsigned long c, i, j, k, len, r, s, last_match_length, code_buf_ptr;
5719+ unsigned char code_buf[17], mask;
5720+ unsigned char *ip, *op;
5721+ unsigned long written = 0;
5722+ unsigned long read = 0;
5723+ unsigned short putbuf = 0;
5724+ uchar putlen = 0;
5725+ unsigned char *srcend = srcbuf + *srclen;
5726+ unsigned char *dstend = dstbuf + *dstlen;
5727+ ip = srcbuf;
5728+ op = dstbuf;
5729+ StartHuff();
5730+ InitTree(); /* initialize trees */
5731+ code_buf[0] = 0; /* code_buf[1..16] saves eight units of code, and
5732+ code_buf[0] works as eight flags, "1" representing that the unit
5733+ is an unencoded letter (1 byte), "0" a position-and-length pair
5734+ (2 bytes). Thus, eight units require at most 16 bytes of code. */
5735+ code_buf_ptr = mask = 1;
5736+ s = 0; r = N - F;
5737+ for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
5738+ any character that will appear often. */
5739+ for (len = 0; (len < F) && (ip < srcend); len++)
5740+ text_buf[r + len] = *(ip++); /* Read F bytes into the last F bytes of
5741+ the buffer */
5742+ read = len;
5743+ for (i = 1; i <= F; i++) InsertNode(r - i); /* Insert the F strings,
5744+ each of which begins with one or more 'space' characters. Note
5745+ the order in which these strings are inserted. This way,
5746+ degenerate trees will be less likely to occur. */
5747+ InsertNode(r); /* Finally, insert the whole string just read. The
5748+ global variables match_length and match_position are set. */
5749+ do {
5750+ if (match_length > len) match_length = len; /* match_length
5751+ may be spuriously long near the end of text. */
5752+ if (match_length <= THRESHOLD) {
5753+ match_length = 1; /* Not long enough match. Send one byte. */
5754+ c = text_buf[r];
5755+ i = 0; j = 0; k = prnt[c + T];
5756+ do {
5757+ i >>= 1;
5758+ /* if node's address is odd-numbered, choose bigger brother node */
5759+ if (k & 1) i |= 0x8000;
5760+ j++;
5761+ } while ((k = prnt[k]) != R);
5762+ putbuf |= i >> putlen;
5763+ if ((putlen += j) >= 8) {
5764+ if (op >= dstend) {
5765+ *dstlen = written;
5766+ return -1;
5767+ }
5768+ *(op++) = putbuf >> 8;
5769+ if ((putlen -= 8) >= 8) {
5770+ if (op >= dstend) {
5771+ *dstlen = written;
5772+ return -1;
5773+ }
5774+ *(op++) = putbuf;
5775+ written += 2;
5776+ putlen -= 8;
5777+ putbuf = i << (j - putlen); /**warm**/
5778+ } else {
5779+ putbuf <<= 8;
5780+ written++;
5781+ }
5782+ *srclen = read;
5783+ }
5784+ update(c);
5785+ } else {
5786+ c = 255 - THRESHOLD + match_length;
5787+ i = 0; j = 0; k = prnt[c + T];
5788+ do {
5789+ i >>= 1;
5790+ /* if node's address is odd-numbered, choose bigger brother node */
5791+ if (k & 1) i |= 0x8000;
5792+ j++;
5793+ } while ((k = prnt[k]) != R);
5794+ putbuf |= i >> putlen;
5795+ if ((putlen += j) >= 8) {
5796+ if (op >= dstend) {
5797+ *dstlen = written;
5798+ return -1;
5799+ }
5800+ *(op++) = putbuf >> 8;
5801+ if ((putlen -= 8) >= 8) {
5802+ if (op >= dstend) {
5803+ *dstlen = written;
5804+ return -1;
5805+ }
5806+ *(op++) = putbuf;
5807+ written += 2;
5808+ putlen -= 8;
5809+ putbuf = i << (j - putlen); /**warm**/
5810+ } else {
5811+ putbuf <<= 8;
5812+ written++;
5813+ }
5814+ *srclen = read;
5815+ }
5816+ update(c);
5817+ j = p_len[match_position >> 6];
5818+ i = p_code[match_position >> 6] << 8;
5819+ putbuf |= i >> putlen;
5820+ if ((putlen += j) >= 8) {
5821+ if (op >= dstend) {
5822+ *dstlen = written;
5823+ return -1;
5824+ }
5825+ *(op++) = putbuf >> 8;
5826+ if ((putlen -= 8) >= 8) {
5827+ if (op >= dstend) {
5828+ *dstlen = written;
5829+ return -1;
5830+ }
5831+ *(op++) = putbuf;
5832+ written += 2;
5833+ putlen -= 8;
5834+ putbuf = i << (j - putlen); /**hot**/
5835+ } else {
5836+ putbuf <<= 8;
5837+ written++;
5838+ }
5839+ *srclen = read;
5840+ }
5841+ j = 6;
5842+ i = (match_position & 0x3f) << 10;
5843+ putbuf |= i >> putlen;
5844+ if ((putlen += j) >= 8) {
5845+ if (op >= dstend) {
5846+ *dstlen = written;
5847+ return -1;
5848+ }
5849+ *(op++) = putbuf >> 8;
5850+ if ((putlen -= 8) >= 8) {
5851+ if (op >= dstend) {
5852+ *dstlen = written;
5853+ return -1;
5854+ }
5855+ *(op++) = putbuf;
5856+ written += 2;
5857+ putlen -= 8;
5858+ putbuf = i << (j - putlen); /**hot**/
5859+ } else {
5860+ putbuf <<= 8;
5861+ written++;
5862+ }
5863+ *srclen = read;
5864+ }
5865+ }
5866+ last_match_length = match_length;
5867+ for (i = 0; (i < last_match_length) && (ip < srcend); i++) {
5868+ c = *(ip++);
5869+ DeleteNode(s);
5870+ text_buf[s] = c;
5871+ if (s < F - 1)
5872+ text_buf[s + N] = c;
5873+ s = (s + 1) & (N - 1);
5874+ r = (r + 1) & (N - 1);
5875+ InsertNode(r);
5876+ }
5877+ read += i;
5878+ while (i++ < last_match_length) {
5879+ DeleteNode(s);
5880+ s = (s + 1) & (N - 1);
5881+ r = (r + 1) & (N - 1);
5882+ if (--len) InsertNode(r);
5883+ }
5884+ } while (len > 0);
5885+ if (putlen) {
5886+ if (op >= dstend) {
5887+ *dstlen = written;
5888+ return -1;
5889+ }
5890+ *(op++) = putbuf >> 8;
5891+ written++;
5892+ *srclen = read;
5893+ }
5894+ *dstlen = written;
5895+ return 0;
5896+}
5897+
5898+static int Decode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long srclen,
5899+ unsigned long dstlen) /* Just the reverse of Encode(). */
5900+{
5901+ unsigned long i, r, j, k, c;
5902+ unsigned char *ip, *op;
5903+ unsigned char *srcend = srcbuf + srclen;
5904+ unsigned char *dstend = dstbuf + dstlen;
5905+ unsigned short getbuf = 0;
5906+ uchar getlen = 0;
5907+ ip = srcbuf;
5908+ op = dstbuf;
5909+ StartHuff();
5910+ for (i = 0; i < N - F; i++) text_buf[i] = ' ';
5911+ r = N - F;
5912+ while (op < dstend) {
5913+ c = son[R];
5914+ /* travel from root to leaf, */
5915+ /* choosing the smaller child node (son[]) if the read bit is 0, */
5916+ /* the bigger (son[]+1} if 1 */
5917+ while (c < T) {
5918+ while (getlen <= 8) {
5919+ unsigned short t;
5920+ t = (ip >= srcend) ? 0 : *(ip++);
5921+ getbuf |= t << (8 - getlen);
5922+ getlen += 8;
5923+ }
5924+ c += ((signed short)getbuf < 0);
5925+ getbuf <<= 1;
5926+ getlen--;
5927+ c = son[c];
5928+ }
5929+ c -= T;
5930+ update(c);
5931+ if (c < 256) {
5932+ if (op >= dstend) return -1;
5933+ *(op++) = c;
5934+ text_buf[r++] = c;
5935+ r &= (N - 1);
5936+ } else {
5937+ j = c - 255 + THRESHOLD;
5938+ while (getlen <= 8) {
5939+ unsigned short t;
5940+ t = (ip >= srcend) ? 0 : *(ip++);
5941+ getbuf |= t << (8 - getlen);
5942+ getlen += 8;
5943+ }
5944+ i = getbuf >> 8;
5945+ getbuf <<= 8;
5946+ getlen -= 8;
5947+ c = d_code[i] << 6;
5948+ k = d_len[i];
5949+ /* read lower 6 bits verbatim */
5950+ k -= 2;
5951+ while (k--) {
5952+ while (getlen <= 8) {
5953+ unsigned short t;
5954+ t = (ip >= srcend) ? 0 : *(ip++);
5955+ getbuf |= t << (8 - getlen);
5956+ getlen += 8;
5957+ }
5958+ i = (i << 1) + ((signed short)getbuf < 0);
5959+ getbuf <<= 1;
5960+ getlen--;
5961+ }
5962+ i = c | (i & 0x3F);
5963+ i = r - i - 1;
5964+ i &= (N - 1);
5965+ for (k = 0; k < j; k++) {
5966+ c = text_buf[(i + k) & (N - 1)];
5967+ if (op >= dstend) return -1;
5968+ *(op++) = c;
5969+ text_buf[r++] = c;
5970+ r &= (N - 1);
5971+ }
5972+ }
5973+ }
5974+ return 0;
5975+}
5976+
5977+/* interface to jffs2 bbc follows */
5978+
5979+#include "jffs2_bbc_framework.h"
5980+
5981+
5982+#define JFFS2_BBC_LZHD_BLOCK_SIGN {0x3a, 0x98, 0xf7, 0xda}
5983+
5984+static int
5985+jffs2_bbc_lzhd_compressor_init (void);
5986+
5987+static void
5988+jffs2_bbc_lzhd_compressor_deinit (void);
5989+
5990+static int
5991+jffs2_bbc_lzhd_compress (void *model, unsigned char *input,
5992+ unsigned char *output, unsigned long *sourcelen,
5993+ unsigned long *dstlen);
5994+
5995+static int
5996+jffs2_bbc_lzhd_estimate (void *model, unsigned char *input,
5997+ unsigned long sourcelen, unsigned long *dstlen,
5998+ unsigned long *readtime, unsigned long *writetime);
5999+
6000+static int
6001+jffs2_bbc_lzhd_decompress (void *model, unsigned char *input,
6002+ unsigned char *output, unsigned long sourcelen,
6003+ unsigned long dstlen);
6004+
6005+static char *
6006+jffs2_bbc_lzhd_proc_info (void);
6007+
6008+static int
6009+jffs2_bbc_lzhd_proc_command (char *command);
6010+
6011+struct jffs2_bbc_compressor_type jffs2_bbc_lzhd = {
6012+ "lzhd",
6013+ 0,
6014+ JFFS2_BBC_LZHD_BLOCK_SIGN,
6015+ jffs2_bbc_lzhd_compressor_init,
6016+ NULL,
6017+ NULL,
6018+ jffs2_bbc_lzhd_compressor_deinit,
6019+ jffs2_bbc_lzhd_compress,
6020+ jffs2_bbc_lzhd_estimate,
6021+ jffs2_bbc_lzhd_decompress,
6022+ jffs2_bbc_lzhd_proc_info,
6023+ jffs2_bbc_lzhd_proc_command
6024+};
6025+
6026+static int
6027+jffs2_bbc_lzhd_compressor_init (void)
6028+{
6029+ return 0;
6030+}
6031+
6032+static void
6033+jffs2_bbc_lzhd_compressor_deinit (void)
6034+{
6035+}
6036+
6037+static int
6038+jffs2_bbc_lzhd_compress (void *model, unsigned char *input,
6039+ unsigned char *output, unsigned long *sourcelen,
6040+ unsigned long *dstlen)
6041+{
6042+ int retval;
6043+ unsigned long dst = *dstlen;
6044+ *(output++) = jffs2_bbc_lzhd.block_sign[0];
6045+ *(output++) = jffs2_bbc_lzhd.block_sign[1];
6046+ dst -= 2;
6047+ retval = Encode(input, output, sourcelen, &dst);
6048+ dst += 2;
6049+ *dstlen = dst;
6050+ return retval;
6051+}
6052+
6053+static int
6054+jffs2_bbc_lzhd_estimate (void *model, unsigned char *input,
6055+ unsigned long sourcelen, unsigned long *dstlen,
6056+ unsigned long *readtime, unsigned long *writetime)
6057+{
6058+ *dstlen = sourcelen * 55 / 100;
6059+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 8;
6060+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 65 / 10;
6061+ return 0;
6062+}
6063+
6064+static int
6065+jffs2_bbc_lzhd_decompress (void *model, unsigned char *input,
6066+ unsigned char *output, unsigned long sourcelen,
6067+ unsigned long dstlen)
6068+{
6069+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzhd.block_sign[0] ) ||
6070+ ( *(input++) != (unsigned char)jffs2_bbc_lzhd.block_sign[1] )
6071+ ) {
6072+ return -1;
6073+ } else {
6074+ return Decode(input, output, sourcelen - 2, dstlen);
6075+ }
6076+}
6077+
6078+static char *
6079+jffs2_bbc_lzhd_proc_info (void)
6080+{
6081+ return "Lempel-Ziv-(dynamic) Huffman compression module";
6082+}
6083+
6084+static int
6085+jffs2_bbc_lzhd_proc_command (char *command)
6086+{
6087+ return 0;
6088+}
6089+
6090+struct jffs2_bbc_compressor_type *
6091+jffs2_bbc_lzhd_init (int mode)
6092+{
6093+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzhd) == 0)
6094+ {
6095+ return &jffs2_bbc_lzhd;
6096+ }
6097+ else
6098+ {
6099+ return NULL;
6100+ }
6101+}
6102+
6103+void
6104+jffs2_bbc_lzhd_deinit (void)
6105+{
6106+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzhd);
6107+}
6108--- /dev/null
6109+++ b/fs/jffs2/jffs2_bbc_lzo_comp.c
6110@@ -0,0 +1,2435 @@
6111+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
6112+
6113+/*
6114+ jffs2_bbc_lzo_comp.c -- LZO1X-1 (and -999) compression module for jffs2
6115+ Copyright (C) 2004 Patrik Kluba
6116+ Based on the original LZO sources
6117+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
6118+*/
6119+
6120+/*
6121+ Original copyright notice follows:
6122+
6123+ lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm
6124+ lzo_ptr.h -- low-level pointer constructs
6125+ lzo_swd.ch -- sliding window dictionary
6126+ lzoconf.h -- configuration for the LZO real-time data compression library
6127+ lzo_mchw.ch -- matching functions using a window
6128+ minilzo.c -- mini subset of the LZO real-time data compression library
6129+ config1x.h -- configuration for the LZO1X algorithm
6130+ lzo1x.h -- public interface of the LZO1X compression algorithm
6131+
6132+ These files are part of the LZO real-time data compression library.
6133+
6134+ Copyright (C) 1996-2002 Markus Franz Xaver Johannes Oberhumer
6135+ All Rights Reserved.
6136+
6137+ The LZO library is free software; you can redistribute it and/or
6138+ modify it under the terms of the GNU General Public License as
6139+ published by the Free Software Foundation; either version 2 of
6140+ the License, or (at your option) any later version.
6141+
6142+ The LZO library is distributed in the hope that it will be useful,
6143+ but WITHOUT ANY WARRANTY; without even the implied warranty of
6144+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
6145+ GNU General Public License for more details.
6146+
6147+ You should have received a copy of the GNU General Public License
6148+ along with the LZO library; see the file COPYING.
6149+ If not, write to the Free Software Foundation, Inc.,
6150+ 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
6151+
6152+ Markus F.X.J. Oberhumer
6153+ <markus@oberhumer.com>
6154+*/
6155+
6156+/*
6157+
6158+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
6159+ Initial release
6160+ -removed all 16 bit code
6161+ -all sensitive data will be on 4 byte boundary
6162+ -removed check parts for library use
6163+ -removed all but LZO1X-* compression
6164+
6165+*/
6166+
6167+#ifndef __KERNEL__
6168+ #include <sys/types.h>
6169+ #include <stddef.h>
6170+ #include <string.h>
6171+ #include <limits.h>
6172+#else
6173+ #include <linux/kernel.h>
6174+ #include <linux/types.h>
6175+ #include <linux/stddef.h>
6176+ #include <linux/string.h>
6177+ #define USHRT_MAX 65535
6178+ /* #define UINT_MAX 4294967295U */
6179+#endif
6180+
6181+/* data type definitions */
6182+#define U32 unsigned long
6183+#define S32 signed long
6184+#define I32 long
6185+#define U16 unsigned short
6186+#define S16 signed short
6187+#define I16 short
6188+#define U8 unsigned char
6189+#define S8 signed char
6190+#define I8 char
6191+
6192+/*************************************/
6193+
6194+/* lzo_swd.ch */
6195+
6196+#define SWD_N N
6197+#define SWD_F F
6198+#define SWD_THRESHOLD THRESHOLD
6199+
6200+/* shortest unsigned int that 2 * SWD_F + SWD_N (currently 53248) fits in */
6201+typedef unsigned short swd_uint;
6202+/* upper limit of that data type */
6203+#define SWD_UINT_MAX USHRT_MAX
6204+
6205+/* minilzo.c */
6206+
6207+#define LZO_VERSION_DATE "Jul 12 2002"
6208+#define LZO_VERSION_STRING "1.08"
6209+#define LZO_VERSION 0x1080
6210+
6211+/* lzo_ptr.h */
6212+
6213+/* Integral types that have *exactly* the same number of bits as a lzo_voidp */
6214+typedef unsigned long lzo_ptr_t;
6215+typedef long lzo_sptr_t;
6216+
6217+
6218+/*************************************/
6219+
6220+/* config1x.h */
6221+
6222+#define M1_MAX_OFFSET 0x0400
6223+#define M2_MAX_OFFSET 0x0800
6224+#define M3_MAX_OFFSET 0x4000
6225+#define M4_MAX_OFFSET 0xbfff
6226+
6227+#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)
6228+
6229+#define M1_MIN_LEN 2
6230+#define M1_MAX_LEN 2
6231+#define M2_MIN_LEN 3
6232+#define M2_MAX_LEN 8
6233+#define M3_MIN_LEN 3
6234+#define M3_MAX_LEN 33
6235+#define M4_MIN_LEN 3
6236+#define M4_MAX_LEN 9
6237+
6238+#define M1_MARKER 0
6239+#define M2_MARKER 64
6240+#define M3_MARKER 32
6241+#define M4_MARKER 16
6242+
6243+#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
6244+
6245+/* minilzo.c */
6246+
6247+#define LZO_BYTE(x) ((unsigned char) ((x) & 0xff))
6248+
6249+#define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b))
6250+#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b))
6251+#define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))
6252+#define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))
6253+
6254+#define lzo_sizeof(type) ((lzo_uint) (sizeof(type)))
6255+
6256+#define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array))))
6257+
6258+#define LZO_SIZE(bits) (1u << (bits))
6259+#define LZO_MASK(bits) (LZO_SIZE(bits) - 1)
6260+
6261+#define LZO_LSIZE(bits) (1ul << (bits))
6262+#define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1)
6263+
6264+#define LZO_USIZE(bits) ((lzo_uint) 1 << (bits))
6265+#define LZO_UMASK(bits) (LZO_USIZE(bits) - 1)
6266+
6267+#define LZO_STYPE_MAX(b) (((1l << (8*(b)-2)) - 1l) + (1l << (8*(b)-2)))
6268+#define LZO_UTYPE_MAX(b) (((1ul << (8*(b)-1)) - 1ul) + (1ul << (8*(b)-1)))
6269+
6270+#define _LZO_STRINGIZE(x) #x
6271+#define _LZO_MEXPAND(x) _LZO_STRINGIZE(x)
6272+
6273+#define _LZO_CONCAT2(a,b) a ## b
6274+#define _LZO_CONCAT3(a,b,c) a ## b ## c
6275+#define _LZO_CONCAT4(a,b,c,d) a ## b ## c ## d
6276+#define _LZO_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
6277+
6278+#define _LZO_ECONCAT2(a,b) _LZO_CONCAT2(a,b)
6279+#define _LZO_ECONCAT3(a,b,c) _LZO_CONCAT3(a,b,c)
6280+#define _LZO_ECONCAT4(a,b,c,d) _LZO_CONCAT4(a,b,c,d)
6281+#define _LZO_ECONCAT5(a,b,c,d,e) _LZO_CONCAT5(a,b,c,d,e)
6282+
6283+#define lzo_dict_t const lzo_bytep
6284+#define lzo_dict_p lzo_dict_t *
6285+#define lzo_moff_t lzo_uint
6286+
6287+#define MEMCPY8_DS(dest,src,len) \
6288+ memcpy(dest,src,len); \
6289+ dest += len; \
6290+ src += len
6291+
6292+#define MEMCPY_DS(dest,src,len) \
6293+ do *dest++ = *src++; \
6294+ while (--len > 0)
6295+
6296+#define MEMMOVE_DS(dest,src,len) \
6297+ do *dest++ = *src++; \
6298+ while (--len > 0)
6299+
6300+#define BZERO8_PTR(s,l,n) memset((s),0,(lzo_uint)(l)*(n))
6301+
6302+#define LZO_BASE 65521u
6303+#define LZO_NMAX 5552
6304+
6305+#define LZO_DO1(buf,i) {s1 += buf[i]; s2 += s1;}
6306+#define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1);
6307+#define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2);
6308+#define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4);
6309+#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8);
6310+
6311+#define IS_SIGNED(type) (((type) (-1)) < ((type) 0))
6312+#define IS_UNSIGNED(type) (((type) (-1)) > ((type) 0))
6313+
6314+#define IS_POWER_OF_2(x) (((x) & ((x) - 1)) == 0)
6315+
6316+#define D_BITS 14
6317+#define D_INDEX1(d,p) d = DM((0x21*DX3(p,5,5,6)) >> 5)
6318+#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
6319+
6320+#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B
6321+
6322+#define DL_MIN_LEN M2_MIN_LEN
6323+
6324+#define D_SIZE LZO_SIZE(D_BITS)
6325+#define D_MASK LZO_MASK(D_BITS)
6326+
6327+#define D_HIGH ((D_MASK >> 1) + 1)
6328+
6329+#define DINDEX1 D_INDEX1
6330+#define DINDEX2 D_INDEX2
6331+
6332+#define DX2(p,s1,s2) \
6333+ (((((lzo_uint32)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0])
6334+
6335+#define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0])
6336+#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s)))
6337+#define DM(v) DMS(v,0)
6338+
6339+#define DENTRY(p,in) (p)
6340+#define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex]
6341+
6342+#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
6343+ (m_pos == NULL || (m_off = (lzo_moff_t) (ip - m_pos)) > max_offset)
6344+
6345+#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
6346+ (BOUNDS_CHECKING_OFF_IN_EXPR( \
6347+ (PTR_LT(m_pos,in) || \
6348+ (m_off = (lzo_moff_t) PTR_DIFF(ip,m_pos)) <= 0 || \
6349+ m_off > max_offset) ))
6350+
6351+#define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr)
6352+
6353+#define DD_BITS 0
6354+#define DD_SIZE LZO_SIZE(DD_BITS)
6355+#define DD_MASK LZO_MASK(DD_BITS)
6356+
6357+#define DL_BITS (D_BITS - DD_BITS)
6358+#define DL_SIZE LZO_SIZE(DL_BITS)
6359+#define DL_MASK LZO_MASK(DL_BITS)
6360+
6361+#define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in)
6362+#define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in)
6363+#define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in)
6364+
6365+#define __COPY4(dst,src) * (lzo_uint32p)(dst) = * (const lzo_uint32p)(src)
6366+#define COPY4(dst,src) __COPY4((lzo_ptr_t)(dst),(lzo_ptr_t)(src))
6367+
6368+#define TEST_IP (ip < ip_end)
6369+#define TEST_OP (op <= op_end)
6370+
6371+#define NEED_IP(x) \
6372+ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
6373+#define NEED_OP(x) \
6374+ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
6375+#define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun
6376+
6377+/* lzo1x_9x.c */
6378+
6379+#define LZO_UINT_MAX UINT_MAX
6380+#define N M4_MAX_OFFSET
6381+#define THRESHOLD 1
6382+#define F 2048
6383+
6384+#define SWD_BEST_OFF (LZO_MAX3( M2_MAX_LEN, M3_MAX_LEN, M4_MAX_LEN ) + 1)
6385+
6386+/* ../include/lzoconf.h */
6387+
6388+typedef U32 lzo_uint32;
6389+typedef I32 lzo_int32;
6390+typedef U32 lzo_uint;
6391+typedef I32 lzo_int;
6392+typedef int lzo_bool;
6393+
6394+#define lzo_byte U8
6395+#define lzo_bytep U8 *
6396+#define lzo_charp char *
6397+#define lzo_voidp void *
6398+#define lzo_shortp short *
6399+#define lzo_ushortp unsigned short *
6400+#define lzo_uint32p lzo_uint32 *
6401+#define lzo_int32p lzo_int32 *
6402+#define lzo_uintp lzo_uint *
6403+#define lzo_intp lzo_int *
6404+#define lzo_voidpp lzo_voidp *
6405+#define lzo_bytepp lzo_bytep *
6406+#define lzo_sizeof_dict_t sizeof(lzo_bytep)
6407+
6408+#define LZO_E_OK 0
6409+#define LZO_E_ERROR (-1)
6410+#define LZO_E_OUT_OF_MEMORY (-2) /* not used right now */
6411+#define LZO_E_NOT_COMPRESSIBLE (-3) /* not used right now */
6412+#define LZO_E_INPUT_OVERRUN (-4)
6413+#define LZO_E_OUTPUT_OVERRUN (-5)
6414+#define LZO_E_LOOKBEHIND_OVERRUN (-6)
6415+#define LZO_E_EOF_NOT_FOUND (-7)
6416+#define LZO_E_INPUT_NOT_CONSUMED (-8)
6417+
6418+#define LZO_PTR_ALIGN_UP(_ptr,_size) \
6419+ ((_ptr) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(_ptr),(lzo_uint)(_size)))
6420+#define LZO_ALIGN(_ptr,_size) LZO_PTR_ALIGN_UP(_ptr,_size)
6421+
6422+typedef int
6423+ (*lzo_compress_t) (const lzo_byte * src, lzo_uint src_len,
6424+ lzo_byte * dst, lzo_uintp dst_len,
6425+ lzo_voidp wrkmem);
6426+
6427+typedef int
6428+ (*lzo_decompress_t) (const lzo_byte * src, lzo_uint src_len,
6429+ lzo_byte * dst, lzo_uintp dst_len,
6430+ lzo_voidp wrkmem);
6431+
6432+typedef int
6433+ (*lzo_optimize_t) (lzo_byte * src, lzo_uint src_len,
6434+ lzo_byte * dst, lzo_uintp dst_len,
6435+ lzo_voidp wrkmem);
6436+
6437+typedef int
6438+ (*lzo_compress_dict_t) (const lzo_byte * src, lzo_uint src_len,
6439+ lzo_byte * dst, lzo_uintp dst_len,
6440+ lzo_voidp wrkmem,
6441+ const lzo_byte * dict, lzo_uint dict_len);
6442+
6443+typedef int
6444+ (*lzo_decompress_dict_t) (const lzo_byte * src, lzo_uint src_len,
6445+ lzo_byte * dst, lzo_uintp dst_len,
6446+ lzo_voidp wrkmem,
6447+ const lzo_byte * dict, lzo_uint dict_len);
6448+
6449+typedef int
6450+ (*lzo_compress_asm_t) (const lzo_byte * src, lzo_uint src_len,
6451+ lzo_byte * dst, lzo_uintp dst_len,
6452+ lzo_voidp wrkmem);
6453+
6454+typedef int
6455+ (*lzo_decompress_asm_t) (const lzo_byte * src, lzo_uint src_len,
6456+ lzo_byte * dst, lzo_uintp dst_len,
6457+ lzo_voidp wrkmem);
6458+
6459+typedef void (*lzo_progress_callback_t) (lzo_uint, lzo_uint);
6460+
6461+typedef union
6462+{
6463+ lzo_bytep p;
6464+ lzo_uint u;
6465+} __lzo_pu_u;
6466+typedef union
6467+{
6468+ lzo_bytep p;
6469+ lzo_uint32 u32;
6470+} __lzo_pu32_u;
6471+typedef union
6472+{
6473+ void *vp;
6474+ lzo_bytep bp;
6475+ lzo_uint32 u32;
6476+ long l;
6477+} lzo_align_t;
6478+
6479+/* lzo1x.h */
6480+
6481+#define LZO1X_1_MEM_COMPRESS ((lzo_uint32) (16384L * lzo_sizeof_dict_t))
6482+#define LZO1X_999_MEM_COMPRESS ((lzo_uint32) (14 * 16384L * sizeof(short)))
6483+
6484+/* lzo_ptr.h */
6485+
6486+#define PTR(a) ((lzo_ptr_t) (a))
6487+#define PTR_LINEAR(a) PTR(a)
6488+#define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0)
6489+#define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0)
6490+#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)
6491+#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)
6492+#define PTR_LT(a,b) (PTR(a) < PTR(b))
6493+#define PTR_GE(a,b) (PTR(a) >= PTR(b))
6494+#define PTR_DIFF(a,b) ((lzo_ptrdiff_t) (PTR(a) - PTR(b)))
6495+#define pd(a,b) ((lzo_uint) ((a)-(b)))
6496+
6497+typedef ptrdiff_t lzo_ptrdiff_t;
6498+
6499+typedef union
6500+{
6501+ char a_char;
6502+ unsigned char a_uchar;
6503+ short a_short;
6504+ unsigned short a_ushort;
6505+ int a_int;
6506+ unsigned int a_uint;
6507+ long a_long;
6508+ unsigned long a_ulong;
6509+ lzo_int a_lzo_int;
6510+ lzo_uint a_lzo_uint;
6511+ lzo_int32 a_lzo_int32;
6512+ lzo_uint32 a_lzo_uint32;
6513+ ptrdiff_t a_ptrdiff_t;
6514+ lzo_ptrdiff_t a_lzo_ptrdiff_t;
6515+ lzo_ptr_t a_lzo_ptr_t;
6516+ lzo_voidp a_lzo_voidp;
6517+ void *a_void_p;
6518+ lzo_bytep a_lzo_bytep;
6519+ lzo_bytepp a_lzo_bytepp;
6520+ lzo_uintp a_lzo_uintp;
6521+ lzo_uint *a_lzo_uint_p;
6522+ lzo_uint32p a_lzo_uint32p;
6523+ lzo_uint32 *a_lzo_uint32_p;
6524+ unsigned char *a_uchar_p;
6525+ char *a_char_p;
6526+}
6527+lzo_full_align_t;
6528+
6529+/* lzo_mchw.ch */
6530+
6531+typedef struct
6532+{
6533+ int init;
6534+
6535+ lzo_uint look;
6536+
6537+ lzo_uint m_len;
6538+ lzo_uint m_off;
6539+
6540+ lzo_uint last_m_len;
6541+ lzo_uint last_m_off;
6542+
6543+ const lzo_byte *bp;
6544+ const lzo_byte *ip;
6545+ const lzo_byte *in;
6546+ const lzo_byte *in_end;
6547+ lzo_byte *out;
6548+
6549+ lzo_progress_callback_t cb;
6550+
6551+ lzo_uint textsize;
6552+ lzo_uint codesize;
6553+ lzo_uint printcount;
6554+
6555+ unsigned long lit_bytes;
6556+ unsigned long match_bytes;
6557+ unsigned long rep_bytes;
6558+ unsigned long lazy;
6559+
6560+ lzo_uint r1_lit;
6561+ lzo_uint r1_m_len;
6562+
6563+ unsigned long m1a_m, m1b_m, m2_m, m3_m, m4_m;
6564+ unsigned long lit1_r, lit2_r, lit3_r;
6565+}
6566+lzo1x_999_t;
6567+
6568+#define getbyte(c) ((c).ip < (c).in_end ? *((c).ip)++ : (-1))
6569+
6570+/* lzo_swd.ch */
6571+
6572+#define SWD_UINT(x) ((swd_uint)(x))
6573+#define SWD_HSIZE 16384
6574+#define SWD_MAX_CHAIN 2048
6575+#define HEAD3(b,p) \
6576+ (((0x9f5f*(((((lzo_uint32)b[p]<<5)^b[p+1])<<5)^b[p+2]))>>5) & (SWD_HSIZE-1))
6577+#define HEAD2(b,p) (b[p] ^ ((unsigned)b[p+1]<<8))
6578+#define NIL2 SWD_UINT_MAX
6579+
6580+typedef struct
6581+{
6582+ lzo_uint n;
6583+ lzo_uint f;
6584+ lzo_uint threshold;
6585+
6586+ lzo_uint max_chain;
6587+ lzo_uint nice_length;
6588+ lzo_bool use_best_off;
6589+ lzo_uint lazy_insert;
6590+
6591+ lzo_uint m_len;
6592+ lzo_uint m_off;
6593+ lzo_uint look;
6594+ int b_char;
6595+
6596+ lzo_uint best_off[SWD_BEST_OFF];
6597+
6598+ lzo1x_999_t *c;
6599+ lzo_uint m_pos;
6600+
6601+ lzo_uint best_pos[SWD_BEST_OFF];
6602+
6603+ const lzo_byte *dict;
6604+ const lzo_byte *dict_end;
6605+ lzo_uint dict_len;
6606+
6607+ lzo_uint ip;
6608+ lzo_uint bp;
6609+ lzo_uint rp;
6610+ lzo_uint b_size;
6611+
6612+ unsigned char *b_wrap;
6613+
6614+ lzo_uint node_count;
6615+ lzo_uint first_rp;
6616+
6617+ unsigned char b[SWD_N + SWD_F + SWD_F];
6618+ swd_uint head3[SWD_HSIZE];
6619+ swd_uint succ3[SWD_N + SWD_F];
6620+ swd_uint best3[SWD_N + SWD_F];
6621+ swd_uint llen3[SWD_HSIZE];
6622+
6623+ swd_uint head2[65536L];
6624+}
6625+lzo1x_999_swd_t;
6626+
6627+#define s_head3(s,key) s->head3[key]
6628+#define swd_pos2off(s,pos) \
6629+ (s->bp > (pos) ? s->bp - (pos) : s->b_size - ((pos) - s->bp))
6630+
6631+static __inline__ void
6632+swd_getbyte (lzo1x_999_swd_t * s)
6633+{
6634+ int c;
6635+
6636+ if ((c = getbyte (*(s->c))) < 0)
6637+ {
6638+ if (s->look > 0)
6639+ --s->look;
6640+ }
6641+ else
6642+ {
6643+ s->b[s->ip] = LZO_BYTE (c);
6644+ if (s->ip < s->f)
6645+ s->b_wrap[s->ip] = LZO_BYTE (c);
6646+ }
6647+ if (++s->ip == s->b_size)
6648+ s->ip = 0;
6649+ if (++s->bp == s->b_size)
6650+ s->bp = 0;
6651+ if (++s->rp == s->b_size)
6652+ s->rp = 0;
6653+}
6654+
6655+static void
6656+swd_initdict (lzo1x_999_swd_t * s, const lzo_byte * dict, lzo_uint dict_len)
6657+{
6658+ s->dict = s->dict_end = NULL;
6659+ s->dict_len = 0;
6660+
6661+ if (!dict || dict_len <= 0)
6662+ return;
6663+ if (dict_len > s->n)
6664+ {
6665+ dict += dict_len - s->n;
6666+ dict_len = s->n;
6667+ }
6668+
6669+ s->dict = dict;
6670+ s->dict_len = dict_len;
6671+ s->dict_end = dict + dict_len;
6672+ memcpy (s->b, dict, dict_len);
6673+ s->ip = dict_len;
6674+}
6675+
6676+static void
6677+swd_insertdict (lzo1x_999_swd_t * s, lzo_uint node, lzo_uint len)
6678+{
6679+ lzo_uint key;
6680+
6681+ s->node_count = s->n - len;
6682+ s->first_rp = node;
6683+
6684+ while (len-- > 0)
6685+ {
6686+ key = HEAD3 (s->b, node);
6687+ s->succ3[node] = s_head3 (s, key);
6688+ s->head3[key] = SWD_UINT (node);
6689+ s->best3[node] = SWD_UINT (s->f + 1);
6690+ s->llen3[key]++;
6691+
6692+ key = HEAD2 (s->b, node);
6693+ s->head2[key] = SWD_UINT (node);
6694+
6695+ node++;
6696+ }
6697+}
6698+
6699+static int
6700+swd_init (lzo1x_999_swd_t * s, const lzo_byte * dict, lzo_uint dict_len)
6701+{
6702+
6703+ s->n = SWD_N;
6704+ s->f = SWD_F;
6705+ s->threshold = SWD_THRESHOLD;
6706+
6707+
6708+
6709+ s->max_chain = SWD_MAX_CHAIN;
6710+ s->nice_length = SWD_F;
6711+ s->use_best_off = 0;
6712+ s->lazy_insert = 0;
6713+
6714+ s->b_size = s->n + s->f;
6715+ if (2 * s->f >= s->n || s->b_size + s->f >= NIL2)
6716+ return LZO_E_ERROR;
6717+ s->b_wrap = s->b + s->b_size;
6718+ s->node_count = s->n;
6719+
6720+ memset (s->llen3, 0, sizeof (s->llen3[0]) * SWD_HSIZE);
6721+ memset (s->head2, 0xff, sizeof (s->head2[0]) * 65536L);
6722+
6723+ s->ip = 0;
6724+ swd_initdict (s, dict, dict_len);
6725+ s->bp = s->ip;
6726+ s->first_rp = s->ip;
6727+
6728+ s->look = (lzo_uint) (s->c->in_end - s->c->ip);
6729+ if (s->look > 0)
6730+ {
6731+ if (s->look > s->f)
6732+ s->look = s->f;
6733+ memcpy (&s->b[s->ip], s->c->ip, s->look);
6734+ s->c->ip += s->look;
6735+ s->ip += s->look;
6736+ }
6737+
6738+ if (s->ip == s->b_size)
6739+ s->ip = 0;
6740+
6741+ if (s->look >= 2 && s->dict_len > 0)
6742+ swd_insertdict (s, 0, s->dict_len);
6743+
6744+ s->rp = s->first_rp;
6745+ if (s->rp >= s->node_count)
6746+ s->rp -= s->node_count;
6747+ else
6748+ s->rp += s->b_size - s->node_count;
6749+
6750+ return LZO_E_OK;
6751+}
6752+
6753+static __inline__ void
6754+swd_remove_node (lzo1x_999_swd_t * s, lzo_uint node)
6755+{
6756+ if (s->node_count == 0)
6757+ {
6758+ lzo_uint key;
6759+
6760+ key = HEAD3 (s->b, node);
6761+
6762+ --s->llen3[key];
6763+
6764+ key = HEAD2 (s->b, node);
6765+
6766+ if ((lzo_uint) s->head2[key] == node)
6767+ s->head2[key] = NIL2;
6768+ }
6769+ else
6770+ --s->node_count;
6771+}
6772+
6773+static void
6774+swd_accept (lzo1x_999_swd_t * s, lzo_uint n)
6775+{
6776+
6777+ while (n--)
6778+ {
6779+ lzo_uint key;
6780+
6781+ swd_remove_node (s, s->rp);
6782+
6783+ key = HEAD3 (s->b, s->bp);
6784+ s->succ3[s->bp] = s_head3 (s, key);
6785+ s->head3[key] = SWD_UINT (s->bp);
6786+ s->best3[s->bp] = SWD_UINT (s->f + 1);
6787+ s->llen3[key]++;
6788+
6789+ key = HEAD2 (s->b, s->bp);
6790+ s->head2[key] = SWD_UINT (s->bp);;
6791+
6792+ swd_getbyte (s);
6793+ }
6794+}
6795+
6796+static void
6797+swd_search (lzo1x_999_swd_t * s, lzo_uint node, lzo_uint cnt)
6798+{
6799+ const unsigned char *p1;
6800+ const unsigned char *p2;
6801+ const unsigned char *px;
6802+
6803+ lzo_uint m_len = s->m_len;
6804+ const unsigned char *b = s->b;
6805+ const unsigned char *bp = s->b + s->bp;
6806+ const unsigned char *bx = s->b + s->bp + s->look;
6807+ unsigned char scan_end1;
6808+
6809+ scan_end1 = bp[m_len - 1];
6810+ for (; cnt-- > 0; node = s->succ3[node])
6811+ {
6812+ p1 = bp;
6813+ p2 = b + node;
6814+ px = bx;
6815+
6816+ if (p2[m_len - 1] == scan_end1 &&
6817+ p2[m_len] == p1[m_len] &&
6818+ p2[0] == p1[0] && p2[1] == p1[1])
6819+ {
6820+ lzo_uint i;
6821+
6822+ p1 += 2;
6823+ p2 += 2;
6824+ do
6825+ {
6826+ }
6827+ while (++p1 < px && *p1 == *++p2);
6828+
6829+ i = p1 - bp;
6830+
6831+ if (i < SWD_BEST_OFF)
6832+ {
6833+ if (s->best_pos[i] == 0)
6834+ s->best_pos[i] = node + 1;
6835+ }
6836+
6837+ if (i > m_len)
6838+ {
6839+ s->m_len = m_len = i;
6840+ s->m_pos = node;
6841+ if (m_len == s->look)
6842+ return;
6843+ if (m_len >= s->nice_length)
6844+ return;
6845+ if (m_len > (lzo_uint) s->best3[node])
6846+ return;
6847+ scan_end1 = bp[m_len - 1];
6848+ }
6849+ }
6850+ }
6851+}
6852+
6853+static lzo_bool
6854+swd_search2 (lzo1x_999_swd_t * s)
6855+{
6856+ lzo_uint key;
6857+
6858+ key = s->head2[HEAD2 (s->b, s->bp)];
6859+ if (key == NIL2)
6860+ return 0;
6861+
6862+ if (s->best_pos[2] == 0)
6863+ s->best_pos[2] = key + 1;
6864+
6865+ if (s->m_len < 2)
6866+ {
6867+ s->m_len = 2;
6868+ s->m_pos = key;
6869+ }
6870+ return 1;
6871+}
6872+
6873+static void
6874+swd_findbest (lzo1x_999_swd_t * s)
6875+{
6876+ lzo_uint key;
6877+ lzo_uint cnt, node;
6878+ lzo_uint len;
6879+
6880+ key = HEAD3 (s->b, s->bp);
6881+ node = s->succ3[s->bp] = s_head3 (s, key);
6882+ cnt = s->llen3[key]++;
6883+
6884+ if (cnt > s->max_chain && s->max_chain > 0)
6885+ cnt = s->max_chain;
6886+ s->head3[key] = SWD_UINT (s->bp);
6887+
6888+ s->b_char = s->b[s->bp];
6889+ len = s->m_len;
6890+ if (s->m_len >= s->look)
6891+ {
6892+ if (s->look == 0)
6893+ s->b_char = -1;
6894+ s->m_off = 0;
6895+ s->best3[s->bp] = SWD_UINT (s->f + 1);
6896+ }
6897+ else
6898+ {
6899+
6900+ if (swd_search2 (s))
6901+
6902+ if (s->look >= 3)
6903+ swd_search (s, node, cnt);
6904+ if (s->m_len > len)
6905+ s->m_off = swd_pos2off (s, s->m_pos);
6906+ s->best3[s->bp] = SWD_UINT (s->m_len);
6907+
6908+ if (s->use_best_off)
6909+ {
6910+ int i;
6911+ for (i = 2; i < SWD_BEST_OFF; i++)
6912+ if (s->best_pos[i] > 0)
6913+ s->best_off[i] =
6914+ swd_pos2off (s,
6915+ s->best_pos[i] -
6916+ 1);
6917+ else
6918+ s->best_off[i] = 0;
6919+ }
6920+
6921+ }
6922+
6923+ swd_remove_node (s, s->rp);
6924+
6925+ key = HEAD2 (s->b, s->bp);
6926+ s->head2[key] = SWD_UINT (s->bp);
6927+
6928+}
6929+
6930+/* lzo_mchw.ch */
6931+
6932+static int
6933+init_match (lzo1x_999_t * c, lzo1x_999_swd_t * s,
6934+ const lzo_byte * dict, lzo_uint dict_len, lzo_uint32 flags)
6935+{
6936+ int r;
6937+
6938+ c->init = 1;
6939+
6940+ s->c = c;
6941+
6942+ c->last_m_len = c->last_m_off = 0;
6943+
6944+ c->textsize = c->codesize = c->printcount = 0;
6945+ c->lit_bytes = c->match_bytes = c->rep_bytes = 0;
6946+ c->lazy = 0;
6947+
6948+ r = swd_init (s, dict, dict_len);
6949+ if (r != 0)
6950+ return r;
6951+
6952+ s->use_best_off = (flags & 1) ? 1 : 0;
6953+ return r;
6954+}
6955+
6956+static int
6957+find_match (lzo1x_999_t * c, lzo1x_999_swd_t * s,
6958+ lzo_uint this_len, lzo_uint skip)
6959+{
6960+ if (skip > 0)
6961+ {
6962+ swd_accept (s, this_len - skip);
6963+ c->textsize += this_len - skip + 1;
6964+ }
6965+ else
6966+ {
6967+ c->textsize += this_len - skip;
6968+ }
6969+
6970+ s->m_len = 1;
6971+ s->m_len = 1;
6972+
6973+ if (s->use_best_off)
6974+ memset (s->best_pos, 0, sizeof (s->best_pos));
6975+
6976+ swd_findbest (s);
6977+ c->m_len = s->m_len;
6978+ c->m_off = s->m_off;
6979+
6980+ swd_getbyte (s);
6981+
6982+ if (s->b_char < 0)
6983+ {
6984+ c->look = 0;
6985+ c->m_len = 0;
6986+ }
6987+ else
6988+ {
6989+ c->look = s->look + 1;
6990+ }
6991+ c->bp = c->ip - c->look;
6992+
6993+ if (c->cb && c->textsize > c->printcount)
6994+ {
6995+ (*c->cb) (c->textsize, c->codesize);
6996+ c->printcount += 1024;
6997+ }
6998+
6999+ return LZO_E_OK;
7000+}
7001+
7002+/* lzo1x_9x.c */
7003+
7004+static lzo_byte *
7005+code_match (lzo1x_999_t * c, lzo_byte * op, lzo_uint m_len, lzo_uint m_off)
7006+{
7007+ lzo_uint x_len = m_len;
7008+ lzo_uint x_off = m_off;
7009+
7010+ c->match_bytes += m_len;
7011+
7012+ if (m_len == 2)
7013+ {
7014+ m_off -= 1;
7015+
7016+ *op++ = LZO_BYTE (M1_MARKER | ((m_off & 3) << 2));
7017+ *op++ = LZO_BYTE (m_off >> 2);
7018+
7019+ c->m1a_m++;
7020+ }
7021+
7022+ else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
7023+
7024+ {
7025+
7026+ m_off -= 1;
7027+ *op++ = LZO_BYTE (((m_len - 1) << 5) | ((m_off & 7) << 2));
7028+ *op++ = LZO_BYTE (m_off >> 3);
7029+ c->m2_m++;
7030+ }
7031+ else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET
7032+ && c->r1_lit >= 4)
7033+ {
7034+ m_off -= 1 + M2_MAX_OFFSET;
7035+
7036+ *op++ = LZO_BYTE (M1_MARKER | ((m_off & 3) << 2));
7037+ *op++ = LZO_BYTE (m_off >> 2);
7038+
7039+ c->m1b_m++;
7040+ }
7041+ else if (m_off <= M3_MAX_OFFSET)
7042+ {
7043+ m_off -= 1;
7044+ if (m_len <= M3_MAX_LEN)
7045+ *op++ = LZO_BYTE (M3_MARKER | (m_len - 2));
7046+ else
7047+ {
7048+ m_len -= M3_MAX_LEN;
7049+ *op++ = M3_MARKER | 0;
7050+ while (m_len > 255)
7051+ {
7052+ m_len -= 255;
7053+ *op++ = 0;
7054+ }
7055+ *op++ = LZO_BYTE (m_len);
7056+ }
7057+
7058+ *op++ = LZO_BYTE (m_off << 2);
7059+ *op++ = LZO_BYTE (m_off >> 6);
7060+
7061+ c->m3_m++;
7062+ }
7063+ else
7064+ {
7065+ lzo_uint k;
7066+
7067+ m_off -= 0x4000;
7068+ k = (m_off & 0x4000) >> 11;
7069+ if (m_len <= M4_MAX_LEN)
7070+ *op++ = LZO_BYTE (M4_MARKER | k | (m_len - 2));
7071+ else
7072+ {
7073+ m_len -= M4_MAX_LEN;
7074+ *op++ = LZO_BYTE (M4_MARKER | k | 0);
7075+ while (m_len > 255)
7076+ {
7077+ m_len -= 255;
7078+ *op++ = 0;
7079+ }
7080+ *op++ = LZO_BYTE (m_len);
7081+ }
7082+
7083+ *op++ = LZO_BYTE (m_off << 2);
7084+ *op++ = LZO_BYTE (m_off >> 6);
7085+
7086+ c->m4_m++;
7087+ }
7088+
7089+ c->last_m_len = x_len;
7090+ c->last_m_off = x_off;
7091+ return op;
7092+}
7093+
7094+static lzo_byte *
7095+STORE_RUN (lzo1x_999_t * c, lzo_byte * op, const lzo_byte * ii, lzo_uint t)
7096+{
7097+ c->lit_bytes += t;
7098+
7099+ if (op == c->out && t <= 238)
7100+ {
7101+ *op++ = LZO_BYTE (17 + t);
7102+ }
7103+ else if (t <= 3)
7104+ {
7105+ op[-2] |= LZO_BYTE (t);
7106+
7107+ c->lit1_r++;
7108+ }
7109+ else if (t <= 18)
7110+ {
7111+ *op++ = LZO_BYTE (t - 3);
7112+ c->lit2_r++;
7113+ }
7114+ else
7115+ {
7116+ lzo_uint tt = t - 18;
7117+
7118+ *op++ = 0;
7119+ while (tt > 255)
7120+ {
7121+ tt -= 255;
7122+ *op++ = 0;
7123+ }
7124+ *op++ = LZO_BYTE (tt);
7125+ c->lit3_r++;
7126+ }
7127+ do
7128+ *op++ = *ii++;
7129+ while (--t > 0);
7130+
7131+ return op;
7132+}
7133+
7134+static lzo_byte *
7135+code_run (lzo1x_999_t * c, lzo_byte * op, const lzo_byte * ii,
7136+ lzo_uint lit, lzo_uint m_len)
7137+{
7138+ if (lit > 0)
7139+ {
7140+ op = STORE_RUN (c, op, ii, lit);
7141+ c->r1_m_len = m_len;
7142+ c->r1_lit = lit;
7143+ }
7144+ else
7145+ {
7146+ c->r1_m_len = 0;
7147+ c->r1_lit = 0;
7148+ }
7149+
7150+ return op;
7151+}
7152+
7153+static int
7154+len_of_coded_match (lzo_uint m_len, lzo_uint m_off, lzo_uint lit)
7155+{
7156+ int n = 4;
7157+
7158+ if (m_len < 2)
7159+ return -1;
7160+ if (m_len == 2)
7161+ return (m_off <= M1_MAX_OFFSET && lit > 0
7162+ && lit < 4) ? 2 : -1;
7163+ if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
7164+ return 2;
7165+ if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4)
7166+ return 2;
7167+ if (m_off <= M3_MAX_OFFSET)
7168+ {
7169+ if (m_len <= M3_MAX_LEN)
7170+ return 3;
7171+ m_len -= M3_MAX_LEN;
7172+ while (m_len > 255)
7173+ {
7174+ m_len -= 255;
7175+ n++;
7176+ }
7177+ return n;
7178+ }
7179+ if (m_off <= M4_MAX_OFFSET)
7180+ {
7181+ if (m_len <= M4_MAX_LEN)
7182+ return 3;
7183+ m_len -= M4_MAX_LEN;
7184+ while (m_len > 255)
7185+ {
7186+ m_len -= 255;
7187+ n++;
7188+ }
7189+ return n;
7190+ }
7191+ return -1;
7192+}
7193+
7194+static lzo_int
7195+min_gain (lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, int l1, int l2,
7196+ int l3)
7197+{
7198+ lzo_int lazy_match_min_gain = 0;
7199+
7200+ lazy_match_min_gain += ahead;
7201+
7202+ if (lit1 <= 3)
7203+ lazy_match_min_gain += (lit2 <= 3) ? 0 : 2;
7204+ else if (lit1 <= 18)
7205+ lazy_match_min_gain += (lit2 <= 18) ? 0 : 1;
7206+
7207+ lazy_match_min_gain += (l2 - l1) * 2;
7208+ if (l3 > 0)
7209+ lazy_match_min_gain -= (ahead - l3) * 2;
7210+
7211+ if (lazy_match_min_gain < 0)
7212+ lazy_match_min_gain = 0;
7213+
7214+ return lazy_match_min_gain;
7215+}
7216+
7217+static void
7218+better_match (const lzo1x_999_swd_t * swd, lzo_uint * m_len, lzo_uint * m_off)
7219+{
7220+ if (*m_len <= M2_MIN_LEN)
7221+ return;
7222+
7223+ if (*m_off <= M2_MAX_OFFSET)
7224+ return;
7225+
7226+ if (*m_off > M2_MAX_OFFSET &&
7227+ *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
7228+ swd->best_off[*m_len - 1]
7229+ && swd->best_off[*m_len - 1] <= M2_MAX_OFFSET)
7230+ {
7231+ *m_len = *m_len - 1;
7232+ *m_off = swd->best_off[*m_len];
7233+ return;
7234+ }
7235+
7236+ if (*m_off > M3_MAX_OFFSET &&
7237+ *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 &&
7238+ swd->best_off[*m_len - 2]
7239+ && swd->best_off[*m_len - 2] <= M2_MAX_OFFSET)
7240+ {
7241+ *m_len = *m_len - 2;
7242+ *m_off = swd->best_off[*m_len];
7243+ return;
7244+ }
7245+
7246+ if (*m_off > M3_MAX_OFFSET &&
7247+ *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 &&
7248+ swd->best_off[*m_len - 1]
7249+ && swd->best_off[*m_len - 1] <= M3_MAX_OFFSET)
7250+ {
7251+ *m_len = *m_len - 1;
7252+ *m_off = swd->best_off[*m_len];
7253+ }
7254+
7255+}
7256+
7257+/* minilzo.c */
7258+
7259+static lzo_bool
7260+lzo_assert (int expr)
7261+{
7262+ return (expr) ? 1 : 0;
7263+}
7264+
7265+/* lzo1x_9x.c */
7266+
7267+static int
7268+lzo1x_999_compress_internal (const lzo_byte * in, lzo_uint in_len,
7269+ lzo_byte * out, lzo_uintp out_len,
7270+ lzo_voidp wrkmem,
7271+ const lzo_byte * dict, lzo_uint dict_len,
7272+ lzo_progress_callback_t cb,
7273+ int try_lazy,
7274+ lzo_uint good_length,
7275+ lzo_uint max_lazy,
7276+ lzo_uint nice_length,
7277+ lzo_uint max_chain, lzo_uint32 flags)
7278+{
7279+ lzo_byte *op;
7280+ const lzo_byte *ii;
7281+ lzo_uint lit;
7282+ lzo_uint m_len, m_off;
7283+ lzo1x_999_t cc;
7284+ lzo1x_999_t *const c = &cc;
7285+ lzo1x_999_swd_t *const swd = (lzo1x_999_swd_t *) wrkmem;
7286+ int r;
7287+
7288+ if (!lzo_assert
7289+ (LZO1X_999_MEM_COMPRESS >= lzo_sizeof (lzo1x_999_swd_t)))
7290+ return LZO_E_ERROR;
7291+
7292+ if (try_lazy < 0)
7293+ try_lazy = 1;
7294+
7295+ if (good_length <= 0)
7296+ good_length = 32;
7297+
7298+ if (max_lazy <= 0)
7299+ max_lazy = 32;
7300+
7301+ if (nice_length <= 0)
7302+ nice_length = 0;
7303+
7304+ if (max_chain <= 0)
7305+ max_chain = SWD_MAX_CHAIN;
7306+
7307+ c->init = 0;
7308+ c->ip = c->in = in;
7309+ c->in_end = in + in_len;
7310+ c->out = out;
7311+ c->cb = cb;
7312+ c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0;
7313+ c->lit1_r = c->lit2_r = c->lit3_r = 0;
7314+
7315+ op = out;
7316+ ii = c->ip;
7317+ lit = 0;
7318+ c->r1_lit = c->r1_m_len = 0;
7319+
7320+ r = init_match (c, swd, dict, dict_len, flags);
7321+ if (r != 0)
7322+ return r;
7323+ if (max_chain > 0)
7324+ swd->max_chain = max_chain;
7325+ if (nice_length > 0)
7326+ swd->nice_length = nice_length;
7327+
7328+ r = find_match (c, swd, 0, 0);
7329+ if (r != 0)
7330+ return r;
7331+ while (c->look > 0)
7332+ {
7333+ lzo_uint ahead;
7334+ lzo_uint max_ahead;
7335+ int l1, l2, l3;
7336+
7337+ c->codesize = op - out;
7338+
7339+ m_len = c->m_len;
7340+ m_off = c->m_off;
7341+
7342+ if (lit == 0)
7343+ ii = c->bp;
7344+
7345+ if (m_len < 2 ||
7346+ (m_len == 2
7347+ && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4))
7348+ || (m_len == 2 && op == out) || (op == out && lit == 0))
7349+ {
7350+
7351+ m_len = 0;
7352+ }
7353+ else if (m_len == M2_MIN_LEN)
7354+ {
7355+
7356+ if (m_off > MX_MAX_OFFSET && lit >= 4)
7357+ m_len = 0;
7358+ }
7359+
7360+ if (m_len == 0)
7361+ {
7362+
7363+ lit++;
7364+ swd->max_chain = max_chain;
7365+ r = find_match (c, swd, 1, 0);
7366+ continue;
7367+ }
7368+
7369+ if (swd->use_best_off)
7370+ better_match (swd, &m_len, &m_off);
7371+
7372+ ahead = 0;
7373+ if (try_lazy <= 0 || m_len >= max_lazy)
7374+ {
7375+
7376+ l1 = 0;
7377+ max_ahead = 0;
7378+ }
7379+ else
7380+ {
7381+
7382+ l1 = len_of_coded_match (m_len, m_off, lit);
7383+
7384+ max_ahead = LZO_MIN (try_lazy, l1 - 1);
7385+
7386+ }
7387+
7388+ while (ahead < max_ahead && c->look > m_len)
7389+ {
7390+ lzo_int lazy_match_min_gain;
7391+
7392+ if (m_len >= good_length)
7393+ swd->max_chain = max_chain >> 2;
7394+ else
7395+ swd->max_chain = max_chain;
7396+ r = find_match (c, swd, 1, 0);
7397+ ahead++;
7398+
7399+ if (c->m_len < m_len)
7400+ continue;
7401+
7402+ if (c->m_len == m_len && c->m_off >= m_off)
7403+ continue;
7404+
7405+ if (swd->use_best_off)
7406+ better_match (swd, &c->m_len, &c->m_off);
7407+
7408+ l2 = len_of_coded_match (c->m_len, c->m_off,
7409+ lit + ahead);
7410+ if (l2 < 0)
7411+ continue;
7412+
7413+ l3 = (op == out) ? -1 : len_of_coded_match (ahead,
7414+ m_off,
7415+ lit);
7416+
7417+ lazy_match_min_gain =
7418+ min_gain (ahead, lit, lit + ahead, l1, l2,
7419+ l3);
7420+ if (c->m_len >= m_len + lazy_match_min_gain)
7421+ {
7422+ c->lazy++;
7423+
7424+ if (l3 > 0)
7425+ {
7426+
7427+ op = code_run (c, op, ii, lit, ahead);
7428+ lit = 0;
7429+
7430+ op = code_match (c, op, ahead, m_off);
7431+ }
7432+ else
7433+ {
7434+ lit += ahead;
7435+ }
7436+ goto lazy_match_done;
7437+ }
7438+ }
7439+
7440+ op = code_run (c, op, ii, lit, m_len);
7441+ lit = 0;
7442+
7443+ op = code_match (c, op, m_len, m_off);
7444+ swd->max_chain = max_chain;
7445+ r = find_match (c, swd, m_len, 1 + ahead);
7446+
7447+ lazy_match_done:;
7448+ }
7449+
7450+ if (lit > 0)
7451+ op = STORE_RUN (c, op, ii, lit);
7452+
7453+ *op++ = M4_MARKER | 1;
7454+ *op++ = 0;
7455+ *op++ = 0;
7456+
7457+ c->codesize = op - out;
7458+
7459+ *out_len = op - out;
7460+
7461+ if (c->cb)
7462+ (*c->cb) (c->textsize, c->codesize);
7463+
7464+ return LZO_E_OK;
7465+}
7466+
7467+static int
7468+lzo1x_999_compress_level (const lzo_byte * in, lzo_uint in_len,
7469+ lzo_byte * out, lzo_uintp out_len,
7470+ lzo_voidp wrkmem,
7471+ const lzo_byte * dict, lzo_uint dict_len,
7472+ lzo_progress_callback_t cb, int compression_level)
7473+{
7474+ static const struct
7475+ {
7476+ int try_lazy;
7477+ lzo_uint good_length;
7478+ lzo_uint max_lazy;
7479+ lzo_uint nice_length;
7480+ lzo_uint max_chain;
7481+ lzo_uint32 flags;
7482+ } c[9] =
7483+ {
7484+ {
7485+ 0, 0, 0, 8, 4, 0},
7486+ {
7487+ 0, 0, 0, 16, 8, 0},
7488+ {
7489+ 0, 0, 0, 32, 16, 0},
7490+ {
7491+ 1, 4, 4, 16, 16, 0},
7492+ {
7493+ 1, 8, 16, 32, 32, 0},
7494+ {
7495+ 1, 8, 16, 128, 128, 0},
7496+ {
7497+ 2, 8, 32, 128, 256, 0},
7498+ {
7499+ 2, 32, 128, F, 2048, 1},
7500+ {
7501+ 2, F, F, F, 4096, 1}
7502+ };
7503+
7504+ if (compression_level < 1 || compression_level > 9)
7505+ return LZO_E_ERROR;
7506+
7507+ compression_level -= 1;
7508+ return lzo1x_999_compress_internal (in, in_len, out, out_len, wrkmem,
7509+ dict, dict_len, cb,
7510+ c[compression_level].try_lazy,
7511+ c[compression_level].good_length,
7512+ c[compression_level].max_lazy,
7513+ 0,
7514+ c[compression_level].max_chain,
7515+ c[compression_level].flags);
7516+}
7517+
7518+static int
7519+lzo1x_999_compress (const lzo_byte * in, lzo_uint in_len,
7520+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
7521+{
7522+ return lzo1x_999_compress_level (in, in_len, out, out_len, wrkmem,
7523+ NULL, 0, 0, 8);
7524+}
7525+
7526+/* minilzo.c */
7527+
7528+static const lzo_byte __lzo_copyright[] = LZO_VERSION_STRING;
7529+
7530+static lzo_uint
7531+_lzo1x_1_do_compress (const lzo_byte * in, lzo_uint in_len,
7532+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
7533+{
7534+
7535+ register const lzo_byte *ip;
7536+
7537+ lzo_byte *op;
7538+ const lzo_byte *const in_end = in + in_len;
7539+ const lzo_byte *const ip_end = in + in_len - 8 - 5;
7540+ const lzo_byte *ii;
7541+ lzo_dict_p const dict = (lzo_dict_p) wrkmem;
7542+
7543+ op = out;
7544+ ip = in;
7545+ ii = ip;
7546+
7547+ ip += 4;
7548+ for (;;)
7549+ {
7550+ register const lzo_byte *m_pos;
7551+
7552+ lzo_uint m_off;
7553+ lzo_uint m_len;
7554+ lzo_uint dindex;
7555+
7556+ DINDEX1 (dindex, ip);
7557+ GINDEX (m_pos, m_off, dict, dindex, in);
7558+ if (LZO_CHECK_MPOS_NON_DET
7559+ (m_pos, m_off, in, ip, M4_MAX_OFFSET))
7560+ goto literal;
7561+
7562+ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
7563+ goto try_match;
7564+ DINDEX2 (dindex, ip);
7565+ GINDEX (m_pos, m_off, dict, dindex, in);
7566+
7567+ if (LZO_CHECK_MPOS_NON_DET
7568+ (m_pos, m_off, in, ip, M4_MAX_OFFSET))
7569+ goto literal;
7570+ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
7571+ goto try_match;
7572+ goto literal;
7573+
7574+ try_match:
7575+ if (m_pos[0] != ip[0] || m_pos[1] != ip[1])
7576+ {
7577+ }
7578+ else
7579+ {
7580+ if (m_pos[2] == ip[2])
7581+ {
7582+ goto match;
7583+ }
7584+ else
7585+ {
7586+ }
7587+ }
7588+
7589+ literal:
7590+ UPDATE_I (dict, 0, dindex, ip, in);
7591+ ++ip;
7592+ if (ip >= ip_end)
7593+ break;
7594+ continue;
7595+
7596+ match:
7597+ UPDATE_I (dict, 0, dindex, ip, in);
7598+
7599+ if (pd (ip, ii) > 0)
7600+ {
7601+ register lzo_uint t = pd (ip, ii);
7602+
7603+ if (t <= 3)
7604+ {
7605+ op[-2] |= LZO_BYTE (t);
7606+ }
7607+ else if (t <= 18)
7608+ *op++ = LZO_BYTE (t - 3);
7609+ else
7610+ {
7611+ register lzo_uint tt = t - 18;
7612+
7613+ *op++ = 0;
7614+ while (tt > 255)
7615+ {
7616+ tt -= 255;
7617+ *op++ = 0;
7618+ }
7619+ *op++ = LZO_BYTE (tt);;
7620+ }
7621+ do
7622+ *op++ = *ii++;
7623+ while (--t > 0);
7624+ }
7625+
7626+ ip += 3;
7627+ if (m_pos[3] != *ip++ || m_pos[4] != *ip++
7628+ || m_pos[5] != *ip++ || m_pos[6] != *ip++
7629+ || m_pos[7] != *ip++ || m_pos[8] != *ip++)
7630+ {
7631+ --ip;
7632+ m_len = ip - ii;
7633+
7634+ if (m_off <= M2_MAX_OFFSET)
7635+ {
7636+ m_off -= 1;
7637+
7638+ *op++ = LZO_BYTE (((m_len -
7639+ 1) << 5) | ((m_off & 7) <<
7640+ 2));
7641+ *op++ = LZO_BYTE (m_off >> 3);
7642+ }
7643+ else if (m_off <= M3_MAX_OFFSET)
7644+ {
7645+ m_off -= 1;
7646+ *op++ = LZO_BYTE (M3_MARKER | (m_len - 2));
7647+ goto m3_m4_offset;
7648+ }
7649+ else
7650+
7651+ {
7652+ m_off -= 0x4000;
7653+
7654+ *op++ = LZO_BYTE (M4_MARKER |
7655+ ((m_off & 0x4000) >> 11) |
7656+ (m_len - 2));
7657+ goto m3_m4_offset;
7658+ }
7659+ }
7660+ else
7661+ {
7662+ {
7663+ const lzo_byte *end = in_end;
7664+ const lzo_byte *m = m_pos + M2_MAX_LEN + 1;
7665+ while (ip < end && *m == *ip)
7666+ m++, ip++;
7667+ m_len = (ip - ii);
7668+ }
7669+
7670+
7671+ if (m_off <= M3_MAX_OFFSET)
7672+ {
7673+ m_off -= 1;
7674+ if (m_len <= 33)
7675+ *op++ = LZO_BYTE (M3_MARKER |
7676+ (m_len - 2));
7677+ else
7678+ {
7679+ m_len -= 33;
7680+ *op++ = M3_MARKER | 0;
7681+ goto m3_m4_len;
7682+ }
7683+ }
7684+ else
7685+ {
7686+ m_off -= 0x4000;
7687+
7688+ if (m_len <= M4_MAX_LEN)
7689+ *op++ = LZO_BYTE (M4_MARKER |
7690+ ((m_off & 0x4000) >>
7691+ 11) | (m_len - 2));
7692+
7693+ else
7694+ {
7695+ m_len -= M4_MAX_LEN;
7696+ *op++ = LZO_BYTE (M4_MARKER |
7697+ ((m_off & 0x4000) >>
7698+ 11));
7699+ m3_m4_len:
7700+ while (m_len > 255)
7701+ {
7702+ m_len -= 255;
7703+ *op++ = 0;
7704+ }
7705+
7706+ *op++ = LZO_BYTE (m_len);
7707+ }
7708+ }
7709+
7710+ m3_m4_offset:
7711+ *op++ = LZO_BYTE ((m_off & 63) << 2);
7712+ *op++ = LZO_BYTE (m_off >> 6);
7713+ }
7714+ ii = ip;
7715+ if (ip >= ip_end)
7716+ break;
7717+ }
7718+
7719+ *out_len = op - out;
7720+ return pd (in_end, ii);
7721+}
7722+
7723+static int
7724+lzo1x_1_compress (const lzo_byte * in, lzo_uint in_len,
7725+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
7726+{
7727+ lzo_byte *op = out;
7728+ lzo_uint t;
7729+
7730+ if (in_len <= M2_MAX_LEN + 5)
7731+ t = in_len;
7732+ else
7733+ {
7734+ t = _lzo1x_1_do_compress (in, in_len, op, out_len, wrkmem);
7735+ op += *out_len;
7736+ }
7737+
7738+ if (t > 0)
7739+ {
7740+ const lzo_byte *ii = in + in_len - t;
7741+
7742+ if (op == out && t <= 238)
7743+ *op++ = LZO_BYTE (17 + t);
7744+ else if (t <= 3)
7745+ op[-2] |= LZO_BYTE (t);
7746+ else if (t <= 18)
7747+ *op++ = LZO_BYTE (t - 3);
7748+ else
7749+ {
7750+ lzo_uint tt = t - 18;
7751+
7752+ *op++ = 0;
7753+ while (tt > 255)
7754+ {
7755+ tt -= 255;
7756+ *op++ = 0;
7757+ }
7758+
7759+ *op++ = LZO_BYTE (tt);
7760+ }
7761+ do
7762+ *op++ = *ii++;
7763+ while (--t > 0);
7764+ }
7765+
7766+ *op++ = M4_MARKER | 1;
7767+ *op++ = 0;
7768+ *op++ = 0;
7769+
7770+ *out_len = op - out;
7771+ return 0;
7772+}
7773+
7774+static int
7775+lzo1x_decompress (const lzo_byte * in, lzo_uint in_len,
7776+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
7777+{
7778+ register lzo_byte *op;
7779+ register const lzo_byte *ip;
7780+ register lzo_uint t;
7781+
7782+ register const lzo_byte *m_pos;
7783+
7784+ const lzo_byte *const ip_end = in + in_len;
7785+ lzo_byte *const op_end = out + *out_len;
7786+
7787+ *out_len = 0;
7788+
7789+ op = out;
7790+ ip = in;
7791+
7792+ if (*ip > 17)
7793+ {
7794+ t = *ip++ - 17;
7795+ if (t < 4)
7796+ goto match_next;
7797+ NEED_OP (t);
7798+ NEED_IP (t + 1);
7799+ do
7800+ *op++ = *ip++;
7801+ while (--t > 0);
7802+ goto first_literal_run;
7803+ }
7804+
7805+ while (TEST_IP && TEST_OP)
7806+ {
7807+ t = *ip++;
7808+ if (t >= 16)
7809+ goto match;
7810+ if (t == 0)
7811+ {
7812+ NEED_IP (1);
7813+ while (*ip == 0)
7814+ {
7815+ t += 255;
7816+ ip++;
7817+ NEED_IP (1);
7818+ }
7819+ t += 15 + *ip++;
7820+ }
7821+ NEED_OP (t + 3);
7822+ NEED_IP (t + 4);
7823+ if (PTR_ALIGNED2_4 (op, ip))
7824+ {
7825+ COPY4 (op, ip);
7826+
7827+ op += 4;
7828+ ip += 4;
7829+ if (--t > 0)
7830+ {
7831+ if (t >= 4)
7832+ {
7833+ do
7834+ {
7835+ COPY4 (op, ip);
7836+ op += 4;
7837+ ip += 4;
7838+ t -= 4;
7839+ }
7840+ while (t >= 4);
7841+ if (t > 0)
7842+ do
7843+ *op++ = *ip++;
7844+ while (--t > 0);
7845+ }
7846+ else
7847+ do
7848+ *op++ = *ip++;
7849+ while (--t > 0);
7850+ }
7851+ }
7852+ else
7853+ {
7854+ *op++ = *ip++;
7855+ *op++ = *ip++;
7856+ *op++ = *ip++;
7857+ do
7858+ *op++ = *ip++;
7859+ while (--t > 0);
7860+ }
7861+ first_literal_run:
7862+
7863+ t = *ip++;
7864+ if (t >= 16)
7865+ goto match;
7866+
7867+ m_pos = op - (1 + M2_MAX_OFFSET);
7868+ m_pos -= t >> 2;
7869+ m_pos -= *ip++ << 2;
7870+ TEST_LOOKBEHIND (m_pos, out);
7871+ NEED_OP (3);
7872+ *op++ = *m_pos++;
7873+ *op++ = *m_pos++;
7874+ *op++ = *m_pos;
7875+
7876+ goto match_done;
7877+
7878+ while (TEST_IP && TEST_OP)
7879+ {
7880+ match:
7881+ if (t >= 64)
7882+ {
7883+ m_pos = op - 1;
7884+ m_pos -= (t >> 2) & 7;
7885+ m_pos -= *ip++ << 3;
7886+ t = (t >> 5) - 1;
7887+ TEST_LOOKBEHIND (m_pos, out);
7888+ NEED_OP (t + 3 - 1);
7889+ goto copy_match;
7890+
7891+ }
7892+ else if (t >= 32)
7893+ {
7894+ t &= 31;
7895+ if (t == 0)
7896+ {
7897+ NEED_IP (1);
7898+ while (*ip == 0)
7899+ {
7900+ t += 255;
7901+ ip++;
7902+ NEED_IP (1);
7903+ }
7904+ t += 31 + *ip++;
7905+ }
7906+
7907+ m_pos = op - 1;
7908+ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
7909+
7910+ ip += 2;
7911+ }
7912+ else if (t >= 16)
7913+ {
7914+ m_pos = op;
7915+ m_pos -= (t & 8) << 11;
7916+
7917+ t &= 7;
7918+ if (t == 0)
7919+ {
7920+ NEED_IP (1);
7921+ while (*ip == 0)
7922+ {
7923+ t += 255;
7924+ ip++;
7925+ NEED_IP (1);
7926+ }
7927+ t += 7 + *ip++;
7928+ }
7929+
7930+ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
7931+
7932+ ip += 2;
7933+ if (m_pos == op)
7934+ goto eof_found;
7935+ m_pos -= 0x4000;
7936+ }
7937+ else
7938+ {
7939+
7940+ m_pos = op - 1;
7941+ m_pos -= t >> 2;
7942+ m_pos -= *ip++ << 2;
7943+ TEST_LOOKBEHIND (m_pos, out);
7944+ NEED_OP (2);
7945+ *op++ = *m_pos++;
7946+ *op++ = *m_pos;
7947+
7948+ goto match_done;
7949+ }
7950+
7951+ TEST_LOOKBEHIND (m_pos, out);
7952+ NEED_OP (t + 3 - 1);
7953+ if (t >= 2 * 4 - (3 - 1)
7954+ && PTR_ALIGNED2_4 (op, m_pos))
7955+ {
7956+ COPY4 (op, m_pos);
7957+ op += 4;
7958+ m_pos += 4;
7959+ t -= 4 - (3 - 1);
7960+ do
7961+ {
7962+ COPY4 (op, m_pos);
7963+ op += 4;
7964+ m_pos += 4;
7965+ t -= 4;
7966+ }
7967+ while (t >= 4);
7968+ if (t > 0)
7969+ do
7970+ *op++ = *m_pos++;
7971+ while (--t > 0);
7972+ }
7973+ else
7974+
7975+ {
7976+ copy_match:
7977+ *op++ = *m_pos++;
7978+ *op++ = *m_pos++;
7979+ do
7980+ *op++ = *m_pos++;
7981+ while (--t > 0);
7982+ }
7983+
7984+ match_done:
7985+ t = ip[-2] & 3;
7986+
7987+ if (t == 0)
7988+ break;
7989+
7990+ match_next:
7991+ NEED_OP (t);
7992+ NEED_IP (t + 1);
7993+ do
7994+ *op++ = *ip++;
7995+ while (--t > 0);
7996+ t = *ip++;
7997+ }
7998+ }
7999+ *out_len = op - out;
8000+ return LZO_E_EOF_NOT_FOUND;
8001+
8002+ eof_found:
8003+ *out_len = op - out;
8004+ return (ip == ip_end ? LZO_E_OK :
8005+ (ip <
8006+ ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
8007+
8008+ input_overrun:
8009+ *out_len = op - out;
8010+ return LZO_E_INPUT_OVERRUN;
8011+
8012+ output_overrun:
8013+ *out_len = op - out;
8014+ return LZO_E_OUTPUT_OVERRUN;
8015+
8016+ lookbehind_overrun:
8017+ *out_len = op - out;
8018+ return LZO_E_LOOKBEHIND_OVERRUN;
8019+}
8020+
8021+/* lzo1x_oo.ch */
8022+
8023+#define NO_LIT LZO_UINT_MAX
8024+
8025+static void
8026+copy2 (lzo_byte * ip, const lzo_byte * m_pos, lzo_ptrdiff_t off)
8027+{
8028+ ip[0] = m_pos[0];
8029+ if (off == 1)
8030+ ip[1] = m_pos[0];
8031+ else
8032+ ip[1] = m_pos[1];
8033+}
8034+
8035+static void
8036+copy3 (lzo_byte * ip, const lzo_byte * m_pos, lzo_ptrdiff_t off)
8037+{
8038+ ip[0] = m_pos[0];
8039+ if (off == 1)
8040+ {
8041+ ip[2] = ip[1] = m_pos[0];
8042+ }
8043+ else if (off == 2)
8044+ {
8045+ ip[1] = m_pos[1];
8046+ ip[2] = m_pos[0];
8047+ }
8048+ else
8049+ {
8050+ ip[1] = m_pos[1];
8051+ ip[2] = m_pos[2];
8052+ }
8053+}
8054+
8055+static int
8056+lzo1x_optimize (lzo_byte * in, lzo_uint in_len,
8057+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
8058+{
8059+ register lzo_byte *op;
8060+ register lzo_byte *ip;
8061+ register lzo_uint t;
8062+ register lzo_byte *m_pos;
8063+ lzo_uint nl;
8064+ const lzo_byte *const ip_end = in + in_len;
8065+ const lzo_byte *const op_end = out + *out_len;
8066+ lzo_byte *litp = NULL;
8067+ lzo_uint lit = 0;
8068+ lzo_uint next_lit = NO_LIT;
8069+ long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;
8070+
8071+ *out_len = 0;
8072+
8073+ op = out;
8074+ ip = in;
8075+
8076+ if (*ip > 17)
8077+ {
8078+ t = *ip++ - 17;
8079+ if (t < 4)
8080+ goto match_next;
8081+ goto first_literal_run;
8082+ }
8083+
8084+ while (TEST_IP && TEST_OP)
8085+ {
8086+ t = *ip++;
8087+ if (t >= 16)
8088+ goto match;
8089+ litp = ip - 1;
8090+ if (t == 0)
8091+ {
8092+ t = 15;
8093+ while (*ip == 0)
8094+ t += 255, ip++;
8095+ t += *ip++;
8096+ }
8097+ lit = t + 3;
8098+ copy_literal_run:
8099+ *op++ = *ip++;
8100+ *op++ = *ip++;
8101+ *op++ = *ip++;
8102+ first_literal_run:
8103+ do
8104+ *op++ = *ip++;
8105+ while (--t > 0);
8106+
8107+ t = *ip++;
8108+
8109+ if (t >= 16)
8110+ goto match;
8111+ m_pos = op - 1 - 0x800;
8112+ m_pos -= t >> 2;
8113+ m_pos -= *ip++ << 2;
8114+ *op++ = *m_pos++;
8115+ *op++ = *m_pos++;
8116+ *op++ = *m_pos++;
8117+ lit = 0;
8118+ goto match_done;
8119+
8120+ while (TEST_IP && TEST_OP)
8121+ {
8122+ if (t < 16)
8123+ {
8124+ m_pos = op - 1;
8125+ m_pos -= t >> 2;
8126+ m_pos -= *ip++ << 2;
8127+
8128+ if (litp == NULL)
8129+ goto copy_m1;
8130+
8131+ nl = ip[-2] & 3;
8132+ if (nl == 0 && lit == 1 && ip[0] >= 16)
8133+ {
8134+ next_lit = nl;
8135+ lit += 2;
8136+ *litp = LZO_BYTE ((*litp & ~3) | lit);
8137+ copy2 (ip - 2, m_pos, op - m_pos);
8138+ o_m1_a++;
8139+ }
8140+ else if (nl == 0 && ip[0] < 16 && ip[0] != 0
8141+ && (lit + 2 + ip[0] < 16))
8142+ {
8143+ t = *ip++;
8144+ *litp &= ~3;
8145+ copy2 (ip - 3 + 1, m_pos, op - m_pos);
8146+ litp += 2;
8147+ if (lit > 0)
8148+ memmove (litp + 1, litp, lit);
8149+ lit += 2 + t + 3;
8150+ *litp = LZO_BYTE (lit - 3);
8151+
8152+ o_m1_b++;
8153+ *op++ = *m_pos++;
8154+ *op++ = *m_pos++;
8155+ goto copy_literal_run;
8156+ }
8157+ copy_m1:
8158+ *op++ = *m_pos++;
8159+ *op++ = *m_pos++;
8160+ }
8161+ else
8162+ {
8163+ match:
8164+ if (t >= 64)
8165+ {
8166+ m_pos = op - 1;
8167+ m_pos -= (t >> 2) & 7;
8168+ m_pos -= *ip++ << 3;
8169+ t = (t >> 5) - 1;
8170+ if (litp == NULL)
8171+ goto copy_m;
8172+
8173+ nl = ip[-2] & 3;
8174+ if (t == 1 && lit > 3 && nl == 0 &&
8175+ ip[0] < 16 && ip[0] != 0
8176+ && (lit + 3 + ip[0] < 16))
8177+ {
8178+ t = *ip++;
8179+ copy3 (ip - 1 - 2, m_pos,
8180+ op - m_pos);
8181+ lit += 3 + t + 3;
8182+ *litp = LZO_BYTE (lit - 3);
8183+ o_m2++;
8184+ *op++ = *m_pos++;
8185+ *op++ = *m_pos++;
8186+ *op++ = *m_pos++;
8187+ goto copy_literal_run;
8188+ }
8189+ }
8190+ else
8191+ {
8192+ if (t >= 32)
8193+ {
8194+ t &= 31;
8195+ if (t == 0)
8196+ {
8197+ t = 31;
8198+ while (*ip == 0)
8199+ t += 255,
8200+ ip++;
8201+ t += *ip++;
8202+ }
8203+ m_pos = op - 1;
8204+ m_pos -= *ip++ >> 2;
8205+ m_pos -= *ip++ << 6;
8206+ }
8207+ else
8208+ {
8209+ m_pos = op;
8210+ m_pos -= (t & 8) << 11;
8211+ t &= 7;
8212+ if (t == 0)
8213+ {
8214+ t = 7;
8215+ while (*ip == 0)
8216+ t += 255,
8217+ ip++;
8218+ t += *ip++;
8219+ }
8220+ m_pos -= *ip++ >> 2;
8221+ m_pos -= *ip++ << 6;
8222+ if (m_pos == op)
8223+ goto eof_found;
8224+ m_pos -= 0x4000;
8225+ }
8226+ if (litp == NULL)
8227+ goto copy_m;
8228+
8229+ nl = ip[-2] & 3;
8230+ if (t == 1 && lit == 0 && nl == 0
8231+ && ip[0] >= 16)
8232+ {
8233+ next_lit = nl;
8234+ lit += 3;
8235+ *litp = LZO_BYTE ((*litp & ~3)
8236+ | lit);
8237+ copy3 (ip - 3, m_pos,
8238+ op - m_pos);
8239+ o_m3_a++;
8240+ }
8241+ else if (t == 1 && lit <= 3 && nl == 0
8242+ && ip[0] < 16 && ip[0] != 0
8243+ && (lit + 3 + ip[0] < 16))
8244+ {
8245+ t = *ip++;
8246+ *litp &= ~3;
8247+ copy3 (ip - 4 + 1, m_pos,
8248+ op - m_pos);
8249+ litp += 2;
8250+ if (lit > 0)
8251+ memmove (litp + 1,
8252+ litp, lit);
8253+ lit += 3 + t + 3;
8254+ *litp = LZO_BYTE (lit - 3);
8255+
8256+ o_m3_b++;
8257+ *op++ = *m_pos++;
8258+ *op++ = *m_pos++;
8259+ *op++ = *m_pos++;
8260+ goto copy_literal_run;
8261+ }
8262+ }
8263+ copy_m:
8264+ *op++ = *m_pos++;
8265+ *op++ = *m_pos++;
8266+ do
8267+ *op++ = *m_pos++;
8268+ while (--t > 0);
8269+ }
8270+
8271+ match_done:
8272+ if (next_lit == NO_LIT)
8273+ {
8274+ t = ip[-2] & 3;
8275+ lit = t;
8276+ litp = ip - 2;
8277+ }
8278+ else
8279+ t = next_lit;
8280+ next_lit = NO_LIT;
8281+ if (t == 0)
8282+ break;
8283+ match_next:
8284+ do
8285+ *op++ = *ip++;
8286+ while (--t > 0);
8287+ t = *ip++;
8288+ }
8289+ }
8290+
8291+ *out_len = op - out;
8292+ return LZO_E_EOF_NOT_FOUND;
8293+
8294+ eof_found:
8295+ *out_len = op - out;
8296+ return (ip == ip_end ? LZO_E_OK :
8297+ (ip <
8298+ ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
8299+}
8300+
8301+/* interface to jffs2 bbc follows */
8302+
8303+#include "jffs2_bbc_framework.h"
8304+
8305+#define BLOCKSIZE 4096
8306+#define OUTBLOCKSIZE (BLOCKSIZE + BLOCKSIZE / 64 + 16 + 3)
8307+
8308+#define JFFS2_BBC_LZO_BLOCK_SIGN {0x3f, 0x47, 0x5a, 0x18}
8309+
8310+static int
8311+jffs2_bbc_lzo_compressor_init (void);
8312+
8313+static void
8314+jffs2_bbc_lzo_compressor_deinit (void);
8315+
8316+static int
8317+jffs2_bbc_lzo_compress (void *model, unsigned char *input,
8318+ unsigned char *output, unsigned long *sourcelen,
8319+ unsigned long *dstlen);
8320+
8321+static int
8322+jffs2_bbc_lzo_estimate (void *model, unsigned char *input,
8323+ unsigned long sourcelen, unsigned long *dstlen,
8324+ unsigned long *readtime, unsigned long *writetime);
8325+
8326+static int
8327+jffs2_bbc_lzo_decompress (void *model, unsigned char *input,
8328+ unsigned char *output, unsigned long sourcelen,
8329+ unsigned long dstlen);
8330+
8331+static char *
8332+jffs2_bbc_lzo_proc_info (void);
8333+
8334+static int
8335+jffs2_bbc_lzo_proc_command (char *command);
8336+
8337+struct jffs2_bbc_compressor_type jffs2_bbc_lzo = {
8338+ "lzo",
8339+ 0,
8340+ JFFS2_BBC_LZO_BLOCK_SIGN,
8341+ jffs2_bbc_lzo_compressor_init,
8342+ NULL,
8343+ NULL,
8344+ jffs2_bbc_lzo_compressor_deinit,
8345+ jffs2_bbc_lzo_compress,
8346+ jffs2_bbc_lzo_estimate,
8347+ jffs2_bbc_lzo_decompress,
8348+ jffs2_bbc_lzo_proc_info,
8349+ jffs2_bbc_lzo_proc_command
8350+};
8351+
8352+static int
8353+no_lzo1x_optimize (lzo_byte * src, lzo_uint src_len,
8354+ lzo_byte * dst, lzo_uintp dst_len, lzo_voidp wrkmem)
8355+{
8356+ return 0;
8357+}
8358+
8359+#ifdef __KERNEL__
8360+static lzo_compress_t lzo1x_compressor = lzo1x_1_compress;
8361+static lzo_optimize_t lzo1x_optimizer = no_lzo1x_optimize;
8362+static int lzo1x_compressor_type = 1;
8363+static int lzo1x_optimize_type = 0;
8364+static unsigned long lzo1x_compressor_memsize = LZO1X_1_MEM_COMPRESS;
8365+#else
8366+static lzo_compress_t lzo1x_compressor = lzo1x_999_compress;
8367+static lzo_optimize_t lzo1x_optimizer = lzo1x_optimize;
8368+static int lzo1x_compressor_type = 999;
8369+static int lzo1x_optimize_type = 1;
8370+static unsigned long lzo1x_compressor_memsize = LZO1X_999_MEM_COMPRESS;
8371+#endif
8372+
8373+static lzo_bytep wrkmem = NULL; /* temporary buffer for compression, used by lzo */
8374+static lzo_bytep cmprssmem = NULL; /* temporary buffer for compression, used by interface */
8375+
8376+static int
8377+jffs2_bbc_lzo_compressor_init (void)
8378+{
8379+ wrkmem = (lzo_bytep) jffs2_bbc_malloc (lzo1x_compressor_memsize);
8380+ cmprssmem = (lzo_bytep) jffs2_bbc_malloc (OUTBLOCKSIZE);
8381+ return !(wrkmem && cmprssmem);
8382+}
8383+
8384+static void
8385+jffs2_bbc_lzo_compressor_deinit (void)
8386+{
8387+ jffs2_bbc_free (wrkmem);
8388+ jffs2_bbc_free (cmprssmem);
8389+}
8390+
8391+static int
8392+jffs2_bbc_lzo_compress (void *model, unsigned char *input,
8393+ unsigned char *output, unsigned long *sourcelen,
8394+ unsigned long *dstlen)
8395+{
8396+ lzo_uint csize = OUTBLOCKSIZE;
8397+ lzo_uint isize = *sourcelen;
8398+ int retval;
8399+ if ((retval =
8400+ lzo1x_compressor (input, *sourcelen, cmprssmem, &csize,
8401+ wrkmem)) != LZO_E_OK)
8402+ {
8403+ *sourcelen = *dstlen = 0;
8404+ return retval;
8405+ }
8406+ else
8407+ {
8408+ retval = lzo1x_optimizer (cmprssmem, csize, input, &isize,
8409+ NULL);
8410+ csize += 2;
8411+ if (csize <= *dstlen) {
8412+ *dstlen = csize;
8413+ *(output++) = jffs2_bbc_lzo.block_sign[0];
8414+ *(output++) = jffs2_bbc_lzo.block_sign[1];
8415+ memcpy (output, cmprssmem, csize - 2);
8416+ return retval;
8417+ } else {
8418+ *sourcelen = *dstlen = 0;
8419+ return -1;
8420+ }
8421+ }
8422+}
8423+
8424+static int
8425+jffs2_bbc_lzo_estimate (void *model, unsigned char *input,
8426+ unsigned long sourcelen, unsigned long *dstlen,
8427+ unsigned long *readtime, unsigned long *writetime)
8428+{
8429+ *dstlen = sourcelen * 55 / 100;
8430+ *readtime = JFFS2_BBC_ZLIB_READ_TIME / 2;
8431+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 8 / 10; /* LZO1X-1 is much-much faster,
8432+ but LZO1X-999 is slow. The default mode for inside kernel compression is LZO1X-1
8433+ This should be *0.4 really */
8434+ return 0;
8435+}
8436+
8437+static int
8438+jffs2_bbc_lzo_decompress (void *model, unsigned char *input,
8439+ unsigned char *output, unsigned long sourcelen,
8440+ unsigned long dstlen)
8441+{
8442+ lzo_uint outlen = dstlen;
8443+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzo.block_sign[0] ) ||
8444+ ( *(input++) != (unsigned char)jffs2_bbc_lzo.block_sign[1] )
8445+ ) {
8446+ return -1;
8447+ } else {
8448+ return lzo1x_decompress (input, sourcelen - 2, output, &outlen, NULL);
8449+ }
8450+}
8451+
8452+static char *
8453+jffs2_bbc_lzo_proc_info (void)
8454+{
8455+ if (lzo1x_compressor_type == 1)
8456+ {
8457+ if (lzo1x_optimize_type == 1)
8458+ {
8459+ return "LZO1X-1 compression with optimization";
8460+ }
8461+ else
8462+ {
8463+ return "LZO1X-1 compression without optimization";
8464+ }
8465+ }
8466+ else if (lzo1x_compressor_type == 999)
8467+ {
8468+ if (lzo1x_optimize_type == 1)
8469+ {
8470+ return "LZO1X-999 compression with optimization";
8471+ }
8472+ else
8473+ {
8474+ return "LZO1X-999 compression without optimization";
8475+ }
8476+ }
8477+ else
8478+ {
8479+ return "Unknown configuration!";
8480+ }
8481+}
8482+
8483+static int
8484+jffs2_bbc_lzo_proc_command (char *command)
8485+{
8486+ switch (*command)
8487+ {
8488+ case 'o':
8489+ /* switch optimization off */
8490+ lzo1x_optimizer = no_lzo1x_optimize;
8491+ lzo1x_optimize_type = 0;
8492+ jffs2_bbc_print1 ("Compression optimization switched off.\n");
8493+ return 0;
8494+ case 'O':
8495+ /* switch optimization on */
8496+ lzo1x_optimizer = lzo1x_optimize;
8497+ lzo1x_optimize_type = 1;
8498+ jffs2_bbc_print1 ("Compression optimization switched on.\n");
8499+ return 0;
8500+ case '1':
8501+ /* switch compression to LZO1X-1 */
8502+ jffs2_bbc_free (wrkmem);
8503+ lzo1x_compressor_type = 1;
8504+ lzo1x_compressor = lzo1x_1_compress;
8505+ lzo1x_compressor_memsize = LZO1X_1_MEM_COMPRESS;
8506+ wrkmem = (lzo_bytep)
8507+ jffs2_bbc_malloc (lzo1x_compressor_memsize);
8508+ jffs2_bbc_print1 ("Compression type switched to LZO1X-1.\n");
8509+ return 0;
8510+ case '9':
8511+ /* switch compression to LZO1X-999 */
8512+ jffs2_bbc_free (wrkmem);
8513+ lzo1x_compressor_type = 999;
8514+ lzo1x_compressor = lzo1x_999_compress;
8515+ lzo1x_compressor_memsize = LZO1X_999_MEM_COMPRESS;
8516+ wrkmem = (lzo_bytep)
8517+ jffs2_bbc_malloc (lzo1x_compressor_memsize);
8518+ jffs2_bbc_print1
8519+ ("Compression type switched to LZO1X-999.\n");
8520+ return 0;
8521+ default:
8522+ jffs2_bbc_print1 ("Unknown command!\n");
8523+ return 0;
8524+ }
8525+}
8526+
8527+
8528+struct jffs2_bbc_compressor_type *
8529+jffs2_bbc_lzo_init (int mode)
8530+{
8531+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzo) == 0)
8532+ {
8533+ return &jffs2_bbc_lzo;
8534+ }
8535+ else
8536+ {
8537+ return NULL;
8538+ }
8539+}
8540+
8541+void
8542+jffs2_bbc_lzo_deinit (void)
8543+{
8544+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzo);
8545+}
8546--- /dev/null
8547+++ b/fs/jffs2/jffs2_bbc_lzss_comp.c
8548@@ -0,0 +1,385 @@
8549+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
8550+
8551+/*
8552+ jffs2_bbc_lzss_comp.c -- Lempel-Ziv-Storer-Szymanski compression module for jffs2
8553+ Copyright (C) 2004 Patrik Kluba
8554+ Based on the LZSS source included in LDS (lossless datacompression sources)
8555+ Block-compression modifications by Patrik Kluba
8556+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
8557+*/
8558+
8559+/*
8560+Original copyright follows:
8561+
8562+**************************************************************
8563+ LZSS.C -- A Data Compression Program
8564+**************************************************************
8565+ 4/6/1989 Haruhiko Okumura
8566+ Use, distribute, and modify this program freely.
8567+ Please send me your improved versions.
8568+ PC-VAN SCIENCE
8569+ NIFTY-Serve PAF01022
8570+ CompuServe 74050,1022
8571+**************************************************************
8572+
8573+*/
8574+
8575+/*
8576+
8577+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
8578+ Initial release
8579+
8580+*/
8581+
8582+/* lzss.c */
8583+
8584+#define N 4096 /* size of ring buffer */
8585+#define F 18 /* upper limit for match_length */
8586+#define THRESHOLD 2 /* encode string into position and length
8587+ if match_length is greater than this */
8588+#define NIL N /* index for root of binary search trees */
8589+
8590+static unsigned char
8591+ text_buf[N + F - 1]; /* ring buffer of size N,
8592+ with extra F-1 bytes to facilitate string comparison */
8593+static unsigned long match_position, match_length; /* of longest match. These are
8594+ set by the InsertNode() procedure. */
8595+static unsigned long lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
8596+ parents -- These constitute binary search trees. */
8597+
8598+static void InitTree(void) /* initialize trees */
8599+{
8600+ unsigned long i;
8601+
8602+ /* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
8603+ left children of node i. These nodes need not be initialized.
8604+ Also, dad[i] is the parent of node i. These are initialized to
8605+ NIL (= N), which stands for 'not used.'
8606+ For i = 0 to 255, rson[N + i + 1] is the root of the tree
8607+ for strings that begin with character i. These are initialized
8608+ to NIL. Note there are 256 trees. */
8609+
8610+ for (i = N + 1; i <= N + 256; i++) rson[i] = NIL;
8611+ for (i = 0; i < N; i++) dad[i] = NIL;
8612+}
8613+
8614+static void InsertNode(unsigned long r)
8615+ /* Inserts string of length F, text_buf[r..r+F-1], into one of the
8616+ trees (text_buf[r]'th tree) and returns the longest-match position
8617+ and length via the global variables match_position and match_length.
8618+ If match_length = F, then removes the old node in favor of the new
8619+ one, because the old one will be deleted sooner.
8620+ Note r plays double role, as tree node and position in buffer. */
8621+{
8622+ unsigned long i, p;
8623+ unsigned char *key;
8624+ signed long cmp;
8625+
8626+ cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
8627+ rson[r] = lson[r] = NIL; match_length = 0;
8628+ for ( ; ; ) {
8629+ if (cmp >= 0) {
8630+ if (rson[p] != NIL) p = rson[p];
8631+ else { rson[p] = r; dad[r] = p; return; }
8632+ } else {
8633+ if (lson[p] != NIL) p = lson[p];
8634+ else { lson[p] = r; dad[r] = p; return; }
8635+ }
8636+ for (i = 1; i < F; i++)
8637+ if ((cmp = key[i] - text_buf[p + i]) != 0) break;
8638+ if (i > match_length) {
8639+ match_position = p;
8640+ if ((match_length = i) >= F) break;
8641+ }
8642+ }
8643+ dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
8644+ dad[lson[p]] = r; dad[rson[p]] = r;
8645+ if (rson[dad[p]] == p) rson[dad[p]] = r;
8646+ else lson[dad[p]] = r;
8647+ dad[p] = NIL; /* remove p */
8648+}
8649+
8650+static void DeleteNode(unsigned long p) /* deletes node p from tree */
8651+{
8652+ unsigned long q;
8653+
8654+ if (dad[p] == NIL) return; /* not in tree */
8655+ if (rson[p] == NIL) q = lson[p];
8656+ else if (lson[p] == NIL) q = rson[p];
8657+ else {
8658+ q = lson[p];
8659+ if (rson[q] != NIL) {
8660+ do { q = rson[q]; } while (rson[q] != NIL);
8661+ rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
8662+ lson[q] = lson[p]; dad[lson[p]] = q;
8663+ }
8664+ rson[q] = rson[p]; dad[rson[p]] = q;
8665+ }
8666+ dad[q] = dad[p];
8667+ if (rson[dad[p]] == p) rson[dad[p]] = q; else lson[dad[p]] = q;
8668+ dad[p] = NIL;
8669+}
8670+
8671+/* modified for block compression */
8672+/* on return, srclen will contain the number of successfully compressed bytes
8673+ and dstlen will contain completed compressed bytes */
8674+
8675+static int Encode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long *srclen,
8676+ unsigned long *dstlen)
8677+{
8678+ unsigned long i, len, r, c, s, last_match_length, code_buf_ptr;
8679+ unsigned char code_buf[17], mask;
8680+ unsigned char *ip, *op;
8681+ unsigned long written = 0;
8682+ unsigned long read = 0;
8683+ unsigned char *srcend = srcbuf + *srclen;
8684+ unsigned char *dstend = dstbuf + *dstlen;
8685+ ip = srcbuf;
8686+ op = dstbuf;
8687+ InitTree(); /* initialize trees */
8688+ code_buf[0] = 0; /* code_buf[1..16] saves eight units of code, and
8689+ code_buf[0] works as eight flags, "1" representing that the unit
8690+ is an unencoded letter (1 byte), "0" a position-and-length pair
8691+ (2 bytes). Thus, eight units require at most 16 bytes of code. */
8692+ code_buf_ptr = mask = 1;
8693+ s = 0; r = N - F;
8694+ for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
8695+ any character that will appear often. */
8696+ for (len = 0; (len < F) && (ip < srcend); len++)
8697+ text_buf[r + len] = *(ip++); /* Read F bytes into the last F bytes of
8698+ the buffer */
8699+ read = len;
8700+ for (i = 1; i <= F; i++) InsertNode(r - i); /* Insert the F strings,
8701+ each of which begins with one or more 'space' characters. Note
8702+ the order in which these strings are inserted. This way,
8703+ degenerate trees will be less likely to occur. */
8704+ InsertNode(r); /* Finally, insert the whole string just read. The
8705+ global variables match_length and match_position are set. */
8706+ do {
8707+ if (match_length > len) match_length = len; /* match_length
8708+ may be spuriously long near the end of text. */
8709+ if (match_length <= THRESHOLD) {
8710+ match_length = 1; /* Not long enough match. Send one byte. */
8711+ code_buf[0] |= mask; /* 'send one byte' flag */
8712+ code_buf[code_buf_ptr++] = text_buf[r]; /* Send uncoded. */
8713+ } else {
8714+ code_buf[code_buf_ptr++] = match_position;
8715+ code_buf[code_buf_ptr++] = (((match_position >> 4) & 0xf0)
8716+ | (match_length - (THRESHOLD + 1))); /* Send position and
8717+ length pair. Note match_length > THRESHOLD. */
8718+ }
8719+ if ((mask <<= 1) == 0) { /* Shift mask left one bit. */
8720+ if ((op + code_buf_ptr) > dstend) {
8721+ *dstlen = written; /* written contains bytes of complete compressed
8722+ code */
8723+ return -1;
8724+ };
8725+ for (i = 0; i < code_buf_ptr; *(op++) = code_buf[i++]); /* Send at most 8 units of */
8726+ /* code together */
8727+ written += code_buf_ptr;
8728+ *srclen = read; /* this many bytes have been successfully compressed */
8729+ code_buf[0] = 0; code_buf_ptr = mask = 1;
8730+ }
8731+ last_match_length = match_length;
8732+ for (i = 0; (i < last_match_length) && (ip < srcend); i++) {
8733+ c = *(ip++);
8734+ DeleteNode(s); /* Delete old strings and */
8735+ text_buf[s] = c; /* read new bytes */
8736+ if (s < F - 1) text_buf[s + N] = c; /* If the position is
8737+ near the end of buffer, extend the buffer to make
8738+ string comparison easier. */
8739+ s = (s + 1) & (N - 1); r = (r + 1) & (N - 1);
8740+ /* Since this is a ring buffer, increment the position
8741+ modulo N. */
8742+ InsertNode(r); /* Register the string in text_buf[r..r+F-1] */
8743+ }
8744+ read += i;
8745+ while (i++ < last_match_length) { /* After the end of text, */
8746+ DeleteNode(s); /* no need to read, but */
8747+ s = (s + 1) & (N - 1); r = (r + 1) & (N - 1);
8748+ if (--len) InsertNode(r); /* buffer may not be empty. */
8749+ }
8750+ } while (len > 0); /* until length of string to be processed is zero */
8751+ if (code_buf_ptr > 1) { /* Send remaining code. */
8752+ if ((op + code_buf_ptr) > dstend) {
8753+ *dstlen = written;
8754+ return -1;
8755+ }
8756+ for (i = 0; i < code_buf_ptr; *(op++) = code_buf[i++]);
8757+ written += code_buf_ptr;
8758+ *srclen = read;
8759+ }
8760+ *dstlen = written;
8761+ return 0;
8762+}
8763+
8764+static int Decode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long srclen,
8765+ unsigned long dstlen) /* Just the reverse of Encode(). */
8766+{
8767+ unsigned long i, r, c, j, k, flags;
8768+ unsigned char *ip, *op;
8769+ unsigned long written;
8770+ unsigned long read;
8771+ unsigned char *srcend = srcbuf + srclen;
8772+ unsigned char *dstend = dstbuf + dstlen;
8773+ read = written = 0;
8774+ ip = srcbuf;
8775+ op = dstbuf;
8776+ for (i = 0; i < N - F; i++) text_buf[i] = ' ';
8777+ r = N - F; flags = 0;
8778+ for ( ; ; ) {
8779+ if (((flags >>= 1) & 256) == 0) {
8780+ if (ip >= srcend) return 0;
8781+ c = *(ip++);
8782+ flags = c | 0xff00; /* uses higher byte cleverly */
8783+ } /* to count eight */
8784+ if (flags & 1) {
8785+ if (ip >= srcend) return 0;
8786+ c = *(ip++);
8787+ if (op >= dstend) return -1;
8788+ *(op++) = text_buf[r++] = c; r &= (N - 1);
8789+ } else {
8790+ if ((ip + 2) > srcend) return 0;
8791+ i = *(ip++);
8792+ j = *(ip++);
8793+ i |= ((j & 0xf0) << 4); j = (j & 0x0f) + THRESHOLD;
8794+ if ((op + j + 1) > dstend) return -1;
8795+ for (k = 0; k <= j; k++) {
8796+ c = text_buf[(i + k) & (N - 1)];
8797+ *(op++) = text_buf[r++] = c; r &= (N - 1);
8798+ }
8799+ }
8800+ }
8801+}
8802+
8803+/* interface to jffs2 bbc follows */
8804+
8805+#include "jffs2_bbc_framework.h"
8806+
8807+
8808+#define JFFS2_BBC_LZSS_BLOCK_SIGN {0x27, 0x6f, 0x12, 0xc4}
8809+
8810+static int
8811+jffs2_bbc_lzss_compressor_init (void);
8812+
8813+static void
8814+jffs2_bbc_lzss_compressor_deinit (void);
8815+
8816+static int
8817+jffs2_bbc_lzss_compress (void *model, unsigned char *input,
8818+ unsigned char *output, unsigned long *sourcelen,
8819+ unsigned long *dstlen);
8820+
8821+static int
8822+jffs2_bbc_lzss_estimate (void *model, unsigned char *input,
8823+ unsigned long sourcelen, unsigned long *dstlen,
8824+ unsigned long *readtime, unsigned long *writetime);
8825+
8826+static int
8827+jffs2_bbc_lzss_decompress (void *model, unsigned char *input,
8828+ unsigned char *output, unsigned long sourcelen,
8829+ unsigned long dstlen);
8830+
8831+static char *
8832+jffs2_bbc_lzss_proc_info (void);
8833+
8834+static int
8835+jffs2_bbc_lzss_proc_command (char *command);
8836+
8837+struct jffs2_bbc_compressor_type jffs2_bbc_lzss = {
8838+ "lzss",
8839+ 0,
8840+ JFFS2_BBC_LZSS_BLOCK_SIGN,
8841+ jffs2_bbc_lzss_compressor_init,
8842+ NULL,
8843+ NULL,
8844+ jffs2_bbc_lzss_compressor_deinit,
8845+ jffs2_bbc_lzss_compress,
8846+ jffs2_bbc_lzss_estimate,
8847+ jffs2_bbc_lzss_decompress,
8848+ jffs2_bbc_lzss_proc_info,
8849+ jffs2_bbc_lzss_proc_command
8850+};
8851+
8852+static int
8853+jffs2_bbc_lzss_compressor_init (void)
8854+{
8855+ return 0;
8856+}
8857+
8858+static void
8859+jffs2_bbc_lzss_compressor_deinit (void)
8860+{
8861+}
8862+
8863+static int
8864+jffs2_bbc_lzss_compress (void *model, unsigned char *input,
8865+ unsigned char *output, unsigned long *sourcelen,
8866+ unsigned long *dstlen)
8867+{
8868+ int retval;
8869+ unsigned long dst = *dstlen;
8870+ *(output++) = jffs2_bbc_lzss.block_sign[0];
8871+ *(output++) = jffs2_bbc_lzss.block_sign[1];
8872+ dst -= 2;
8873+ retval = Encode(input, output, sourcelen, &dst);
8874+ dst += 2;
8875+ *dstlen = dst;
8876+ return retval;
8877+}
8878+
8879+static int
8880+jffs2_bbc_lzss_estimate (void *model, unsigned char *input,
8881+ unsigned long sourcelen, unsigned long *dstlen,
8882+ unsigned long *readtime, unsigned long *writetime)
8883+{
8884+ *dstlen = sourcelen * 60 / 100;
8885+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 12 / 10;
8886+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 3;
8887+ return 0;
8888+}
8889+
8890+static int
8891+jffs2_bbc_lzss_decompress (void *model, unsigned char *input,
8892+ unsigned char *output, unsigned long sourcelen,
8893+ unsigned long dstlen)
8894+{
8895+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzss.block_sign[0] ) ||
8896+ ( *(input++) != (unsigned char)jffs2_bbc_lzss.block_sign[1] )
8897+ ) {
8898+ return -1;
8899+ } else {
8900+ return Decode(input, output, sourcelen - 2, dstlen);
8901+ }
8902+}
8903+
8904+static char *
8905+jffs2_bbc_lzss_proc_info (void)
8906+{
8907+ return "Lempel-Ziv-Storer-Szymanski compression module";
8908+}
8909+
8910+static int
8911+jffs2_bbc_lzss_proc_command (char *command)
8912+{
8913+ return 0;
8914+}
8915+
8916+struct jffs2_bbc_compressor_type *
8917+jffs2_bbc_lzss_init (int mode)
8918+{
8919+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzss) == 0)
8920+ {
8921+ return &jffs2_bbc_lzss;
8922+ }
8923+ else
8924+ {
8925+ return NULL;
8926+ }
8927+}
8928+
8929+void
8930+jffs2_bbc_lzss_deinit (void)
8931+{
8932+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzss);
8933+}
8934--- /dev/null
8935+++ b/fs/jffs2/linux-2.4.25.hpatch
8936@@ -0,0 +1,97 @@
8937+FMakefile
8938+=BBC insertion
8939+-COMPR_OBJS
8940+iMakefile.bbc.inc
8941++
8942+I
8943+?JFFS2_OBJS
8944++ $(JFFS2_BBC_KERNEL_OBJS) \
8945+
8946+F../Config.in
8947+=BBC insertion
8948+-tristate 'Compressed ROM file system support' CONFIG_CRAMFS
8949+iConfig.in.bbc.inc
8950++
8951+I
8952+F../../Documentation/Configure.help
8953+=BBC insertion
8954+-JFFS stats available
8955+iConfigure.help.bbc.inc
8956++
8957+I
8958+Fcompr_zlib.c
8959+=(de)compress->(de)compress2
8960+-int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
8961++int jffs2_zlib_compress2(unsigned char *data_in, unsigned char *cpage_out,
8962+-void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
8963++void jffs2_zlib_decompress2(unsigned char *data_in, unsigned char *cpage_out,
8964+?inflateEnd(&strm);
8965+?}
8966++
8967++extern int jffs2_zlib_compress(unsigned char *data_in, unsigned char *cpage_out, __u32 * sourcelen, __u32 * dstlen);
8968++extern void jffs2_zlib_decompress(unsigned char *data_in, unsigned char *cpage_out, __u32 srclen, __u32 destlen);
8969++
8970++int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
8971++ __u32 *sourcelen, __u32 *dstlen)
8972++{
8973++ return jffs2_zlib_compress(data_in,cpage_out,sourcelen,dstlen);
8974++}
8975++
8976++void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
8977++ __u32 srclen, __u32 destlen)
8978++{
8979++ jffs2_zlib_decompress(data_in,cpage_out,srclen,destlen);
8980++}
8981++
8982+
8983+Ffile.c
8984+=set_act_sb before write
8985+-#include
8986++#include "jffs2_bbc_framework.h" /**BBC**/
8987+I
8988+?int jffs2_commit_write
8989+-jffs2_compress(
8990++ jffs2_bbc_model_set_act_sb(c); /**BBC**/
8991+I
8992+
8993+Fgc.c
8994+=set_act_sb before write
8995+-#include
8996++#include "jffs2_bbc_framework.h" /**BBC**/
8997+I
8998+?int jffs2_garbage_collect_dnode(
8999+-jffs2_compress(
9000++ jffs2_bbc_model_set_act_sb(c); /**BBC**/
9001+I
9002+
9003+Fread.c
9004+=set_act_sb before read
9005+-#include
9006++#include "jffs2_bbc_framework.h" /**BBC**/
9007+I
9008+?int jffs2_read_dnode(
9009+-jffs2_decompress(
9010++ jffs2_bbc_model_set_act_sb(c); /**BBC**/
9011+I
9012+
9013+Fsuper.c
9014+=init, load_model
9015+-#include
9016++#include "jffs2_bbc_fs.h" /**BBC**/
9017+I
9018+?struct super_block *jffs2_read_super(
9019+-return sb;
9020++ jffs2_bbc_load_model(sb); /**BBC**/
9021+I
9022+?void jffs2_put_super
9023+?c = JFFS2_SB_INFO
9024++ jffs2_bbc_unload_model(sb); /**BBC**/
9025+?init_jffs2_fs(void)
9026+?int ret;
9027++
9028++ jffs2_bbc_proc_init(); /**BBC**/
9029++
9030+?exit_jffs2_fs(void)
9031+?{
9032++ jffs2_bbc_proc_deinit(); /**BBC**/
9033++
9034--- a/fs/jffs2/read.c
9035+++ b/fs/jffs2/read.c
9036@@ -35,6 +35,7 @@
9037  *
9038  */
9039 
9040+#include "jffs2_bbc_framework.h" /**BBC**/
9041 #include <linux/kernel.h>
9042 #include <linux/slab.h>
9043 #include <linux/jffs2.h>
9044@@ -140,6 +141,7 @@ int jffs2_read_dnode(struct jffs2_sb_inf
9045     D2(printk(KERN_DEBUG "Data CRC matches calculated CRC %08x\n", crc));
9046     if (ri->compr != JFFS2_COMPR_NONE) {
9047         D2(printk(KERN_DEBUG "Decompress %d bytes from %p to %d bytes at %p\n", ri->csize, readbuf, ri->dsize, decomprbuf));
9048+ jffs2_bbc_model_set_act_sb(c); /**BBC**/
9049         ret = jffs2_decompress(ri->compr, readbuf, decomprbuf, ri->csize, ri->dsize);
9050         if (ret) {
9051             printk(KERN_WARNING "Error: jffs2_decompress returned %d\n", ret);
9052--- a/fs/jffs2/super.c
9053+++ b/fs/jffs2/super.c
9054@@ -35,6 +35,7 @@
9055  *
9056  */
9057 
9058+#include "jffs2_bbc_fs.h" /**BBC**/
9059 #include <linux/config.h>
9060 #include <linux/kernel.h>
9061 #include <linux/module.h>
9062@@ -272,6 +273,7 @@ static struct super_block *jffs2_read_su
9063     sb->s_magic = JFFS2_SUPER_MAGIC;
9064     if (!(sb->s_flags & MS_RDONLY))
9065         jffs2_start_garbage_collect_thread(c);
9066+ jffs2_bbc_load_model(sb); /**BBC**/
9067     return sb;
9068 
9069  out_root_i:
9070@@ -288,6 +290,7 @@ static struct super_block *jffs2_read_su
9071 void jffs2_put_super (struct super_block *sb)
9072 {
9073     struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
9074+ jffs2_bbc_unload_model(sb); /**BBC**/
9075 
9076     D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n"));
9077 
9078@@ -344,6 +347,9 @@ static int __init init_jffs2_fs(void)
9079 {
9080     int ret;
9081 
9082+ jffs2_bbc_proc_init(); /**BBC**/
9083+
9084+
9085     printk(KERN_NOTICE "JFFS2 version 2.1. (C) 2001 Red Hat, Inc., designed by Axis Communications AB.\n");
9086 
9087 #ifdef JFFS2_OUT_OF_KERNEL
9088@@ -388,6 +394,8 @@ static int __init init_jffs2_fs(void)
9089 
9090 static void __exit exit_jffs2_fs(void)
9091 {
9092+ jffs2_bbc_proc_deinit(); /**BBC**/
9093+
9094     jffs2_destroy_slab_caches();
9095     jffs2_zlib_exit();
9096     unregister_filesystem(&jffs2_fs_type);
9097

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