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