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