target/linux/generic-2.4/patches/003-jffs2_compression.patch

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