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