yetangitu/FBReaderJ
1
0
Fork 0
mirror of https://github.com/geometer/FBReaderJ.git synced 2025-10-04 18:29:23 +02:00
Code Issues Releases Wiki Activity

better zip processing

Browse source 
git-svn-id: https://only.mawhrin.net/repos/FBReaderJ/trunk@1311 6a642e6f-84f6-412e-ac94-c4a38d5a04b0
This commit is contained in:
Nikolay Pultsin 2010-04-30 04:26:10 +00:00
parent dabac4421a
commit 9ebd823406
13 changed files with 688 additions and 711 deletions
Download patch file Download diff file Expand all files Collapse all files

BIN
libs/armeabi/libDeflatingDecompressor.so
View file

Binary file not shown.

4
native/sources/DeflatingDecompressor/Android.mk
View file

@ -4,7 +4,7 @@ include $(CLEAR_VARS)
LOCAL_MODULE := DeflatingDecompressor
LOCAL_SRC_FILES := DeflatingDecompressor.cpp
#LOCAL_LDLIBS := -lz
LOCAL_ALLOW_UNDEFINED_SYMBOLS := true
LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -lz
LOCAL_ALLOW_UNDEFINED_SYMBOLS := false
include $(BUILD_SHARED_LIBRARY)

12
native/sources/DeflatingDecompressor/DeflatingDecompressor.cpp
View file

@ -39,9 +39,9 @@ void Java_org_amse_ys_zip_NativeDeflatingDecompressor_endInflating(JNIEnv *env,
}
}
// returns ((used inLength) << 16) + utLength
// returns (endFlag << 32) + ((used inLength) << 16) + outLength
extern "C"
jint Java_org_amse_ys_zip_NativeDeflatingDecompressor_inflate(JNIEnv *env, jobject thiz, jbyteArray in, jint inOffset, jint inLength, jbyteArray out) {
jlong Java_org_amse_ys_zip_NativeDeflatingDecompressor_inflate(JNIEnv *env, jobject thiz, jbyteArray in, jint inOffset, jint inLength, jbyteArray out) {
int i;
z_stream *stream = 0;
for (i = 0; i < SIZE; ++i) {
@ -64,8 +64,12 @@ jint Java_org_amse_ys_zip_NativeDeflatingDecompressor_inflate(JNIEnv *env, jobje
const int code = inflate(stream, Z_SYNC_FLUSH);
env->ReleaseByteArrayElements(in, inStart, 0);
env->ReleaseByteArrayElements(out, outStart, 0);
if ((code == Z_OK) || (code == Z_STREAM_END)) {
return ((inLength - stream->avail_in) << 16) + outLength - stream->avail_out;
if (code == Z_OK || code == Z_STREAM_END) {
jlong result = ((inLength - stream->avail_in) << 16) + outLength - stream->avail_out;
if (code == Z_STREAM_END) {
result |= ((jlong)1) << 32;
}
return result;
}
return 0;
}

136
src/org/amse/ys/zip/CircularBuffer.java
View file

@ -1,66 +1,70 @@
package org.amse.ys.zip;
import java.io.IOException;
final class CircularBuffer {
static final int DICTIONARY_LENGTH = (1 << 15);
private static final int DICTIONARY_MASK = DICTIONARY_LENGTH - 1;
private final byte[] myBuffer = new byte[DICTIONARY_LENGTH];
private int myBytesReady; // number of bytes can be read
private int myCurrentPosition; // the next byte to read is
// myDictionary[myCurrentPosition]
void reset() {
myBytesReady = 0;
myCurrentPosition = 0;
}
public int available() {
return myBytesReady;
}
public void read(byte[] buffer, int offset, int length) {
int from = myCurrentPosition;
if (from + length > DICTIONARY_LENGTH) {
final int firstPart = DICTIONARY_LENGTH - from;
final int secondPart = length - firstPart;
System.arraycopy(myBuffer, from, buffer, offset, firstPart);
System.arraycopy(myBuffer, 0, buffer, offset + firstPart, secondPart);
myCurrentPosition = secondPart;
} else {
System.arraycopy(myBuffer, from, buffer, offset, length);
myCurrentPosition = from + length;
}
myBytesReady -= length;
}
public byte read() throws IOException {
if (myBytesReady == 0) {
throw new ZipException("reading from empty buffer");
}
final byte result = myBuffer[myCurrentPosition++];
myCurrentPosition &= DICTIONARY_MASK;
myBytesReady--;
return result;
}
public void writeByte(byte toWrite) {
myBuffer[(myCurrentPosition + myBytesReady) & DICTIONARY_MASK] = toWrite;
myBytesReady++;
}
public void repeat(int length, int distance) throws IOException {
if (myBytesReady + length > DICTIONARY_LENGTH) {
throw new ZipException("circular buffer overflow");
}
int writePoint = (myCurrentPosition + myBytesReady) & DICTIONARY_MASK;
int readPoint = (writePoint - distance) & DICTIONARY_MASK;
for (int i = 0; i < length; i++) {
myBuffer[writePoint++] = myBuffer[readPoint++];
writePoint &= DICTIONARY_MASK;
readPoint &= DICTIONARY_MASK;
}
myBytesReady += length;
}
}
package org.amse.ys.zip;
import java.io.IOException;
final class CircularBuffer {
static final int DICTIONARY_LENGTH = (1 << 15);
private static final int DICTIONARY_MASK = DICTIONARY_LENGTH - 1;
private final byte[] myBuffer = new byte[DICTIONARY_LENGTH];
private int myBytesReady; // number of bytes can be read
private int myCurrentPosition; // the next byte to read is
// myDictionary[myCurrentPosition]
void reset() {
myBytesReady = 0;
myCurrentPosition = 0;
}
public int available() {
return myBytesReady;
}
public void read(byte[] buffer, int offset, int length) {
int from = myCurrentPosition;
if (from + length > DICTIONARY_LENGTH) {
final int firstPart = DICTIONARY_LENGTH - from;
final int secondPart = length - firstPart;
if (buffer != null) {
System.arraycopy(myBuffer, from, buffer, offset, firstPart);
System.arraycopy(myBuffer, 0, buffer, offset + firstPart, secondPart);
}
myCurrentPosition = secondPart;
} else {
if (buffer != null) {
System.arraycopy(myBuffer, from, buffer, offset, length);
}
myCurrentPosition = from + length;
}
myBytesReady -= length;
}
public byte read() throws IOException {
if (myBytesReady == 0) {
throw new ZipException("reading from empty buffer");
}
final byte result = myBuffer[myCurrentPosition++];
myCurrentPosition &= DICTIONARY_MASK;
myBytesReady--;
return result;
}
public void writeByte(byte toWrite) {
myBuffer[(myCurrentPosition + myBytesReady) & DICTIONARY_MASK] = toWrite;
myBytesReady++;
}
public void repeat(int length, int distance) throws IOException {
if (myBytesReady + length > DICTIONARY_LENGTH) {
throw new ZipException("circular buffer overflow");
}
int writePoint = (myCurrentPosition + myBytesReady) & DICTIONARY_MASK;
int readPoint = (writePoint - distance) & DICTIONARY_MASK;
for (int i = 0; i < length; i++) {
myBuffer[writePoint++] = myBuffer[readPoint++];
writePoint &= DICTIONARY_MASK;
readPoint &= DICTIONARY_MASK;
}
myBytesReady += length;
}
}

8
src/org/amse/ys/zip/Decompressor.java
View file

@ -7,6 +7,9 @@ public abstract class Decompressor {
public Decompressor(MyBufferedInputStream is, LocalFileHeader header) {
}
/**
* byte b[] -- target buffer for bytes; might be null
*/
public abstract int read(byte b[], int off, int len) throws IOException;
public abstract int read() throws IOException;
@ -35,10 +38,7 @@ public abstract class Decompressor {
return decompressor;
}
}
return
NativeDeflatingDecompressor.INITIALIZED
? new NativeDeflatingDecompressor(is, header)
: new DeflatingDecompressor(is, header);
return new NativeDeflatingDecompressor(is, header);
default:
throw new ZipException("Unsupported method of compression");
}

760
src/org/amse/ys/zip/DeflatingDecompressor.java
View file

@ -1,380 +1,380 @@
package org.amse.ys.zip;
import java.io.*;
public class DeflatingDecompressor extends AbstractDeflatingDecompressor {
private static final int ST_HEADER = 1;
private static final int ST_NO_COMPRESSION = 2;
private static final int ST_FIXED_CODES = 3;
private static final int ST_DYNAMIC_CODES = 4;
private static final int ST_END_OF_FILE = 5;
// common variables
private MyBufferedInputStream myStream;
private LocalFileHeader myHeader;
private int myState;
private int myTotalLength;
private int myBytesRead;
private int myCurrentPosition;
private boolean myTheBlockIsFinal;
// for bit reader
private int myBitsInBuffer;
private int myTempInt; // should contain 16 bit available for reading
// output buffer
private final CircularBuffer myOutputBuffer = new CircularBuffer();
// for no compression method
private int myCurrentBlockLength;
private int myReadInBlock;
// for Huffman codes
private final int[] myHuffmanCodes = new int[1 << 15];
private final int[] myDistanceCodes = new int[1 << 15];
private final int[] myAuxCodes = new int[1 << 15];
public DeflatingDecompressor(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
super();
reset(inputStream, header);
}
void reset(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
myStream = inputStream;
myHeader = header;
myTotalLength = header.getCompressedSize();
myBytesRead = 0;
myCurrentPosition = 0;
myTheBlockIsFinal = false;
myState = ST_HEADER;
myOutputBuffer.reset();
myBitsInBuffer = 0;
myTempInt = 0;
myCurrentBlockLength = 0;
myReadInBlock = 0;
}
@Override
public int available() throws IOException {
return myHeader.getUncompressedSize() - myCurrentPosition;
}
private void ensure16BitsInBuffer() throws IOException {
do {
int tmp = myStream.read();
if (tmp < 0) {
throw new ZipException("getBit: read after end of file");
}
myTempInt += tmp << myBitsInBuffer;
myBitsInBuffer += 8;
myBytesRead++;
} while (myBitsInBuffer <= 16);
}
/**
*
* This code is potentially dangerous, because can read 3 bytes after end of block
*
*/
private int getBit() throws IOException {
if (myBitsInBuffer < 16) {
ensure16BitsInBuffer();
}
myBitsInBuffer--;
int result = (myTempInt & 1);
myTempInt = (myTempInt >> 1);
return result;
}
private int readIntegerByBit(int length) throws IOException {
if (myBitsInBuffer < 16) {
ensure16BitsInBuffer();
}
final int result = myTempInt & ((1 << length) - 1);
myTempInt >>>= length;
myBitsInBuffer -= length;
return result;
}
private static final int MAX_LEN = CircularBuffer.DICTIONARY_LENGTH / 2;
@Override
public int read(byte b[], int off, int len) throws IOException {
int i = 0;
int available = myOutputBuffer.available();
while (i < len) {
int toRead = Math.min(MAX_LEN, len - i);
while (available < toRead) {
if (myState == ST_END_OF_FILE) {
break;
}
if (myState == ST_HEADER) {
readHeader();
}
available += pushNextSymbolToDictionary();
}
if (available == 0) {
break;
}
if (toRead > available) {
toRead = available;
}
myOutputBuffer.read(b, off + i, toRead);
i += toRead;
available -= toRead;
}
myCurrentPosition += i;
return (i > 0) ? i : -1;
}
@Override
public int read() throws IOException {
myCurrentPosition++;
while (myOutputBuffer.available() == 0) {
if (myState == ST_HEADER) {
readHeader();
}
pushNextSymbolToDictionary();
if (myState == ST_END_OF_FILE) {
return -1;
}
}
return myOutputBuffer.read() & 0xFF;
}
private int pushNextSymbolToDictionary() throws IOException {
if (myState == ST_NO_COMPRESSION) {
myOutputBuffer.writeByte((byte)readIntegerByBit(8));
myReadInBlock++;
if (myCurrentBlockLength == myReadInBlock) {
if (myTheBlockIsFinal) {
myState = ST_END_OF_FILE;
} else {
myState = ST_HEADER;
}
}
return 1;
} else {
int currentHuffmanCode = readHuffmanCode(myHuffmanCodes);
int length;
switch (currentHuffmanCode) {
default:
myOutputBuffer.writeByte((byte)currentHuffmanCode);
return 1;
case 256:
myState = myTheBlockIsFinal ? ST_END_OF_FILE : ST_HEADER;
return 0;
case 257:
case 258:
case 259:
case 260:
case 261:
case 262:
case 263:
case 264:
length = currentHuffmanCode + 3 - 257;
break;
case 265:
case 266:
case 267:
case 268:
length = ((currentHuffmanCode - 265) << 1) + 11 + getBit();
break;
case 269:
case 270:
case 271:
case 272:
length = ((currentHuffmanCode - 269) << 2) + 19 + readIntegerByBit(2);
break;
case 273:
case 274:
case 275:
case 276:
length = ((currentHuffmanCode - 273) << 3) + 35 + readIntegerByBit(3);
break;
case 277:
case 278:
case 279:
case 280:
length = ((currentHuffmanCode - 277) << 4) + 67 + readIntegerByBit(4);
break;
case 281:
case 282:
case 283:
case 284:
length = ((currentHuffmanCode - 281) << 5) + 131 + readIntegerByBit(5);
break;
case 285:
length = 258;
break;
}
// reading distanse
final int huffmanCode = readHuffmanCode(myDistanceCodes);
final int distance;
if (huffmanCode <= 3) {
distance = huffmanCode + 1;
} else if (huffmanCode <= 29) {
final int extraBits = (huffmanCode / 2) - 1;
int previousCode = (1 << (huffmanCode / 2));
if ((huffmanCode % 2) != 0) {
previousCode += (1 << extraBits);
}
distance = previousCode + 1 + readIntegerByBit(extraBits);
} else {
throw new ZipException("distance code > 29 found");
}
myOutputBuffer.repeat(length, distance);
return length;
}
}
private int readHuffmanCode(int[] table) throws IOException {
int bitsInBuffer = myBitsInBuffer;
int buffer = myTempInt;
while (bitsInBuffer <= 16) {
buffer += myStream.read() << bitsInBuffer;
bitsInBuffer += 8;
myBytesRead++;
}
final int tmp = table[buffer & 0x7FFF];
final int len = tmp >> 16;
myTempInt = buffer >>> len;
myBitsInBuffer = bitsInBuffer - len;
return tmp & 0x0FFFF;
}
private void readHeader() throws IOException {
if ((myState != ST_HEADER) || (myBytesRead >= myTotalLength)) {
throw new ZipException("unexpected case of readheader call");
}
myTheBlockIsFinal = (getBit() != 0);
switch (readIntegerByBit(2)) {
case 0:
myState = ST_NO_COMPRESSION;
readIntegerByBit(myBitsInBuffer % 8);
myCurrentBlockLength = readIntegerByBit(16);
readIntegerByBit(16);
myReadInBlock = 0;
break;
case 1:
myState = ST_FIXED_CODES;
CodeBuilder.buildFixedHuffmanCodes(myHuffmanCodes);
CodeBuilder.buildFixedDistanceCodes(myDistanceCodes);
break;
case 2:
myState = ST_DYNAMIC_CODES;
readCodes();
break;
case 3:
throw new ZipException(
"Code 11 found in header of delflated block. (means error according to specification)");
}
//myHuffmanCodes.print();
}
private void readCodes() throws IOException {
//int headersFound = 0;
final int[] codeLenSequence = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11,
4, 12, 3, 13, 2, 14, 1, 15 };
final int numberOfLiteralCodes = readIntegerByBit(5);
final int numberOfDistanceCodes = readIntegerByBit(5);
final int numberOfLengthCodes = readIntegerByBit(4);
// reading HCLEN codes
final CodeBuilder headerReadingCoder = new CodeBuilder(19);
for (int i = 0; i < (numberOfLengthCodes + 4); i++) {
headerReadingCoder.addCodeLength(codeLenSequence[i],
readIntegerByBit(3));
}
headerReadingCoder.buildTable(myAuxCodes);
CodeBuilder usualCodeBuilder = new CodeBuilder(288);
int previousNumber = 0;
for (int i = 0; i < (numberOfLiteralCodes + 257); i++) {
int currentHuffmanCode = readHuffmanCode(myAuxCodes);
//headersFound++;
if (currentHuffmanCode <= 15) {
usualCodeBuilder.addCodeLength(i, currentHuffmanCode);
previousNumber = currentHuffmanCode;
} else {
// repeating previous codes
boolean previous;
int repeatNumber = 0;
switch (currentHuffmanCode) {
case 16:
repeatNumber = 3 + readIntegerByBit(2);
previous = true;
break;
case 17:
repeatNumber = 3 + readIntegerByBit(3);
previous = false;
break;
case 18:
repeatNumber = 11 + readIntegerByBit(7);
previous = false;
break;
default:
throw new ZipException("error when reading dynamic Huffman codes");
}
previousNumber = previous ? previousNumber : 0;
for (int j = 0; j < repeatNumber; j++) {
usualCodeBuilder.addCodeLength(i + j, previousNumber);
}
i += repeatNumber - 1;
}
}
// we can build huffman codes for charset
usualCodeBuilder.buildTable(myHuffmanCodes);
// building distance codes
CodeBuilder distanceCodeBuilder = new CodeBuilder(32);
previousNumber = 0;
for (int i = 0; i < (numberOfDistanceCodes + 1); i++) {
int currentHuffmanCode = readHuffmanCode(myAuxCodes);
//headersFound++;
if (currentHuffmanCode <= 15) {
distanceCodeBuilder.addCodeLength(i, currentHuffmanCode);
previousNumber = currentHuffmanCode;
} else {
// repeating previous codes
boolean previous;
int repeatNumber = 0;
switch (currentHuffmanCode) {
case 16:
repeatNumber = 3 + readIntegerByBit(2);
previous = true;
break;
case 17:
repeatNumber = 3 + readIntegerByBit(3);
previous = false;
break;
case 18:
repeatNumber = 11 + readIntegerByBit(7);
previous = false;
break;
default:
throw new ZipException("error when reading dynamic Huffman codes");
}
previousNumber = (previous ? previousNumber : 0);
for (int j = 0; j < repeatNumber; j++) {
distanceCodeBuilder.addCodeLength(i + j, previousNumber);
}
i += (repeatNumber - 1);
}
}
distanceCodeBuilder.buildTable(myDistanceCodes);
}
}
package org.amse.ys.zip;
import java.io.*;
public class DeflatingDecompressor extends AbstractDeflatingDecompressor {
private static final int ST_HEADER = 1;
private static final int ST_NO_COMPRESSION = 2;
private static final int ST_FIXED_CODES = 3;
private static final int ST_DYNAMIC_CODES = 4;
private static final int ST_END_OF_FILE = 5;
// common variables
private MyBufferedInputStream myStream;
private LocalFileHeader myHeader;
private int myState;
private int myTotalLength;
private int myBytesRead;
private int myCurrentPosition;
private boolean myTheBlockIsFinal;
// for bit reader
private int myBitsInBuffer;
private int myTempInt; // should contain 16 bit available for reading
// output buffer
private final CircularBuffer myOutputBuffer = new CircularBuffer();
// for no compression method
private int myCurrentBlockLength;
private int myReadInBlock;
// for Huffman codes
private final int[] myHuffmanCodes = new int[1 << 15];
private final int[] myDistanceCodes = new int[1 << 15];
private final int[] myAuxCodes = new int[1 << 15];
public DeflatingDecompressor(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
super();
reset(inputStream, header);
}
void reset(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
myStream = inputStream;
myHeader = header;
myTotalLength = header.CompressedSize;
myBytesRead = 0;
myCurrentPosition = 0;
myTheBlockIsFinal = false;
myState = ST_HEADER;
myOutputBuffer.reset();
myBitsInBuffer = 0;
myTempInt = 0;
myCurrentBlockLength = 0;
myReadInBlock = 0;
}
@Override
public int available() throws IOException {
return myHeader.UncompressedSize - myCurrentPosition;
}
private void ensure16BitsInBuffer() throws IOException {
do {
int tmp = myStream.read();
if (tmp < 0) {
throw new ZipException("getBit: read after end of file");
}
myTempInt += tmp << myBitsInBuffer;
myBitsInBuffer += 8;
myBytesRead++;
} while (myBitsInBuffer <= 16);
}
/**
*
* This code is potentially dangerous, because can read 3 bytes after end of block
*
*/
private int getBit() throws IOException {
if (myBitsInBuffer < 16) {
ensure16BitsInBuffer();
}
myBitsInBuffer--;
int result = (myTempInt & 1);
myTempInt = (myTempInt >> 1);
return result;
}
private int readIntegerByBit(int length) throws IOException {
if (myBitsInBuffer < 16) {
ensure16BitsInBuffer();
}
final int result = myTempInt & ((1 << length) - 1);
myTempInt >>>= length;
myBitsInBuffer -= length;
return result;
}
private static final int MAX_LEN = CircularBuffer.DICTIONARY_LENGTH / 2;
@Override
public int read(byte b[], int off, int len) throws IOException {
int i = 0;
int available = myOutputBuffer.available();
while (i < len) {
int toRead = Math.min(MAX_LEN, len - i);
while (available < toRead) {
if (myState == ST_END_OF_FILE) {
break;
}
if (myState == ST_HEADER) {
readHeader();
}
available += pushNextSymbolToDictionary();
}
if (available == 0) {
break;
}
if (toRead > available) {
toRead = available;
}
myOutputBuffer.read(b, off + i, toRead);
i += toRead;
available -= toRead;
}
myCurrentPosition += i;
return (i > 0) ? i : -1;
}
@Override
public int read() throws IOException {
myCurrentPosition++;
while (myOutputBuffer.available() == 0) {
if (myState == ST_HEADER) {
readHeader();
}
pushNextSymbolToDictionary();
if (myState == ST_END_OF_FILE) {
return -1;
}
}
return myOutputBuffer.read() & 0xFF;
}
private int pushNextSymbolToDictionary() throws IOException {
if (myState == ST_NO_COMPRESSION) {
myOutputBuffer.writeByte((byte)readIntegerByBit(8));
myReadInBlock++;
if (myCurrentBlockLength == myReadInBlock) {
if (myTheBlockIsFinal) {
myState = ST_END_OF_FILE;
} else {
myState = ST_HEADER;
}
}
return 1;
} else {
int currentHuffmanCode = readHuffmanCode(myHuffmanCodes);
int length;
switch (currentHuffmanCode) {
default:
myOutputBuffer.writeByte((byte)currentHuffmanCode);
return 1;
case 256:
myState = myTheBlockIsFinal ? ST_END_OF_FILE : ST_HEADER;
return 0;
case 257:
case 258:
case 259:
case 260:
case 261:
case 262:
case 263:
case 264:
length = currentHuffmanCode + 3 - 257;
break;
case 265:
case 266:
case 267:
case 268:
length = ((currentHuffmanCode - 265) << 1) + 11 + getBit();
break;
case 269:
case 270:
case 271:
case 272:
length = ((currentHuffmanCode - 269) << 2) + 19 + readIntegerByBit(2);
break;
case 273:
case 274:
case 275:
case 276:
length = ((currentHuffmanCode - 273) << 3) + 35 + readIntegerByBit(3);
break;
case 277:
case 278:
case 279:
case 280:
length = ((currentHuffmanCode - 277) << 4) + 67 + readIntegerByBit(4);
break;
case 281:
case 282:
case 283:
case 284:
length = ((currentHuffmanCode - 281) << 5) + 131 + readIntegerByBit(5);
break;
case 285:
length = 258;
break;
}
// reading distanse
final int huffmanCode = readHuffmanCode(myDistanceCodes);
final int distance;
if (huffmanCode <= 3) {
distance = huffmanCode + 1;
} else if (huffmanCode <= 29) {
final int extraBits = (huffmanCode / 2) - 1;
int previousCode = (1 << (huffmanCode / 2));
if ((huffmanCode % 2) != 0) {
previousCode += (1 << extraBits);
}
distance = previousCode + 1 + readIntegerByBit(extraBits);
} else {
throw new ZipException("distance code > 29 found");
}
myOutputBuffer.repeat(length, distance);
return length;
}
}
private int readHuffmanCode(int[] table) throws IOException {
int bitsInBuffer = myBitsInBuffer;
int buffer = myTempInt;
while (bitsInBuffer <= 16) {
buffer += myStream.read() << bitsInBuffer;
bitsInBuffer += 8;
myBytesRead++;
}
final int tmp = table[buffer & 0x7FFF];
final int len = tmp >> 16;
myTempInt = buffer >>> len;
myBitsInBuffer = bitsInBuffer - len;
return tmp & 0x0FFFF;
}
private void readHeader() throws IOException {
if ((myState != ST_HEADER) || (myBytesRead >= myTotalLength)) {
throw new ZipException("unexpected case of readheader call");
}
myTheBlockIsFinal = (getBit() != 0);
switch (readIntegerByBit(2)) {
case 0:
myState = ST_NO_COMPRESSION;
readIntegerByBit(myBitsInBuffer % 8);
myCurrentBlockLength = readIntegerByBit(16);
readIntegerByBit(16);
myReadInBlock = 0;
break;
case 1:
myState = ST_FIXED_CODES;
CodeBuilder.buildFixedHuffmanCodes(myHuffmanCodes);
CodeBuilder.buildFixedDistanceCodes(myDistanceCodes);
break;
case 2:
myState = ST_DYNAMIC_CODES;
readCodes();
break;
case 3:
throw new ZipException(
"Code 11 found in header of delflated block. (means error according to specification)");
}
//myHuffmanCodes.print();
}
private void readCodes() throws IOException {
//int headersFound = 0;
final int[] codeLenSequence = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11,
4, 12, 3, 13, 2, 14, 1, 15 };
final int numberOfLiteralCodes = readIntegerByBit(5);
final int numberOfDistanceCodes = readIntegerByBit(5);
final int numberOfLengthCodes = readIntegerByBit(4);
// reading HCLEN codes
final CodeBuilder headerReadingCoder = new CodeBuilder(19);
for (int i = 0; i < (numberOfLengthCodes + 4); i++) {
headerReadingCoder.addCodeLength(codeLenSequence[i],
readIntegerByBit(3));
}
headerReadingCoder.buildTable(myAuxCodes);
CodeBuilder usualCodeBuilder = new CodeBuilder(288);
int previousNumber = 0;
for (int i = 0; i < (numberOfLiteralCodes + 257); i++) {
int currentHuffmanCode = readHuffmanCode(myAuxCodes);
//headersFound++;
if (currentHuffmanCode <= 15) {
usualCodeBuilder.addCodeLength(i, currentHuffmanCode);
previousNumber = currentHuffmanCode;
} else {
// repeating previous codes
boolean previous;
int repeatNumber = 0;
switch (currentHuffmanCode) {
case 16:
repeatNumber = 3 + readIntegerByBit(2);
previous = true;
break;
case 17:
repeatNumber = 3 + readIntegerByBit(3);
previous = false;
break;
case 18:
repeatNumber = 11 + readIntegerByBit(7);
previous = false;
break;
default:
throw new ZipException("error when reading dynamic Huffman codes");
}
previousNumber = previous ? previousNumber : 0;
for (int j = 0; j < repeatNumber; j++) {
usualCodeBuilder.addCodeLength(i + j, previousNumber);
}
i += repeatNumber - 1;
}
}
// we can build huffman codes for charset
usualCodeBuilder.buildTable(myHuffmanCodes);
// building distance codes
CodeBuilder distanceCodeBuilder = new CodeBuilder(32);
previousNumber = 0;
for (int i = 0; i < (numberOfDistanceCodes + 1); i++) {
int currentHuffmanCode = readHuffmanCode(myAuxCodes);
//headersFound++;
if (currentHuffmanCode <= 15) {
distanceCodeBuilder.addCodeLength(i, currentHuffmanCode);
previousNumber = currentHuffmanCode;
} else {
// repeating previous codes
boolean previous;
int repeatNumber = 0;
switch (currentHuffmanCode) {
case 16:
repeatNumber = 3 + readIntegerByBit(2);
previous = true;
break;
case 17:
repeatNumber = 3 + readIntegerByBit(3);
previous = false;
break;
case 18:
repeatNumber = 11 + readIntegerByBit(7);
previous = false;
break;
default:
throw new ZipException("error when reading dynamic Huffman codes");
}
previousNumber = (previous ? previousNumber : 0);
for (int j = 0; j < repeatNumber; j++) {
distanceCodeBuilder.addCodeLength(i + j, previousNumber);
}
i += (repeatNumber - 1);
}
}
distanceCodeBuilder.buildTable(myDistanceCodes);
}
}

95
src/org/amse/ys/zip/LocalFileHeader.java
View file

@ -8,62 +8,57 @@ package org.amse.ys.zip;
import java.io.IOException;
public class LocalFileHeader {
/**
* Initilization of constants. Implements: versions, ...
*/
static final int FILE_HEADER_SIGNATURE = 0x04034b50;
static final int FOLDER_HEADER_SIGNATURE = 0x02014b50;
static final int DATA_DESCRIPTOR_SIGNATURE = 0x07084b50;
final int VersionNeededToExtract;
final int GeneralPurposeFlag;
final int CompressionMethod;
private int myCompressedSize; // not final!
private int myUncompressedSize; // not final!
final int OffsetOfLocalData;
public final String FileName;
private boolean mySizeIsKnown;
int Signature;
LocalFileHeader(int versionNeededToExtract, int generalPurposeFlag,
int compressionMethod, int compressedSize, int uncompressedSize,
int offsetOfLocalData, String fileName) {
VersionNeededToExtract = versionNeededToExtract;
GeneralPurposeFlag = generalPurposeFlag;
CompressionMethod = compressionMethod;
myCompressedSize = compressedSize;
myUncompressedSize = uncompressedSize;
OffsetOfLocalData = offsetOfLocalData;
FileName = fileName;
mySizeIsKnown = ((GeneralPurposeFlag & 8) == 0);
int Version;
int Flags;
int CompressionMethod;
int ModificationTime;
int ModificationDate;
int CRC32;
int CompressedSize;
int UncompressedSize;
int NameLength;
int ExtraLength;
public String FileName;
int DataOffset;
LocalFileHeader() {
}
boolean sizeIsKnown() {
return mySizeIsKnown;
}
int getCompressedSize() throws IOException {
if (mySizeIsKnown) {
return myCompressedSize;
} else {
throw new ZipException(
"Error in getCompressedSize: file size is not known yet");
}
}
int getUncompressedSize() throws IOException {
if (mySizeIsKnown) {
return myUncompressedSize;
} else {
throw new ZipException(
"Error in getUncompressedSize: file size is not known yet");
}
}
void setSizes(int compressedSize, int uncompressedSize) {
if (!mySizeIsKnown) {
myCompressedSize = compressedSize;
myUncompressedSize = uncompressedSize;
mySizeIsKnown = true;
}
void readFrom(MyBufferedInputStream stream) throws IOException {
Signature = stream.read4Bytes();
switch (Signature) {
default:
break;
case FILE_HEADER_SIGNATURE:
Version = stream.read2Bytes();
Flags = stream.read2Bytes();
CompressionMethod = stream.read2Bytes();
ModificationTime = stream.read2Bytes();
ModificationDate = stream.read2Bytes();
CRC32 = stream.read4Bytes();
CompressedSize = stream.read4Bytes();
UncompressedSize = stream.read4Bytes();
if (CompressionMethod == 0 && CompressedSize != UncompressedSize) {
CompressedSize = UncompressedSize;
}
NameLength = stream.read2Bytes();
ExtraLength = stream.read2Bytes();
FileName = stream.readString(NameLength);
stream.skip(ExtraLength);
break;
case DATA_DESCRIPTOR_SIGNATURE:
CRC32 = stream.read4Bytes();
CompressedSize = stream.read4Bytes();
UncompressedSize = stream.read4Bytes();
break;
}
DataOffset = stream.offset();
}
}

28
src/org/amse/ys/zip/MyBufferedInputStream.java
View file

@ -114,9 +114,32 @@ final class MyBufferedInputStream extends InputStream {
}
public void backSkip(int n) throws IOException {
throw new IOException("Back skip is not implemented");
if (n > 0) {
if (myPositionInBuffer >= n) {
myPositionInBuffer -= n;
myBytesReady += n;
myCurrentPosition -= n;
} else {
myFileInputStream.close();
myFileInputStream = myStreamHolder.getInputStream();
myBytesReady = 0;
myPositionInBuffer = 0;
int position = myCurrentPosition - n;
myCurrentPosition = 0;
skip(position);
}
}
}
public void setPosition(int position) throws IOException {
if (myCurrentPosition < position) {
skip(position - myCurrentPosition);
} else {
backSkip(myCurrentPosition - position);
}
}
/*
public void setPosition(int position) throws IOException {
if (myCurrentPosition < position) {
skip(position - myCurrentPosition);
@ -125,9 +148,10 @@ final class MyBufferedInputStream extends InputStream {
myFileInputStream = myStreamHolder.getInputStream();
myBytesReady = 0;
skip(position);
myCurrentPosition = position;
}
myCurrentPosition = position;
}
*/
public void close() throws IOException {
myFileInputStream.close();

251
src/org/amse/ys/zip/NativeDeflatingDecompressor.java
View file

@ -1,125 +1,126 @@
package org.amse.ys.zip;
import java.io.*;
public class NativeDeflatingDecompressor extends AbstractDeflatingDecompressor {
public static final boolean INITIALIZED;
static {
boolean ini;
try {
System.loadLibrary("DeflatingDecompressor");
ini = true;
} catch (Throwable t) {
ini = false;
}
INITIALIZED = ini;
}
// common variables
private MyBufferedInputStream myStream;
private int myCompressedAvailable;
private int myAvailable;
private static final int IN_BUFFER_SIZE = 2048;
private static final int OUT_BUFFER_SIZE = 32768;
private final byte[] myInBuffer = new byte[IN_BUFFER_SIZE];
private int myInBufferOffset;
private int myInBufferLength;
private final byte[] myOutBuffer = new byte[OUT_BUFFER_SIZE];
private int myOutBufferOffset;
private int myOutBufferLength;
public NativeDeflatingDecompressor(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
super();
reset(inputStream, header);
}
void reset(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
endInflating();
myStream = inputStream;
myCompressedAvailable = header.getCompressedSize();
myAvailable = header.getUncompressedSize();
myInBufferOffset = IN_BUFFER_SIZE;
myInBufferLength = 0;
myOutBufferOffset = OUT_BUFFER_SIZE;
myOutBufferLength = 0;
startInflating();
}
@Override
public int available() {
return myAvailable;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
if (myAvailable <= 0) {
return -1;
}
if (len > myAvailable) {
len = myAvailable;
}
for (int toFill = len; toFill > 0; ) {
if (myOutBufferLength == 0) {
fillOutBuffer();
}
if (myOutBufferLength == 0) {
throw new IOException("cannot read from zip");
}
final int ready = (toFill < myOutBufferLength) ? toFill : myOutBufferLength;
System.arraycopy(myOutBuffer, myOutBufferOffset, b, off, ready);
off += ready;
myOutBufferOffset += ready;
toFill -= ready;
myOutBufferLength -= ready;
}
myAvailable -= len;
return len;
}
@Override
public int read() throws IOException {
if (myAvailable <= 0) {
return -1;
}
if (myOutBufferLength == 0) {
fillOutBuffer();
}
if (myOutBufferLength == 0) {
throw new IOException("cannot read from zip");
}
--myAvailable;
--myOutBufferLength;
return myOutBuffer[myOutBufferOffset++];
}
private void fillOutBuffer() throws IOException {
while (myOutBufferLength == 0) {
if (myInBufferLength == 0) {
myInBufferOffset = 0;
final int toRead = (myCompressedAvailable < IN_BUFFER_SIZE) ? myCompressedAvailable : IN_BUFFER_SIZE;
if (myStream.read(myInBuffer, 0, toRead) != toRead) {
throw new IOException("cannot read from base stream");
}
myInBufferLength = toRead;
myCompressedAvailable -= toRead;
}
final int code = inflate(myInBuffer, myInBufferOffset, myInBufferLength, myOutBuffer);
if (code == 0) {
throw new IOException("cannot read from base stream");
}
myInBufferOffset += code >> 16;
myInBufferLength -= code >> 16;
myOutBufferOffset = 0;
myOutBufferLength = code & 0x0FFFF;
}
}
private native boolean startInflating();
private native void endInflating();
private native int inflate(byte[] in, int inOffset, int inLength, byte[] out);
}
package org.amse.ys.zip;
import java.io.*;
public class NativeDeflatingDecompressor extends AbstractDeflatingDecompressor {
static {
System.loadLibrary("DeflatingDecompressor");
}
// common variables
private MyBufferedInputStream myStream;
private int myCompressedAvailable;
private int myAvailable;
private static final int IN_BUFFER_SIZE = 2048;
private static final int OUT_BUFFER_SIZE = 32768;
private final byte[] myInBuffer = new byte[IN_BUFFER_SIZE];
private int myInBufferOffset;
private int myInBufferLength;
private final byte[] myOutBuffer = new byte[OUT_BUFFER_SIZE];
private int myOutBufferOffset;
private int myOutBufferLength;
public NativeDeflatingDecompressor(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
super();
reset(inputStream, header);
}
void reset(MyBufferedInputStream inputStream, LocalFileHeader header) throws IOException {
endInflating();
myStream = inputStream;
myCompressedAvailable = header.CompressedSize;
myAvailable = header.UncompressedSize;
myInBufferOffset = IN_BUFFER_SIZE;
myInBufferLength = 0;
myOutBufferOffset = OUT_BUFFER_SIZE;
myOutBufferLength = 0;
startInflating();
}
@Override
public int available() {
return myAvailable;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
if (myAvailable <= 0) {
return -1;
}
if (len > myAvailable) {
len = myAvailable;
}
for (int toFill = len; toFill > 0; ) {
if (myOutBufferLength == 0) {
fillOutBuffer();
}
if (myOutBufferLength == 0) {
throw new IOException("cannot read from zip");
}
final int ready = (toFill < myOutBufferLength) ? toFill : myOutBufferLength;
if (b != null) {
System.arraycopy(myOutBuffer, myOutBufferOffset, b, off, ready);
}
off += ready;
myOutBufferOffset += ready;
toFill -= ready;
myOutBufferLength -= ready;
}
myAvailable -= len;
return len;
}
@Override
public int read() throws IOException {
if (myAvailable <= 0) {
return -1;
}
if (myOutBufferLength == 0) {
fillOutBuffer();
}
if (myOutBufferLength == 0) {
throw new IOException("cannot read from zip");
}
--myAvailable;
--myOutBufferLength;
return myOutBuffer[myOutBufferOffset++];
}
private void fillOutBuffer() throws IOException {
while (myOutBufferLength == 0) {
if (myInBufferLength == 0) {
myInBufferOffset = 0;
final int toRead = (myCompressedAvailable < IN_BUFFER_SIZE) ? myCompressedAvailable : IN_BUFFER_SIZE;
if (myStream.read(myInBuffer, 0, toRead) != toRead) {
throw new IOException("cannot read from base stream");
}
myInBufferLength = toRead;
myCompressedAvailable -= toRead;
}
final long result = inflate(myInBuffer, myInBufferOffset, myInBufferLength, myOutBuffer);
if (result == 0) {
throw new IOException("cannot read from base stream");
}
final int in = (int)(result >> 16) & 0xFFFF;
final int out = (int)result & 0xFFFF;
myInBufferOffset += in;
myInBufferLength -= in;
myOutBufferOffset = 0;
myOutBufferLength = out;
if ((result & (1L << 32)) != 0) {
endInflating();
myStream.backSkip(myInBufferLength - myInBufferOffset);
break;
}
}
}
private native boolean startInflating();
private native void endInflating();
private native long inflate(byte[] in, int inOffset, int inLength, byte[] out);
}

8
src/org/amse/ys/zip/NoCompressionDecompressor.java
View file

@ -20,13 +20,15 @@ public class NoCompressionDecompressor extends Decompressor {
if (value == -1) {
break;
}
b[off + i] = (byte)value;
if (b != null) {
b[off + i] = (byte)value;
}
}
return (i > 0) ? i : -1;
}
public int read() throws IOException {
if (myCurrentPosition < myHeader.getCompressedSize()) {
if (myCurrentPosition < myHeader.CompressedSize) {
myCurrentPosition++;
return myStream.read();
} else {
@ -35,6 +37,6 @@ public class NoCompressionDecompressor extends Decompressor {
}
public int available() throws IOException {
return (myHeader.getUncompressedSize() - myCurrentPosition);
return (myHeader.UncompressedSize - myCurrentPosition);
}
}

93
src/org/amse/ys/zip/ZipFile.java
View file

@ -42,28 +42,18 @@ public final class ZipFile {
}
private boolean readFileHeader(MyBufferedInputStream baseStream, String fileToFind) throws IOException {
int version2extract = baseStream.read2Bytes();
int generalFlag = baseStream.read2Bytes();
int compressionMethod = baseStream.read2Bytes();
baseStream.skip(8);
LocalFileHeader header = new LocalFileHeader();
header.readFrom(baseStream);
int compressedSize = baseStream.read4Bytes();
int uncompressedSize = baseStream.read4Bytes();
int fileNameSize = baseStream.read2Bytes();
int extraField = baseStream.read2Bytes();
final String fileName = baseStream.readString(fileNameSize);
baseStream.skip(extraField);
LocalFileHeader header = new LocalFileHeader(version2extract, generalFlag,
compressionMethod, compressedSize, uncompressedSize,
baseStream.offset(), fileName);
myFileHeaders.put(fileName, header);
if (header.sizeIsKnown()) {
baseStream.skip(compressedSize);
if (header.FileName != null) {
myFileHeaders.put(header.FileName, header);
}
if ((header.Flags & 0x08) == 0) {
baseStream.skip(header.CompressedSize);
} else {
findAndReadDescriptor(baseStream, header);
}
return fileName.equals(fileToFind);
return header.FileName != null && header.FileName.equals(fileToFind);
}
private void readAllHeaders() throws IOException {
@ -78,16 +68,6 @@ public final class ZipFile {
try {
while (true) {
int header = baseStream.read4Bytes();
if (header != LocalFileHeader.FILE_HEADER_SIGNATURE) {
if (header == LocalFileHeader.FOLDER_HEADER_SIGNATURE) {
break; // central directory, no more files
} else {
throw new ZipException(
"readHeaders. Wrong signature found = " + header
+ " at position " + baseStream.offset());
}
}
readFileHeader(baseStream, null);
}
} finally {
@ -99,39 +79,16 @@ public final class ZipFile {
* Finds descriptor of the last header and installs sizes of files
*/
private void findAndReadDescriptor(MyBufferedInputStream baseStream, LocalFileHeader header) throws IOException {
loop:
while (true) {
int signature = 0;
do {
int nextByte = baseStream.read();
if (nextByte < 0) {
throw new ZipException(
"readFileHeaders. Unexpected end of file when looking for DataDescriptor");
}
signature = ((signature >> 8) & 0x0FFFFFF) | (nextByte << 24);
} while (
signature != LocalFileHeader.FILE_HEADER_SIGNATURE &&
signature != LocalFileHeader.FOLDER_HEADER_SIGNATURE &&
signature != LocalFileHeader.DATA_DESCRIPTOR_SIGNATURE
);
switch (signature) {
case LocalFileHeader.FILE_HEADER_SIGNATURE:
break loop;
case LocalFileHeader.FOLDER_HEADER_SIGNATURE:
break loop;
case LocalFileHeader.DATA_DESCRIPTOR_SIGNATURE:
baseStream.skip(4);
int compressedSize = baseStream.read4Bytes();
int uncompressedSize = baseStream.read4Bytes();
if ((baseStream.offset() - header.OffsetOfLocalData - 16) == compressedSize) {
header.setSizes(compressedSize, uncompressedSize);
break loop;
} else {
baseStream.backSkip(12);
continue loop;
}
Decompressor decompressor = Decompressor.init(baseStream, header);
int uncompressedSize = 0;
while (true) {
int blockSize = decompressor.read(null, 0, 2048);
if (blockSize <= 0) {
break;
}
}
uncompressedSize += blockSize;
}
header.UncompressedSize = uncompressedSize;
}
private final Queue<MyBufferedInputStream> myStoredStreams = new LinkedList<MyBufferedInputStream>();
@ -150,7 +107,7 @@ loop:
}
public int getEntrySize(String entryName) throws IOException {
return getHeader(entryName).getUncompressedSize();
return getHeader(entryName).UncompressedSize;
}
public InputStream getInputStream(String entryName) throws IOException {
@ -171,18 +128,8 @@ loop:
MyBufferedInputStream baseStream = getBaseStream();
baseStream.setPosition(0);
try {
do {
int signature = baseStream.read4Bytes();
if (signature != LocalFileHeader.FILE_HEADER_SIGNATURE) {
if (signature == LocalFileHeader.FOLDER_HEADER_SIGNATURE) {
break; // central directory, no more files
} else {
throw new ZipException(
"Wrong signature " + signature
+ " found at position " + baseStream.offset());
}
}
} while (!readFileHeader(baseStream, entryName));
while (!readFileHeader(baseStream, entryName)) {
}
LocalFileHeader header = myFileHeaders.get(entryName);
if (header != null) {
return header;

2
src/org/amse/ys/zip/ZipInputStream.java
View file

@ -14,7 +14,7 @@ class ZipInputStream extends InputStream {
public ZipInputStream(ZipFile parent, LocalFileHeader header) throws IOException {
myParent = parent;
myBaseStream = parent.getBaseStream();
myBaseStream.setPosition(header.OffsetOfLocalData);
myBaseStream.setPosition(header.DataOffset);
myDecompressor = Decompressor.init(myBaseStream, header);
}

2
src/org/geometerplus/zlibrary/text/view/ZLTextView.java
View file

@ -832,7 +832,7 @@ public abstract class ZLTextView extends ZLTextViewBase {
}
public final synchronized void gotoPosition(int paragraphIndex, int wordIndex, int charIndex) {
if (myModel != null) {
if (myModel != null && myModel.getParagraphsNumber() > 0) {
myCurrentPage.moveStartCursor(paragraphIndex, wordIndex, charIndex);
myPreviousPage.reset();
myNextPage.reset();