+ * The specification for Adler32 may be found in RFC 1950. (ZLIB Compressed Data + * Format Specification version 3.3) + *

+ *

+ * From that document: + *

+ * "ADLER32 (Adler-32 checksum) This contains a checksum value of the + * uncompressed data (excluding any dictionary data) computed according to + * Adler-32 algorithm. This algorithm is a 32-bit extension and improvement of + * the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073 standard. + *

+ * Adler-32 is composed of two sums accumulated per byte: s1 is the sum of all + * bytes, s2 is the sum of all s1 values. Both sums are done modulo 65521. s1 is + * initialized to 1, s2 to zero. The Adler-32 checksum is stored as s2*65536 + + * s1 in most- significant-byte first (network) order." + *

+ * "8.2. The Adler-32 algorithm + *

+ * The Adler-32 algorithm is much faster than the CRC32 algorithm yet still + * provides an extremely low probability of undetected errors. + *

+ * The modulo on unsigned long accumulators can be delayed for 5552 bytes, so + * the modulo operation time is negligible. If the bytes are a, b, c, the second + * sum is 3a + 2b + c + 3, and so is position and order sensitive, unlike the + * first sum, which is just a checksum. That 65521 is prime is important to + * avoid a possible large class of two-byte errors that leave the check + * unchanged. (The Fletcher checksum uses 255, which is not prime and which also + * makes the Fletcher check insensitive to single byte changes 0 <-> 255.) + *

+ * The sum s1 is initialized to 1 instead of zero to make the length of the + * sequence part of s2, so that the length does not have to be checked + * separately. (Any sequence of zeroes has a Fletcher checksum of zero.)" + * + * @author John Leuner, Per Bothner + * @since JDK 1.1 + * + * @see InflaterInputStream + * @see DeflaterOutputStream + */ +public class Adler32 implements Checksum { + + /** largest prime smaller than 65536 */ + private static final int BASE = 65521; + + private int checksum; // we do all in int. + + // Note that java doesn't have unsigned integers, + // so we have to be careful with what arithmetic + // we do. We return the checksum as a long to + // avoid sign confusion. + + /** + * Creates a new instance of the Adler32 class. The checksum + * starts off with a value of 1. + */ + public Adler32() { + reset(); + } + + /** + * Resets the Adler32 checksum to the initial value. + */ + @Override + public void reset() { + checksum = 1; // Initialize to 1 + } + + /** + * Updates the checksum with the byte b. + * + * @param bval + * the data value to add. The high byte of the int is ignored. + */ + @Override + public void update(final int bval) { + // We could make a length 1 byte array and call update again, but I + // would rather not have that overhead + int s1 = checksum & 0xffff; + int s2 = checksum >>> 16; + + s1 = (s1 + (bval & 0xFF)) % BASE; + s2 = (s1 + s2) % BASE; + + checksum = (s2 << 16) + s1; + } + + /** + * Updates the checksum with the bytes taken from the array. + * + * @param buffer + * an array of bytes + */ + public void update(final byte[] buffer) { + update(buffer, 0, buffer.length); + } + + /** + * Updates the checksum with the bytes taken from the array. + * + * @param buf + * an array of bytes + * @param off + * the start of the data used for this update + * @param len + * the number of bytes to use for this update + */ + @Override + public void update(final byte[] buf, int off, int len) { + // (By Per Bothner) + int s1 = checksum & 0xffff; + int s2 = checksum >>> 16; + + while (len > 0) { + // We can defer the modulo operation: + // s1 maximally grows from 65521 to 65521 + 255 * 3800 + // s2 maximally grows by 3800 * median(s1) = 2090079800 < 2^31 + int n = 3800; + if (n > len) { + n = len; + } + len -= n; + while (--n >= 0) { + s1 = s1 + (buf[off++] & 0xFF); + s2 = s2 + s1; + } + s1 %= BASE; + s2 %= BASE; + } + + /* + * Old implementation, borrowed from somewhere: int n; + * + * while (len-- > 0) { + * + * s1 = (s1 + (bs[offset++] & 0xff)) % BASE; s2 = (s2 + s1) % BASE; } + */ + + checksum = (s2 << 16) | s1; + } + + /** + * Returns the Adler32 data checksum computed so far. + */ + @Override + public long getValue() { + return checksum & 0xffffffffL; + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/CRC32.java b/epublib-core/src/main/java/net/sf/jazzlib/CRC32.java new file mode 100644 index 00000000..f5d40cd4 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/CRC32.java @@ -0,0 +1,138 @@ +/* CRC32.java - Computes CRC32 data checksum of a data stream + Copyright (C) 1999. 2000, 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * The actual CRC32 algorithm is taken from RFC 1952. + * Status: Believed complete and correct. + */ + +/** + * Computes CRC32 data checksum of a data stream. The actual CRC32 algorithm is + * described in RFC 1952 (GZIP file format specification version 4.3). Can be + * used to get the CRC32 over a stream if used with checked input/output + * streams. + * + * @see InflaterInputStream + * @see DeflaterOutputStream + * + * @author Per Bothner + * @date April 1, 1999. + */ +public class CRC32 implements Checksum { + /** The crc data checksum so far. */ + private int crc = 0; + + /** The fast CRC table. Computed once when the CRC32 class is loaded. */ + private static int[] crc_table = make_crc_table(); + + /** Make the table for a fast CRC. */ + private static int[] make_crc_table() { + final int[] crc_table = new int[256]; + for (int n = 0; n < 256; n++) { + int c = n; + for (int k = 8; --k >= 0;) { + if ((c & 1) != 0) { + c = 0xedb88320 ^ (c >>> 1); + } else { + c = c >>> 1; + } + } + crc_table[n] = c; + } + return crc_table; + } + + /** + * Returns the CRC32 data checksum computed so far. + */ + @Override + public long getValue() { + return crc & 0xffffffffL; + } + + /** + * Resets the CRC32 data checksum as if no update was ever called. + */ + @Override + public void reset() { + crc = 0; + } + + /** + * Updates the checksum with the int bval. + * + * @param bval + * (the byte is taken as the lower 8 bits of bval) + */ + + @Override + public void update(final int bval) { + int c = ~crc; + c = crc_table[(c ^ bval) & 0xff] ^ (c >>> 8); + crc = ~c; + } + + /** + * Adds the byte array to the data checksum. + * + * @param buf + * the buffer which contains the data + * @param off + * the offset in the buffer where the data starts + * @param len + * the length of the data + */ + @Override + public void update(final byte[] buf, int off, int len) { + int c = ~crc; + while (--len >= 0) { + c = crc_table[(c ^ buf[off++]) & 0xff] ^ (c >>> 8); + } + crc = ~c; + } + + /** + * Adds the complete byte array to the data checksum. + */ + public void update(final byte[] buf) { + update(buf, 0, buf.length); + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/CheckedInputStream.java b/epublib-core/src/main/java/net/sf/jazzlib/CheckedInputStream.java new file mode 100644 index 00000000..80289057 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/CheckedInputStream.java @@ -0,0 +1,135 @@ +/* CheckedInputStream.java - Compute checksum of data being read + Copyright (C) 1999, 2000 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +import java.io.FilterInputStream; +import java.io.IOException; +import java.io.InputStream; + +/* Written using on-line Java Platform 1.2 API Specification + * and JCL book. + * Believed complete and correct. + */ + +/** + * InputStream that computes a checksum of the data being read using a supplied + * Checksum object. + * + * @see Checksum + * + * @author Tom Tromey + * @date May 17, 1999 + */ +public class CheckedInputStream extends FilterInputStream { + /** + * Creates a new CheckInputStream on top of the supplied OutputStream using + * the supplied Checksum. + */ + public CheckedInputStream(final InputStream in, final Checksum sum) { + super(in); + this.sum = sum; + } + + /** + * Returns the Checksum object used. To get the data checksum computed so + * far call getChecksum.getValue(). + */ + public Checksum getChecksum() { + return sum; + } + + /** + * Reads one byte, updates the checksum and returns the read byte (or -1 + * when the end of file was reached). + */ + @Override + public int read() throws IOException { + final int x = in.read(); + if (x != -1) { + sum.update(x); + } + return x; + } + + /** + * Reads at most len bytes in the supplied buffer and updates the checksum + * with it. Returns the number of bytes actually read or -1 when the end of + * file was reached. + */ + @Override + public int read(final byte[] buf, final int off, final int len) + throws IOException { + final int r = in.read(buf, off, len); + if (r != -1) { + sum.update(buf, off, r); + } + return r; + } + + /** + * Skips n bytes by reading them in a temporary buffer and updating the the + * checksum with that buffer. Returns the actual number of bytes skiped + * which can be less then requested when the end of file is reached. + */ + @Override + public long skip(long n) throws IOException { + if (n == 0) { + return 0; + } + + int min = (int) Math.min(n, 1024); + final byte[] buf = new byte[min]; + + long s = 0; + while (n > 0) { + final int r = in.read(buf, 0, min); + if (r == -1) { + break; + } + n -= r; + s += r; + min = (int) Math.min(n, 1024); + sum.update(buf, 0, r); + } + + return s; + } + + /** The checksum object. */ + private final Checksum sum; +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/CheckedOutputStream.java b/epublib-core/src/main/java/net/sf/jazzlib/CheckedOutputStream.java new file mode 100644 index 00000000..7077ec09 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/CheckedOutputStream.java @@ -0,0 +1,97 @@ +/* CheckedOutputStream.java - Compute checksum of data being written. + Copyright (C) 1999, 2000 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +import java.io.FilterOutputStream; +import java.io.IOException; +import java.io.OutputStream; + +/* Written using on-line Java Platform 1.2 API Specification + * and JCL book. + * Believed complete and correct. + */ + +/** + * OutputStream that computes a checksum of data being written using a supplied + * Checksum object. + * + * @see Checksum + * + * @author Tom Tromey + * @date May 17, 1999 + */ +public class CheckedOutputStream extends FilterOutputStream { + /** + * Creates a new CheckInputStream on top of the supplied OutputStream using + * the supplied Checksum. + */ + public CheckedOutputStream(final OutputStream out, final Checksum cksum) { + super(out); + this.sum = cksum; + } + + /** + * Returns the Checksum object used. To get the data checksum computed so + * far call getChecksum.getValue(). + */ + public Checksum getChecksum() { + return sum; + } + + /** + * Writes one byte to the OutputStream and updates the Checksum. + */ + @Override + public void write(final int bval) throws IOException { + out.write(bval); + sum.update(bval); + } + + /** + * Writes the byte array to the OutputStream and updates the Checksum. + */ + @Override + public void write(final byte[] buf, final int off, final int len) + throws IOException { + out.write(buf, off, len); + sum.update(buf, off, len); + } + + /** The checksum object. */ + private final Checksum sum; +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/Checksum.java b/epublib-core/src/main/java/net/sf/jazzlib/Checksum.java new file mode 100644 index 00000000..7bae782c --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/Checksum.java @@ -0,0 +1,89 @@ +/* Checksum.java - Interface to compute a data checksum + Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +/** + * Interface to compute a data checksum used by checked input/output streams. A + * data checksum can be updated by one byte or with a byte array. After each + * update the value of the current checksum can be returned by calling + * getValue. The complete checksum object can also be reset so it + * can be used again with new data. + * + * @see CheckedInputStream + * @see CheckedOutputStream + * + * @author Per Bothner + * @author Jochen Hoenicke + */ +public interface Checksum { + /** + * Returns the data checksum computed so far. + */ + long getValue(); + + /** + * Resets the data checksum as if no update was ever called. + */ + void reset(); + + /** + * Adds one byte to the data checksum. + * + * @param bval + * the data value to add. The high byte of the int is ignored. + */ + void update(int bval); + + /** + * Adds the byte array to the data checksum. + * + * @param buf + * the buffer which contains the data + * @param off + * the offset in the buffer where the data starts + * @param len + * the length of the data + */ + void update(byte[] buf, int off, int len); +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/DataFormatException.java b/epublib-core/src/main/java/net/sf/jazzlib/DataFormatException.java new file mode 100644 index 00000000..79501ec8 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/DataFormatException.java @@ -0,0 +1,69 @@ +/* DataformatException.java -- thrown when compressed data is corrupt + Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/** + * Exception thrown when compressed data is corrupt. + * + * @author Tom Tromey + * @author John Leuner + * @since 1.1 + * @status updated to 1.4 + */ +public class DataFormatException extends Exception { + /** + * Compatible with JDK 1.1+. + */ + private static final long serialVersionUID = 2219632870893641452L; + + /** + * Create an exception without a message. + */ + public DataFormatException() { + } + + /** + * Create an exception with a message. + * + * @param msg + * the message + */ + public DataFormatException(final String msg) { + super(msg); + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/Deflater.java b/epublib-core/src/main/java/net/sf/jazzlib/Deflater.java new file mode 100644 index 00000000..c9af5fe0 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/Deflater.java @@ -0,0 +1,511 @@ +/* Deflater.java - Compress a data stream + Copyright (C) 1999, 2000, 2001, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/** + * This is the Deflater class. The deflater class compresses input with the + * deflate algorithm described in RFC 1951. It has several compression levels + * and three different strategies described below. + * + * This class is not thread safe. This is inherent in the API, due to the + * split of deflate and setInput. + * + * @author Jochen Hoenicke + * @author Tom Tromey + */ +public class Deflater { + /** + * The best and slowest compression level. This tries to find very long and + * distant string repetitions. + */ + public static final int BEST_COMPRESSION = 9; + /** + * The worst but fastest compression level. + */ + public static final int BEST_SPEED = 1; + /** + * The default compression level. + */ + public static final int DEFAULT_COMPRESSION = -1; + /** + * This level won't compress at all but output uncompressed blocks. + */ + public static final int NO_COMPRESSION = 0; + + /** + * The default strategy. + */ + public static final int DEFAULT_STRATEGY = 0; + /** + * This strategy will only allow longer string repetitions. It is useful for + * random data with a small character set. + */ + public static final int FILTERED = 1; + + /** + * This strategy will not look for string repetitions at all. It only + * encodes with Huffman trees (which means, that more common characters get + * a smaller encoding. + */ + public static final int HUFFMAN_ONLY = 2; + + /** + * The compression method. This is the only method supported so far. There + * is no need to use this constant at all. + */ + public static final int DEFLATED = 8; + + /* + * The Deflater can do the following state transitions: + * + * (1) -> INIT_STATE ----> INIT_FINISHING_STATE ---. / | (2) (5) | / v (5) | + * (3)| SETDICT_STATE ---> SETDICT_FINISHING_STATE |(3) \ | (3) | ,-------' + * | | | (3) / v v (5) v v (1) -> BUSY_STATE ----> FINISHING_STATE | (6) v + * FINISHED_STATE \_____________________________________/ | (7) v + * CLOSED_STATE + * + * (1) If we should produce a header we start in INIT_STATE, otherwise we + * start in BUSY_STATE. (2) A dictionary may be set only when we are in + * INIT_STATE, then we change the state as indicated. (3) Whether a + * dictionary is set or not, on the first call of deflate we change to + * BUSY_STATE. (4) -- intentionally left blank -- :) (5) FINISHING_STATE is + * entered, when flush() is called to indicate that there is no more INPUT. + * There are also states indicating, that the header wasn't written yet. (6) + * FINISHED_STATE is entered, when everything has been flushed to the + * internal pending output buffer. (7) At any time (7) + */ + + private static final int IS_SETDICT = 0x01; + private static final int IS_FLUSHING = 0x04; + private static final int IS_FINISHING = 0x08; + + private static final int INIT_STATE = 0x00; + private static final int SETDICT_STATE = 0x01; + private static final int BUSY_STATE = 0x10; + private static final int FLUSHING_STATE = 0x14; + private static final int FINISHING_STATE = 0x1c; + private static final int FINISHED_STATE = 0x1e; + private static final int CLOSED_STATE = 0x7f; + + /** Compression level. */ + private int level; + + /** should we include a header. */ + private final boolean noHeader; + + /** The current state. */ + private int state; + + /** The total bytes of output written. */ + private int totalOut; + + /** The pending output. */ + private DeflaterPending pending; + + /** The deflater engine. */ + private DeflaterEngine engine; + + /** + * Creates a new deflater with default compression level. + */ + public Deflater() { + this(DEFAULT_COMPRESSION, false); + } + + /** + * Creates a new deflater with given compression level. + * + * @param lvl + * the compression level, a value between NO_COMPRESSION and + * BEST_COMPRESSION, or DEFAULT_COMPRESSION. + * @exception IllegalArgumentException + * if lvl is out of range. + */ + public Deflater(final int lvl) { + this(lvl, false); + } + + /** + * Creates a new deflater with given compression level. + * + * @param lvl + * the compression level, a value between NO_COMPRESSION and + * BEST_COMPRESSION. + * @param nowrap + * true, iff we should suppress the deflate header at the + * beginning and the adler checksum at the end of the output. + * This is useful for the GZIP format. + * @exception IllegalArgumentException + * if lvl is out of range. + */ + public Deflater(int lvl, final boolean nowrap) { + if (lvl == DEFAULT_COMPRESSION) { + lvl = 6; + } else if ((lvl < NO_COMPRESSION) || (lvl > BEST_COMPRESSION)) { + throw new IllegalArgumentException(); + } + + pending = new DeflaterPending(); + engine = new DeflaterEngine(pending); + this.noHeader = nowrap; + setStrategy(DEFAULT_STRATEGY); + setLevel(lvl); + reset(); + } + + /** + * Resets the deflater. The deflater acts afterwards as if it was just + * created with the same compression level and strategy as it had before. + */ + public void reset() { + state = (noHeader ? BUSY_STATE : INIT_STATE); + totalOut = 0; + pending.reset(); + engine.reset(); + } + + /** + * Frees all objects allocated by the compressor. There's no reason to call + * this, since you can just rely on garbage collection. Exists only for + * compatibility against Sun's JDK, where the compressor allocates native + * memory. If you call any method (even reset) afterwards the behaviour is + * undefined. + * + * @deprecated Just clear all references to deflater instead. + */ + @Deprecated + public void end() { + engine = null; + pending = null; + state = CLOSED_STATE; + } + + /** + * Gets the current adler checksum of the data that was processed so far. + */ + public int getAdler() { + return engine.getAdler(); + } + + /** + * Gets the number of input bytes processed so far. + */ + public int getTotalIn() { + return engine.getTotalIn(); + } + + /** + * Gets the number of output bytes so far. + */ + public int getTotalOut() { + return totalOut; + } + + /** + * Finalizes this object. + */ + @Override + protected void finalize() { + /* Exists solely for compatibility. We don't have any native state. */ + } + + /** + * Flushes the current input block. Further calls to deflate() will produce + * enough output to inflate everything in the current input block. This is + * not part of Sun's JDK so I have made it package private. It is used by + * DeflaterOutputStream to implement flush(). + */ + void flush() { + state |= IS_FLUSHING; + } + + /** + * Finishes the deflater with the current input block. It is an error to + * give more input after this method was called. This method must be called + * to force all bytes to be flushed. + */ + public void finish() { + state |= IS_FLUSHING | IS_FINISHING; + } + + /** + * Returns true iff the stream was finished and no more output bytes are + * available. + */ + public boolean finished() { + return (state == FINISHED_STATE) && pending.isFlushed(); + } + + /** + * Returns true, if the input buffer is empty. You should then call + * setInput().
+ * + * NOTE: This method can also return true when the stream was + * finished. + */ + public boolean needsInput() { + return engine.needsInput(); + } + + /** + * Sets the data which should be compressed next. This should be only called + * when needsInput indicates that more input is needed. If you call setInput + * when needsInput() returns false, the previous input that is still pending + * will be thrown away. The given byte array should not be changed, before + * needsInput() returns true again. This call is equivalent to + * setInput(input, 0, input.length). + * + * @param input + * the buffer containing the input data. + * @exception IllegalStateException + * if the buffer was finished() or ended(). + */ + public void setInput(final byte[] input) { + setInput(input, 0, input.length); + } + + /** + * Sets the data which should be compressed next. This should be only called + * when needsInput indicates that more input is needed. The given byte array + * should not be changed, before needsInput() returns true again. + * + * @param input + * the buffer containing the input data. + * @param off + * the start of the data. + * @param len + * the length of the data. + * @exception IllegalStateException + * if the buffer was finished() or ended() or if previous + * input is still pending. + */ + public void setInput(final byte[] input, final int off, final int len) { + if ((state & IS_FINISHING) != 0) { + throw new IllegalStateException("finish()/end() already called"); + } + engine.setInput(input, off, len); + } + + /** + * Sets the compression level. There is no guarantee of the exact position + * of the change, but if you call this when needsInput is true the change of + * compression level will occur somewhere near before the end of the so far + * given input. + * + * @param lvl + * the new compression level. + */ + public void setLevel(int lvl) { + if (lvl == DEFAULT_COMPRESSION) { + lvl = 6; + } else if ((lvl < NO_COMPRESSION) || (lvl > BEST_COMPRESSION)) { + throw new IllegalArgumentException(); + } + + if (level != lvl) { + level = lvl; + engine.setLevel(lvl); + } + } + + /** + * Sets the compression strategy. Strategy is one of DEFAULT_STRATEGY, + * HUFFMAN_ONLY and FILTERED. For the exact position where the strategy is + * changed, the same as for setLevel() applies. + * + * @param stgy + * the new compression strategy. + */ + public void setStrategy(final int stgy) { + if ((stgy != DEFAULT_STRATEGY) && (stgy != FILTERED) + && (stgy != HUFFMAN_ONLY)) { + throw new IllegalArgumentException(); + } + engine.setStrategy(stgy); + } + + /** + * Deflates the current input block to the given array. It returns the + * number of bytes compressed, or 0 if either needsInput() or finished() + * returns true or length is zero. + * + * @param output + * the buffer where to write the compressed data. + */ + public int deflate(final byte[] output) { + return deflate(output, 0, output.length); + } + + /** + * Deflates the current input block to the given array. It returns the + * number of bytes compressed, or 0 if either needsInput() or finished() + * returns true or length is zero. + * + * @param output + * the buffer where to write the compressed data. + * @param offset + * the offset into the output array. + * @param length + * the maximum number of bytes that may be written. + * @exception IllegalStateException + * if end() was called. + * @exception IndexOutOfBoundsException + * if offset and/or length don't match the array length. + */ + public int deflate(final byte[] output, int offset, int length) { + final int origLength = length; + + if (state == CLOSED_STATE) { + throw new IllegalStateException("Deflater closed"); + } + + if (state < BUSY_STATE) { + /* output header */ + int header = (DEFLATED + ((DeflaterConstants.MAX_WBITS - 8) << 4)) << 8; + int level_flags = (level - 1) >> 1; + if ((level_flags < 0) || (level_flags > 3)) { + level_flags = 3; + } + header |= level_flags << 6; + if ((state & IS_SETDICT) != 0) { + /* Dictionary was set */ + header |= DeflaterConstants.PRESET_DICT; + } + header += 31 - (header % 31); + + pending.writeShortMSB(header); + if ((state & IS_SETDICT) != 0) { + final int chksum = engine.getAdler(); + engine.resetAdler(); + pending.writeShortMSB(chksum >> 16); + pending.writeShortMSB(chksum & 0xffff); + } + + state = BUSY_STATE | (state & (IS_FLUSHING | IS_FINISHING)); + } + + for (;;) { + final int count = pending.flush(output, offset, length); + offset += count; + totalOut += count; + length -= count; + if ((length == 0) || (state == FINISHED_STATE)) { + break; + } + + if (!engine.deflate((state & IS_FLUSHING) != 0, + (state & IS_FINISHING) != 0)) { + if (state == BUSY_STATE) { + /* We need more input now */ + return origLength - length; + } else if (state == FLUSHING_STATE) { + if (level != NO_COMPRESSION) { + /* + * We have to supply some lookahead. 8 bit lookahead are + * needed by the zlib inflater, and we must fill the + * next byte, so that all bits are flushed. + */ + int neededbits = 8 + ((-pending.getBitCount()) & 7); + while (neededbits > 0) { + /* + * write a static tree block consisting solely of an + * EOF: + */ + pending.writeBits(2, 10); + neededbits -= 10; + } + } + state = BUSY_STATE; + } else if (state == FINISHING_STATE) { + pending.alignToByte(); + /* We have completed the stream */ + if (!noHeader) { + final int adler = engine.getAdler(); + pending.writeShortMSB(adler >> 16); + pending.writeShortMSB(adler & 0xffff); + } + state = FINISHED_STATE; + } + } + } + + return origLength - length; + } + + /** + * Sets the dictionary which should be used in the deflate process. This + * call is equivalent to setDictionary(dict, 0, + * dict.length). + * + * @param dict + * the dictionary. + * @exception IllegalStateException + * if setInput () or deflate () were already called or + * another dictionary was already set. + */ + public void setDictionary(final byte[] dict) { + setDictionary(dict, 0, dict.length); + } + + /** + * Sets the dictionary which should be used in the deflate process. The + * dictionary should be a byte array containing strings that are likely to + * occur in the data which should be compressed. The dictionary is not + * stored in the compressed output, only a checksum. To decompress the + * output you need to supply the same dictionary again. + * + * @param dict + * the dictionary. + * @param offset + * an offset into the dictionary. + * @param length + * the length of the dictionary. + * @exception IllegalStateException + * if setInput () or deflate () were already called or + * another dictionary was already set. + */ + public void setDictionary(final byte[] dict, final int offset, + final int length) { + if (state != INIT_STATE) { + throw new IllegalStateException(); + } + + state = SETDICT_STATE; + engine.setDictionary(dict, offset, length); + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/DeflaterConstants.java b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterConstants.java new file mode 100644 index 00000000..b3985f99 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterConstants.java @@ -0,0 +1,77 @@ +/* net.sf.jazzlib.DeflaterConstants + Copyright (C) 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +interface DeflaterConstants { + final static boolean DEBUGGING = false; + + final static int STORED_BLOCK = 0; + final static int STATIC_TREES = 1; + final static int DYN_TREES = 2; + final static int PRESET_DICT = 0x20; + + final static int DEFAULT_MEM_LEVEL = 8; + + final static int MAX_MATCH = 258; + final static int MIN_MATCH = 3; + + final static int MAX_WBITS = 15; + final static int WSIZE = 1 << MAX_WBITS; + final static int WMASK = WSIZE - 1; + + final static int HASH_BITS = DEFAULT_MEM_LEVEL + 7; + final static int HASH_SIZE = 1 << HASH_BITS; + final static int HASH_MASK = HASH_SIZE - 1; + final static int HASH_SHIFT = ((HASH_BITS + MIN_MATCH) - 1) / MIN_MATCH; + + final static int MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; + final static int MAX_DIST = WSIZE - MIN_LOOKAHEAD; + + final static int PENDING_BUF_SIZE = 1 << (DEFAULT_MEM_LEVEL + 8); + final static int MAX_BLOCK_SIZE = Math.min(65535, PENDING_BUF_SIZE - 5); + + final static int DEFLATE_STORED = 0; + final static int DEFLATE_FAST = 1; + final static int DEFLATE_SLOW = 2; + + final static int GOOD_LENGTH[] = { 0, 4, 4, 4, 4, 8, 8, 8, 32, 32 }; + final static int MAX_LAZY[] = { 0, 4, 5, 6, 4, 16, 16, 32, 128, 258 }; + final static int NICE_LENGTH[] = { 0, 8, 16, 32, 16, 32, 128, 128, 258, 258 }; + final static int MAX_CHAIN[] = { 0, 4, 8, 32, 16, 32, 128, 256, 1024, 4096 }; + final static int COMPR_FUNC[] = { 0, 1, 1, 1, 1, 2, 2, 2, 2, 2 }; +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/DeflaterEngine.java b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterEngine.java new file mode 100644 index 00000000..814d0c32 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterEngine.java @@ -0,0 +1,674 @@ +/* net.sf.jazzlib.DeflaterEngine + Copyright (C) 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +class DeflaterEngine implements DeflaterConstants { + private final static int TOO_FAR = 4096; + + private int ins_h; + + /** + * Hashtable, hashing three characters to an index for window, so that + * window[index]..window[index+2] have this hash code. Note that the array + * should really be unsigned short, so you need to and the values with + * 0xffff. + */ + private final short[] head; + + /** + * prev[index & WMASK] points to the previous index that has the same hash + * code as the string starting at index. This way entries with the same hash + * code are in a linked list. Note that the array should really be unsigned + * short, so you need to and the values with 0xffff. + */ + private final short[] prev; + + private int matchStart, matchLen; + private boolean prevAvailable; + private int blockStart; + + /** + * strstart points to the current character in window. + */ + private int strstart; + + /** + * lookahead is the number of characters starting at strstart in window that + * are valid. So window[strstart] until window[strstart+lookahead-1] are + * valid characters. + */ + private int lookahead; + + /** + * This array contains the part of the uncompressed stream that is of + * relevance. The current character is indexed by strstart. + */ + private final byte[] window; + + private int strategy, max_chain, max_lazy, niceLength, goodLength; + + /** The current compression function. */ + private int comprFunc; + + /** The input data for compression. */ + private byte[] inputBuf; + + /** The total bytes of input read. */ + private int totalIn; + + /** The offset into inputBuf, where input data starts. */ + private int inputOff; + + /** The end offset of the input data. */ + private int inputEnd; + + private final DeflaterPending pending; + private final DeflaterHuffman huffman; + + /** The adler checksum */ + private final Adler32 adler; + + /* + * DEFLATE ALGORITHM: + * + * The uncompressed stream is inserted into the window array. When the + * window array is full the first half is thrown away and the second half is + * copied to the beginning. + * + * The head array is a hash table. Three characters build a hash value and + * they the value points to the corresponding index in window of the last + * string with this hash. The prev array implements a linked list of matches + * with the same hash: prev[index & WMASK] points to the previous index with + * the same hash. + */ + + DeflaterEngine(final DeflaterPending pending) { + this.pending = pending; + huffman = new DeflaterHuffman(pending); + adler = new Adler32(); + + window = new byte[2 * WSIZE]; + head = new short[HASH_SIZE]; + prev = new short[WSIZE]; + + /* + * We start at index 1, to avoid a implementation deficiency, that we + * cannot build a repeat pattern at index 0. + */ + blockStart = strstart = 1; + } + + public void reset() { + huffman.reset(); + adler.reset(); + blockStart = strstart = 1; + lookahead = 0; + totalIn = 0; + prevAvailable = false; + matchLen = MIN_MATCH - 1; + for (int i = 0; i < HASH_SIZE; i++) { + head[i] = 0; + } + for (int i = 0; i < WSIZE; i++) { + prev[i] = 0; + } + } + + public final void resetAdler() { + adler.reset(); + } + + public final int getAdler() { + final int chksum = (int) adler.getValue(); + return chksum; + } + + public final int getTotalIn() { + return totalIn; + } + + public final void setStrategy(final int strat) { + strategy = strat; + } + + public void setLevel(final int lvl) { + goodLength = DeflaterConstants.GOOD_LENGTH[lvl]; + max_lazy = DeflaterConstants.MAX_LAZY[lvl]; + niceLength = DeflaterConstants.NICE_LENGTH[lvl]; + max_chain = DeflaterConstants.MAX_CHAIN[lvl]; + + if (DeflaterConstants.COMPR_FUNC[lvl] != comprFunc) { + if (DeflaterConstants.DEBUGGING) { + System.err.println("Change from " + comprFunc + " to " + + DeflaterConstants.COMPR_FUNC[lvl]); + } + switch (comprFunc) { + case DEFLATE_STORED: + if (strstart > blockStart) { + huffman.flushStoredBlock(window, blockStart, strstart + - blockStart, false); + blockStart = strstart; + } + updateHash(); + break; + case DEFLATE_FAST: + if (strstart > blockStart) { + huffman.flushBlock(window, blockStart, strstart + - blockStart, false); + blockStart = strstart; + } + break; + case DEFLATE_SLOW: + if (prevAvailable) { + huffman.tallyLit(window[strstart - 1] & 0xff); + } + if (strstart > blockStart) { + huffman.flushBlock(window, blockStart, strstart + - blockStart, false); + blockStart = strstart; + } + prevAvailable = false; + matchLen = MIN_MATCH - 1; + break; + } + comprFunc = COMPR_FUNC[lvl]; + } + } + + private final void updateHash() { + if (DEBUGGING) { + System.err.println("updateHash: " + strstart); + } + ins_h = (window[strstart] << HASH_SHIFT) ^ window[strstart + 1]; + } + + /** + * Inserts the current string in the head hash and returns the previous + * value for this hash. + */ + private final int insertString() { + short match; + final int hash = ((ins_h << HASH_SHIFT) ^ window[strstart + + (MIN_MATCH - 1)]) + & HASH_MASK; + + if (DEBUGGING) { + if (hash != (((window[strstart] << (2 * HASH_SHIFT)) + ^ (window[strstart + 1] << HASH_SHIFT) ^ (window[strstart + 2])) & HASH_MASK)) { + throw new InternalError("hash inconsistent: " + hash + "/" + + window[strstart] + "," + window[strstart + 1] + "," + + window[strstart + 2] + "," + HASH_SHIFT); + } + } + + prev[strstart & WMASK] = match = head[hash]; + head[hash] = (short) strstart; + ins_h = hash; + return match & 0xffff; + } + + private void slideWindow() { + System.arraycopy(window, WSIZE, window, 0, WSIZE); + matchStart -= WSIZE; + strstart -= WSIZE; + blockStart -= WSIZE; + + /* + * Slide the hash table (could be avoided with 32 bit values at the + * expense of memory usage). + */ + for (int i = 0; i < HASH_SIZE; i++) { + final int m = head[i] & 0xffff; + head[i] = m >= WSIZE ? (short) (m - WSIZE) : 0; + } + + /* + * Slide the prev table. + */ + for (int i = 0; i < WSIZE; i++) { + final int m = prev[i] & 0xffff; + prev[i] = m >= WSIZE ? (short) (m - WSIZE) : 0; + } + } + + /** + * Fill the window when the lookahead becomes insufficient. Updates strstart + * and lookahead. + * + * OUT assertions: strstart + lookahead <= 2*WSIZE lookahead >= + * MIN_LOOKAHEAD or inputOff == inputEnd + */ + private void fillWindow() { + /* + * If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (strstart >= (WSIZE + MAX_DIST)) { + slideWindow(); + } + + /* + * If there is not enough lookahead, but still some input left, read in + * the input + */ + while ((lookahead < DeflaterConstants.MIN_LOOKAHEAD) + && (inputOff < inputEnd)) { + int more = (2 * WSIZE) - lookahead - strstart; + + if (more > (inputEnd - inputOff)) { + more = inputEnd - inputOff; + } + + System.arraycopy(inputBuf, inputOff, window, strstart + lookahead, + more); + adler.update(inputBuf, inputOff, more); + inputOff += more; + totalIn += more; + lookahead += more; + } + + if (lookahead >= MIN_MATCH) { + updateHash(); + } + } + + /** + * Find the best (longest) string in the window matching the string starting + * at strstart. + * + * Preconditions: strstart + MAX_MATCH <= window.length. + * + * + * @param curMatch + */ + private boolean findLongestMatch(int curMatch) { + int chainLength = this.max_chain; + int niceLength = this.niceLength; + final short[] prev = this.prev; + int scan = this.strstart; + int match; + int best_end = this.strstart + matchLen; + int best_len = Math.max(matchLen, MIN_MATCH - 1); + + final int limit = Math.max(strstart - MAX_DIST, 0); + + final int strend = (scan + MAX_MATCH) - 1; + byte scan_end1 = window[best_end - 1]; + byte scan_end = window[best_end]; + + /* Do not waste too much time if we already have a good match: */ + if (best_len >= this.goodLength) { + chainLength >>= 2; + } + + /* + * Do not look for matches beyond the end of the input. This is + * necessary to make deflate deterministic. + */ + if (niceLength > lookahead) { + niceLength = lookahead; + } + + if (DeflaterConstants.DEBUGGING + && (strstart > ((2 * WSIZE) - MIN_LOOKAHEAD))) { + throw new InternalError("need lookahead"); + } + + do { + if (DeflaterConstants.DEBUGGING && (curMatch >= strstart)) { + throw new InternalError("future match"); + } + if ((window[curMatch + best_len] != scan_end) + || (window[(curMatch + best_len) - 1] != scan_end1) + || (window[curMatch] != window[scan]) + || (window[curMatch + 1] != window[scan + 1])) { + continue; + } + + match = curMatch + 2; + scan += 2; + + /* + * We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + while ((window[++scan] == window[++match]) + && (window[++scan] == window[++match]) + && (window[++scan] == window[++match]) + && (window[++scan] == window[++match]) + && (window[++scan] == window[++match]) + && (window[++scan] == window[++match]) + && (window[++scan] == window[++match]) + && (window[++scan] == window[++match]) && (scan < strend)) { + ; + } + + if (scan > best_end) { + // if (DeflaterConstants.DEBUGGING && ins_h == 0) + // System.err.println("Found match: "+curMatch+"-"+(scan-strstart)); + matchStart = curMatch; + best_end = scan; + best_len = scan - strstart; + if (best_len >= niceLength) { + break; + } + + scan_end1 = window[best_end - 1]; + scan_end = window[best_end]; + } + scan = strstart; + } while (((curMatch = (prev[curMatch & WMASK] & 0xffff)) > limit) + && (--chainLength != 0)); + + matchLen = Math.min(best_len, lookahead); + return matchLen >= MIN_MATCH; + } + + void setDictionary(final byte[] buffer, int offset, int length) { + if (DeflaterConstants.DEBUGGING && (strstart != 1)) { + throw new IllegalStateException("strstart not 1"); + } + adler.update(buffer, offset, length); + if (length < MIN_MATCH) { + return; + } + if (length > MAX_DIST) { + offset += length - MAX_DIST; + length = MAX_DIST; + } + + System.arraycopy(buffer, offset, window, strstart, length); + + updateHash(); + length--; + while (--length > 0) { + insertString(); + strstart++; + } + strstart += 2; + blockStart = strstart; + } + + private boolean deflateStored(final boolean flush, final boolean finish) { + if (!flush && (lookahead == 0)) { + return false; + } + + strstart += lookahead; + lookahead = 0; + + int storedLen = strstart - blockStart; + + if ((storedLen >= DeflaterConstants.MAX_BLOCK_SIZE) + /* Block is full */ + || ((blockStart < WSIZE) && (storedLen >= MAX_DIST)) + /* Block may move out of window */ + || flush) { + boolean lastBlock = finish; + if (storedLen > DeflaterConstants.MAX_BLOCK_SIZE) { + storedLen = DeflaterConstants.MAX_BLOCK_SIZE; + lastBlock = false; + } + + if (DeflaterConstants.DEBUGGING) { + System.err.println("storedBlock[" + storedLen + "," + lastBlock + + "]"); + } + + huffman.flushStoredBlock(window, blockStart, storedLen, lastBlock); + blockStart += storedLen; + return !lastBlock; + } + return true; + } + + private boolean deflateFast(final boolean flush, final boolean finish) { + if ((lookahead < MIN_LOOKAHEAD) && !flush) { + return false; + } + + while ((lookahead >= MIN_LOOKAHEAD) || flush) { + if (lookahead == 0) { + /* We are flushing everything */ + huffman.flushBlock(window, blockStart, strstart - blockStart, + finish); + blockStart = strstart; + return false; + } + + if (strstart > ((2 * WSIZE) - MIN_LOOKAHEAD)) { + /* + * slide window, as findLongestMatch need this. This should only + * happen when flushing and the window is almost full. + */ + slideWindow(); + } + + int hashHead; + if ((lookahead >= MIN_MATCH) && ((hashHead = insertString()) != 0) + && (strategy != Deflater.HUFFMAN_ONLY) + && ((strstart - hashHead) <= MAX_DIST) + && findLongestMatch(hashHead)) { + /* longestMatch sets matchStart and matchLen */ + if (DeflaterConstants.DEBUGGING) { + for (int i = 0; i < matchLen; i++) { + if (window[strstart + i] != window[matchStart + i]) { + throw new InternalError(); + } + } + } + huffman.tallyDist(strstart - matchStart, matchLen); + + lookahead -= matchLen; + if ((matchLen <= max_lazy) && (lookahead >= MIN_MATCH)) { + while (--matchLen > 0) { + strstart++; + insertString(); + } + strstart++; + } else { + strstart += matchLen; + if (lookahead >= (MIN_MATCH - 1)) { + updateHash(); + } + } + matchLen = MIN_MATCH - 1; + continue; + } else { + /* No match found */ + huffman.tallyLit(window[strstart] & 0xff); + strstart++; + lookahead--; + } + + if (huffman.isFull()) { + final boolean lastBlock = finish && (lookahead == 0); + huffman.flushBlock(window, blockStart, strstart - blockStart, + lastBlock); + blockStart = strstart; + return !lastBlock; + } + } + return true; + } + + private boolean deflateSlow(final boolean flush, final boolean finish) { + if ((lookahead < MIN_LOOKAHEAD) && !flush) { + return false; + } + + while ((lookahead >= MIN_LOOKAHEAD) || flush) { + if (lookahead == 0) { + if (prevAvailable) { + huffman.tallyLit(window[strstart - 1] & 0xff); + } + prevAvailable = false; + + /* We are flushing everything */ + if (DeflaterConstants.DEBUGGING && !flush) { + throw new InternalError("Not flushing, but no lookahead"); + } + huffman.flushBlock(window, blockStart, strstart - blockStart, + finish); + blockStart = strstart; + return false; + } + + if (strstart >= ((2 * WSIZE) - MIN_LOOKAHEAD)) { + /* + * slide window, as findLongestMatch need this. This should only + * happen when flushing and the window is almost full. + */ + slideWindow(); + } + + final int prevMatch = matchStart; + int prevLen = matchLen; + if (lookahead >= MIN_MATCH) { + final int hashHead = insertString(); + if ((strategy != Deflater.HUFFMAN_ONLY) && (hashHead != 0) + && ((strstart - hashHead) <= MAX_DIST) + && findLongestMatch(hashHead)) { + /* longestMatch sets matchStart and matchLen */ + + /* Discard match if too small and too far away */ + if ((matchLen <= 5) + && ((strategy == Deflater.FILTERED) || ((matchLen == MIN_MATCH) && ((strstart - matchStart) > TOO_FAR)))) { + matchLen = MIN_MATCH - 1; + } + } + } + + /* previous match was better */ + if ((prevLen >= MIN_MATCH) && (matchLen <= prevLen)) { + if (DeflaterConstants.DEBUGGING) { + for (int i = 0; i < matchLen; i++) { + if (window[(strstart - 1) + i] != window[prevMatch + i]) { + throw new InternalError(); + } + } + } + huffman.tallyDist(strstart - 1 - prevMatch, prevLen); + prevLen -= 2; + do { + strstart++; + lookahead--; + if (lookahead >= MIN_MATCH) { + insertString(); + } + } while (--prevLen > 0); + strstart++; + lookahead--; + prevAvailable = false; + matchLen = MIN_MATCH - 1; + } else { + if (prevAvailable) { + huffman.tallyLit(window[strstart - 1] & 0xff); + } + prevAvailable = true; + strstart++; + lookahead--; + } + + if (huffman.isFull()) { + int len = strstart - blockStart; + if (prevAvailable) { + len--; + } + final boolean lastBlock = (finish && (lookahead == 0) && !prevAvailable); + huffman.flushBlock(window, blockStart, len, lastBlock); + blockStart += len; + return !lastBlock; + } + } + return true; + } + + public boolean deflate(final boolean flush, final boolean finish) { + boolean progress; + do { + fillWindow(); + final boolean canFlush = flush && (inputOff == inputEnd); + if (DeflaterConstants.DEBUGGING) { + System.err.println("window: [" + blockStart + "," + strstart + + "," + lookahead + "], " + comprFunc + "," + canFlush); + } + switch (comprFunc) { + case DEFLATE_STORED: + progress = deflateStored(canFlush, finish); + break; + case DEFLATE_FAST: + progress = deflateFast(canFlush, finish); + break; + case DEFLATE_SLOW: + progress = deflateSlow(canFlush, finish); + break; + default: + throw new InternalError(); + } + } while (pending.isFlushed() /* repeat while we have no pending output */ + && progress); /* and progress was made */ + + return progress; + } + + public void setInput(final byte[] buf, final int off, final int len) { + if (inputOff < inputEnd) { + throw new IllegalStateException( + "Old input was not completely processed"); + } + + final int end = off + len; + + /* + * We want to throw an ArrayIndexOutOfBoundsException early. The check + * is very tricky: it also handles integer wrap around. + */ + if ((0 > off) || (off > end) || (end > buf.length)) { + throw new ArrayIndexOutOfBoundsException(); + } + + inputBuf = buf; + inputOff = off; + inputEnd = end; + } + + public final boolean needsInput() { + return inputEnd == inputOff; + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/DeflaterHuffman.java b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterHuffman.java new file mode 100644 index 00000000..75913ac6 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterHuffman.java @@ -0,0 +1,748 @@ +/* net.sf.jazzlib.DeflaterHuffman + Copyright (C) 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/** + * This is the DeflaterHuffman class. + * + * This class is not thread safe. This is inherent in the API, due to the + * split of deflate and setInput. + * + * @author Jochen Hoenicke + * @date Jan 6, 2000 + */ +class DeflaterHuffman { + private static final int BUFSIZE = 1 << (DeflaterConstants.DEFAULT_MEM_LEVEL + 6); + private static final int LITERAL_NUM = 286; + private static final int DIST_NUM = 30; + private static final int BITLEN_NUM = 19; + private static final int REP_3_6 = 16; + private static final int REP_3_10 = 17; + private static final int REP_11_138 = 18; + private static final int EOF_SYMBOL = 256; + private static final int[] BL_ORDER = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, + 11, 4, 12, 3, 13, 2, 14, 1, 15 }; + + private final static String bit4Reverse = "\000\010\004\014\002\012\006\016\001\011\005\015\003\013\007\017"; + + class Tree { + short[] freqs; + short[] codes; + byte[] length; + int[] bl_counts; + int minNumCodes, numCodes; + int maxLength; + + Tree(final int elems, final int minCodes, final int maxLength) { + this.minNumCodes = minCodes; + this.maxLength = maxLength; + freqs = new short[elems]; + bl_counts = new int[maxLength]; + } + + void reset() { + for (int i = 0; i < freqs.length; i++) { + freqs[i] = 0; + } + codes = null; + length = null; + } + + final void writeSymbol(final int code) { + if (DeflaterConstants.DEBUGGING) { + freqs[code]--; + // System.err.print("writeSymbol("+freqs.length+","+code+"): "); + } + pending.writeBits(codes[code] & 0xffff, length[code]); + } + + final void checkEmpty() { + boolean empty = true; + for (int i = 0; i < freqs.length; i++) { + if (freqs[i] != 0) { + System.err.println("freqs[" + i + "] == " + freqs[i]); + empty = false; + } + } + if (!empty) { + throw new InternalError(); + } + System.err.println("checkEmpty suceeded!"); + } + + void setStaticCodes(final short[] stCodes, final byte[] stLength) { + codes = stCodes; + length = stLength; + } + + public void buildCodes() { + final int[] nextCode = new int[maxLength]; + int code = 0; + codes = new short[freqs.length]; + + if (DeflaterConstants.DEBUGGING) { + System.err.println("buildCodes: " + freqs.length); + } + for (int bits = 0; bits < maxLength; bits++) { + nextCode[bits] = code; + code += bl_counts[bits] << (15 - bits); + if (DeflaterConstants.DEBUGGING) { + System.err.println("bits: " + (bits + 1) + " count: " + + bl_counts[bits] + " nextCode: " + + Integer.toHexString(code)); + } + } + if (DeflaterConstants.DEBUGGING && (code != 65536)) { + throw new RuntimeException("Inconsistent bl_counts!"); + } + + for (int i = 0; i < numCodes; i++) { + final int bits = length[i]; + if (bits > 0) { + if (DeflaterConstants.DEBUGGING) { + System.err.println("codes[" + i + "] = rev(" + + Integer.toHexString(nextCode[bits - 1]) + + ")," + bits); + } + codes[i] = bitReverse(nextCode[bits - 1]); + nextCode[bits - 1] += 1 << (16 - bits); + } + } + } + + private void buildLength(final int childs[]) { + this.length = new byte[freqs.length]; + final int numNodes = childs.length / 2; + final int numLeafs = (numNodes + 1) / 2; + int overflow = 0; + + for (int i = 0; i < maxLength; i++) { + bl_counts[i] = 0; + } + + /* First calculate optimal bit lengths */ + final int lengths[] = new int[numNodes]; + lengths[numNodes - 1] = 0; + for (int i = numNodes - 1; i >= 0; i--) { + if (childs[(2 * i) + 1] != -1) { + int bitLength = lengths[i] + 1; + if (bitLength > maxLength) { + bitLength = maxLength; + overflow++; + } + lengths[childs[2 * i]] = lengths[childs[(2 * i) + 1]] = bitLength; + } else { + /* A leaf node */ + final int bitLength = lengths[i]; + bl_counts[bitLength - 1]++; + this.length[childs[2 * i]] = (byte) lengths[i]; + } + } + + if (DeflaterConstants.DEBUGGING) { + System.err.println("Tree " + freqs.length + " lengths:"); + for (int i = 0; i < numLeafs; i++) { + System.err.println("Node " + childs[2 * i] + " freq: " + + freqs[childs[2 * i]] + " len: " + + length[childs[2 * i]]); + } + } + + if (overflow == 0) { + return; + } + + int incrBitLen = maxLength - 1; + do { + /* Find the first bit length which could increase: */ + while (bl_counts[--incrBitLen] == 0) { + ; + } + + /* + * Move this node one down and remove a corresponding amount of + * overflow nodes. + */ + do { + bl_counts[incrBitLen]--; + bl_counts[++incrBitLen]++; + overflow -= 1 << (maxLength - 1 - incrBitLen); + } while ((overflow > 0) && (incrBitLen < (maxLength - 1))); + } while (overflow > 0); + + /* + * We may have overshot above. Move some nodes from maxLength to + * maxLength-1 in that case. + */ + bl_counts[maxLength - 1] += overflow; + bl_counts[maxLength - 2] -= overflow; + + /* + * Now recompute all bit lengths, scanning in increasing frequency. + * It is simpler to reconstruct all lengths instead of fixing only + * the wrong ones. This idea is taken from 'ar' written by Haruhiko + * Okumura. + * + * The nodes were inserted with decreasing frequency into the childs + * array. + */ + int nodePtr = 2 * numLeafs; + for (int bits = maxLength; bits != 0; bits--) { + int n = bl_counts[bits - 1]; + while (n > 0) { + final int childPtr = 2 * childs[nodePtr++]; + if (childs[childPtr + 1] == -1) { + /* We found another leaf */ + length[childs[childPtr]] = (byte) bits; + n--; + } + } + } + if (DeflaterConstants.DEBUGGING) { + System.err.println("*** After overflow elimination. ***"); + for (int i = 0; i < numLeafs; i++) { + System.err.println("Node " + childs[2 * i] + " freq: " + + freqs[childs[2 * i]] + " len: " + + length[childs[2 * i]]); + } + } + } + + void buildTree() { + final int numSymbols = freqs.length; + + /* + * heap is a priority queue, sorted by frequency, least frequent + * nodes first. The heap is a binary tree, with the property, that + * the parent node is smaller than both child nodes. This assures + * that the smallest node is the first parent. + * + * The binary tree is encoded in an array: 0 is root node and the + * nodes 2*n+1, 2*n+2 are the child nodes of node n. + */ + final int[] heap = new int[numSymbols]; + int heapLen = 0; + int maxCode = 0; + for (int n = 0; n < numSymbols; n++) { + final int freq = freqs[n]; + if (freq != 0) { + /* Insert n into heap */ + int pos = heapLen++; + int ppos; + while ((pos > 0) + && (freqs[heap[ppos = (pos - 1) / 2]] > freq)) { + heap[pos] = heap[ppos]; + pos = ppos; + } + heap[pos] = n; + maxCode = n; + } + } + + /* + * We could encode a single literal with 0 bits but then we don't + * see the literals. Therefore we force at least two literals to + * avoid this case. We don't care about order in this case, both + * literals get a 1 bit code. + */ + while (heapLen < 2) { + final int node = maxCode < 2 ? ++maxCode : 0; + heap[heapLen++] = node; + } + + numCodes = Math.max(maxCode + 1, minNumCodes); + + final int numLeafs = heapLen; + final int[] childs = new int[(4 * heapLen) - 2]; + final int[] values = new int[(2 * heapLen) - 1]; + int numNodes = numLeafs; + for (int i = 0; i < heapLen; i++) { + final int node = heap[i]; + childs[2 * i] = node; + childs[(2 * i) + 1] = -1; + values[i] = freqs[node] << 8; + heap[i] = i; + } + + /* + * Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + do { + final int first = heap[0]; + int last = heap[--heapLen]; + + /* Propagate the hole to the leafs of the heap */ + int ppos = 0; + int path = 1; + while (path < heapLen) { + if (((path + 1) < heapLen) + && (values[heap[path]] > values[heap[path + 1]])) { + path++; + } + + heap[ppos] = heap[path]; + ppos = path; + path = (path * 2) + 1; + } + + /* + * Now propagate the last element down along path. Normally it + * shouldn't go too deep. + */ + int lastVal = values[last]; + while (((path = ppos) > 0) + && (values[heap[ppos = (path - 1) / 2]] > lastVal)) { + heap[path] = heap[ppos]; + } + heap[path] = last; + + final int second = heap[0]; + + /* Create a new node father of first and second */ + last = numNodes++; + childs[2 * last] = first; + childs[(2 * last) + 1] = second; + final int mindepth = Math.min(values[first] & 0xff, + values[second] & 0xff); + values[last] = lastVal = ((values[first] + values[second]) - mindepth) + 1; + + /* Again, propagate the hole to the leafs */ + ppos = 0; + path = 1; + while (path < heapLen) { + if (((path + 1) < heapLen) + && (values[heap[path]] > values[heap[path + 1]])) { + path++; + } + + heap[ppos] = heap[path]; + ppos = path; + path = (ppos * 2) + 1; + } + + /* Now propagate the new element down along path */ + while (((path = ppos) > 0) + && (values[heap[ppos = (path - 1) / 2]] > lastVal)) { + heap[path] = heap[ppos]; + } + heap[path] = last; + } while (heapLen > 1); + + if (heap[0] != ((childs.length / 2) - 1)) { + throw new RuntimeException("Weird!"); + } + + buildLength(childs); + } + + int getEncodedLength() { + int len = 0; + for (int i = 0; i < freqs.length; i++) { + len += freqs[i] * length[i]; + } + return len; + } + + void calcBLFreq(final Tree blTree) { + int max_count; /* max repeat count */ + int min_count; /* min repeat count */ + int count; /* repeat count of the current code */ + int curlen = -1; /* length of current code */ + + int i = 0; + while (i < numCodes) { + count = 1; + final int nextlen = length[i]; + if (nextlen == 0) { + max_count = 138; + min_count = 3; + } else { + max_count = 6; + min_count = 3; + if (curlen != nextlen) { + blTree.freqs[nextlen]++; + count = 0; + } + } + curlen = nextlen; + i++; + + while ((i < numCodes) && (curlen == length[i])) { + i++; + if (++count >= max_count) { + break; + } + } + + if (count < min_count) { + blTree.freqs[curlen] += count; + } else if (curlen != 0) { + blTree.freqs[REP_3_6]++; + } else if (count <= 10) { + blTree.freqs[REP_3_10]++; + } else { + blTree.freqs[REP_11_138]++; + } + } + } + + void writeTree(final Tree blTree) { + int max_count; /* max repeat count */ + int min_count; /* min repeat count */ + int count; /* repeat count of the current code */ + int curlen = -1; /* length of current code */ + + int i = 0; + while (i < numCodes) { + count = 1; + final int nextlen = length[i]; + if (nextlen == 0) { + max_count = 138; + min_count = 3; + } else { + max_count = 6; + min_count = 3; + if (curlen != nextlen) { + blTree.writeSymbol(nextlen); + count = 0; + } + } + curlen = nextlen; + i++; + + while ((i < numCodes) && (curlen == length[i])) { + i++; + if (++count >= max_count) { + break; + } + } + + if (count < min_count) { + while (count-- > 0) { + blTree.writeSymbol(curlen); + } + } else if (curlen != 0) { + blTree.writeSymbol(REP_3_6); + pending.writeBits(count - 3, 2); + } else if (count <= 10) { + blTree.writeSymbol(REP_3_10); + pending.writeBits(count - 3, 3); + } else { + blTree.writeSymbol(REP_11_138); + pending.writeBits(count - 11, 7); + } + } + } + } + + DeflaterPending pending; + private final Tree literalTree, distTree, blTree; + + private final short d_buf[]; + private final byte l_buf[]; + private int last_lit; + private int extra_bits; + + private static short staticLCodes[]; + private static byte staticLLength[]; + private static short staticDCodes[]; + private static byte staticDLength[]; + + /** + * Reverse the bits of a 16 bit value. + */ + static short bitReverse(final int value) { + return (short) ((bit4Reverse.charAt(value & 0xf) << 12) + | (bit4Reverse.charAt((value >> 4) & 0xf) << 8) + | (bit4Reverse.charAt((value >> 8) & 0xf) << 4) | bit4Reverse + .charAt(value >> 12)); + } + + static { + /* See RFC 1951 3.2.6 */ + /* Literal codes */ + staticLCodes = new short[LITERAL_NUM]; + staticLLength = new byte[LITERAL_NUM]; + int i = 0; + while (i < 144) { + staticLCodes[i] = bitReverse((0x030 + i) << 8); + staticLLength[i++] = 8; + } + while (i < 256) { + staticLCodes[i] = bitReverse(((0x190 - 144) + i) << 7); + staticLLength[i++] = 9; + } + while (i < 280) { + staticLCodes[i] = bitReverse(((0x000 - 256) + i) << 9); + staticLLength[i++] = 7; + } + while (i < LITERAL_NUM) { + staticLCodes[i] = bitReverse(((0x0c0 - 280) + i) << 8); + staticLLength[i++] = 8; + } + + /* Distant codes */ + staticDCodes = new short[DIST_NUM]; + staticDLength = new byte[DIST_NUM]; + for (i = 0; i < DIST_NUM; i++) { + staticDCodes[i] = bitReverse(i << 11); + staticDLength[i] = 5; + } + } + + public DeflaterHuffman(final DeflaterPending pending) { + this.pending = pending; + + literalTree = new Tree(LITERAL_NUM, 257, 15); + distTree = new Tree(DIST_NUM, 1, 15); + blTree = new Tree(BITLEN_NUM, 4, 7); + + d_buf = new short[BUFSIZE]; + l_buf = new byte[BUFSIZE]; + } + + public final void reset() { + last_lit = 0; + extra_bits = 0; + literalTree.reset(); + distTree.reset(); + blTree.reset(); + } + + private final int l_code(int len) { + if (len == 255) { + return 285; + } + + int code = 257; + while (len >= 8) { + code += 4; + len >>= 1; + } + return code + len; + } + + private final int d_code(int distance) { + int code = 0; + while (distance >= 4) { + code += 2; + distance >>= 1; + } + return code + distance; + } + + public void sendAllTrees(final int blTreeCodes) { + blTree.buildCodes(); + literalTree.buildCodes(); + distTree.buildCodes(); + pending.writeBits(literalTree.numCodes - 257, 5); + pending.writeBits(distTree.numCodes - 1, 5); + pending.writeBits(blTreeCodes - 4, 4); + for (int rank = 0; rank < blTreeCodes; rank++) { + pending.writeBits(blTree.length[BL_ORDER[rank]], 3); + } + literalTree.writeTree(blTree); + distTree.writeTree(blTree); + if (DeflaterConstants.DEBUGGING) { + blTree.checkEmpty(); + } + } + + public void compressBlock() { + for (int i = 0; i < last_lit; i++) { + final int litlen = l_buf[i] & 0xff; + int dist = d_buf[i]; + if (dist-- != 0) { + if (DeflaterConstants.DEBUGGING) { + System.err.print("[" + (dist + 1) + "," + (litlen + 3) + + "]: "); + } + + final int lc = l_code(litlen); + literalTree.writeSymbol(lc); + + int bits = (lc - 261) / 4; + if ((bits > 0) && (bits <= 5)) { + pending.writeBits(litlen & ((1 << bits) - 1), bits); + } + + final int dc = d_code(dist); + distTree.writeSymbol(dc); + + bits = (dc / 2) - 1; + if (bits > 0) { + pending.writeBits(dist & ((1 << bits) - 1), bits); + } + } else { + if (DeflaterConstants.DEBUGGING) { + if ((litlen > 32) && (litlen < 127)) { + System.err.print("(" + (char) litlen + "): "); + } else { + System.err.print("{" + litlen + "}: "); + } + } + literalTree.writeSymbol(litlen); + } + } + if (DeflaterConstants.DEBUGGING) { + System.err.print("EOF: "); + } + literalTree.writeSymbol(EOF_SYMBOL); + if (DeflaterConstants.DEBUGGING) { + literalTree.checkEmpty(); + distTree.checkEmpty(); + } + } + + public void flushStoredBlock(final byte[] stored, final int stored_offset, + final int stored_len, final boolean lastBlock) { + if (DeflaterConstants.DEBUGGING) { + System.err.println("Flushing stored block " + stored_len); + } + pending.writeBits((DeflaterConstants.STORED_BLOCK << 1) + + (lastBlock ? 1 : 0), 3); + pending.alignToByte(); + pending.writeShort(stored_len); + pending.writeShort(~stored_len); + pending.writeBlock(stored, stored_offset, stored_len); + reset(); + } + + public void flushBlock(final byte[] stored, final int stored_offset, + final int stored_len, final boolean lastBlock) { + literalTree.freqs[EOF_SYMBOL]++; + + /* Build trees */ + literalTree.buildTree(); + distTree.buildTree(); + + /* Calculate bitlen frequency */ + literalTree.calcBLFreq(blTree); + distTree.calcBLFreq(blTree); + + /* Build bitlen tree */ + blTree.buildTree(); + + int blTreeCodes = 4; + for (int i = 18; i > blTreeCodes; i--) { + if (blTree.length[BL_ORDER[i]] > 0) { + blTreeCodes = i + 1; + } + } + int opt_len = 14 + (blTreeCodes * 3) + blTree.getEncodedLength() + + literalTree.getEncodedLength() + distTree.getEncodedLength() + + extra_bits; + + int static_len = extra_bits; + for (int i = 0; i < LITERAL_NUM; i++) { + static_len += literalTree.freqs[i] * staticLLength[i]; + } + for (int i = 0; i < DIST_NUM; i++) { + static_len += distTree.freqs[i] * staticDLength[i]; + } + if (opt_len >= static_len) { + /* Force static trees */ + opt_len = static_len; + } + + if ((stored_offset >= 0) && ((stored_len + 4) < (opt_len >> 3))) { + /* Store Block */ + if (DeflaterConstants.DEBUGGING) { + System.err.println("Storing, since " + stored_len + " < " + + opt_len + " <= " + static_len); + } + flushStoredBlock(stored, stored_offset, stored_len, lastBlock); + } else if (opt_len == static_len) { + /* Encode with static tree */ + pending.writeBits((DeflaterConstants.STATIC_TREES << 1) + + (lastBlock ? 1 : 0), 3); + literalTree.setStaticCodes(staticLCodes, staticLLength); + distTree.setStaticCodes(staticDCodes, staticDLength); + compressBlock(); + reset(); + } else { + /* Encode with dynamic tree */ + pending.writeBits((DeflaterConstants.DYN_TREES << 1) + + (lastBlock ? 1 : 0), 3); + sendAllTrees(blTreeCodes); + compressBlock(); + reset(); + } + } + + public final boolean isFull() { + return last_lit == BUFSIZE; + } + + public final boolean tallyLit(final int lit) { + if (DeflaterConstants.DEBUGGING) { + if ((lit > 32) && (lit < 127)) { + System.err.println("(" + (char) lit + ")"); + } else { + System.err.println("{" + lit + "}"); + } + } + d_buf[last_lit] = 0; + l_buf[last_lit++] = (byte) lit; + literalTree.freqs[lit]++; + return last_lit == BUFSIZE; + } + + public final boolean tallyDist(final int dist, final int len) { + if (DeflaterConstants.DEBUGGING) { + System.err.println("[" + dist + "," + len + "]"); + } + + d_buf[last_lit] = (short) dist; + l_buf[last_lit++] = (byte) (len - 3); + + final int lc = l_code(len - 3); + literalTree.freqs[lc]++; + if ((lc >= 265) && (lc < 285)) { + extra_bits += (lc - 261) / 4; + } + + final int dc = d_code(dist - 1); + distTree.freqs[dc]++; + if (dc >= 4) { + extra_bits += (dc / 2) - 1; + } + return last_lit == BUFSIZE; + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/DeflaterOutputStream.java b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterOutputStream.java new file mode 100644 index 00000000..bbc021fd --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterOutputStream.java @@ -0,0 +1,210 @@ +/* DeflaterOutputStream.java - Output filter for compressing. + Copyright (C) 1999, 2000, 2001, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +import java.io.FilterOutputStream; +import java.io.IOException; +import java.io.OutputStream; + +/* Written using on-line Java Platform 1.2 API Specification + * and JCL book. + * Believed complete and correct. + */ + +/** + * This is a special FilterOutputStream deflating the bytes that are written + * through it. It uses the Deflater for deflating. + * + * A special thing to be noted is that flush() doesn't flush everything in Sun's + * JDK, but it does so in jazzlib. This is because Sun's Deflater doesn't have a + * way to flush() everything, without finishing the stream. + * + * @author Tom Tromey, Jochen Hoenicke + * @date Jan 11, 2001 + */ +public class DeflaterOutputStream extends FilterOutputStream { + /** + * This buffer is used temporarily to retrieve the bytes from the deflater + * and write them to the underlying output stream. + */ + protected byte[] buf; + + /** + * The deflater which is used to deflate the stream. + */ + protected Deflater def; + + /** + * Deflates everything in the def's input buffers. This will call + * def.deflate() until all bytes from the input buffers are + * processed. + */ + protected void deflate() throws IOException { + while (!def.needsInput()) { + final int len = def.deflate(buf, 0, buf.length); + + // System.err.println("DOS deflated " + len + " out of " + + // buf.length); + if (len <= 0) { + break; + } + out.write(buf, 0, len); + } + + if (!def.needsInput()) { + throw new InternalError("Can't deflate all input?"); + } + } + + /** + * Creates a new DeflaterOutputStream with a default Deflater and default + * buffer size. + * + * @param out + * the output stream where deflated output should be written. + */ + public DeflaterOutputStream(final OutputStream out) { + this(out, new Deflater(), 512); + } + + /** + * Creates a new DeflaterOutputStream with the given Deflater and default + * buffer size. + * + * @param out + * the output stream where deflated output should be written. + * @param defl + * the underlying deflater. + */ + public DeflaterOutputStream(final OutputStream out, final Deflater defl) { + this(out, defl, 512); + } + + /** + * Creates a new DeflaterOutputStream with the given Deflater and buffer + * size. + * + * @param out + * the output stream where deflated output should be written. + * @param defl + * the underlying deflater. + * @param bufsize + * the buffer size. + * @exception IllegalArgumentException + * if bufsize isn't positive. + */ + public DeflaterOutputStream(final OutputStream out, final Deflater defl, + final int bufsize) { + super(out); + if (bufsize <= 0) { + throw new IllegalArgumentException("bufsize <= 0"); + } + buf = new byte[bufsize]; + def = defl; + } + + /** + * Flushes the stream by calling flush() on the deflater and then on the + * underlying stream. This ensures that all bytes are flushed. This function + * doesn't work in Sun's JDK, but only in jazzlib. + */ + @Override + public void flush() throws IOException { + def.flush(); + deflate(); + out.flush(); + } + + /** + * Finishes the stream by calling finish() on the deflater. This was the + * only way to ensure that all bytes are flushed in Sun's JDK. + */ + public void finish() throws IOException { + def.finish(); + while (!def.finished()) { + final int len = def.deflate(buf, 0, buf.length); + if (len <= 0) { + break; + } + out.write(buf, 0, len); + } + if (!def.finished()) { + throw new InternalError("Can't deflate all input?"); + } + out.flush(); + } + + /** + * Calls finish () and closes the stream. + */ + @Override + public void close() throws IOException { + finish(); + out.close(); + } + + /** + * Writes a single byte to the compressed output stream. + * + * @param bval + * the byte value. + */ + @Override + public void write(final int bval) throws IOException { + final byte[] b = new byte[1]; + b[0] = (byte) bval; + write(b, 0, 1); + } + + /** + * Writes a len bytes from an array to the compressed stream. + * + * @param buf + * the byte array. + * @param off + * the offset into the byte array where to start. + * @param len + * the number of bytes to write. + */ + @Override + public void write(final byte[] buf, final int off, final int len) + throws IOException { + def.setInput(buf, off, len); + deflate(); + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/DeflaterPending.java b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterPending.java new file mode 100644 index 00000000..e3f0dcaa --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/DeflaterPending.java @@ -0,0 +1,51 @@ +/* net.sf.jazzlib.DeflaterPending + Copyright (C) 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/** + * This class stores the pending output of the Deflater. + * + * @author Jochen Hoenicke + * @date Jan 5, 2000 + */ + +class DeflaterPending extends PendingBuffer { + public DeflaterPending() { + super(DeflaterConstants.PENDING_BUF_SIZE); + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/GZIPInputStream.java b/epublib-core/src/main/java/net/sf/jazzlib/GZIPInputStream.java new file mode 100644 index 00000000..e9111ede --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/GZIPInputStream.java @@ -0,0 +1,369 @@ +/* GZIPInputStream.java - Input filter for reading gzip file + Copyright (C) 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +import java.io.EOFException; +import java.io.IOException; +import java.io.InputStream; + +/** + * This filter stream is used to decompress a "GZIP" format stream. The "GZIP" + * format is described in RFC 1952. + * + * @author John Leuner + * @author Tom Tromey + * @since JDK 1.1 + */ +public class GZIPInputStream extends InflaterInputStream { + /** + * The magic number found at the start of a GZIP stream. + */ + public static final int GZIP_MAGIC = 0x1f8b; + + /** + * The mask for bit 0 of the flag byte. + */ + static final int FTEXT = 0x1; + + /** + * The mask for bit 1 of the flag byte. + */ + static final int FHCRC = 0x2; + + /** + * The mask for bit 2 of the flag byte. + */ + static final int FEXTRA = 0x4; + + /** + * The mask for bit 3 of the flag byte. + */ + static final int FNAME = 0x8; + + /** + * The mask for bit 4 of the flag byte. + */ + static final int FCOMMENT = 0x10; + + /** + * The CRC-32 checksum value for uncompressed data. + */ + protected CRC32 crc; + + /** + * Indicates whether or not the end of the stream has been reached. + */ + protected boolean eos; + + /** + * Indicates whether or not the GZIP header has been read in. + */ + private boolean readGZIPHeader; + + /** + * Creates a GZIPInputStream with the default buffer size. + * + * @param in + * The stream to read compressed data from (in GZIP format). + * + * @throws IOException + * if an error occurs during an I/O operation. + */ + public GZIPInputStream(final InputStream in) throws IOException { + this(in, 4096); + } + + /** + * Creates a GZIPInputStream with the specified buffer size. + * + * @param in + * The stream to read compressed data from (in GZIP format). + * @param size + * The size of the buffer to use. + * + * @throws IOException + * if an error occurs during an I/O operation. + * @throws IllegalArgumentException + * if size is less than or equal to 0. + */ + public GZIPInputStream(final InputStream in, final int size) + throws IOException { + super(in, new Inflater(true), size); + crc = new CRC32(); + } + + /** + * Closes the input stream. + * + * @throws IOException + * if an error occurs during an I/O operation. + */ + @Override + public void close() throws IOException { + // Nothing to do here. + super.close(); + } + + /** + * Reads in GZIP-compressed data and stores it in uncompressed form into an + * array of bytes. The method will block until either enough input data + * becomes available or the compressed stream reaches its end. + * + * @param buf + * the buffer into which the uncompressed data will be stored. + * @param offset + * the offset indicating where in buf the + * uncompressed data should be placed. + * @param len + * the number of uncompressed bytes to be read. + */ + @Override + public int read(final byte[] buf, final int offset, final int len) + throws IOException { + // We first have to slurp in the GZIP header, then we feed all the + // rest of the data to the superclass. + // + // As we do that we continually update the CRC32. Once the data is + // finished, we check the CRC32. + // + // This means we don't need our own buffer, as everything is done + // in the superclass. + if (!readGZIPHeader) { + readHeader(); + } + + if (eos) { + return -1; + } + + // System.err.println("GZIPIS.read(byte[], off, len ... " + offset + + // " and len " + len); + + /* + * We don't have to read the header, so we just grab data from the + * superclass. + */ + final int numRead = super.read(buf, offset, len); + if (numRead > 0) { + crc.update(buf, offset, numRead); + } + + if (inf.finished()) { + readFooter(); + } + return numRead; + } + + /** + * Reads in the GZIP header. + */ + private void readHeader() throws IOException { + /* 1. Check the two magic bytes */ + final CRC32 headCRC = new CRC32(); + int magic = in.read(); + if (magic < 0) { + eos = true; + return; + } + headCRC.update(magic); + if (magic != (GZIP_MAGIC >> 8)) { + throw new IOException( + "Error in GZIP header, first byte doesn't match"); + } + + magic = in.read(); + if (magic != (GZIP_MAGIC & 0xff)) { + throw new IOException( + "Error in GZIP header, second byte doesn't match"); + } + headCRC.update(magic); + + /* 2. Check the compression type (must be 8) */ + final int CM = in.read(); + if (CM != 8) { + throw new IOException( + "Error in GZIP header, data not in deflate format"); + } + headCRC.update(CM); + + /* 3. Check the flags */ + final int flags = in.read(); + if (flags < 0) { + throw new EOFException("Early EOF in GZIP header"); + } + headCRC.update(flags); + + /* + * This flag byte is divided into individual bits as follows: + * + * bit 0 FTEXT bit 1 FHCRC bit 2 FEXTRA bit 3 FNAME bit 4 FCOMMENT bit 5 + * reserved bit 6 reserved bit 7 reserved + */ + + /* 3.1 Check the reserved bits are zero */ + if ((flags & 0xd0) != 0) { + throw new IOException("Reserved flag bits in GZIP header != 0"); + } + + /* 4.-6. Skip the modification time, extra flags, and OS type */ + for (int i = 0; i < 6; i++) { + final int readByte = in.read(); + if (readByte < 0) { + throw new EOFException("Early EOF in GZIP header"); + } + headCRC.update(readByte); + } + + /* 7. Read extra field */ + if ((flags & FEXTRA) != 0) { + /* Skip subfield id */ + for (int i = 0; i < 2; i++) { + final int readByte = in.read(); + if (readByte < 0) { + throw new EOFException("Early EOF in GZIP header"); + } + headCRC.update(readByte); + } + if ((in.read() < 0) || (in.read() < 0)) { + throw new EOFException("Early EOF in GZIP header"); + } + + int len1, len2, extraLen; + len1 = in.read(); + len2 = in.read(); + if ((len1 < 0) || (len2 < 0)) { + throw new EOFException("Early EOF in GZIP header"); + } + headCRC.update(len1); + headCRC.update(len2); + + extraLen = (len1 << 8) | len2; + for (int i = 0; i < extraLen; i++) { + final int readByte = in.read(); + if (readByte < 0) { + throw new EOFException("Early EOF in GZIP header"); + } + headCRC.update(readByte); + } + } + + /* 8. Read file name */ + if ((flags & FNAME) != 0) { + int readByte; + while ((readByte = in.read()) > 0) { + headCRC.update(readByte); + } + if (readByte < 0) { + throw new EOFException("Early EOF in GZIP file name"); + } + headCRC.update(readByte); + } + + /* 9. Read comment */ + if ((flags & FCOMMENT) != 0) { + int readByte; + while ((readByte = in.read()) > 0) { + headCRC.update(readByte); + } + + if (readByte < 0) { + throw new EOFException("Early EOF in GZIP comment"); + } + headCRC.update(readByte); + } + + /* 10. Read header CRC */ + if ((flags & FHCRC) != 0) { + int tempByte; + int crcval = in.read(); + if (crcval < 0) { + throw new EOFException("Early EOF in GZIP header"); + } + + tempByte = in.read(); + if (tempByte < 0) { + throw new EOFException("Early EOF in GZIP header"); + } + + crcval = (crcval << 8) | tempByte; + if (crcval != ((int) headCRC.getValue() & 0xffff)) { + throw new IOException("Header CRC value mismatch"); + } + } + + readGZIPHeader = true; + // System.err.println("Read GZIP header"); + } + + private void readFooter() throws IOException { + final byte[] footer = new byte[8]; + int avail = inf.getRemaining(); + if (avail > 8) { + avail = 8; + } + System.arraycopy(buf, len - inf.getRemaining(), footer, 0, avail); + int needed = 8 - avail; + while (needed > 0) { + final int count = in.read(footer, 8 - needed, needed); + if (count <= 0) { + throw new EOFException("Early EOF in GZIP footer"); + } + needed -= count; // Jewel Jan 16 + } + + final int crcval = (footer[0] & 0xff) | ((footer[1] & 0xff) << 8) + | ((footer[2] & 0xff) << 16) | (footer[3] << 24); + if (crcval != (int) crc.getValue()) { + throw new IOException("GZIP crc sum mismatch, theirs \"" + + Integer.toHexString(crcval) + "\" and ours \"" + + Integer.toHexString((int) crc.getValue())); + } + + final int total = (footer[4] & 0xff) | ((footer[5] & 0xff) << 8) + | ((footer[6] & 0xff) << 16) | (footer[7] << 24); + if (total != inf.getTotalOut()) { + throw new IOException("Number of bytes mismatch"); + } + + /* + * FIXME" XXX Should we support multiple members. Difficult, since there + * may be some bytes still in buf + */ + eos = true; + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/GZIPOutputStream.java b/epublib-core/src/main/java/net/sf/jazzlib/GZIPOutputStream.java new file mode 100644 index 00000000..26d27c4d --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/GZIPOutputStream.java @@ -0,0 +1,150 @@ +/* GZIPOutputStream.java - Create a file in gzip format + Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +import java.io.IOException; +import java.io.OutputStream; + +/** + * This filter stream is used to compress a stream into a "GZIP" stream. The + * "GZIP" format is described in RFC 1952. + * + * @author John Leuner + * @author Tom Tromey + * @since JDK 1.1 + */ + +/* + * Written using on-line Java Platform 1.2 API Specification and JCL book. + * Believed complete and correct. + */ + +public class GZIPOutputStream extends DeflaterOutputStream { + /** + * CRC-32 value for uncompressed data + */ + protected CRC32 crc; + + /* + * Creates a GZIPOutputStream with the default buffer size + * + * + * @param out The stream to read data (to be compressed) from + */ + public GZIPOutputStream(final OutputStream out) throws IOException { + this(out, 4096); + } + + /** + * Creates a GZIPOutputStream with the specified buffer size + * + * @param out + * The stream to read compressed data from + * @param size + * Size of the buffer to use + */ + public GZIPOutputStream(final OutputStream out, final int size) + throws IOException { + super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true), size); + + crc = new CRC32(); + final int mod_time = (int) (System.currentTimeMillis() / 1000L); + final byte[] gzipHeader = { + /* The two magic bytes */ + (byte) (GZIPInputStream.GZIP_MAGIC >> 8), + (byte) GZIPInputStream.GZIP_MAGIC, + + /* The compression type */ + (byte) Deflater.DEFLATED, + + /* The flags (not set) */ + 0, + + /* The modification time */ + (byte) mod_time, (byte) (mod_time >> 8), + (byte) (mod_time >> 16), (byte) (mod_time >> 24), + + /* The extra flags */ + 0, + + /* The OS type (unknown) */ + (byte) 255 }; + + out.write(gzipHeader); + // System.err.println("wrote GZIP header (" + gzipHeader.length + + // " bytes )"); + } + + @Override + public synchronized void write(final byte[] buf, final int off, + final int len) throws IOException { + super.write(buf, off, len); + crc.update(buf, off, len); + } + + /** + * Writes remaining compressed output data to the output stream and closes + * it. + */ + @Override + public void close() throws IOException { + finish(); + out.close(); + } + + @Override + public void finish() throws IOException { + super.finish(); + + final int totalin = def.getTotalIn(); + final int crcval = (int) (crc.getValue() & 0xffffffff); + + // System.err.println("CRC val is " + Integer.toHexString( crcval ) + + // " and length " + Integer.toHexString(totalin)); + + final byte[] gzipFooter = { (byte) crcval, (byte) (crcval >> 8), + (byte) (crcval >> 16), (byte) (crcval >> 24), + + (byte) totalin, (byte) (totalin >> 8), (byte) (totalin >> 16), + (byte) (totalin >> 24) }; + + out.write(gzipFooter); + // System.err.println("wrote GZIP trailer (" + gzipFooter.length + + // " bytes )"); + } +} diff --git a/epublib-core/src/main/java/net/sf/jazzlib/Inflater.java b/epublib-core/src/main/java/net/sf/jazzlib/Inflater.java new file mode 100644 index 00000000..9e5b9b61 --- /dev/null +++ b/epublib-core/src/main/java/net/sf/jazzlib/Inflater.java @@ -0,0 +1,710 @@ +/* Inflater.java - Decompress a data stream + Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package net.sf.jazzlib; + +/* Written using on-line Java Platform 1.2 API Specification + * and JCL book. + * Believed complete and correct. + */ + +/** + * Inflater is used to decompress data that has been compressed according to the + * "deflate" standard described in rfc1950. + * + * The usage is as following. First you have to set some input with + * setInput(), then inflate() it. If inflate doesn't inflate any + * bytes there may be three reasons: + *

+ *
• needsInput() returns true because the input buffer is empty. You have to + * provide more input with setInput(). NOTE: needsInput() also + * returns true when, the stream is finished.
+ *
• needsDictionary() returns true, you have to provide a preset dictionary + * with setDictionary().
+ *
• finished() returns true, the inflater has finished.
+ *