diff options
Diffstat (limited to 'package/linux/kernel-patches/301-jffs-compression')
| -rw-r--r-- | package/linux/kernel-patches/301-jffs-compression | 9119 |
1 files changed, 0 insertions, 9119 deletions
diff --git a/package/linux/kernel-patches/301-jffs-compression b/package/linux/kernel-patches/301-jffs-compression deleted file mode 100644 index 12491d471c..0000000000 --- a/package/linux/kernel-patches/301-jffs-compression +++ /dev/null @@ -1,9119 +0,0 @@ -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$ -+ * -+ * 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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+#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$ -+*******************************************************************************/ -+ -+//#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$ -+*******************************************************************************/ -+ -+//#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$ -+*******************************************************************************/ -+ -+//#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$ -+*******************************************************************************/ -+ -+//#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$ -+*******************************************************************************/ -+ -+//#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$ -+*******************************************************************************/ -+ -+//#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$ -+*******************************************************************************/ -+ -+//#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$ -+ * -+ * 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$ -+ * -+ * 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$ -+ * -+ * 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$ -+ * -+ * 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$ -+*/ -+ -+/* -+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$ -+*/ -+ -+/* -+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$ -+*/ -+ -+/* -+ 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$ -+*/ -+ -+/* -+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); |