kunfei
3 years ago
committed by
GitHub
commit
3aed980f5e
@ -0,0 +1,197 @@ |
|||||||
|
/* Adler32.java - Computes Adler32 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/* |
||||||
|
* Written using on-line Java Platform 1.2 API Specification, as well |
||||||
|
* as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). |
||||||
|
* The actual Adler32 algorithm is taken from RFC 1950. |
||||||
|
* Status: Believed complete and correct. |
||||||
|
*/ |
||||||
|
|
||||||
|
/** |
||||||
|
* Computes Adler32 checksum for a stream of data. An Adler32 |
||||||
|
* checksum is not as reliable as a CRC32 checksum, but a lot faster to |
||||||
|
* compute. |
||||||
|
* <p> |
||||||
|
* The specification for Adler32 may be found in RFC 1950. |
||||||
|
* (ZLIB Compressed Data Format Specification version 3.3) |
||||||
|
* <p> |
||||||
|
* <p> |
||||||
|
* From that document: |
||||||
|
* <p> |
||||||
|
* "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. |
||||||
|
* <p> |
||||||
|
* 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." |
||||||
|
* <p> |
||||||
|
* "8.2. The Adler-32 algorithm |
||||||
|
* <p> |
||||||
|
* The Adler-32 algorithm is much faster than the CRC32 algorithm yet |
||||||
|
* still provides an extremely low probability of undetected errors. |
||||||
|
* <p> |
||||||
|
* 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.) |
||||||
|
* <p> |
||||||
|
* 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 |
||||||
|
* @see InflaterInputStream |
||||||
|
* @see DeflaterOutputStream |
||||||
|
* @since JDK 1.1 |
||||||
|
*/ |
||||||
|
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 <code>Adler32</code> class. |
||||||
|
* The checksum starts off with a value of 1. |
||||||
|
*/ |
||||||
|
public Adler32() { |
||||||
|
reset(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Resets the Adler32 checksum to the initial value. |
||||||
|
*/ |
||||||
|
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. |
||||||
|
*/ |
||||||
|
public void update(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(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 |
||||||
|
*/ |
||||||
|
public void update(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. |
||||||
|
*/ |
||||||
|
public long getValue() { |
||||||
|
return (long) checksum & 0xffffffffL; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,368 @@ |
|||||||
|
package me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import android.content.Context; |
||||||
|
import android.net.Uri; |
||||||
|
import android.os.ParcelFileDescriptor; |
||||||
|
import android.system.ErrnoException; |
||||||
|
import android.system.OsConstants; |
||||||
|
|
||||||
|
import androidx.annotation.NonNull; |
||||||
|
|
||||||
|
import java.io.Closeable; |
||||||
|
import java.io.DataInput; |
||||||
|
import java.io.DataInputStream; |
||||||
|
import java.io.EOFException; |
||||||
|
import java.io.FileDescriptor; |
||||||
|
import java.io.FileInputStream; |
||||||
|
import java.io.FileNotFoundException; |
||||||
|
import java.io.IOException; |
||||||
|
import java.nio.ByteBuffer; |
||||||
|
import java.nio.ByteOrder; |
||||||
|
import java.nio.channels.FileChannel; |
||||||
|
|
||||||
|
public class AndroidRandomReadableFile implements DataInput, Closeable { |
||||||
|
private ParcelFileDescriptor pfd; |
||||||
|
private FileInputStream fis; |
||||||
|
private DataInputStream dis; |
||||||
|
public long pos = 0; |
||||||
|
|
||||||
|
public AndroidRandomReadableFile(@NonNull Context context, @NonNull Uri treeUri) throws FileNotFoundException { |
||||||
|
try { |
||||||
|
pfd = context.getContentResolver().openFileDescriptor(treeUri, "r"); |
||||||
|
fis = new FileInputStream(pfd.getFileDescriptor()); |
||||||
|
dis = new DataInputStream(fis); |
||||||
|
} catch (FileNotFoundException e) { |
||||||
|
throw e; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public final FileDescriptor getFD() { |
||||||
|
return pfd.getFileDescriptor(); |
||||||
|
} |
||||||
|
|
||||||
|
public final FileChannel getChannel() { |
||||||
|
if (fis == null || pos != getPos()) { |
||||||
|
fis = new FileInputStream(pfd.getFileDescriptor()); |
||||||
|
} |
||||||
|
return fis.getChannel(); |
||||||
|
} |
||||||
|
|
||||||
|
public final FileInputStream getFileInputStream() { |
||||||
|
if (fis == null || pos != getPos()) { |
||||||
|
fis = new FileInputStream(pfd.getFileDescriptor()); |
||||||
|
} |
||||||
|
return fis; |
||||||
|
} |
||||||
|
|
||||||
|
public int read() throws IOException { |
||||||
|
byte[] b = new byte[1]; |
||||||
|
return (read(b, 0, 1) != -1) ? b[0] & 0xff : -1; |
||||||
|
} |
||||||
|
|
||||||
|
public int read(byte[] b) { |
||||||
|
try { |
||||||
|
return read(b, 0, b.length); |
||||||
|
} catch (IOException e) { |
||||||
|
e.printStackTrace(); |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public int read(byte[] b, int off, int len) throws IOException { |
||||||
|
try { |
||||||
|
return android.system.Os.read(pfd.getFileDescriptor(), b, off, len); |
||||||
|
} catch (Exception e) { |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
private void syncInputStream() { |
||||||
|
fis = new FileInputStream(pfd.getFileDescriptor()); |
||||||
|
dis = new DataInputStream(fis); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
public void seek(long pos) throws IOException { |
||||||
|
try { |
||||||
|
android.system.Os.lseek(pfd.getFileDescriptor(), pos, OsConstants.SEEK_SET); |
||||||
|
} catch (Exception e) { |
||||||
|
throw new IOException(e); |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
public long length() throws IOException { |
||||||
|
try { |
||||||
|
return android.system.Os.lseek(pfd.getFileDescriptor(), 0, OsConstants.SEEK_END); |
||||||
|
} catch (Exception e) { |
||||||
|
throw new IOException(e); |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
public long getPos() { |
||||||
|
try { |
||||||
|
return android.system.Os.lseek(pfd.getFileDescriptor(), 0, OsConstants.SEEK_CUR); |
||||||
|
} catch (Exception e) { |
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public void readFully(byte[] b) throws IOException { |
||||||
|
try { |
||||||
|
android.system.Os.read(pfd.getFileDescriptor(), b, 0, b.length); |
||||||
|
} catch (ErrnoException e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public void readFully(byte[] b, int off, int len) throws IOException { |
||||||
|
try { |
||||||
|
android.system.Os.read(pfd.getFileDescriptor(), b, off, len); |
||||||
|
//syncInputStream();
|
||||||
|
} catch (ErrnoException e) { |
||||||
|
throw new IOException(e); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public int skipBytes(int n) throws IOException { |
||||||
|
try { |
||||||
|
byte[] b = new byte[n]; |
||||||
|
return android.system.Os.read(pfd.getFileDescriptor(), b, 0, b.length); |
||||||
|
} catch (Exception e) { |
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public boolean readBoolean() throws IOException { |
||||||
|
int ch = this.read(); |
||||||
|
if (ch < 0) |
||||||
|
throw new EOFException(); |
||||||
|
return (ch != 0); |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public byte readByte() throws IOException { |
||||||
|
int ch = this.read(); |
||||||
|
if (ch < 0) |
||||||
|
throw new EOFException(); |
||||||
|
return (byte) (ch); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
@Override |
||||||
|
public int readUnsignedByte() throws IOException { |
||||||
|
int ch = this.read(); |
||||||
|
if (ch < 0) |
||||||
|
throw new EOFException(); |
||||||
|
return ch; |
||||||
|
} |
||||||
|
|
||||||
|
private final byte[] readBuffer = new byte[8]; |
||||||
|
|
||||||
|
@Override |
||||||
|
public short readShort() throws IOException { |
||||||
|
readFully(readBuffer, 0, 2); |
||||||
|
return ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asShortBuffer().get(); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public int readUnsignedShort() throws IOException { |
||||||
|
readFully(readBuffer, 0, 2); |
||||||
|
return ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asShortBuffer().get() & 0xffff; |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public char readChar() throws IOException { |
||||||
|
readFully(readBuffer, 0, 2); |
||||||
|
return (char) ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asShortBuffer().get(); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public int readInt() throws IOException { |
||||||
|
readFully(readBuffer, 0, 4); |
||||||
|
return ByteBuffer.wrap(readBuffer).order(ByteOrder.BIG_ENDIAN).asIntBuffer().get(); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public long readLong() throws IOException { |
||||||
|
readFully(readBuffer, 0, 8); |
||||||
|
return (((long) readBuffer[0] << 56) + |
||||||
|
((long) (readBuffer[1] & 255) << 48) + |
||||||
|
((long) (readBuffer[2] & 255) << 40) + |
||||||
|
((long) (readBuffer[3] & 255) << 32) + |
||||||
|
((long) (readBuffer[4] & 255) << 24) + |
||||||
|
((readBuffer[5] & 255) << 16) + |
||||||
|
((readBuffer[6] & 255) << 8) + |
||||||
|
((readBuffer[7] & 255) << 0)); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public float readFloat() throws IOException { |
||||||
|
return Float.intBitsToFloat(readInt()); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public double readDouble() throws IOException { |
||||||
|
return Double.longBitsToDouble(readLong()); |
||||||
|
} |
||||||
|
|
||||||
|
private char[] lineBuffer; |
||||||
|
|
||||||
|
@Deprecated |
||||||
|
@Override |
||||||
|
public String readLine() throws IOException { |
||||||
|
char[] buf = lineBuffer; |
||||||
|
|
||||||
|
if (buf == null) { |
||||||
|
buf = lineBuffer = new char[128]; |
||||||
|
} |
||||||
|
|
||||||
|
int room = buf.length; |
||||||
|
int offset = 0; |
||||||
|
int c; |
||||||
|
|
||||||
|
loop: |
||||||
|
while (true) { |
||||||
|
switch (c = this.read()) { |
||||||
|
case -1: |
||||||
|
case '\n': |
||||||
|
break loop; |
||||||
|
|
||||||
|
case '\r': |
||||||
|
int c2 = this.read(); |
||||||
|
break loop; |
||||||
|
|
||||||
|
default: |
||||||
|
if (--room < 0) { |
||||||
|
buf = new char[offset + 128]; |
||||||
|
room = buf.length - offset - 1; |
||||||
|
System.arraycopy(lineBuffer, 0, buf, 0, offset); |
||||||
|
lineBuffer = buf; |
||||||
|
} |
||||||
|
buf[offset++] = (char) c; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
if ((c == -1) && (offset == 0)) { |
||||||
|
return null; |
||||||
|
} |
||||||
|
return String.copyValueOf(buf, 0, offset); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public String readUTF() throws IOException { |
||||||
|
if (pos != getPos()) { |
||||||
|
syncInputStream(); |
||||||
|
} |
||||||
|
return dis.readUTF(); |
||||||
|
} |
||||||
|
|
||||||
|
// public final static String readUTF(DataInput in) throws IOException {
|
||||||
|
// int utflen = in.readUnsignedShort();
|
||||||
|
// byte[] bytearr = null;
|
||||||
|
// char[] chararr = null;
|
||||||
|
// if (in instanceof DataInputStream) {
|
||||||
|
// DataInputStream dis = (DataInputStream)in;
|
||||||
|
// if (dis.bytearr.length < utflen){
|
||||||
|
// dis.bytearr = new byte[utflen*2];
|
||||||
|
// dis.chararr = new char[utflen*2];
|
||||||
|
// }
|
||||||
|
// chararr = dis.chararr;
|
||||||
|
// bytearr = dis.bytearr;
|
||||||
|
// } else {
|
||||||
|
// bytearr = new byte[utflen];
|
||||||
|
// chararr = new char[utflen];
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// int c, char2, char3;
|
||||||
|
// int count = 0;
|
||||||
|
// int chararr_count=0;
|
||||||
|
//
|
||||||
|
// in.readFully(bytearr, 0, utflen);
|
||||||
|
//
|
||||||
|
// while (count < utflen) {
|
||||||
|
// c = (int) bytearr[count] & 0xff;
|
||||||
|
// if (c > 127) break;
|
||||||
|
// count++;
|
||||||
|
// chararr[chararr_count++]=(char)c;
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// while (count < utflen) {
|
||||||
|
// c = (int) bytearr[count] & 0xff;
|
||||||
|
// switch (c >> 4) {
|
||||||
|
// case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
|
||||||
|
// /* 0xxxxxxx*/
|
||||||
|
// count++;
|
||||||
|
// chararr[chararr_count++]=(char)c;
|
||||||
|
// break;
|
||||||
|
// case 12: case 13:
|
||||||
|
// /* 110x xxxx 10xx xxxx*/
|
||||||
|
// count += 2;
|
||||||
|
// if (count > utflen)
|
||||||
|
// throw new UTFDataFormatException(
|
||||||
|
// "malformed input: partial character at end");
|
||||||
|
// char2 = (int) bytearr[count-1];
|
||||||
|
// if ((char2 & 0xC0) != 0x80)
|
||||||
|
// throw new UTFDataFormatException(
|
||||||
|
// "malformed input around byte " + count);
|
||||||
|
// chararr[chararr_count++]=(char)(((c & 0x1F) << 6) |
|
||||||
|
// (char2 & 0x3F));
|
||||||
|
// break;
|
||||||
|
// case 14:
|
||||||
|
// /* 1110 xxxx 10xx xxxx 10xx xxxx */
|
||||||
|
// count += 3;
|
||||||
|
// if (count > utflen)
|
||||||
|
// throw new UTFDataFormatException(
|
||||||
|
// "malformed input: partial character at end");
|
||||||
|
// char2 = (int) bytearr[count-2];
|
||||||
|
// char3 = (int) bytearr[count-1];
|
||||||
|
// if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))
|
||||||
|
// throw new UTFDataFormatException(
|
||||||
|
// "malformed input around byte " + (count-1));
|
||||||
|
// chararr[chararr_count++]=(char)(((c & 0x0F) << 12) |
|
||||||
|
// ((char2 & 0x3F) << 6) |
|
||||||
|
// ((char3 & 0x3F) << 0));
|
||||||
|
// break;
|
||||||
|
// default:
|
||||||
|
// /* 10xx xxxx, 1111 xxxx */
|
||||||
|
// throw new UTFDataFormatException(
|
||||||
|
// "malformed input around byte " + count);
|
||||||
|
// }
|
||||||
|
// }
|
||||||
|
// // The number of chars produced may be less than utflen
|
||||||
|
// return new String(chararr, 0, chararr_count);
|
||||||
|
// }
|
||||||
|
|
||||||
|
@Override |
||||||
|
public void close() throws IOException { |
||||||
|
try { |
||||||
|
dis.close(); |
||||||
|
} catch (Exception e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
|
||||||
|
try { |
||||||
|
fis.close(); |
||||||
|
} catch (Exception e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
try { |
||||||
|
pfd.close(); |
||||||
|
} catch (Exception e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,134 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/* |
||||||
|
* 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. |
||||||
|
* |
||||||
|
* @author Per Bothner |
||||||
|
* @date April 1, 1999. |
||||||
|
* @see InflaterInputStream |
||||||
|
* @see DeflaterOutputStream |
||||||
|
*/ |
||||||
|
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 final int[] crc_table = make_crc_table(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Make the table for a fast CRC. |
||||||
|
*/ |
||||||
|
private static int[] make_crc_table() { |
||||||
|
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. |
||||||
|
*/ |
||||||
|
public long getValue() { |
||||||
|
return (long) crc & 0xffffffffL; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Resets the CRC32 data checksum as if no update was ever called. |
||||||
|
*/ |
||||||
|
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) |
||||||
|
*/ |
||||||
|
|
||||||
|
public void update(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 |
||||||
|
*/ |
||||||
|
public void update(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(byte[] buf) { |
||||||
|
update(buf, 0, buf.length); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,128 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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. |
||||||
|
* |
||||||
|
* @author Tom Tromey |
||||||
|
* @date May 17, 1999 |
||||||
|
* @see Checksum |
||||||
|
*/ |
||||||
|
public class CheckedInputStream extends FilterInputStream { |
||||||
|
/** |
||||||
|
* Creates a new CheckInputStream on top of the supplied OutputStream |
||||||
|
* using the supplied Checksum. |
||||||
|
*/ |
||||||
|
public CheckedInputStream(InputStream in, Checksum sum) { |
||||||
|
super(in); |
||||||
|
this.sum = sum; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the Checksum object used. To get the data checksum computed so |
||||||
|
* far call <code>getChecksum.getValue()</code>. |
||||||
|
*/ |
||||||
|
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). |
||||||
|
*/ |
||||||
|
public int read() throws IOException { |
||||||
|
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. |
||||||
|
*/ |
||||||
|
public int read(byte[] buf, int off, int len) throws IOException { |
||||||
|
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. |
||||||
|
*/ |
||||||
|
public long skip(long n) throws IOException { |
||||||
|
if (n == 0) |
||||||
|
return 0; |
||||||
|
|
||||||
|
int min = (int) Math.min(n, 1024); |
||||||
|
byte[] buf = new byte[min]; |
||||||
|
|
||||||
|
long s = 0; |
||||||
|
while (n > 0) { |
||||||
|
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; |
||||||
|
} |
||||||
@ -0,0 +1,95 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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. |
||||||
|
* |
||||||
|
* @author Tom Tromey |
||||||
|
* @date May 17, 1999 |
||||||
|
* @see Checksum |
||||||
|
*/ |
||||||
|
public class CheckedOutputStream extends FilterOutputStream { |
||||||
|
/** |
||||||
|
* Creates a new CheckInputStream on top of the supplied OutputStream |
||||||
|
* using the supplied Checksum. |
||||||
|
*/ |
||||||
|
public CheckedOutputStream(OutputStream out, Checksum cksum) { |
||||||
|
super(out); |
||||||
|
this.sum = cksum; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the Checksum object used. To get the data checksum computed so |
||||||
|
* far call <code>getChecksum.getValue()</code>. |
||||||
|
*/ |
||||||
|
public Checksum getChecksum() { |
||||||
|
return sum; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Writes one byte to the OutputStream and updates the Checksum. |
||||||
|
*/ |
||||||
|
public void write(int bval) throws IOException { |
||||||
|
out.write(bval); |
||||||
|
sum.update(bval); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Writes the byte array to the OutputStream and updates the Checksum. |
||||||
|
*/ |
||||||
|
public void write(byte[] buf, int off, int len) throws IOException { |
||||||
|
out.write(buf, off, len); |
||||||
|
sum.update(buf, off, len); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* The checksum object. |
||||||
|
*/ |
||||||
|
private Checksum sum; |
||||||
|
} |
||||||
@ -0,0 +1,84 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/* |
||||||
|
* 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 |
||||||
|
* <code>getValue</code>. The complete checksum object can also be reset |
||||||
|
* so it can be used again with new data. |
||||||
|
* |
||||||
|
* @author Per Bothner |
||||||
|
* @author Jochen Hoenicke |
||||||
|
* @see CheckedInputStream |
||||||
|
* @see CheckedOutputStream |
||||||
|
*/ |
||||||
|
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); |
||||||
|
} |
||||||
@ -0,0 +1,68 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/** |
||||||
|
* Exception thrown when compressed data is corrupt. |
||||||
|
* |
||||||
|
* @author Tom Tromey |
||||||
|
* @author John Leuner |
||||||
|
* @status updated to 1.4 |
||||||
|
* @since 1.1 |
||||||
|
*/ |
||||||
|
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(String msg) { |
||||||
|
super(msg); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,512 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/** |
||||||
|
* 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. |
||||||
|
* <p> |
||||||
|
* This class is <i>not</i> 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 INIT_FINISHING_STATE = 0x08; |
||||||
|
private static final int SETDICT_FINISHING_STATE = 0x09; |
||||||
|
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 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. |
||||||
|
* @throws IllegalArgumentException if lvl is out of range. |
||||||
|
*/ |
||||||
|
public Deflater(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. |
||||||
|
* @throws IllegalArgumentException if lvl is out of range. |
||||||
|
*/ |
||||||
|
public Deflater(int lvl, 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 |
||||||
|
* <i>undefined</i>. |
||||||
|
* |
||||||
|
* @deprecated Just clear all references to deflater instead. |
||||||
|
*/ |
||||||
|
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. |
||||||
|
*/ |
||||||
|
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(). <br> |
||||||
|
* |
||||||
|
* <em>NOTE</em>: 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 <code>setInput(input, 0, input.length)</code>. |
||||||
|
* |
||||||
|
* @param input the buffer containing the input data. |
||||||
|
* @throws IllegalStateException if the buffer was finished() or ended(). |
||||||
|
*/ |
||||||
|
public void setInput(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. |
||||||
|
* @throws IllegalStateException if the buffer was finished() or ended() |
||||||
|
* or if previous input is still pending. |
||||||
|
*/ |
||||||
|
public void setInput(byte[] input, int off, 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(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(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. |
||||||
|
* @throws IllegalStateException if end() was called. |
||||||
|
* @throws IndexOutOfBoundsException if offset and/or length |
||||||
|
* don't match the array length. |
||||||
|
*/ |
||||||
|
public int deflate(byte[] output, int offset, int length) { |
||||||
|
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) { |
||||||
|
int chksum = engine.getAdler(); |
||||||
|
engine.resetAdler(); |
||||||
|
pending.writeShortMSB(chksum >> 16); |
||||||
|
pending.writeShortMSB(chksum & 0xffff); |
||||||
|
} |
||||||
|
|
||||||
|
state = BUSY_STATE | (state & (IS_FLUSHING | IS_FINISHING)); |
||||||
|
} |
||||||
|
|
||||||
|
for (; ; ) { |
||||||
|
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) { |
||||||
|
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 <code>setDictionary(dict, 0, |
||||||
|
* dict.length)</code>. |
||||||
|
* |
||||||
|
* @param dict the dictionary. |
||||||
|
* @throws IllegalStateException if setInput () or deflate () |
||||||
|
* were already called or another dictionary was already set. |
||||||
|
*/ |
||||||
|
public void setDictionary(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. |
||||||
|
* @throws IllegalStateException if setInput () or deflate () were |
||||||
|
* already called or another dictionary was already set. |
||||||
|
*/ |
||||||
|
public void setDictionary(byte[] dict, int offset, int length) { |
||||||
|
if (state != INIT_STATE) |
||||||
|
throw new IllegalStateException(); |
||||||
|
|
||||||
|
state = SETDICT_STATE; |
||||||
|
engine.setDictionary(dict, offset, length); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,77 @@ |
|||||||
|
/* me.ag2s.epublib.zip.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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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}; |
||||||
|
} |
||||||
@ -0,0 +1,653 @@ |
|||||||
|
/* me.ag2s.epublib.zip.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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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 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 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 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 DeflaterPending pending; |
||||||
|
private DeflaterHuffman huffman; |
||||||
|
|
||||||
|
/** |
||||||
|
* The adler checksum |
||||||
|
*/ |
||||||
|
private 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(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() { |
||||||
|
int chksum = (int) adler.getValue(); |
||||||
|
return chksum; |
||||||
|
} |
||||||
|
|
||||||
|
public final int getTotalIn() { |
||||||
|
return totalIn; |
||||||
|
} |
||||||
|
|
||||||
|
public final void setStrategy(int strat) { |
||||||
|
strategy = strat; |
||||||
|
} |
||||||
|
|
||||||
|
public void setLevel(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; |
||||||
|
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++) { |
||||||
|
int m = head[i] & 0xffff; |
||||||
|
head[i] = m >= WSIZE ? (short) (m - WSIZE) : 0; |
||||||
|
} |
||||||
|
|
||||||
|
/* Slide the prev table. |
||||||
|
*/ |
||||||
|
for (int i = 0; i < WSIZE; i++) { |
||||||
|
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. |
||||||
|
* <p> |
||||||
|
* 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. |
||||||
|
* <p> |
||||||
|
* Preconditions: |
||||||
|
* strstart + MAX_MATCH <= window.length. |
||||||
|
* |
||||||
|
* @param curMatch |
||||||
|
*/ |
||||||
|
private boolean findLongestMatch(int curMatch) { |
||||||
|
int chainLength = this.max_chain; |
||||||
|
int niceLength = this.niceLength; |
||||||
|
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); |
||||||
|
|
||||||
|
int limit = Math.max(strstart - MAX_DIST, 0); |
||||||
|
|
||||||
|
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(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(boolean flush, 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(boolean flush, 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()) { |
||||||
|
boolean lastBlock = finish && lookahead == 0; |
||||||
|
huffman.flushBlock(window, blockStart, strstart - blockStart, |
||||||
|
lastBlock); |
||||||
|
blockStart = strstart; |
||||||
|
return !lastBlock; |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
private boolean deflateSlow(boolean flush, 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(); |
||||||
|
} |
||||||
|
|
||||||
|
int prevMatch = matchStart; |
||||||
|
int prevLen = matchLen; |
||||||
|
if (lookahead >= MIN_MATCH) { |
||||||
|
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--; |
||||||
|
boolean lastBlock = (finish && lookahead == 0 && !prevAvailable); |
||||||
|
huffman.flushBlock(window, blockStart, len, lastBlock); |
||||||
|
blockStart += len; |
||||||
|
return !lastBlock; |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
public boolean deflate(boolean flush, boolean finish) { |
||||||
|
boolean progress; |
||||||
|
do { |
||||||
|
fillWindow(); |
||||||
|
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(byte[] buf, int off, int len) { |
||||||
|
if (inputOff < inputEnd) |
||||||
|
throw new IllegalStateException |
||||||
|
("Old input was not completely processed"); |
||||||
|
|
||||||
|
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; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,704 @@ |
|||||||
|
/* me.ag2s.epublib.zip.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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/** |
||||||
|
* This is the DeflaterHuffman class. |
||||||
|
* <p> |
||||||
|
* This class is <i>not</i> 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(int elems, int minCodes, 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(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(short[] stCodes, byte[] stLength) { |
||||||
|
codes = stCodes; |
||||||
|
length = stLength; |
||||||
|
} |
||||||
|
|
||||||
|
public void buildCodes() { |
||||||
|
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++) { |
||||||
|
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(int childs[]) { |
||||||
|
this.length = new byte[freqs.length]; |
||||||
|
int numNodes = childs.length / 2; |
||||||
|
int numLeafs = (numNodes + 1) / 2; |
||||||
|
int overflow = 0; |
||||||
|
|
||||||
|
for (int i = 0; i < maxLength; i++) |
||||||
|
bl_counts[i] = 0; |
||||||
|
|
||||||
|
/* First calculate optimal bit lengths */ |
||||||
|
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 */ |
||||||
|
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) { |
||||||
|
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() { |
||||||
|
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. |
||||||
|
*/ |
||||||
|
int[] heap = new int[numSymbols]; |
||||||
|
int heapLen = 0; |
||||||
|
int maxCode = 0; |
||||||
|
for (int n = 0; n < numSymbols; n++) { |
||||||
|
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) { |
||||||
|
int node = maxCode < 2 ? ++maxCode : 0; |
||||||
|
heap[heapLen++] = node; |
||||||
|
} |
||||||
|
|
||||||
|
numCodes = Math.max(maxCode + 1, minNumCodes); |
||||||
|
|
||||||
|
int numLeafs = heapLen; |
||||||
|
int[] childs = new int[4 * heapLen - 2]; |
||||||
|
int[] values = new int[2 * heapLen - 1]; |
||||||
|
int numNodes = numLeafs; |
||||||
|
for (int i = 0; i < heapLen; i++) { |
||||||
|
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 { |
||||||
|
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; |
||||||
|
|
||||||
|
|
||||||
|
int second = heap[0]; |
||||||
|
|
||||||
|
/* Create a new node father of first and second */ |
||||||
|
last = numNodes++; |
||||||
|
childs[2 * last] = first; |
||||||
|
childs[2 * last + 1] = second; |
||||||
|
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(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; |
||||||
|
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(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; |
||||||
|
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 Tree literalTree, distTree, blTree; |
||||||
|
|
||||||
|
private short d_buf[]; |
||||||
|
private 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(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(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(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++) { |
||||||
|
int litlen = l_buf[i] & 0xff; |
||||||
|
int dist = d_buf[i]; |
||||||
|
if (dist-- != 0) { |
||||||
|
if (DeflaterConstants.DEBUGGING) |
||||||
|
System.err.print("[" + (dist + 1) + "," + (litlen + 3) + "]: "); |
||||||
|
|
||||||
|
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); |
||||||
|
|
||||||
|
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(byte[] stored, |
||||||
|
int stored_offset, int stored_len, |
||||||
|
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(byte[] stored, int stored_offset, int stored_len, |
||||||
|
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(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(int dist, int len) { |
||||||
|
if (DeflaterConstants.DEBUGGING) |
||||||
|
System.err.println("[" + dist + "," + len + "]"); |
||||||
|
|
||||||
|
d_buf[last_lit] = (short) dist; |
||||||
|
l_buf[last_lit++] = (byte) (len - 3); |
||||||
|
|
||||||
|
int lc = l_code(len - 3); |
||||||
|
literalTree.freqs[lc]++; |
||||||
|
if (lc >= 265 && lc < 285) |
||||||
|
extra_bits += (lc - 261) / 4; |
||||||
|
|
||||||
|
int dc = d_code(dist - 1); |
||||||
|
distTree.freqs[dc]++; |
||||||
|
if (dc >= 4) |
||||||
|
extra_bits += dc / 2 - 1; |
||||||
|
return last_lit == BUFSIZE; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,190 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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. |
||||||
|
* <p> |
||||||
|
* 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 |
||||||
|
* <code>def.deflate()</code> until all bytes from the input buffers |
||||||
|
* are processed. |
||||||
|
*/ |
||||||
|
protected void deflate() throws IOException { |
||||||
|
while (!def.needsInput()) { |
||||||
|
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(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(OutputStream out, 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. |
||||||
|
* @throws IllegalArgumentException if bufsize isn't positive. |
||||||
|
*/ |
||||||
|
public DeflaterOutputStream(OutputStream out, Deflater defl, 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. |
||||||
|
*/ |
||||||
|
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()) { |
||||||
|
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. |
||||||
|
*/ |
||||||
|
public void close() throws IOException { |
||||||
|
finish(); |
||||||
|
out.close(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Writes a single byte to the compressed output stream. |
||||||
|
* |
||||||
|
* @param bval the byte value. |
||||||
|
*/ |
||||||
|
public void write(int bval) throws IOException { |
||||||
|
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. |
||||||
|
*/ |
||||||
|
public void write(byte[] buf, int off, int len) throws IOException { |
||||||
|
def.setInput(buf, off, len); |
||||||
|
deflate(); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,52 @@ |
|||||||
|
/* me.ag2s.epublib.zip.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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/** |
||||||
|
* 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); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,338 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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(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 <code>size</code> |
||||||
|
* is less than or equal to 0. |
||||||
|
*/ |
||||||
|
public GZIPInputStream(InputStream in, 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. |
||||||
|
*/ |
||||||
|
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 <code>buf</code> |
||||||
|
* the uncompressed data should be placed. |
||||||
|
* @param len the number of uncompressed bytes to be read. |
||||||
|
*/ |
||||||
|
public int read(byte[] buf, int offset, 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. |
||||||
|
*/ |
||||||
|
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 */ |
||||||
|
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) */ |
||||||
|
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 */ |
||||||
|
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++) { |
||||||
|
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++) { |
||||||
|
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++) { |
||||||
|
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 { |
||||||
|
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) { |
||||||
|
int count = in.read(footer, 8 - needed, needed); |
||||||
|
if (count <= 0) |
||||||
|
throw new EOFException("Early EOF in GZIP footer"); |
||||||
|
needed -= count; //Jewel Jan 16
|
||||||
|
} |
||||||
|
|
||||||
|
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())); |
||||||
|
|
||||||
|
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; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,146 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
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(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(OutputStream out, int size) throws IOException { |
||||||
|
super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true), size); |
||||||
|
|
||||||
|
crc = new CRC32(); |
||||||
|
int mod_time = (int) (System.currentTimeMillis() / 1000L); |
||||||
|
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 )");
|
||||||
|
} |
||||||
|
|
||||||
|
public synchronized void write(byte[] buf, int off, 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. |
||||||
|
*/ |
||||||
|
public void close() throws IOException { |
||||||
|
finish(); |
||||||
|
out.close(); |
||||||
|
} |
||||||
|
|
||||||
|
public void finish() throws IOException { |
||||||
|
super.finish(); |
||||||
|
|
||||||
|
int totalin = def.getTotalIn(); |
||||||
|
int crcval = (int) (crc.getValue() & 0xffffffff); |
||||||
|
|
||||||
|
// System.err.println("CRC val is " + Integer.toHexString( crcval ) + " and length " + Integer.toHexString(totalin));
|
||||||
|
|
||||||
|
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 )");
|
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,681 @@ |
|||||||
|
/* 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/* 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. |
||||||
|
* <p> |
||||||
|
* The usage is as following. First you have to set some input with |
||||||
|
* <code>setInput()</code>, then inflate() it. If inflate doesn't |
||||||
|
* inflate any bytes there may be three reasons: |
||||||
|
* <ul> |
||||||
|
* <li>needsInput() returns true because the input buffer is empty. |
||||||
|
* You have to provide more input with <code>setInput()</code>. |
||||||
|
* NOTE: needsInput() also returns true when, the stream is finished. |
||||||
|
* </li> |
||||||
|
* <li>needsDictionary() returns true, you have to provide a preset |
||||||
|
* dictionary with <code>setDictionary()</code>.</li> |
||||||
|
* <li>finished() returns true, the inflater has finished.</li> |
||||||
|
* </ul> |
||||||
|
* Once the first output byte is produced, a dictionary will not be |
||||||
|
* needed at a later stage. |
||||||
|
* |
||||||
|
* @author John Leuner, Jochen Hoenicke |
||||||
|
* @author Tom Tromey |
||||||
|
* @date May 17, 1999 |
||||||
|
* @since JDK 1.1 |
||||||
|
*/ |
||||||
|
public class Inflater { |
||||||
|
/* Copy lengths for literal codes 257..285 */ |
||||||
|
private static final int CPLENS[] = |
||||||
|
{ |
||||||
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, |
||||||
|
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258 |
||||||
|
}; |
||||||
|
|
||||||
|
/* Extra bits for literal codes 257..285 */ |
||||||
|
private static final int CPLEXT[] = |
||||||
|
{ |
||||||
|
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, |
||||||
|
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 |
||||||
|
}; |
||||||
|
|
||||||
|
/* Copy offsets for distance codes 0..29 */ |
||||||
|
private static final int CPDIST[] = { |
||||||
|
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, |
||||||
|
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, |
||||||
|
8193, 12289, 16385, 24577 |
||||||
|
}; |
||||||
|
|
||||||
|
/* Extra bits for distance codes */ |
||||||
|
private static final int CPDEXT[] = { |
||||||
|
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, |
||||||
|
7, 7, 8, 8, 9, 9, 10, 10, 11, 11, |
||||||
|
12, 12, 13, 13 |
||||||
|
}; |
||||||
|
|
||||||
|
/* This are the state in which the inflater can be. */ |
||||||
|
private static final int DECODE_HEADER = 0; |
||||||
|
private static final int DECODE_DICT = 1; |
||||||
|
private static final int DECODE_BLOCKS = 2; |
||||||
|
private static final int DECODE_STORED_LEN1 = 3; |
||||||
|
private static final int DECODE_STORED_LEN2 = 4; |
||||||
|
private static final int DECODE_STORED = 5; |
||||||
|
private static final int DECODE_DYN_HEADER = 6; |
||||||
|
private static final int DECODE_HUFFMAN = 7; |
||||||
|
private static final int DECODE_HUFFMAN_LENBITS = 8; |
||||||
|
private static final int DECODE_HUFFMAN_DIST = 9; |
||||||
|
private static final int DECODE_HUFFMAN_DISTBITS = 10; |
||||||
|
private static final int DECODE_CHKSUM = 11; |
||||||
|
private static final int FINISHED = 12; |
||||||
|
|
||||||
|
/** |
||||||
|
* This variable contains the current state. |
||||||
|
*/ |
||||||
|
private int mode; |
||||||
|
|
||||||
|
/** |
||||||
|
* The adler checksum of the dictionary or of the decompressed |
||||||
|
* stream, as it is written in the header resp. footer of the |
||||||
|
* compressed stream. <br> |
||||||
|
* <p> |
||||||
|
* Only valid if mode is DECODE_DICT or DECODE_CHKSUM. |
||||||
|
*/ |
||||||
|
private int readAdler; |
||||||
|
/** |
||||||
|
* The number of bits needed to complete the current state. This |
||||||
|
* is valid, if mode is DECODE_DICT, DECODE_CHKSUM, |
||||||
|
* DECODE_HUFFMAN_LENBITS or DECODE_HUFFMAN_DISTBITS. |
||||||
|
*/ |
||||||
|
private int neededBits; |
||||||
|
private int repLength, repDist; |
||||||
|
private int uncomprLen; |
||||||
|
/** |
||||||
|
* True, if the last block flag was set in the last block of the |
||||||
|
* inflated stream. This means that the stream ends after the |
||||||
|
* current block. |
||||||
|
*/ |
||||||
|
private boolean isLastBlock; |
||||||
|
|
||||||
|
/** |
||||||
|
* The total number of inflated bytes. |
||||||
|
*/ |
||||||
|
private int totalOut; |
||||||
|
/** |
||||||
|
* The total number of bytes set with setInput(). This is not the |
||||||
|
* value returned by getTotalIn(), since this also includes the |
||||||
|
* unprocessed input. |
||||||
|
*/ |
||||||
|
private int totalIn; |
||||||
|
/** |
||||||
|
* This variable stores the nowrap flag that was given to the constructor. |
||||||
|
* True means, that the inflated stream doesn't contain a header nor the |
||||||
|
* checksum in the footer. |
||||||
|
*/ |
||||||
|
private boolean nowrap; |
||||||
|
|
||||||
|
private StreamManipulator input; |
||||||
|
private OutputWindow outputWindow; |
||||||
|
private InflaterDynHeader dynHeader; |
||||||
|
private InflaterHuffmanTree litlenTree, distTree; |
||||||
|
private Adler32 adler; |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a new inflater. |
||||||
|
*/ |
||||||
|
public Inflater() { |
||||||
|
this(false); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a new inflater. |
||||||
|
* |
||||||
|
* @param nowrap true if no header and checksum field appears in the |
||||||
|
* stream. This is used for GZIPed input. For compatibility with |
||||||
|
* Sun JDK you should provide one byte of input more than needed in |
||||||
|
* this case. |
||||||
|
*/ |
||||||
|
public Inflater(boolean nowrap) { |
||||||
|
this.nowrap = nowrap; |
||||||
|
this.adler = new Adler32(); |
||||||
|
input = new StreamManipulator(); |
||||||
|
outputWindow = new OutputWindow(); |
||||||
|
mode = nowrap ? DECODE_BLOCKS : DECODE_HEADER; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Finalizes this object. |
||||||
|
*/ |
||||||
|
protected void finalize() { |
||||||
|
/* Exists only for compatibility */ |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Frees all objects allocated by the inflater. There's no reason |
||||||
|
* to call this, since you can just rely on garbage collection (even |
||||||
|
* for the Sun implementation). Exists only for compatibility |
||||||
|
* with Sun's JDK, where the compressor allocates native memory. |
||||||
|
* If you call any method (even reset) afterwards the behaviour is |
||||||
|
* <i>undefined</i>. |
||||||
|
* |
||||||
|
* @deprecated Just clear all references to inflater instead. |
||||||
|
*/ |
||||||
|
public void end() { |
||||||
|
outputWindow = null; |
||||||
|
input = null; |
||||||
|
dynHeader = null; |
||||||
|
litlenTree = null; |
||||||
|
distTree = null; |
||||||
|
adler = null; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns true, if the inflater has finished. This means, that no |
||||||
|
* input is needed and no output can be produced. |
||||||
|
*/ |
||||||
|
public boolean finished() { |
||||||
|
return mode == FINISHED && outputWindow.getAvailable() == 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the adler checksum. This is either the checksum of all |
||||||
|
* uncompressed bytes returned by inflate(), or if needsDictionary() |
||||||
|
* returns true (and thus no output was yet produced) this is the |
||||||
|
* adler checksum of the expected dictionary. |
||||||
|
* |
||||||
|
* @returns the adler checksum. |
||||||
|
*/ |
||||||
|
public int getAdler() { |
||||||
|
return needsDictionary() ? readAdler : (int) adler.getValue(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the number of unprocessed input. Useful, if the end of the |
||||||
|
* stream is reached and you want to further process the bytes after |
||||||
|
* the deflate stream. |
||||||
|
* |
||||||
|
* @return the number of bytes of the input which were not processed. |
||||||
|
*/ |
||||||
|
public int getRemaining() { |
||||||
|
return input.getAvailableBytes(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the total number of processed compressed input bytes. |
||||||
|
* |
||||||
|
* @return the total number of bytes of processed input bytes. |
||||||
|
*/ |
||||||
|
public int getTotalIn() { |
||||||
|
return totalIn - getRemaining(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the total number of output bytes returned by inflate(). |
||||||
|
* |
||||||
|
* @return the total number of output bytes. |
||||||
|
*/ |
||||||
|
public int getTotalOut() { |
||||||
|
return totalOut; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Inflates the compressed stream to the output buffer. If this |
||||||
|
* returns 0, you should check, whether needsDictionary(), |
||||||
|
* needsInput() or finished() returns true, to determine why no |
||||||
|
* further output is produced. |
||||||
|
* |
||||||
|
* @param buffer the output buffer. |
||||||
|
* @return the number of bytes written to the buffer, 0 if no further |
||||||
|
* output can be produced. |
||||||
|
* @throws DataFormatException if deflated stream is invalid. |
||||||
|
* @throws IllegalArgumentException if buf has length 0. |
||||||
|
*/ |
||||||
|
public int inflate(byte[] buf) throws DataFormatException { |
||||||
|
return inflate(buf, 0, buf.length); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Inflates the compressed stream to the output buffer. If this |
||||||
|
* returns 0, you should check, whether needsDictionary(), |
||||||
|
* needsInput() or finished() returns true, to determine why no |
||||||
|
* further output is produced. |
||||||
|
* |
||||||
|
* @param buffer the output buffer. |
||||||
|
* @param off the offset into buffer where the output should start. |
||||||
|
* @param len the maximum length of the output. |
||||||
|
* @return the number of bytes written to the buffer, 0 if no further |
||||||
|
* output can be produced. |
||||||
|
* @throws DataFormatException if deflated stream is invalid. |
||||||
|
* @throws IndexOutOfBoundsException if the off and/or len are wrong. |
||||||
|
*/ |
||||||
|
public int inflate(byte[] buf, int off, int len) throws DataFormatException { |
||||||
|
/* Special case: len may be zero */ |
||||||
|
if (len == 0) |
||||||
|
return 0; |
||||||
|
/* Check for correct buff, off, len triple */ |
||||||
|
if (0 > off || off > off + len || off + len > buf.length) |
||||||
|
throw new ArrayIndexOutOfBoundsException(); |
||||||
|
int count = 0; |
||||||
|
int more; |
||||||
|
do { |
||||||
|
if (mode != DECODE_CHKSUM) { |
||||||
|
/* Don't give away any output, if we are waiting for the |
||||||
|
* checksum in the input stream. |
||||||
|
* |
||||||
|
* With this trick we have always: |
||||||
|
* needsInput() and not finished() |
||||||
|
* implies more output can be produced. |
||||||
|
*/ |
||||||
|
more = outputWindow.copyOutput(buf, off, len); |
||||||
|
adler.update(buf, off, more); |
||||||
|
off += more; |
||||||
|
count += more; |
||||||
|
totalOut += more; |
||||||
|
len -= more; |
||||||
|
if (len == 0) |
||||||
|
return count; |
||||||
|
} |
||||||
|
} |
||||||
|
while (decode() || (outputWindow.getAvailable() > 0 |
||||||
|
&& mode != DECODE_CHKSUM)); |
||||||
|
return count; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns true, if a preset dictionary is needed to inflate the input. |
||||||
|
*/ |
||||||
|
public boolean needsDictionary() { |
||||||
|
return mode == DECODE_DICT && neededBits == 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns true, if the input buffer is empty. |
||||||
|
* You should then call setInput(). <br> |
||||||
|
* |
||||||
|
* <em>NOTE</em>: This method also returns true when the stream is finished. |
||||||
|
*/ |
||||||
|
public boolean needsInput() { |
||||||
|
return input.needsInput(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Resets the inflater so that a new stream can be decompressed. All |
||||||
|
* pending input and output will be discarded. |
||||||
|
*/ |
||||||
|
public void reset() { |
||||||
|
mode = nowrap ? DECODE_BLOCKS : DECODE_HEADER; |
||||||
|
totalIn = totalOut = 0; |
||||||
|
input.reset(); |
||||||
|
outputWindow.reset(); |
||||||
|
dynHeader = null; |
||||||
|
litlenTree = null; |
||||||
|
distTree = null; |
||||||
|
isLastBlock = false; |
||||||
|
adler.reset(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the preset dictionary. This should only be called, if |
||||||
|
* needsDictionary() returns true and it should set the same |
||||||
|
* dictionary, that was used for deflating. The getAdler() |
||||||
|
* function returns the checksum of the dictionary needed. |
||||||
|
* |
||||||
|
* @param buffer the dictionary. |
||||||
|
* @throws IllegalStateException if no dictionary is needed. |
||||||
|
* @throws IllegalArgumentException if the dictionary checksum is |
||||||
|
* wrong. |
||||||
|
*/ |
||||||
|
public void setDictionary(byte[] buffer) { |
||||||
|
setDictionary(buffer, 0, buffer.length); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the preset dictionary. This should only be called, if |
||||||
|
* needsDictionary() returns true and it should set the same |
||||||
|
* dictionary, that was used for deflating. The getAdler() |
||||||
|
* function returns the checksum of the dictionary needed. |
||||||
|
* |
||||||
|
* @param buffer the dictionary. |
||||||
|
* @param off the offset into buffer where the dictionary starts. |
||||||
|
* @param len the length of the dictionary. |
||||||
|
* @throws IllegalStateException if no dictionary is needed. |
||||||
|
* @throws IllegalArgumentException if the dictionary checksum is |
||||||
|
* wrong. |
||||||
|
* @throws IndexOutOfBoundsException if the off and/or len are wrong. |
||||||
|
*/ |
||||||
|
public void setDictionary(byte[] buffer, int off, int len) { |
||||||
|
if (!needsDictionary()) |
||||||
|
throw new IllegalStateException(); |
||||||
|
|
||||||
|
adler.update(buffer, off, len); |
||||||
|
if ((int) adler.getValue() != readAdler) |
||||||
|
throw new IllegalArgumentException("Wrong adler checksum"); |
||||||
|
adler.reset(); |
||||||
|
outputWindow.copyDict(buffer, off, len); |
||||||
|
mode = DECODE_BLOCKS; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the input. This should only be called, if needsInput() |
||||||
|
* returns true. |
||||||
|
* |
||||||
|
* @param buffer the input. |
||||||
|
* @throws IllegalStateException if no input is needed. |
||||||
|
*/ |
||||||
|
public void setInput(byte[] buf) { |
||||||
|
setInput(buf, 0, buf.length); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the input. This should only be called, if needsInput() |
||||||
|
* returns true. |
||||||
|
* |
||||||
|
* @param buffer the input. |
||||||
|
* @param off the offset into buffer where the input starts. |
||||||
|
* @param len the length of the input. |
||||||
|
* @throws IllegalStateException if no input is needed. |
||||||
|
* @throws IndexOutOfBoundsException if the off and/or len are wrong. |
||||||
|
*/ |
||||||
|
public void setInput(byte[] buf, int off, int len) { |
||||||
|
input.setInput(buf, off, len); |
||||||
|
totalIn += len; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Decodes the deflate header. |
||||||
|
* |
||||||
|
* @return false if more input is needed. |
||||||
|
* @throws DataFormatException if header is invalid. |
||||||
|
*/ |
||||||
|
private boolean decodeHeader() throws DataFormatException { |
||||||
|
int header = input.peekBits(16); |
||||||
|
if (header < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(16); |
||||||
|
|
||||||
|
/* The header is written in "wrong" byte order */ |
||||||
|
header = ((header << 8) | (header >> 8)) & 0xffff; |
||||||
|
if (header % 31 != 0) |
||||||
|
throw new DataFormatException("Header checksum illegal"); |
||||||
|
|
||||||
|
if ((header & 0x0f00) != (Deflater.DEFLATED << 8)) |
||||||
|
throw new DataFormatException("Compression Method unknown"); |
||||||
|
|
||||||
|
/* Maximum size of the backwards window in bits. |
||||||
|
* We currently ignore this, but we could use it to make the |
||||||
|
* inflater window more space efficient. On the other hand the |
||||||
|
* full window (15 bits) is needed most times, anyway. |
||||||
|
int max_wbits = ((header & 0x7000) >> 12) + 8; |
||||||
|
*/ |
||||||
|
|
||||||
|
if ((header & 0x0020) == 0) // Dictionary flag?
|
||||||
|
{ |
||||||
|
mode = DECODE_BLOCKS; |
||||||
|
} else { |
||||||
|
mode = DECODE_DICT; |
||||||
|
neededBits = 32; |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Decodes the dictionary checksum after the deflate header. |
||||||
|
* |
||||||
|
* @return false if more input is needed. |
||||||
|
*/ |
||||||
|
private boolean decodeDict() { |
||||||
|
while (neededBits > 0) { |
||||||
|
int dictByte = input.peekBits(8); |
||||||
|
if (dictByte < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(8); |
||||||
|
readAdler = (readAdler << 8) | dictByte; |
||||||
|
neededBits -= 8; |
||||||
|
} |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Decodes the huffman encoded symbols in the input stream. |
||||||
|
* |
||||||
|
* @return false if more input is needed, true if output window is |
||||||
|
* full or the current block ends. |
||||||
|
* @throws DataFormatException if deflated stream is invalid. |
||||||
|
*/ |
||||||
|
private boolean decodeHuffman() throws DataFormatException { |
||||||
|
int free = outputWindow.getFreeSpace(); |
||||||
|
while (free >= 258) { |
||||||
|
int symbol; |
||||||
|
switch (mode) { |
||||||
|
case DECODE_HUFFMAN: |
||||||
|
/* This is the inner loop so it is optimized a bit */ |
||||||
|
while (((symbol = litlenTree.getSymbol(input)) & ~0xff) == 0) { |
||||||
|
outputWindow.write(symbol); |
||||||
|
if (--free < 258) |
||||||
|
return true; |
||||||
|
} |
||||||
|
if (symbol < 257) { |
||||||
|
if (symbol < 0) |
||||||
|
return false; |
||||||
|
else { |
||||||
|
/* symbol == 256: end of block */ |
||||||
|
distTree = null; |
||||||
|
litlenTree = null; |
||||||
|
mode = DECODE_BLOCKS; |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
try { |
||||||
|
repLength = CPLENS[symbol - 257]; |
||||||
|
neededBits = CPLEXT[symbol - 257]; |
||||||
|
} catch (ArrayIndexOutOfBoundsException ex) { |
||||||
|
throw new DataFormatException("Illegal rep length code"); |
||||||
|
} |
||||||
|
/* fall through */ |
||||||
|
case DECODE_HUFFMAN_LENBITS: |
||||||
|
if (neededBits > 0) { |
||||||
|
mode = DECODE_HUFFMAN_LENBITS; |
||||||
|
int i = input.peekBits(neededBits); |
||||||
|
if (i < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(neededBits); |
||||||
|
repLength += i; |
||||||
|
} |
||||||
|
mode = DECODE_HUFFMAN_DIST; |
||||||
|
/* fall through */ |
||||||
|
case DECODE_HUFFMAN_DIST: |
||||||
|
symbol = distTree.getSymbol(input); |
||||||
|
if (symbol < 0) |
||||||
|
return false; |
||||||
|
try { |
||||||
|
repDist = CPDIST[symbol]; |
||||||
|
neededBits = CPDEXT[symbol]; |
||||||
|
} catch (ArrayIndexOutOfBoundsException ex) { |
||||||
|
throw new DataFormatException("Illegal rep dist code"); |
||||||
|
} |
||||||
|
/* fall through */ |
||||||
|
case DECODE_HUFFMAN_DISTBITS: |
||||||
|
if (neededBits > 0) { |
||||||
|
mode = DECODE_HUFFMAN_DISTBITS; |
||||||
|
int i = input.peekBits(neededBits); |
||||||
|
if (i < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(neededBits); |
||||||
|
repDist += i; |
||||||
|
} |
||||||
|
outputWindow.repeat(repLength, repDist); |
||||||
|
free -= repLength; |
||||||
|
mode = DECODE_HUFFMAN; |
||||||
|
break; |
||||||
|
default: |
||||||
|
throw new IllegalStateException(); |
||||||
|
} |
||||||
|
} |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Decodes the adler checksum after the deflate stream. |
||||||
|
* |
||||||
|
* @return false if more input is needed. |
||||||
|
* @throws DataFormatException if checksum doesn't match. |
||||||
|
*/ |
||||||
|
private boolean decodeChksum() throws DataFormatException { |
||||||
|
while (neededBits > 0) { |
||||||
|
int chkByte = input.peekBits(8); |
||||||
|
if (chkByte < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(8); |
||||||
|
readAdler = (readAdler << 8) | chkByte; |
||||||
|
neededBits -= 8; |
||||||
|
} |
||||||
|
if ((int) adler.getValue() != readAdler) |
||||||
|
throw new DataFormatException("Adler chksum doesn't match: " |
||||||
|
+ Integer.toHexString((int) adler.getValue()) |
||||||
|
+ " vs. " + Integer.toHexString(readAdler)); |
||||||
|
mode = FINISHED; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Decodes the deflated stream. |
||||||
|
* |
||||||
|
* @return false if more input is needed, or if finished. |
||||||
|
* @throws DataFormatException if deflated stream is invalid. |
||||||
|
*/ |
||||||
|
private boolean decode() throws DataFormatException { |
||||||
|
switch (mode) { |
||||||
|
case DECODE_HEADER: |
||||||
|
return decodeHeader(); |
||||||
|
case DECODE_DICT: |
||||||
|
return decodeDict(); |
||||||
|
case DECODE_CHKSUM: |
||||||
|
return decodeChksum(); |
||||||
|
|
||||||
|
case DECODE_BLOCKS: |
||||||
|
if (isLastBlock) { |
||||||
|
if (nowrap) { |
||||||
|
mode = FINISHED; |
||||||
|
return false; |
||||||
|
} else { |
||||||
|
input.skipToByteBoundary(); |
||||||
|
neededBits = 32; |
||||||
|
mode = DECODE_CHKSUM; |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
int type = input.peekBits(3); |
||||||
|
if (type < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(3); |
||||||
|
|
||||||
|
if ((type & 1) != 0) |
||||||
|
isLastBlock = true; |
||||||
|
switch (type >> 1) { |
||||||
|
case DeflaterConstants.STORED_BLOCK: |
||||||
|
input.skipToByteBoundary(); |
||||||
|
mode = DECODE_STORED_LEN1; |
||||||
|
break; |
||||||
|
case DeflaterConstants.STATIC_TREES: |
||||||
|
litlenTree = InflaterHuffmanTree.defLitLenTree; |
||||||
|
distTree = InflaterHuffmanTree.defDistTree; |
||||||
|
mode = DECODE_HUFFMAN; |
||||||
|
break; |
||||||
|
case DeflaterConstants.DYN_TREES: |
||||||
|
dynHeader = new InflaterDynHeader(); |
||||||
|
mode = DECODE_DYN_HEADER; |
||||||
|
break; |
||||||
|
default: |
||||||
|
throw new DataFormatException("Unknown block type " + type); |
||||||
|
} |
||||||
|
return true; |
||||||
|
|
||||||
|
case DECODE_STORED_LEN1: { |
||||||
|
if ((uncomprLen = input.peekBits(16)) < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(16); |
||||||
|
mode = DECODE_STORED_LEN2; |
||||||
|
} |
||||||
|
/* fall through */ |
||||||
|
case DECODE_STORED_LEN2: { |
||||||
|
int nlen = input.peekBits(16); |
||||||
|
if (nlen < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(16); |
||||||
|
if (nlen != (uncomprLen ^ 0xffff)) |
||||||
|
throw new DataFormatException("broken uncompressed block"); |
||||||
|
mode = DECODE_STORED; |
||||||
|
} |
||||||
|
/* fall through */ |
||||||
|
case DECODE_STORED: { |
||||||
|
int more = outputWindow.copyStored(input, uncomprLen); |
||||||
|
uncomprLen -= more; |
||||||
|
if (uncomprLen == 0) { |
||||||
|
mode = DECODE_BLOCKS; |
||||||
|
return true; |
||||||
|
} |
||||||
|
return !input.needsInput(); |
||||||
|
} |
||||||
|
|
||||||
|
case DECODE_DYN_HEADER: |
||||||
|
if (!dynHeader.decode(input)) |
||||||
|
return false; |
||||||
|
litlenTree = dynHeader.buildLitLenTree(); |
||||||
|
distTree = dynHeader.buildDistTree(); |
||||||
|
mode = DECODE_HUFFMAN; |
||||||
|
/* fall through */ |
||||||
|
case DECODE_HUFFMAN: |
||||||
|
case DECODE_HUFFMAN_LENBITS: |
||||||
|
case DECODE_HUFFMAN_DIST: |
||||||
|
case DECODE_HUFFMAN_DISTBITS: |
||||||
|
return decodeHuffman(); |
||||||
|
case FINISHED: |
||||||
|
return false; |
||||||
|
default: |
||||||
|
throw new IllegalStateException(); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,187 @@ |
|||||||
|
/* me.ag2s.epublib.zip.InflaterDynHeader |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
class InflaterDynHeader { |
||||||
|
private static final int LNUM = 0; |
||||||
|
private static final int DNUM = 1; |
||||||
|
private static final int BLNUM = 2; |
||||||
|
private static final int BLLENS = 3; |
||||||
|
private static final int LENS = 4; |
||||||
|
private static final int REPS = 5; |
||||||
|
|
||||||
|
private static final int repMin[] = {3, 3, 11}; |
||||||
|
private static final int repBits[] = {2, 3, 7}; |
||||||
|
|
||||||
|
|
||||||
|
private byte[] blLens; |
||||||
|
private byte[] litdistLens; |
||||||
|
|
||||||
|
private InflaterHuffmanTree blTree; |
||||||
|
|
||||||
|
private int mode; |
||||||
|
private int lnum, dnum, blnum, num; |
||||||
|
private int repSymbol; |
||||||
|
private byte lastLen; |
||||||
|
private int ptr; |
||||||
|
|
||||||
|
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}; |
||||||
|
|
||||||
|
public InflaterDynHeader() { |
||||||
|
} |
||||||
|
|
||||||
|
public boolean decode(StreamManipulator input) throws DataFormatException { |
||||||
|
decode_loop: |
||||||
|
for (; ; ) { |
||||||
|
switch (mode) { |
||||||
|
case LNUM: |
||||||
|
lnum = input.peekBits(5); |
||||||
|
if (lnum < 0) |
||||||
|
return false; |
||||||
|
lnum += 257; |
||||||
|
input.dropBits(5); |
||||||
|
// System.err.println("LNUM: "+lnum);
|
||||||
|
mode = DNUM; |
||||||
|
/* fall through */ |
||||||
|
case DNUM: |
||||||
|
dnum = input.peekBits(5); |
||||||
|
if (dnum < 0) |
||||||
|
return false; |
||||||
|
dnum++; |
||||||
|
input.dropBits(5); |
||||||
|
// System.err.println("DNUM: "+dnum);
|
||||||
|
num = lnum + dnum; |
||||||
|
litdistLens = new byte[num]; |
||||||
|
mode = BLNUM; |
||||||
|
/* fall through */ |
||||||
|
case BLNUM: |
||||||
|
blnum = input.peekBits(4); |
||||||
|
if (blnum < 0) |
||||||
|
return false; |
||||||
|
blnum += 4; |
||||||
|
input.dropBits(4); |
||||||
|
blLens = new byte[19]; |
||||||
|
ptr = 0; |
||||||
|
// System.err.println("BLNUM: "+blnum);
|
||||||
|
mode = BLLENS; |
||||||
|
/* fall through */ |
||||||
|
case BLLENS: |
||||||
|
while (ptr < blnum) { |
||||||
|
int len = input.peekBits(3); |
||||||
|
if (len < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(3); |
||||||
|
// System.err.println("blLens["+BL_ORDER[ptr]+"]: "+len);
|
||||||
|
blLens[BL_ORDER[ptr]] = (byte) len; |
||||||
|
ptr++; |
||||||
|
} |
||||||
|
blTree = new InflaterHuffmanTree(blLens); |
||||||
|
blLens = null; |
||||||
|
ptr = 0; |
||||||
|
mode = LENS; |
||||||
|
/* fall through */ |
||||||
|
case LENS: { |
||||||
|
int symbol; |
||||||
|
while (((symbol = blTree.getSymbol(input)) & ~15) == 0) { |
||||||
|
/* Normal case: symbol in [0..15] */ |
||||||
|
|
||||||
|
// System.err.println("litdistLens["+ptr+"]: "+symbol);
|
||||||
|
litdistLens[ptr++] = lastLen = (byte) symbol; |
||||||
|
|
||||||
|
if (ptr == num) { |
||||||
|
/* Finished */ |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* need more input ? */ |
||||||
|
if (symbol < 0) |
||||||
|
return false; |
||||||
|
|
||||||
|
/* otherwise repeat code */ |
||||||
|
if (symbol >= 17) { |
||||||
|
/* repeat zero */ |
||||||
|
// System.err.println("repeating zero");
|
||||||
|
lastLen = 0; |
||||||
|
} else { |
||||||
|
if (ptr == 0) |
||||||
|
throw new DataFormatException(); |
||||||
|
} |
||||||
|
repSymbol = symbol - 16; |
||||||
|
mode = REPS; |
||||||
|
} |
||||||
|
/* fall through */ |
||||||
|
|
||||||
|
case REPS: { |
||||||
|
int bits = repBits[repSymbol]; |
||||||
|
int count = input.peekBits(bits); |
||||||
|
if (count < 0) |
||||||
|
return false; |
||||||
|
input.dropBits(bits); |
||||||
|
count += repMin[repSymbol]; |
||||||
|
// System.err.println("litdistLens repeated: "+count);
|
||||||
|
|
||||||
|
if (ptr + count > num) |
||||||
|
throw new DataFormatException(); |
||||||
|
while (count-- > 0) |
||||||
|
litdistLens[ptr++] = lastLen; |
||||||
|
|
||||||
|
if (ptr == num) { |
||||||
|
/* Finished */ |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
mode = LENS; |
||||||
|
continue decode_loop; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public InflaterHuffmanTree buildLitLenTree() throws DataFormatException { |
||||||
|
byte[] litlenLens = new byte[lnum]; |
||||||
|
System.arraycopy(litdistLens, 0, litlenLens, 0, lnum); |
||||||
|
return new InflaterHuffmanTree(litlenLens); |
||||||
|
} |
||||||
|
|
||||||
|
public InflaterHuffmanTree buildDistTree() throws DataFormatException { |
||||||
|
byte[] distLens = new byte[dnum]; |
||||||
|
System.arraycopy(litdistLens, lnum, distLens, 0, dnum); |
||||||
|
return new InflaterHuffmanTree(distLens); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,187 @@ |
|||||||
|
/* me.ag2s.epublib.zip.InflaterHuffmanTree |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
public class InflaterHuffmanTree { |
||||||
|
private final static int MAX_BITLEN = 15; |
||||||
|
private short[] tree; |
||||||
|
|
||||||
|
public static InflaterHuffmanTree defLitLenTree, defDistTree; |
||||||
|
|
||||||
|
static { |
||||||
|
try { |
||||||
|
byte[] codeLengths = new byte[288]; |
||||||
|
int i = 0; |
||||||
|
while (i < 144) |
||||||
|
codeLengths[i++] = 8; |
||||||
|
while (i < 256) |
||||||
|
codeLengths[i++] = 9; |
||||||
|
while (i < 280) |
||||||
|
codeLengths[i++] = 7; |
||||||
|
while (i < 288) |
||||||
|
codeLengths[i++] = 8; |
||||||
|
defLitLenTree = new InflaterHuffmanTree(codeLengths); |
||||||
|
|
||||||
|
codeLengths = new byte[32]; |
||||||
|
i = 0; |
||||||
|
while (i < 32) |
||||||
|
codeLengths[i++] = 5; |
||||||
|
defDistTree = new InflaterHuffmanTree(codeLengths); |
||||||
|
} catch (DataFormatException ex) { |
||||||
|
throw new InternalError |
||||||
|
("InflaterHuffmanTree: static tree length illegal"); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Constructs a Huffman tree from the array of code lengths. |
||||||
|
* |
||||||
|
* @param codeLengths the array of code lengths |
||||||
|
*/ |
||||||
|
public InflaterHuffmanTree(byte[] codeLengths) throws DataFormatException { |
||||||
|
buildTree(codeLengths); |
||||||
|
} |
||||||
|
|
||||||
|
private void buildTree(byte[] codeLengths) throws DataFormatException { |
||||||
|
int[] blCount = new int[MAX_BITLEN + 1]; |
||||||
|
int[] nextCode = new int[MAX_BITLEN + 1]; |
||||||
|
for (int i = 0; i < codeLengths.length; i++) { |
||||||
|
int bits = codeLengths[i]; |
||||||
|
if (bits > 0) |
||||||
|
blCount[bits]++; |
||||||
|
} |
||||||
|
|
||||||
|
int code = 0; |
||||||
|
int treeSize = 512; |
||||||
|
for (int bits = 1; bits <= MAX_BITLEN; bits++) { |
||||||
|
nextCode[bits] = code; |
||||||
|
code += blCount[bits] << (16 - bits); |
||||||
|
if (bits >= 10) { |
||||||
|
/* We need an extra table for bit lengths >= 10. */ |
||||||
|
int start = nextCode[bits] & 0x1ff80; |
||||||
|
int end = code & 0x1ff80; |
||||||
|
treeSize += (end - start) >> (16 - bits); |
||||||
|
} |
||||||
|
} |
||||||
|
if (code != 65536) |
||||||
|
throw new DataFormatException("Code lengths don't add up properly."); |
||||||
|
|
||||||
|
/* Now create and fill the extra tables from longest to shortest |
||||||
|
* bit len. This way the sub trees will be aligned. |
||||||
|
*/ |
||||||
|
tree = new short[treeSize]; |
||||||
|
int treePtr = 512; |
||||||
|
for (int bits = MAX_BITLEN; bits >= 10; bits--) { |
||||||
|
int end = code & 0x1ff80; |
||||||
|
code -= blCount[bits] << (16 - bits); |
||||||
|
int start = code & 0x1ff80; |
||||||
|
for (int i = start; i < end; i += 1 << 7) { |
||||||
|
tree[DeflaterHuffman.bitReverse(i)] |
||||||
|
= (short) ((-treePtr << 4) | bits); |
||||||
|
treePtr += 1 << (bits - 9); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
for (int i = 0; i < codeLengths.length; i++) { |
||||||
|
int bits = codeLengths[i]; |
||||||
|
if (bits == 0) |
||||||
|
continue; |
||||||
|
code = nextCode[bits]; |
||||||
|
int revcode = DeflaterHuffman.bitReverse(code); |
||||||
|
if (bits <= 9) { |
||||||
|
do { |
||||||
|
tree[revcode] = (short) ((i << 4) | bits); |
||||||
|
revcode += 1 << bits; |
||||||
|
} |
||||||
|
while (revcode < 512); |
||||||
|
} else { |
||||||
|
int subTree = tree[revcode & 511]; |
||||||
|
int treeLen = 1 << (subTree & 15); |
||||||
|
subTree = -(subTree >> 4); |
||||||
|
do { |
||||||
|
tree[subTree | (revcode >> 9)] = (short) ((i << 4) | bits); |
||||||
|
revcode += 1 << bits; |
||||||
|
} |
||||||
|
while (revcode < treeLen); |
||||||
|
} |
||||||
|
nextCode[bits] = code + (1 << (16 - bits)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Reads the next symbol from input. The symbol is encoded using the |
||||||
|
* huffman tree. |
||||||
|
* |
||||||
|
* @param input the input source. |
||||||
|
* @return the next symbol, or -1 if not enough input is available. |
||||||
|
*/ |
||||||
|
public int getSymbol(StreamManipulator input) throws DataFormatException { |
||||||
|
int lookahead, symbol; |
||||||
|
if ((lookahead = input.peekBits(9)) >= 0) { |
||||||
|
if ((symbol = tree[lookahead]) >= 0) { |
||||||
|
input.dropBits(symbol & 15); |
||||||
|
return symbol >> 4; |
||||||
|
} |
||||||
|
int subtree = -(symbol >> 4); |
||||||
|
int bitlen = symbol & 15; |
||||||
|
if ((lookahead = input.peekBits(bitlen)) >= 0) { |
||||||
|
symbol = tree[subtree | (lookahead >> 9)]; |
||||||
|
input.dropBits(symbol & 15); |
||||||
|
return symbol >> 4; |
||||||
|
} else { |
||||||
|
int bits = input.getAvailableBits(); |
||||||
|
lookahead = input.peekBits(bits); |
||||||
|
symbol = tree[subtree | (lookahead >> 9)]; |
||||||
|
if ((symbol & 15) <= bits) { |
||||||
|
input.dropBits(symbol & 15); |
||||||
|
return symbol >> 4; |
||||||
|
} else |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} else { |
||||||
|
int bits = input.getAvailableBits(); |
||||||
|
lookahead = input.peekBits(bits); |
||||||
|
symbol = tree[lookahead]; |
||||||
|
if (symbol >= 0 && (symbol & 15) <= bits) { |
||||||
|
input.dropBits(symbol & 15); |
||||||
|
return symbol >> 4; |
||||||
|
} else |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,230 @@ |
|||||||
|
/* InflaterInputStream.java - Input stream filter for decompressing |
||||||
|
Copyright (C) 1999, 2000, 2001, 2002, 2003, 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import java.io.FilterInputStream; |
||||||
|
import java.io.IOException; |
||||||
|
import java.io.InputStream; |
||||||
|
|
||||||
|
/** |
||||||
|
* This filter stream is used to decompress data compressed in the "deflate" |
||||||
|
* format. The "deflate" format is described in RFC 1951. |
||||||
|
* <p> |
||||||
|
* This stream may form the basis for other decompression filters, such |
||||||
|
* as the <code>GZIPInputStream</code>. |
||||||
|
* |
||||||
|
* @author John Leuner |
||||||
|
* @author Tom Tromey |
||||||
|
* @since 1.1 |
||||||
|
*/ |
||||||
|
public class InflaterInputStream extends FilterInputStream { |
||||||
|
/** |
||||||
|
* Decompressor for this filter |
||||||
|
*/ |
||||||
|
protected Inflater inf; |
||||||
|
|
||||||
|
/** |
||||||
|
* Byte array used as a buffer |
||||||
|
*/ |
||||||
|
protected byte[] buf; |
||||||
|
|
||||||
|
/** |
||||||
|
* Size of buffer |
||||||
|
*/ |
||||||
|
protected int len; |
||||||
|
|
||||||
|
/* |
||||||
|
* We just use this if we are decoding one byte at a time with the read() call |
||||||
|
*/ |
||||||
|
private byte[] onebytebuffer = new byte[1]; |
||||||
|
|
||||||
|
/** |
||||||
|
* Create an InflaterInputStream with the default decompresseor |
||||||
|
* and a default buffer size. |
||||||
|
* |
||||||
|
* @param in the InputStream to read bytes from |
||||||
|
*/ |
||||||
|
public InflaterInputStream(InputStream in) { |
||||||
|
this(in, new Inflater(), 4096); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Create an InflaterInputStream with the specified decompresseor |
||||||
|
* and a default buffer size. |
||||||
|
* |
||||||
|
* @param in the InputStream to read bytes from |
||||||
|
* @param inf the decompressor used to decompress data read from in |
||||||
|
*/ |
||||||
|
public InflaterInputStream(InputStream in, Inflater inf) { |
||||||
|
this(in, inf, 4096); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Create an InflaterInputStream with the specified decompresseor |
||||||
|
* and a specified buffer size. |
||||||
|
* |
||||||
|
* @param in the InputStream to read bytes from |
||||||
|
* @param inf the decompressor used to decompress data read from in |
||||||
|
* @param size size of the buffer to use |
||||||
|
*/ |
||||||
|
public InflaterInputStream(InputStream in, Inflater inf, int size) { |
||||||
|
super(in); |
||||||
|
this.len = 0; |
||||||
|
|
||||||
|
if (in == null) |
||||||
|
throw new NullPointerException("in may not be null"); |
||||||
|
if (inf == null) |
||||||
|
throw new NullPointerException("inf may not be null"); |
||||||
|
if (size < 0) |
||||||
|
throw new IllegalArgumentException("size may not be negative"); |
||||||
|
|
||||||
|
this.inf = inf; |
||||||
|
this.buf = new byte[size]; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns 0 once the end of the stream (EOF) has been reached. |
||||||
|
* Otherwise returns 1. |
||||||
|
*/ |
||||||
|
public int available() throws IOException { |
||||||
|
// According to the JDK 1.2 docs, this should only ever return 0
|
||||||
|
// or 1 and should not be relied upon by Java programs.
|
||||||
|
return inf.finished() ? 0 : 1; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Closes the input stream |
||||||
|
*/ |
||||||
|
public synchronized void close() throws IOException { |
||||||
|
if (in != null) |
||||||
|
in.close(); |
||||||
|
in = null; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Fills the buffer with more data to decompress. |
||||||
|
*/ |
||||||
|
protected void fill() throws IOException { |
||||||
|
if (in == null) |
||||||
|
throw new ZipException("InflaterInputStream is closed"); |
||||||
|
|
||||||
|
len = in.read(buf, 0, buf.length); |
||||||
|
|
||||||
|
if (len < 0) |
||||||
|
throw new ZipException("Deflated stream ends early."); |
||||||
|
|
||||||
|
inf.setInput(buf, 0, len); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Reads one byte of decompressed data. |
||||||
|
* <p> |
||||||
|
* The byte is in the lower 8 bits of the int. |
||||||
|
*/ |
||||||
|
public int read() throws IOException { |
||||||
|
int nread = read(onebytebuffer, 0, 1); //read one byte
|
||||||
|
|
||||||
|
if (nread > 0) |
||||||
|
return onebytebuffer[0] & 0xff; |
||||||
|
|
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Decompresses data into the byte array |
||||||
|
* |
||||||
|
* @param b the array to read and decompress data into |
||||||
|
* @param off the offset indicating where the data should be placed |
||||||
|
* @param len the number of bytes to decompress |
||||||
|
*/ |
||||||
|
public int read(byte[] b, int off, int len) throws IOException { |
||||||
|
if (len == 0) |
||||||
|
return 0; |
||||||
|
|
||||||
|
for (; ; ) { |
||||||
|
int count; |
||||||
|
|
||||||
|
try { |
||||||
|
count = inf.inflate(b, off, len); |
||||||
|
} catch (DataFormatException dfe) { |
||||||
|
throw new ZipException(dfe.getMessage()); |
||||||
|
} |
||||||
|
|
||||||
|
if (count > 0) |
||||||
|
return count; |
||||||
|
|
||||||
|
if (inf.needsDictionary() |
||||||
|
| inf.finished()) |
||||||
|
return -1; |
||||||
|
else if (inf.needsInput()) |
||||||
|
fill(); |
||||||
|
else |
||||||
|
throw new InternalError("Don't know what to do"); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Skip specified number of bytes of uncompressed data |
||||||
|
* |
||||||
|
* @param n number of bytes to skip |
||||||
|
*/ |
||||||
|
public long skip(long n) throws IOException { |
||||||
|
if (n < 0) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
|
||||||
|
if (n == 0) |
||||||
|
return 0; |
||||||
|
|
||||||
|
// Implementation copied from InputStream
|
||||||
|
// Throw away n bytes by reading them into a temp byte[].
|
||||||
|
// Limit the temp array to 2Kb so we don't grab too much memory.
|
||||||
|
final int buflen = n > 2048 ? 2048 : (int) n; |
||||||
|
byte[] tmpbuf = new byte[buflen]; |
||||||
|
final long origN = n; |
||||||
|
|
||||||
|
while (n > 0L) { |
||||||
|
int numread = read(tmpbuf, 0, n > buflen ? buflen : (int) n); |
||||||
|
if (numread <= 0) |
||||||
|
break; |
||||||
|
n -= numread; |
||||||
|
} |
||||||
|
|
||||||
|
return origN - n; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,161 @@ |
|||||||
|
/* me.ag2s.epublib.zip.OutputWindow |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/* |
||||||
|
* Contains the output from the Inflation process. |
||||||
|
* |
||||||
|
* We need to have a window so that we can refer backwards into the output stream |
||||||
|
* to repeat stuff. |
||||||
|
* |
||||||
|
* @author John Leuner |
||||||
|
* @since JDK 1.1 |
||||||
|
*/ |
||||||
|
|
||||||
|
class OutputWindow { |
||||||
|
private final int WINDOW_SIZE = 1 << 15; |
||||||
|
private final int WINDOW_MASK = WINDOW_SIZE - 1; |
||||||
|
|
||||||
|
private byte[] window = new byte[WINDOW_SIZE]; //The window is 2^15 bytes
|
||||||
|
private int window_end = 0; |
||||||
|
private int window_filled = 0; |
||||||
|
|
||||||
|
public void write(int abyte) { |
||||||
|
if (window_filled++ == WINDOW_SIZE) |
||||||
|
throw new IllegalStateException("Window full"); |
||||||
|
window[window_end++] = (byte) abyte; |
||||||
|
window_end &= WINDOW_MASK; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
private final void slowRepeat(int rep_start, int len, int dist) { |
||||||
|
while (len-- > 0) { |
||||||
|
window[window_end++] = window[rep_start++]; |
||||||
|
window_end &= WINDOW_MASK; |
||||||
|
rep_start &= WINDOW_MASK; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public void repeat(int len, int dist) { |
||||||
|
if ((window_filled += len) > WINDOW_SIZE) |
||||||
|
throw new IllegalStateException("Window full"); |
||||||
|
|
||||||
|
int rep_start = (window_end - dist) & WINDOW_MASK; |
||||||
|
int border = WINDOW_SIZE - len; |
||||||
|
if (rep_start <= border && window_end < border) { |
||||||
|
if (len <= dist) { |
||||||
|
System.arraycopy(window, rep_start, window, window_end, len); |
||||||
|
window_end += len; |
||||||
|
} else { |
||||||
|
/* We have to copy manually, since the repeat pattern overlaps. |
||||||
|
*/ |
||||||
|
while (len-- > 0) |
||||||
|
window[window_end++] = window[rep_start++]; |
||||||
|
} |
||||||
|
} else |
||||||
|
slowRepeat(rep_start, len, dist); |
||||||
|
} |
||||||
|
|
||||||
|
public int copyStored(StreamManipulator input, int len) { |
||||||
|
len = Math.min(Math.min(len, WINDOW_SIZE - window_filled), |
||||||
|
input.getAvailableBytes()); |
||||||
|
int copied; |
||||||
|
|
||||||
|
int tailLen = WINDOW_SIZE - window_end; |
||||||
|
if (len > tailLen) { |
||||||
|
copied = input.copyBytes(window, window_end, tailLen); |
||||||
|
if (copied == tailLen) |
||||||
|
copied += input.copyBytes(window, 0, len - tailLen); |
||||||
|
} else |
||||||
|
copied = input.copyBytes(window, window_end, len); |
||||||
|
|
||||||
|
window_end = (window_end + copied) & WINDOW_MASK; |
||||||
|
window_filled += copied; |
||||||
|
return copied; |
||||||
|
} |
||||||
|
|
||||||
|
public void copyDict(byte[] dict, int offset, int len) { |
||||||
|
if (window_filled > 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
|
||||||
|
if (len > WINDOW_SIZE) { |
||||||
|
offset += len - WINDOW_SIZE; |
||||||
|
len = WINDOW_SIZE; |
||||||
|
} |
||||||
|
System.arraycopy(dict, offset, window, 0, len); |
||||||
|
window_end = len & WINDOW_MASK; |
||||||
|
} |
||||||
|
|
||||||
|
public int getFreeSpace() { |
||||||
|
return WINDOW_SIZE - window_filled; |
||||||
|
} |
||||||
|
|
||||||
|
public int getAvailable() { |
||||||
|
return window_filled; |
||||||
|
} |
||||||
|
|
||||||
|
public int copyOutput(byte[] output, int offset, int len) { |
||||||
|
int copy_end = window_end; |
||||||
|
if (len > window_filled) |
||||||
|
len = window_filled; |
||||||
|
else |
||||||
|
copy_end = (window_end - window_filled + len) & WINDOW_MASK; |
||||||
|
|
||||||
|
int copied = len; |
||||||
|
int tailLen = len - copy_end; |
||||||
|
|
||||||
|
if (tailLen > 0) { |
||||||
|
System.arraycopy(window, WINDOW_SIZE - tailLen, |
||||||
|
output, offset, tailLen); |
||||||
|
offset += tailLen; |
||||||
|
len = copy_end; |
||||||
|
} |
||||||
|
System.arraycopy(window, copy_end - len, output, offset, len); |
||||||
|
window_filled -= copied; |
||||||
|
if (window_filled < 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
return copied; |
||||||
|
} |
||||||
|
|
||||||
|
public void reset() { |
||||||
|
window_filled = window_end = 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,181 @@ |
|||||||
|
/* me.ag2s.epublib.zip.PendingBuffer |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/** |
||||||
|
* This class is general purpose class for writing data to a buffer. |
||||||
|
* <p> |
||||||
|
* It allows you to write bits as well as bytes |
||||||
|
* <p> |
||||||
|
* Based on DeflaterPending.java |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
* @date Jan 5, 2000 |
||||||
|
*/ |
||||||
|
|
||||||
|
class PendingBuffer { |
||||||
|
protected byte[] buf; |
||||||
|
int start; |
||||||
|
int end; |
||||||
|
|
||||||
|
int bits; |
||||||
|
int bitCount; |
||||||
|
|
||||||
|
public PendingBuffer() { |
||||||
|
this(4096); |
||||||
|
} |
||||||
|
|
||||||
|
public PendingBuffer(int bufsize) { |
||||||
|
buf = new byte[bufsize]; |
||||||
|
} |
||||||
|
|
||||||
|
public final void reset() { |
||||||
|
start = end = bitCount = 0; |
||||||
|
} |
||||||
|
|
||||||
|
public final void writeByte(int b) { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
buf[end++] = (byte) b; |
||||||
|
} |
||||||
|
|
||||||
|
public final void writeShort(int s) { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
buf[end++] = (byte) s; |
||||||
|
buf[end++] = (byte) (s >> 8); |
||||||
|
} |
||||||
|
|
||||||
|
public final void writeInt(int s) { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
buf[end++] = (byte) s; |
||||||
|
buf[end++] = (byte) (s >> 8); |
||||||
|
buf[end++] = (byte) (s >> 16); |
||||||
|
buf[end++] = (byte) (s >> 24); |
||||||
|
} |
||||||
|
|
||||||
|
public final void writeBlock(byte[] block, int offset, int len) { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
System.arraycopy(block, offset, buf, end, len); |
||||||
|
end += len; |
||||||
|
} |
||||||
|
|
||||||
|
public final int getBitCount() { |
||||||
|
return bitCount; |
||||||
|
} |
||||||
|
|
||||||
|
public final void alignToByte() { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
if (bitCount > 0) { |
||||||
|
buf[end++] = (byte) bits; |
||||||
|
if (bitCount > 8) |
||||||
|
buf[end++] = (byte) (bits >>> 8); |
||||||
|
} |
||||||
|
bits = 0; |
||||||
|
bitCount = 0; |
||||||
|
} |
||||||
|
|
||||||
|
public final void writeBits(int b, int count) { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
if (DeflaterConstants.DEBUGGING) |
||||||
|
System.err.println("writeBits(" + Integer.toHexString(b) + "," + count + ")"); |
||||||
|
bits |= b << bitCount; |
||||||
|
bitCount += count; |
||||||
|
if (bitCount >= 16) { |
||||||
|
buf[end++] = (byte) bits; |
||||||
|
buf[end++] = (byte) (bits >>> 8); |
||||||
|
bits >>>= 16; |
||||||
|
bitCount -= 16; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public final void writeShortMSB(int s) { |
||||||
|
if (DeflaterConstants.DEBUGGING && start != 0) |
||||||
|
throw new IllegalStateException(); |
||||||
|
buf[end++] = (byte) (s >> 8); |
||||||
|
buf[end++] = (byte) s; |
||||||
|
} |
||||||
|
|
||||||
|
public final boolean isFlushed() { |
||||||
|
return end == 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Flushes the pending buffer into the given output array. If the |
||||||
|
* output array is to small, only a partial flush is done. |
||||||
|
* |
||||||
|
* @param output the output array; |
||||||
|
* @param offset the offset into output array; |
||||||
|
* @param length the maximum number of bytes to store; |
||||||
|
* @throws IndexOutOfBoundsException if offset or length are |
||||||
|
* invalid. |
||||||
|
*/ |
||||||
|
public final int flush(byte[] output, int offset, int length) { |
||||||
|
if (bitCount >= 8) { |
||||||
|
buf[end++] = (byte) bits; |
||||||
|
bits >>>= 8; |
||||||
|
bitCount -= 8; |
||||||
|
} |
||||||
|
if (length > end - start) { |
||||||
|
length = end - start; |
||||||
|
System.arraycopy(buf, start, output, offset, length); |
||||||
|
start = 0; |
||||||
|
end = 0; |
||||||
|
} else { |
||||||
|
System.arraycopy(buf, start, output, offset, length); |
||||||
|
start += length; |
||||||
|
} |
||||||
|
return length; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
public final byte[] toByteArray() { |
||||||
|
byte[] ret = new byte[end - start]; |
||||||
|
System.arraycopy(buf, start, ret, 0, ret.length); |
||||||
|
start = 0; |
||||||
|
end = 0; |
||||||
|
return ret; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,206 @@ |
|||||||
|
/* me.ag2s.epublib.zip.StreamManipulator |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
/** |
||||||
|
* This class allows us to retrieve a specified amount of bits from |
||||||
|
* the input buffer, as well as copy big byte blocks. |
||||||
|
* <p> |
||||||
|
* It uses an int buffer to store up to 31 bits for direct |
||||||
|
* manipulation. This guarantees that we can get at least 16 bits, |
||||||
|
* but we only need at most 15, so this is all safe. |
||||||
|
* <p> |
||||||
|
* There are some optimizations in this class, for example, you must |
||||||
|
* never peek more then 8 bits more than needed, and you must first |
||||||
|
* peek bits before you may drop them. This is not a general purpose |
||||||
|
* class but optimized for the behaviour of the Inflater. |
||||||
|
* |
||||||
|
* @author John Leuner, Jochen Hoenicke |
||||||
|
*/ |
||||||
|
|
||||||
|
class StreamManipulator { |
||||||
|
private byte[] window; |
||||||
|
private int window_start = 0; |
||||||
|
private int window_end = 0; |
||||||
|
|
||||||
|
private int buffer = 0; |
||||||
|
private int bits_in_buffer = 0; |
||||||
|
|
||||||
|
/** |
||||||
|
* Get the next n bits but don't increase input pointer. n must be |
||||||
|
* less or equal 16 and if you if this call succeeds, you must drop |
||||||
|
* at least n-8 bits in the next call. |
||||||
|
* |
||||||
|
* @return the value of the bits, or -1 if not enough bits available. |
||||||
|
*/ |
||||||
|
public final int peekBits(int n) { |
||||||
|
if (bits_in_buffer < n) { |
||||||
|
if (window_start == window_end) |
||||||
|
return -1; |
||||||
|
buffer |= (window[window_start++] & 0xff |
||||||
|
| (window[window_start++] & 0xff) << 8) << bits_in_buffer; |
||||||
|
bits_in_buffer += 16; |
||||||
|
} |
||||||
|
return buffer & ((1 << n) - 1); |
||||||
|
} |
||||||
|
|
||||||
|
/* Drops the next n bits from the input. You should have called peekBits |
||||||
|
* with a bigger or equal n before, to make sure that enough bits are in |
||||||
|
* the bit buffer. |
||||||
|
*/ |
||||||
|
public final void dropBits(int n) { |
||||||
|
buffer >>>= n; |
||||||
|
bits_in_buffer -= n; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the next n bits and increases input pointer. This is equivalent |
||||||
|
* to peekBits followed by dropBits, except for correct error handling. |
||||||
|
* |
||||||
|
* @return the value of the bits, or -1 if not enough bits available. |
||||||
|
*/ |
||||||
|
public final int getBits(int n) { |
||||||
|
int bits = peekBits(n); |
||||||
|
if (bits >= 0) |
||||||
|
dropBits(n); |
||||||
|
return bits; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the number of bits available in the bit buffer. This must be |
||||||
|
* only called when a previous peekBits() returned -1. |
||||||
|
* |
||||||
|
* @return the number of bits available. |
||||||
|
*/ |
||||||
|
public final int getAvailableBits() { |
||||||
|
return bits_in_buffer; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the number of bytes available. |
||||||
|
* |
||||||
|
* @return the number of bytes available. |
||||||
|
*/ |
||||||
|
public final int getAvailableBytes() { |
||||||
|
return window_end - window_start + (bits_in_buffer >> 3); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Skips to the next byte boundary. |
||||||
|
*/ |
||||||
|
public void skipToByteBoundary() { |
||||||
|
buffer >>= (bits_in_buffer & 7); |
||||||
|
bits_in_buffer &= ~7; |
||||||
|
} |
||||||
|
|
||||||
|
public final boolean needsInput() { |
||||||
|
return window_start == window_end; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/* Copies length bytes from input buffer to output buffer starting |
||||||
|
* at output[offset]. You have to make sure, that the buffer is |
||||||
|
* byte aligned. If not enough bytes are available, copies fewer |
||||||
|
* bytes. |
||||||
|
* @param length the length to copy, 0 is allowed. |
||||||
|
* @return the number of bytes copied, 0 if no byte is available. |
||||||
|
*/ |
||||||
|
public int copyBytes(byte[] output, int offset, int length) { |
||||||
|
if (length < 0) |
||||||
|
throw new IllegalArgumentException("length negative"); |
||||||
|
if ((bits_in_buffer & 7) != 0) |
||||||
|
/* bits_in_buffer may only be 0 or 8 */ |
||||||
|
throw new IllegalStateException("Bit buffer is not aligned!"); |
||||||
|
|
||||||
|
int count = 0; |
||||||
|
while (bits_in_buffer > 0 && length > 0) { |
||||||
|
output[offset++] = (byte) buffer; |
||||||
|
buffer >>>= 8; |
||||||
|
bits_in_buffer -= 8; |
||||||
|
length--; |
||||||
|
count++; |
||||||
|
} |
||||||
|
if (length == 0) |
||||||
|
return count; |
||||||
|
|
||||||
|
int avail = window_end - window_start; |
||||||
|
if (length > avail) |
||||||
|
length = avail; |
||||||
|
System.arraycopy(window, window_start, output, offset, length); |
||||||
|
window_start += length; |
||||||
|
|
||||||
|
if (((window_start - window_end) & 1) != 0) { |
||||||
|
/* We always want an even number of bytes in input, see peekBits */ |
||||||
|
buffer = (window[window_start++] & 0xff); |
||||||
|
bits_in_buffer = 8; |
||||||
|
} |
||||||
|
return count + length; |
||||||
|
} |
||||||
|
|
||||||
|
public StreamManipulator() { |
||||||
|
} |
||||||
|
|
||||||
|
public void reset() { |
||||||
|
window_start = window_end = buffer = bits_in_buffer = 0; |
||||||
|
} |
||||||
|
|
||||||
|
public void setInput(byte[] buf, int off, int len) { |
||||||
|
if (window_start < window_end) |
||||||
|
throw new IllegalStateException |
||||||
|
("Old input was not completely processed"); |
||||||
|
|
||||||
|
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(); |
||||||
|
|
||||||
|
if ((len & 1) != 0) { |
||||||
|
/* We always want an even number of bytes in input, see peekBits */ |
||||||
|
buffer |= (buf[off++] & 0xff) << bits_in_buffer; |
||||||
|
bits_in_buffer += 8; |
||||||
|
} |
||||||
|
|
||||||
|
window = buf; |
||||||
|
window_start = off; |
||||||
|
window_end = end; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,96 @@ |
|||||||
|
/* me.ag2s.epublib.zip.ZipConstants |
||||||
|
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 thata |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
interface ZipConstants { |
||||||
|
/* The local file header */ |
||||||
|
int LOCHDR = 30; |
||||||
|
int LOCSIG = 'P' | ('K' << 8) | (3 << 16) | (4 << 24); |
||||||
|
|
||||||
|
int LOCVER = 4; |
||||||
|
int LOCFLG = 6; |
||||||
|
int LOCHOW = 8; |
||||||
|
int LOCTIM = 10; |
||||||
|
int LOCCRC = 14; |
||||||
|
int LOCSIZ = 18; |
||||||
|
int LOCLEN = 22; |
||||||
|
int LOCNAM = 26; |
||||||
|
int LOCEXT = 28; |
||||||
|
|
||||||
|
/* The Data descriptor */ |
||||||
|
int EXTSIG = 'P' | ('K' << 8) | (7 << 16) | (8 << 24); |
||||||
|
int EXTHDR = 16; |
||||||
|
|
||||||
|
int EXTCRC = 4; |
||||||
|
int EXTSIZ = 8; |
||||||
|
int EXTLEN = 12; |
||||||
|
|
||||||
|
/* The central directory file header */ |
||||||
|
int CENSIG = 'P' | ('K' << 8) | (1 << 16) | (2 << 24); |
||||||
|
int CENHDR = 46; |
||||||
|
|
||||||
|
int CENVEM = 4; |
||||||
|
int CENVER = 6; |
||||||
|
int CENFLG = 8; |
||||||
|
int CENHOW = 10; |
||||||
|
int CENTIM = 12; |
||||||
|
int CENCRC = 16; |
||||||
|
int CENSIZ = 20; |
||||||
|
int CENLEN = 24; |
||||||
|
int CENNAM = 28; |
||||||
|
int CENEXT = 30; |
||||||
|
int CENCOM = 32; |
||||||
|
int CENDSK = 34; |
||||||
|
int CENATT = 36; |
||||||
|
int CENATX = 38; |
||||||
|
int CENOFF = 42; |
||||||
|
|
||||||
|
/* The entries in the end of central directory */ |
||||||
|
int ENDSIG = 'P' | ('K' << 8) | (5 << 16) | (6 << 24); |
||||||
|
int ENDHDR = 22; |
||||||
|
|
||||||
|
/* The following two fields are missing in SUN JDK */ |
||||||
|
int ENDNRD = 4; |
||||||
|
int ENDDCD = 6; |
||||||
|
int ENDSUB = 8; |
||||||
|
int ENDTOT = 10; |
||||||
|
int ENDSIZ = 12; |
||||||
|
int ENDOFF = 16; |
||||||
|
int ENDCOM = 20; |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,389 @@ |
|||||||
|
/* me.ag2s.epublib.zip.ZipEntry |
||||||
|
Copyright (C) 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import java.util.Calendar; |
||||||
|
import java.util.Date; |
||||||
|
|
||||||
|
/** |
||||||
|
* This class represents a member of a zip archive. ZipFile and |
||||||
|
* ZipInputStream will give you instances of this class as information |
||||||
|
* about the members in an archive. On the other hand ZipOutputStream |
||||||
|
* needs an instance of this class to create a new member. |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
*/ |
||||||
|
public class ZipEntry implements ZipConstants, Cloneable { |
||||||
|
private static final int KNOWN_SIZE = 1; |
||||||
|
private static final int KNOWN_CSIZE = 2; |
||||||
|
private static final int KNOWN_CRC = 4; |
||||||
|
private static final int KNOWN_TIME = 8; |
||||||
|
|
||||||
|
private static Calendar cal; |
||||||
|
|
||||||
|
private final String name; |
||||||
|
private int size; |
||||||
|
private int compressedSize; |
||||||
|
private int crc; |
||||||
|
private int dostime; |
||||||
|
private short known = 0; |
||||||
|
private short method = -1; |
||||||
|
private byte[] extra = null; |
||||||
|
private String comment = null; |
||||||
|
|
||||||
|
int flags; /* used by ZipOutputStream */ |
||||||
|
int offset; /* used by ZipFile and ZipOutputStream */ |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Compression method. This method doesn't compress at all. |
||||||
|
*/ |
||||||
|
public final static int STORED = 0; |
||||||
|
/** |
||||||
|
* Compression method. This method uses the Deflater. |
||||||
|
*/ |
||||||
|
public final static int DEFLATED = 8; |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a zip entry with the given name. |
||||||
|
* |
||||||
|
* @param name the name. May include directory components separated |
||||||
|
* by '/'. |
||||||
|
* @throws NullPointerException when name is null. |
||||||
|
* @throws IllegalArgumentException when name is bigger then 65535 chars. |
||||||
|
*/ |
||||||
|
public ZipEntry(String name) { |
||||||
|
int length = name.length(); |
||||||
|
if (length > 65535) |
||||||
|
throw new IllegalArgumentException("name length is " + length); |
||||||
|
this.name = name; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a copy of the given zip entry. |
||||||
|
* |
||||||
|
* @param e the entry to copy. |
||||||
|
*/ |
||||||
|
public ZipEntry(ZipEntry e) { |
||||||
|
name = e.name; |
||||||
|
known = e.known; |
||||||
|
size = e.size; |
||||||
|
compressedSize = e.compressedSize; |
||||||
|
crc = e.crc; |
||||||
|
dostime = e.dostime; |
||||||
|
method = e.method; |
||||||
|
extra = e.extra; |
||||||
|
comment = e.comment; |
||||||
|
} |
||||||
|
|
||||||
|
final void setDOSTime(int dostime) { |
||||||
|
this.dostime = dostime; |
||||||
|
known |= KNOWN_TIME; |
||||||
|
} |
||||||
|
|
||||||
|
final int getDOSTime() { |
||||||
|
if ((known & KNOWN_TIME) == 0) |
||||||
|
return 0; |
||||||
|
else |
||||||
|
return dostime; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a copy of this zip entry. |
||||||
|
*/ |
||||||
|
/** |
||||||
|
* Clones the entry. |
||||||
|
*/ |
||||||
|
public Object clone() { |
||||||
|
try { |
||||||
|
// The JCL says that the `extra' field is also copied.
|
||||||
|
ZipEntry clone = (ZipEntry) super.clone(); |
||||||
|
if (extra != null) |
||||||
|
clone.extra = (byte[]) extra.clone(); |
||||||
|
return clone; |
||||||
|
} catch (CloneNotSupportedException ex) { |
||||||
|
throw new InternalError(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the entry name. The path components in the entry are |
||||||
|
* always separated by slashes ('/'). |
||||||
|
*/ |
||||||
|
public String getName() { |
||||||
|
return name; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the time of last modification of the entry. |
||||||
|
* |
||||||
|
* @time the time of last modification of the entry. |
||||||
|
*/ |
||||||
|
public void setTime(long time) { |
||||||
|
Calendar cal = getCalendar(); |
||||||
|
synchronized (cal) { |
||||||
|
cal.setTime(new Date(time * 1000L)); |
||||||
|
dostime = (cal.get(Calendar.YEAR) - 1980 & 0x7f) << 25 |
||||||
|
| (cal.get(Calendar.MONTH) + 1) << 21 |
||||||
|
| (cal.get(Calendar.DAY_OF_MONTH)) << 16 |
||||||
|
| (cal.get(Calendar.HOUR_OF_DAY)) << 11 |
||||||
|
| (cal.get(Calendar.MINUTE)) << 5 |
||||||
|
| (cal.get(Calendar.SECOND)) >> 1; |
||||||
|
} |
||||||
|
dostime = (int) (dostime / 1000L); |
||||||
|
this.known |= KNOWN_TIME; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the time of last modification of the entry. |
||||||
|
* |
||||||
|
* @return the time of last modification of the entry, or -1 if unknown. |
||||||
|
*/ |
||||||
|
public long getTime() { |
||||||
|
if ((known & KNOWN_TIME) == 0) |
||||||
|
return -1; |
||||||
|
|
||||||
|
int sec = 2 * (dostime & 0x1f); |
||||||
|
int min = (dostime >> 5) & 0x3f; |
||||||
|
int hrs = (dostime >> 11) & 0x1f; |
||||||
|
int day = (dostime >> 16) & 0x1f; |
||||||
|
int mon = ((dostime >> 21) & 0xf) - 1; |
||||||
|
int year = ((dostime >> 25) & 0x7f) + 1980; /* since 1900 */ |
||||||
|
|
||||||
|
try { |
||||||
|
cal = getCalendar(); |
||||||
|
synchronized (cal) { |
||||||
|
cal.set(year, mon, day, hrs, min, sec); |
||||||
|
return cal.getTime().getTime(); |
||||||
|
} |
||||||
|
} catch (RuntimeException ex) { |
||||||
|
/* Ignore illegal time stamp */ |
||||||
|
known &= ~KNOWN_TIME; |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private static synchronized Calendar getCalendar() { |
||||||
|
if (cal == null) |
||||||
|
cal = Calendar.getInstance(); |
||||||
|
|
||||||
|
return cal; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the size of the uncompressed data. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if size is not in 0..0xffffffffL |
||||||
|
*/ |
||||||
|
public void setSize(long size) { |
||||||
|
if ((size & 0xffffffff00000000L) != 0) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
this.size = (int) size; |
||||||
|
this.known |= KNOWN_SIZE; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the size of the uncompressed data. |
||||||
|
* |
||||||
|
* @return the size or -1 if unknown. |
||||||
|
*/ |
||||||
|
public long getSize() { |
||||||
|
return (known & KNOWN_SIZE) != 0 ? size & 0xffffffffL : -1L; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the size of the compressed data. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if size is not in 0..0xffffffffL |
||||||
|
*/ |
||||||
|
public void setCompressedSize(long csize) { |
||||||
|
if ((csize & 0xffffffff00000000L) != 0) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
this.compressedSize = (int) csize; |
||||||
|
this.known |= KNOWN_CSIZE; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the size of the compressed data. |
||||||
|
* |
||||||
|
* @return the size or -1 if unknown. |
||||||
|
*/ |
||||||
|
public long getCompressedSize() { |
||||||
|
return (known & KNOWN_CSIZE) != 0 ? compressedSize & 0xffffffffL : -1L; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the crc of the uncompressed data. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if crc is not in 0..0xffffffffL |
||||||
|
*/ |
||||||
|
public void setCrc(long crc) { |
||||||
|
if ((crc & 0xffffffff00000000L) != 0) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
this.crc = (int) crc; |
||||||
|
this.known |= KNOWN_CRC; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the crc of the uncompressed data. |
||||||
|
* |
||||||
|
* @return the crc or -1 if unknown. |
||||||
|
*/ |
||||||
|
public long getCrc() { |
||||||
|
return (known & KNOWN_CRC) != 0 ? crc & 0xffffffffL : -1L; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the compression method. Only DEFLATED and STORED are |
||||||
|
* supported. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if method is not supported. |
||||||
|
* @see ZipOutputStream#DEFLATED |
||||||
|
* @see ZipOutputStream#STORED |
||||||
|
*/ |
||||||
|
public void setMethod(int method) { |
||||||
|
if (method != ZipOutputStream.STORED |
||||||
|
&& method != ZipOutputStream.DEFLATED) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
this.method = (short) method; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the compression method. |
||||||
|
* |
||||||
|
* @return the compression method or -1 if unknown. |
||||||
|
*/ |
||||||
|
public int getMethod() { |
||||||
|
return method; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the extra data. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if extra is longer than 0xffff bytes. |
||||||
|
*/ |
||||||
|
public void setExtra(byte[] extra) { |
||||||
|
if (extra == null) { |
||||||
|
this.extra = null; |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
if (extra.length > 0xffff) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
this.extra = extra; |
||||||
|
try { |
||||||
|
int pos = 0; |
||||||
|
while (pos < extra.length) { |
||||||
|
int sig = (extra[pos++] & 0xff) |
||||||
|
| (extra[pos++] & 0xff) << 8; |
||||||
|
int len = (extra[pos++] & 0xff) |
||||||
|
| (extra[pos++] & 0xff) << 8; |
||||||
|
if (sig == 0x5455) { |
||||||
|
/* extended time stamp */ |
||||||
|
int flags = extra[pos]; |
||||||
|
if ((flags & 1) != 0) { |
||||||
|
long time = ((extra[pos + 1] & 0xff) |
||||||
|
| (extra[pos + 2] & 0xff) << 8 |
||||||
|
| (extra[pos + 3] & 0xff) << 16 |
||||||
|
| (extra[pos + 4] & 0xff) << 24); |
||||||
|
setTime(time); |
||||||
|
} |
||||||
|
} |
||||||
|
pos += len; |
||||||
|
} |
||||||
|
} catch (ArrayIndexOutOfBoundsException ex) { |
||||||
|
/* be lenient */ |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the extra data. |
||||||
|
* |
||||||
|
* @return the extra data or null if not set. |
||||||
|
*/ |
||||||
|
public byte[] getExtra() { |
||||||
|
return extra; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets the entry comment. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if comment is longer than 0xffff. |
||||||
|
*/ |
||||||
|
public void setComment(String comment) { |
||||||
|
if (comment != null && comment.length() > 0xffff) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
this.comment = comment; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the comment. |
||||||
|
* |
||||||
|
* @return the comment or null if not set. |
||||||
|
*/ |
||||||
|
public String getComment() { |
||||||
|
return comment; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets true, if the entry is a directory. This is solely |
||||||
|
* determined by the name, a trailing slash '/' marks a directory. |
||||||
|
*/ |
||||||
|
public boolean isDirectory() { |
||||||
|
int nlen = name.length(); |
||||||
|
return nlen > 0 && name.charAt(nlen - 1) == '/'; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the string representation of this ZipEntry. This is just |
||||||
|
* the name as returned by getName(). |
||||||
|
*/ |
||||||
|
public String toString() { |
||||||
|
return name; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Gets the hashCode of this ZipEntry. This is just the hashCode |
||||||
|
* of the name. Note that the equals method isn't changed, though. |
||||||
|
*/ |
||||||
|
public int hashCode() { |
||||||
|
return name.hashCode(); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,69 @@ |
|||||||
|
/* ZipException.java - exception representing a zip related error |
||||||
|
Copyright (C) 1998, 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import java.io.IOException; |
||||||
|
|
||||||
|
/** |
||||||
|
* Thrown during the creation or input of a zip file. |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
* @author Per Bothner |
||||||
|
* @status updated to 1.4 |
||||||
|
*/ |
||||||
|
public class ZipException extends IOException { |
||||||
|
/** |
||||||
|
* Compatible with JDK 1.0+. |
||||||
|
*/ |
||||||
|
private static final long serialVersionUID = 8000196834066748623L; |
||||||
|
|
||||||
|
/** |
||||||
|
* Create an exception without a message. |
||||||
|
*/ |
||||||
|
public ZipException() { |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Create an exception with a message. |
||||||
|
* |
||||||
|
* @param msg the message |
||||||
|
*/ |
||||||
|
public ZipException(String msg) { |
||||||
|
super(msg); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,526 @@ |
|||||||
|
/* me.ag2s.epublib.zip.ZipFile |
||||||
|
Copyright (C) 2001, 2002, 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import android.content.Context; |
||||||
|
import android.net.Uri; |
||||||
|
import android.system.ErrnoException; |
||||||
|
|
||||||
|
import androidx.annotation.NonNull; |
||||||
|
|
||||||
|
import java.io.BufferedInputStream; |
||||||
|
import java.io.Closeable; |
||||||
|
import java.io.DataInput; |
||||||
|
import java.io.EOFException; |
||||||
|
import java.io.IOException; |
||||||
|
import java.io.InputStream; |
||||||
|
import java.util.Enumeration; |
||||||
|
import java.util.HashMap; |
||||||
|
import java.util.Iterator; |
||||||
|
import java.util.NoSuchElementException; |
||||||
|
|
||||||
|
/** |
||||||
|
* This class represents a Zip archive. You can ask for the contained |
||||||
|
* entries, or get an input stream for a file entry. The entry is |
||||||
|
* automatically decompressed. |
||||||
|
* <p> |
||||||
|
* This class is thread safe: You can open input streams for arbitrary |
||||||
|
* entries in different threads. |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
* @author Artur Biesiadowski |
||||||
|
*/ |
||||||
|
public class ZipFile implements ZipConstants, Closeable { |
||||||
|
|
||||||
|
/** |
||||||
|
* Mode flag to open a zip file for reading. |
||||||
|
*/ |
||||||
|
public static final int OPEN_READ = 0x1; |
||||||
|
|
||||||
|
/** |
||||||
|
* Mode flag to delete a zip file after reading. |
||||||
|
*/ |
||||||
|
public static final int OPEN_DELETE = 0x4; |
||||||
|
|
||||||
|
@NonNull |
||||||
|
public Context getContext() { |
||||||
|
return context; |
||||||
|
} |
||||||
|
|
||||||
|
public Uri getUri() { |
||||||
|
return Uri.parse(name); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
@NonNull |
||||||
|
private final Context context; |
||||||
|
|
||||||
|
// Name of this zip file.
|
||||||
|
@NonNull |
||||||
|
private final String name; |
||||||
|
|
||||||
|
// File from which zip entries are read.
|
||||||
|
@NonNull |
||||||
|
private final /*RandomAccessFile*/ AndroidRandomReadableFile araf; |
||||||
|
|
||||||
|
|
||||||
|
// The entries of this zip file when initialized and not yet closed.
|
||||||
|
private HashMap<String, ZipEntry> entries; |
||||||
|
|
||||||
|
private boolean closed = false; |
||||||
|
|
||||||
|
/** |
||||||
|
* Opens a Zip file with the given name for reading. |
||||||
|
* |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws ZipException if the file doesn't contain a valid zip |
||||||
|
* archive. |
||||||
|
*/ |
||||||
|
public ZipFile(@NonNull Context context, @NonNull Uri uri) throws ZipException, IOException { |
||||||
|
this.context = context; |
||||||
|
this.araf = new AndroidRandomReadableFile(context, uri); |
||||||
|
this.name = uri.toString(); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Opens a Zip file reading the given File in the given mode. |
||||||
|
* |
||||||
|
* If the OPEN_DELETE mode is specified, the zip file will be deleted at |
||||||
|
* some time moment after it is opened. It will be deleted before the zip |
||||||
|
* file is closed or the Virtual Machine exits. |
||||||
|
* |
||||||
|
* The contents of the zip file will be accessible until it is closed. |
||||||
|
* |
||||||
|
* The OPEN_DELETE mode is currently unimplemented in this library |
||||||
|
* |
||||||
|
* @since JDK1.3 |
||||||
|
* @param mode Must be one of OPEN_READ or OPEN_READ | OPEN_DELETE |
||||||
|
* |
||||||
|
* @exception IOException if a i/o error occured. |
||||||
|
* @exception ZipException if the file doesn't contain a valid zip |
||||||
|
* archive. |
||||||
|
*/ |
||||||
|
// public ZipFile(File file, int mode) throws ZipException, IOException
|
||||||
|
// {
|
||||||
|
// if ((mode & OPEN_DELETE) != 0)
|
||||||
|
// {
|
||||||
|
// throw new IllegalArgumentException
|
||||||
|
// ("OPEN_DELETE mode not supported yet in me.ag2s.epublib.zip.ZipFile");
|
||||||
|
// }
|
||||||
|
// this.raf = new RandomAccessFile(file, "r");
|
||||||
|
// this.name = file.getPath();
|
||||||
|
// }
|
||||||
|
|
||||||
|
/** |
||||||
|
* Read an unsigned short in little endian byte order from the given |
||||||
|
* DataInput stream using the given byte buffer. |
||||||
|
* |
||||||
|
* @param di DataInput stream to read from. |
||||||
|
* @param b the byte buffer to read in (must be at least 2 bytes long). |
||||||
|
* @return The value read. |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws EOFException if the file ends prematurely |
||||||
|
*/ |
||||||
|
private final int readLeShort(DataInput di, byte[] b) throws IOException { |
||||||
|
di.readFully(b, 0, 2); |
||||||
|
return (b[0] & 0xff) | (b[1] & 0xff) << 8; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Read an int in little endian byte order from the given |
||||||
|
* DataInput stream using the given byte buffer. |
||||||
|
* |
||||||
|
* @param di DataInput stream to read from. |
||||||
|
* @param b the byte buffer to read in (must be at least 4 bytes long). |
||||||
|
* @return The value read. |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws EOFException if the file ends prematurely |
||||||
|
*/ |
||||||
|
private final int readLeInt(DataInput di, byte[] b) throws IOException { |
||||||
|
di.readFully(b, 0, 4); |
||||||
|
return ((b[0] & 0xff) | (b[1] & 0xff) << 8) |
||||||
|
| ((b[2] & 0xff) | (b[3] & 0xff) << 8) << 16; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Read an unsigned short in little endian byte order from the given |
||||||
|
* byte buffer at the given offset. |
||||||
|
* |
||||||
|
* @param b the byte array to read from. |
||||||
|
* @param off the offset to read from. |
||||||
|
* @return The value read. |
||||||
|
*/ |
||||||
|
private final int readLeShort(byte[] b, int off) { |
||||||
|
return (b[off] & 0xff) | (b[off + 1] & 0xff) << 8; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Read an int in little endian byte order from the given |
||||||
|
* byte buffer at the given offset. |
||||||
|
* |
||||||
|
* @param b the byte array to read from. |
||||||
|
* @param off the offset to read from. |
||||||
|
* @return The value read. |
||||||
|
*/ |
||||||
|
private final int readLeInt(byte[] b, int off) { |
||||||
|
return ((b[off] & 0xff) | (b[off + 1] & 0xff) << 8) |
||||||
|
| ((b[off + 2] & 0xff) | (b[off + 3] & 0xff) << 8) << 16; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
/** |
||||||
|
* Read the central directory of a zip file and fill the entries |
||||||
|
* array. This is called exactly once when first needed. It is called |
||||||
|
* while holding the lock on <code>raf</code>. |
||||||
|
* |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws ZipException if the central directory is malformed |
||||||
|
*/ |
||||||
|
private void readEntries() throws ZipException, IOException, ErrnoException { |
||||||
|
/* Search for the End Of Central Directory. When a zip comment is |
||||||
|
* present the directory may start earlier. |
||||||
|
* FIXME: This searches the whole file in a very slow manner if the |
||||||
|
* file isn't a zip file. |
||||||
|
*/ |
||||||
|
long pos = araf.length() - ENDHDR; |
||||||
|
byte[] ebs = new byte[CENHDR]; |
||||||
|
|
||||||
|
do { |
||||||
|
if (pos < 0) |
||||||
|
throw new ZipException |
||||||
|
("central directory not found, probably not a zip file: " + name); |
||||||
|
araf.seek(pos--); |
||||||
|
} |
||||||
|
while (readLeInt(araf, ebs) != ENDSIG); |
||||||
|
|
||||||
|
if (araf.skipBytes(ENDTOT - ENDNRD) != ENDTOT - ENDNRD) |
||||||
|
throw new EOFException(name); |
||||||
|
int count = readLeShort(araf, ebs); |
||||||
|
if (araf.skipBytes(ENDOFF - ENDSIZ) != ENDOFF - ENDSIZ) |
||||||
|
throw new EOFException(name); |
||||||
|
int centralOffset = readLeInt(araf, ebs); |
||||||
|
|
||||||
|
entries = new HashMap<>(count + count / 2); |
||||||
|
araf.seek(centralOffset); |
||||||
|
|
||||||
|
byte[] buffer = new byte[16]; |
||||||
|
for (int i = 0; i < count; i++) { |
||||||
|
araf.readFully(ebs); |
||||||
|
if (readLeInt(ebs, 0) != CENSIG) |
||||||
|
throw new ZipException("Wrong Central Directory signature: " + name); |
||||||
|
|
||||||
|
int method = readLeShort(ebs, CENHOW); |
||||||
|
int dostime = readLeInt(ebs, CENTIM); |
||||||
|
int crc = readLeInt(ebs, CENCRC); |
||||||
|
int csize = readLeInt(ebs, CENSIZ); |
||||||
|
int size = readLeInt(ebs, CENLEN); |
||||||
|
int nameLen = readLeShort(ebs, CENNAM); |
||||||
|
int extraLen = readLeShort(ebs, CENEXT); |
||||||
|
int commentLen = readLeShort(ebs, CENCOM); |
||||||
|
|
||||||
|
int offset = readLeInt(ebs, CENOFF); |
||||||
|
|
||||||
|
int needBuffer = Math.max(nameLen, commentLen); |
||||||
|
if (buffer.length < needBuffer) |
||||||
|
buffer = new byte[needBuffer]; |
||||||
|
|
||||||
|
araf.readFully(buffer, 0, nameLen); |
||||||
|
String name = new String(buffer, 0, 0, nameLen); |
||||||
|
|
||||||
|
ZipEntry entry = new ZipEntry(name); |
||||||
|
entry.setMethod(method); |
||||||
|
entry.setCrc(crc & 0xffffffffL); |
||||||
|
entry.setSize(size & 0xffffffffL); |
||||||
|
entry.setCompressedSize(csize & 0xffffffffL); |
||||||
|
entry.setDOSTime(dostime); |
||||||
|
if (extraLen > 0) { |
||||||
|
byte[] extra = new byte[extraLen]; |
||||||
|
araf.readFully(extra); |
||||||
|
entry.setExtra(extra); |
||||||
|
} |
||||||
|
if (commentLen > 0) { |
||||||
|
araf.readFully(buffer, 0, commentLen); |
||||||
|
entry.setComment(new String(buffer, 0, commentLen)); |
||||||
|
} |
||||||
|
entry.offset = offset; |
||||||
|
entries.put(name, entry); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Closes the ZipFile. This also closes all input streams given by |
||||||
|
* this class. After this is called, no further method should be |
||||||
|
* called. |
||||||
|
* |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
*/ |
||||||
|
@Override |
||||||
|
public void close() throws IOException { |
||||||
|
synchronized (araf) { |
||||||
|
closed = true; |
||||||
|
entries = null; |
||||||
|
araf.close(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Calls the <code>close()</code> method when this ZipFile has not yet |
||||||
|
* been explicitly closed. |
||||||
|
*/ |
||||||
|
protected void finalize() throws IOException { |
||||||
|
if (!closed && araf != null) close(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns an enumeration of all Zip entries in this Zip file. |
||||||
|
*/ |
||||||
|
public Enumeration<? extends ZipEntry> entries() { |
||||||
|
try { |
||||||
|
return new ZipEntryEnumeration(getEntries().values().iterator()); |
||||||
|
} catch (IOException ioe) { |
||||||
|
return null; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Checks that the ZipFile is still open and reads entries when necessary. |
||||||
|
* |
||||||
|
* @throws IllegalStateException when the ZipFile has already been closed. |
||||||
|
* @throws IOException, ErrnoException when the entries could not be read. |
||||||
|
*/ |
||||||
|
private HashMap<String, ZipEntry> getEntries() throws IOException { |
||||||
|
synchronized (araf) { |
||||||
|
if (closed) |
||||||
|
throw new IllegalStateException("ZipFile has closed: " + name); |
||||||
|
|
||||||
|
if (entries == null) { |
||||||
|
try { |
||||||
|
readEntries(); |
||||||
|
} catch (ErrnoException e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return entries; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Searches for a zip entry in this archive with the given name. |
||||||
|
* |
||||||
|
* @param name May contain directory components separated by |
||||||
|
* slashes ('/'). |
||||||
|
* @return the zip entry, or null if no entry with that name exists. |
||||||
|
*/ |
||||||
|
public ZipEntry getEntry(String name) { |
||||||
|
try { |
||||||
|
HashMap<String, ZipEntry> entries = getEntries(); |
||||||
|
ZipEntry entry = entries.get(name); |
||||||
|
return entry != null ? (ZipEntry) entry.clone() : null; |
||||||
|
} catch (IOException ioe) { |
||||||
|
return null; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
//access should be protected by synchronized(raf)
|
||||||
|
private final byte[] locBuf = new byte[LOCHDR]; |
||||||
|
|
||||||
|
/** |
||||||
|
* Checks, if the local header of the entry at index i matches the |
||||||
|
* central directory, and returns the offset to the data. |
||||||
|
* |
||||||
|
* @param entry to check. |
||||||
|
* @return the start offset of the (compressed) data. |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws ZipException if the local header doesn't match the |
||||||
|
* central directory header |
||||||
|
*/ |
||||||
|
private long checkLocalHeader(ZipEntry entry) throws IOException { |
||||||
|
synchronized (araf) { |
||||||
|
try { |
||||||
|
araf.seek(entry.offset); |
||||||
|
} catch (IOException e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
araf.readFully(locBuf); |
||||||
|
|
||||||
|
if (readLeInt(locBuf, 0) != LOCSIG) |
||||||
|
throw new ZipException("Wrong Local header signature: " + name); |
||||||
|
|
||||||
|
if (entry.getMethod() != readLeShort(locBuf, LOCHOW)) |
||||||
|
throw new ZipException("Compression method mismatch: " + name); |
||||||
|
|
||||||
|
if (entry.getName().length() != readLeShort(locBuf, LOCNAM)) |
||||||
|
throw new ZipException("file name length mismatch: " + name); |
||||||
|
|
||||||
|
int extraLen = entry.getName().length() + readLeShort(locBuf, LOCEXT); |
||||||
|
return entry.offset + LOCHDR + extraLen; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates an input stream reading the given zip entry as |
||||||
|
* uncompressed data. Normally zip entry should be an entry |
||||||
|
* returned by getEntry() or entries(). |
||||||
|
* |
||||||
|
* @param entry the entry to create an InputStream for. |
||||||
|
* @return the input stream. |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws ZipException if the Zip archive is malformed. |
||||||
|
*/ |
||||||
|
public InputStream getInputStream(ZipEntry entry) throws IOException { |
||||||
|
HashMap<String, ZipEntry> entries = getEntries(); |
||||||
|
String name = entry.getName(); |
||||||
|
ZipEntry zipEntry = entries.get(name); |
||||||
|
if (zipEntry == null) |
||||||
|
throw new NoSuchElementException(name); |
||||||
|
|
||||||
|
long start = checkLocalHeader(zipEntry); |
||||||
|
int method = zipEntry.getMethod(); |
||||||
|
InputStream is = new BufferedInputStream(new PartialInputStream |
||||||
|
(araf, start, zipEntry.getCompressedSize())); |
||||||
|
switch (method) { |
||||||
|
case ZipOutputStream.STORED: |
||||||
|
return is; |
||||||
|
case ZipOutputStream.DEFLATED: |
||||||
|
return new InflaterInputStream(is, new Inflater(true)); |
||||||
|
default: |
||||||
|
throw new ZipException("Unknown compression method " + method); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the (path) name of this zip file. |
||||||
|
*/ |
||||||
|
@NonNull |
||||||
|
public String getName() { |
||||||
|
return name; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns the number of entries in this zip file. |
||||||
|
*/ |
||||||
|
public int size() { |
||||||
|
try { |
||||||
|
return getEntries().size(); |
||||||
|
} catch (IOException ioe) { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private static class ZipEntryEnumeration implements Enumeration<ZipEntry> { |
||||||
|
private final Iterator<ZipEntry> elements; |
||||||
|
|
||||||
|
public ZipEntryEnumeration(Iterator<ZipEntry> elements) { |
||||||
|
this.elements = elements; |
||||||
|
} |
||||||
|
|
||||||
|
public boolean hasMoreElements() { |
||||||
|
return elements.hasNext(); |
||||||
|
} |
||||||
|
|
||||||
|
public ZipEntry nextElement() { |
||||||
|
/* We return a clone, just to be safe that the user doesn't |
||||||
|
* change the entry. |
||||||
|
*/ |
||||||
|
return (ZipEntry) elements.next().clone(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private static class PartialInputStream extends InputStream { |
||||||
|
private final /*RandomAccessFile*/ AndroidRandomReadableFile raf; |
||||||
|
long filepos, end; |
||||||
|
|
||||||
|
public PartialInputStream(AndroidRandomReadableFile raf, long start, long len) { |
||||||
|
this.raf = raf; |
||||||
|
filepos = start; |
||||||
|
end = start + len; |
||||||
|
} |
||||||
|
|
||||||
|
public int available() { |
||||||
|
long amount = end - filepos; |
||||||
|
if (amount > Integer.MAX_VALUE) |
||||||
|
return Integer.MAX_VALUE; |
||||||
|
return (int) amount; |
||||||
|
} |
||||||
|
|
||||||
|
public int read() throws IOException { |
||||||
|
if (filepos == end) |
||||||
|
return -1; |
||||||
|
synchronized (raf) { |
||||||
|
try { |
||||||
|
raf.seek(filepos++); |
||||||
|
} catch (IOException e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
return raf.read(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public int read(byte[] b, int off, int len) throws IOException { |
||||||
|
if (len > end - filepos) { |
||||||
|
len = (int) (end - filepos); |
||||||
|
if (len == 0) |
||||||
|
return -1; |
||||||
|
} |
||||||
|
synchronized (raf) { |
||||||
|
try { |
||||||
|
raf.seek(filepos); |
||||||
|
} catch (IOException e) { |
||||||
|
e.printStackTrace(); |
||||||
|
} |
||||||
|
int count = raf.read(b, off, len); |
||||||
|
if (count > 0) |
||||||
|
filepos += len; |
||||||
|
return count; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public long skip(long amount) { |
||||||
|
if (amount < 0) |
||||||
|
throw new IllegalArgumentException(); |
||||||
|
if (amount > end - filepos) |
||||||
|
amount = end - filepos; |
||||||
|
filepos += amount; |
||||||
|
return amount; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,344 @@ |
|||||||
|
/* me.ag2s.epublib.zip.ZipInputStream |
||||||
|
Copyright (C) 2001, 2002, 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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import java.io.EOFException; |
||||||
|
import java.io.IOException; |
||||||
|
import java.io.InputStream; |
||||||
|
|
||||||
|
/** |
||||||
|
* This is a FilterInputStream that reads the files in an zip archive |
||||||
|
* one after another. It has a special method to get the zip entry of |
||||||
|
* the next file. The zip entry contains information about the file name |
||||||
|
* size, compressed size, CRC, etc. |
||||||
|
* <p> |
||||||
|
* It includes support for STORED and DEFLATED entries. |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
*/ |
||||||
|
public class ZipInputStream extends InflaterInputStream implements ZipConstants { |
||||||
|
private CRC32 crc = new CRC32(); |
||||||
|
private ZipEntry entry = null; |
||||||
|
|
||||||
|
private int csize; |
||||||
|
private int size; |
||||||
|
private int method; |
||||||
|
private int flags; |
||||||
|
private int avail; |
||||||
|
private boolean entryAtEOF; |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a new Zip input stream, reading a zip archive. |
||||||
|
*/ |
||||||
|
public ZipInputStream(InputStream in) { |
||||||
|
super(in, new Inflater(true)); |
||||||
|
} |
||||||
|
|
||||||
|
private void fillBuf() throws IOException { |
||||||
|
avail = len = in.read(buf, 0, buf.length); |
||||||
|
} |
||||||
|
|
||||||
|
private int readBuf(byte[] out, int offset, int length) throws IOException { |
||||||
|
if (avail <= 0) { |
||||||
|
fillBuf(); |
||||||
|
if (avail <= 0) |
||||||
|
return -1; |
||||||
|
} |
||||||
|
if (length > avail) |
||||||
|
length = avail; |
||||||
|
System.arraycopy(buf, len - avail, out, offset, length); |
||||||
|
avail -= length; |
||||||
|
return length; |
||||||
|
} |
||||||
|
|
||||||
|
private void readFully(byte[] out) throws IOException { |
||||||
|
int off = 0; |
||||||
|
int len = out.length; |
||||||
|
while (len > 0) { |
||||||
|
int count = readBuf(out, off, len); |
||||||
|
if (count == -1) |
||||||
|
throw new EOFException(); |
||||||
|
off += count; |
||||||
|
len -= count; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private final int readLeByte() throws IOException { |
||||||
|
if (avail <= 0) { |
||||||
|
fillBuf(); |
||||||
|
if (avail <= 0) |
||||||
|
throw new ZipException("EOF in header"); |
||||||
|
} |
||||||
|
return buf[len - avail--] & 0xff; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Read an unsigned short in little endian byte order. |
||||||
|
*/ |
||||||
|
private final int readLeShort() throws IOException { |
||||||
|
return readLeByte() | (readLeByte() << 8); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Read an int in little endian byte order. |
||||||
|
*/ |
||||||
|
private final int readLeInt() throws IOException { |
||||||
|
return readLeShort() | (readLeShort() << 16); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Open the next entry from the zip archive, and return its description. |
||||||
|
* If the previous entry wasn't closed, this method will close it. |
||||||
|
*/ |
||||||
|
public ZipEntry getNextEntry() throws IOException { |
||||||
|
if (crc == null) |
||||||
|
throw new IOException("Stream closed."); |
||||||
|
if (entry != null) |
||||||
|
closeEntry(); |
||||||
|
|
||||||
|
int header = readLeInt(); |
||||||
|
if (header == CENSIG) { |
||||||
|
/* Central Header reached. */ |
||||||
|
close(); |
||||||
|
return null; |
||||||
|
} |
||||||
|
if (header != LOCSIG) |
||||||
|
throw new ZipException("Wrong Local header signature: " |
||||||
|
+ Integer.toHexString(header)); |
||||||
|
/* skip version */ |
||||||
|
readLeShort(); |
||||||
|
flags = readLeShort(); |
||||||
|
method = readLeShort(); |
||||||
|
int dostime = readLeInt(); |
||||||
|
int crc = readLeInt(); |
||||||
|
csize = readLeInt(); |
||||||
|
size = readLeInt(); |
||||||
|
int nameLen = readLeShort(); |
||||||
|
int extraLen = readLeShort(); |
||||||
|
|
||||||
|
if (method == ZipOutputStream.STORED && csize != size) |
||||||
|
throw new ZipException("Stored, but compressed != uncompressed"); |
||||||
|
|
||||||
|
|
||||||
|
byte[] buffer = new byte[nameLen]; |
||||||
|
readFully(buffer); |
||||||
|
String name = new String(buffer); |
||||||
|
|
||||||
|
entry = createZipEntry(name); |
||||||
|
entryAtEOF = false; |
||||||
|
entry.setMethod(method); |
||||||
|
if ((flags & 8) == 0) { |
||||||
|
entry.setCrc(crc & 0xffffffffL); |
||||||
|
entry.setSize(size & 0xffffffffL); |
||||||
|
entry.setCompressedSize(csize & 0xffffffffL); |
||||||
|
} |
||||||
|
entry.setDOSTime(dostime); |
||||||
|
if (extraLen > 0) { |
||||||
|
byte[] extra = new byte[extraLen]; |
||||||
|
readFully(extra); |
||||||
|
entry.setExtra(extra); |
||||||
|
} |
||||||
|
|
||||||
|
if (method == ZipOutputStream.DEFLATED && avail > 0) { |
||||||
|
System.arraycopy(buf, len - avail, buf, 0, avail); |
||||||
|
len = avail; |
||||||
|
avail = 0; |
||||||
|
inf.setInput(buf, 0, len); |
||||||
|
} |
||||||
|
return entry; |
||||||
|
} |
||||||
|
|
||||||
|
private void readDataDescr() throws IOException { |
||||||
|
if (readLeInt() != EXTSIG) |
||||||
|
throw new ZipException("Data descriptor signature not found"); |
||||||
|
entry.setCrc(readLeInt() & 0xffffffffL); |
||||||
|
csize = readLeInt(); |
||||||
|
size = readLeInt(); |
||||||
|
entry.setSize(size & 0xffffffffL); |
||||||
|
entry.setCompressedSize(csize & 0xffffffffL); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Closes the current zip entry and moves to the next one. |
||||||
|
*/ |
||||||
|
public void closeEntry() throws IOException { |
||||||
|
if (crc == null) |
||||||
|
throw new IOException("Stream closed."); |
||||||
|
if (entry == null) |
||||||
|
return; |
||||||
|
|
||||||
|
if (method == ZipOutputStream.DEFLATED) { |
||||||
|
if ((flags & 8) != 0) { |
||||||
|
/* We don't know how much we must skip, read until end. */ |
||||||
|
byte[] tmp = new byte[2048]; |
||||||
|
while (read(tmp) > 0) |
||||||
|
; |
||||||
|
/* read will close this entry */ |
||||||
|
return; |
||||||
|
} |
||||||
|
csize -= inf.getTotalIn(); |
||||||
|
avail = inf.getRemaining(); |
||||||
|
} |
||||||
|
|
||||||
|
if (avail > csize && csize >= 0) |
||||||
|
avail -= csize; |
||||||
|
else { |
||||||
|
csize -= avail; |
||||||
|
avail = 0; |
||||||
|
while (csize != 0) { |
||||||
|
long skipped = in.skip(csize & 0xffffffffL); |
||||||
|
if (skipped <= 0) |
||||||
|
throw new ZipException("zip archive ends early."); |
||||||
|
csize -= skipped; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
size = 0; |
||||||
|
crc.reset(); |
||||||
|
if (method == ZipOutputStream.DEFLATED) |
||||||
|
inf.reset(); |
||||||
|
entry = null; |
||||||
|
entryAtEOF = true; |
||||||
|
} |
||||||
|
|
||||||
|
public int available() throws IOException { |
||||||
|
return entryAtEOF ? 0 : 1; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Reads a byte from the current zip entry. |
||||||
|
* |
||||||
|
* @return the byte or -1 on EOF. |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws ZipException if the deflated stream is corrupted. |
||||||
|
*/ |
||||||
|
public int read() throws IOException { |
||||||
|
byte[] b = new byte[1]; |
||||||
|
if (read(b, 0, 1) <= 0) |
||||||
|
return -1; |
||||||
|
return b[0] & 0xff; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Reads a block of bytes from the current zip entry. |
||||||
|
* |
||||||
|
* @return the number of bytes read (may be smaller, even before |
||||||
|
* EOF), or -1 on EOF. |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
* @throws ZipException if the deflated stream is corrupted. |
||||||
|
*/ |
||||||
|
public int read(byte[] b, int off, int len) throws IOException { |
||||||
|
if (len == 0) |
||||||
|
return 0; |
||||||
|
if (crc == null) |
||||||
|
throw new IOException("Stream closed."); |
||||||
|
if (entry == null) |
||||||
|
return -1; |
||||||
|
boolean finished = false; |
||||||
|
switch (method) { |
||||||
|
case ZipOutputStream.DEFLATED: |
||||||
|
len = super.read(b, off, len); |
||||||
|
if (len < 0) { |
||||||
|
if (!inf.finished()) |
||||||
|
throw new ZipException("Inflater not finished!?"); |
||||||
|
avail = inf.getRemaining(); |
||||||
|
if ((flags & 8) != 0) |
||||||
|
readDataDescr(); |
||||||
|
|
||||||
|
if (inf.getTotalIn() != csize |
||||||
|
|| inf.getTotalOut() != size) |
||||||
|
throw new ZipException("size mismatch: " + csize + ";" + size + " <-> " + inf.getTotalIn() + ";" + inf.getTotalOut()); |
||||||
|
inf.reset(); |
||||||
|
finished = true; |
||||||
|
} |
||||||
|
break; |
||||||
|
|
||||||
|
case ZipOutputStream.STORED: |
||||||
|
|
||||||
|
if (len > csize && csize >= 0) |
||||||
|
len = csize; |
||||||
|
|
||||||
|
len = readBuf(b, off, len); |
||||||
|
if (len > 0) { |
||||||
|
csize -= len; |
||||||
|
size -= len; |
||||||
|
} |
||||||
|
|
||||||
|
if (csize == 0) |
||||||
|
finished = true; |
||||||
|
else if (len < 0) |
||||||
|
throw new ZipException("EOF in stored block"); |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
if (len > 0) |
||||||
|
crc.update(b, off, len); |
||||||
|
|
||||||
|
if (finished) { |
||||||
|
if ((crc.getValue() & 0xffffffffL) != entry.getCrc()) |
||||||
|
throw new ZipException("CRC mismatch"); |
||||||
|
crc.reset(); |
||||||
|
entry = null; |
||||||
|
entryAtEOF = true; |
||||||
|
} |
||||||
|
return len; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Closes the zip file. |
||||||
|
* |
||||||
|
* @throws IOException if a i/o error occured. |
||||||
|
*/ |
||||||
|
public void close() throws IOException { |
||||||
|
super.close(); |
||||||
|
crc = null; |
||||||
|
entry = null; |
||||||
|
entryAtEOF = true; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a new zip entry for the given name. This is equivalent |
||||||
|
* to new ZipEntry(name). |
||||||
|
* |
||||||
|
* @param name the name of the zip entry. |
||||||
|
*/ |
||||||
|
protected ZipEntry createZipEntry(String name) { |
||||||
|
return new ZipEntry(name); |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,383 @@ |
|||||||
|
/* me.ag2s.epublib.zip.ZipOutputStream |
||||||
|
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 me.ag2s.epublib.zip; |
||||||
|
|
||||||
|
import java.io.IOException; |
||||||
|
import java.io.OutputStream; |
||||||
|
import java.util.ArrayList; |
||||||
|
|
||||||
|
/** |
||||||
|
* This is a FilterOutputStream that writes the files into a zip |
||||||
|
* archive one after another. It has a special method to start a new |
||||||
|
* zip entry. The zip entries contains information about the file name |
||||||
|
* size, compressed size, CRC, etc. |
||||||
|
* <p> |
||||||
|
* It includes support for STORED and DEFLATED entries. |
||||||
|
* <p> |
||||||
|
* This class is not thread safe. |
||||||
|
* |
||||||
|
* @author Jochen Hoenicke |
||||||
|
*/ |
||||||
|
public class ZipOutputStream extends DeflaterOutputStream implements ZipConstants { |
||||||
|
private ArrayList<ZipEntry> entries = new ArrayList<>(); |
||||||
|
private final CRC32 crc = new CRC32(); |
||||||
|
private ZipEntry curEntry = null; |
||||||
|
|
||||||
|
private int curMethod; |
||||||
|
private int size; |
||||||
|
private int offset = 0; |
||||||
|
|
||||||
|
private byte[] zipComment = new byte[0]; |
||||||
|
private int defaultMethod = DEFLATED; |
||||||
|
|
||||||
|
/** |
||||||
|
* Our Zip version is hard coded to 1.0 resp. 2.0 |
||||||
|
*/ |
||||||
|
private final static int ZIP_STORED_VERSION = 10; |
||||||
|
private final static int ZIP_DEFLATED_VERSION = 20; |
||||||
|
|
||||||
|
/** |
||||||
|
* Compression method. This method doesn't compress at all. |
||||||
|
*/ |
||||||
|
public final static int STORED = 0; |
||||||
|
/** |
||||||
|
* Compression method. This method uses the Deflater. |
||||||
|
*/ |
||||||
|
public final static int DEFLATED = 8; |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a new Zip output stream, writing a zip archive. |
||||||
|
* |
||||||
|
* @param out the output stream to which the zip archive is written. |
||||||
|
*/ |
||||||
|
public ZipOutputStream(OutputStream out) { |
||||||
|
super(out, new Deflater(Deflater.DEFAULT_COMPRESSION, true)); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Set the zip file comment. |
||||||
|
* |
||||||
|
* @param comment the comment. |
||||||
|
* @throws IllegalArgumentException if encoding of comment is |
||||||
|
* longer than 0xffff bytes. |
||||||
|
*/ |
||||||
|
public void setComment(String comment) { |
||||||
|
byte[] commentBytes; |
||||||
|
commentBytes = comment.getBytes(); |
||||||
|
if (commentBytes.length > 0xffff) |
||||||
|
throw new IllegalArgumentException("Comment too long."); |
||||||
|
zipComment = commentBytes; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets default compression method. If the Zip entry specifies |
||||||
|
* another method its method takes precedence. |
||||||
|
* |
||||||
|
* @param method the method. |
||||||
|
* @throws IllegalArgumentException if method is not supported. |
||||||
|
* @see #STORED |
||||||
|
* @see #DEFLATED |
||||||
|
*/ |
||||||
|
public void setMethod(int method) { |
||||||
|
if (method != STORED && method != DEFLATED) |
||||||
|
throw new IllegalArgumentException("Method not supported."); |
||||||
|
defaultMethod = method; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Sets default compression level. The new level will be activated |
||||||
|
* immediately. |
||||||
|
* |
||||||
|
* @throws IllegalArgumentException if level is not supported. |
||||||
|
* @see Deflater |
||||||
|
*/ |
||||||
|
public void setLevel(int level) { |
||||||
|
def.setLevel(level); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Write an unsigned short in little endian byte order. |
||||||
|
*/ |
||||||
|
private final void writeLeShort(int value) throws IOException { |
||||||
|
out.write(value & 0xff); |
||||||
|
out.write((value >> 8) & 0xff); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Write an int in little endian byte order. |
||||||
|
*/ |
||||||
|
private final void writeLeInt(int value) throws IOException { |
||||||
|
writeLeShort(value); |
||||||
|
writeLeShort(value >> 16); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Starts a new Zip entry. It automatically closes the previous |
||||||
|
* entry if present. If the compression method is stored, the entry |
||||||
|
* must have a valid size and crc, otherwise all elements (except |
||||||
|
* name) are optional, but must be correct if present. If the time |
||||||
|
* is not set in the entry, the current time is used. |
||||||
|
* |
||||||
|
* @param entry the entry. |
||||||
|
* @throws IOException if an I/O error occured. |
||||||
|
* @throws ZipException if stream was finished. |
||||||
|
*/ |
||||||
|
public void putNextEntry(ZipEntry entry) throws IOException { |
||||||
|
if (entries == null) |
||||||
|
throw new ZipException("ZipOutputStream was finished"); |
||||||
|
|
||||||
|
int method = entry.getMethod(); |
||||||
|
int flags = 0; |
||||||
|
if (method == -1) |
||||||
|
method = defaultMethod; |
||||||
|
|
||||||
|
if (method == STORED) { |
||||||
|
if (entry.getCompressedSize() >= 0) { |
||||||
|
if (entry.getSize() < 0) |
||||||
|
entry.setSize(entry.getCompressedSize()); |
||||||
|
else if (entry.getSize() != entry.getCompressedSize()) |
||||||
|
throw new ZipException |
||||||
|
("Method STORED, but compressed size != size"); |
||||||
|
} else |
||||||
|
entry.setCompressedSize(entry.getSize()); |
||||||
|
|
||||||
|
if (entry.getSize() < 0) |
||||||
|
throw new ZipException("Method STORED, but size not set"); |
||||||
|
if (entry.getCrc() < 0) |
||||||
|
throw new ZipException("Method STORED, but crc not set"); |
||||||
|
} else if (method == DEFLATED) { |
||||||
|
if (entry.getCompressedSize() < 0 |
||||||
|
|| entry.getSize() < 0 || entry.getCrc() < 0) |
||||||
|
flags |= 8; |
||||||
|
} |
||||||
|
|
||||||
|
if (curEntry != null) |
||||||
|
closeEntry(); |
||||||
|
|
||||||
|
if (entry.getTime() < 0) |
||||||
|
entry.setTime(System.currentTimeMillis()); |
||||||
|
|
||||||
|
entry.flags = flags; |
||||||
|
entry.offset = offset; |
||||||
|
entry.setMethod(method); |
||||||
|
curMethod = method; |
||||||
|
/* Write the local file header */ |
||||||
|
writeLeInt(LOCSIG); |
||||||
|
writeLeShort(method == STORED |
||||||
|
? ZIP_STORED_VERSION : ZIP_DEFLATED_VERSION); |
||||||
|
writeLeShort(flags); |
||||||
|
writeLeShort(method); |
||||||
|
writeLeInt(entry.getDOSTime()); |
||||||
|
if ((flags & 8) == 0) { |
||||||
|
writeLeInt((int) entry.getCrc()); |
||||||
|
writeLeInt((int) entry.getCompressedSize()); |
||||||
|
writeLeInt((int) entry.getSize()); |
||||||
|
} else { |
||||||
|
writeLeInt(0); |
||||||
|
writeLeInt(0); |
||||||
|
writeLeInt(0); |
||||||
|
} |
||||||
|
byte[] name = entry.getName().getBytes(); |
||||||
|
if (name.length > 0xffff) |
||||||
|
throw new ZipException("Name too long."); |
||||||
|
byte[] extra = entry.getExtra(); |
||||||
|
if (extra == null) |
||||||
|
extra = new byte[0]; |
||||||
|
writeLeShort(name.length); |
||||||
|
writeLeShort(extra.length); |
||||||
|
out.write(name); |
||||||
|
out.write(extra); |
||||||
|
|
||||||
|
offset += LOCHDR + name.length + extra.length; |
||||||
|
|
||||||
|
/* Activate the entry. */ |
||||||
|
|
||||||
|
curEntry = entry; |
||||||
|
crc.reset(); |
||||||
|
if (method == DEFLATED) |
||||||
|
def.reset(); |
||||||
|
size = 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Closes the current entry. |
||||||
|
* |
||||||
|
* @throws IOException if an I/O error occured. |
||||||
|
* @throws ZipException if no entry is active. |
||||||
|
*/ |
||||||
|
public void closeEntry() throws IOException { |
||||||
|
if (curEntry == null) |
||||||
|
throw new ZipException("No open entry"); |
||||||
|
|
||||||
|
/* First finish the deflater, if appropriate */ |
||||||
|
if (curMethod == DEFLATED) |
||||||
|
super.finish(); |
||||||
|
|
||||||
|
int csize = curMethod == DEFLATED ? def.getTotalOut() : size; |
||||||
|
|
||||||
|
if (curEntry.getSize() < 0) |
||||||
|
curEntry.setSize(size); |
||||||
|
else if (curEntry.getSize() != size) |
||||||
|
throw new ZipException("size was " + size |
||||||
|
+ ", but I expected " + curEntry.getSize()); |
||||||
|
|
||||||
|
if (curEntry.getCompressedSize() < 0) |
||||||
|
curEntry.setCompressedSize(csize); |
||||||
|
else if (curEntry.getCompressedSize() != csize) |
||||||
|
throw new ZipException("compressed size was " + csize |
||||||
|
+ ", but I expected " + curEntry.getSize()); |
||||||
|
|
||||||
|
if (curEntry.getCrc() < 0) |
||||||
|
curEntry.setCrc(crc.getValue()); |
||||||
|
else if (curEntry.getCrc() != crc.getValue()) |
||||||
|
throw new ZipException("crc was " + Long.toHexString(crc.getValue()) |
||||||
|
+ ", but I expected " |
||||||
|
+ Long.toHexString(curEntry.getCrc())); |
||||||
|
|
||||||
|
offset += csize; |
||||||
|
|
||||||
|
/* Now write the data descriptor entry if needed. */ |
||||||
|
if (curMethod == DEFLATED && (curEntry.flags & 8) != 0) { |
||||||
|
writeLeInt(EXTSIG); |
||||||
|
writeLeInt((int) curEntry.getCrc()); |
||||||
|
writeLeInt((int) curEntry.getCompressedSize()); |
||||||
|
writeLeInt((int) curEntry.getSize()); |
||||||
|
offset += EXTHDR; |
||||||
|
} |
||||||
|
|
||||||
|
entries.add(curEntry); |
||||||
|
//entries.addElement(curEntry);
|
||||||
|
curEntry = null; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Writes the given buffer to the current entry. |
||||||
|
* |
||||||
|
* @throws IOException if an I/O error occured. |
||||||
|
* @throws ZipException if no entry is active. |
||||||
|
*/ |
||||||
|
public void write(byte[] b, int off, int len) throws IOException { |
||||||
|
if (curEntry == null) |
||||||
|
throw new ZipException("No open entry."); |
||||||
|
|
||||||
|
switch (curMethod) { |
||||||
|
case DEFLATED: |
||||||
|
super.write(b, off, len); |
||||||
|
break; |
||||||
|
|
||||||
|
case STORED: |
||||||
|
out.write(b, off, len); |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
crc.update(b, off, len); |
||||||
|
size += len; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Finishes the stream. This will write the central directory at the |
||||||
|
* end of the zip file and flush the stream. |
||||||
|
* |
||||||
|
* @throws IOException if an I/O error occured. |
||||||
|
*/ |
||||||
|
public void finish() throws IOException { |
||||||
|
if (entries == null) |
||||||
|
return; |
||||||
|
if (curEntry != null) |
||||||
|
closeEntry(); |
||||||
|
|
||||||
|
int numEntries = 0; |
||||||
|
int sizeEntries = 0; |
||||||
|
|
||||||
|
//Enumeration<ZipEntry> items = entries.elements();
|
||||||
|
//items.nextElement();
|
||||||
|
for (ZipEntry entry : entries) { |
||||||
|
int method = entry.getMethod(); |
||||||
|
writeLeInt(CENSIG); |
||||||
|
writeLeShort(method == STORED |
||||||
|
? ZIP_STORED_VERSION : ZIP_DEFLATED_VERSION); |
||||||
|
writeLeShort(method == STORED |
||||||
|
? ZIP_STORED_VERSION : ZIP_DEFLATED_VERSION); |
||||||
|
writeLeShort(entry.flags); |
||||||
|
writeLeShort(method); |
||||||
|
writeLeInt(entry.getDOSTime()); |
||||||
|
writeLeInt((int) entry.getCrc()); |
||||||
|
writeLeInt((int) entry.getCompressedSize()); |
||||||
|
writeLeInt((int) entry.getSize()); |
||||||
|
|
||||||
|
byte[] name = entry.getName().getBytes(); |
||||||
|
if (name.length > 0xffff) |
||||||
|
throw new ZipException("Name too long."); |
||||||
|
byte[] extra = entry.getExtra(); |
||||||
|
if (extra == null) |
||||||
|
extra = new byte[0]; |
||||||
|
String strComment = entry.getComment(); |
||||||
|
byte[] comment = strComment != null |
||||||
|
? strComment.getBytes() : new byte[0]; |
||||||
|
if (comment.length > 0xffff) |
||||||
|
throw new ZipException("Comment too long."); |
||||||
|
|
||||||
|
writeLeShort(name.length); |
||||||
|
writeLeShort(extra.length); |
||||||
|
writeLeShort(comment.length); |
||||||
|
writeLeShort(0); /* disk number */ |
||||||
|
writeLeShort(0); /* internal file attr */ |
||||||
|
writeLeInt(0); /* external file attr */ |
||||||
|
writeLeInt(entry.offset); |
||||||
|
|
||||||
|
out.write(name); |
||||||
|
out.write(extra); |
||||||
|
out.write(comment); |
||||||
|
numEntries++; |
||||||
|
sizeEntries += CENHDR + name.length + extra.length + comment.length; |
||||||
|
} |
||||||
|
|
||||||
|
writeLeInt(ENDSIG); |
||||||
|
writeLeShort(0); /* disk number */ |
||||||
|
writeLeShort(0); /* disk with start of central dir */ |
||||||
|
writeLeShort(numEntries); |
||||||
|
writeLeShort(numEntries); |
||||||
|
writeLeInt(sizeEntries); |
||||||
|
writeLeInt(offset); |
||||||
|
writeLeShort(zipComment.length); |
||||||
|
out.write(zipComment); |
||||||
|
out.flush(); |
||||||
|
entries = null; |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue