+++ /dev/null
-diff -Nur linux-mips-cvs/Documentation/Configure.help linux-mips/Documentation/Configure.help
---- linux-mips-cvs/Documentation/Configure.help 2005-01-20 03:19:21.000000000 +0100
-+++ linux-mips/Documentation/Configure.help 2005-02-07 05:08:35.000000000 +0100
-@@ -17528,6 +17528,32 @@
- If reporting bugs, please try to have available a full dump of the
- messages at debug level 1 while the misbehaviour was occurring.
-
-+ARMLIB compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_ARMLIB
-+ This enables ARMLIB support for BBC.
-+
-+LZO1X-* compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZO
-+ This enables LZO1X-1 and LZO1X-999 support for BBC. (fast & good
-+ compressor, beats ZLIB in everything)
-+
-+LZARI compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZARI
-+ This enables LempelZiv-Storer-Szymanski compression for BBC with
-+ additional arithmetic coding (damn slow, but best compresor).
-+
-+LZHD compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZHD
-+ This enables LempelZiv-Storer-Szymanski compression for BBC with
-+ additional dynamic Huffman coding (a little faster than LZARI, and
-+ it's compression ratio is a little worse than LZARI's)
-+
-+LZSS compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZSS
-+ This enables simple LempelZiv-Storer-Szymanski compression for BBC
-+ (faster than LZHD, and, and has a not-so-good compression ratio,
-+ was included just for testing)
-+
- JFFS stats available in /proc filesystem
- CONFIG_JFFS_PROC_FS
- Enabling this option will cause statistics from mounted JFFS file systems
-diff -Nur linux-mips-cvs/fs/Config.in linux-mips/fs/Config.in
---- linux-mips-cvs/fs/Config.in 2004-11-19 01:28:47.000000000 +0100
-+++ linux-mips/fs/Config.in 2005-02-07 05:08:34.000000000 +0100
-@@ -50,6 +50,12 @@
- if [ "$CONFIG_JFFS2_FS" = "y" -o "$CONFIG_JFFS2_FS" = "m" ] ; then
- int 'JFFS2 debugging verbosity (0 = quiet, 2 = noisy)' CONFIG_JFFS2_FS_DEBUG 0
- fi
-+dep_mbool ' ARMLIB compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_ARMLIB $CONFIG_JFFS2_FS
-+dep_mbool ' LZO1X-* compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZO $CONFIG_JFFS2_FS
-+dep_mbool ' LZARI compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZARI $CONFIG_JFFS2_FS
-+dep_mbool ' LZHD compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZHD $CONFIG_JFFS2_FS
-+dep_mbool ' LZSS compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZSS $CONFIG_JFFS2_FS
-+
- tristate 'Compressed ROM file system support' CONFIG_CRAMFS
- bool 'Virtual memory file system support (former shm fs)' CONFIG_TMPFS
- define_bool CONFIG_RAMFS y
-diff -Nur linux-mips-cvs/fs/jffs2/Config.in.bbc.inc linux-mips/fs/jffs2/Config.in.bbc.inc
---- linux-mips-cvs/fs/jffs2/Config.in.bbc.inc 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/Config.in.bbc.inc 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,5 @@
-+dep_mbool ' ARMLIB compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_ARMLIB $CONFIG_JFFS2_FS
-+dep_mbool ' LZO1X-* compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZO $CONFIG_JFFS2_FS
-+dep_mbool ' LZARI compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZARI $CONFIG_JFFS2_FS
-+dep_mbool ' LZHD compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZHD $CONFIG_JFFS2_FS
-+dep_mbool ' LZSS compression support for BBC (EXPERIMENTAL)' CONFIG_JFFS2_BBC_LZSS $CONFIG_JFFS2_FS
-diff -Nur linux-mips-cvs/fs/jffs2/Configure.help.bbc.inc linux-mips/fs/jffs2/Configure.help.bbc.inc
---- linux-mips-cvs/fs/jffs2/Configure.help.bbc.inc 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/Configure.help.bbc.inc 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,25 @@
-+ARMLIB compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_ARMLIB
-+ This enables ARMLIB support for BBC.
-+
-+LZO1X-* compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZO
-+ This enables LZO1X-1 and LZO1X-999 support for BBC. (fast & good
-+ compressor, beats ZLIB in everything)
-+
-+LZARI compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZARI
-+ This enables LempelZiv-Storer-Szymanski compression for BBC with
-+ additional arithmetic coding (damn slow, but best compresor).
-+
-+LZHD compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZHD
-+ This enables LempelZiv-Storer-Szymanski compression for BBC with
-+ additional dynamic Huffman coding (a little faster than LZARI, and
-+ it's compression ratio is a little worse than LZARI's)
-+
-+LZSS compression support for BBC (EXPERIMENTAL)
-+CONFIG_JFFS2_BBC_LZSS
-+ This enables simple LempelZiv-Storer-Szymanski compression for BBC
-+ (faster than LZHD, and, and has a not-so-good compression ratio,
-+ was included just for testing)
-diff -Nur linux-mips-cvs/fs/jffs2/Kconfig.bbc.inc linux-mips/fs/jffs2/Kconfig.bbc.inc
---- linux-mips-cvs/fs/jffs2/Kconfig.bbc.inc 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/Kconfig.bbc.inc 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,40 @@
-+config JFFS2_BBC_ARMLIB
-+ bool "ARMLIB compression support for BBC (EXPERIMENTAL)"
-+ depends on JFFS2_FS && EXPERIMENTAL
-+ default y
-+ help
-+ This enables ARMLIB support for BBC.
-+
-+config JFFS2_BBC_LZO
-+ bool "LZO1X-* compression support for BBC (EXPERIMENTAL)"
-+ depends on JFFS2_FS && EXPERIMENTAL
-+ default y
-+ help
-+ This enables LZO1X-1 and LZO1X-999 support for BBC. (fast & good
-+ compressor)
-+
-+config JFFS2_BBC_LZARI
-+ bool "LZARI compression support for BBC (EXPERIMENTAL)"
-+ depends on JFFS2_FS && EXPERIMENTAL
-+ default y
-+ help
-+ This enables LempelZiv-Storer-Szymanski compression for BBC with
-+ additional arithmetic coding (damn slow, but best compresor).
-+
-+config JFFS2_BBC_LZHD
-+ bool "LZHD compression support for BBC (EXPERIMENTAL)"
-+ depends on JFFS2_FS && EXPERIMENTAL
-+ default y
-+ help
-+ This enables LempelZiv-Storer-Szymanski compression for BBC with
-+ additional dynamic Huffman coding (a little faster than LZARI, and
-+ it's compression ratio is a little worse than LZARI's)
-+
-+config JFFS2_BBC_LZSS
-+ bool "LZSS compression support for BBC (EXPERIMENTAL)"
-+ depends on JFFS2_FS && EXPERIMENTAL
-+ default y
-+ help
-+ This enables simple LempelZiv-Storer-Szymanski compression for BBC
-+ (faster than LZHD, and, and has a not-so-good compression ratio,
-+ was included just for testing)
-diff -Nur linux-mips-cvs/fs/jffs2/Makefile linux-mips/fs/jffs2/Makefile
---- linux-mips-cvs/fs/jffs2/Makefile 2003-08-13 19:19:25.000000000 +0200
-+++ linux-mips/fs/jffs2/Makefile 2005-02-07 05:08:34.000000000 +0100
-@@ -10,9 +10,23 @@
- # Note 2! The CFLAGS definitions are now in the main makefile...
-
-
-+JFFS2_BBC_KERNEL_OBJS-y = jffs2_bbc_framework.o jffs2_bbc_fs.o
-+
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_ARMLIB) += jffs2_bbc_armlib_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZO) += jffs2_bbc_lzo_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZSS) += jffs2_bbc_lzss_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZARI) += jffs2_bbc_lzari_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZHD) += jffs2_bbc_lzhd_comp.o
-+
-+JFFS2_BBC_KERNEL_OBJS := $(JFFS2_BBC_KERNEL_OBJS-y)
-+
-+JFFS2_BBC_MKFS_OBJS = jffs2_bbc_mkfs.o jffs2_bbc_framework.o jffs2_bbc_armlib_comp.o jffs2_bbc_lzo_comp.o\
-+ jffs2_bbc_lzss_comp.o jffs2_bbc_lzari_comp.o jffs2_bbc_lzhd_comp.o
-+
- COMPR_OBJS := compr.o compr_rubin.o compr_rtime.o pushpull.o \
- compr_zlib.o
- JFFS2_OBJS := dir.o file.o ioctl.o nodelist.o malloc.o \
-+ $(JFFS2_BBC_KERNEL_OBJS) \
- read.o nodemgmt.o readinode.o super.o write.o scan.o gc.o \
- symlink.o build.o erase.o background.o
-
-diff -Nur linux-mips-cvs/fs/jffs2/Makefile.bbc.inc linux-mips/fs/jffs2/Makefile.bbc.inc
---- linux-mips-cvs/fs/jffs2/Makefile.bbc.inc 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/Makefile.bbc.inc 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,12 @@
-+JFFS2_BBC_KERNEL_OBJS-y = jffs2_bbc_framework.o jffs2_bbc_fs.o
-+
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_ARMLIB) += jffs2_bbc_armlib_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZO) += jffs2_bbc_lzo_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZSS) += jffs2_bbc_lzss_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZARI) += jffs2_bbc_lzari_comp.o
-+JFFS2_BBC_KERNEL_OBJS-$(CONFIG_JFFS2_BBC_LZHD) += jffs2_bbc_lzhd_comp.o
-+
-+JFFS2_BBC_KERNEL_OBJS := $(JFFS2_BBC_KERNEL_OBJS-y)
-+
-+JFFS2_BBC_MKFS_OBJS = jffs2_bbc_mkfs.o jffs2_bbc_framework.o jffs2_bbc_armlib_comp.o jffs2_bbc_lzo_comp.o\
-+ jffs2_bbc_lzss_comp.o jffs2_bbc_lzari_comp.o jffs2_bbc_lzhd_comp.o
-diff -Nur linux-mips-cvs/fs/jffs2/compr_zlib.c linux-mips/fs/jffs2/compr_zlib.c
---- linux-mips-cvs/fs/jffs2/compr_zlib.c 2003-01-11 18:53:17.000000000 +0100
-+++ linux-mips/fs/jffs2/compr_zlib.c 2005-02-07 05:08:35.000000000 +0100
-@@ -85,7 +85,7 @@
- vfree(inflate_workspace);
- }
-
--int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
-+int jffs2_zlib_compress2(unsigned char *data_in, unsigned char *cpage_out,
- __u32 *sourcelen, __u32 *dstlen)
- {
- z_stream strm;
-@@ -145,7 +145,7 @@
- return 0;
- }
-
--void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
-+void jffs2_zlib_decompress2(unsigned char *data_in, unsigned char *cpage_out,
- __u32 srclen, __u32 destlen)
- {
- z_stream strm;
-@@ -175,3 +175,19 @@
- zlib_inflateEnd(&strm);
- up(&inflate_sem);
- }
-+
-+extern int jffs2_zlib_compress(unsigned char *data_in, unsigned char *cpage_out, __u32 * sourcelen, __u32 * dstlen);
-+extern void jffs2_zlib_decompress(unsigned char *data_in, unsigned char *cpage_out, __u32 srclen, __u32 destlen);
-+
-+int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
-+ __u32 *sourcelen, __u32 *dstlen)
-+{
-+ return jffs2_zlib_compress(data_in,cpage_out,sourcelen,dstlen);
-+}
-+
-+void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
-+ __u32 srclen, __u32 destlen)
-+{
-+ jffs2_zlib_decompress(data_in,cpage_out,srclen,destlen);
-+}
-+
-diff -Nur linux-mips-cvs/fs/jffs2/file.c linux-mips/fs/jffs2/file.c
---- linux-mips-cvs/fs/jffs2/file.c 2003-11-17 02:07:44.000000000 +0100
-+++ linux-mips/fs/jffs2/file.c 2005-02-07 05:08:35.000000000 +0100
-@@ -35,6 +35,7 @@
- *
- */
-
-+#include "jffs2_bbc_framework.h" /**BBC**/
- #include <linux/kernel.h>
- #include <linux/mtd/compatmac.h> /* for min() */
- #include <linux/slab.h>
-@@ -459,6 +460,7 @@
-
- comprbuf = kmalloc(cdatalen, GFP_KERNEL);
- if (comprbuf) {
-+ jffs2_bbc_model_set_act_sb(c); /**BBC**/
- comprtype = jffs2_compress(page_address(pg)+ (file_ofs & (PAGE_CACHE_SIZE-1)), comprbuf, &datalen, &cdatalen);
- }
- if (comprtype == JFFS2_COMPR_NONE) {
-diff -Nur linux-mips-cvs/fs/jffs2/gc.c linux-mips/fs/jffs2/gc.c
---- linux-mips-cvs/fs/jffs2/gc.c 2003-11-17 02:07:44.000000000 +0100
-+++ linux-mips/fs/jffs2/gc.c 2005-02-07 05:08:35.000000000 +0100
-@@ -35,6 +35,7 @@
- *
- */
-
-+#include "jffs2_bbc_framework.h" /**BBC**/
- #include <linux/kernel.h>
- #include <linux/mtd/mtd.h>
- #include <linux/slab.h>
-@@ -651,6 +652,7 @@
- writebuf = pg_ptr + (offset & (PAGE_CACHE_SIZE -1));
-
- if (comprbuf) {
-+ jffs2_bbc_model_set_act_sb(c); /**BBC**/
- comprtype = jffs2_compress(writebuf, comprbuf, &datalen, &cdatalen);
- }
- if (comprtype) {
-diff -Nur linux-mips-cvs/fs/jffs2/hpatch linux-mips/fs/jffs2/hpatch
---- linux-mips-cvs/fs/jffs2/hpatch 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/hpatch 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,191 @@
-+#!/usr/bin/perl
-+# A patch-like utility
-+# Designed for patching different version of jffs2 with the same hpatch file
-+#
-+# Copyright (C) 2004, Ferenc Havasi
-+#
-+# This program is free software; you can redistribute it and/or
-+# modify it under the terms of the GNU General Public License
-+# as published by the Free Software Foundation; either version 2
-+# of the License, or (at your option) any later version.
-+#
-+# This program is distributed in the hope that it will be useful,
-+# but WITHOUT ANY WARRANTY; without even the implied warranty of
-+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+# GNU General Public License for more details.
-+#
-+# You should have received a copy of the GNU General Public License
-+# along with this program; if not, write to the Free Software
-+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+
-+$filename_tmp1="file1.tmp";
-+$filename_tmp2="file2.tmp";
-+
-+$filename_in="";
-+$filename_out=$filename_tmp1;
-+$filename_cnt=0;
-+
-+# Modes:
-+# 0: expecting =
-+# 1: normal_cmd
-+# 2: skip until =
-+# 3: expecting F (first state)
-+$mode=3;
-+
-+%rules = ();
-+
-+sub file_end {
-+ if (($mode!=2)&&($modified==1)) {
-+ while (<SRC>) {
-+ print DST $_;
-+ }
-+ close(SRC);
-+ close(DST);
-+ if ($cmd_name ne "") { $rules{"$cmd_name"}=1; }
-+ $filename_result=$filename_out;
-+ if ($filename_result ne $filename_in_save) {
-+ open(RES,"<$filename_result") or die "Cannot open $filename_result.\n";
-+ open(DST,">$filename_in_save") or die "Cannot open $filename_in_save.\n";
-+ while (<RES>) {
-+ print DST $_;
-+ }
-+ close(DST);
-+ close(RES);
-+ }
-+ unlink($filename_tmp1) && unlink($filename_tmp2);
-+ }
-+ else {
-+ close(SRC);
-+ close(DST);
-+ $filename_result=$filename_in;
-+ if ($filename_result ne $filename_in_save) {
-+ open(RES,"<$filename_result") or die "Cannot open $filename_result.\n";
-+ open(DST,">$filename_in_save") or die "Cannot open $filename_in_save.\n";
-+ while (<RES>) {
-+ print DST $_;
-+ }
-+ close(DST);
-+ close(RES);
-+ }
-+ unlink($filename_tmp1);
-+ }
-+ $modified=0;
-+ foreach $rulename (keys %rules) {
-+ if ($rules{"$rulename"}==0) { print(STDERR "On $filename_in_save error applying rule $rulename.\n"); }
-+ }
-+ %rules = ();
-+}
-+
-+if ($#ARGV<0) {
-+ print ("usage: hpatch hpatch_file\n");
-+ exit;
-+}
-+
-+open(CMD,"<$ARGV[0]") or die "Cannot open $ARGV[0].\n";
-+$cmd_linenum=0;
-+
-+while (chomp($cmd_line=<CMD>)) {
-+ $cmd_linenum++;
-+ if ($cmd_line eq "") {next;}
-+ #$cmd_line =~ s/\#.*//;
-+ $cmd_line =~ s/\ *$//;
-+ if ($cmd_line eq "") {next;}
-+ if ($cmd_line =~ /^F(.*)/) {
-+ $tmp_filename_in=$1;
-+ if ($mode!=3) {
-+ file_end();
-+ }
-+ $filename_in=$tmp_filename_in;
-+ $filename_in_save=$filename_in;
-+ open(SRC,"<$filename_in") or die "Cannot open $filename_in.\n";
-+ open(DST,">$filename_out") or die "Cannot open $filename_out.\n";;
-+ $modified=0;
-+ $mode=0;
-+ next;
-+ }
-+ if ($mode==3) {die "error: F expression expected in line $cmd_linenum\n";}
-+ if ($cmd_line =~ /^=(.*)/) {
-+ $tmp_cmd_name=$1;
-+ if (($mode!=2)&&($modified==1)) {
-+ while (<SRC>) {
-+ print DST $_;
-+ }
-+ close(SRC);
-+ close(DST);
-+ if (($cmd_name ne "")) {$rules{"$cmd_name"}=1;};
-+ $filename_cnt++;
-+ if ($filename_cnt%2==1) {
-+ $filename_in=$filename_tmp1;
-+ $filename_out=$filename_tmp2;
-+ }
-+ else {
-+ $filename_in=$filename_tmp2;
-+ $filename_out=$filename_tmp1;
-+ }
-+ }
-+ else {
-+ close(SRC);
-+ close(DST);
-+ }
-+ $mode=1;
-+ $cmd_name=$tmp_cmd_name;
-+ if (($cmd_name ne "")) {
-+ if ($rules{"$cmd_name"}==1) {
-+ $mode=2;
-+ }
-+ else {
-+ $rules{"$cmd_name"}=0;
-+ }
-+ }
-+ open(SRC,"<$filename_in") or die "Cannot open $filename_in.\n";
-+ open(DST,">$filename_out") or die "Cannot open $filename_out.\n";
-+ $modified=0;
-+ next;
-+ }
-+ if ($mode == 0) {die "error: = expression expected in line $cmd_linenum\n";}
-+ if ($mode == 2) {next;}
-+ if ($cmd_line =~ /^!(.*)/) {
-+ print "$1\n";
-+ $modified=1;
-+ next;
-+ }
-+ if ($cmd_line =~ /^\?(.*)/) {
-+ $search_str=$1;
-+ $found=0;
-+ while (<SRC>) {
-+ print DST $_;
-+ if (index($_,$search_str)>=0) {$found=1; last;}
-+ }
-+ if ($found==0) { $mode=2; }
-+ next;
-+ }
-+ if ($cmd_line =~ /^\+(.*)/) {
-+ print DST "$1\n";
-+ $modified=1;
-+ next;
-+ }
-+ if ($cmd_line =~ /^\-(.*)/) {
-+ $search_str=$1;
-+ $found=0;
-+ while (<SRC>) {
-+ if (index($_,$search_str)>=0) {$saved_line=$_; $found=1; $modified=1; last;}
-+ print DST $_;
-+ }
-+ if ($found==0) { $mode=2; }
-+ next;
-+ }
-+ if ($cmd_line =~ /^i(.*)/) {
-+ $filename_inc=$1;
-+ open(INCSRC,"<$filename_inc") or die "Cannot open $filename_inc.\n";
-+ while (<INCSRC>) {
-+ print DST $_;
-+ }
-+ next;
-+ }
-+ if ($cmd_line =~ /^I/) {
-+ print DST $saved_line;
-+ next;
-+ }
-+}
-+file_end();
-+close(CMD);
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_armlib_comp.c linux-mips/fs/jffs2/jffs2_bbc_armlib_comp.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_armlib_comp.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_armlib_comp.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,2224 @@
-+/*
-+ * JFFS2-BBC: armlib compressor plugin
-+ *
-+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+ *
-+ * Copyright (C) 2004, Ferenc Havasi & Tamas Gergely
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License
-+ * as published by the Free Software Foundation; either version 2
-+ * of the License, or (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+ *
-+ */
-+
-+#include "jffs2_bbc_framework.h"
-+
-+#ifdef __KERNEL__
-+#include <linux/string.h>
-+#else
-+#include <string.h>
-+#endif
-+
-+//ORIGIN: include/DataStructures/TypeDefs.h
-+
-+/*******************************************************************************
-+* FILE: TypeDefs.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef TYPEDEFS_H
-+#define TYPEDEFS_H
-+
-+#pragma pack(4)
-+
-+#ifndef bool
-+#define bool char
-+#define true 1
-+#define false 0
-+#endif
-+
-+#ifndef u8
-+#define u8 unsigned char
-+#endif
-+#ifndef u16
-+#define u16 unsigned short
-+#endif
-+#ifndef u32
-+#define u32 unsigned long
-+#endif
-+#ifndef s8
-+#define s8 signed char
-+#endif
-+#ifndef s16
-+#define s16 signed short
-+#endif
-+#ifndef s32
-+#define s32 signed long
-+#endif
-+
-+typedef struct
-+{
-+ u32 capacity;
-+ u32 size;
-+ u32 alloc_size;
-+ void *ptr;
-+} vector;
-+
-+#define VECTOR_P_END(vct) ((void*)(((char*)((vct)->ptr)) + (vct)->size))
-+#define VECTOR_S_END(vct) ((void*)(((char*)((vct).ptr)) + (vct).size))
-+
-+static void vector_clear(vector *);
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static void vector_reset(vector *);
-+static void vector_clr_ptr(vector *);
-+static void vector_add_u8(vector *, u8);
-+static void vector_add_u16(vector *, u16);
-+static void vector_add_u32(vector *, u32);
-+static void vector_add_s8(vector *, s8);
-+static void vector_add_s16(vector *, s16);
-+static void vector_add_s32(vector *, s32);
-+static void vector_add_ptr(vector *, void *);
-+static void vector_concat(vector *, vector *);
-+#endif
-+
-+#endif
-+
-+//ORIGIN: include/DataStructures/DataTypes.h
-+
-+/*******************************************************************************
-+* FILE: DataTypes.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef DATATYPES_H
-+#define DATATYPES_H
-+
-+//#include "DataStructures/TypeDefs.h"
-+
-+typedef u16 THUMB_DataType;
-+typedef u32 ARM_DataType;
-+typedef u8 TokenType;
-+typedef u8 PredictorType;
-+typedef u8 *ProbDist;
-+
-+typedef vector RawData;
-+typedef vector RawBlocks;
-+typedef vector TokenStream;
-+typedef vector TokenBlocks;
-+typedef vector LatType;
-+
-+#define THUMB_DATA_LENGTH 16
-+#define ARM_DATA_LENGTH 32
-+#define TOKEN_LENGTH 8
-+#define TOKEN_MAXVALUE 0xff
-+#define PREDICTOR_LENGTH 8
-+#define PREDICTOR_MAXVALUE 0xff
-+
-+#endif
-+
-+//ORIGIN: include/DataStructures/BitVector.h
-+
-+/*******************************************************************************
-+* FILE: BitVector.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef BITVECTOR_H
-+#define BITVECTOR_H
-+
-+//#include "DataStructures/TypeDefs.h"
-+
-+typedef vector BitBlocks;
-+
-+#pragma pack(4)
-+
-+typedef struct
-+{
-+ u32 freebits;
-+ u32 capacity;
-+ u32 size;
-+ u8 *base;
-+ u8 *ptr;
-+} BitVector;
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static void bitblocks_clear(BitBlocks *);
-+static void bitvector_clear(BitVector *);
-+static void bitvector_W_reset(BitVector *);
-+static void bitvector_W_add0(BitVector *);
-+static void bitvector_W_add1(BitVector *);
-+static void bitvector_W_concat_b(BitVector *, BitVector *);
-+static void bitvector_W_concat_v(BitVector *, vector *);
-+static void bitvector_W_flush(BitVector *);
-+static void bitvector_R_reset(BitVector *);
-+static u8 bitvector_R_get1(BitVector *);
-+static u8 bitvector_R_get8(BitVector *);
-+#endif
-+
-+#define BITVECTOR_P_END(bv) ((void*)(((bv)->base)+((bv)->size)))
-+#define BITVECTOR_S_END(bv) ((void*)( ((bv).base)+ ((bv).size)))
-+#define BITVECTOR_SKIP(bv,num) ((bv)->ptr) += (num)
-+
-+#endif
-+
-+//ORIGIN: include/DataStructures/DecisionTree.h
-+
-+/*******************************************************************************
-+* FILE: DecisionTree.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef DECISIONTREE_H
-+#define DECISIONTREE_H
-+
-+//#include "DataStructures/DataTypes.h"
-+
-+#pragma pack(4)
-+
-+#define TREENODETYPE_NULLNODE 0
-+#define TREENODETYPE_NODE_BINARY_EQ 1
-+#define TREENODETYPE_LEAF_P 2
-+#define TREENODETYPE_LEAF_C 3
-+#define TREENODETYPE_NODE_BINARY_LT 5
-+#define TREENODETYPE_IS_NODE(n) (((n) == TREENODETYPE_NODE_BINARY_EQ) || \
-+ ((n) == TREENODETYPE_NODE_BINARY_LT))
-+#define TREENODETYPE_IS_NODE_BINARY(n) (((n) == TREENODETYPE_NODE_BINARY_EQ) || \
-+ ((n) == TREENODETYPE_NODE_BINARY_LT))
-+
-+#define TREENODETYPE_IS_LEAF(n) (((n) == TREENODETYPE_LEAF_P) || \
-+ ((n) == TREENODETYPE_LEAF_C))
-+
-+
-+#define TREE_SUBTREE_RELATION_LEFT_EQ !=
-+#define TREE_SUBTREE_RELATION_RIGHT_EQ ==
-+#define TREE_SUBTREE_RELATION_LEFT_LT <
-+#define TREE_SUBTREE_RELATION_RIGHT_LT >=
-+
-+#define GET_NODE_PTR_TYPE(n) (((TreeNodeDummy*)(n))->type)
-+
-+typedef struct
-+{
-+ u8 type;
-+} TreeNodeDummy;
-+
-+typedef struct
-+{
-+ u8 type; // [TREENODETYPE_NODE_BINARY]
-+ u8 attribute;
-+ PredictorType value;
-+ void *left;
-+ void *right;
-+} TreeNodeBinary;
-+
-+typedef struct
-+{
-+ u8 type; // [TREENODETYPE_LEAF_P]
-+ u16 pairs;
-+ PredictorType *probabilities;
-+} TreeLeafP;
-+
-+typedef struct
-+{
-+ u8 type; // [TREENODETYPE_LEAF_C]
-+ PredictorType predicted_class;
-+} TreeLeafC;
-+
-+typedef struct
-+{
-+ u32 high;
-+ u32 low;
-+ u32 max;
-+} ProbabilityType;
-+
-+
-+typedef struct
-+{
-+ void *root;
-+ u16 number_of_classes;
-+ u16 number_of_predictors;
-+ PredictorType *predictor_max_values;
-+} DecisionTree;
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static void decisiontree_delete(DecisionTree *);
-+static void decisiontree_get_probability_for_token(void *, PredictorType *, TokenType, ProbabilityType *);
-+static TokenType decisiontree_get_token_for_range(void *, PredictorType *, u32, u32, ProbabilityType *);
-+#endif
-+
-+#endif
-+
-+//ORIGIN: include/DataStructures/PredictorTable.h
-+
-+/*******************************************************************************
-+* FILE: PredictorTable.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef PREDICTORTABLE_H
-+#define PREDICTORTABLE_H
-+
-+//#include "DataStructures/TypeDefs.h"
-+//#include "DataStructures/DataTypes.h"
-+////#include "DataStructures/Filter.h"
-+////#include "DataStructures/Converter.h"
-+////#include "DataStructures/Manipulator.h"
-+
-+#define NUMBER_OF_PREDICTORS_ARM 17
-+
-+#ifndef __KERNEL__
-+#define NUMBER_OF_PREDICTORS_TXT 2
-+#else
-+#undef TXT_TOKENS
-+#endif // __KERNEL__
-+
-+#ifdef TXT_TOKENS
-+#define NUMBER_OF_PREDICTORS NUMBER_OF_PREDICTORS_TXT
-+#define predictortable_reset predictortable_resetTXT
-+#define predictortable_update predictortable_updateTXT
-+#define predictortable_minvalue predictortable_minvalueTXT
-+#define predictortable_maxvalue predictortable_maxvalueTXT
-+#else
-+#define NUMBER_OF_PREDICTORS NUMBER_OF_PREDICTORS_ARM
-+#define predictortable_reset predictortable_resetARM
-+#define predictortable_update predictortable_updateARM
-+#define predictortable_minvalue predictortable_minvalueARM
-+#define predictortable_maxvalue predictortable_maxvalueARM
-+#endif
-+
-+
-+#pragma pack(4)
-+
-+typedef struct
-+{
-+ PredictorType *predictors;
-+} PredictorTable;
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static void predictortable_clear(PredictorTable *);
-+static void predictortable_free(PredictorTable *);
-+static void predictortable_resetARM(PredictorTable *);
-+static void predictortable_updateARM(PredictorTable *, TokenType);
-+static PredictorType predictortable_minvalueARM(PredictorTable *, u32);
-+static PredictorType predictortable_maxvalueARM(PredictorTable *, u32);
-+#endif
-+
-+#ifndef __KERNEL__
-+/*
-+static void predictortable_resetTXT(PredictorTable *);
-+static void predictortable_updateTXT(PredictorTable *, TokenType);
-+static PredictorType predictortable_minvalueTXT(PredictorTable *, u32);
-+static PredictorType predictortable_maxvalueTXT(PredictorTable *, u32);
-+*/
-+#endif // __KERNEL__
-+
-+#endif
-+
-+//ORIGIN: include/DataStructures/ipack_model.h
-+
-+/*******************************************************************************
-+* FILE: ipack_model.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef IPACK_MODEL_H
-+#define IPACK_MODEL_H
-+
-+//#include "DataStructures/DataTypes.h"
-+//#include "DataStructures/DecisionTree.h"
-+//#include "DataStructures/PredictorTable.h"
-+
-+#define PROBABILITY_SHIFT 12
-+#define PROBABILITY_MAX 0x00001000l
-+
-+#define NUMBER_OF_TOKENS_ARM 16
-+#define NUMBER_OF_TOKENS_PER_INSTRUCTION_ARM 8
-+
-+#ifndef __KERNEL__
-+#define NUMBER_OF_TOKENS_TXT 256
-+#define NUMBER_OF_TOKENS_PER_INSTRUCTION_TXT 4
-+#else
-+#undef TXT_TOKENS
-+#endif // __KERNEL__
-+
-+#ifdef TXT_TOKENS
-+#define NUMBER_OF_TOKENS NUMBER_OF_TOKENS_TXT
-+#define NUMBER_OF_TOKENS_PER_INSTRUCTION NUMBER_OF_TOKENS_PER_INSTRUCTION_TXT
-+#else
-+#define NUMBER_OF_TOKENS NUMBER_OF_TOKENS_ARM
-+#define NUMBER_OF_TOKENS_PER_INSTRUCTION NUMBER_OF_TOKENS_PER_INSTRUCTION_ARM
-+#endif
-+
-+#pragma pack(4)
-+
-+/*
-+ Data structure of an internal node of the tree
-+*/
-+typedef struct
-+{
-+ PredictorType *attribute_ptr;
-+ u32 value; // PredictorType
-+ void *right_child_ptr;
-+} ipack_treenodeBin;
-+/*
-+ Data structure of a leaf with probabilities
-+*/
-+typedef struct
-+{
-+ u16 probabilities[0]; // PredictorType[0]
-+} ipack_treeleafP;
-+/*
-+ Data structure of a leaf with class prediction
-+*/
-+typedef struct
-+{
-+ PredictorType predicted_class; // PredictorType
-+} ipack_treeleafC;
-+/*
-+ Possible data structures of a tree node
-+*/
-+typedef union
-+{
-+ ipack_treenodeBin nodeBin;
-+ ipack_treeleafP leafP;
-+ ipack_treeleafC leafC;
-+} ipack_node_data;
-+/*
-+ Tree node
-+*/
-+typedef struct
-+{
-+ u32 type; // u8
-+ ipack_node_data data; // ipack_node_data
-+} ipack_nodetype;
-+/*
-+ Nullnode
-+*/
-+typedef struct
-+{
-+ u32 type;
-+ u16 probabilities[NUMBER_OF_TOKENS];
-+} ipack_nullnode;
-+/*
-+ Model for ipack project
-+*/
-+typedef struct
-+{
-+ char ID[4]; // char[4]
-+ char block_sign[4]; // only the first 2 are used!
-+ void *tree_root_ptr; // void*
-+ void *tree_code; // generated ARM code
-+ PredictorType *predictors_ptr; // PredictorType*
-+ ipack_nullnode nullnode;
-+} ipack_model_type;
-+
-+typedef struct
-+{
-+ u32 high;
-+ u32 low;
-+} ipack_probability_type;
-+
-+
-+static void ipack_model_get_probability_for_token(ipack_nodetype *, TokenType, ipack_probability_type *);
-+static TokenType ipack_model_get_token_for_range(ipack_nodetype *, u32, u32, ipack_probability_type *);
-+/*void ipack_model_predictortable_reset (PredictorType*);
-+void ipack_model_predictortable_update (PredictorType*, TokenType);*/
-+
-+#ifndef __KERNEL__
-+/*static void ipack_model_printinfo(ipack_model_type *);
-+static void ipack_dumpmodel(void *);*/
-+#endif
-+
-+#endif
-+
-+//ORIGIN: include/Builders/PredictorGenerator.h
-+
-+/*******************************************************************************
-+* FILE: PredictorGenerator.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef PREDICTORGENERATOR_H
-+#define PREDICTORGENERATOR_H
-+
-+//#include "DataStructures.h"
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static PredictorTable *predictorgenerator_generate(void);
-+#endif
-+
-+#endif
-+
-+//ORIGIN: include/Builders/Coder.h
-+
-+/*******************************************************************************
-+* FILE: Coder.h
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+#ifndef CODER_H
-+#define CODER_H
-+
-+#define CODER_VALUEBITS 16
-+#define CODER_VALUEMAX 0x00010000l
-+#define CODER_VALUE3RD 0x0000c000l
-+#define CODER_VALUEHLF 0x00008000l
-+#define CODER_VALUE1ST 0x00004000l
-+
-+#endif
-+
-+//ORIGIN: DataStructures/src/TypeDefs.c
-+
-+/*******************************************************************************
-+* FILE: TypeDefs.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "ipack_common.h"
-+//#include "DataStructures/TypeDefs.h"
-+#ifndef __KERNEL__
-+#include <memory.h>
-+#endif
-+
-+#define VECTOR_ALLOC_SIZE 0x00001000
-+
-+static void vector_clear(vector * vct)
-+{
-+ if (vct->ptr)
-+ jffs2_bbc_free(vct->ptr);
-+ vct->capacity = 0;
-+ vct->size = 0;
-+ vct->ptr = 0;
-+}
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static void vector_extend(vector * vct)
-+{
-+ void *tmp;
-+ vct->capacity += vct->alloc_size;
-+ tmp = jffs2_bbc_malloc(vct->capacity);
-+ if (vct->ptr) {
-+ memcpy(tmp, vct->ptr, vct->size);
-+ jffs2_bbc_free(vct->ptr);
-+ }
-+ vct->ptr = tmp;
-+}
-+
-+static void vector_reset(vector * vct)
-+{
-+ vct->capacity = 0;
-+ vct->size = 0;
-+ vct->alloc_size = VECTOR_ALLOC_SIZE;
-+ vct->ptr = 0;
-+}
-+
-+static void vector_clr_ptr(vector * vct)
-+{
-+ void **it;
-+ void *end_it;
-+ for (it = vct->ptr, end_it = (((char *) (vct->ptr)) + vct->size); it != end_it; it++) {
-+ vector_clear(*it);
-+ jffs2_bbc_free(*it);
-+ }
-+ if (vct->ptr)
-+ jffs2_bbc_free(vct->ptr);
-+ vct->capacity = 0;
-+ vct->size = 0;
-+ vct->ptr = 0;
-+}
-+
-+static void vector_add_u8(vector * vct, u8 val)
-+{
-+ if ((vct->size) + sizeof(u8) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(u8 *) ((char *) (vct->ptr) + (vct->size)) = val;
-+ vct->size += sizeof(u8);
-+};
-+
-+static void vector_add_u16(vector * vct, u16 val)
-+{
-+ if ((vct->size) + sizeof(u16) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(u16 *) ((char *) (vct->ptr) + (vct->size)) = val;
-+ vct->size += sizeof(u16);
-+};
-+
-+static void vector_add_u32(vector * vct, u32 val)
-+{
-+ if ((vct->size) + sizeof(u32) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(u32 *) ((char *) (vct->ptr) + (vct->size)) = val;
-+ vct->size += sizeof(u32);
-+};
-+
-+static void vector_add_s8(vector * vct, s8 val)
-+{
-+ if ((vct->size) + sizeof(s8) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(s8 *) ((char *) (vct->ptr) + (vct->size)) = val;
-+ vct->size += sizeof(s8);
-+};
-+
-+static void vector_add_s16(vector * vct, s16 val)
-+{
-+ if ((vct->size) + sizeof(s16) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(s16 *) ((char *) (vct->ptr) + (vct->size)) = val;
-+ vct->size += sizeof(s16);
-+};
-+
-+static void vector_add_s32(vector * vct, s32 val)
-+{
-+ if ((vct->size) + sizeof(s32) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(s32 *) ((char *) (vct->ptr) + (vct->size)) = val;
-+ vct->size += sizeof(s32);
-+};
-+
-+static void vector_add_ptr(vector * vct, void *ptr)
-+{
-+ if ((vct->size) + sizeof(void *) > (vct->capacity)) {
-+ vector_extend(vct);
-+ }
-+ *(void **) ((char *) (vct->ptr) + (vct->size)) = ptr;
-+ vct->size += sizeof(void *);
-+}
-+
-+static void vector_concat(vector * lhs, vector * rhs)
-+{
-+ void *tmp;
-+ if (!(rhs->size)) {
-+ return;
-+ }
-+ tmp = lhs->ptr;
-+ lhs->capacity = (lhs->size) + (rhs->size);
-+ lhs->ptr = jffs2_bbc_malloc(lhs->capacity);
-+ if (tmp) {
-+ memcpy(lhs->ptr, tmp, lhs->size);
-+ jffs2_bbc_free(tmp);
-+ }
-+ memcpy((((u8 *) lhs->ptr) + lhs->size), rhs->ptr, rhs->size);
-+ lhs->size += rhs->size;
-+}
-+
-+#endif
-+
-+//ORIGIN: DataStructures/src/BitVector.c
-+
-+/*******************************************************************************
-+* FILE: BitVector.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "ipack_common.h"
-+//#include "DataStructures/BitVector.h"
-+#ifndef __KERNEL__
-+#include <memory.h>
-+#endif
-+
-+#define VECTOR_ALLOC_SIZE 0x00001000
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+
-+static void bitblocks_clear(BitBlocks * this)
-+{
-+ BitVector **it;
-+ void *end_it;
-+ for (it = this->ptr, end_it = VECTOR_P_END(this); it != end_it; it++) {
-+ bitvector_clear(*it);
-+ jffs2_bbc_free(*it);
-+ }
-+ jffs2_bbc_free(this->ptr);
-+ this->ptr = 0;
-+}
-+
-+static void bitvector_clear(BitVector * this)
-+{
-+ if (this->base) {
-+ jffs2_bbc_free(this->base);
-+ }
-+ this->freebits = 0;
-+ this->capacity = 0;
-+ this->size = 0;
-+ this->base = 0;
-+ this->ptr = 0;
-+}
-+
-+static void bitvector_W_reset(BitVector * this)
-+{
-+ this->freebits = 0;
-+ this->capacity = 0;
-+ this->size = 0;
-+ this->base = 0;
-+ this->ptr = 0;
-+}
-+
-+static void bitvector_W_add0(BitVector * this)
-+{
-+ if (!(this->freebits)) {
-+ if (this->size == this->capacity) {
-+ void *tmp = this->base;
-+ this->capacity += VECTOR_ALLOC_SIZE;
-+ this->base = jffs2_bbc_malloc(this->capacity);
-+ this->ptr = ((u8 *) (this->base)) + this->size;
-+ memcpy(this->base, tmp, this->size);
-+ jffs2_bbc_free(tmp);
-+ }
-+ else {
-+ this->ptr++;
-+ }
-+ this->size++;
-+ this->freebits = 7;
-+ *(this->ptr) = 0x00;
-+ }
-+ else {
-+ this->freebits--;
-+ (*(this->ptr)) <<= 1;
-+ }
-+}
-+
-+static void bitvector_W_add1(BitVector * this)
-+{
-+ if (!(this->freebits)) {
-+ if (this->size == this->capacity) {
-+ void *tmp = this->base;
-+ this->capacity += VECTOR_ALLOC_SIZE;
-+ this->base = jffs2_bbc_malloc(this->capacity);
-+ this->ptr = ((u8 *) (this->base)) + this->size;
-+ memcpy(this->base, tmp, this->size);
-+ jffs2_bbc_free(tmp);
-+ }
-+ else {
-+ this->ptr++;
-+ }
-+ this->size++;
-+ this->freebits = 7;
-+ *(this->ptr) = 0x01;
-+ }
-+ else {
-+ this->freebits--;
-+ (*(this->ptr)) <<= 1;
-+ (*(this->ptr)) |= 0x01;
-+ }
-+}
-+
-+static void bitvector_W_concat_b(BitVector * lhs, BitVector * rhs)
-+{
-+ void *tmp;
-+ if (!(rhs->size)) {
-+ return;
-+ }
-+ tmp = lhs->base;
-+ lhs->capacity = ((((lhs->size) + (rhs->size) - 1) / VECTOR_ALLOC_SIZE) + 1) * VECTOR_ALLOC_SIZE;
-+ lhs->base = jffs2_bbc_malloc(lhs->capacity);
-+ if (tmp) {
-+ memcpy(lhs->base, tmp, lhs->size);
-+ jffs2_bbc_free(tmp);
-+ }
-+ memcpy((((u8 *) (lhs->base)) + lhs->size), rhs->base, rhs->size);
-+ lhs->freebits = 0;
-+ lhs->size += rhs->size;
-+ lhs->ptr = ((u8 *) (lhs->base)) + lhs->size;
-+}
-+
-+static void bitvector_W_concat_v(BitVector * lhs, vector * rhs)
-+{
-+ void *tmp;
-+ if (!(rhs->size)) {
-+ return;
-+ }
-+ tmp = lhs->base;
-+ lhs->capacity = ((((lhs->size) + (rhs->size) - 1) / VECTOR_ALLOC_SIZE) + 1) * VECTOR_ALLOC_SIZE;
-+ lhs->base = jffs2_bbc_malloc(lhs->capacity);
-+ if (tmp) {
-+ memcpy(lhs->base, tmp, lhs->size);
-+ jffs2_bbc_free(tmp);
-+ }
-+ memcpy((((u8 *) (lhs->base)) + lhs->size), rhs->ptr, rhs->size);
-+ lhs->freebits = 0;
-+ lhs->size += rhs->size;
-+ lhs->ptr = ((u8 *) (lhs->base)) + lhs->size;
-+}
-+
-+static void bitvector_W_flush(BitVector * this)
-+{
-+ (*(this->ptr)) <<= this->freebits;
-+ this->freebits = 0;
-+}
-+
-+static void bitvector_R_reset(BitVector * this)
-+{
-+ this->freebits = 7;
-+ this->ptr = this->base;
-+}
-+
-+static u8 bitvector_R_get1(BitVector * this)
-+{
-+ u8 tmp = ((*(this->ptr)) >> this->freebits) & 0x01;
-+ if (!(this->freebits)) {
-+ this->freebits = 7;
-+ this->ptr++;
-+ }
-+ else {
-+ this->freebits--;
-+ }
-+ return tmp;
-+}
-+
-+static u8 bitvector_R_get8(BitVector * this)
-+{
-+ u8 tmp = (*(this->ptr));
-+ this->ptr++;
-+ return tmp;
-+}
-+
-+#endif
-+
-+//ORIGIN: DataStructures/src/DecisionTree.c
-+
-+/*******************************************************************************
-+* FILE: DecisionTree.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "ipack_common.h"
-+//#include "DataStructures/DecisionTree.h"
-+
-+static void decisiontree_delete_node(void *root)
-+{
-+ u8 tmp = GET_NODE_PTR_TYPE(root);
-+ if (TREENODETYPE_IS_NODE_BINARY(tmp)) {
-+ decisiontree_delete_node(((TreeNodeBinary *) root)->left);
-+ decisiontree_delete_node(((TreeNodeBinary *) root)->right);
-+ }
-+ else if ((tmp) == TREENODETYPE_LEAF_P) {
-+ if (((TreeLeafP *) root)->probabilities) {
-+ jffs2_bbc_free(((TreeLeafP *) root)->probabilities);
-+ }
-+ }
-+ else if ((tmp) == TREENODETYPE_LEAF_C) {
-+ }
-+ jffs2_bbc_free(root);
-+}
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+
-+static void decisiontree_delete(DecisionTree * dt)
-+{
-+ decisiontree_delete_node(dt->root);
-+ jffs2_bbc_free(dt->predictor_max_values);
-+}
-+
-+static void decisiontree_get_probability_for_token(void *root, PredictorType * preds, TokenType token, ProbabilityType * prob)
-+{
-+ void *tmp = root;
-+ while (TREENODETYPE_IS_NODE(((TreeNodeBinary *) tmp)->type)) {
-+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_EQ) {
-+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_EQ((TreeNodeBinary *) tmp)->value) {
-+ tmp = ((TreeNodeBinary *) tmp)->left;
-+ }
-+ else {
-+ tmp = ((TreeNodeBinary *) tmp)->right;
-+ }
-+ }
-+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_LT) {
-+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_LT((TreeNodeBinary *) tmp)->value) {
-+ tmp = ((TreeNodeBinary *) tmp)->left;
-+ }
-+ else {
-+ tmp = ((TreeNodeBinary *) tmp)->right;
-+ }
-+ }
-+ }
-+ prob->high = 0;
-+ prob->low = 0;
-+ prob->max = 0;
-+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_P) {
-+ u32 i;
-+ u32 lngth = ((TreeLeafP *) tmp)->pairs << 1;
-+ for (i = 0; i < lngth;) {
-+ TokenType at = ((TreeLeafP *) tmp)->probabilities[i++];
-+ TokenType av = ((TreeLeafP *) tmp)->probabilities[i++];
-+ if (token > at)
-+ prob->low += av;
-+ if (token >= at)
-+ prob->high += av;
-+ prob->max += av;
-+ }
-+ }
-+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_C) {
-+ if (((TreeLeafC *) tmp)->predicted_class == token) {
-+ prob->high = TOKEN_MAXVALUE;
-+ prob->max = TOKEN_MAXVALUE;
-+ }
-+ }
-+}
-+
-+static TokenType decisiontree_get_token_for_range(void *root, PredictorType * preds, u32 value, u32 range, ProbabilityType * prob)
-+{
-+ void *tmp = root;
-+ TokenType token = 0;
-+ while (TREENODETYPE_IS_NODE(((TreeNodeBinary *) tmp)->type)) {
-+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_EQ) {
-+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_EQ((TreeNodeBinary *) tmp)->value) {
-+ tmp = ((TreeNodeBinary *) tmp)->left;
-+ }
-+ else {
-+ tmp = ((TreeNodeBinary *) tmp)->right;
-+ }
-+ }
-+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_NODE_BINARY_LT) {
-+ if (preds[((TreeNodeBinary *) tmp)->attribute] TREE_SUBTREE_RELATION_LEFT_LT((TreeNodeBinary *) tmp)->value) {
-+ tmp = ((TreeNodeBinary *) tmp)->left;
-+ }
-+ else {
-+ tmp = ((TreeNodeBinary *) tmp)->right;
-+ }
-+ }
-+ }
-+ prob->high = 0;
-+ prob->low = 0;
-+ prob->max = 0;
-+ if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_P) {
-+ u32 i;
-+ u32 norm;
-+ TokenType at = 0;
-+ TokenType av;
-+ u32 lngth = ((TreeLeafP *) tmp)->pairs << 1;
-+ for (i = 0; i < lngth;) {
-+ i++;
-+ prob->max += ((TreeLeafP *) tmp)->probabilities[i++];
-+ }
-+ norm = (value * prob->max - 1) / range;
-+ for (i = 0; prob->high <= norm;) {
-+ at = ((TreeLeafP *) tmp)->probabilities[i++];
-+ av = ((TreeLeafP *) tmp)->probabilities[i++];
-+ prob->high += av;
-+ if (prob->high <= norm)
-+ prob->low += av;
-+ }
-+ token = at;
-+ }
-+ else if (((TreeNodeBinary *) tmp)->type == TREENODETYPE_LEAF_C) {
-+ token = ((TreeLeafC *) tmp)->predicted_class;
-+ prob->high = TOKEN_MAXVALUE;
-+ prob->max = TOKEN_MAXVALUE;
-+ }
-+ return token;
-+}
-+#endif
-+
-+//ORIGIN: DataStructures/src/PredictorTable.c
-+
-+/*******************************************************************************
-+* FILE: PredictorTable.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "ipack_common.h"
-+//#include "DataStructures/PredictorTable.h"
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+
-+static void predictortable_clear(PredictorTable * table)
-+{
-+ table->predictors = 0;
-+}
-+
-+static void predictortable_free(PredictorTable * table)
-+{
-+ if (table->predictors) {
-+ jffs2_bbc_free(table->predictors);
-+ table->predictors = 0;
-+ }
-+}
-+
-+static void predictortable_resetARM(PredictorTable * table)
-+{
-+ register PredictorType *ptr = table->predictors;
-+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS_ARM;
-+ while (ptr < end) {
-+ *(ptr++) = 0;
-+ }
-+}
-+
-+static void predictortable_updateARM(PredictorTable * table, TokenType token)
-+{
-+ register PredictorType *ptr = table->predictors;
-+ register u32 ndx = ptr[0] + 1;
-+ ptr[ndx + 8] = ptr[ndx];
-+ ptr[ndx] = token;
-+ if (ndx == 8) {
-+ ptr[0] = 0;
-+ }
-+ else {
-+ ++ptr[0];
-+ }
-+}
-+
-+static PredictorType predictortable_minvalueARM(PredictorTable * table, u32 index)
-+{
-+ return 0;
-+}
-+
-+static PredictorType predictortable_maxvalueARM(PredictorTable * table, u32 index)
-+{
-+ if (index == 0) {
-+ return 7;
-+ }
-+ else {
-+ return 15;
-+ }
-+}
-+
-+#endif
-+
-+#ifndef __KERNEL__
-+
-+/*static void predictortable_resetTXT(PredictorTable * table)
-+{
-+ register PredictorType *ptr = table->predictors;
-+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS_TXT;
-+ while (ptr < end) {
-+ *(ptr++) = 0;
-+ }
-+}
-+
-+static void predictortable_updateTXT(PredictorTable * table, TokenType token)
-+{ //TODO: modify
-+ register PredictorType *ptr = table->predictors;
-+// register u32 ndx;
-+ ptr[0] = token;
-+ if ((('a' <= token) && (token <= 'z')) || (('A' <= token) && (token <= 'Z'))) {
-+ ++(ptr[1]);
-+ }
-+ else {
-+ ptr[1] = 0;
-+ }
-+}
-+
-+static PredictorType predictortable_minvalueTXT(PredictorTable * table, u32 index)
-+{
-+ return 0;
-+}
-+
-+static PredictorType predictortable_maxvalueTXT(PredictorTable * table, u32 index)
-+{ //TODO: modify
-+ return 254;
-+}*/
-+
-+#endif // __KERNEL__
-+
-+//ORIGIN: DataStructures/src/ipack_model.c
-+
-+/*******************************************************************************
-+* FILE: ipack_model.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "DataStructures/ipack_model.h"
-+//#include "measuredef.h"
-+//#include "ipack_common.h"
-+
-+#ifdef __MEASURE_TIME_MODEL_GETPROB
-+#define __MT_P_MAX 256
-+#define __MT_P_DIV 128
-+#define __MT_P_MIN 0
-+#endif
-+
-+static void ipack_model_get_probability_for_token(ipack_nodetype * tmp, TokenType token, ipack_probability_type * prob)
-+{
-+// register ipack_nodetype* tmp = model->tree_root_ptr;
-+// register ipack_nodetype* tmp = root;
-+ while (TREENODETYPE_IS_NODE(tmp->type)) {
-+ if (tmp->type == TREENODETYPE_NODE_BINARY_EQ) {
-+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_EQ tmp->data.nodeBin.value) {
-+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
-+ }
-+ else {
-+ tmp = tmp->data.nodeBin.right_child_ptr;
-+ }
-+ }
-+ else if (tmp->type == TREENODETYPE_NODE_BINARY_LT) {
-+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_LT tmp->data.nodeBin.value) {
-+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
-+ }
-+ else {
-+ tmp = tmp->data.nodeBin.right_child_ptr;
-+ }
-+ }
-+ }
-+ prob->high = 0;
-+ prob->low = 0;
-+// prob->max = 0;
-+ if (tmp->type == TREENODETYPE_LEAF_P) {
-+ if (token) {
-+ prob->low = tmp->data.leafP.probabilities[token - 1];
-+ }
-+ prob->high = tmp->data.leafP.probabilities[token];
-+// prob->max = tmp->data.leafP.probabilities[15];
-+ }
-+ else if (tmp->type == TREENODETYPE_LEAF_C) {
-+ if (tmp->data.leafC.predicted_class == token) {
-+ prob->high = TOKEN_MAXVALUE;
-+// prob->max = TOKEN_MAXVALUE;
-+ }
-+ }
-+}
-+
-+#ifndef IPACK_ARM_ASM
-+
-+//return ipack_model_get_token_for_range2(tmp,value,range,prob);
-+
-+static TokenType ipack_model_get_token_for_range(ipack_nodetype * tmp, u32 value, u32 range, ipack_probability_type * prob)
-+{
-+// register ipack_nodetype* tmp = model->tree_root_ptr;
-+// register ipack_nodetype* tmp = root;
-+ register TokenType token = 0;
-+ while (TREENODETYPE_IS_NODE(tmp->type)) {
-+ if (tmp->type == TREENODETYPE_NODE_BINARY_EQ) {
-+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_EQ tmp->data.nodeBin.value) {
-+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
-+ }
-+ else {
-+ tmp = tmp->data.nodeBin.right_child_ptr;
-+ }
-+ }
-+ else if (tmp->type == TREENODETYPE_NODE_BINARY_LT) {
-+ if (*(tmp->data.nodeBin.attribute_ptr) TREE_SUBTREE_RELATION_LEFT_LT tmp->data.nodeBin.value) {
-+ ((char *) tmp) += sizeof(tmp->type) + sizeof(ipack_treenodeBin);
-+ }
-+ else {
-+ tmp = tmp->data.nodeBin.right_child_ptr;
-+ }
-+ }
-+ }
-+ prob->high = 0;
-+ prob->low = 0;
-+// prob->max = 0;
-+ if (tmp->type == TREENODETYPE_LEAF_P) {
-+ u32 i;
-+ u32 norm;
-+// prob->max = tmp->data.leafP.probabilities[15];
-+/* norm = (value * prob->max -1)/range;
-+ for(i = 0; i < 15; ++i) {
-+ if(tmp->data.leafP.probabilities[i] > norm) {
-+ break;
-+ }
-+ }*/
-+ norm = ((value << PROBABILITY_SHIFT) - 1);
-+ for (i = 0; i < NUMBER_OF_TOKENS; ++i) {
-+ if (range * tmp->data.leafP.probabilities[i] > norm) {
-+ break;
-+ }
-+ }
-+ token = (TokenType) i;
-+ prob->high = tmp->data.leafP.probabilities[i];
-+ if (token) {
-+ prob->low = tmp->data.leafP.probabilities[token - 1];
-+ }
-+ }
-+ else if (tmp->type == TREENODETYPE_LEAF_C) {
-+ token = tmp->data.leafC.predicted_class;
-+ prob->high = PROBABILITY_MAX;
-+// prob->max = PROBABILITY_MAX;
-+ }
-+ return token;
-+}
-+#endif
-+/*
-+void ipack_model_predictortable_reset(PredictorType* ptr)
-+{
-+// register PredictorType* ptr = model->predictors_ptr;
-+// register PredictorType* ptr = preds;
-+ register PredictorType* end = ptr + NUMBER_OF_PREDICTORS;
-+ while(ptr < end) {
-+ *(ptr++) = 0;
-+ }
-+}
-+
-+void ipack_model_predictortable_update(PredictorType* ptr, TokenType token)
-+{
-+// register PredictorType* ptr = model->predictors_ptr;
-+// register PredictorType* ptr = preds;
-+ register u32 ndx = ptr[0] + 1;
-+ ptr[ndx + 8] = ptr[ndx];
-+ ptr[ndx] = token;
-+ if(ndx == 8) {
-+ ptr[0] = 0;
-+ } else {
-+ ++ ptr[0];
-+ }
-+}*/
-+/****************************************************************************/
-+
-+#ifndef __KERNEL__
-+static void ipack_model_countpreds(void *ptr, ipack_nodetype * node, double *table, double val)
-+{
-+ if ((node->type == TREENODETYPE_NODE_BINARY_EQ) || (node->type == TREENODETYPE_NODE_BINARY_LT)) {
-+ table[(u32) (node->data.nodeBin.attribute_ptr) - (u32) (ptr)] += val;
-+ ipack_model_countpreds(ptr, (void *) (((u8 *) (node)) + sizeof(node->type) + sizeof(ipack_treenodeBin)), table, val / 2);
-+ ipack_model_countpreds(ptr, node->data.nodeBin.right_child_ptr, table, val / 2);
-+ }
-+ else {
-+ }
-+}
-+
-+/*static void ipack_model_printinfo(ipack_model_type * model)
-+{
-+ double *prcnt = jffs2_bbc_malloc(sizeof(double) * NUMBER_OF_PREDICTORS);
-+ u32 i;
-+ for (i = 0; i < NUMBER_OF_PREDICTORS; i++) {
-+ prcnt[i] = 0.0;
-+ }
-+ ipack_model_countpreds(model->predictors_ptr, model->tree_root_ptr, prcnt, 100);
-+ for (i = 0; i < NUMBER_OF_PREDICTORS; i++) {
-+ jffs2_bbc_print3(" p[%3d] = %10.6lf\n", (int) i, prcnt[i]);
-+ }
-+ jffs2_bbc_free(prcnt);
-+}*/
-+
-+static void ipack_dumpnode(unsigned char **ptr, FILE * file, char *prefs)
-+{
-+ switch (*((*ptr)++)) {
-+ u32 i;
-+ u32 j;
-+ u32 x;
-+ u32 y;
-+ case TREENODETYPE_NODE_BINARY_EQ:
-+ x = *((*ptr)++);
-+ y = *((*ptr)++);
-+ fprintf(file, "%s+->\tBinary node: P[%u] equals %u\n", prefs, (unsigned int)x, (unsigned int)y);
-+ for (j = 0; j < 4096 && prefs[j]; ++j);
-+ prefs[j] = '\t';
-+ prefs[++j] = '|';
-+ ipack_dumpnode(ptr, file, prefs);
-+ prefs[j--] = 0;
-+ ipack_dumpnode(ptr, file, prefs);
-+ prefs[j] = 0;
-+ break;
-+ case TREENODETYPE_NODE_BINARY_LT:
-+ x = *((*ptr)++);
-+ y = *((*ptr)++);
-+ fprintf(file, "%s+->\tBinary node: P[%u] greater than %u\n", prefs, (unsigned int)x, (unsigned int)y);
-+ for (j = 0; j < 4096 && prefs[j]; ++j);
-+ prefs[j] = '\t';
-+ prefs[++j] = '|';
-+ ipack_dumpnode(ptr, file, prefs);
-+ prefs[j--] = 0;
-+ ipack_dumpnode(ptr, file, prefs);
-+ prefs[j] = 0;
-+ break;
-+ case TREENODETYPE_LEAF_P:
-+ x = *((*ptr)++);
-+ fprintf(file, "%s+->\tLeaf: %u pairs\n", prefs, (unsigned int)x);
-+ (*ptr) += (x << 1);
-+ break;
-+ case TREENODETYPE_LEAF_C:
-+ x = *((*ptr)++);
-+ fprintf(file, "%s+->\tLeaf: class %u\n", prefs, (unsigned int)x);
-+ break;
-+ default:
-+ fprintf(file, "%s+->\tLeaf: nullnode\n", prefs);
-+ }
-+}
-+
-+/*static void ipack_dumpmodel(void *model)
-+{
-+ unsigned char *tmp_ptr = model;
-+ FILE *file;
-+ char C[4096];
-+ if ((file = fopen("DUMPED_MODEL", "wa"))) {
-+ int i;
-+ for (i = 0; i < 4096; C[i++] = 0);
-+ tmp_ptr += 8;
-+ tmp_ptr += sizeof(u32);
-+ ipack_dumpnode(&tmp_ptr, file, C);
-+ fclose(file);
-+ }
-+}*/
-+
-+#endif
-+
-+//ORIGIN: Builders/src/PredictorGenerator.c
-+
-+/*******************************************************************************
-+* FILE: PredictorGenerator.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "ipack_common.h"
-+//#include "Builders/PredictorGenerator.h"
-+
-+#ifdef JFFS2_BBC_ARMLIB_MODELGEN
-+static PredictorTable *predictorgenerator_generate( /*PredictorGeneratorSettings* settings */ )
-+{
-+ PredictorTable *ptr = jffs2_bbc_malloc(sizeof(PredictorTable));
-+ predictortable_clear(ptr);
-+ ptr->predictors = jffs2_bbc_malloc(NUMBER_OF_PREDICTORS * sizeof(PredictorType));
-+ return ptr;
-+}
-+#endif
-+
-+//ORIGIN: Builders/src/ipack_armlib_compressor.c
-+
-+/*******************************************************************************
-+* FILE: ipack_armlim_compressor.c
-+* AUTHOR: Tamás Gergely
-+* MODIFIED: $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*******************************************************************************/
-+
-+//#include "ipack_common.h"
-+//#include "DataStructures.h"
-+//#include "Builders/PredictorGenerator.h"
-+//#include "Builders/Tokenizer.h"
-+//#include "Builders/Coder.h"
-+
-+#define EC_NO_ERROR 0
-+#define EC_NOT_IPMF_FILE -1
-+#define EC_NOT_IPMF_MODEL -2
-+#define EC_NOT_HG_BLOCK -3
-+#define EC_WRONG_INPUT_LENGTH -501
-+#define EC_CODER_WRONG_PROBABILITY 1
-+#define EC_CODER_WRONG_RANGE 2
-+#define EC_BUFFER_OVERFLOW 501
-+#define EC_BUFFER_UNDERFLOW 502
-+#define EC_UNKNOWN_TOKEN_TYPE 1001
-+#define EC_UNKNOWN_FILTER 1002
-+#define EC_UNKNOWN_CONVERTER 1003
-+#define EC_UNKNOWN_MANIPULATOR 1004
-+
-+/*******************************************************************************
-+
-+ COMPRESSOR INIT FUNCTIONS
-+
-+*******************************************************************************/
-+
-+#define ROUND_UP_TO_DWORD(val) ( ( (val) + 3 ) & 0xfffffffc )
-+
-+#ifndef __KERNEL__
-+int ipack_glb_endian_X;
-+#endif
-+
-+static int ipack_compressor_init_tree(unsigned char **ptr, ipack_model_type * model, ipack_nodetype * node, void *nullnode)
-+{
-+ int retval = 0;
-+ node->type = *((*ptr)++);
-+ switch (node->type) {
-+ u32 i;
-+ u32 j;
-+ u32 lngth;
-+ u32 tmpret;
-+ TokenType at;
-+ u16 av;
-+ case TREENODETYPE_NODE_BINARY_EQ:
-+ case TREENODETYPE_NODE_BINARY_LT:
-+ node->data.nodeBin.attribute_ptr = (model->predictors_ptr) + (*((*ptr)++));
-+ node->data.nodeBin.value = *((*ptr)++);
-+ retval = sizeof(node->data.nodeBin);
-+ retval += ipack_compressor_init_tree(ptr, model, (void *) ROUND_UP_TO_DWORD(((u32) node) + sizeof(node->type) + sizeof(node->data.nodeBin)), nullnode);
-+ node->data.nodeBin.right_child_ptr = (void *) ROUND_UP_TO_DWORD(((u32) node) + retval + sizeof(node->type));
-+ retval += ipack_compressor_init_tree(ptr, model, node->data.nodeBin.right_child_ptr, nullnode);
-+ break;
-+ case TREENODETYPE_LEAF_P:
-+ lngth = *((*ptr)++);
-+ av = 0;
-+ for (i = 0, j = 0; i < lngth; ++i) {
-+ at = *((*ptr)++);
-+ while (j < at) {
-+ node->data.leafP.probabilities[j++] = av;
-+ }
-+ av += *((*ptr)++);
-+ }
-+ while (j < NUMBER_OF_TOKENS) {
-+ node->data.leafP.probabilities[j++] = av;
-+ }
-+ for (i = 0; i < NUMBER_OF_TOKENS; ++i) {
-+ node->data.leafP.probabilities[i] = ((node->data.leafP.probabilities[i] << PROBABILITY_SHIFT) / node->data.leafP.probabilities[NUMBER_OF_TOKENS - 1]);
-+ }
-+ retval = ROUND_UP_TO_DWORD(NUMBER_OF_TOKENS * sizeof(u16));
-+ break;
-+ case TREENODETYPE_LEAF_C:
-+ node->data.leafC.predicted_class = *((*ptr)++);
-+ retval = sizeof(node->data.leafC);
-+ retval = ROUND_UP_TO_DWORD(retval);
-+ break;
-+ default:
-+ return 0;
-+ }
-+ return retval + sizeof(node->type);
-+}
-+
-+#define IPACK_TREE_CONVERT_REPLACE 0
-+#define IPACK_TREE_CONVERT_KEEP 1
-+
-+static void *ipack_tree_to_code(ipack_model_type * model, int *code_size);
-+
-+static int ipack_armlib_convert_tree_to_code(ipack_model_type * model_img, int mode)
-+{
-+#ifdef IPACK_TREE_TO_CODE
-+ int tree_size;
-+
-+ model_img->tree_code = ipack_tree_to_code(model_img, &tree_size);
-+ jffs2_bbc_print2("Convertation done. Code size=%d\n", tree_size);
-+ if (mode == IPACK_TREE_CONVERT_REPLACE) {
-+ jffs2_bbc_print1("Freeing original tree.\n");
-+ jffs2_bbc_free(model_img->tree_root_ptr);
-+ model_img->tree_root_ptr = NULL;
-+ }
-+#endif
-+ return 0;
-+}
-+
-+
-+static int ipack_armlib_compressor_init(void **model)
-+{
-+ int retval = EC_NO_ERROR;
-+ unsigned char *tmp_ptr = *model;
-+ u32 i;
-+ ipack_model_type *model_img;
-+ char tmp_c[2];
-+
-+ if (*(tmp_ptr++) != 'i') {
-+ return EC_NOT_IPMF_FILE;
-+ }
-+ else if (*(tmp_ptr++) != 'P') {
-+ return EC_NOT_IPMF_FILE;
-+ }
-+ else if (*(tmp_ptr++) != 'M') {
-+ return EC_NOT_IPMF_FILE;
-+ }
-+ else if (*(tmp_ptr++) != 'F') {
-+ return EC_NOT_IPMF_FILE;
-+ }
-+ tmp_c[0] = *(tmp_ptr++);
-+ tmp_c[1] = *(tmp_ptr++);
-+ tmp_ptr += 2;
-+
-+ //model_img = jffs2_bbc_malloc(*((u32*)tmp_ptr));
-+ model_img = jffs2_bbc_malloc(sizeof(ipack_model_type) + ROUND_UP_TO_DWORD(NUMBER_OF_PREDICTORS));
-+ model_img->tree_root_ptr = jffs2_bbc_malloc(*((u32 *) tmp_ptr)); //it is smaller a little but, but...
-+
-+ tmp_ptr += sizeof(u32);
-+
-+ model_img->ID[0] = 'i';
-+ model_img->ID[1] = 'P';
-+ model_img->ID[2] = 'M';
-+ model_img->ID[3] = 'F';
-+
-+ model_img->block_sign[0] = tmp_c[0];
-+ model_img->block_sign[1] = tmp_c[1];
-+
-+ model_img->nullnode.type = TREENODETYPE_LEAF_P;
-+ for (i = 0; i < NUMBER_OF_TOKENS; ++i) {
-+ model_img->nullnode.probabilities[i] = 0;
-+ }
-+ model_img->predictors_ptr = (void *) (((u32) model_img) + sizeof(ipack_model_type));
-+ //model_img->tree_root_ptr = (void*)ROUND_UP_TO_DWORD(((u32)(model_img->predictors_ptr)) + NUMBER_OF_PREDICTORS);//ALIGN
-+
-+ ipack_compressor_init_tree(&tmp_ptr, model_img, model_img->tree_root_ptr, &(model_img->nullnode));
-+
-+#ifdef IPACK_TREE_TO_CODE
-+#ifdef IPACK_AUTO_TREE_TO_CODE
-+ jffs2_bbc_print1("Automatically converting tree to ARM code...\n");
-+ ipack_armlib_convert_tree_to_code(model_img, IPACK_TREE_CONVERT_REPLACE);
-+#else
-+ model_img->tree_code = NULL;
-+#endif
-+#else
-+ model_img->tree_code = NULL;
-+#endif
-+
-+ jffs2_bbc_free(*model);
-+ *model = model_img;
-+ return retval;
-+}
-+
-+/*******************************************************************************
-+
-+ COMPRESSOR DEINIT FUNCTIONS
-+
-+*******************************************************************************/
-+
-+
-+/* Descructor of compressor (model will be freed with jffs2_bbc_free() after it)*/
-+static void ipack_armlib_compressor_deinit(void)
-+{
-+}
-+
-+/*******************************************************************************
-+
-+ COMPRESS FUNCTIONS
-+
-+*******************************************************************************/
-+
-+static int writebits0(unsigned char **dest, u8 * freebits, u32 * opposite, unsigned char *end)
-+{
-+ if (!(*freebits)) {
-+ ++(*dest);
-+ *freebits = 7;
-+ **dest = 0x00;
-+ }
-+ else {
-+ --(*freebits);
-+ (**dest) <<= 1;
-+ }
-+ if ((*dest == end) && !(*freebits)) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ while (*opposite) {
-+ --(*opposite);
-+ if (!(*freebits)) {
-+ ++(*dest);
-+ *freebits = 7;
-+ **dest = 0x01;
-+ }
-+ else {
-+ --(*freebits);
-+ (**dest) <<= 1;
-+ (**dest) |= 0x01;
-+ }
-+ if ((*dest == end) && !(*freebits)) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ }
-+ return 0;
-+}
-+
-+static int writebits1(unsigned char **dest, u8 * freebits, u32 * opposite, unsigned char *end)
-+{
-+ if (!(*freebits)) {
-+ ++(*dest);
-+ *freebits = 7;
-+ **dest = 0x01;
-+ }
-+ else {
-+ --(*freebits);
-+ (**dest) <<= 1;
-+ (**dest) |= 0x01;
-+ }
-+ if ((*dest == end) && !(*freebits)) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ while (*opposite) {
-+ --(*opposite);
-+ if (!(*freebits)) {
-+ ++(*dest);
-+ *freebits = 7;
-+ **dest = 0x00;
-+ }
-+ else {
-+ --(*freebits);
-+ (**dest) <<= 1;
-+ }
-+ if ((*dest == end) && !(*freebits)) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ }
-+ return 0;
-+}
-+
-+
-+
-+
-+/* Compress block
-+ * *dstlen bytes are allocated.
-+ * if it is not enough write *sourcelen over to the processed amount of data
-+ * returns non zero if fails
-+ */
-+static int ipack_armlib_compress(void *model, unsigned char *input, unsigned char *output, unsigned long *sourcelen, unsigned long *dstlen)
-+{
-+ register u32 coder_high = CODER_VALUEMAX - 1;
-+ register u32 coder_low = 0;
-+ u32 coder_opbits = 0;
-+ u8 bitvector_freebits = 8;
-+ unsigned char *bitvector_ptr = output;
-+ unsigned char *bitvector_end = output + (*dstlen - 1);
-+ ARM_DataType *tmpp;
-+ TokenStream tmpv;
-+ TokenType *it;
-+ void *end_it;
-+
-+ ipack_nodetype *treeroot = ((ipack_model_type *) model)->tree_root_ptr;
-+ PredictorType *predctrs = ((ipack_model_type *) model)->predictors_ptr;
-+
-+#ifdef IPACK_TREE_TO_CODE
-+ void (*treefunc) (ipack_nodetype *, TokenType, ipack_probability_type *);
-+
-+ treefunc = ((ipack_model_type *) model)->tree_code;
-+ if (treefunc != NULL)
-+ treefunc += 4;
-+#endif
-+
-+ if ((*sourcelen % 4) != 0) {
-+ return EC_WRONG_INPUT_LENGTH;
-+ }
-+ if (*dstlen <= 4) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+
-+ if (((ipack_model_type *) model)->ID[0] != 'i') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+ else if (((ipack_model_type *) model)->ID[1] != 'P') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+ else if (((ipack_model_type *) model)->ID[2] != 'M') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+ else if (((ipack_model_type *) model)->ID[3] != 'F') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+#ifdef TXT_TOKENS
-+ tmpv.capacity = (*sourcelen);
-+#else
-+ tmpv.capacity = (*sourcelen) << 1;
-+#endif
-+ tmpv.size = tmpv.capacity;
-+ tmpv.ptr = jffs2_bbc_malloc(tmpv.size);
-+ it = tmpv.ptr;
-+
-+#ifndef __KERNEL__
-+ if (ipack_glb_endian_X) {
-+ for (tmpp = (void *) input; (u32) tmpp < (u32) (input + *sourcelen); ++tmpp) {
-+#ifdef TXT_TOKENS
-+ *(it++) = (u8) ((*tmpp & 0xff000000) >> 24);
-+ *(it++) = (u8) ((*tmpp & 0x00ff0000) >> 16);
-+ *(it++) = (u8) ((*tmpp & 0x0000ff00) >> 8);
-+ *(it++) = (u8) ((*tmpp & 0x000000ff));
-+#else
-+ *(it++) = (u8) ((*tmpp & 0x0000f000) >> 12);
-+ *(it++) = (u8) ((*tmpp & 0x0000000f));
-+ *(it++) = (u8) ((*tmpp & 0xf0000000) >> 28);
-+ *(it++) = (u8) ((*tmpp & 0x000f0000) >> 16);
-+ *(it++) = (u8) ((*tmpp & 0x00000f00) >> 8);
-+ *(it++) = (u8) ((*tmpp & 0x00f00000) >> 20);
-+ *(it++) = (u8) ((*tmpp & 0x0f000000) >> 24);
-+ *(it++) = (u8) ((*tmpp & 0x000000f0) >> 4);
-+#endif //TXT_TOKENS
-+ }
-+ }
-+ else {
-+#endif
-+ for (tmpp = (void *) input; (u32) tmpp < (u32) (input + *sourcelen); ++tmpp) {
-+#ifdef TXT_TOKENS
-+ *(it++) = (u8) ((*tmpp & 0x000000ff));
-+ *(it++) = (u8) ((*tmpp & 0x0000ff00) >> 8);
-+ *(it++) = (u8) ((*tmpp & 0x00ff0000) >> 16);
-+ *(it++) = (u8) ((*tmpp & 0xff000000) >> 24);
-+#else
-+ *(it++) = (u8) ((*tmpp & 0x00f00000) >> 20);
-+ *(it++) = (u8) ((*tmpp & 0x0f000000) >> 24);
-+ *(it++) = (u8) ((*tmpp & 0x000000f0) >> 4);
-+ *(it++) = (u8) ((*tmpp & 0x00000f00) >> 8);
-+ *(it++) = (u8) ((*tmpp & 0x000f0000) >> 16);
-+ *(it++) = (u8) ((*tmpp & 0x0000f000) >> 12);
-+ *(it++) = (u8) ((*tmpp & 0x0000000f));
-+ *(it++) = (u8) ((*tmpp & 0xf0000000) >> 28);
-+#endif //TXT_TOKENS
-+ }
-+#ifndef __KERNEL__
-+ }
-+#endif
-+/*
-+ ENCODE
-+*/
-+ { //predictor reset
-+ register PredictorType *ptr = predctrs;
-+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS;
-+ while (ptr < end) {
-+ *(ptr++) = 0;
-+ }
-+ }
-+
-+ //*(bitvector_ptr++) = 'H';
-+ //*(bitvector_ptr++) = 'G';
-+ *(bitvector_ptr++) = ((ipack_model_type *) model)->block_sign[0];
-+ *(bitvector_ptr++) = ((ipack_model_type *) model)->block_sign[1];
-+
-+ *(bitvector_ptr++) = (unsigned char) (((*sourcelen) >> 8) & 0xff);
-+ *(bitvector_ptr++) = (unsigned char) ((*sourcelen) & 0xff);
-+ for (it = tmpv.ptr, end_it = VECTOR_S_END(tmpv); it != end_it; ++it) {
-+ ipack_probability_type prob;
-+ u32 range;
-+
-+#ifdef IPACK_TREE_TO_CODE
-+ if (treefunc != NULL)
-+ (*treefunc) (treeroot, *it, &prob);
-+ else
-+ ipack_model_get_probability_for_token(treeroot, *it, &prob);
-+#else
-+ ipack_model_get_probability_for_token(treeroot, *it, &prob);
-+#endif
-+
-+ if (prob.high == prob.low) {
-+ vector_clear(&tmpv);
-+ return EC_CODER_WRONG_PROBABILITY;
-+ }
-+ range = coder_high - coder_low + 1;
-+ coder_high = coder_low + ((range * prob.high) >> PROBABILITY_SHIFT) - 1;
-+ coder_low += ((range * prob.low) >> PROBABILITY_SHIFT);
-+ for (;;) {
-+ if (coder_high < CODER_VALUEHLF) {
-+ if (writebits0(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
-+ vector_clear(&tmpv);
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ }
-+ else if (coder_low >= CODER_VALUEHLF) {
-+ if (writebits1(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
-+ vector_clear(&tmpv);
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ coder_high -= CODER_VALUEHLF;
-+ coder_low -= CODER_VALUEHLF;
-+ }
-+ else if ((CODER_VALUE1ST <= coder_low) && (coder_high < CODER_VALUE3RD)) {
-+ ++coder_opbits;
-+ coder_high -= CODER_VALUE1ST;
-+ coder_low -= CODER_VALUE1ST;
-+ }
-+ else {
-+ break;
-+ }
-+ coder_high <<= 1;
-+ ++coder_high;
-+ coder_low <<= 1;
-+ if (coder_high < coder_low) {
-+ vector_clear(&tmpv);
-+ return EC_CODER_WRONG_RANGE;
-+ }
-+ }
-+ {
-+#ifdef TXT_TOKENS
-+// register u32 ndx;
-+ predctrs[0] = *it;
-+ if ((('a' <= *it) && (*it <= 'z')) || (('A' <= *it) && (*it <= 'Z'))) {
-+ ++(predctrs[1]);
-+ }
-+ else {
-+ predctrs[1] = 0;
-+ }
-+#else
-+ register u32 ndx = predctrs[0] + 1;
-+ predctrs[ndx + 8] = predctrs[ndx];
-+ predctrs[ndx] = *it;
-+ if (ndx == 8) {
-+ predctrs[0] = 0;
-+ }
-+ else {
-+ ++predctrs[0];
-+ }
-+#endif
-+ }
-+
-+ }
-+ vector_clear(&tmpv);
-+ ++coder_opbits;
-+ if (coder_low < CODER_VALUE1ST) {
-+ if (writebits0(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ }
-+ else {
-+ if (writebits1(&bitvector_ptr, &bitvector_freebits, &coder_opbits, bitvector_end)) {
-+ return EC_BUFFER_OVERFLOW;
-+ }
-+ }
-+ (*(bitvector_ptr)) <<= bitvector_freebits;
-+ *dstlen = ((u32) bitvector_ptr - (u32) output + 1);
-+ return EC_NO_ERROR;
-+}
-+
-+/*******************************************************************************
-+
-+ DECOMPRESS FUNCTIONS
-+
-+*******************************************************************************/
-+
-+typedef struct
-+{
-+ u32 high;
-+ u32 low;
-+ u32 value;
-+ u32 overread;
-+} ipack_decompressor_values;
-+
-+typedef struct
-+{
-+ u8 freebits;
-+ unsigned char *ptr;
-+ unsigned char *end;
-+} ipack_decompressor_bitvector;
-+
-+static u8 ipack_bitvector_R_get1(ipack_decompressor_bitvector * bv)
-+{
-+ u8 tmp;
-+ if (bv->ptr == bv->end) {
-+ bv->freebits = 0;
-+ return 0;
-+ }
-+ tmp = (*(bv->ptr) >> bv->freebits) & 0x01;
-+ if (!(bv->freebits)) {
-+ bv->freebits = 7;
-+ ++(bv->ptr);
-+ }
-+ else {
-+ --(bv->freebits);
-+ }
-+ return tmp;
-+}
-+
-+/* Decompress block
-+ * returns non zero if fails
-+ */
-+static int ipack_armlib_decompress(void *model, unsigned char *input, unsigned char *output, unsigned long sourcelen, unsigned long dstlen)
-+{
-+ ARM_DataType *data;
-+ register u32 coder_high = CODER_VALUEMAX - 1;
-+ register u32 coder_low = 0;
-+ register u32 coder_value = 0;
-+ u32 coder_overread = 0;
-+ ipack_decompressor_bitvector bitvector;
-+ u32 lngth;
-+ u32 i;
-+ u32 cntbytes;
-+ TokenType tkns[8];
-+ TokenType *tptr;
-+
-+ ipack_nodetype *treeroot = ((ipack_model_type *) model)->tree_root_ptr;
-+ PredictorType *predctrs = ((ipack_model_type *) model)->predictors_ptr;
-+
-+#ifdef IPACK_TREE_TO_CODE
-+ TokenType(*treefunc) (ipack_nodetype *, u32, u32, ipack_probability_type *);
-+
-+ treefunc = ((ipack_model_type *) model)->tree_code;
-+#endif
-+
-+
-+ if (((ipack_model_type *) model)->ID[0] != 'i') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+ else if (((ipack_model_type *) model)->ID[1] != 'P') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+ else if (((ipack_model_type *) model)->ID[2] != 'M') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+ else if (((ipack_model_type *) model)->ID[3] != 'F') {
-+ return EC_NOT_IPMF_MODEL;
-+ }
-+
-+ bitvector.freebits = 7;
-+ bitvector.ptr = input;
-+ bitvector.end = input + sourcelen;
-+
-+ /*if(*(bitvector.ptr++) != 'H') {
-+ return EC_NOT_HG_BLOCK;
-+ } else if(*(bitvector.ptr++) != 'G') {
-+ return EC_NOT_HG_BLOCK;
-+ } */
-+ bitvector.ptr++;
-+ bitvector.ptr++;
-+
-+ data = (void *) output;
-+ cntbytes = *(bitvector.ptr++);
-+ cntbytes <<= 8;
-+ cntbytes += *(bitvector.ptr++);
-+
-+ { //predictor reset
-+ register PredictorType *ptr = predctrs;
-+ register PredictorType *end = ptr + NUMBER_OF_PREDICTORS;
-+ while (ptr < end) {
-+ *(ptr++) = 0;
-+ }
-+ }
-+ for (i = 0; i < CODER_VALUEBITS; ++i) {
-+ coder_value <<= 1;
-+ coder_value += ipack_bitvector_R_get1(&bitvector);
-+ }
-+ lngth = dstlen >> 2;
-+ if (lngth > (cntbytes >> 2)) {
-+ lngth = cntbytes >> 2;
-+ }
-+ for (i = 0; (i < lngth); ++i) {
-+ TokenType itoken;
-+ u32 j;
-+ tptr = tkns;
-+ for (j = 0; j < NUMBER_OF_TOKENS_PER_INSTRUCTION; ++j) {
-+ ipack_probability_type prob;
-+ u32 range = coder_high - coder_low + 1;
-+
-+#ifdef IPACK_TREE_TO_CODE
-+ if (treefunc != NULL)
-+ itoken = (*treefunc) (treeroot, coder_value - coder_low + 1, range, &prob);
-+ else
-+#endif
-+ itoken = ipack_model_get_token_for_range(treeroot, coder_value - coder_low + 1, range, &prob);
-+
-+
-+ if (prob.high == prob.low) {
-+ return EC_CODER_WRONG_PROBABILITY;
-+ }
-+ coder_high = coder_low + ((range * prob.high) >> PROBABILITY_SHIFT) - 1;
-+ coder_low += ((range * prob.low) >> PROBABILITY_SHIFT);
-+ for (;;) {
-+ if (coder_high < CODER_VALUEHLF) {
-+ }
-+ else if (CODER_VALUEHLF <= coder_low) {
-+ coder_value -= CODER_VALUEHLF;
-+ coder_high -= CODER_VALUEHLF;
-+ coder_low -= CODER_VALUEHLF;
-+ }
-+ else if ((CODER_VALUE1ST <= coder_low) && (coder_high < CODER_VALUE3RD)) {
-+ coder_value -= CODER_VALUE1ST;
-+ coder_high -= CODER_VALUE1ST;
-+ coder_low -= CODER_VALUE1ST;
-+ }
-+ else {
-+ break;
-+ }
-+ coder_low <<= 1;
-+ coder_high <<= 1;
-+ ++(coder_high);
-+ coder_value <<= 1;
-+ if (bitvector.ptr == bitvector.end) {
-+ bitvector.freebits = 0;
-+ }
-+ coder_value += ((*(bitvector.ptr) >> bitvector.freebits) & 0x01);
-+ if (bitvector.freebits) {
-+ --bitvector.freebits;
-+ }
-+ else {
-+ bitvector.freebits = 7;
-+ ++bitvector.ptr;
-+ }
-+ if (coder_high < coder_low) {
-+ return EC_CODER_WRONG_RANGE;
-+ }
-+ if ((bitvector.ptr == bitvector.end) && !(bitvector.freebits)) {
-+ if ((coder_overread++) > CODER_VALUEBITS) {
-+ return EC_BUFFER_UNDERFLOW;
-+ }
-+ }
-+ }
-+ {
-+#ifdef TXT_TOKENS
-+// register u32 ndx;
-+ predctrs[0] = itoken;
-+ if ((('a' <= itoken) && (itoken <= 'z')) || (('A' <= itoken) && (itoken <= 'Z'))) {
-+ ++(predctrs[1]);
-+ }
-+ else {
-+ predctrs[1] = 0;
-+ }
-+
-+#else
-+ register u32 ndx = predctrs[0] + 1;
-+ predctrs[ndx + 8] = predctrs[ndx];
-+ predctrs[ndx] = itoken;
-+ if (ndx == 8) {
-+ predctrs[0] = 0;
-+ }
-+ else {
-+ ++predctrs[0];
-+ }
-+#endif
-+ }
-+
-+ (*(tptr++)) = itoken;
-+ }
-+ tptr = tkns;
-+#ifndef __KERNEL__
-+ if (ipack_glb_endian_X) {
-+#ifdef TXT_TOKENS
-+ (*data) = ((*tptr) << 24);
-+ ++tptr;
-+ (*data) |= ((*tptr) << 16);
-+ ++tptr;
-+ (*data) |= ((*tptr) << 8);
-+ ++tptr;
-+ (*data) |= (*tptr);
-+ ++data;
-+#else
-+ (*data) = (((*tptr) & 0xf) << 12);
-+ ++tptr;
-+ (*data) |= ((*tptr) & 0xf);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 28);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 16);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 8);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 20);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 24);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 4);
-+ ++data;
-+#endif
-+ }
-+ else {
-+#endif
-+#ifdef TXT_TOKENS
-+ (*data) = (*tptr);
-+ ++tptr;
-+ (*data) |= ((*tptr) << 8);
-+ ++tptr;
-+ (*data) |= ((*tptr) << 16);
-+ ++tptr;
-+ (*data) |= ((*tptr) << 24);
-+ ++data;
-+#else
-+ (*data) = (((*tptr) & 0xf) << 20);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 24);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 4);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 8);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 16);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 12);
-+ ++tptr;
-+ (*data) |= ((*tptr) & 0xf);
-+ ++tptr;
-+ (*data) |= (((*tptr) & 0xf) << 28);
-+ ++data;
-+#endif
-+#ifndef __KERNEL__
-+ }
-+#endif
-+ }
-+ return EC_NO_ERROR;
-+}
-+
-+static int ipack_armlib_estimate(void *model, unsigned char *input, unsigned long sourcelen, unsigned long *dstlen, unsigned long *readtime, unsigned long *writetime)
-+{
-+ int i, tmp, tmp2, max, maxi;
-+ int cnt_cond[] = { 0, 0, 0, 0 };
-+ int cnt_inst[] = { 0, 0, 0, 0 };
-+
-+ // TODO: make a more precise estimation!!!
-+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 6;
-+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 2;
-+
-+ if (sourcelen % 4 != 0) {
-+ *dstlen = sourcelen;
-+ return 0;
-+ }
-+ for (i = 0; i < sourcelen; i++, input++) {
-+ tmp2 = tmp = *input;
-+ tmp = ((tmp) & 0xf0) >> 4;
-+ tmp2 = tmp2 & 0xf;
-+ if (tmp == 14)
-+ cnt_cond[i % 4]++;
-+ if ((tmp2 == 2) || (tmp2 == 3))
-+ cnt_inst[i % 4]++;
-+ }
-+ maxi = -1;
-+ max = -1;
-+ for (i = 0; i < 4; i++)
-+ if (max < cnt_cond[i]) {
-+ max = cnt_cond[i];
-+ maxi = i;
-+ }
-+ /*jffs2_bbc_print("armlib_EST: %d/%d : %d/%d %d/%d %d/%d %d/%d",
-+ cnt_cond[maxi],cnt_inst[maxi],
-+ cnt_cond[0],cnt_inst[0],
-+ cnt_cond[1],cnt_inst[1],
-+ cnt_cond[2],cnt_inst[2],
-+ cnt_cond[3],cnt_inst[3]); */
-+
-+ if (cnt_cond[maxi] < (sourcelen >> 4)) {
-+ *dstlen = sourcelen;
-+ }
-+ else {
-+ *dstlen = sourcelen / 3;
-+ }
-+
-+ return 0;
-+}
-+
-+static char *ipack_armlib_proc_info(void);
-+static int ipack_armlib_proc_command(char *command);
-+static void ipack_armlib_destroy_model(void **model);
-+
-+struct jffs2_bbc_compressor_type jffs2_bbc_armlib = {
-+ "armlib",
-+ 0x464d5069,
-+ {0, 0, 0, 0},
-+ NULL, // init
-+ ipack_armlib_compressor_init, // init_model
-+ ipack_armlib_destroy_model, // destroy_model
-+ ipack_armlib_compressor_deinit, // deinit
-+ ipack_armlib_compress,
-+ ipack_armlib_estimate,
-+ ipack_armlib_decompress,
-+ ipack_armlib_proc_info,
-+ ipack_armlib_proc_command
-+};
-+
-+
-+static char *ipack_armlib_proc_info()
-+{
-+#ifdef IPACK_TREE_TO_CODE
-+#ifdef IPACK_AUTO_TREE_TO_CODE
-+ return "automatic tree to code conversion";
-+#else
-+ return "manual tree to code conversion possibility";
-+#endif
-+#else
-+ return "tree in memory version";
-+#endif
-+}
-+
-+static int ipack_armlib_proc_command(char *command)
-+{
-+ struct jffs2_bbc_model_list_node *model;
-+ ipack_model_type *armlib_model;
-+
-+ if ((*command == 'g') || (*command == 'G')) {
-+ jffs2_bbc_print1("Converting tree(s) to ARM code... (keeping original)\n");
-+ model = jffs2_bbc_armlib.models;
-+ if (model == NULL)
-+ jffs2_bbc_print1("no model found!\n");
-+ while (model != NULL) {
-+ armlib_model = model->model;
-+ if (armlib_model == NULL) {
-+ jffs2_bbc_print1("Error: NULL model!\n");
-+ }
-+ else {
-+ ipack_armlib_convert_tree_to_code(armlib_model, IPACK_TREE_CONVERT_KEEP);
-+ }
-+ model = model->next_compr_model;
-+ }
-+ }
-+ else if ((*command == 'r') || (*command == 'R')) {
-+ jffs2_bbc_print1("Converting tree(s) to ARM code... (deleting original)\n");
-+ model = jffs2_bbc_armlib.models;
-+ if (model == NULL)
-+ jffs2_bbc_print1("no model found!\n");
-+ while (model != NULL) {
-+ armlib_model = model->model;
-+ if (armlib_model == NULL) {
-+ jffs2_bbc_print1("Error: NULL model!\n");
-+ }
-+ else {
-+ //armlib_model->tree_code = ipack_tree_to_code(armlib_model, &tree_size);
-+ //jffs2_bbc_print("Convertation done. Code size=%d\n",tree_size);
-+ ipack_armlib_convert_tree_to_code(armlib_model, IPACK_TREE_CONVERT_REPLACE);
-+ }
-+ model = model->next_compr_model;
-+ }
-+ }
-+ else if ((*command == 'c') || (*command == 'C')) {
-+ jffs2_bbc_print1("Deleting ARM representation of the tree(s)...\n");
-+ model = jffs2_bbc_armlib.models;
-+ if (model == NULL)
-+ jffs2_bbc_print1("no model found!\n");
-+ while (model != NULL) {
-+ armlib_model = model->model;
-+ if (armlib_model == NULL) {
-+ jffs2_bbc_print1("Error: NULL model!\n");
-+ }
-+ else {
-+ if (armlib_model->tree_code == NULL) {
-+ jffs2_bbc_print1("already deleted.\n");
-+ }
-+ else {
-+ if (armlib_model->tree_root_ptr == NULL) {
-+ jffs2_bbc_print1("cannot delete this ARM tree - original tree has deleted\n");
-+ }
-+ else {
-+ jffs2_bbc_print1("deleting...");
-+ jffs2_bbc_free(armlib_model->tree_code);
-+ armlib_model->tree_code = NULL;
-+ jffs2_bbc_print1("done.\n");
-+ }
-+ }
-+ }
-+ model = model->next_compr_model;
-+ }
-+ }
-+ else if (*command == '?') {
-+ jffs2_bbc_print1("ARMLIB commands:\n");
-+ jffs2_bbc_print1(" g: convert TREEs to ARM code and keep the original\n");
-+ jffs2_bbc_print1(" r: convert TREEs to ARM code and remove the original\n");
-+ jffs2_bbc_print1(" c: delete the original TREEs - if there is any\n");
-+ }
-+ else {
-+ jffs2_bbc_print1("Unknown command.\n");
-+ }
-+ return 0;
-+}
-+
-+static void ipack_armlib_destroy_model(void **model)
-+{
-+ ipack_model_type *model_img;
-+
-+ model_img = *model;
-+ if (model_img == NULL) {
-+ jffs2_bbc_print1("jffs2.bbc: armlib: NULL model at destoying model!\n");
-+ return;
-+ }
-+ if (model_img->tree_code != NULL) {
-+ //jffs2_bbc_print1("jffs2.bbc: armlib: debug: freeing code...\n");
-+ jffs2_bbc_free(model_img->tree_code);
-+ model_img->tree_code = NULL;
-+ }
-+ if (model_img->tree_root_ptr != NULL) {
-+ //jffs2_bbc_print1("jffs2.bbc: armlib: debug: freeing tree...\n");
-+ jffs2_bbc_free(model_img->tree_root_ptr);
-+ model_img->tree_root_ptr = NULL;
-+ }
-+
-+ jffs2_bbc_free(model_img);
-+ *model = NULL;
-+}
-+
-+struct jffs2_bbc_compressor_type *jffs2_bbc_armlib_init(int mode)
-+{
-+ if (jffs2_bbc_register_compressor(&jffs2_bbc_armlib) == 0)
-+ return &jffs2_bbc_armlib;
-+ else
-+ return NULL;
-+}
-+
-+void jffs2_bbc_armlib_deinit(void)
-+{
-+ jffs2_bbc_unregister_compressor(&jffs2_bbc_armlib);
-+}
-+
-+/*END OF ARMLIB*/
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_framework.c linux-mips/fs/jffs2/jffs2_bbc_framework.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_framework.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_framework.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,1324 @@
-+/*
-+ * JFFS2-BBC: Compression Framework
-+ *
-+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+ *
-+ * Copyright (C) 2004, Ferenc Havasi
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License
-+ * as published by the Free Software Foundation; either version 2
-+ * of the License, or (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+ *
-+ */
-+
-+/* USE JFFS2_BBC_STANDALONE define if you don't want to compile without JFFS2 */
-+
-+//#define DEBUG_COMPRESSORS
-+//#define DEBUG_SHOW_BLOCK_SIZES
-+
-+#define JFFS2_BBC_STAT_BUFF_SIZE 8000
-+
-+#ifndef __KERNEL__
-+
-+#include <stdio.h>
-+#include <malloc.h>
-+typedef unsigned long uint32_t;
-+
-+#else
-+
-+#include <linux/kernel.h>
-+#include <linux/slab.h>
-+#include <linux/vmalloc.h>
-+
-+#endif
-+
-+#define JFFS2_BBC_ZLIB_BLOCK_SIGN_0 (120)
-+#define JFFS2_BBC_ZLIB_BLOCK_SIGN_1 (94)
-+
-+#define JFFS2_BBC_DUMMY_BLOCKSIGN_0 (0x54)
-+#define JFFS2_BBC_DUMMY_BLOCKSIGN_1 (0x01)
-+
-+#ifndef NULL
-+#define NULL ((void*)(0))
-+#endif
-+
-+#include "jffs2_bbc_framework.h"
-+
-+/*********************************************************************
-+ * Global data *
-+ *********************************************************************/
-+
-+static int jffs2_bbc_compression_mode = JFFS2_BBC_ZLIB_MODE;
-+static struct jffs2_bbc_compressor_type *jffs2_bbc_manual_compressor = NULL;
-+static struct jffs2_bbc_compressor_type *jffs2_bbc_compressors = NULL;
-+static struct jffs2_bbc_model_list_node *jffs2_bbc_model_list = NULL;
-+static void *last_sb = NULL; /* previously activated sb */
-+
-+/*********************************************************************
-+ * Compressor initialization *
-+ *********************************************************************/
-+
-+#ifndef JFFS2_BBC_STANDALONE
-+
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_ARMLIB)
-+struct jffs2_bbc_compressor_type *jffs2_bbc_armlib_init(void);
-+void jffs2_bbc_armlib_deinit(void);
-+#endif
-+
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZO)
-+struct jffs2_bbc_compressor_type *jffs2_bbc_lzo_init(void);
-+void jffs2_bbc_lzo_deinit(void);
-+#endif
-+
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZSS)
-+struct jffs2_bbc_compressor_type *jffs2_bbc_lzss_init(void);
-+void jffs2_bbc_lzss_deinit(void);
-+#endif
-+
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZARI)
-+struct jffs2_bbc_compressor_type *jffs2_bbc_lzari_init(void);
-+void jffs2_bbc_lzari_deinit(void);
-+#endif
-+
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZHD)
-+struct jffs2_bbc_compressor_type *jffs2_bbc_lzhd_init(void);
-+void jffs2_bbc_lzhd_deinit(void);
-+#endif
-+
-+void jffs2_bbc_compressor_init()
-+{
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_ARMLIB)
-+ jffs2_bbc_armlib_init();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZO)
-+ jffs2_bbc_lzo_init();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZSS)
-+ jffs2_bbc_lzss_init();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZARI)
-+ jffs2_bbc_lzari_init();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZHD)
-+ jffs2_bbc_lzhd_init();
-+#endif
-+}
-+
-+void jffs2_bbc_compressor_deinit()
-+{
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZHD)
-+ jffs2_bbc_lzhd_deinit();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZARI)
-+ jffs2_bbc_lzari_deinit();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZSS)
-+ jffs2_bbc_lzss_deinit();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_LZO)
-+ jffs2_bbc_lzo_deinit();
-+#endif
-+#if !defined(__KERNEL__) || defined(CONFIG_JFFS2_BBC_ARMLIB)
-+ jffs2_bbc_armlib_deinit();
-+#endif
-+}
-+
-+#endif
-+
-+#ifndef JFFS2_BBC_STANDALONE
-+
-+/*********************************************************************
-+ * ZLIB COMPRESSOR *
-+ *********************************************************************/
-+
-+extern int jffs2_zlib_compress2(unsigned char *data_in, unsigned char *cpage_out, uint32_t * sourcelen, uint32_t * dstlen);
-+extern void jffs2_zlib_decompress2(unsigned char *data_in, unsigned char *cpage_out, uint32_t srclen, uint32_t destlen);
-+
-+static int jffs2_bbc_zlib_compress(void *model, unsigned char *input, unsigned char *output, unsigned long *sourcelen, unsigned long *dstlen)
-+{
-+ return jffs2_zlib_compress2(input, output, sourcelen, dstlen);
-+}
-+
-+static int jffs2_bbc_zlib_decompress(void *model, unsigned char *input, unsigned char *output, unsigned long sourcelen, unsigned long dstlen)
-+{
-+ jffs2_zlib_decompress2(input, output, sourcelen, dstlen);
-+ return 0;
-+}
-+
-+static int jffs2_bbc_zlib_estimate(void *model, unsigned char *input, unsigned long sourcelen, unsigned long *dstlen, unsigned long *readtime, unsigned long *writetime)
-+{
-+ *dstlen = sourcelen * 65 / 100;
-+ *readtime = JFFS2_BBC_ZLIB_READ_TIME;
-+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME;
-+ return 0;
-+}
-+
-+static struct jffs2_bbc_compressor_type jffs2_bbc_zlib = {
-+ "zlib",
-+ 0,
-+ {JFFS2_BBC_ZLIB_BLOCK_SIGN_0, JFFS2_BBC_ZLIB_BLOCK_SIGN_1, 0, 0},
-+ NULL,
-+ NULL,
-+ NULL,
-+ NULL,
-+ jffs2_bbc_zlib_compress,
-+ jffs2_bbc_zlib_estimate,
-+ jffs2_bbc_zlib_decompress,
-+ NULL,
-+ NULL,
-+ 1
-+};
-+
-+static struct jffs2_bbc_compressor_type *jffs2_bbc_original_compressor = &jffs2_bbc_zlib;
-+
-+#endif
-+
-+/*********************************************************************
-+ * Compression mode handling *
-+ *********************************************************************/
-+
-+int jffs2_bbc_get_compression_mode(void)
-+{
-+ return jffs2_bbc_compression_mode;
-+}
-+
-+void jffs2_bbc_set_compression_mode(int mode)
-+{
-+ jffs2_bbc_compression_mode = mode;
-+}
-+
-+void jffs2_bbc_set_manual_compressor(struct jffs2_bbc_compressor_type *c)
-+{
-+ jffs2_bbc_manual_compressor = c;
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_MANUAL_MODE);
-+}
-+
-+int jffs2_bbc_set_manual_compressor_by_name(char *name)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+ int i;
-+
-+ l = jffs2_bbc_compressors;
-+ while (l != NULL) {
-+ for (i = 0; i < 1000; i++) {
-+ if (l->name[i] == 0) {
-+ jffs2_bbc_set_manual_compressor(l);
-+ return 0;
-+ }
-+ else if (name[i] == 0)
-+ i = 1000;
-+ else if (name[i] != l->name[i])
-+ i = 1000;
-+ }
-+ l = l->next;
-+ }
-+ jffs2_bbc_set_manual_compressor(NULL);
-+ return 1;
-+}
-+
-+static struct jffs2_bbc_compressor_type *jffs2_bbc_get_compressor_by_name(char *name)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+ int i;
-+
-+#ifndef JFFS2_BBC_STANDALONE
-+ l = jffs2_bbc_original_compressor;
-+ for (i = 0; i < 1000; i++) {
-+ if (l->name[i] == 0) {
-+ return l;
-+ }
-+ else if (name[i] == 0)
-+ i = 1000;
-+ else if (name[i] != l->name[i])
-+ i = 1000;
-+ }
-+#endif
-+
-+ l = jffs2_bbc_compressors;
-+ while (l != NULL) {
-+ for (i = 0; i < 1000; i++) {
-+ if (l->name[i] == 0) {
-+ return l;
-+ }
-+ else if (name[i] == 0)
-+ i = 1000;
-+ else if (name[i] != l->name[i])
-+ i = 1000;
-+ }
-+ l = l->next;
-+ }
-+
-+ return NULL;
-+}
-+
-+int jffs2_bbc_disable_compressor_by_name(char *name)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+
-+ l = jffs2_bbc_get_compressor_by_name(name);
-+ if (l == NULL) return 1;
-+ l->enabled = 0;
-+ return 0;
-+}
-+
-+int jffs2_bbc_enable_compressor_by_name(char *name)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+
-+ l = jffs2_bbc_get_compressor_by_name(name);
-+ if (l == NULL) return 1;
-+ l->enabled = 1;
-+ return 0;
-+}
-+
-+void jffs2_bbc_compressor_command_by_name(char *name_and_command)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+ int i;
-+
-+ l = jffs2_bbc_compressors;
-+ while (l != NULL) {
-+ for (i = 0; i < 1000; i++) {
-+ if (l->name[i] == 0) {
-+ if (name_and_command[i] != ':') {
-+ jffs2_bbc_print1("jffs2.bbc: ':' missing after compressor name\n");
-+ }
-+ else {
-+ if (l->proc_command != NULL)
-+ l->proc_command(name_and_command + i + 1);
-+ }
-+ i = 1000;
-+ return;
-+ }
-+ else if (name_and_command[i] == 0) {
-+ i = 1000;
-+ }
-+ else if (name_and_command[i] != l->name[i]) {
-+ i = 1000;
-+ }
-+ }
-+ l = l->next;
-+ }
-+}
-+
-+struct jffs2_bbc_compressor_type *jffs2_bbc_get_manual_compressor(void)
-+{
-+ if (jffs2_bbc_get_compression_mode() != JFFS2_BBC_MANUAL_MODE) {
-+ jffs2_bbc_manual_compressor = NULL;
-+ }
-+ return jffs2_bbc_manual_compressor;
-+}
-+
-+/*********************************************************************
-+ * Compressor handling *
-+ *********************************************************************/
-+
-+struct jffs2_bbc_compressor_type *jffs2_bbc_get_compressor_list(void)
-+{
-+ return jffs2_bbc_compressors;
-+}
-+
-+struct jffs2_bbc_model_list_node *jffs2_bbc_get_model_list(void)
-+{
-+ return jffs2_bbc_model_list;
-+}
-+
-+int jffs2_bbc_register_compressor(struct jffs2_bbc_compressor_type *c)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+ struct jffs2_bbc_model_list_node *l2;
-+ int model_found = 0;
-+
-+ l = jffs2_bbc_compressors;
-+ /* Check for confilcts */
-+ while (l != NULL) {
-+ c->name[15] = 0;
-+ /*if (strcmp(c->name,l->name)==0) {
-+ jffs2_bbc_print1("jffs2.bbc: compressor is already loaded.");
-+ return -1;
-+ } */
-+ if ((l->model_file_sign == c->model_file_sign) && (c->model_file_sign != 0)) {
-+ jffs2_bbc_print1("jffs2.bbc: already used model file sign. fail.");
-+ return -1;
-+ }
-+ l = l->next;
-+ }
-+ /* Search and initialize model */
-+ c->models = NULL;
-+ c->mounted = 0;
-+ if (c->init != NULL) {
-+ if (c->init() != 0) {
-+ jffs2_bbc_print2("jffs2.bbc: cannot initialize compressor %s.\n", c->name);
-+ return -1;
-+ }
-+ }
-+ if (c->model_file_sign != 0) {
-+ l2 = jffs2_bbc_model_list;
-+ while (1) {
-+ if (l2 == NULL)
-+ break;
-+ if (c->model_file_sign == l2->sign) {
-+ if (l2->compressor != NULL) {
-+ jffs2_bbc_print2("jffs2.bbc: register for %s: BUG, model file already reserved!!!!\n", c->name);
-+ }
-+ else {
-+ if (c->init_model(&(l2->model)) != 0) {
-+ jffs2_bbc_print2("jffs2.bbc: cannot initialize compressor %s for a model", c->name);
-+ }
-+ else {
-+ l2->compressor = c;
-+ l2->next_compr_model = c->models;
-+ c->models = l2;
-+ c->mounted++;
-+ model_found++;
-+ }
-+ }
-+ }
-+ l2 = l2->next_model;
-+ }
-+ /*if (model_found==0) {
-+ jffs2_bbc_print2("jffs2.bbc: no macthing model file found for %s at this time (maybe later)\n",c->name);
-+ } */
-+ }
-+ /* Insert to the end of the compressor list */
-+ c->enabled = 1;
-+ c->buffer = NULL;
-+ c->buffer_size = 0;
-+ c->stat_compr_orig = c->stat_compr_new = c->stat_decompr = 0;
-+ c->next = NULL;
-+ if (jffs2_bbc_compressors == NULL) {
-+ jffs2_bbc_compressors = c;
-+ }
-+ else {
-+ l = jffs2_bbc_compressors;
-+ while (l->next != NULL)
-+ l = l->next;
-+ l->next = c;
-+ }
-+ return 0;
-+}
-+
-+int jffs2_bbc_unregister_compressor(struct jffs2_bbc_compressor_type *c)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+ struct jffs2_bbc_model_list_node *l2;
-+
-+ if (c->mounted != 0) {
-+ jffs2_bbc_print1("jffs2.bbc: Compressor is in use. Sorry.");
-+ return -1;
-+ }
-+ if (jffs2_bbc_compressors == NULL) {
-+ jffs2_bbc_print1("jffs2.bbc: unregister: empty list.");
-+ return -1;
-+ }
-+ else if (jffs2_bbc_compressors == c) {
-+ if (c->deinit != NULL)
-+ c->deinit();
-+ jffs2_bbc_compressors = c->next;
-+ }
-+ else {
-+ l = jffs2_bbc_compressors;
-+ while (l->next != c) {
-+ if (l->next == NULL) {
-+ jffs2_bbc_print2("jffs2.bbc: unregister: cannot find compressor %s in the list.", c->name);
-+ return -1;
-+ }
-+ l = l->next;
-+ }
-+ if (c->deinit != NULL)
-+ c->deinit();
-+ l->next = c->next;
-+ }
-+ if (c->buffer != NULL) {
-+ jffs2_bbc_free(c->buffer);
-+ c->buffer = NULL;
-+ c->buffer_size = 0;
-+ }
-+
-+ l2 = jffs2_bbc_model_list;
-+ while (l2 != NULL) {
-+ if (l2->compressor == c) {
-+ jffs2_bbc_print1("jffs2.bbc: unregister: BUG: model found!!!");
-+ l2->compressor = NULL;
-+ l2->next_compr_model = NULL;
-+ }
-+ l2 = l2->next_model;
-+ }
-+
-+ return 0;
-+}
-+
-+int jffs2_bbc_model_new(void *sb, int i_num, void *model)
-+{
-+ struct jffs2_bbc_model_list_node *node;
-+ struct jffs2_bbc_compressor_type *l;
-+ char block_sign[2];
-+
-+ int sign;
-+
-+ /* check for conflicts... */
-+ sign = *((int *) model);
-+ block_sign[0] = *(((char *) model) + 4);
-+ block_sign[1] = *(((char *) model) + 5);
-+ node = jffs2_bbc_model_list;
-+ while (node != NULL) {
-+ if ((node->block_sign[0] == block_sign[0]) && (node->block_sign[1] == block_sign[1]) && (node->sb == sb)) {
-+ //jffs2_bbc_print2("jffs2.bbc: model_new: model conflict (inode=%d)!\n",i_num);
-+ return -1;
-+ }
-+ node = node->next_model;
-+ }
-+
-+ /* insertion */
-+ node = jffs2_bbc_malloc_small((long)sizeof(struct jffs2_bbc_model_list_node));
-+ node->sb = sb;
-+ node->model = model;
-+ node->sign = *((int *) model);
-+ node->block_sign[0] = *(((char *) model) + 4);
-+ node->block_sign[1] = *(((char *) model) + 5);
-+ node->inode = i_num;
-+ node->next_model = jffs2_bbc_model_list;
-+ node->compressor = NULL;
-+ node->stat_decompr = 0;
-+ node->next_compr_model = NULL;
-+ jffs2_bbc_model_list = node;
-+
-+ /* search for matching compressor */
-+ l = jffs2_bbc_compressors;
-+ while (l != NULL) {
-+ if (l->model_file_sign == sign) {
-+ //jffs2_bbc_print2("jffs2.bbc: compressor for model found: %s ",l->name);
-+ if (l->init_model(&(node->model)) != 0) {
-+ jffs2_bbc_print1("jffs2.bbc: cannot initialize compressor for a model");
-+ }
-+ else {
-+ l->mounted++;
-+ node->compressor = l;
-+ node->next_compr_model = l->models;
-+ l->models = node;
-+ }
-+ break;
-+ }
-+ l = l->next;
-+ }
-+ return 0;
-+}
-+
-+static void jffs2_bbc_model_del_from_compressor(struct jffs2_bbc_model_list_node *node)
-+{
-+ struct jffs2_bbc_model_list_node *l;
-+
-+ if (node->model != NULL) {
-+ if (node->compressor != NULL) {
-+ if (node->compressor->destroy_model == NULL) {
-+ jffs2_bbc_free(node->model);
-+ node->model = NULL;
-+ }
-+ else {
-+ node->compressor->destroy_model(&(node->model));
-+ if (node->model != NULL)
-+ jffs2_bbc_print1("jffs2.bbc: warning: not NULL model after destroying!\n");
-+ }
-+ }
-+ }
-+
-+ if (node->compressor == NULL) {
-+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_del_from_compressor: no compressor!\n");
-+ return;
-+ }
-+ l = node->compressor->models;
-+ if (l == NULL) {
-+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_del_from_compressor error, models=NULL!\n");
-+ return;
-+ }
-+ if (l == node) {
-+ node->compressor->models = node->next_compr_model;
-+ node->compressor->mounted--;
-+ return;
-+ }
-+ while (1) {
-+ if (l->next_compr_model == node) {
-+ l->next_compr_model = node->next_compr_model;
-+ node->compressor->mounted--;
-+ return;
-+ }
-+ l = l->next_compr_model;
-+ if (l == NULL) {
-+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_del_from_compressor: not found\n");
-+ return;
-+ }
-+ }
-+}
-+
-+void jffs2_bbc_model_del(void *sb)
-+{
-+ struct jffs2_bbc_model_list_node *l, *l2;
-+
-+ l = jffs2_bbc_model_list;
-+ if (l == NULL)
-+ return;
-+ if (l->sb == sb) {
-+ jffs2_bbc_model_list = l->next_model;
-+ jffs2_bbc_model_del_from_compressor(l);
-+ jffs2_bbc_free_small(l);
-+ jffs2_bbc_model_del(sb);
-+ return;
-+ }
-+ while (1) {
-+ if (l->next_model == NULL) {
-+ break;
-+ }
-+ if (l->next_model->sb == sb) {
-+ l2 = l->next_model;
-+ l->next_model = l->next_model->next_model;
-+ jffs2_bbc_model_del_from_compressor(l2);
-+ jffs2_bbc_free_small(l2);
-+ jffs2_bbc_model_del(sb);
-+ return;
-+ }
-+ l = l->next_model;
-+ }
-+ last_sb = NULL;
-+}
-+
-+void jffs2_bbc_model_set_act_sb(void *sb)
-+{
-+ last_sb = sb;
-+}
-+
-+void *jffs2_bbc_model_get_act_sb(void)
-+{
-+ return last_sb;
-+}
-+
-+void *jffs2_bbc_model_get_newest(struct jffs2_bbc_compressor_type *compressor)
-+{
-+ struct jffs2_bbc_model_list_node *m, *best_m;
-+ int max_sign, sign;
-+
-+ if (compressor == NULL) {
-+ jffs2_bbc_print1("jffs2.bbc: jffs2_bbc_model_get: NULL!!\n");
-+ return NULL;
-+ }
-+
-+ best_m = NULL;
-+ max_sign = -1;
-+ m = compressor->models;
-+ while (m != NULL) {
-+ if (m->sb == last_sb) {
-+ sign = (int) (m->block_sign[0]) * 256 + (int) (m->block_sign[1]);
-+ if (sign > max_sign) {
-+ max_sign = sign;
-+ best_m = m;
-+ }
-+ }
-+ m = m->next_compr_model;
-+ }
-+ if (best_m != NULL)
-+ return best_m->model;
-+ else
-+ return NULL;
-+}
-+
-+/*********************************************************************
-+ * Statistics *
-+ *********************************************************************/
-+
-+static char *jffs2_bbc_stat_buff = NULL;
-+
-+char *jffs2_bbc_get_model_stats(void)
-+{
-+ char *b;
-+ struct jffs2_bbc_model_list_node *m;
-+ struct jffs2_bbc_compressor_type *c;
-+
-+ if (jffs2_bbc_stat_buff == NULL)
-+ jffs2_bbc_stat_buff = jffs2_bbc_malloc(8000);
-+
-+ b = jffs2_bbc_stat_buff;
-+
-+ b += sprintf(b, "Loaded compressors:");
-+ c = jffs2_bbc_compressors;
-+ while (c != NULL) {
-+ b += sprintf(b, "\n %s (%d) ", c->name, c->enabled);
-+ if (c->model_file_sign != 0) {
-+ b += sprintf(b, "m_sign=%d ", c->model_file_sign);
-+ b += sprintf(b, "models=");
-+ m = c->models;
-+ while (m != NULL) {
-+ b += sprintf(b, "(inode=%d)", m->inode);
-+ m = m->next_compr_model;
-+ }
-+ }
-+ else {
-+ b += sprintf(b, "b_sign=(%d,%d) nomodel", (int) (c->block_sign[0]), (int) (c->block_sign[1]));
-+ }
-+ if (c->proc_info != NULL) {
-+ b += sprintf(b, "\n %s", c->proc_info());
-+ }
-+ c = c->next;
-+ }
-+
-+ m = jffs2_bbc_model_list;
-+
-+ if (m == NULL) {
-+ b += sprintf(b, "\nPresent models: NONE\n");
-+ }
-+ else {
-+ b += sprintf(b, "\nPresent models:\n");
-+ while (m != NULL) {
-+ 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);
-+ if (m->compressor == NULL)
-+ b += sprintf(b, ",compressor=NULL\n");
-+ else
-+ b += sprintf(b, ",compressor=%s\n", m->compressor->name);
-+ m = m->next_model;
-+ }
-+ }
-+
-+ return jffs2_bbc_stat_buff;
-+}
-+
-+/*********************************************************************
-+ * Memory handling, debug *
-+ *********************************************************************/
-+
-+static int jffs2_bbc_mem_counter = 0;
-+
-+#ifdef __KERNEL__
-+
-+void *jffs2_bbc_malloc(long size)
-+{
-+ void *addr = vmalloc(size);
-+ if (addr != NULL)
-+ jffs2_bbc_mem_counter++;
-+ else {
-+ jffs2_bbc_print2("DEBUG: not enough memory (%ld)\n", size);
-+ }
-+ return addr;
-+}
-+
-+void jffs2_bbc_free(void *addr)
-+{
-+ jffs2_bbc_mem_counter--;
-+ vfree(addr);
-+}
-+
-+void *jffs2_bbc_malloc_small(long size)
-+{
-+ void *addr;
-+ addr = kmalloc(size, 0);
-+ if (addr != NULL)
-+ jffs2_bbc_mem_counter++;
-+ return addr;
-+}
-+
-+void jffs2_bbc_free_small(void *addr)
-+{
-+ jffs2_bbc_mem_counter--;
-+ kfree(addr);
-+}
-+
-+#else
-+
-+void *jffs2_bbc_malloc(long size)
-+{
-+ void *addr = malloc(size);
-+ if (addr != NULL)
-+ jffs2_bbc_mem_counter++;
-+ return addr;
-+}
-+
-+void jffs2_bbc_free(void *addr)
-+{
-+ jffs2_bbc_mem_counter--;
-+ free(addr);
-+}
-+
-+void *jffs2_bbc_malloc_small(long size)
-+{
-+ return jffs2_bbc_malloc(size);
-+}
-+
-+void jffs2_bbc_free_small(void *addr)
-+{
-+ jffs2_bbc_free(addr);
-+}
-+
-+#endif
-+
-+int jffs2_bbc_test_memory_counter(int verbose)
-+{
-+ if (verbose > 0) {
-+ jffs2_bbc_print2("jffs2.bbc: mem_counter=%d!\n", jffs2_bbc_mem_counter);
-+ }
-+ return jffs2_bbc_mem_counter;
-+}
-+
-+int jffs2_bbc_get_memory_counter(void)
-+{
-+ return jffs2_bbc_mem_counter;
-+}
-+
-+static char mem_stat[200];
-+
-+char *jffs2_bbc_get_mem_stats(void)
-+{
-+ sprintf(mem_stat, "Memcounter=%d\n", jffs2_bbc_mem_counter);
-+ return mem_stat;
-+}
-+
-+void jffs2_bbc_print_flush(void)
-+{
-+#ifdef __KERNEL__
-+ return;
-+#else
-+ fflush(stdout);
-+ fflush(stderr);
-+#endif
-+}
-+
-+/*********************************************************************
-+ * FRAMEWORK - ZLIB REPLACEMENT *
-+ *********************************************************************/
-+
-+#ifndef JFFS2_BBC_STANDALONE
-+
-+/* Temorary buffers */
-+static char stat_str[JFFS2_BBC_STAT_BUFF_SIZE];
-+static int tmp_buffer_size = 0;
-+static char *tmp_buffer = NULL;
-+
-+/* Statistic - used by /proc/jffs2_bbc and mkfs.jffs2 */
-+char *jffs2_bbc_get_compr_stats(void)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+ char *s = stat_str;
-+
-+ s += sprintf(s, "Compression statistics:\n");
-+ l = jffs2_bbc_original_compressor;
-+ //s += sprintf(s, " zlib: compr=%d/%d decompr=%d\n", stat_zlib_compr_new, stat_zlib_compr_orig, stat_zlib_decompr);
-+ s += sprintf(s, " %s: compr=%d/%d decompr=%d\n", l->name, l->stat_compr_new, l->stat_compr_orig, l->stat_decompr);
-+ l = jffs2_bbc_get_compressor_list();
-+ while (l != NULL) {
-+ s += sprintf(s, " %s: compr=%d/%d decompr=%d\n", l->name, l->stat_compr_new, l->stat_compr_orig, l->stat_decompr);
-+ l = l->next;
-+ }
-+ return stat_str;
-+}
-+
-+static void jffs2_bbc_buffer_fill(unsigned char *buff, int size)
-+{
-+ for (; size > 0; size--, buff++)
-+ *buff = 255;
-+}
-+
-+
-+static int jffs2_bbc_update_compr_buf(unsigned long size)
-+{
-+ struct jffs2_bbc_compressor_type *l;
-+
-+ if (size < 5000)
-+ size = 5000;
-+ if (tmp_buffer == NULL) {
-+ tmp_buffer = jffs2_bbc_malloc(size);
-+ jffs2_bbc_buffer_fill(tmp_buffer, size);
-+ tmp_buffer_size = size;
-+ }
-+ else if (tmp_buffer_size < size) {
-+ jffs2_bbc_free(tmp_buffer);
-+ tmp_buffer = jffs2_bbc_malloc(size);
-+ jffs2_bbc_buffer_fill(tmp_buffer, size);
-+ tmp_buffer_size = size;
-+ }
-+ l = jffs2_bbc_get_compressor_list();
-+ while (l != NULL) {
-+ if (l->buffer == NULL) {
-+ l->buffer_size = size;
-+ l->buffer = jffs2_bbc_malloc(size);
-+ jffs2_bbc_buffer_fill(l->buffer, size);
-+ }
-+ else if (l->buffer_size < size) {
-+ jffs2_bbc_free(l->buffer);
-+ l->buffer_size = size;
-+ l->buffer = jffs2_bbc_malloc(size);
-+ jffs2_bbc_buffer_fill(l->buffer, size);
-+ }
-+ l = l->next;
-+ }
-+ return 0;
-+}
-+
-+#ifdef DEBUG_COMPRESSORS
-+
-+static unsigned char *debug_tmp_buff = NULL;
-+static long debug_orig_srclen = -1;
-+static long debug_orig_dstlen = -1;
-+static int debug_mem_counter = -1;
-+
-+
-+void debug_before_compress(struct jffs2_bbc_compressor_type *c, void *model, unsigned char *input, unsigned char *output, long *sourcelen, long *dstlen)
-+{
-+
-+ debug_orig_srclen = *sourcelen; // for buffer overflow test
-+ debug_orig_dstlen = *dstlen; // for buffer overflow test
-+ output[debug_orig_dstlen + 1] = 255;
-+
-+ debug_mem_counter = jffs2_bbc_get_memory_counter(); // for memory guard
-+}
-+
-+void debug_after_compress(struct jffs2_bbc_compressor_type *c, int back, void *model, unsigned char *input, unsigned char *output, long *sourcelen, long *dstlen)
-+{
-+ long dst_len = *dstlen;
-+ long src_len = *sourcelen;
-+ int i;
-+
-+ // Memory guard
-+ if (debug_mem_counter != jffs2_bbc_get_memory_counter()) {
-+ jffs2_bbc_print4("!!!!!!!! %s error: possible COMPRESSOR MEMORY LEAK: %d->%d\n", c->name, debug_mem_counter, jffs2_bbc_get_memory_counter());
-+ debug_mem_counter = jffs2_bbc_get_memory_counter();
-+ }
-+
-+ // Buffer overflow test
-+ if (output[debug_orig_dstlen + 1] != 255) {
-+ 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);
-+ }
-+
-+ // Decompression check
-+ if (back == 0) {
-+ if (debug_tmp_buff == NULL)
-+ debug_tmp_buff = jffs2_bbc_malloc(17000);
-+ for (i = 0; i < src_len; i++) debug_tmp_buff[i] = 0xf6;
-+ c->decompress(model, output, debug_tmp_buff, dst_len, src_len);
-+ // Memory guard for decompressor
-+ if (debug_mem_counter != jffs2_bbc_get_memory_counter()) {
-+ jffs2_bbc_print4("!!!!!!!! %s error: possible DECOMPRESSOR MEMORY LEAK: %d->%d\n", c->name, debug_mem_counter, jffs2_bbc_get_memory_counter());
-+ debug_mem_counter = jffs2_bbc_get_memory_counter();
-+ }
-+
-+ for (i = 0; i < src_len; i++)
-+ if (input[i] != debug_tmp_buff[i]) {
-+ 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);
-+ break;
-+ }
-+ return;
-+ }
-+
-+ // Return value test
-+ //jffs2_bbc_print3("!!!!!!!! %s error: %d !!!!!!!!!!!!\n", c->name, back);
-+}
-+
-+#endif
-+
-+int jffs2_zlib_compress(unsigned char *data_in, unsigned char *cpage_out, uint32_t * sourcelen, uint32_t * dstlen)
-+{
-+ struct jffs2_bbc_compressor_type *c;
-+ int back, back_zlib, mode, min, i, i2;
-+ long tmp = 0, tmp_read_time = 1000, tmp_write_time = 1000, orig_src, orig_dest, src, dest;
-+ struct jffs2_bbc_model_list_node *m;
-+ void *sb;
-+ unsigned char *tmp_p = NULL;
-+
-+ sb = jffs2_bbc_model_get_act_sb();
-+
-+ orig_src = *sourcelen;
-+ orig_dest = *dstlen;
-+
-+ mode = jffs2_bbc_get_compression_mode();
-+
-+ if (mode == JFFS2_BBC_DUMMY_MODE) {
-+ i=0; i2=0;
-+ if (*dstlen>2) {
-+ cpage_out[i++]=JFFS2_BBC_DUMMY_BLOCKSIGN_0;
-+ cpage_out[i++]=JFFS2_BBC_DUMMY_BLOCKSIGN_1;
-+ i2=i;
-+ }
-+ for (;((i < *dstlen) && (i < (*sourcelen)+i2));i++) {
-+ cpage_out[i] = data_in[i-i2];
-+ }
-+ *sourcelen=i-i2;
-+ *dstlen=i;
-+ return 0;
-+ }
-+
-+ if (mode == JFFS2_BBC_ZLIB_MODE) {
-+ /*if (!jffs2_bbc_original_compressor->enabled) {
-+ jffs2_bbc_print2("jffs2.bbc: WARNING: ZLIB mode but %s disabled! Enabling for this procedure...\n",jffs2_bbc_original_compressor->name);
-+ }*/
-+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
-+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
-+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
-+ return back;
-+ }
-+
-+ jffs2_bbc_update_compr_buf(orig_dest);
-+
-+ if (mode == JFFS2_BBC_SIZE_MODE) {
-+ // Testing all compressors
-+ if (!jffs2_bbc_original_compressor->enabled) {
-+ min = -1;
-+ }
-+ else {
-+ back_zlib = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
-+ min = *dstlen;
-+ }
-+ c = jffs2_bbc_get_compressor_list();
-+ while (c != NULL) {
-+ c->buffer_cnt = -1;
-+ if (c->enabled == 0) {
-+ c = c->next;
-+ continue;
-+ }
-+ if (c->model_file_sign == 0) {
-+ src = orig_src;
-+ dest = orig_dest;
-+#ifdef DEBUG_COMPRESSORS
-+ debug_before_compress(c, NULL, data_in, c->buffer, &src, &dest);
-+#endif
-+ back = c->compress(NULL, data_in, c->buffer, &src, &dest);
-+#ifdef DEBUG_COMPRESSORS
-+ debug_after_compress(c, back, NULL, data_in, c->buffer, &src, &dest);
-+#endif
-+ if (back == 0) {
-+ c->buffer_cnt = dest;
-+ if ((min < 0) || (min > dest))
-+ min = dest;
-+ }
-+ }
-+ else {
-+ m = c->models;
-+ while (m != NULL) {
-+ src = orig_src;
-+ dest = orig_dest;
-+ if (m->sb == sb) {
-+ if (c->buffer_cnt == -1) {
-+#ifdef DEBUG_COMPRESSORS
-+ debug_before_compress(c, m->model, data_in, c->buffer, (long *) (&src), (long *) (&dest));
-+#endif
-+ back = c->compress(m->model, data_in, c->buffer, (long *) (&src), (long *) (&dest));
-+#ifdef DEBUG_COMPRESSORS
-+ debug_after_compress(c, back, m->model, data_in, c->buffer, (long *) (&src), (long *) (&dest));
-+#endif
-+ if (back == 0) {
-+ c->buffer_cnt = dest;
-+ if ((min < 0) || (min > dest))
-+ min = dest;
-+ }
-+ }
-+ else {
-+#ifdef DEBUG_COMPRESSORS
-+ debug_before_compress(c, m->model, data_in, tmp_buffer, &src, &dest);
-+#endif
-+ back = c->compress(m->model, data_in, tmp_buffer, &src, &dest);
-+#ifdef DEBUG_COMPRESSORS
-+ debug_after_compress(c, back, m->model, data_in, tmp_buffer, &src, &dest);
-+#endif
-+ if (back == 0) {
-+ if (c->buffer_cnt > dest) {
-+ c->buffer_cnt = dest;
-+ tmp_p = c->buffer;
-+ c->buffer = tmp_buffer;
-+ tmp_buffer = tmp_p;
-+ if ((min < 0) || (min > dest))
-+ min = dest;
-+ }
-+ }
-+ }
-+ }
-+ m = m->next_compr_model;
-+ }
-+ }
-+ c = c->next;
-+ }
-+ //Finding the best and copy its result
-+
-+#ifdef DEBUG_SHOW_BLOCK_SIZES
-+ jffs2_bbc_print1("\n");
-+ if (jffs2_bbc_original_compressor->enabled) {
-+ if (min == *dstlen) {
-+ jffs2_bbc_print3("%s:%d* ", jffs2_bbc_original_compressor->name, (int) (*dstlen));
-+ }
-+ else {
-+ jffs2_bbc_print3("%s:%d ", jffs2_bbc_original_compressor->name, (int) (*dstlen));
-+ }
-+ }
-+ c = jffs2_bbc_get_compressor_list();
-+ while (c != NULL) {
-+ if (c->enabled == 0) {
-+ c = c->next;
-+ continue;
-+ }
-+ if (c->buffer_cnt == min)
-+ jffs2_bbc_print3("%s:%d* ", c->name, c->buffer_cnt);
-+ else
-+ jffs2_bbc_print3("%s:%d ", c->name, c->buffer_cnt);
-+ c = c->next;
-+ }
-+#endif
-+
-+ if (min == -1) {
-+ return -1; // none of compressors work (maybe too short output buffer)
-+ }
-+
-+ if (jffs2_bbc_original_compressor->enabled) {
-+ if (min == *dstlen) {
-+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
-+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
-+ return back_zlib;
-+ }
-+ }
-+
-+ c = jffs2_bbc_get_compressor_list();
-+ while (c != NULL) {
-+ if (c->enabled == 0) {
-+ c = c->next;
-+ continue;
-+ }
-+ if (c->buffer_cnt == min) {
-+ *dstlen = c->buffer_cnt;
-+ *sourcelen = orig_src;
-+ for (i = 0; i < *dstlen; i++) {
-+ cpage_out[i] = c->buffer[i];
-+ }
-+ c->stat_compr_orig += *sourcelen;
-+ c->stat_compr_new += *dstlen;
-+ return 0;
-+ }
-+ c = c->next;
-+ }
-+ jffs2_bbc_print1("jffs2.bbc: compr (full): BUG!!!\n");
-+ return 0;
-+ }
-+
-+ if ((mode == JFFS2_BBC_FASTR_MODE)||(mode == JFFS2_BBC_FASTW_MODE)||(mode == JFFS2_BBC_FASTS_MODE)) {
-+ // Estimating all compressors
-+ if (jffs2_bbc_original_compressor->enabled) {
-+ back = jffs2_bbc_original_compressor->estimate(NULL, data_in, *sourcelen, &tmp, &tmp_read_time, &tmp_write_time);
-+ }
-+ else {
-+ tmp = -1;
-+ tmp_read_time = -1;
-+ tmp_write_time = -1;
-+ }
-+ if (mode == JFFS2_BBC_FASTR_MODE) tmp = tmp_read_time;
-+ if (mode == JFFS2_BBC_FASTW_MODE) tmp = tmp_write_time;
-+ min = tmp;
-+ c = jffs2_bbc_get_compressor_list();
-+ while (c != NULL) {
-+ src = orig_src;
-+ dest = orig_dest;
-+ c->buffer_cnt = -1;
-+ if (c->enabled == 0) {
-+ c = c->next;
-+ continue;
-+ }
-+ if ((c->model_file_sign == 0) || (jffs2_bbc_model_get_newest(c) != NULL)) {
-+ back = c->estimate(jffs2_bbc_model_get_newest(c), data_in, src, &dest, &tmp_read_time, &tmp_write_time);
-+ if (mode == JFFS2_BBC_FASTR_MODE) dest = tmp_read_time;
-+ if (mode == JFFS2_BBC_FASTW_MODE) dest = tmp_write_time;
-+ if (back == 0) {
-+ c->buffer_cnt = dest;
-+ if ((min < 0) || (min > dest))
-+ min = dest;
-+ }
-+ else {
-+ c->buffer_cnt = -1;
-+ }
-+ }
-+ c = c->next;
-+ }
-+ // Finding the best and compress with it
-+ if (min == -1) {
-+ return -1;
-+ }
-+ if (jffs2_bbc_original_compressor->enabled) {
-+ if (min == tmp) {
-+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
-+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
-+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
-+ return back;
-+ }
-+ }
-+ c = jffs2_bbc_get_compressor_list();
-+ while (c != NULL) {
-+ if (c->enabled == 0) {
-+ c = c->next;
-+ continue;
-+ }
-+ if (c->buffer_cnt == min) {
-+ back = c->compress(jffs2_bbc_model_get_newest(c), data_in, cpage_out, (unsigned long*)sourcelen, (unsigned long*)dstlen);
-+ if ((back == 0) && (*dstlen < orig_dest) && (*dstlen > 4)) {
-+ c->stat_compr_orig += *sourcelen;
-+ c->stat_compr_new += *dstlen;
-+ }
-+ else { // fallback will always be available
-+ *sourcelen = orig_src;
-+ *dstlen = orig_dest;
-+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
-+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
-+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
-+ return back;
-+ }
-+ return 0;
-+ }
-+ c = c->next;
-+ }
-+ jffs2_bbc_print1("jffs2.bbc: compress (fastX mode): BUG!!!\n");
-+ return 0;
-+ }
-+
-+ if (mode == JFFS2_BBC_MANUAL_MODE) {
-+ c = jffs2_bbc_get_manual_compressor();
-+ if (c != NULL) {
-+ if (c->model_file_sign == 0) {
-+ src = orig_src;
-+ dest = orig_dest;
-+ back = c->compress(NULL, data_in, cpage_out, &src, &dest);
-+ if (back == 0) {
-+ *dstlen = dest;
-+ *sourcelen = src;
-+ c->stat_compr_orig += *sourcelen;
-+ c->stat_compr_new += *dstlen;
-+ return 0;
-+ }
-+ }
-+ else {
-+ c->buffer_cnt = -1;
-+ m = c->models;
-+ min = -1;
-+ while (m != NULL) {
-+ src = orig_src;
-+ dest = orig_dest;
-+ if (m->sb == sb) {
-+ if (min == -1) {
-+ back = c->compress(m->model, data_in, cpage_out, (unsigned long*)sourcelen, (unsigned long*)dstlen);
-+ if ((back == 0) && (*dstlen < orig_dest) && (*dstlen > 4)) {
-+ min = dest;
-+ tmp_p = cpage_out;
-+ }
-+ }
-+ else {
-+ back = c->compress(m->model, data_in, tmp_buffer, &src, &dest);
-+ if ((back == 0) && (dest < orig_dest) && (dest > 4)) {
-+ if (c->buffer_cnt > dest) {
-+ if (min > dest) {
-+ min = dest;
-+ tmp_p = tmp_buffer;
-+ }
-+ }
-+ }
-+ }
-+ }
-+ m = m->next_compr_model;
-+ }
-+ if (min != -1) {
-+ if (tmp_p != cpage_out) {
-+ for (i = 0; i < min; i++)
-+ cpage_out[i] = tmp_p[i];
-+ *sourcelen = orig_src;
-+ *dstlen = min;
-+ }
-+ c->stat_compr_orig += *sourcelen;
-+ c->stat_compr_new += *dstlen;
-+ return 0;
-+ }
-+ }
-+ }
-+ /*else {
-+ jffs2_bbc_print1("iPack: manual mode without selected compressor!\n");
-+ } */
-+
-+ /*if (!jffs2_bbc_original_compressor->enabled) {
-+ jffs2_bbc_print2("jffs2.bbc: WARNING: %s must be enabled! Enabling for this procedure...\n",jffs2_bbc_original_compressor->name);
-+ }*/
-+ back = jffs2_bbc_original_compressor->compress(NULL, data_in, cpage_out, sourcelen, dstlen);
-+ jffs2_bbc_original_compressor->stat_compr_orig += *sourcelen;
-+ jffs2_bbc_original_compressor->stat_compr_new += *dstlen;
-+ return back;
-+
-+
-+ }
-+
-+ jffs2_bbc_print1("jffs2.bbc: compress: unimlemented compress mode!!!\n");
-+ return 0;
-+}
-+
-+void jffs2_zlib_decompress(unsigned char *data_in, unsigned char *cpage_out, uint32_t srclen, uint32_t destlen)
-+{
-+ struct jffs2_bbc_model_list_node *m;
-+ struct jffs2_bbc_compressor_type *c;
-+ char d[2];
-+ void *sb;
-+ int i;
-+
-+ /* If the input too small... */
-+ if (destlen<=2) {
-+ cpage_out[0]=data_in[0];
-+ if (destlen==2) cpage_out[1]=data_in[1];
-+ return;
-+ }
-+
-+ sb = jffs2_bbc_model_get_act_sb();
-+ d[0] = *(data_in);
-+ d[1] = *(data_in + 1);
-+
-+ d[0] &= 0x7f; // Variants support...
-+
-+ /* Search for model based decompressors... */
-+ m = jffs2_bbc_get_model_list();
-+ while (m != NULL) {
-+ if ((d[0] == m->block_sign[0]) && (d[1] == m->block_sign[1]) && (sb == m->sb)) {
-+ if (m->compressor == NULL) {
-+ jffs2_bbc_print3("jffs2.bbc: decompressor for block_sign (%d,%d) not loaded!\n", (int) (d[0]), (int) (d[1]));
-+ }
-+ else {
-+ m->compressor->decompress(m->model, data_in, cpage_out, srclen, destlen);
-+ m->compressor->stat_decompr++;
-+ m->stat_decompr++;
-+ }
-+ return;
-+ }
-+ m = m->next_model;
-+ }
-+ /* Is it ZLIB? */
-+ if ((((int) d[0]) == (int)(jffs2_bbc_original_compressor->block_sign[0])) && (((int) d[1]) == (int)(jffs2_bbc_original_compressor->block_sign[1]))) {
-+ jffs2_bbc_original_compressor->decompress(NULL, data_in, cpage_out, srclen, destlen);
-+ jffs2_bbc_original_compressor->stat_decompr++;
-+ return;
-+ }
-+ /* Search for non model based decompressors... */
-+ c = jffs2_bbc_get_compressor_list();
-+ while (c != NULL) {
-+ if (c->model_file_sign == 0) {
-+ if (((int) (d[0]) == (int) (c->block_sign[0])) && ((int) (d[1]) == (int) (c->block_sign[1]))) {
-+ c->decompress(NULL, data_in, cpage_out, srclen, destlen);
-+ c->stat_decompr++;
-+ return;
-+ }
-+ }
-+ c = c->next;
-+ }
-+ /* Is it DUMMY? */
-+ if ((((int) d[0]) == JFFS2_BBC_DUMMY_BLOCKSIGN_0) && (((int) d[1]) == JFFS2_BBC_DUMMY_BLOCKSIGN_1)) {
-+ for (i=0;i<destlen;i++) {
-+ cpage_out[i]=data_in[i+2];
-+ }
-+ return;
-+ }
-+ /* No matching decompressor found... */
-+ 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);
-+ jffs2_bbc_original_compressor->decompress(NULL, data_in, cpage_out, srclen, destlen);
-+ jffs2_bbc_original_compressor->stat_decompr++;
-+}
-+
-+#endif
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_framework.h linux-mips/fs/jffs2/jffs2_bbc_framework.h
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_framework.h 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_framework.h 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,202 @@
-+/*
-+ * JFFS2-BBC: Compression Framework - headers
-+ *
-+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+ *
-+ * Copyright (C) 2004, Ferenc Havasi
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License
-+ * as published by the Free Software Foundation; either version 2
-+ * of the License, or (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+ *
-+ */
-+
-+#ifndef __JFFS2_BBC_FRAMEWORK_H__
-+
-+#define __JFFS2_BBC_FRAMEWORK_H__
-+
-+#define JFFS2_BBC_VERSION "0.54.3"
-+
-+#define JFFS2_BBC_CONFIG_FILE "bbc.conf"
-+
-+/*********************************************************************
-+ * Compression mode handling *
-+ *********************************************************************/
-+
-+#define JFFS2_BBC_ZLIB_MODE 1
-+#define JFFS2_BBC_SIZE_MODE 2
-+#define JFFS2_BBC_FASTR_MODE 3
-+#define JFFS2_BBC_FASTW_MODE 4
-+#define JFFS2_BBC_FASTS_MODE 5
-+#define JFFS2_BBC_MANUAL_MODE 6
-+#define JFFS2_BBC_DUMMY_MODE 7
-+
-+int jffs2_bbc_get_compression_mode(void);
-+void jffs2_bbc_set_compression_mode(int mode);
-+
-+/*********************************************************************
-+ * Read/write speed unit *
-+ * everything is relative to the speed of zlib *
-+ * bigger number means slower speed! *
-+ *********************************************************************/
-+
-+#define JFFS2_BBC_ZLIB_READ_TIME 10000
-+#define JFFS2_BBC_ZLIB_WRITE_TIME 10000
-+
-+/*********************************************************************
-+ * Compressor handling *
-+ *********************************************************************/
-+
-+struct jffs2_bbc_compressor_type
-+{
-+ char name[16];
-+ int model_file_sign; /* 0 for no model file needed */
-+ char block_sign[4]; /* only nomodel compressors, and only the first 2 _bytes are used! */
-+ int (*init)(void);
-+ int (*init_model)(void **model);
-+ void (*destroy_model)(void **model);
-+ void (*deinit)(void);
-+ /* Compress block
-+ * *dstlen bytes are allocated.
-+ * if it is not enough write *sourcelen over to the processed amount of data
-+ * returns non zero if fails
-+ */
-+ int (*compress)(void *model, unsigned char *input, unsigned char *output, unsigned long *sourcelen, unsigned long *dstlen);
-+ int (*estimate)(void *model, unsigned char *input, unsigned long sourcelen,
-+ unsigned long *dstlen, unsigned long *readtime, unsigned long *writetime);
-+ /* Decompress block
-+ * returns non zero if fails
-+ */
-+ int (*decompress)(void *model, unsigned char *input, unsigned char *output, unsigned long sourcelen, unsigned long dstlen);
-+ char *(*proc_info)(void);
-+ int (*proc_command)(char *command);
-+ int enabled; /* filled by BBC */
-+ int mounted; /* filled by BBC */
-+ void *models; /* filled by BBC */
-+ char *buffer; /* filled by BBC */
-+ int buffer_size; /* filled by BBC */
-+ int buffer_cnt; /* filled by BBC */
-+ int buffer_tmp; /* filled by BBC */
-+ int stat_compr_orig; /* filled by BBC */
-+ int stat_compr_new; /* filled by BBC */
-+ int stat_decompr; /* filled by BBC */
-+ struct jffs2_bbc_compressor_type *next; /* filled by BBC */
-+};
-+
-+/* It sets the compression mode to JFFS2_BBC_MANUAL_MODE */
-+
-+void jffs2_bbc_set_manual_compressor(struct jffs2_bbc_compressor_type *c); /* NULL = ZLIB */
-+int jffs2_bbc_set_manual_compressor_by_name(char *name);
-+int jffs2_bbc_disable_compressor_by_name(char *name);
-+int jffs2_bbc_enable_compressor_by_name(char *name);
-+void jffs2_bbc_compressor_command_by_name(char *name_and_command);
-+
-+/* If the compression mode is JFFS2_BCC_MANUAL_MODE the manually setted
-+ compressor can be get using it. Otherwise it returns with NULL. */
-+
-+struct jffs2_bbc_compressor_type *jffs2_bbc_get_manual_compressor(void);
-+
-+struct jffs2_bbc_model_list_node
-+{
-+ void *sb; /* FS idendifier (JFFS2_SB_INFO(sb) at this moment) */
-+ void *model; /* model data */
-+ int sign; /* sign of the model (first 4 bytes) */
-+ char block_sign[4]; /* block sign - only the first 2 bytes are used! */
-+ int inode; /* inode number of the model file */
-+ int stat_decompr;
-+ struct jffs2_bbc_compressor_type *compressor;
-+ struct jffs2_bbc_model_list_node *next_model;
-+ struct jffs2_bbc_model_list_node *next_compr_model;
-+};
-+
-+struct jffs2_bbc_compressor_type *jffs2_bbc_get_compressor_list(void);
-+struct jffs2_bbc_model_list_node *jffs2_bbc_get_model_list(void);
-+
-+int jffs2_bbc_register_compressor(struct jffs2_bbc_compressor_type *c);
-+int jffs2_bbc_unregister_compressor(struct jffs2_bbc_compressor_type *c);
-+
-+int jffs2_bbc_model_new(void *sb, int i_num, void *model);
-+void jffs2_bbc_model_del(void *sb);
-+void jffs2_bbc_model_set_act_sb(void *sb);
-+void *jffs2_bbc_model_get_act_sb(void);
-+void *jffs2_bbc_model_get_newest(struct jffs2_bbc_compressor_type *compressor);
-+
-+/*********************************************************************
-+ * Compressor init function *
-+ *********************************************************************/
-+
-+void jffs2_bbc_compressor_init(void);
-+void jffs2_bbc_compressor_deinit(void);
-+
-+/*********************************************************************
-+ * Statistics *
-+ *********************************************************************/
-+
-+char *jffs2_bbc_get_compr_stats(void);
-+char *jffs2_bbc_get_model_stats(void);
-+
-+/*********************************************************************
-+ * Other *
-+ *********************************************************************/
-+
-+
-+void jffs2_bbc_print_flush(void);
-+
-+#ifdef __KERNEL__
-+#include <linux/kernel.h>
-+#define jffs2_bbc_print1(a) printk(a)
-+#define jffs2_bbc_print2(a,b) printk(a,b)
-+#define jffs2_bbc_print3(a,b,c) printk(a,b,c)
-+#define jffs2_bbc_print4(a,b,c,d) printk(a,b,c,d)
-+#define jffs2_bbc_print5(a,b,c,d,e) printk(a,b,c,d,e)
-+#define jffs2_bbc_print6(a,b,c,d,e,f) printk(a,b,c,d,e,f)
-+#define jffs2_bbc_print7(a,b,c,d,e,f,g) printk(a,b,c,d,e,f,g)
-+#define jffs2_bbc_print8(a,b,c,d,e,f,g,h) printk(a,b,c,d,e,f,g,h)
-+#define jffs2_bbc_print9(a,b,c,d,e,f,g,h,i) printk(a,b,c,d,e,f,g,h,i)
-+#else
-+#include <stdio.h>
-+#define jffs2_bbc_print1(a) fprintf(stderr,a)
-+#define jffs2_bbc_print2(a,b) fprintf(stderr,a,b)
-+#define jffs2_bbc_print3(a,b,c) fprintf(stderr,a,b,c)
-+#define jffs2_bbc_print4(a,b,c,d) fprintf(stderr,a,b,c,d)
-+#define jffs2_bbc_print5(a,b,c,d,e) fprintf(stderr,a,b,c,d,e)
-+#define jffs2_bbc_print6(a,b,c,d,e,f) fprintf(stderr,a,b,c,d,e,f)
-+#define jffs2_bbc_print7(a,b,c,d,e,f,g) fprintf(stderr,a,b,c,d,e,f,g)
-+#define jffs2_bbc_print8(a,b,c,d,e,f,g,h) fprintf(stderr,a,b,c,d,e,f,g,h)
-+#define jffs2_bbc_print9(a,b,c,d,e,f,g,h,i) fprintf(stderr,a,b,c,d,e,f,g,h,i)
-+#endif
-+
-+/* Handle endianness */
-+#ifndef __KERNEL__
-+
-+#define ENDIAN_HOST_AND_TARGET_SAME 0
-+#define ENDIAN_HOST_AND_TARGET_DIFFERENT 1
-+
-+extern int jffs2_bbc_glb_endian_X;
-+
-+#endif
-+
-+/* Allocating more than one page (tip. 4096 byte) */
-+void *jffs2_bbc_malloc(long size);
-+void jffs2_bbc_free(void *addr);
-+
-+/* Allocating less than one page (tip. 4096 byte) */
-+void *jffs2_bbc_malloc_small(long size);
-+void jffs2_bbc_free_small(void *addr);
-+
-+/* Memory guarding */
-+int jffs2_bbc_test_memory_counter(int verbose);
-+char *jffs2_bbc_get_mem_stats(void);
-+int jffs2_bbc_get_memory_counter(void);
-+
-+#endif
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_fs.c linux-mips/fs/jffs2/jffs2_bbc_fs.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_fs.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_fs.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,331 @@
-+/*
-+ * JFFS2-BBC: File System Extension for Linux Kernel
-+ *
-+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+ *
-+ * Copyright (C) 2004, Ferenc Havasi
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License
-+ * as published by the Free Software Foundation; either version 2
-+ * of the License, or (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+ *
-+ */
-+
-+#include <linux/kernel.h>
-+#include <linux/fs.h>
-+#include <linux/jffs2.h>
-+#include <linux/proc_fs.h>
-+#include <linux/version.h>
-+
-+#include "nodelist.h"
-+
-+#include "jffs2_bbc_framework.h"
-+
-+struct jffs2_bbc_fs_sb_list {
-+ struct super_block *sb;
-+ struct jffs2_bbc_fs_sb_list *next;
-+};
-+
-+static struct jffs2_bbc_fs_sb_list *sb_list = NULL;
-+
-+void jffs2_bbc_proc_init(void);
-+void jffs2_bbc_proc_deinit(void);
-+
-+void jffs2_bbc_load_model(void *sb_par) {
-+ struct jffs2_sb_info *c;
-+ //struct jffs2_inode_info *f;
-+ struct dentry *config_dentry,*model_dentry;
-+ struct qstr config_name,model_name;
-+ struct file *config_file,*model_file;
-+ char *buff=NULL,*model_buff;
-+ int config_size,model_size;
-+ int i,prev_i;
-+ struct super_block *sb;
-+ struct jffs2_bbc_fs_sb_list *sb_l;
-+
-+ sb = sb_par;
-+ sb_l = jffs2_bbc_malloc_small(sizeof(struct jffs2_bbc_fs_sb_list));
-+ sb_l->sb = sb;
-+ sb_l->next = sb_list;
-+ sb_list = sb_l;
-+ config_name.name = JFFS2_BBC_CONFIG_FILE;
-+ config_name.len = strlen(config_name.name);
-+ config_name.hash = full_name_hash(config_name.name,config_name.len);
-+ config_dentry = d_alloc(sb->s_root,&config_name);
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,config_dentry);
-+#else
-+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,config_dentry,NULL);
-+#endif
-+
-+ if (config_dentry->d_inode != NULL) {
-+ config_size = config_dentry->d_inode->i_size;
-+ //printk("config_file_size=%d\n",config_size);
-+ if (config_size > 0) {
-+ buff = jffs2_bbc_malloc(config_size+1);
-+ config_file = dentry_open(config_dentry,NULL,O_RDONLY);
-+ kernel_read(config_file,0,buff,config_size);
-+ buff[config_size] = 0;
-+ for (prev_i = i = 0 ; i < config_size+1 ; i++) {
-+ if (buff[i] == '\n') buff[i]=0;
-+ if (buff[i] == 0) {
-+ if (prev_i != i) {
-+ if ((buff[prev_i] == '-') && (buff[prev_i+1] == 0)) break;
-+ printk("reading model file %s... ",buff+prev_i);
-+ model_name.name = buff+prev_i;
-+ model_name.len = strlen(buff+prev_i);
-+ model_name.hash = full_name_hash(model_name.name,model_name.len);
-+ model_dentry = d_alloc(sb->s_root,&model_name);
-+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
-+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,model_dentry);
-+#else
-+ sb->s_root->d_inode->i_op->lookup(sb->s_root->d_inode,model_dentry,NULL);
-+#endif
-+ if (model_dentry->d_inode != NULL) {
-+ c = JFFS2_SB_INFO(model_dentry->d_inode->i_sb);
-+ //f = JFFS2_INODE_INFO(model_dentry->d_inode);
-+ model_size = model_dentry->d_inode->i_size;
-+ model_buff = jffs2_bbc_malloc(model_size);
-+ model_file = dentry_open(model_dentry,NULL,O_RDONLY);
-+ kernel_read(model_file,0,model_buff,model_size);
-+ if (jffs2_bbc_model_new(c,model_dentry->d_inode->i_ino,model_buff) != 0) {
-+ printk("already loaded.\n");
-+ jffs2_bbc_free(model_buff);
-+ }
-+ else {
-+ printk("done (%d bytes readed from inode %d).\n",model_size,(int)(model_dentry->d_inode->i_ino));
-+ }
-+ }
-+ else {
-+ printk("not found.\n");
-+ }
-+ dput(model_dentry);
-+ }
-+ prev_i = i+1;
-+ }
-+ }
-+ }
-+ }
-+ dput(config_dentry);
-+ if (buff != NULL) jffs2_bbc_free(buff);
-+}
-+
-+void jffs2_bbc_unload_model(void *sb_par)
-+{
-+ struct jffs2_sb_info *c;
-+ struct super_block *sb = sb_par;
-+ struct jffs2_bbc_fs_sb_list *sb_l,*sb_l2;
-+ int done = 0;
-+
-+ c = JFFS2_SB_INFO(sb);
-+ jffs2_bbc_model_del(c);
-+ if (sb_list == NULL) printk("jffs2.bbc: error! NULL sb list!\n");
-+ else {
-+ if (sb_list->sb == sb) {
-+ jffs2_bbc_free_small(sb_list);
-+ sb_list = NULL;
-+ done = 1;
-+ }
-+ else {
-+ sb_l = sb_list;
-+ while (sb_l->next != NULL) {
-+ if (sb_l->next->sb == sb) {
-+ sb_l2 = sb_l->next->next;
-+ jffs2_bbc_free_small(sb_l->next);
-+ sb_l->next = sb_l2;
-+ done = 1;
-+ }
-+ sb_l = sb_l->next;
-+ }
-+
-+ }
-+ if (done == 0) {
-+ printk("jffs2.bbc: cannot delete sb from sblist!\n");
-+ }
-+ }
-+}
-+
-+static int jffs2_bbc_get_mounted(void) {
-+ struct jffs2_bbc_fs_sb_list *sb_l;
-+ int num = 0;
-+
-+ sb_l = sb_list;
-+ while (sb_l != NULL) {
-+ num++;
-+ sb_l = sb_l->next;
-+ }
-+ return num;
-+
-+}
-+
-+int jffs2_bbc_proc_read(char *buf, char **start, off_t offset, int count, int *eof, void *data)
-+{
-+ int len = 0, mode;
-+
-+ mode = jffs2_bbc_get_compression_mode();
-+ len += sprintf(buf + len, "BBC version: %s\n", JFFS2_BBC_VERSION);
-+ len += sprintf(buf+len,"Mounted jffs2 filesystems: %d\n",jffs2_bbc_get_mounted());
-+ //len += sprintf(buf+len,"actual model file inode: %d\n",jffs2_bbc_model_get_inum());
-+ len += sprintf(buf + len, "Compression mode: ");
-+ if (mode == JFFS2_BBC_ZLIB_MODE)
-+ len += sprintf(buf + len, "ZLIB mode");
-+ else if (mode == JFFS2_BBC_SIZE_MODE)
-+ len += sprintf(buf + len, "SIZE mode");
-+ else if (mode == JFFS2_BBC_FASTR_MODE)
-+ len += sprintf(buf + len, "FASTR mode");
-+ else if (mode == JFFS2_BBC_FASTW_MODE)
-+ len += sprintf(buf + len, "FASTW mode");
-+ else if (mode == JFFS2_BBC_FASTS_MODE)
-+ len += sprintf(buf + len, "FASTS mode");
-+ else if (mode == JFFS2_BBC_DUMMY_MODE)
-+ len += sprintf(buf + len, "DUMMY mode");
-+ else if (mode == JFFS2_BBC_MANUAL_MODE) {
-+ len += sprintf(buf + len, "MANUAL mode (");
-+ if (jffs2_bbc_get_manual_compressor() != NULL)
-+ len += sprintf(buf + len, "%s)", jffs2_bbc_get_manual_compressor()->name);
-+ else
-+ len += sprintf(buf + len, "ZLIB)");
-+ }
-+ else
-+ len += sprintf(buf + len, "unknown mode");
-+ len += sprintf(buf + len, "\n");
-+ len += sprintf(buf + len, "%s", jffs2_bbc_get_compr_stats());
-+ len += sprintf(buf + len, "%s", jffs2_bbc_get_model_stats());
-+ len += sprintf(buf + len, "%s", jffs2_bbc_get_mem_stats());
-+ *eof = 1;
-+ return len;
-+}
-+
-+int jffs2_bbc_proc_write(struct file *file, const char *buffer_orig, unsigned long count, void *data)
-+{
-+ char *buffer;
-+ int i;
-+ struct jffs2_bbc_fs_sb_list *sb_l;
-+
-+ if (buffer_orig == NULL) return 0;
-+
-+ buffer = jffs2_bbc_malloc(count+2);
-+ for (i=0;i<count;i++) buffer[i]=buffer_orig[i];
-+ buffer[count] = 0;
-+ if ((*buffer == 'z') || (*buffer == 'Z')) {
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_ZLIB_MODE);
-+ jffs2_bbc_print1("jffs2.bbc: ZLIB compression mode activated.\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if ((*buffer == 's') || (*buffer == 'S')) {
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_SIZE_MODE);
-+ jffs2_bbc_print1("jffs2.bbc: SIZE compression mode activated.\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if ((*buffer == 'd') || (*buffer == 'D')) {
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_DUMMY_MODE);
-+ jffs2_bbc_print1("jffs2.bbc: DUMMY compression mode activated.\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((*buffer == 'm') || (*buffer == 'M')) && (count >= 3) && (buffer[1] == ':')) {
-+ jffs2_bbc_print1("jffs2.bbc: activating MANUAL mode.\n");
-+ jffs2_bbc_set_manual_compressor_by_name(buffer + 2);
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((*buffer == '0')) && (count >= 3) && (buffer[1] == ':')) {
-+ jffs2_bbc_print1("jffs2.bbc: disabling a compressor... ");
-+ if (jffs2_bbc_disable_compressor_by_name(buffer + 2) == 0) {
-+ jffs2_bbc_print1("done.\n");
-+ }
-+ else {
-+ jffs2_bbc_print1("not found.\n");
-+ }
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((*buffer == '1')) && (count >= 3) && (buffer[1] == ':')) {
-+ jffs2_bbc_print1("jffs2.bbc: enabling a compressor... ");
-+ if (jffs2_bbc_enable_compressor_by_name(buffer + 2) == 0) {
-+ jffs2_bbc_print1("done.\n");
-+ }
-+ else {
-+ jffs2_bbc_print1("not found.\n");
-+ }
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((*buffer == 'c') || (*buffer == 'C')) && (count >= 3) && (buffer[1] == ':')) {
-+ jffs2_bbc_compressor_command_by_name(buffer + 2);
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if ((*buffer == 'r') || (*buffer == 'R')) {
-+ jffs2_bbc_print1("jffs2.bbc: reloading model files:\n");
-+ sb_l = sb_list;
-+ while (sb_l != NULL) {
-+ jffs2_bbc_unload_model(sb_l->sb);
-+ jffs2_bbc_load_model(sb_l->sb);
-+ sb_l = sb_l->next;
-+ }
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((buffer[0] == 'f') || (buffer[0] == 'F'))&&((buffer[1] == 'r') || (buffer[1] == 'R'))) {
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_FASTR_MODE);
-+ jffs2_bbc_print1("jffs2.bbc: FASTR compression mode activated.\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((buffer[0] == 'f') || (buffer[0] == 'F'))&&((buffer[1] == 'w') || (buffer[1] == 'W'))) {
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_FASTW_MODE);
-+ jffs2_bbc_print1("jffs2.bbc: FASTW compression mode activated.\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+ else if (((buffer[0] == 'f') || (buffer[0] == 'F'))&&((buffer[1] == 's') || (buffer[1] == 'S'))) {
-+ jffs2_bbc_set_compression_mode(JFFS2_BBC_FASTS_MODE);
-+ jffs2_bbc_print1("jffs2.bbc: FASTS compression mode activated.\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+ }
-+
-+ jffs2_bbc_print1("jffs2.bbc: unkown command. Valid commands are:\n"
-+ " z = switch to ZLIB compression mode\n"
-+ " s = switch to SIZE compression mode\n"
-+ " d = switch to DUMMY compression mode\n"
-+ " fr = switch to FASTR compression mode\n"
-+ " fw = switch to FASTW compression mode\n"
-+ " fs = switch to FASTS compression mode\n"
-+ " r = reread model files from actual file system\n"
-+ " m:compressor_name = switch to MANUAL compression mode\n"
-+ " 0:compressor_name = disable a compressor\n"
-+ " 1:compressor_name = enable a compressor\n"
-+ " c:compressor_name:command = enable a compressor\n");
-+ jffs2_bbc_free(buffer);
-+ return count;
-+}
-+
-+void jffs2_bbc_proc_init()
-+{
-+ struct proc_dir_entry *res = create_proc_entry("jffs2_bbc", 0, NULL);
-+ jffs2_bbc_compressor_init();
-+ if (res) {
-+ res->read_proc = jffs2_bbc_proc_read;
-+ res->write_proc = jffs2_bbc_proc_write;
-+ }
-+}
-+
-+void jffs2_bbc_proc_deinit()
-+{
-+ jffs2_bbc_compressor_deinit();
-+ remove_proc_entry("jffs2_bbc", NULL);
-+}
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_fs.h linux-mips/fs/jffs2/jffs2_bbc_fs.h
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_fs.h 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_fs.h 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,30 @@
-+/*
-+ * JFFS2 BBC: File System Extension for Linux Kernel - headers
-+ *
-+ * $Id: 301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+ *
-+ * Copyright (C) 2004, Ferenc Havasi
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License
-+ * as published by the Free Software Foundation; either version 2
-+ * of the License, or (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+ *
-+ */
-+
-+extern int jffs2_bbc_inode_not_found;
-+
-+void jffs2_bbc_load_model(void *sb);
-+void jffs2_bbc_unload_model(void *sb);
-+
-+void jffs2_bbc_proc_init(void);
-+void jffs2_bbc_proc_deinit(void);
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_lzari_comp.c linux-mips/fs/jffs2/jffs2_bbc_lzari_comp.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_lzari_comp.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_lzari_comp.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,788 @@
-+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
-+
-+/*
-+ jffs2_bbc_lzari_comp.c -- Lempel-Ziv-Arithmetic coding compression module for jffs2
-+ Copyright (C) 2004 Patrik Kluba
-+ Based on the LZARI source included in LDS (lossless datacompression sources)
-+ Block-compression and bitstream modifications by Patrik Kluba
-+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*/
-+
-+/*
-+Original copyright follows:
-+
-+**************************************************************
-+ LZARI.C -- A Data Compression Program
-+ (tab = 4 spaces)
-+**************************************************************
-+ 4/7/1989 Haruhiko Okumura
-+ Use, distribute, and modify this program freely.
-+ Please send me your improved versions.
-+ PC-VAN SCIENCE
-+ NIFTY-Serve PAF01022
-+ CompuServe 74050,1022
-+**************************************************************
-+
-+LZARI.C (c)1989 by Haruyasu Yoshizaki, Haruhiko Okumura, and Kenji Rikitake.
-+All rights reserved. Permission granted for non-commercial use.
-+
-+*/
-+
-+/*
-+
-+ 2004-02-18 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
-+ Removed unused variables and fixed no return value
-+
-+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
-+ Initial release
-+
-+*/
-+
-+/* lzari.c */
-+
-+#define N 4096 /* size of ring buffer */
-+#define F 60 /* upper limit for match_length */
-+#define THRESHOLD 2 /* encode string into position and length
-+ if match_length is greater than this */
-+#define NIL N /* index for root of binary search trees */
-+
-+static unsigned char
-+ text_buf[N + F - 1]; /* ring buffer of size N,
-+ with extra F-1 bytes to facilitate string comparison */
-+static unsigned long match_position, match_length, /* of longest match. These are
-+ set by the InsertNode() procedure. */
-+ lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
-+ parents -- These constitute binary search trees. */
-+
-+static void InitTree(void) /* Initialize trees */
-+{
-+ unsigned long i;
-+
-+ /* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
-+ left children of node i. These nodes need not be initialized.
-+ Also, dad[i] is the parent of node i. These are initialized to
-+ NIL (= N), which stands for 'not used.'
-+ For i = 0 to 255, rson[N + i + 1] is the root of the tree
-+ for strings that begin with character i. These are initialized
-+ to NIL. Note there are 256 trees. */
-+
-+ for (i = N + 1; i <= N + 256; i++) rson[i] = NIL; /* root */
-+ for (i = 0; i < N; i++) dad[i] = NIL; /* node */
-+}
-+
-+static void InsertNode(unsigned long r)
-+ /* Inserts string of length F, text_buf[r..r+F-1], into one of the
-+ trees (text_buf[r]'th tree) and returns the longest-match position
-+ and length via the global variables match_position and match_length.
-+ If match_length = F, then removes the old node in favor of the new
-+ one, because the old one will be deleted sooner.
-+ Note r plays double role, as tree node and position in buffer. */
-+{
-+ unsigned long i, p, temp;
-+ unsigned char *key;
-+ signed long cmp;
-+
-+ cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
-+ rson[r] = lson[r] = NIL; match_length = 0;
-+ for ( ; ; ) {
-+ if (cmp >= 0) {
-+ if (rson[p] != NIL) p = rson[p];
-+ else { rson[p] = r; dad[r] = p; return; }
-+ } else {
-+ if (lson[p] != NIL) p = lson[p];
-+ else { lson[p] = r; dad[r] = p; return; }
-+ }
-+ for (i = 1; i < F; i++)
-+ if ((cmp = key[i] - text_buf[p + i]) != 0) break;
-+ if (i > THRESHOLD) {
-+ if (i > match_length) {
-+ match_position = (r - p) & (N - 1);
-+ if ((match_length = i) >= F) break;
-+ } else if (i == match_length) {
-+ if ((temp = (r - p) & (N - 1)) < match_position)
-+ match_position = temp;
-+ }
-+ }
-+ }
-+ dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
-+ dad[lson[p]] = r; dad[rson[p]] = r;
-+ if (rson[dad[p]] == p) rson[dad[p]] = r;
-+ else lson[dad[p]] = r;
-+ dad[p] = NIL; /* remove p */
-+}
-+
-+static void DeleteNode(unsigned long p) /* Delete node p from tree */
-+{
-+ unsigned long q;
-+
-+ if (dad[p] == NIL) return; /* not in tree */
-+ if (rson[p] == NIL) q = lson[p];
-+ else if (lson[p] == NIL) q = rson[p];
-+ else {
-+ q = lson[p];
-+ if (rson[q] != NIL) {
-+ do { q = rson[q]; } while (rson[q] != NIL);
-+ rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
-+ lson[q] = lson[p]; dad[lson[p]] = q;
-+ }
-+ rson[q] = rson[p]; dad[rson[p]] = q;
-+ }
-+ dad[q] = dad[p];
-+ if (rson[dad[p]] == p) rson[dad[p]] = q;
-+ else lson[dad[p]] = q;
-+ dad[p] = NIL;
-+}
-+
-+/********** Arithmetic Compression **********/
-+
-+/* If you are not familiar with arithmetic compression, you should read
-+ I. E. Witten, R. M. Neal, and J. G. Cleary,
-+ Communications of the ACM, Vol. 30, pp. 520-540 (1987),
-+ from which much have been borrowed. */
-+
-+#define M 15
-+
-+/* Q1 (= 2 to the M) must be sufficiently large, but not so
-+ large as the unsigned long 4 * Q1 * (Q1 - 1) overflows. */
-+
-+#define Q1 (1UL << M)
-+#define Q2 (2 * Q1)
-+#define Q3 (3 * Q1)
-+#define Q4 (4 * Q1)
-+#define MAX_CUM (Q1 - 1)
-+
-+#define N_CHAR (256 - THRESHOLD + F)
-+ /* character code = 0, 1, ..., N_CHAR - 1 */
-+
-+static unsigned long char_to_sym[N_CHAR], sym_to_char[N_CHAR + 1];
-+static unsigned long
-+ sym_freq[N_CHAR + 1], /* frequency for symbols */
-+ sym_cum[N_CHAR + 1], /* cumulative freq for symbols */
-+ position_cum[N + 1]; /* cumulative freq for positions */
-+
-+static void StartModel(void) /* Initialize model */
-+{
-+ unsigned long ch, sym, i;
-+
-+ sym_cum[N_CHAR] = 0;
-+ for (sym = N_CHAR; sym >= 1; sym--) {
-+ ch = sym - 1;
-+ char_to_sym[ch] = sym; sym_to_char[sym] = ch;
-+ sym_freq[sym] = 1;
-+ sym_cum[sym - 1] = sym_cum[sym] + sym_freq[sym];
-+ }
-+ sym_freq[0] = 0; /* sentinel (!= sym_freq[1]) */
-+ position_cum[N] = 0;
-+ for (i = N; i >= 1; i--)
-+ position_cum[i - 1] = position_cum[i] + 10000 / (i + 200);
-+ /* empirical distribution function (quite tentative) */
-+ /* Please devise a better mechanism! */
-+}
-+
-+static void UpdateModel(unsigned long sym)
-+{
-+ unsigned long c, ch_i, ch_sym;
-+ unsigned long i;
-+ if (sym_cum[0] >= MAX_CUM) {
-+ c = 0;
-+ for (i = N_CHAR; i > 0; i--) {
-+ sym_cum[i] = c;
-+ c += (sym_freq[i] = (sym_freq[i] + 1) >> 1);
-+ }
-+ sym_cum[0] = c;
-+ }
-+ for (i = sym; sym_freq[i] == sym_freq[i - 1]; i--) ;
-+ if (i < sym) {
-+ ch_i = sym_to_char[i]; ch_sym = sym_to_char[sym];
-+ sym_to_char[i] = ch_sym; sym_to_char[sym] = ch_i;
-+ char_to_sym[ch_i] = sym; char_to_sym[ch_sym] = i;
-+ }
-+ sym_freq[i]++;
-+ while (--i > 0) sym_cum[i]++;
-+ sym_cum[0]++;
-+}
-+
-+static unsigned long BinarySearchSym(unsigned long x)
-+ /* 1 if x >= sym_cum[1],
-+ N_CHAR if sym_cum[N_CHAR] > x,
-+ i such that sym_cum[i - 1] > x >= sym_cum[i] otherwise */
-+{
-+ unsigned long i, j, k;
-+
-+ i = 1; j = N_CHAR;
-+ while (i < j) {
-+ k = (i + j) / 2;
-+ if (sym_cum[k] > x) i = k + 1; else j = k;
-+ }
-+ return i;
-+}
-+
-+unsigned long BinarySearchPos(unsigned long x)
-+ /* 0 if x >= position_cum[1],
-+ N - 1 if position_cum[N] > x,
-+ i such that position_cum[i] > x >= position_cum[i + 1] otherwise */
-+{
-+ unsigned long i, j, k;
-+
-+ i = 1; j = N;
-+ while (i < j) {
-+ k = (i + j) / 2;
-+ if (position_cum[k] > x) i = k + 1; else j = k;
-+ }
-+ return i - 1;
-+}
-+
-+/* modified for block compression */
-+/* on return, srclen will contain the number of successfully compressed bytes
-+ and dstlen will contain completed compressed bytes */
-+
-+static int Encode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long *srclen,
-+ unsigned long *dstlen)
-+{
-+ unsigned long c, i, len, r, s, last_match_length, sym, range;
-+ unsigned long low = 0;
-+ unsigned long high = Q4;
-+ unsigned long shifts = 0; /* counts for magnifying low and high around Q2 */
-+ unsigned char *ip, *op;
-+ unsigned long written = 0;
-+ unsigned long read = 0;
-+ unsigned char buffer = 0;
-+ unsigned char mask = 128;
-+ unsigned char *srcend = srcbuf + *srclen;
-+ unsigned char *dstend = dstbuf + *dstlen;
-+ ip = srcbuf;
-+ op = dstbuf;
-+ StartModel();
-+ InitTree(); /* initialize trees */
-+ s = 0; r = N - F;
-+ for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
-+ any character that will appear often. */
-+ for (len = 0; (len < F) && (ip < srcend); len++)
-+ text_buf[r + len] = *(ip++); /* Read F bytes into the last F bytes of
-+ the buffer */
-+ read = len;
-+ for (i = 1; i <= F; i++) InsertNode(r - i); /* Insert the F strings,
-+ each of which begins with one or more 'space' characters. Note
-+ the order in which these strings are inserted. This way,
-+ degenerate trees will be less likely to occur. */
-+ InsertNode(r); /* Finally, insert the whole string just read. The
-+ global variables match_length and match_position are set. */
-+ do {
-+ if (match_length > len) match_length = len; /* match_length
-+ may be spuriously long near the end of text. */
-+ if (match_length <= THRESHOLD) {
-+ match_length = 1; /* Not long enough match. Send one byte. */
-+ sym = char_to_sym[text_buf[r]];
-+ range = high - low;
-+ high = low + (range * sym_cum[sym - 1]) / sym_cum[0];
-+ low += (range * sym_cum[sym ]) / sym_cum[0];
-+ for ( ; ; ) {
-+ if (high <= Q2) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ } else if (low >= Q2) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ low -= Q2;
-+ high -= Q2;
-+ } else if (low >= Q1 && high <= Q3) {
-+ shifts++;
-+ low -= Q1;
-+ high -= Q1;
-+ } else break;
-+ low += low; high += high;
-+ }
-+ UpdateModel(sym);
-+ } else {
-+ sym = char_to_sym[255 - THRESHOLD + match_length];
-+ range = high - low;
-+ high = low + (range * sym_cum[sym - 1]) / sym_cum[0];
-+ low += (range * sym_cum[sym ]) / sym_cum[0];
-+ for ( ; ; ) {
-+ if (high <= Q2) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ } else if (low >= Q2) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ low -= Q2;
-+ high -= Q2;
-+ } else if (low >= Q1 && high <= Q3) {
-+ shifts++;
-+ low -= Q1;
-+ high -= Q1;
-+ } else break;
-+ low += low; high += high;
-+ }
-+ UpdateModel(sym);
-+ range = high - low;
-+ high = low + (range * position_cum[match_position - 1]) / position_cum[0];
-+ low += (range * position_cum[match_position ]) / position_cum[0];
-+ for ( ; ; ) {
-+ if (high <= Q2) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ } else {
-+ if (low >= Q2) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ low -= Q2;
-+ high -= Q2;
-+ } else {
-+ if ((low >= Q1) && (high <= Q3)) {
-+ shifts++;
-+ low -= Q1;
-+ high -= Q1;
-+ } else {
-+ break;
-+ }
-+ }
-+ }
-+ low += low;
-+ high += high;
-+ }
-+ }
-+ last_match_length = match_length;
-+ for (i = 0; (i < last_match_length) && (ip < srcend); i++) {
-+ c = *(ip++);
-+ DeleteNode(s);
-+ text_buf[s] = c;
-+ if (s < F - 1)
-+ text_buf[s + N] = c;
-+ s = (s + 1) & (N - 1);
-+ r = (r + 1) & (N - 1);
-+ InsertNode(r);
-+ }
-+ read += i;
-+ while (i++ < last_match_length) {
-+ DeleteNode(s);
-+ s = (s + 1) & (N - 1);
-+ r = (r + 1) & (N - 1);
-+ if (--len) InsertNode(r);
-+ }
-+ } while (len > 0);
-+ shifts++;
-+ if (low < Q1) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ } else {
-+ buffer |= mask;
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ for ( ; shifts > 0; shifts--) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ }
-+ for (i = 0; i < 7; i++) {
-+ if ((mask >>= 1) == 0) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = buffer;
-+ buffer = 0;
-+ mask = 128;
-+ written++;
-+ *srclen = read;
-+ }
-+ }
-+ *dstlen = written;
-+ return 0;
-+}
-+
-+static int Decode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long srclen,
-+ unsigned long dstlen) /* Just the reverse of Encode(). */
-+{
-+ unsigned long i, r, j, k, c, range, sym;
-+ unsigned char *ip, *op;
-+ unsigned char *srcend = srcbuf + srclen;
-+ unsigned char *dstend = dstbuf + dstlen;
-+ unsigned char buffer = 0;
-+ unsigned char mask = 0;
-+ unsigned long low = 0;
-+ unsigned long high = Q4;
-+ unsigned long value = 0;
-+ ip = srcbuf;
-+ op = dstbuf;
-+ for (i = 0; i < M + 2; i++) {
-+ value *= 2;
-+ if ((mask >>= 1) == 0) {
-+ buffer = (ip >= srcend) ? 0 : *(ip++);
-+ mask = 128;
-+ }
-+ value += ((buffer & mask) != 0);
-+ }
-+ StartModel();
-+ for (i = 0; i < N - F; i++) text_buf[i] = ' ';
-+ r = N - F;
-+ while (op < dstend) {
-+ range = high - low;
-+ sym = BinarySearchSym((unsigned long)
-+ (((value - low + 1) * sym_cum[0] - 1) / range));
-+ high = low + (range * sym_cum[sym - 1]) / sym_cum[0];
-+ low += (range * sym_cum[sym ]) / sym_cum[0];
-+ for ( ; ; ) {
-+ if (low >= Q2) {
-+ value -= Q2; low -= Q2; high -= Q2;
-+ } else if (low >= Q1 && high <= Q3) {
-+ value -= Q1; low -= Q1; high -= Q1;
-+ } else if (high > Q2) break;
-+ low += low; high += high;
-+ value *= 2;
-+ if ((mask >>= 1) == 0) {
-+ buffer = (ip >= srcend) ? 0 : *(ip++);
-+ mask = 128;
-+ }
-+ value += ((buffer & mask) != 0);
-+ }
-+ c = sym_to_char[sym];
-+ UpdateModel(sym);
-+ if (c < 256) {
-+ if (op >= dstend) return -1;
-+ *(op++) = c;
-+ text_buf[r++] = c;
-+ r &= (N - 1);
-+ } else {
-+ j = c - 255 + THRESHOLD;
-+ range = high - low;
-+ i = BinarySearchPos((unsigned long)
-+ (((value - low + 1) * position_cum[0] - 1) / range));
-+ high = low + (range * position_cum[i ]) / position_cum[0];
-+ low += (range * position_cum[i + 1]) / position_cum[0];
-+ for ( ; ; ) {
-+ if (low >= Q2) {
-+ value -= Q2; low -= Q2; high -= Q2;
-+ } else if (low >= Q1 && high <= Q3) {
-+ value -= Q1; low -= Q1; high -= Q1;
-+ } else if (high > Q2) break;
-+ low += low; high += high;
-+ value *= 2;
-+ if ((mask >>= 1) == 0) {
-+ buffer = (ip >= srcend) ? 0 : *(ip++);
-+ mask = 128;
-+ }
-+ value += ((buffer & mask) != 0);
-+ }
-+ i = (r - i - 1) & (N - 1);
-+ for (k = 0; k < j; k++) {
-+ c = text_buf[(i + k) & (N - 1)];
-+ if (op >= dstend) return -1;
-+ *(op++) = c;
-+ text_buf[r++] = c;
-+ r &= (N - 1);
-+ }
-+ }
-+ }
-+ return 0;
-+}
-+
-+/* interface to jffs2 bbc follows */
-+
-+#include "jffs2_bbc_framework.h"
-+
-+#define JFFS2_BBC_LZARI_BLOCK_SIGN {0x73, 0x9a, 0x1c, 0x4d}
-+
-+static int
-+jffs2_bbc_lzari_compressor_init (void);
-+
-+static void
-+jffs2_bbc_lzari_compressor_deinit (void);
-+
-+static int
-+jffs2_bbc_lzari_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen);
-+
-+static int
-+jffs2_bbc_lzari_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime);
-+
-+static int
-+jffs2_bbc_lzari_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen);
-+
-+static char *
-+jffs2_bbc_lzari_proc_info (void);
-+
-+static int
-+jffs2_bbc_lzari_proc_command (char *command);
-+
-+struct jffs2_bbc_compressor_type jffs2_bbc_lzari = {
-+ "lzari",
-+ 0,
-+ JFFS2_BBC_LZARI_BLOCK_SIGN,
-+ jffs2_bbc_lzari_compressor_init,
-+ NULL,
-+ NULL,
-+ jffs2_bbc_lzari_compressor_deinit,
-+ jffs2_bbc_lzari_compress,
-+ jffs2_bbc_lzari_estimate,
-+ jffs2_bbc_lzari_decompress,
-+ jffs2_bbc_lzari_proc_info,
-+ jffs2_bbc_lzari_proc_command
-+};
-+
-+static int
-+jffs2_bbc_lzari_compressor_init (void)
-+{
-+ return 0;
-+}
-+
-+static void
-+jffs2_bbc_lzari_compressor_deinit (void)
-+{
-+}
-+
-+static int
-+jffs2_bbc_lzari_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen)
-+{
-+ int retval;
-+ unsigned long dst = *dstlen;
-+ *(output++) = jffs2_bbc_lzari.block_sign[0];
-+ *(output++) = jffs2_bbc_lzari.block_sign[1];
-+ dst -= 2;
-+ retval = Encode(input, output, sourcelen, &dst);
-+ dst += 2;
-+ *dstlen = dst;
-+ return retval;
-+}
-+
-+static int
-+jffs2_bbc_lzari_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime)
-+{
-+ *dstlen = sourcelen / 2;
-+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 15;
-+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 7;
-+ return 0;
-+}
-+
-+static int
-+jffs2_bbc_lzari_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen)
-+{
-+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzari.block_sign[0] ) ||
-+ ( *(input++) != (unsigned char)jffs2_bbc_lzari.block_sign[1] )
-+ ) {
-+ return -1;
-+ } else {
-+ return Decode(input, output, sourcelen - 2, dstlen);
-+ }
-+}
-+
-+static char *
-+jffs2_bbc_lzari_proc_info (void)
-+{
-+ return "Lempel-Ziv-Arithmetic coding compression module";
-+}
-+
-+static int
-+jffs2_bbc_lzari_proc_command (char *command)
-+{
-+ return 0;
-+}
-+
-+struct jffs2_bbc_compressor_type *
-+jffs2_bbc_lzari_init (int mode)
-+{
-+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzari) == 0)
-+ {
-+ return &jffs2_bbc_lzari;
-+ }
-+ else
-+ {
-+ return NULL;
-+ }
-+}
-+
-+void
-+jffs2_bbc_lzari_deinit (void)
-+{
-+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzari);
-+}
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_lzhd_comp.c linux-mips/fs/jffs2/jffs2_bbc_lzhd_comp.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_lzhd_comp.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_lzhd_comp.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,747 @@
-+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
-+
-+/*
-+ jffs2_bbc_lzhd_comp.c -- Lempel-Ziv-(dynamic) Huffman compression module for jffs2
-+ Copyright (C) 2004 Patrik Kluba
-+ Based on the LZHUF source included in LDS (lossless datacompression sources)
-+ Block-compression and bitstream modifications by Patrik Kluba
-+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*/
-+
-+/*
-+Original copyright follows:
-+
-+**************************************************************
-+ lzhuf.c
-+ written by Haruyasu Yoshizaki 11/20/1988
-+ some minor changes 4/6/1989
-+ comments translated by Haruhiko Okumura 4/7/1989
-+**************************************************************
-+
-+LZHUF.C (c)1989 by Haruyasu Yoshizaki, Haruhiko Okumura, and Kenji Rikitake.
-+All rights reserved. Permission granted for non-commercial use.
-+
-+*/
-+
-+/*
-+
-+ 2004-02-18 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
-+ Replaced name lzh-d with lzhd
-+ Fixed no return value
-+
-+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
-+ Initial release
-+
-+*/
-+
-+/* required because of memmove */
-+#ifndef __KERNEL__
-+ #include <string.h>
-+#else
-+ #include <linux/string.h>
-+#endif
-+
-+/* lzhuf.c */
-+
-+#define N 4096 /* size of ring buffer */
-+#define F 60 /* upper limit for match_length */
-+#define THRESHOLD 2 /* encode string into position and length
-+ if match_length is greater than this */
-+#define NIL N /* index for root of binary search trees */
-+
-+static unsigned char
-+ text_buf[N + F - 1]; /* ring buffer of size N,
-+ with extra F-1 bytes to facilitate string comparison */
-+static unsigned long match_position, match_length, /* of longest match. These are
-+ set by the InsertNode() procedure. */
-+ lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
-+ parents -- These constitute binary search trees. */
-+
-+static void InitTree(void) /* initialize trees */
-+{
-+ unsigned long i;
-+
-+ /* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
-+ left children of node i. These nodes need not be initialized.
-+ Also, dad[i] is the parent of node i. These are initialized to
-+ NIL (= N), which stands for 'not used.'
-+ For i = 0 to 255, rson[N + i + 1] is the root of the tree
-+ for strings that begin with character i. These are initialized
-+ to NIL. Note there are 256 trees. */
-+
-+ for (i = N + 1; i <= N + 256; i++) rson[i] = NIL;
-+ for (i = 0; i < N; i++) dad[i] = NIL;
-+}
-+
-+static void InsertNode(unsigned long r)
-+ /* Inserts string of length F, text_buf[r..r+F-1], into one of the
-+ trees (text_buf[r]'th tree) and returns the longest-match position
-+ and length via the global variables match_position and match_length.
-+ If match_length = F, then removes the old node in favor of the new
-+ one, because the old one will be deleted sooner.
-+ Note r plays double role, as tree node and position in buffer. */
-+{
-+ unsigned long i, p, c;
-+ signed long cmp;
-+ unsigned char *key;
-+
-+ cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
-+ rson[r] = lson[r] = NIL; match_length = 0;
-+ for ( ; ; ) {
-+ if (cmp >= 0) {
-+ if (rson[p] != NIL) p = rson[p];
-+ else { rson[p] = r; dad[r] = p; return; }
-+ } else {
-+ if (lson[p] != NIL) p = lson[p];
-+ else { lson[p] = r; dad[r] = p; return; }
-+ }
-+ for (i = 1; i < F; i++)
-+ if ((cmp = key[i] - text_buf[p + i]) != 0) break;
-+ if (i > THRESHOLD) {
-+ if (i > match_length) {
-+ match_position = ((r - p) & (N - 1)) - 1;
-+ if ((match_length = i) >= F) break;
-+ }
-+ if (i == match_length) {
-+ if ((c = ((r - p) & (N - 1)) - 1) < match_position) {
-+ match_position = c;
-+ }
-+ }
-+ }
-+ }
-+ dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
-+ dad[lson[p]] = r; dad[rson[p]] = r;
-+ if (rson[dad[p]] == p) rson[dad[p]] = r;
-+ else lson[dad[p]] = r;
-+ dad[p] = NIL; /* remove p */
-+}
-+
-+static void DeleteNode(unsigned long p) /* deletes node p from tree */
-+{
-+ unsigned long q;
-+
-+ if (dad[p] == NIL) return; /* not in tree */
-+ if (rson[p] == NIL) q = lson[p];
-+ else if (lson[p] == NIL) q = rson[p];
-+ else {
-+ q = lson[p];
-+ if (rson[q] != NIL) {
-+ do { q = rson[q]; } while (rson[q] != NIL);
-+ rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
-+ lson[q] = lson[p]; dad[lson[p]] = q;
-+ }
-+ rson[q] = rson[p]; dad[rson[p]] = q;
-+ }
-+ dad[q] = dad[p];
-+ if (rson[dad[p]] == p) rson[dad[p]] = q; else lson[dad[p]] = q;
-+ dad[p] = NIL;
-+}
-+
-+/* Huffman coding */
-+
-+#define N_CHAR (256 - THRESHOLD + F)
-+ /* kinds of characters (character code = 0..N_CHAR-1) */
-+#define T (N_CHAR * 2 - 1) /* size of table */
-+#define R (T - 1) /* position of root */
-+#define MAX_FREQ 0x8000 /* updates tree when the */
-+ /* root frequency comes to this value. */
-+
-+typedef unsigned long uchar; // much-much faster
-+
-+/* table for encoding and decoding the upper 6 bits of position */
-+
-+/* for encoding */
-+static uchar p_len[64] = {
-+ 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
-+};
-+
-+static uchar p_code[64] = {
-+ 0x00, 0x20, 0x30, 0x40, 0x50, 0x58, 0x60, 0x68,
-+ 0x70, 0x78, 0x80, 0x88, 0x90, 0x94, 0x98, 0x9C,
-+ 0xA0, 0xA4, 0xA8, 0xAC, 0xB0, 0xB4, 0xB8, 0xBC,
-+ 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE,
-+ 0xD0, 0xD2, 0xD4, 0xD6, 0xD8, 0xDA, 0xDC, 0xDE,
-+ 0xE0, 0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEC, 0xEE,
-+ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
-+ 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
-+};
-+
-+/* for decoding */
-+static uchar d_code[256] = {
-+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-+ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
-+ 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
-+ 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
-+ 0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D,
-+ 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
-+ 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11,
-+ 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
-+ 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15,
-+ 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
-+ 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B,
-+ 0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F,
-+ 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23,
-+ 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
-+ 0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B,
-+ 0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F,
-+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
-+ 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
-+};
-+
-+static uchar d_len[256] = {
-+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
-+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
-+};
-+
-+static unsigned long freq[T + 1]; /* frequency table */
-+
-+static unsigned long prnt[T + N_CHAR]; /* pointers to parent nodes, except for the */
-+ /* elements [T..T + N_CHAR - 1] which are used to get */
-+ /* the positions of leaves corresponding to the codes. */
-+
-+static unsigned long son[T]; /* pointers to child nodes (son[], son[] + 1) */
-+
-+/* initialization of tree */
-+
-+static void StartHuff(void)
-+{
-+ unsigned long i, j;
-+
-+ for (i = 0; i < N_CHAR; i++) {
-+ freq[i] = 1;
-+ son[i] = i + T;
-+ prnt[i + T] = i;
-+ }
-+ i = 0; j = N_CHAR;
-+ while (j <= R) {
-+ freq[j] = freq[i] + freq[i + 1];
-+ son[j] = i;
-+ prnt[i] = prnt[i + 1] = j;
-+ i += 2; j++;
-+ }
-+ freq[T] = 0xffff;
-+ prnt[R] = 0;
-+}
-+
-+/* reconstruction of tree */
-+
-+static void reconst(void)
-+{
-+ unsigned long f, l, i, j, k;
-+
-+ /* collect leaf nodes in the first half of the table */
-+ /* and replace the freq by (freq + 1) / 2. */
-+ j = 0;
-+ for (i = 0; i < T; i++) {
-+ if (son[i] >= T) {
-+ freq[j] = (freq[i] + 1) / 2;
-+ son[j] = son[i];
-+ j++;
-+ }
-+ }
-+ /* begin constructing tree by connecting sons */
-+ for (i = 0, j = N_CHAR; j < T; i += 2, j++) {
-+ k = i + 1;
-+ f = freq[j] = freq[i] + freq[k];
-+ for (k = j - 1; f < freq[k]; k--);
-+ k++;
-+ l = (j - k) * 2;
-+ memmove(&freq[k + 1], &freq[k], l*sizeof(unsigned long));
-+ freq[k] = f;
-+ memmove(&son[k + 1], &son[k], l*sizeof(unsigned long));
-+ son[k] = i;
-+ }
-+ /* connect prnt */
-+ for (i = 0; i < T; i++) {
-+ if ((k = son[i]) >= T) {
-+ prnt[k] = i;
-+ } else {
-+ prnt[k] = prnt[k + 1] = i;
-+ }
-+ }
-+}
-+
-+/* increment frequency of given code by one, and update tree */
-+
-+static void update(unsigned long c)
-+{
-+ unsigned long i, j, k, l;
-+
-+ if (freq[R] == MAX_FREQ) {
-+ reconst();
-+ }
-+ c = prnt[c + T];
-+ do {
-+ k = ++freq[c];
-+
-+ /* if the order is disturbed, exchange nodes */
-+ if (k > freq[l = c + 1]) {
-+ while (k > freq[++l]);
-+ l--;
-+ freq[c] = freq[l];
-+ freq[l] = k;
-+
-+ i = son[c];
-+ prnt[i] = l;
-+ if (i < T) prnt[i + 1] = l;
-+
-+ j = son[l];
-+ son[l] = i;
-+
-+ prnt[j] = c;
-+ if (j < T) prnt[j + 1] = c;
-+ son[c] = j;
-+
-+ c = l;
-+ }
-+ } while (c = prnt[c]); /* repeat up to root */
-+}
-+
-+/* modified for block compression */
-+/* on return, srclen will contain the number of successfully compressed bytes
-+ and dstlen will contain completed compressed bytes */
-+
-+static int Encode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long *srclen,
-+ unsigned long *dstlen)
-+{
-+ unsigned long c, i, j, k, len, r, s, last_match_length, code_buf_ptr;
-+ unsigned char code_buf[17], mask;
-+ unsigned char *ip, *op;
-+ unsigned long written = 0;
-+ unsigned long read = 0;
-+ unsigned short putbuf = 0;
-+ uchar putlen = 0;
-+ unsigned char *srcend = srcbuf + *srclen;
-+ unsigned char *dstend = dstbuf + *dstlen;
-+ ip = srcbuf;
-+ op = dstbuf;
-+ StartHuff();
-+ InitTree(); /* initialize trees */
-+ code_buf[0] = 0; /* code_buf[1..16] saves eight units of code, and
-+ code_buf[0] works as eight flags, "1" representing that the unit
-+ is an unencoded letter (1 byte), "0" a position-and-length pair
-+ (2 bytes). Thus, eight units require at most 16 bytes of code. */
-+ code_buf_ptr = mask = 1;
-+ s = 0; r = N - F;
-+ for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
-+ any character that will appear often. */
-+ for (len = 0; (len < F) && (ip < srcend); len++)
-+ text_buf[r + len] = *(ip++); /* Read F bytes into the last F bytes of
-+ the buffer */
-+ read = len;
-+ for (i = 1; i <= F; i++) InsertNode(r - i); /* Insert the F strings,
-+ each of which begins with one or more 'space' characters. Note
-+ the order in which these strings are inserted. This way,
-+ degenerate trees will be less likely to occur. */
-+ InsertNode(r); /* Finally, insert the whole string just read. The
-+ global variables match_length and match_position are set. */
-+ do {
-+ if (match_length > len) match_length = len; /* match_length
-+ may be spuriously long near the end of text. */
-+ if (match_length <= THRESHOLD) {
-+ match_length = 1; /* Not long enough match. Send one byte. */
-+ c = text_buf[r];
-+ i = 0; j = 0; k = prnt[c + T];
-+ do {
-+ i >>= 1;
-+ /* if node's address is odd-numbered, choose bigger brother node */
-+ if (k & 1) i |= 0x8000;
-+ j++;
-+ } while ((k = prnt[k]) != R);
-+ putbuf |= i >> putlen;
-+ if ((putlen += j) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf >> 8;
-+ if ((putlen -= 8) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf;
-+ written += 2;
-+ putlen -= 8;
-+ putbuf = i << (j - putlen); /**warm**/
-+ } else {
-+ putbuf <<= 8;
-+ written++;
-+ }
-+ *srclen = read;
-+ }
-+ update(c);
-+ } else {
-+ c = 255 - THRESHOLD + match_length;
-+ i = 0; j = 0; k = prnt[c + T];
-+ do {
-+ i >>= 1;
-+ /* if node's address is odd-numbered, choose bigger brother node */
-+ if (k & 1) i |= 0x8000;
-+ j++;
-+ } while ((k = prnt[k]) != R);
-+ putbuf |= i >> putlen;
-+ if ((putlen += j) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf >> 8;
-+ if ((putlen -= 8) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf;
-+ written += 2;
-+ putlen -= 8;
-+ putbuf = i << (j - putlen); /**warm**/
-+ } else {
-+ putbuf <<= 8;
-+ written++;
-+ }
-+ *srclen = read;
-+ }
-+ update(c);
-+ j = p_len[match_position >> 6];
-+ i = p_code[match_position >> 6] << 8;
-+ putbuf |= i >> putlen;
-+ if ((putlen += j) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf >> 8;
-+ if ((putlen -= 8) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf;
-+ written += 2;
-+ putlen -= 8;
-+ putbuf = i << (j - putlen); /**hot**/
-+ } else {
-+ putbuf <<= 8;
-+ written++;
-+ }
-+ *srclen = read;
-+ }
-+ j = 6;
-+ i = (match_position & 0x3f) << 10;
-+ putbuf |= i >> putlen;
-+ if ((putlen += j) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf >> 8;
-+ if ((putlen -= 8) >= 8) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf;
-+ written += 2;
-+ putlen -= 8;
-+ putbuf = i << (j - putlen); /**hot**/
-+ } else {
-+ putbuf <<= 8;
-+ written++;
-+ }
-+ *srclen = read;
-+ }
-+ }
-+ last_match_length = match_length;
-+ for (i = 0; (i < last_match_length) && (ip < srcend); i++) {
-+ c = *(ip++);
-+ DeleteNode(s);
-+ text_buf[s] = c;
-+ if (s < F - 1)
-+ text_buf[s + N] = c;
-+ s = (s + 1) & (N - 1);
-+ r = (r + 1) & (N - 1);
-+ InsertNode(r);
-+ }
-+ read += i;
-+ while (i++ < last_match_length) {
-+ DeleteNode(s);
-+ s = (s + 1) & (N - 1);
-+ r = (r + 1) & (N - 1);
-+ if (--len) InsertNode(r);
-+ }
-+ } while (len > 0);
-+ if (putlen) {
-+ if (op >= dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ *(op++) = putbuf >> 8;
-+ written++;
-+ *srclen = read;
-+ }
-+ *dstlen = written;
-+ return 0;
-+}
-+
-+static int Decode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long srclen,
-+ unsigned long dstlen) /* Just the reverse of Encode(). */
-+{
-+ unsigned long i, r, j, k, c;
-+ unsigned char *ip, *op;
-+ unsigned char *srcend = srcbuf + srclen;
-+ unsigned char *dstend = dstbuf + dstlen;
-+ unsigned short getbuf = 0;
-+ uchar getlen = 0;
-+ ip = srcbuf;
-+ op = dstbuf;
-+ StartHuff();
-+ for (i = 0; i < N - F; i++) text_buf[i] = ' ';
-+ r = N - F;
-+ while (op < dstend) {
-+ c = son[R];
-+ /* travel from root to leaf, */
-+ /* choosing the smaller child node (son[]) if the read bit is 0, */
-+ /* the bigger (son[]+1} if 1 */
-+ while (c < T) {
-+ while (getlen <= 8) {
-+ unsigned short t;
-+ t = (ip >= srcend) ? 0 : *(ip++);
-+ getbuf |= t << (8 - getlen);
-+ getlen += 8;
-+ }
-+ c += ((signed short)getbuf < 0);
-+ getbuf <<= 1;
-+ getlen--;
-+ c = son[c];
-+ }
-+ c -= T;
-+ update(c);
-+ if (c < 256) {
-+ if (op >= dstend) return -1;
-+ *(op++) = c;
-+ text_buf[r++] = c;
-+ r &= (N - 1);
-+ } else {
-+ j = c - 255 + THRESHOLD;
-+ while (getlen <= 8) {
-+ unsigned short t;
-+ t = (ip >= srcend) ? 0 : *(ip++);
-+ getbuf |= t << (8 - getlen);
-+ getlen += 8;
-+ }
-+ i = getbuf >> 8;
-+ getbuf <<= 8;
-+ getlen -= 8;
-+ c = d_code[i] << 6;
-+ k = d_len[i];
-+ /* read lower 6 bits verbatim */
-+ k -= 2;
-+ while (k--) {
-+ while (getlen <= 8) {
-+ unsigned short t;
-+ t = (ip >= srcend) ? 0 : *(ip++);
-+ getbuf |= t << (8 - getlen);
-+ getlen += 8;
-+ }
-+ i = (i << 1) + ((signed short)getbuf < 0);
-+ getbuf <<= 1;
-+ getlen--;
-+ }
-+ i = c | (i & 0x3F);
-+ i = r - i - 1;
-+ i &= (N - 1);
-+ for (k = 0; k < j; k++) {
-+ c = text_buf[(i + k) & (N - 1)];
-+ if (op >= dstend) return -1;
-+ *(op++) = c;
-+ text_buf[r++] = c;
-+ r &= (N - 1);
-+ }
-+ }
-+ }
-+ return 0;
-+}
-+
-+/* interface to jffs2 bbc follows */
-+
-+#include "jffs2_bbc_framework.h"
-+
-+
-+#define JFFS2_BBC_LZHD_BLOCK_SIGN {0x3a, 0x98, 0xf7, 0xda}
-+
-+static int
-+jffs2_bbc_lzhd_compressor_init (void);
-+
-+static void
-+jffs2_bbc_lzhd_compressor_deinit (void);
-+
-+static int
-+jffs2_bbc_lzhd_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen);
-+
-+static int
-+jffs2_bbc_lzhd_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime);
-+
-+static int
-+jffs2_bbc_lzhd_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen);
-+
-+static char *
-+jffs2_bbc_lzhd_proc_info (void);
-+
-+static int
-+jffs2_bbc_lzhd_proc_command (char *command);
-+
-+struct jffs2_bbc_compressor_type jffs2_bbc_lzhd = {
-+ "lzhd",
-+ 0,
-+ JFFS2_BBC_LZHD_BLOCK_SIGN,
-+ jffs2_bbc_lzhd_compressor_init,
-+ NULL,
-+ NULL,
-+ jffs2_bbc_lzhd_compressor_deinit,
-+ jffs2_bbc_lzhd_compress,
-+ jffs2_bbc_lzhd_estimate,
-+ jffs2_bbc_lzhd_decompress,
-+ jffs2_bbc_lzhd_proc_info,
-+ jffs2_bbc_lzhd_proc_command
-+};
-+
-+static int
-+jffs2_bbc_lzhd_compressor_init (void)
-+{
-+ return 0;
-+}
-+
-+static void
-+jffs2_bbc_lzhd_compressor_deinit (void)
-+{
-+}
-+
-+static int
-+jffs2_bbc_lzhd_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen)
-+{
-+ int retval;
-+ unsigned long dst = *dstlen;
-+ *(output++) = jffs2_bbc_lzhd.block_sign[0];
-+ *(output++) = jffs2_bbc_lzhd.block_sign[1];
-+ dst -= 2;
-+ retval = Encode(input, output, sourcelen, &dst);
-+ dst += 2;
-+ *dstlen = dst;
-+ return retval;
-+}
-+
-+static int
-+jffs2_bbc_lzhd_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime)
-+{
-+ *dstlen = sourcelen * 55 / 100;
-+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 8;
-+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 65 / 10;
-+ return 0;
-+}
-+
-+static int
-+jffs2_bbc_lzhd_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen)
-+{
-+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzhd.block_sign[0] ) ||
-+ ( *(input++) != (unsigned char)jffs2_bbc_lzhd.block_sign[1] )
-+ ) {
-+ return -1;
-+ } else {
-+ return Decode(input, output, sourcelen - 2, dstlen);
-+ }
-+}
-+
-+static char *
-+jffs2_bbc_lzhd_proc_info (void)
-+{
-+ return "Lempel-Ziv-(dynamic) Huffman compression module";
-+}
-+
-+static int
-+jffs2_bbc_lzhd_proc_command (char *command)
-+{
-+ return 0;
-+}
-+
-+struct jffs2_bbc_compressor_type *
-+jffs2_bbc_lzhd_init (int mode)
-+{
-+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzhd) == 0)
-+ {
-+ return &jffs2_bbc_lzhd;
-+ }
-+ else
-+ {
-+ return NULL;
-+ }
-+}
-+
-+void
-+jffs2_bbc_lzhd_deinit (void)
-+{
-+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzhd);
-+}
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_lzo_comp.c linux-mips/fs/jffs2/jffs2_bbc_lzo_comp.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_lzo_comp.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_lzo_comp.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,2435 @@
-+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
-+
-+/*
-+ jffs2_bbc_lzo_comp.c -- LZO1X-1 (and -999) compression module for jffs2
-+ Copyright (C) 2004 Patrik Kluba
-+ Based on the original LZO sources
-+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*/
-+
-+/*
-+ Original copyright notice follows:
-+
-+ lzo1x_9x.c -- implementation of the LZO1X-999 compression algorithm
-+ lzo_ptr.h -- low-level pointer constructs
-+ lzo_swd.ch -- sliding window dictionary
-+ lzoconf.h -- configuration for the LZO real-time data compression library
-+ lzo_mchw.ch -- matching functions using a window
-+ minilzo.c -- mini subset of the LZO real-time data compression library
-+ config1x.h -- configuration for the LZO1X algorithm
-+ lzo1x.h -- public interface of the LZO1X compression algorithm
-+
-+ These files are part of the LZO real-time data compression library.
-+
-+ Copyright (C) 1996-2002 Markus Franz Xaver Johannes Oberhumer
-+ All Rights Reserved.
-+
-+ The LZO library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU General Public License as
-+ published by the Free Software Foundation; either version 2 of
-+ the License, or (at your option) any later version.
-+
-+ The LZO library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ GNU General Public License for more details.
-+
-+ You should have received a copy of the GNU General Public License
-+ along with the LZO library; see the file COPYING.
-+ If not, write to the Free Software Foundation, Inc.,
-+ 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-+
-+ Markus F.X.J. Oberhumer
-+ <markus@oberhumer.com>
-+*/
-+
-+/*
-+
-+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
-+ Initial release
-+ -removed all 16 bit code
-+ -all sensitive data will be on 4 byte boundary
-+ -removed check parts for library use
-+ -removed all but LZO1X-* compression
-+
-+*/
-+
-+#ifndef __KERNEL__
-+ #include <sys/types.h>
-+ #include <stddef.h>
-+ #include <string.h>
-+ #include <limits.h>
-+#else
-+ #include <linux/kernel.h>
-+ #include <linux/types.h>
-+ #include <linux/stddef.h>
-+ #include <linux/string.h>
-+ #define USHRT_MAX 65535
-+ /* #define UINT_MAX 4294967295U */
-+#endif
-+
-+/* data type definitions */
-+#define U32 unsigned long
-+#define S32 signed long
-+#define I32 long
-+#define U16 unsigned short
-+#define S16 signed short
-+#define I16 short
-+#define U8 unsigned char
-+#define S8 signed char
-+#define I8 char
-+
-+/*************************************/
-+
-+/* lzo_swd.ch */
-+
-+#define SWD_N N
-+#define SWD_F F
-+#define SWD_THRESHOLD THRESHOLD
-+
-+/* shortest unsigned int that 2 * SWD_F + SWD_N (currently 53248) fits in */
-+typedef unsigned short swd_uint;
-+/* upper limit of that data type */
-+#define SWD_UINT_MAX USHRT_MAX
-+
-+/* minilzo.c */
-+
-+#define LZO_VERSION_DATE "Jul 12 2002"
-+#define LZO_VERSION_STRING "1.08"
-+#define LZO_VERSION 0x1080
-+
-+/* lzo_ptr.h */
-+
-+/* Integral types that have *exactly* the same number of bits as a lzo_voidp */
-+typedef unsigned long lzo_ptr_t;
-+typedef long lzo_sptr_t;
-+
-+
-+/*************************************/
-+
-+/* config1x.h */
-+
-+#define M1_MAX_OFFSET 0x0400
-+#define M2_MAX_OFFSET 0x0800
-+#define M3_MAX_OFFSET 0x4000
-+#define M4_MAX_OFFSET 0xbfff
-+
-+#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)
-+
-+#define M1_MIN_LEN 2
-+#define M1_MAX_LEN 2
-+#define M2_MIN_LEN 3
-+#define M2_MAX_LEN 8
-+#define M3_MIN_LEN 3
-+#define M3_MAX_LEN 33
-+#define M4_MIN_LEN 3
-+#define M4_MAX_LEN 9
-+
-+#define M1_MARKER 0
-+#define M2_MARKER 64
-+#define M3_MARKER 32
-+#define M4_MARKER 16
-+
-+#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
-+
-+/* minilzo.c */
-+
-+#define LZO_BYTE(x) ((unsigned char) ((x) & 0xff))
-+
-+#define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b))
-+#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b))
-+#define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))
-+#define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))
-+
-+#define lzo_sizeof(type) ((lzo_uint) (sizeof(type)))
-+
-+#define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array))))
-+
-+#define LZO_SIZE(bits) (1u << (bits))
-+#define LZO_MASK(bits) (LZO_SIZE(bits) - 1)
-+
-+#define LZO_LSIZE(bits) (1ul << (bits))
-+#define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1)
-+
-+#define LZO_USIZE(bits) ((lzo_uint) 1 << (bits))
-+#define LZO_UMASK(bits) (LZO_USIZE(bits) - 1)
-+
-+#define LZO_STYPE_MAX(b) (((1l << (8*(b)-2)) - 1l) + (1l << (8*(b)-2)))
-+#define LZO_UTYPE_MAX(b) (((1ul << (8*(b)-1)) - 1ul) + (1ul << (8*(b)-1)))
-+
-+#define _LZO_STRINGIZE(x) #x
-+#define _LZO_MEXPAND(x) _LZO_STRINGIZE(x)
-+
-+#define _LZO_CONCAT2(a,b) a ## b
-+#define _LZO_CONCAT3(a,b,c) a ## b ## c
-+#define _LZO_CONCAT4(a,b,c,d) a ## b ## c ## d
-+#define _LZO_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
-+
-+#define _LZO_ECONCAT2(a,b) _LZO_CONCAT2(a,b)
-+#define _LZO_ECONCAT3(a,b,c) _LZO_CONCAT3(a,b,c)
-+#define _LZO_ECONCAT4(a,b,c,d) _LZO_CONCAT4(a,b,c,d)
-+#define _LZO_ECONCAT5(a,b,c,d,e) _LZO_CONCAT5(a,b,c,d,e)
-+
-+#define lzo_dict_t const lzo_bytep
-+#define lzo_dict_p lzo_dict_t *
-+#define lzo_moff_t lzo_uint
-+
-+#define MEMCPY8_DS(dest,src,len) \
-+ memcpy(dest,src,len); \
-+ dest += len; \
-+ src += len
-+
-+#define MEMCPY_DS(dest,src,len) \
-+ do *dest++ = *src++; \
-+ while (--len > 0)
-+
-+#define MEMMOVE_DS(dest,src,len) \
-+ do *dest++ = *src++; \
-+ while (--len > 0)
-+
-+#define BZERO8_PTR(s,l,n) memset((s),0,(lzo_uint)(l)*(n))
-+
-+#define LZO_BASE 65521u
-+#define LZO_NMAX 5552
-+
-+#define LZO_DO1(buf,i) {s1 += buf[i]; s2 += s1;}
-+#define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1);
-+#define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2);
-+#define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4);
-+#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8);
-+
-+#define IS_SIGNED(type) (((type) (-1)) < ((type) 0))
-+#define IS_UNSIGNED(type) (((type) (-1)) > ((type) 0))
-+
-+#define IS_POWER_OF_2(x) (((x) & ((x) - 1)) == 0)
-+
-+#define D_BITS 14
-+#define D_INDEX1(d,p) d = DM((0x21*DX3(p,5,5,6)) >> 5)
-+#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
-+
-+#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B
-+
-+#define DL_MIN_LEN M2_MIN_LEN
-+
-+#define D_SIZE LZO_SIZE(D_BITS)
-+#define D_MASK LZO_MASK(D_BITS)
-+
-+#define D_HIGH ((D_MASK >> 1) + 1)
-+
-+#define DINDEX1 D_INDEX1
-+#define DINDEX2 D_INDEX2
-+
-+#define DX2(p,s1,s2) \
-+ (((((lzo_uint32)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0])
-+
-+#define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0])
-+#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s)))
-+#define DM(v) DMS(v,0)
-+
-+#define DENTRY(p,in) (p)
-+#define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex]
-+
-+#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
-+ (m_pos == NULL || (m_off = (lzo_moff_t) (ip - m_pos)) > max_offset)
-+
-+#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
-+ (BOUNDS_CHECKING_OFF_IN_EXPR( \
-+ (PTR_LT(m_pos,in) || \
-+ (m_off = (lzo_moff_t) PTR_DIFF(ip,m_pos)) <= 0 || \
-+ m_off > max_offset) ))
-+
-+#define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr)
-+
-+#define DD_BITS 0
-+#define DD_SIZE LZO_SIZE(DD_BITS)
-+#define DD_MASK LZO_MASK(DD_BITS)
-+
-+#define DL_BITS (D_BITS - DD_BITS)
-+#define DL_SIZE LZO_SIZE(DL_BITS)
-+#define DL_MASK LZO_MASK(DL_BITS)
-+
-+#define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in)
-+#define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in)
-+#define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in)
-+
-+#define __COPY4(dst,src) * (lzo_uint32p)(dst) = * (const lzo_uint32p)(src)
-+#define COPY4(dst,src) __COPY4((lzo_ptr_t)(dst),(lzo_ptr_t)(src))
-+
-+#define TEST_IP (ip < ip_end)
-+#define TEST_OP (op <= op_end)
-+
-+#define NEED_IP(x) \
-+ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
-+#define NEED_OP(x) \
-+ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
-+#define TEST_LOOKBEHIND(m_pos,out) if (m_pos < out) goto lookbehind_overrun
-+
-+/* lzo1x_9x.c */
-+
-+#define LZO_UINT_MAX UINT_MAX
-+#define N M4_MAX_OFFSET
-+#define THRESHOLD 1
-+#define F 2048
-+
-+#define SWD_BEST_OFF (LZO_MAX3( M2_MAX_LEN, M3_MAX_LEN, M4_MAX_LEN ) + 1)
-+
-+/* ../include/lzoconf.h */
-+
-+typedef U32 lzo_uint32;
-+typedef I32 lzo_int32;
-+typedef U32 lzo_uint;
-+typedef I32 lzo_int;
-+typedef int lzo_bool;
-+
-+#define lzo_byte U8
-+#define lzo_bytep U8 *
-+#define lzo_charp char *
-+#define lzo_voidp void *
-+#define lzo_shortp short *
-+#define lzo_ushortp unsigned short *
-+#define lzo_uint32p lzo_uint32 *
-+#define lzo_int32p lzo_int32 *
-+#define lzo_uintp lzo_uint *
-+#define lzo_intp lzo_int *
-+#define lzo_voidpp lzo_voidp *
-+#define lzo_bytepp lzo_bytep *
-+#define lzo_sizeof_dict_t sizeof(lzo_bytep)
-+
-+#define LZO_E_OK 0
-+#define LZO_E_ERROR (-1)
-+#define LZO_E_OUT_OF_MEMORY (-2) /* not used right now */
-+#define LZO_E_NOT_COMPRESSIBLE (-3) /* not used right now */
-+#define LZO_E_INPUT_OVERRUN (-4)
-+#define LZO_E_OUTPUT_OVERRUN (-5)
-+#define LZO_E_LOOKBEHIND_OVERRUN (-6)
-+#define LZO_E_EOF_NOT_FOUND (-7)
-+#define LZO_E_INPUT_NOT_CONSUMED (-8)
-+
-+#define LZO_PTR_ALIGN_UP(_ptr,_size) \
-+ ((_ptr) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(_ptr),(lzo_uint)(_size)))
-+#define LZO_ALIGN(_ptr,_size) LZO_PTR_ALIGN_UP(_ptr,_size)
-+
-+typedef int
-+ (*lzo_compress_t) (const lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem);
-+
-+typedef int
-+ (*lzo_decompress_t) (const lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem);
-+
-+typedef int
-+ (*lzo_optimize_t) (lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem);
-+
-+typedef int
-+ (*lzo_compress_dict_t) (const lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem,
-+ const lzo_byte * dict, lzo_uint dict_len);
-+
-+typedef int
-+ (*lzo_decompress_dict_t) (const lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem,
-+ const lzo_byte * dict, lzo_uint dict_len);
-+
-+typedef int
-+ (*lzo_compress_asm_t) (const lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem);
-+
-+typedef int
-+ (*lzo_decompress_asm_t) (const lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len,
-+ lzo_voidp wrkmem);
-+
-+typedef void (*lzo_progress_callback_t) (lzo_uint, lzo_uint);
-+
-+typedef union
-+{
-+ lzo_bytep p;
-+ lzo_uint u;
-+} __lzo_pu_u;
-+typedef union
-+{
-+ lzo_bytep p;
-+ lzo_uint32 u32;
-+} __lzo_pu32_u;
-+typedef union
-+{
-+ void *vp;
-+ lzo_bytep bp;
-+ lzo_uint32 u32;
-+ long l;
-+} lzo_align_t;
-+
-+/* lzo1x.h */
-+
-+#define LZO1X_1_MEM_COMPRESS ((lzo_uint32) (16384L * lzo_sizeof_dict_t))
-+#define LZO1X_999_MEM_COMPRESS ((lzo_uint32) (14 * 16384L * sizeof(short)))
-+
-+/* lzo_ptr.h */
-+
-+#define PTR(a) ((lzo_ptr_t) (a))
-+#define PTR_LINEAR(a) PTR(a)
-+#define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0)
-+#define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0)
-+#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)
-+#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)
-+#define PTR_LT(a,b) (PTR(a) < PTR(b))
-+#define PTR_GE(a,b) (PTR(a) >= PTR(b))
-+#define PTR_DIFF(a,b) ((lzo_ptrdiff_t) (PTR(a) - PTR(b)))
-+#define pd(a,b) ((lzo_uint) ((a)-(b)))
-+
-+typedef ptrdiff_t lzo_ptrdiff_t;
-+
-+typedef union
-+{
-+ char a_char;
-+ unsigned char a_uchar;
-+ short a_short;
-+ unsigned short a_ushort;
-+ int a_int;
-+ unsigned int a_uint;
-+ long a_long;
-+ unsigned long a_ulong;
-+ lzo_int a_lzo_int;
-+ lzo_uint a_lzo_uint;
-+ lzo_int32 a_lzo_int32;
-+ lzo_uint32 a_lzo_uint32;
-+ ptrdiff_t a_ptrdiff_t;
-+ lzo_ptrdiff_t a_lzo_ptrdiff_t;
-+ lzo_ptr_t a_lzo_ptr_t;
-+ lzo_voidp a_lzo_voidp;
-+ void *a_void_p;
-+ lzo_bytep a_lzo_bytep;
-+ lzo_bytepp a_lzo_bytepp;
-+ lzo_uintp a_lzo_uintp;
-+ lzo_uint *a_lzo_uint_p;
-+ lzo_uint32p a_lzo_uint32p;
-+ lzo_uint32 *a_lzo_uint32_p;
-+ unsigned char *a_uchar_p;
-+ char *a_char_p;
-+}
-+lzo_full_align_t;
-+
-+/* lzo_mchw.ch */
-+
-+typedef struct
-+{
-+ int init;
-+
-+ lzo_uint look;
-+
-+ lzo_uint m_len;
-+ lzo_uint m_off;
-+
-+ lzo_uint last_m_len;
-+ lzo_uint last_m_off;
-+
-+ const lzo_byte *bp;
-+ const lzo_byte *ip;
-+ const lzo_byte *in;
-+ const lzo_byte *in_end;
-+ lzo_byte *out;
-+
-+ lzo_progress_callback_t cb;
-+
-+ lzo_uint textsize;
-+ lzo_uint codesize;
-+ lzo_uint printcount;
-+
-+ unsigned long lit_bytes;
-+ unsigned long match_bytes;
-+ unsigned long rep_bytes;
-+ unsigned long lazy;
-+
-+ lzo_uint r1_lit;
-+ lzo_uint r1_m_len;
-+
-+ unsigned long m1a_m, m1b_m, m2_m, m3_m, m4_m;
-+ unsigned long lit1_r, lit2_r, lit3_r;
-+}
-+lzo1x_999_t;
-+
-+#define getbyte(c) ((c).ip < (c).in_end ? *((c).ip)++ : (-1))
-+
-+/* lzo_swd.ch */
-+
-+#define SWD_UINT(x) ((swd_uint)(x))
-+#define SWD_HSIZE 16384
-+#define SWD_MAX_CHAIN 2048
-+#define HEAD3(b,p) \
-+ (((0x9f5f*(((((lzo_uint32)b[p]<<5)^b[p+1])<<5)^b[p+2]))>>5) & (SWD_HSIZE-1))
-+#define HEAD2(b,p) (b[p] ^ ((unsigned)b[p+1]<<8))
-+#define NIL2 SWD_UINT_MAX
-+
-+typedef struct
-+{
-+ lzo_uint n;
-+ lzo_uint f;
-+ lzo_uint threshold;
-+
-+ lzo_uint max_chain;
-+ lzo_uint nice_length;
-+ lzo_bool use_best_off;
-+ lzo_uint lazy_insert;
-+
-+ lzo_uint m_len;
-+ lzo_uint m_off;
-+ lzo_uint look;
-+ int b_char;
-+
-+ lzo_uint best_off[SWD_BEST_OFF];
-+
-+ lzo1x_999_t *c;
-+ lzo_uint m_pos;
-+
-+ lzo_uint best_pos[SWD_BEST_OFF];
-+
-+ const lzo_byte *dict;
-+ const lzo_byte *dict_end;
-+ lzo_uint dict_len;
-+
-+ lzo_uint ip;
-+ lzo_uint bp;
-+ lzo_uint rp;
-+ lzo_uint b_size;
-+
-+ unsigned char *b_wrap;
-+
-+ lzo_uint node_count;
-+ lzo_uint first_rp;
-+
-+ unsigned char b[SWD_N + SWD_F + SWD_F];
-+ swd_uint head3[SWD_HSIZE];
-+ swd_uint succ3[SWD_N + SWD_F];
-+ swd_uint best3[SWD_N + SWD_F];
-+ swd_uint llen3[SWD_HSIZE];
-+
-+ swd_uint head2[65536L];
-+}
-+lzo1x_999_swd_t;
-+
-+#define s_head3(s,key) s->head3[key]
-+#define swd_pos2off(s,pos) \
-+ (s->bp > (pos) ? s->bp - (pos) : s->b_size - ((pos) - s->bp))
-+
-+static __inline__ void
-+swd_getbyte (lzo1x_999_swd_t * s)
-+{
-+ int c;
-+
-+ if ((c = getbyte (*(s->c))) < 0)
-+ {
-+ if (s->look > 0)
-+ --s->look;
-+ }
-+ else
-+ {
-+ s->b[s->ip] = LZO_BYTE (c);
-+ if (s->ip < s->f)
-+ s->b_wrap[s->ip] = LZO_BYTE (c);
-+ }
-+ if (++s->ip == s->b_size)
-+ s->ip = 0;
-+ if (++s->bp == s->b_size)
-+ s->bp = 0;
-+ if (++s->rp == s->b_size)
-+ s->rp = 0;
-+}
-+
-+static void
-+swd_initdict (lzo1x_999_swd_t * s, const lzo_byte * dict, lzo_uint dict_len)
-+{
-+ s->dict = s->dict_end = NULL;
-+ s->dict_len = 0;
-+
-+ if (!dict || dict_len <= 0)
-+ return;
-+ if (dict_len > s->n)
-+ {
-+ dict += dict_len - s->n;
-+ dict_len = s->n;
-+ }
-+
-+ s->dict = dict;
-+ s->dict_len = dict_len;
-+ s->dict_end = dict + dict_len;
-+ memcpy (s->b, dict, dict_len);
-+ s->ip = dict_len;
-+}
-+
-+static void
-+swd_insertdict (lzo1x_999_swd_t * s, lzo_uint node, lzo_uint len)
-+{
-+ lzo_uint key;
-+
-+ s->node_count = s->n - len;
-+ s->first_rp = node;
-+
-+ while (len-- > 0)
-+ {
-+ key = HEAD3 (s->b, node);
-+ s->succ3[node] = s_head3 (s, key);
-+ s->head3[key] = SWD_UINT (node);
-+ s->best3[node] = SWD_UINT (s->f + 1);
-+ s->llen3[key]++;
-+
-+ key = HEAD2 (s->b, node);
-+ s->head2[key] = SWD_UINT (node);
-+
-+ node++;
-+ }
-+}
-+
-+static int
-+swd_init (lzo1x_999_swd_t * s, const lzo_byte * dict, lzo_uint dict_len)
-+{
-+
-+ s->n = SWD_N;
-+ s->f = SWD_F;
-+ s->threshold = SWD_THRESHOLD;
-+
-+
-+
-+ s->max_chain = SWD_MAX_CHAIN;
-+ s->nice_length = SWD_F;
-+ s->use_best_off = 0;
-+ s->lazy_insert = 0;
-+
-+ s->b_size = s->n + s->f;
-+ if (2 * s->f >= s->n || s->b_size + s->f >= NIL2)
-+ return LZO_E_ERROR;
-+ s->b_wrap = s->b + s->b_size;
-+ s->node_count = s->n;
-+
-+ memset (s->llen3, 0, sizeof (s->llen3[0]) * SWD_HSIZE);
-+ memset (s->head2, 0xff, sizeof (s->head2[0]) * 65536L);
-+
-+ s->ip = 0;
-+ swd_initdict (s, dict, dict_len);
-+ s->bp = s->ip;
-+ s->first_rp = s->ip;
-+
-+ s->look = (lzo_uint) (s->c->in_end - s->c->ip);
-+ if (s->look > 0)
-+ {
-+ if (s->look > s->f)
-+ s->look = s->f;
-+ memcpy (&s->b[s->ip], s->c->ip, s->look);
-+ s->c->ip += s->look;
-+ s->ip += s->look;
-+ }
-+
-+ if (s->ip == s->b_size)
-+ s->ip = 0;
-+
-+ if (s->look >= 2 && s->dict_len > 0)
-+ swd_insertdict (s, 0, s->dict_len);
-+
-+ s->rp = s->first_rp;
-+ if (s->rp >= s->node_count)
-+ s->rp -= s->node_count;
-+ else
-+ s->rp += s->b_size - s->node_count;
-+
-+ return LZO_E_OK;
-+}
-+
-+static __inline__ void
-+swd_remove_node (lzo1x_999_swd_t * s, lzo_uint node)
-+{
-+ if (s->node_count == 0)
-+ {
-+ lzo_uint key;
-+
-+ key = HEAD3 (s->b, node);
-+
-+ --s->llen3[key];
-+
-+ key = HEAD2 (s->b, node);
-+
-+ if ((lzo_uint) s->head2[key] == node)
-+ s->head2[key] = NIL2;
-+ }
-+ else
-+ --s->node_count;
-+}
-+
-+static void
-+swd_accept (lzo1x_999_swd_t * s, lzo_uint n)
-+{
-+
-+ while (n--)
-+ {
-+ lzo_uint key;
-+
-+ swd_remove_node (s, s->rp);
-+
-+ key = HEAD3 (s->b, s->bp);
-+ s->succ3[s->bp] = s_head3 (s, key);
-+ s->head3[key] = SWD_UINT (s->bp);
-+ s->best3[s->bp] = SWD_UINT (s->f + 1);
-+ s->llen3[key]++;
-+
-+ key = HEAD2 (s->b, s->bp);
-+ s->head2[key] = SWD_UINT (s->bp);;
-+
-+ swd_getbyte (s);
-+ }
-+}
-+
-+static void
-+swd_search (lzo1x_999_swd_t * s, lzo_uint node, lzo_uint cnt)
-+{
-+ const unsigned char *p1;
-+ const unsigned char *p2;
-+ const unsigned char *px;
-+
-+ lzo_uint m_len = s->m_len;
-+ const unsigned char *b = s->b;
-+ const unsigned char *bp = s->b + s->bp;
-+ const unsigned char *bx = s->b + s->bp + s->look;
-+ unsigned char scan_end1;
-+
-+ scan_end1 = bp[m_len - 1];
-+ for (; cnt-- > 0; node = s->succ3[node])
-+ {
-+ p1 = bp;
-+ p2 = b + node;
-+ px = bx;
-+
-+ if (p2[m_len - 1] == scan_end1 &&
-+ p2[m_len] == p1[m_len] &&
-+ p2[0] == p1[0] && p2[1] == p1[1])
-+ {
-+ lzo_uint i;
-+
-+ p1 += 2;
-+ p2 += 2;
-+ do
-+ {
-+ }
-+ while (++p1 < px && *p1 == *++p2);
-+
-+ i = p1 - bp;
-+
-+ if (i < SWD_BEST_OFF)
-+ {
-+ if (s->best_pos[i] == 0)
-+ s->best_pos[i] = node + 1;
-+ }
-+
-+ if (i > m_len)
-+ {
-+ s->m_len = m_len = i;
-+ s->m_pos = node;
-+ if (m_len == s->look)
-+ return;
-+ if (m_len >= s->nice_length)
-+ return;
-+ if (m_len > (lzo_uint) s->best3[node])
-+ return;
-+ scan_end1 = bp[m_len - 1];
-+ }
-+ }
-+ }
-+}
-+
-+static lzo_bool
-+swd_search2 (lzo1x_999_swd_t * s)
-+{
-+ lzo_uint key;
-+
-+ key = s->head2[HEAD2 (s->b, s->bp)];
-+ if (key == NIL2)
-+ return 0;
-+
-+ if (s->best_pos[2] == 0)
-+ s->best_pos[2] = key + 1;
-+
-+ if (s->m_len < 2)
-+ {
-+ s->m_len = 2;
-+ s->m_pos = key;
-+ }
-+ return 1;
-+}
-+
-+static void
-+swd_findbest (lzo1x_999_swd_t * s)
-+{
-+ lzo_uint key;
-+ lzo_uint cnt, node;
-+ lzo_uint len;
-+
-+ key = HEAD3 (s->b, s->bp);
-+ node = s->succ3[s->bp] = s_head3 (s, key);
-+ cnt = s->llen3[key]++;
-+
-+ if (cnt > s->max_chain && s->max_chain > 0)
-+ cnt = s->max_chain;
-+ s->head3[key] = SWD_UINT (s->bp);
-+
-+ s->b_char = s->b[s->bp];
-+ len = s->m_len;
-+ if (s->m_len >= s->look)
-+ {
-+ if (s->look == 0)
-+ s->b_char = -1;
-+ s->m_off = 0;
-+ s->best3[s->bp] = SWD_UINT (s->f + 1);
-+ }
-+ else
-+ {
-+
-+ if (swd_search2 (s))
-+
-+ if (s->look >= 3)
-+ swd_search (s, node, cnt);
-+ if (s->m_len > len)
-+ s->m_off = swd_pos2off (s, s->m_pos);
-+ s->best3[s->bp] = SWD_UINT (s->m_len);
-+
-+ if (s->use_best_off)
-+ {
-+ int i;
-+ for (i = 2; i < SWD_BEST_OFF; i++)
-+ if (s->best_pos[i] > 0)
-+ s->best_off[i] =
-+ swd_pos2off (s,
-+ s->best_pos[i] -
-+ 1);
-+ else
-+ s->best_off[i] = 0;
-+ }
-+
-+ }
-+
-+ swd_remove_node (s, s->rp);
-+
-+ key = HEAD2 (s->b, s->bp);
-+ s->head2[key] = SWD_UINT (s->bp);
-+
-+}
-+
-+/* lzo_mchw.ch */
-+
-+static int
-+init_match (lzo1x_999_t * c, lzo1x_999_swd_t * s,
-+ const lzo_byte * dict, lzo_uint dict_len, lzo_uint32 flags)
-+{
-+ int r;
-+
-+ c->init = 1;
-+
-+ s->c = c;
-+
-+ c->last_m_len = c->last_m_off = 0;
-+
-+ c->textsize = c->codesize = c->printcount = 0;
-+ c->lit_bytes = c->match_bytes = c->rep_bytes = 0;
-+ c->lazy = 0;
-+
-+ r = swd_init (s, dict, dict_len);
-+ if (r != 0)
-+ return r;
-+
-+ s->use_best_off = (flags & 1) ? 1 : 0;
-+ return r;
-+}
-+
-+static int
-+find_match (lzo1x_999_t * c, lzo1x_999_swd_t * s,
-+ lzo_uint this_len, lzo_uint skip)
-+{
-+ if (skip > 0)
-+ {
-+ swd_accept (s, this_len - skip);
-+ c->textsize += this_len - skip + 1;
-+ }
-+ else
-+ {
-+ c->textsize += this_len - skip;
-+ }
-+
-+ s->m_len = 1;
-+ s->m_len = 1;
-+
-+ if (s->use_best_off)
-+ memset (s->best_pos, 0, sizeof (s->best_pos));
-+
-+ swd_findbest (s);
-+ c->m_len = s->m_len;
-+ c->m_off = s->m_off;
-+
-+ swd_getbyte (s);
-+
-+ if (s->b_char < 0)
-+ {
-+ c->look = 0;
-+ c->m_len = 0;
-+ }
-+ else
-+ {
-+ c->look = s->look + 1;
-+ }
-+ c->bp = c->ip - c->look;
-+
-+ if (c->cb && c->textsize > c->printcount)
-+ {
-+ (*c->cb) (c->textsize, c->codesize);
-+ c->printcount += 1024;
-+ }
-+
-+ return LZO_E_OK;
-+}
-+
-+/* lzo1x_9x.c */
-+
-+static lzo_byte *
-+code_match (lzo1x_999_t * c, lzo_byte * op, lzo_uint m_len, lzo_uint m_off)
-+{
-+ lzo_uint x_len = m_len;
-+ lzo_uint x_off = m_off;
-+
-+ c->match_bytes += m_len;
-+
-+ if (m_len == 2)
-+ {
-+ m_off -= 1;
-+
-+ *op++ = LZO_BYTE (M1_MARKER | ((m_off & 3) << 2));
-+ *op++ = LZO_BYTE (m_off >> 2);
-+
-+ c->m1a_m++;
-+ }
-+
-+ else if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
-+
-+ {
-+
-+ m_off -= 1;
-+ *op++ = LZO_BYTE (((m_len - 1) << 5) | ((m_off & 7) << 2));
-+ *op++ = LZO_BYTE (m_off >> 3);
-+ c->m2_m++;
-+ }
-+ else if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET
-+ && c->r1_lit >= 4)
-+ {
-+ m_off -= 1 + M2_MAX_OFFSET;
-+
-+ *op++ = LZO_BYTE (M1_MARKER | ((m_off & 3) << 2));
-+ *op++ = LZO_BYTE (m_off >> 2);
-+
-+ c->m1b_m++;
-+ }
-+ else if (m_off <= M3_MAX_OFFSET)
-+ {
-+ m_off -= 1;
-+ if (m_len <= M3_MAX_LEN)
-+ *op++ = LZO_BYTE (M3_MARKER | (m_len - 2));
-+ else
-+ {
-+ m_len -= M3_MAX_LEN;
-+ *op++ = M3_MARKER | 0;
-+ while (m_len > 255)
-+ {
-+ m_len -= 255;
-+ *op++ = 0;
-+ }
-+ *op++ = LZO_BYTE (m_len);
-+ }
-+
-+ *op++ = LZO_BYTE (m_off << 2);
-+ *op++ = LZO_BYTE (m_off >> 6);
-+
-+ c->m3_m++;
-+ }
-+ else
-+ {
-+ lzo_uint k;
-+
-+ m_off -= 0x4000;
-+ k = (m_off & 0x4000) >> 11;
-+ if (m_len <= M4_MAX_LEN)
-+ *op++ = LZO_BYTE (M4_MARKER | k | (m_len - 2));
-+ else
-+ {
-+ m_len -= M4_MAX_LEN;
-+ *op++ = LZO_BYTE (M4_MARKER | k | 0);
-+ while (m_len > 255)
-+ {
-+ m_len -= 255;
-+ *op++ = 0;
-+ }
-+ *op++ = LZO_BYTE (m_len);
-+ }
-+
-+ *op++ = LZO_BYTE (m_off << 2);
-+ *op++ = LZO_BYTE (m_off >> 6);
-+
-+ c->m4_m++;
-+ }
-+
-+ c->last_m_len = x_len;
-+ c->last_m_off = x_off;
-+ return op;
-+}
-+
-+static lzo_byte *
-+STORE_RUN (lzo1x_999_t * c, lzo_byte * op, const lzo_byte * ii, lzo_uint t)
-+{
-+ c->lit_bytes += t;
-+
-+ if (op == c->out && t <= 238)
-+ {
-+ *op++ = LZO_BYTE (17 + t);
-+ }
-+ else if (t <= 3)
-+ {
-+ op[-2] |= LZO_BYTE (t);
-+
-+ c->lit1_r++;
-+ }
-+ else if (t <= 18)
-+ {
-+ *op++ = LZO_BYTE (t - 3);
-+ c->lit2_r++;
-+ }
-+ else
-+ {
-+ lzo_uint tt = t - 18;
-+
-+ *op++ = 0;
-+ while (tt > 255)
-+ {
-+ tt -= 255;
-+ *op++ = 0;
-+ }
-+ *op++ = LZO_BYTE (tt);
-+ c->lit3_r++;
-+ }
-+ do
-+ *op++ = *ii++;
-+ while (--t > 0);
-+
-+ return op;
-+}
-+
-+static lzo_byte *
-+code_run (lzo1x_999_t * c, lzo_byte * op, const lzo_byte * ii,
-+ lzo_uint lit, lzo_uint m_len)
-+{
-+ if (lit > 0)
-+ {
-+ op = STORE_RUN (c, op, ii, lit);
-+ c->r1_m_len = m_len;
-+ c->r1_lit = lit;
-+ }
-+ else
-+ {
-+ c->r1_m_len = 0;
-+ c->r1_lit = 0;
-+ }
-+
-+ return op;
-+}
-+
-+static int
-+len_of_coded_match (lzo_uint m_len, lzo_uint m_off, lzo_uint lit)
-+{
-+ int n = 4;
-+
-+ if (m_len < 2)
-+ return -1;
-+ if (m_len == 2)
-+ return (m_off <= M1_MAX_OFFSET && lit > 0
-+ && lit < 4) ? 2 : -1;
-+ if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
-+ return 2;
-+ if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4)
-+ return 2;
-+ if (m_off <= M3_MAX_OFFSET)
-+ {
-+ if (m_len <= M3_MAX_LEN)
-+ return 3;
-+ m_len -= M3_MAX_LEN;
-+ while (m_len > 255)
-+ {
-+ m_len -= 255;
-+ n++;
-+ }
-+ return n;
-+ }
-+ if (m_off <= M4_MAX_OFFSET)
-+ {
-+ if (m_len <= M4_MAX_LEN)
-+ return 3;
-+ m_len -= M4_MAX_LEN;
-+ while (m_len > 255)
-+ {
-+ m_len -= 255;
-+ n++;
-+ }
-+ return n;
-+ }
-+ return -1;
-+}
-+
-+static lzo_int
-+min_gain (lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, int l1, int l2,
-+ int l3)
-+{
-+ lzo_int lazy_match_min_gain = 0;
-+
-+ lazy_match_min_gain += ahead;
-+
-+ if (lit1 <= 3)
-+ lazy_match_min_gain += (lit2 <= 3) ? 0 : 2;
-+ else if (lit1 <= 18)
-+ lazy_match_min_gain += (lit2 <= 18) ? 0 : 1;
-+
-+ lazy_match_min_gain += (l2 - l1) * 2;
-+ if (l3 > 0)
-+ lazy_match_min_gain -= (ahead - l3) * 2;
-+
-+ if (lazy_match_min_gain < 0)
-+ lazy_match_min_gain = 0;
-+
-+ return lazy_match_min_gain;
-+}
-+
-+static void
-+better_match (const lzo1x_999_swd_t * swd, lzo_uint * m_len, lzo_uint * m_off)
-+{
-+ if (*m_len <= M2_MIN_LEN)
-+ return;
-+
-+ if (*m_off <= M2_MAX_OFFSET)
-+ return;
-+
-+ if (*m_off > M2_MAX_OFFSET &&
-+ *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 &&
-+ swd->best_off[*m_len - 1]
-+ && swd->best_off[*m_len - 1] <= M2_MAX_OFFSET)
-+ {
-+ *m_len = *m_len - 1;
-+ *m_off = swd->best_off[*m_len];
-+ return;
-+ }
-+
-+ if (*m_off > M3_MAX_OFFSET &&
-+ *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 &&
-+ swd->best_off[*m_len - 2]
-+ && swd->best_off[*m_len - 2] <= M2_MAX_OFFSET)
-+ {
-+ *m_len = *m_len - 2;
-+ *m_off = swd->best_off[*m_len];
-+ return;
-+ }
-+
-+ if (*m_off > M3_MAX_OFFSET &&
-+ *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 &&
-+ swd->best_off[*m_len - 1]
-+ && swd->best_off[*m_len - 1] <= M3_MAX_OFFSET)
-+ {
-+ *m_len = *m_len - 1;
-+ *m_off = swd->best_off[*m_len];
-+ }
-+
-+}
-+
-+/* minilzo.c */
-+
-+static lzo_bool
-+lzo_assert (int expr)
-+{
-+ return (expr) ? 1 : 0;
-+}
-+
-+/* lzo1x_9x.c */
-+
-+static int
-+lzo1x_999_compress_internal (const lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len,
-+ lzo_voidp wrkmem,
-+ const lzo_byte * dict, lzo_uint dict_len,
-+ lzo_progress_callback_t cb,
-+ int try_lazy,
-+ lzo_uint good_length,
-+ lzo_uint max_lazy,
-+ lzo_uint nice_length,
-+ lzo_uint max_chain, lzo_uint32 flags)
-+{
-+ lzo_byte *op;
-+ const lzo_byte *ii;
-+ lzo_uint lit;
-+ lzo_uint m_len, m_off;
-+ lzo1x_999_t cc;
-+ lzo1x_999_t *const c = &cc;
-+ lzo1x_999_swd_t *const swd = (lzo1x_999_swd_t *) wrkmem;
-+ int r;
-+
-+ if (!lzo_assert
-+ (LZO1X_999_MEM_COMPRESS >= lzo_sizeof (lzo1x_999_swd_t)))
-+ return LZO_E_ERROR;
-+
-+ if (try_lazy < 0)
-+ try_lazy = 1;
-+
-+ if (good_length <= 0)
-+ good_length = 32;
-+
-+ if (max_lazy <= 0)
-+ max_lazy = 32;
-+
-+ if (nice_length <= 0)
-+ nice_length = 0;
-+
-+ if (max_chain <= 0)
-+ max_chain = SWD_MAX_CHAIN;
-+
-+ c->init = 0;
-+ c->ip = c->in = in;
-+ c->in_end = in + in_len;
-+ c->out = out;
-+ c->cb = cb;
-+ c->m1a_m = c->m1b_m = c->m2_m = c->m3_m = c->m4_m = 0;
-+ c->lit1_r = c->lit2_r = c->lit3_r = 0;
-+
-+ op = out;
-+ ii = c->ip;
-+ lit = 0;
-+ c->r1_lit = c->r1_m_len = 0;
-+
-+ r = init_match (c, swd, dict, dict_len, flags);
-+ if (r != 0)
-+ return r;
-+ if (max_chain > 0)
-+ swd->max_chain = max_chain;
-+ if (nice_length > 0)
-+ swd->nice_length = nice_length;
-+
-+ r = find_match (c, swd, 0, 0);
-+ if (r != 0)
-+ return r;
-+ while (c->look > 0)
-+ {
-+ lzo_uint ahead;
-+ lzo_uint max_ahead;
-+ int l1, l2, l3;
-+
-+ c->codesize = op - out;
-+
-+ m_len = c->m_len;
-+ m_off = c->m_off;
-+
-+ if (lit == 0)
-+ ii = c->bp;
-+
-+ if (m_len < 2 ||
-+ (m_len == 2
-+ && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4))
-+ || (m_len == 2 && op == out) || (op == out && lit == 0))
-+ {
-+
-+ m_len = 0;
-+ }
-+ else if (m_len == M2_MIN_LEN)
-+ {
-+
-+ if (m_off > MX_MAX_OFFSET && lit >= 4)
-+ m_len = 0;
-+ }
-+
-+ if (m_len == 0)
-+ {
-+
-+ lit++;
-+ swd->max_chain = max_chain;
-+ r = find_match (c, swd, 1, 0);
-+ continue;
-+ }
-+
-+ if (swd->use_best_off)
-+ better_match (swd, &m_len, &m_off);
-+
-+ ahead = 0;
-+ if (try_lazy <= 0 || m_len >= max_lazy)
-+ {
-+
-+ l1 = 0;
-+ max_ahead = 0;
-+ }
-+ else
-+ {
-+
-+ l1 = len_of_coded_match (m_len, m_off, lit);
-+
-+ max_ahead = LZO_MIN (try_lazy, l1 - 1);
-+
-+ }
-+
-+ while (ahead < max_ahead && c->look > m_len)
-+ {
-+ lzo_int lazy_match_min_gain;
-+
-+ if (m_len >= good_length)
-+ swd->max_chain = max_chain >> 2;
-+ else
-+ swd->max_chain = max_chain;
-+ r = find_match (c, swd, 1, 0);
-+ ahead++;
-+
-+ if (c->m_len < m_len)
-+ continue;
-+
-+ if (c->m_len == m_len && c->m_off >= m_off)
-+ continue;
-+
-+ if (swd->use_best_off)
-+ better_match (swd, &c->m_len, &c->m_off);
-+
-+ l2 = len_of_coded_match (c->m_len, c->m_off,
-+ lit + ahead);
-+ if (l2 < 0)
-+ continue;
-+
-+ l3 = (op == out) ? -1 : len_of_coded_match (ahead,
-+ m_off,
-+ lit);
-+
-+ lazy_match_min_gain =
-+ min_gain (ahead, lit, lit + ahead, l1, l2,
-+ l3);
-+ if (c->m_len >= m_len + lazy_match_min_gain)
-+ {
-+ c->lazy++;
-+
-+ if (l3 > 0)
-+ {
-+
-+ op = code_run (c, op, ii, lit, ahead);
-+ lit = 0;
-+
-+ op = code_match (c, op, ahead, m_off);
-+ }
-+ else
-+ {
-+ lit += ahead;
-+ }
-+ goto lazy_match_done;
-+ }
-+ }
-+
-+ op = code_run (c, op, ii, lit, m_len);
-+ lit = 0;
-+
-+ op = code_match (c, op, m_len, m_off);
-+ swd->max_chain = max_chain;
-+ r = find_match (c, swd, m_len, 1 + ahead);
-+
-+ lazy_match_done:;
-+ }
-+
-+ if (lit > 0)
-+ op = STORE_RUN (c, op, ii, lit);
-+
-+ *op++ = M4_MARKER | 1;
-+ *op++ = 0;
-+ *op++ = 0;
-+
-+ c->codesize = op - out;
-+
-+ *out_len = op - out;
-+
-+ if (c->cb)
-+ (*c->cb) (c->textsize, c->codesize);
-+
-+ return LZO_E_OK;
-+}
-+
-+static int
-+lzo1x_999_compress_level (const lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len,
-+ lzo_voidp wrkmem,
-+ const lzo_byte * dict, lzo_uint dict_len,
-+ lzo_progress_callback_t cb, int compression_level)
-+{
-+ static const struct
-+ {
-+ int try_lazy;
-+ lzo_uint good_length;
-+ lzo_uint max_lazy;
-+ lzo_uint nice_length;
-+ lzo_uint max_chain;
-+ lzo_uint32 flags;
-+ } c[9] =
-+ {
-+ {
-+ 0, 0, 0, 8, 4, 0},
-+ {
-+ 0, 0, 0, 16, 8, 0},
-+ {
-+ 0, 0, 0, 32, 16, 0},
-+ {
-+ 1, 4, 4, 16, 16, 0},
-+ {
-+ 1, 8, 16, 32, 32, 0},
-+ {
-+ 1, 8, 16, 128, 128, 0},
-+ {
-+ 2, 8, 32, 128, 256, 0},
-+ {
-+ 2, 32, 128, F, 2048, 1},
-+ {
-+ 2, F, F, F, 4096, 1}
-+ };
-+
-+ if (compression_level < 1 || compression_level > 9)
-+ return LZO_E_ERROR;
-+
-+ compression_level -= 1;
-+ return lzo1x_999_compress_internal (in, in_len, out, out_len, wrkmem,
-+ dict, dict_len, cb,
-+ c[compression_level].try_lazy,
-+ c[compression_level].good_length,
-+ c[compression_level].max_lazy,
-+ 0,
-+ c[compression_level].max_chain,
-+ c[compression_level].flags);
-+}
-+
-+static int
-+lzo1x_999_compress (const lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
-+{
-+ return lzo1x_999_compress_level (in, in_len, out, out_len, wrkmem,
-+ NULL, 0, 0, 8);
-+}
-+
-+/* minilzo.c */
-+
-+static const lzo_byte __lzo_copyright[] = LZO_VERSION_STRING;
-+
-+static lzo_uint
-+_lzo1x_1_do_compress (const lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
-+{
-+
-+ register const lzo_byte *ip;
-+
-+ lzo_byte *op;
-+ const lzo_byte *const in_end = in + in_len;
-+ const lzo_byte *const ip_end = in + in_len - 8 - 5;
-+ const lzo_byte *ii;
-+ lzo_dict_p const dict = (lzo_dict_p) wrkmem;
-+
-+ op = out;
-+ ip = in;
-+ ii = ip;
-+
-+ ip += 4;
-+ for (;;)
-+ {
-+ register const lzo_byte *m_pos;
-+
-+ lzo_uint m_off;
-+ lzo_uint m_len;
-+ lzo_uint dindex;
-+
-+ DINDEX1 (dindex, ip);
-+ GINDEX (m_pos, m_off, dict, dindex, in);
-+ if (LZO_CHECK_MPOS_NON_DET
-+ (m_pos, m_off, in, ip, M4_MAX_OFFSET))
-+ goto literal;
-+
-+ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
-+ goto try_match;
-+ DINDEX2 (dindex, ip);
-+ GINDEX (m_pos, m_off, dict, dindex, in);
-+
-+ if (LZO_CHECK_MPOS_NON_DET
-+ (m_pos, m_off, in, ip, M4_MAX_OFFSET))
-+ goto literal;
-+ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
-+ goto try_match;
-+ goto literal;
-+
-+ try_match:
-+ if (m_pos[0] != ip[0] || m_pos[1] != ip[1])
-+ {
-+ }
-+ else
-+ {
-+ if (m_pos[2] == ip[2])
-+ {
-+ goto match;
-+ }
-+ else
-+ {
-+ }
-+ }
-+
-+ literal:
-+ UPDATE_I (dict, 0, dindex, ip, in);
-+ ++ip;
-+ if (ip >= ip_end)
-+ break;
-+ continue;
-+
-+ match:
-+ UPDATE_I (dict, 0, dindex, ip, in);
-+
-+ if (pd (ip, ii) > 0)
-+ {
-+ register lzo_uint t = pd (ip, ii);
-+
-+ if (t <= 3)
-+ {
-+ op[-2] |= LZO_BYTE (t);
-+ }
-+ else if (t <= 18)
-+ *op++ = LZO_BYTE (t - 3);
-+ else
-+ {
-+ register lzo_uint tt = t - 18;
-+
-+ *op++ = 0;
-+ while (tt > 255)
-+ {
-+ tt -= 255;
-+ *op++ = 0;
-+ }
-+ *op++ = LZO_BYTE (tt);;
-+ }
-+ do
-+ *op++ = *ii++;
-+ while (--t > 0);
-+ }
-+
-+ ip += 3;
-+ if (m_pos[3] != *ip++ || m_pos[4] != *ip++
-+ || m_pos[5] != *ip++ || m_pos[6] != *ip++
-+ || m_pos[7] != *ip++ || m_pos[8] != *ip++)
-+ {
-+ --ip;
-+ m_len = ip - ii;
-+
-+ if (m_off <= M2_MAX_OFFSET)
-+ {
-+ m_off -= 1;
-+
-+ *op++ = LZO_BYTE (((m_len -
-+ 1) << 5) | ((m_off & 7) <<
-+ 2));
-+ *op++ = LZO_BYTE (m_off >> 3);
-+ }
-+ else if (m_off <= M3_MAX_OFFSET)
-+ {
-+ m_off -= 1;
-+ *op++ = LZO_BYTE (M3_MARKER | (m_len - 2));
-+ goto m3_m4_offset;
-+ }
-+ else
-+
-+ {
-+ m_off -= 0x4000;
-+
-+ *op++ = LZO_BYTE (M4_MARKER |
-+ ((m_off & 0x4000) >> 11) |
-+ (m_len - 2));
-+ goto m3_m4_offset;
-+ }
-+ }
-+ else
-+ {
-+ {
-+ const lzo_byte *end = in_end;
-+ const lzo_byte *m = m_pos + M2_MAX_LEN + 1;
-+ while (ip < end && *m == *ip)
-+ m++, ip++;
-+ m_len = (ip - ii);
-+ }
-+
-+
-+ if (m_off <= M3_MAX_OFFSET)
-+ {
-+ m_off -= 1;
-+ if (m_len <= 33)
-+ *op++ = LZO_BYTE (M3_MARKER |
-+ (m_len - 2));
-+ else
-+ {
-+ m_len -= 33;
-+ *op++ = M3_MARKER | 0;
-+ goto m3_m4_len;
-+ }
-+ }
-+ else
-+ {
-+ m_off -= 0x4000;
-+
-+ if (m_len <= M4_MAX_LEN)
-+ *op++ = LZO_BYTE (M4_MARKER |
-+ ((m_off & 0x4000) >>
-+ 11) | (m_len - 2));
-+
-+ else
-+ {
-+ m_len -= M4_MAX_LEN;
-+ *op++ = LZO_BYTE (M4_MARKER |
-+ ((m_off & 0x4000) >>
-+ 11));
-+ m3_m4_len:
-+ while (m_len > 255)
-+ {
-+ m_len -= 255;
-+ *op++ = 0;
-+ }
-+
-+ *op++ = LZO_BYTE (m_len);
-+ }
-+ }
-+
-+ m3_m4_offset:
-+ *op++ = LZO_BYTE ((m_off & 63) << 2);
-+ *op++ = LZO_BYTE (m_off >> 6);
-+ }
-+ ii = ip;
-+ if (ip >= ip_end)
-+ break;
-+ }
-+
-+ *out_len = op - out;
-+ return pd (in_end, ii);
-+}
-+
-+static int
-+lzo1x_1_compress (const lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
-+{
-+ lzo_byte *op = out;
-+ lzo_uint t;
-+
-+ if (in_len <= M2_MAX_LEN + 5)
-+ t = in_len;
-+ else
-+ {
-+ t = _lzo1x_1_do_compress (in, in_len, op, out_len, wrkmem);
-+ op += *out_len;
-+ }
-+
-+ if (t > 0)
-+ {
-+ const lzo_byte *ii = in + in_len - t;
-+
-+ if (op == out && t <= 238)
-+ *op++ = LZO_BYTE (17 + t);
-+ else if (t <= 3)
-+ op[-2] |= LZO_BYTE (t);
-+ else if (t <= 18)
-+ *op++ = LZO_BYTE (t - 3);
-+ else
-+ {
-+ lzo_uint tt = t - 18;
-+
-+ *op++ = 0;
-+ while (tt > 255)
-+ {
-+ tt -= 255;
-+ *op++ = 0;
-+ }
-+
-+ *op++ = LZO_BYTE (tt);
-+ }
-+ do
-+ *op++ = *ii++;
-+ while (--t > 0);
-+ }
-+
-+ *op++ = M4_MARKER | 1;
-+ *op++ = 0;
-+ *op++ = 0;
-+
-+ *out_len = op - out;
-+ return 0;
-+}
-+
-+static int
-+lzo1x_decompress (const lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
-+{
-+ register lzo_byte *op;
-+ register const lzo_byte *ip;
-+ register lzo_uint t;
-+
-+ register const lzo_byte *m_pos;
-+
-+ const lzo_byte *const ip_end = in + in_len;
-+ lzo_byte *const op_end = out + *out_len;
-+
-+ *out_len = 0;
-+
-+ op = out;
-+ ip = in;
-+
-+ if (*ip > 17)
-+ {
-+ t = *ip++ - 17;
-+ if (t < 4)
-+ goto match_next;
-+ NEED_OP (t);
-+ NEED_IP (t + 1);
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+ goto first_literal_run;
-+ }
-+
-+ while (TEST_IP && TEST_OP)
-+ {
-+ t = *ip++;
-+ if (t >= 16)
-+ goto match;
-+ if (t == 0)
-+ {
-+ NEED_IP (1);
-+ while (*ip == 0)
-+ {
-+ t += 255;
-+ ip++;
-+ NEED_IP (1);
-+ }
-+ t += 15 + *ip++;
-+ }
-+ NEED_OP (t + 3);
-+ NEED_IP (t + 4);
-+ if (PTR_ALIGNED2_4 (op, ip))
-+ {
-+ COPY4 (op, ip);
-+
-+ op += 4;
-+ ip += 4;
-+ if (--t > 0)
-+ {
-+ if (t >= 4)
-+ {
-+ do
-+ {
-+ COPY4 (op, ip);
-+ op += 4;
-+ ip += 4;
-+ t -= 4;
-+ }
-+ while (t >= 4);
-+ if (t > 0)
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+ }
-+ else
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+ }
-+ }
-+ else
-+ {
-+ *op++ = *ip++;
-+ *op++ = *ip++;
-+ *op++ = *ip++;
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+ }
-+ first_literal_run:
-+
-+ t = *ip++;
-+ if (t >= 16)
-+ goto match;
-+
-+ m_pos = op - (1 + M2_MAX_OFFSET);
-+ m_pos -= t >> 2;
-+ m_pos -= *ip++ << 2;
-+ TEST_LOOKBEHIND (m_pos, out);
-+ NEED_OP (3);
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos;
-+
-+ goto match_done;
-+
-+ while (TEST_IP && TEST_OP)
-+ {
-+ match:
-+ if (t >= 64)
-+ {
-+ m_pos = op - 1;
-+ m_pos -= (t >> 2) & 7;
-+ m_pos -= *ip++ << 3;
-+ t = (t >> 5) - 1;
-+ TEST_LOOKBEHIND (m_pos, out);
-+ NEED_OP (t + 3 - 1);
-+ goto copy_match;
-+
-+ }
-+ else if (t >= 32)
-+ {
-+ t &= 31;
-+ if (t == 0)
-+ {
-+ NEED_IP (1);
-+ while (*ip == 0)
-+ {
-+ t += 255;
-+ ip++;
-+ NEED_IP (1);
-+ }
-+ t += 31 + *ip++;
-+ }
-+
-+ m_pos = op - 1;
-+ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
-+
-+ ip += 2;
-+ }
-+ else if (t >= 16)
-+ {
-+ m_pos = op;
-+ m_pos -= (t & 8) << 11;
-+
-+ t &= 7;
-+ if (t == 0)
-+ {
-+ NEED_IP (1);
-+ while (*ip == 0)
-+ {
-+ t += 255;
-+ ip++;
-+ NEED_IP (1);
-+ }
-+ t += 7 + *ip++;
-+ }
-+
-+ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
-+
-+ ip += 2;
-+ if (m_pos == op)
-+ goto eof_found;
-+ m_pos -= 0x4000;
-+ }
-+ else
-+ {
-+
-+ m_pos = op - 1;
-+ m_pos -= t >> 2;
-+ m_pos -= *ip++ << 2;
-+ TEST_LOOKBEHIND (m_pos, out);
-+ NEED_OP (2);
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos;
-+
-+ goto match_done;
-+ }
-+
-+ TEST_LOOKBEHIND (m_pos, out);
-+ NEED_OP (t + 3 - 1);
-+ if (t >= 2 * 4 - (3 - 1)
-+ && PTR_ALIGNED2_4 (op, m_pos))
-+ {
-+ COPY4 (op, m_pos);
-+ op += 4;
-+ m_pos += 4;
-+ t -= 4 - (3 - 1);
-+ do
-+ {
-+ COPY4 (op, m_pos);
-+ op += 4;
-+ m_pos += 4;
-+ t -= 4;
-+ }
-+ while (t >= 4);
-+ if (t > 0)
-+ do
-+ *op++ = *m_pos++;
-+ while (--t > 0);
-+ }
-+ else
-+
-+ {
-+ copy_match:
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ do
-+ *op++ = *m_pos++;
-+ while (--t > 0);
-+ }
-+
-+ match_done:
-+ t = ip[-2] & 3;
-+
-+ if (t == 0)
-+ break;
-+
-+ match_next:
-+ NEED_OP (t);
-+ NEED_IP (t + 1);
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+ t = *ip++;
-+ }
-+ }
-+ *out_len = op - out;
-+ return LZO_E_EOF_NOT_FOUND;
-+
-+ eof_found:
-+ *out_len = op - out;
-+ return (ip == ip_end ? LZO_E_OK :
-+ (ip <
-+ ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
-+
-+ input_overrun:
-+ *out_len = op - out;
-+ return LZO_E_INPUT_OVERRUN;
-+
-+ output_overrun:
-+ *out_len = op - out;
-+ return LZO_E_OUTPUT_OVERRUN;
-+
-+ lookbehind_overrun:
-+ *out_len = op - out;
-+ return LZO_E_LOOKBEHIND_OVERRUN;
-+}
-+
-+/* lzo1x_oo.ch */
-+
-+#define NO_LIT LZO_UINT_MAX
-+
-+static void
-+copy2 (lzo_byte * ip, const lzo_byte * m_pos, lzo_ptrdiff_t off)
-+{
-+ ip[0] = m_pos[0];
-+ if (off == 1)
-+ ip[1] = m_pos[0];
-+ else
-+ ip[1] = m_pos[1];
-+}
-+
-+static void
-+copy3 (lzo_byte * ip, const lzo_byte * m_pos, lzo_ptrdiff_t off)
-+{
-+ ip[0] = m_pos[0];
-+ if (off == 1)
-+ {
-+ ip[2] = ip[1] = m_pos[0];
-+ }
-+ else if (off == 2)
-+ {
-+ ip[1] = m_pos[1];
-+ ip[2] = m_pos[0];
-+ }
-+ else
-+ {
-+ ip[1] = m_pos[1];
-+ ip[2] = m_pos[2];
-+ }
-+}
-+
-+static int
-+lzo1x_optimize (lzo_byte * in, lzo_uint in_len,
-+ lzo_byte * out, lzo_uintp out_len, lzo_voidp wrkmem)
-+{
-+ register lzo_byte *op;
-+ register lzo_byte *ip;
-+ register lzo_uint t;
-+ register lzo_byte *m_pos;
-+ lzo_uint nl;
-+ const lzo_byte *const ip_end = in + in_len;
-+ const lzo_byte *const op_end = out + *out_len;
-+ lzo_byte *litp = NULL;
-+ lzo_uint lit = 0;
-+ lzo_uint next_lit = NO_LIT;
-+ long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;
-+
-+ *out_len = 0;
-+
-+ op = out;
-+ ip = in;
-+
-+ if (*ip > 17)
-+ {
-+ t = *ip++ - 17;
-+ if (t < 4)
-+ goto match_next;
-+ goto first_literal_run;
-+ }
-+
-+ while (TEST_IP && TEST_OP)
-+ {
-+ t = *ip++;
-+ if (t >= 16)
-+ goto match;
-+ litp = ip - 1;
-+ if (t == 0)
-+ {
-+ t = 15;
-+ while (*ip == 0)
-+ t += 255, ip++;
-+ t += *ip++;
-+ }
-+ lit = t + 3;
-+ copy_literal_run:
-+ *op++ = *ip++;
-+ *op++ = *ip++;
-+ *op++ = *ip++;
-+ first_literal_run:
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+
-+ t = *ip++;
-+
-+ if (t >= 16)
-+ goto match;
-+ m_pos = op - 1 - 0x800;
-+ m_pos -= t >> 2;
-+ m_pos -= *ip++ << 2;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ lit = 0;
-+ goto match_done;
-+
-+ while (TEST_IP && TEST_OP)
-+ {
-+ if (t < 16)
-+ {
-+ m_pos = op - 1;
-+ m_pos -= t >> 2;
-+ m_pos -= *ip++ << 2;
-+
-+ if (litp == NULL)
-+ goto copy_m1;
-+
-+ nl = ip[-2] & 3;
-+ if (nl == 0 && lit == 1 && ip[0] >= 16)
-+ {
-+ next_lit = nl;
-+ lit += 2;
-+ *litp = LZO_BYTE ((*litp & ~3) | lit);
-+ copy2 (ip - 2, m_pos, op - m_pos);
-+ o_m1_a++;
-+ }
-+ else if (nl == 0 && ip[0] < 16 && ip[0] != 0
-+ && (lit + 2 + ip[0] < 16))
-+ {
-+ t = *ip++;
-+ *litp &= ~3;
-+ copy2 (ip - 3 + 1, m_pos, op - m_pos);
-+ litp += 2;
-+ if (lit > 0)
-+ memmove (litp + 1, litp, lit);
-+ lit += 2 + t + 3;
-+ *litp = LZO_BYTE (lit - 3);
-+
-+ o_m1_b++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ goto copy_literal_run;
-+ }
-+ copy_m1:
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ }
-+ else
-+ {
-+ match:
-+ if (t >= 64)
-+ {
-+ m_pos = op - 1;
-+ m_pos -= (t >> 2) & 7;
-+ m_pos -= *ip++ << 3;
-+ t = (t >> 5) - 1;
-+ if (litp == NULL)
-+ goto copy_m;
-+
-+ nl = ip[-2] & 3;
-+ if (t == 1 && lit > 3 && nl == 0 &&
-+ ip[0] < 16 && ip[0] != 0
-+ && (lit + 3 + ip[0] < 16))
-+ {
-+ t = *ip++;
-+ copy3 (ip - 1 - 2, m_pos,
-+ op - m_pos);
-+ lit += 3 + t + 3;
-+ *litp = LZO_BYTE (lit - 3);
-+ o_m2++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ goto copy_literal_run;
-+ }
-+ }
-+ else
-+ {
-+ if (t >= 32)
-+ {
-+ t &= 31;
-+ if (t == 0)
-+ {
-+ t = 31;
-+ while (*ip == 0)
-+ t += 255,
-+ ip++;
-+ t += *ip++;
-+ }
-+ m_pos = op - 1;
-+ m_pos -= *ip++ >> 2;
-+ m_pos -= *ip++ << 6;
-+ }
-+ else
-+ {
-+ m_pos = op;
-+ m_pos -= (t & 8) << 11;
-+ t &= 7;
-+ if (t == 0)
-+ {
-+ t = 7;
-+ while (*ip == 0)
-+ t += 255,
-+ ip++;
-+ t += *ip++;
-+ }
-+ m_pos -= *ip++ >> 2;
-+ m_pos -= *ip++ << 6;
-+ if (m_pos == op)
-+ goto eof_found;
-+ m_pos -= 0x4000;
-+ }
-+ if (litp == NULL)
-+ goto copy_m;
-+
-+ nl = ip[-2] & 3;
-+ if (t == 1 && lit == 0 && nl == 0
-+ && ip[0] >= 16)
-+ {
-+ next_lit = nl;
-+ lit += 3;
-+ *litp = LZO_BYTE ((*litp & ~3)
-+ | lit);
-+ copy3 (ip - 3, m_pos,
-+ op - m_pos);
-+ o_m3_a++;
-+ }
-+ else if (t == 1 && lit <= 3 && nl == 0
-+ && ip[0] < 16 && ip[0] != 0
-+ && (lit + 3 + ip[0] < 16))
-+ {
-+ t = *ip++;
-+ *litp &= ~3;
-+ copy3 (ip - 4 + 1, m_pos,
-+ op - m_pos);
-+ litp += 2;
-+ if (lit > 0)
-+ memmove (litp + 1,
-+ litp, lit);
-+ lit += 3 + t + 3;
-+ *litp = LZO_BYTE (lit - 3);
-+
-+ o_m3_b++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ goto copy_literal_run;
-+ }
-+ }
-+ copy_m:
-+ *op++ = *m_pos++;
-+ *op++ = *m_pos++;
-+ do
-+ *op++ = *m_pos++;
-+ while (--t > 0);
-+ }
-+
-+ match_done:
-+ if (next_lit == NO_LIT)
-+ {
-+ t = ip[-2] & 3;
-+ lit = t;
-+ litp = ip - 2;
-+ }
-+ else
-+ t = next_lit;
-+ next_lit = NO_LIT;
-+ if (t == 0)
-+ break;
-+ match_next:
-+ do
-+ *op++ = *ip++;
-+ while (--t > 0);
-+ t = *ip++;
-+ }
-+ }
-+
-+ *out_len = op - out;
-+ return LZO_E_EOF_NOT_FOUND;
-+
-+ eof_found:
-+ *out_len = op - out;
-+ return (ip == ip_end ? LZO_E_OK :
-+ (ip <
-+ ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
-+}
-+
-+/* interface to jffs2 bbc follows */
-+
-+#include "jffs2_bbc_framework.h"
-+
-+#define BLOCKSIZE 4096
-+#define OUTBLOCKSIZE (BLOCKSIZE + BLOCKSIZE / 64 + 16 + 3)
-+
-+#define JFFS2_BBC_LZO_BLOCK_SIGN {0x3f, 0x47, 0x5a, 0x18}
-+
-+static int
-+jffs2_bbc_lzo_compressor_init (void);
-+
-+static void
-+jffs2_bbc_lzo_compressor_deinit (void);
-+
-+static int
-+jffs2_bbc_lzo_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen);
-+
-+static int
-+jffs2_bbc_lzo_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime);
-+
-+static int
-+jffs2_bbc_lzo_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen);
-+
-+static char *
-+jffs2_bbc_lzo_proc_info (void);
-+
-+static int
-+jffs2_bbc_lzo_proc_command (char *command);
-+
-+struct jffs2_bbc_compressor_type jffs2_bbc_lzo = {
-+ "lzo",
-+ 0,
-+ JFFS2_BBC_LZO_BLOCK_SIGN,
-+ jffs2_bbc_lzo_compressor_init,
-+ NULL,
-+ NULL,
-+ jffs2_bbc_lzo_compressor_deinit,
-+ jffs2_bbc_lzo_compress,
-+ jffs2_bbc_lzo_estimate,
-+ jffs2_bbc_lzo_decompress,
-+ jffs2_bbc_lzo_proc_info,
-+ jffs2_bbc_lzo_proc_command
-+};
-+
-+static int
-+no_lzo1x_optimize (lzo_byte * src, lzo_uint src_len,
-+ lzo_byte * dst, lzo_uintp dst_len, lzo_voidp wrkmem)
-+{
-+ return 0;
-+}
-+
-+#ifdef __KERNEL__
-+static lzo_compress_t lzo1x_compressor = lzo1x_1_compress;
-+static lzo_optimize_t lzo1x_optimizer = no_lzo1x_optimize;
-+static int lzo1x_compressor_type = 1;
-+static int lzo1x_optimize_type = 0;
-+static unsigned long lzo1x_compressor_memsize = LZO1X_1_MEM_COMPRESS;
-+#else
-+static lzo_compress_t lzo1x_compressor = lzo1x_999_compress;
-+static lzo_optimize_t lzo1x_optimizer = lzo1x_optimize;
-+static int lzo1x_compressor_type = 999;
-+static int lzo1x_optimize_type = 1;
-+static unsigned long lzo1x_compressor_memsize = LZO1X_999_MEM_COMPRESS;
-+#endif
-+
-+static lzo_bytep wrkmem = NULL; /* temporary buffer for compression, used by lzo */
-+static lzo_bytep cmprssmem = NULL; /* temporary buffer for compression, used by interface */
-+
-+static int
-+jffs2_bbc_lzo_compressor_init (void)
-+{
-+ wrkmem = (lzo_bytep) jffs2_bbc_malloc (lzo1x_compressor_memsize);
-+ cmprssmem = (lzo_bytep) jffs2_bbc_malloc (OUTBLOCKSIZE);
-+ return !(wrkmem && cmprssmem);
-+}
-+
-+static void
-+jffs2_bbc_lzo_compressor_deinit (void)
-+{
-+ jffs2_bbc_free (wrkmem);
-+ jffs2_bbc_free (cmprssmem);
-+}
-+
-+static int
-+jffs2_bbc_lzo_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen)
-+{
-+ lzo_uint csize = OUTBLOCKSIZE;
-+ lzo_uint isize = *sourcelen;
-+ int retval;
-+ if ((retval =
-+ lzo1x_compressor (input, *sourcelen, cmprssmem, &csize,
-+ wrkmem)) != LZO_E_OK)
-+ {
-+ *sourcelen = *dstlen = 0;
-+ return retval;
-+ }
-+ else
-+ {
-+ retval = lzo1x_optimizer (cmprssmem, csize, input, &isize,
-+ NULL);
-+ csize += 2;
-+ if (csize <= *dstlen) {
-+ *dstlen = csize;
-+ *(output++) = jffs2_bbc_lzo.block_sign[0];
-+ *(output++) = jffs2_bbc_lzo.block_sign[1];
-+ memcpy (output, cmprssmem, csize - 2);
-+ return retval;
-+ } else {
-+ *sourcelen = *dstlen = 0;
-+ return -1;
-+ }
-+ }
-+}
-+
-+static int
-+jffs2_bbc_lzo_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime)
-+{
-+ *dstlen = sourcelen * 55 / 100;
-+ *readtime = JFFS2_BBC_ZLIB_READ_TIME / 2;
-+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 8 / 10; /* LZO1X-1 is much-much faster,
-+ but LZO1X-999 is slow. The default mode for inside kernel compression is LZO1X-1
-+ This should be *0.4 really */
-+ return 0;
-+}
-+
-+static int
-+jffs2_bbc_lzo_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen)
-+{
-+ lzo_uint outlen = dstlen;
-+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzo.block_sign[0] ) ||
-+ ( *(input++) != (unsigned char)jffs2_bbc_lzo.block_sign[1] )
-+ ) {
-+ return -1;
-+ } else {
-+ return lzo1x_decompress (input, sourcelen - 2, output, &outlen, NULL);
-+ }
-+}
-+
-+static char *
-+jffs2_bbc_lzo_proc_info (void)
-+{
-+ if (lzo1x_compressor_type == 1)
-+ {
-+ if (lzo1x_optimize_type == 1)
-+ {
-+ return "LZO1X-1 compression with optimization";
-+ }
-+ else
-+ {
-+ return "LZO1X-1 compression without optimization";
-+ }
-+ }
-+ else if (lzo1x_compressor_type == 999)
-+ {
-+ if (lzo1x_optimize_type == 1)
-+ {
-+ return "LZO1X-999 compression with optimization";
-+ }
-+ else
-+ {
-+ return "LZO1X-999 compression without optimization";
-+ }
-+ }
-+ else
-+ {
-+ return "Unknown configuration!";
-+ }
-+}
-+
-+static int
-+jffs2_bbc_lzo_proc_command (char *command)
-+{
-+ switch (*command)
-+ {
-+ case 'o':
-+ /* switch optimization off */
-+ lzo1x_optimizer = no_lzo1x_optimize;
-+ lzo1x_optimize_type = 0;
-+ jffs2_bbc_print1 ("Compression optimization switched off.\n");
-+ return 0;
-+ case 'O':
-+ /* switch optimization on */
-+ lzo1x_optimizer = lzo1x_optimize;
-+ lzo1x_optimize_type = 1;
-+ jffs2_bbc_print1 ("Compression optimization switched on.\n");
-+ return 0;
-+ case '1':
-+ /* switch compression to LZO1X-1 */
-+ jffs2_bbc_free (wrkmem);
-+ lzo1x_compressor_type = 1;
-+ lzo1x_compressor = lzo1x_1_compress;
-+ lzo1x_compressor_memsize = LZO1X_1_MEM_COMPRESS;
-+ wrkmem = (lzo_bytep)
-+ jffs2_bbc_malloc (lzo1x_compressor_memsize);
-+ jffs2_bbc_print1 ("Compression type switched to LZO1X-1.\n");
-+ return 0;
-+ case '9':
-+ /* switch compression to LZO1X-999 */
-+ jffs2_bbc_free (wrkmem);
-+ lzo1x_compressor_type = 999;
-+ lzo1x_compressor = lzo1x_999_compress;
-+ lzo1x_compressor_memsize = LZO1X_999_MEM_COMPRESS;
-+ wrkmem = (lzo_bytep)
-+ jffs2_bbc_malloc (lzo1x_compressor_memsize);
-+ jffs2_bbc_print1
-+ ("Compression type switched to LZO1X-999.\n");
-+ return 0;
-+ default:
-+ jffs2_bbc_print1 ("Unknown command!\n");
-+ return 0;
-+ }
-+}
-+
-+
-+struct jffs2_bbc_compressor_type *
-+jffs2_bbc_lzo_init (int mode)
-+{
-+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzo) == 0)
-+ {
-+ return &jffs2_bbc_lzo;
-+ }
-+ else
-+ {
-+ return NULL;
-+ }
-+}
-+
-+void
-+jffs2_bbc_lzo_deinit (void)
-+{
-+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzo);
-+}
-diff -Nur linux-mips-cvs/fs/jffs2/jffs2_bbc_lzss_comp.c linux-mips/fs/jffs2/jffs2_bbc_lzss_comp.c
---- linux-mips-cvs/fs/jffs2/jffs2_bbc_lzss_comp.c 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/jffs2_bbc_lzss_comp.c 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,385 @@
-+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
-+
-+/*
-+ jffs2_bbc_lzss_comp.c -- Lempel-Ziv-Storer-Szymanski compression module for jffs2
-+ Copyright (C) 2004 Patrik Kluba
-+ Based on the LZSS source included in LDS (lossless datacompression sources)
-+ Block-compression modifications by Patrik Kluba
-+ $Header: /openwrt/openwrt/package/linux/kernel-patches/301-jffs-compression,v 1.1 2005/03/26 10:33:31 wbx Exp $
-+*/
-+
-+/*
-+Original copyright follows:
-+
-+**************************************************************
-+ LZSS.C -- A Data Compression Program
-+**************************************************************
-+ 4/6/1989 Haruhiko Okumura
-+ Use, distribute, and modify this program freely.
-+ Please send me your improved versions.
-+ PC-VAN SCIENCE
-+ NIFTY-Serve PAF01022
-+ CompuServe 74050,1022
-+**************************************************************
-+
-+*/
-+
-+/*
-+
-+ 2004-02-16 pajko <pajko(AT)halom(DOT)u-szeged(DOT)hu>
-+ Initial release
-+
-+*/
-+
-+/* lzss.c */
-+
-+#define N 4096 /* size of ring buffer */
-+#define F 18 /* upper limit for match_length */
-+#define THRESHOLD 2 /* encode string into position and length
-+ if match_length is greater than this */
-+#define NIL N /* index for root of binary search trees */
-+
-+static unsigned char
-+ text_buf[N + F - 1]; /* ring buffer of size N,
-+ with extra F-1 bytes to facilitate string comparison */
-+static unsigned long match_position, match_length; /* of longest match. These are
-+ set by the InsertNode() procedure. */
-+static unsigned long lson[N + 1], rson[N + 257], dad[N + 1]; /* left & right children &
-+ parents -- These constitute binary search trees. */
-+
-+static void InitTree(void) /* initialize trees */
-+{
-+ unsigned long i;
-+
-+ /* For i = 0 to N - 1, rson[i] and lson[i] will be the right and
-+ left children of node i. These nodes need not be initialized.
-+ Also, dad[i] is the parent of node i. These are initialized to
-+ NIL (= N), which stands for 'not used.'
-+ For i = 0 to 255, rson[N + i + 1] is the root of the tree
-+ for strings that begin with character i. These are initialized
-+ to NIL. Note there are 256 trees. */
-+
-+ for (i = N + 1; i <= N + 256; i++) rson[i] = NIL;
-+ for (i = 0; i < N; i++) dad[i] = NIL;
-+}
-+
-+static void InsertNode(unsigned long r)
-+ /* Inserts string of length F, text_buf[r..r+F-1], into one of the
-+ trees (text_buf[r]'th tree) and returns the longest-match position
-+ and length via the global variables match_position and match_length.
-+ If match_length = F, then removes the old node in favor of the new
-+ one, because the old one will be deleted sooner.
-+ Note r plays double role, as tree node and position in buffer. */
-+{
-+ unsigned long i, p;
-+ unsigned char *key;
-+ signed long cmp;
-+
-+ cmp = 1; key = &text_buf[r]; p = N + 1 + key[0];
-+ rson[r] = lson[r] = NIL; match_length = 0;
-+ for ( ; ; ) {
-+ if (cmp >= 0) {
-+ if (rson[p] != NIL) p = rson[p];
-+ else { rson[p] = r; dad[r] = p; return; }
-+ } else {
-+ if (lson[p] != NIL) p = lson[p];
-+ else { lson[p] = r; dad[r] = p; return; }
-+ }
-+ for (i = 1; i < F; i++)
-+ if ((cmp = key[i] - text_buf[p + i]) != 0) break;
-+ if (i > match_length) {
-+ match_position = p;
-+ if ((match_length = i) >= F) break;
-+ }
-+ }
-+ dad[r] = dad[p]; lson[r] = lson[p]; rson[r] = rson[p];
-+ dad[lson[p]] = r; dad[rson[p]] = r;
-+ if (rson[dad[p]] == p) rson[dad[p]] = r;
-+ else lson[dad[p]] = r;
-+ dad[p] = NIL; /* remove p */
-+}
-+
-+static void DeleteNode(unsigned long p) /* deletes node p from tree */
-+{
-+ unsigned long q;
-+
-+ if (dad[p] == NIL) return; /* not in tree */
-+ if (rson[p] == NIL) q = lson[p];
-+ else if (lson[p] == NIL) q = rson[p];
-+ else {
-+ q = lson[p];
-+ if (rson[q] != NIL) {
-+ do { q = rson[q]; } while (rson[q] != NIL);
-+ rson[dad[q]] = lson[q]; dad[lson[q]] = dad[q];
-+ lson[q] = lson[p]; dad[lson[p]] = q;
-+ }
-+ rson[q] = rson[p]; dad[rson[p]] = q;
-+ }
-+ dad[q] = dad[p];
-+ if (rson[dad[p]] == p) rson[dad[p]] = q; else lson[dad[p]] = q;
-+ dad[p] = NIL;
-+}
-+
-+/* modified for block compression */
-+/* on return, srclen will contain the number of successfully compressed bytes
-+ and dstlen will contain completed compressed bytes */
-+
-+static int Encode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long *srclen,
-+ unsigned long *dstlen)
-+{
-+ unsigned long i, len, r, c, s, last_match_length, code_buf_ptr;
-+ unsigned char code_buf[17], mask;
-+ unsigned char *ip, *op;
-+ unsigned long written = 0;
-+ unsigned long read = 0;
-+ unsigned char *srcend = srcbuf + *srclen;
-+ unsigned char *dstend = dstbuf + *dstlen;
-+ ip = srcbuf;
-+ op = dstbuf;
-+ InitTree(); /* initialize trees */
-+ code_buf[0] = 0; /* code_buf[1..16] saves eight units of code, and
-+ code_buf[0] works as eight flags, "1" representing that the unit
-+ is an unencoded letter (1 byte), "0" a position-and-length pair
-+ (2 bytes). Thus, eight units require at most 16 bytes of code. */
-+ code_buf_ptr = mask = 1;
-+ s = 0; r = N - F;
-+ for (i = s; i < r; i++) text_buf[i] = ' '; /* Clear the buffer with
-+ any character that will appear often. */
-+ for (len = 0; (len < F) && (ip < srcend); len++)
-+ text_buf[r + len] = *(ip++); /* Read F bytes into the last F bytes of
-+ the buffer */
-+ read = len;
-+ for (i = 1; i <= F; i++) InsertNode(r - i); /* Insert the F strings,
-+ each of which begins with one or more 'space' characters. Note
-+ the order in which these strings are inserted. This way,
-+ degenerate trees will be less likely to occur. */
-+ InsertNode(r); /* Finally, insert the whole string just read. The
-+ global variables match_length and match_position are set. */
-+ do {
-+ if (match_length > len) match_length = len; /* match_length
-+ may be spuriously long near the end of text. */
-+ if (match_length <= THRESHOLD) {
-+ match_length = 1; /* Not long enough match. Send one byte. */
-+ code_buf[0] |= mask; /* 'send one byte' flag */
-+ code_buf[code_buf_ptr++] = text_buf[r]; /* Send uncoded. */
-+ } else {
-+ code_buf[code_buf_ptr++] = match_position;
-+ code_buf[code_buf_ptr++] = (((match_position >> 4) & 0xf0)
-+ | (match_length - (THRESHOLD + 1))); /* Send position and
-+ length pair. Note match_length > THRESHOLD. */
-+ }
-+ if ((mask <<= 1) == 0) { /* Shift mask left one bit. */
-+ if ((op + code_buf_ptr) > dstend) {
-+ *dstlen = written; /* written contains bytes of complete compressed
-+ code */
-+ return -1;
-+ };
-+ for (i = 0; i < code_buf_ptr; *(op++) = code_buf[i++]); /* Send at most 8 units of */
-+ /* code together */
-+ written += code_buf_ptr;
-+ *srclen = read; /* this many bytes have been successfully compressed */
-+ code_buf[0] = 0; code_buf_ptr = mask = 1;
-+ }
-+ last_match_length = match_length;
-+ for (i = 0; (i < last_match_length) && (ip < srcend); i++) {
-+ c = *(ip++);
-+ DeleteNode(s); /* Delete old strings and */
-+ text_buf[s] = c; /* read new bytes */
-+ if (s < F - 1) text_buf[s + N] = c; /* If the position is
-+ near the end of buffer, extend the buffer to make
-+ string comparison easier. */
-+ s = (s + 1) & (N - 1); r = (r + 1) & (N - 1);
-+ /* Since this is a ring buffer, increment the position
-+ modulo N. */
-+ InsertNode(r); /* Register the string in text_buf[r..r+F-1] */
-+ }
-+ read += i;
-+ while (i++ < last_match_length) { /* After the end of text, */
-+ DeleteNode(s); /* no need to read, but */
-+ s = (s + 1) & (N - 1); r = (r + 1) & (N - 1);
-+ if (--len) InsertNode(r); /* buffer may not be empty. */
-+ }
-+ } while (len > 0); /* until length of string to be processed is zero */
-+ if (code_buf_ptr > 1) { /* Send remaining code. */
-+ if ((op + code_buf_ptr) > dstend) {
-+ *dstlen = written;
-+ return -1;
-+ }
-+ for (i = 0; i < code_buf_ptr; *(op++) = code_buf[i++]);
-+ written += code_buf_ptr;
-+ *srclen = read;
-+ }
-+ *dstlen = written;
-+ return 0;
-+}
-+
-+static int Decode(unsigned char *srcbuf, unsigned char *dstbuf, unsigned long srclen,
-+ unsigned long dstlen) /* Just the reverse of Encode(). */
-+{
-+ unsigned long i, r, c, j, k, flags;
-+ unsigned char *ip, *op;
-+ unsigned long written;
-+ unsigned long read;
-+ unsigned char *srcend = srcbuf + srclen;
-+ unsigned char *dstend = dstbuf + dstlen;
-+ read = written = 0;
-+ ip = srcbuf;
-+ op = dstbuf;
-+ for (i = 0; i < N - F; i++) text_buf[i] = ' ';
-+ r = N - F; flags = 0;
-+ for ( ; ; ) {
-+ if (((flags >>= 1) & 256) == 0) {
-+ if (ip >= srcend) return 0;
-+ c = *(ip++);
-+ flags = c | 0xff00; /* uses higher byte cleverly */
-+ } /* to count eight */
-+ if (flags & 1) {
-+ if (ip >= srcend) return 0;
-+ c = *(ip++);
-+ if (op >= dstend) return -1;
-+ *(op++) = text_buf[r++] = c; r &= (N - 1);
-+ } else {
-+ if ((ip + 2) > srcend) return 0;
-+ i = *(ip++);
-+ j = *(ip++);
-+ i |= ((j & 0xf0) << 4); j = (j & 0x0f) + THRESHOLD;
-+ if ((op + j + 1) > dstend) return -1;
-+ for (k = 0; k <= j; k++) {
-+ c = text_buf[(i + k) & (N - 1)];
-+ *(op++) = text_buf[r++] = c; r &= (N - 1);
-+ }
-+ }
-+ }
-+}
-+
-+/* interface to jffs2 bbc follows */
-+
-+#include "jffs2_bbc_framework.h"
-+
-+
-+#define JFFS2_BBC_LZSS_BLOCK_SIGN {0x27, 0x6f, 0x12, 0xc4}
-+
-+static int
-+jffs2_bbc_lzss_compressor_init (void);
-+
-+static void
-+jffs2_bbc_lzss_compressor_deinit (void);
-+
-+static int
-+jffs2_bbc_lzss_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen);
-+
-+static int
-+jffs2_bbc_lzss_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime);
-+
-+static int
-+jffs2_bbc_lzss_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen);
-+
-+static char *
-+jffs2_bbc_lzss_proc_info (void);
-+
-+static int
-+jffs2_bbc_lzss_proc_command (char *command);
-+
-+struct jffs2_bbc_compressor_type jffs2_bbc_lzss = {
-+ "lzss",
-+ 0,
-+ JFFS2_BBC_LZSS_BLOCK_SIGN,
-+ jffs2_bbc_lzss_compressor_init,
-+ NULL,
-+ NULL,
-+ jffs2_bbc_lzss_compressor_deinit,
-+ jffs2_bbc_lzss_compress,
-+ jffs2_bbc_lzss_estimate,
-+ jffs2_bbc_lzss_decompress,
-+ jffs2_bbc_lzss_proc_info,
-+ jffs2_bbc_lzss_proc_command
-+};
-+
-+static int
-+jffs2_bbc_lzss_compressor_init (void)
-+{
-+ return 0;
-+}
-+
-+static void
-+jffs2_bbc_lzss_compressor_deinit (void)
-+{
-+}
-+
-+static int
-+jffs2_bbc_lzss_compress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long *sourcelen,
-+ unsigned long *dstlen)
-+{
-+ int retval;
-+ unsigned long dst = *dstlen;
-+ *(output++) = jffs2_bbc_lzss.block_sign[0];
-+ *(output++) = jffs2_bbc_lzss.block_sign[1];
-+ dst -= 2;
-+ retval = Encode(input, output, sourcelen, &dst);
-+ dst += 2;
-+ *dstlen = dst;
-+ return retval;
-+}
-+
-+static int
-+jffs2_bbc_lzss_estimate (void *model, unsigned char *input,
-+ unsigned long sourcelen, unsigned long *dstlen,
-+ unsigned long *readtime, unsigned long *writetime)
-+{
-+ *dstlen = sourcelen * 60 / 100;
-+ *readtime = JFFS2_BBC_ZLIB_READ_TIME * 12 / 10;
-+ *writetime = JFFS2_BBC_ZLIB_WRITE_TIME * 3;
-+ return 0;
-+}
-+
-+static int
-+jffs2_bbc_lzss_decompress (void *model, unsigned char *input,
-+ unsigned char *output, unsigned long sourcelen,
-+ unsigned long dstlen)
-+{
-+ if ( ( *(input++) != (unsigned char)jffs2_bbc_lzss.block_sign[0] ) ||
-+ ( *(input++) != (unsigned char)jffs2_bbc_lzss.block_sign[1] )
-+ ) {
-+ return -1;
-+ } else {
-+ return Decode(input, output, sourcelen - 2, dstlen);
-+ }
-+}
-+
-+static char *
-+jffs2_bbc_lzss_proc_info (void)
-+{
-+ return "Lempel-Ziv-Storer-Szymanski compression module";
-+}
-+
-+static int
-+jffs2_bbc_lzss_proc_command (char *command)
-+{
-+ return 0;
-+}
-+
-+struct jffs2_bbc_compressor_type *
-+jffs2_bbc_lzss_init (int mode)
-+{
-+ if (jffs2_bbc_register_compressor (&jffs2_bbc_lzss) == 0)
-+ {
-+ return &jffs2_bbc_lzss;
-+ }
-+ else
-+ {
-+ return NULL;
-+ }
-+}
-+
-+void
-+jffs2_bbc_lzss_deinit (void)
-+{
-+ jffs2_bbc_unregister_compressor (&jffs2_bbc_lzss);
-+}
-diff -Nur linux-mips-cvs/fs/jffs2/linux-2.4.25.hpatch linux-mips/fs/jffs2/linux-2.4.25.hpatch
---- linux-mips-cvs/fs/jffs2/linux-2.4.25.hpatch 1970-01-01 01:00:00.000000000 +0100
-+++ linux-mips/fs/jffs2/linux-2.4.25.hpatch 2005-02-07 05:08:34.000000000 +0100
-@@ -0,0 +1,97 @@
-+FMakefile
-+=BBC insertion
-+-COMPR_OBJS
-+iMakefile.bbc.inc
-++
-+I
-+?JFFS2_OBJS
-++ $(JFFS2_BBC_KERNEL_OBJS) \
-+
-+F../Config.in
-+=BBC insertion
-+-tristate 'Compressed ROM file system support' CONFIG_CRAMFS
-+iConfig.in.bbc.inc
-++
-+I
-+F../../Documentation/Configure.help
-+=BBC insertion
-+-JFFS stats available
-+iConfigure.help.bbc.inc
-++
-+I
-+Fcompr_zlib.c
-+=(de)compress->(de)compress2
-+-int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
-++int jffs2_zlib_compress2(unsigned char *data_in, unsigned char *cpage_out,
-+-void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
-++void jffs2_zlib_decompress2(unsigned char *data_in, unsigned char *cpage_out,
-+?inflateEnd(&strm);
-+?}
-++
-++extern int jffs2_zlib_compress(unsigned char *data_in, unsigned char *cpage_out, __u32 * sourcelen, __u32 * dstlen);
-++extern void jffs2_zlib_decompress(unsigned char *data_in, unsigned char *cpage_out, __u32 srclen, __u32 destlen);
-++
-++int zlib_compress(unsigned char *data_in, unsigned char *cpage_out,
-++ __u32 *sourcelen, __u32 *dstlen)
-++{
-++ return jffs2_zlib_compress(data_in,cpage_out,sourcelen,dstlen);
-++}
-++
-++void zlib_decompress(unsigned char *data_in, unsigned char *cpage_out,
-++ __u32 srclen, __u32 destlen)
-++{
-++ jffs2_zlib_decompress(data_in,cpage_out,srclen,destlen);
-++}
-++
-+
-+Ffile.c
-+=set_act_sb before write
-+-#include
-++#include "jffs2_bbc_framework.h" /**BBC**/
-+I
-+?int jffs2_commit_write
-+-jffs2_compress(
-++ jffs2_bbc_model_set_act_sb(c); /**BBC**/
-+I
-+
-+Fgc.c
-+=set_act_sb before write
-+-#include
-++#include "jffs2_bbc_framework.h" /**BBC**/
-+I
-+?int jffs2_garbage_collect_dnode(
-+-jffs2_compress(
-++ jffs2_bbc_model_set_act_sb(c); /**BBC**/
-+I
-+
-+Fread.c
-+=set_act_sb before read
-+-#include
-++#include "jffs2_bbc_framework.h" /**BBC**/
-+I
-+?int jffs2_read_dnode(
-+-jffs2_decompress(
-++ jffs2_bbc_model_set_act_sb(c); /**BBC**/
-+I
-+
-+Fsuper.c
-+=init, load_model
-+-#include
-++#include "jffs2_bbc_fs.h" /**BBC**/
-+I
-+?struct super_block *jffs2_read_super(
-+-return sb;
-++ jffs2_bbc_load_model(sb); /**BBC**/
-+I
-+?void jffs2_put_super
-+?c = JFFS2_SB_INFO
-++ jffs2_bbc_unload_model(sb); /**BBC**/
-+?init_jffs2_fs(void)
-+?int ret;
-++
-++ jffs2_bbc_proc_init(); /**BBC**/
-++
-+?exit_jffs2_fs(void)
-+?{
-++ jffs2_bbc_proc_deinit(); /**BBC**/
-++
-diff -Nur linux-mips-cvs/fs/jffs2/read.c linux-mips/fs/jffs2/read.c
---- linux-mips-cvs/fs/jffs2/read.c 2003-11-17 02:07:44.000000000 +0100
-+++ linux-mips/fs/jffs2/read.c 2005-02-07 05:08:35.000000000 +0100
-@@ -35,6 +35,7 @@
- *
- */
-
-+#include "jffs2_bbc_framework.h" /**BBC**/
- #include <linux/kernel.h>
- #include <linux/slab.h>
- #include <linux/jffs2.h>
-@@ -140,6 +141,7 @@
- D2(printk(KERN_DEBUG "Data CRC matches calculated CRC %08x\n", crc));
- if (ri->compr != JFFS2_COMPR_NONE) {
- D2(printk(KERN_DEBUG "Decompress %d bytes from %p to %d bytes at %p\n", ri->csize, readbuf, ri->dsize, decomprbuf));
-+ jffs2_bbc_model_set_act_sb(c); /**BBC**/
- ret = jffs2_decompress(ri->compr, readbuf, decomprbuf, ri->csize, ri->dsize);
- if (ret) {
- printk(KERN_WARNING "Error: jffs2_decompress returned %d\n", ret);
-diff -Nur linux-mips-cvs/fs/jffs2/super.c linux-mips/fs/jffs2/super.c
---- linux-mips-cvs/fs/jffs2/super.c 2003-01-11 18:53:17.000000000 +0100
-+++ linux-mips/fs/jffs2/super.c 2005-02-07 05:08:35.000000000 +0100
-@@ -35,6 +35,7 @@
- *
- */
-
-+#include "jffs2_bbc_fs.h" /**BBC**/
- #include <linux/config.h>
- #include <linux/kernel.h>
- #include <linux/module.h>
-@@ -272,6 +273,7 @@
- sb->s_magic = JFFS2_SUPER_MAGIC;
- if (!(sb->s_flags & MS_RDONLY))
- jffs2_start_garbage_collect_thread(c);
-+ jffs2_bbc_load_model(sb); /**BBC**/
- return sb;
-
- out_root_i:
-@@ -288,6 +290,7 @@
- void jffs2_put_super (struct super_block *sb)
- {
- struct jffs2_sb_info *c = JFFS2_SB_INFO(sb);
-+ jffs2_bbc_unload_model(sb); /**BBC**/
-
- D2(printk(KERN_DEBUG "jffs2: jffs2_put_super()\n"));
-
-@@ -344,6 +347,9 @@
- {
- int ret;
-
-+ jffs2_bbc_proc_init(); /**BBC**/
-+
-+
- printk(KERN_NOTICE "JFFS2 version 2.1. (C) 2001 Red Hat, Inc., designed by Axis Communications AB.\n");
-
- #ifdef JFFS2_OUT_OF_KERNEL
-@@ -388,6 +394,8 @@
-
- static void __exit exit_jffs2_fs(void)
- {
-+ jffs2_bbc_proc_deinit(); /**BBC**/
-+
- jffs2_destroy_slab_caches();
- jffs2_zlib_exit();
- unregister_filesystem(&jffs2_fs_type);
projects / openwrt / svn-archive / openwrt.git / blobdiff