From 124f869faae3a0f75a3825e6a8e195c17f3c626a Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Thu, 16 Oct 2014 23:34:20 +0400 Subject: initial for idea --- .../java/com/github/junrar/unpack/ComprDataIO.java | 362 +++++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 org.fox.ttcomics/src/main/java/com/github/junrar/unpack/ComprDataIO.java (limited to 'org.fox.ttcomics/src/main/java/com/github/junrar/unpack/ComprDataIO.java') diff --git a/org.fox.ttcomics/src/main/java/com/github/junrar/unpack/ComprDataIO.java b/org.fox.ttcomics/src/main/java/com/github/junrar/unpack/ComprDataIO.java new file mode 100644 index 0000000..8791b09 --- /dev/null +++ b/org.fox.ttcomics/src/main/java/com/github/junrar/unpack/ComprDataIO.java @@ -0,0 +1,362 @@ +/* + * Copyright (c) 2007 innoSysTec (R) GmbH, Germany. All rights reserved. + * Original author: Edmund Wagner + * Creation date: 31.05.2007 + * + * Source: $HeadURL$ + * Last changed: $LastChangedDate$ + * + * the unrar licence applies to all junrar source and binary distributions + * you are not allowed to use this source to re-create the RAR compression algorithm + * + * Here some html entities which can be used for escaping javadoc tags: + * "&": "&" or "&" + * "<": "<" or "<" + * ">": ">" or ">" + * "@": "@" + */ +package com.github.junrar.unpack; + +import java.io.EOFException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +import com.github.junrar.Archive; +import com.github.junrar.UnrarCallback; +import com.github.junrar.Volume; +import com.github.junrar.crc.RarCRC; +import com.github.junrar.exception.RarException; +import com.github.junrar.exception.RarException.RarExceptionType; +import com.github.junrar.io.ReadOnlyAccessInputStream; +import com.github.junrar.rarfile.FileHeader; + + +/** + * DOCUMENT ME + * + * @author $LastChangedBy$ + * @version $LastChangedRevision$ + */ +public class ComprDataIO { + + private final Archive archive; + + private long unpPackedSize; + + private boolean testMode; + + private boolean skipUnpCRC; + + private InputStream inputStream; + + private OutputStream outputStream; + + private FileHeader subHead; + + // cryptData Crypt; + // cryptData Decrypt; + private boolean packVolume; + + private boolean unpVolume; + + private boolean nextVolumeMissing; + + private long totalPackRead; + + private long unpArcSize; + + private long curPackRead, curPackWrite, curUnpRead, curUnpWrite; + + private long processedArcSize, totalArcSize; + + private long packFileCRC, unpFileCRC, packedCRC; + + private int encryption; + + private int decryption; + + private int lastPercent; + + private char currentCommand; + + public ComprDataIO(Archive arc) { + this.archive = arc; + } + + public void init(OutputStream outputStream) { + this.outputStream = outputStream; + unpPackedSize = 0; + testMode = false; + skipUnpCRC = false; + packVolume = false; + unpVolume = false; + nextVolumeMissing = false; + // command = null; + encryption = 0; + decryption = 0; + totalPackRead = 0; + curPackRead = curPackWrite = curUnpRead = curUnpWrite = 0; + packFileCRC = unpFileCRC = packedCRC = 0xffffffff; + lastPercent = -1; + subHead = null; + + currentCommand = 0; + processedArcSize = totalArcSize = 0; + } + + public void init(FileHeader hd) throws IOException { + long startPos = hd.getPositionInFile() + hd.getHeaderSize(); + unpPackedSize = hd.getFullPackSize(); + inputStream = new ReadOnlyAccessInputStream(archive.getRof(), startPos, + startPos + unpPackedSize); + subHead = hd; + curUnpRead = 0; + curPackWrite = 0; + packedCRC = 0xFFffFFff; + } + + public int unpRead(byte[] addr, int offset, int count) throws IOException, + RarException { + int retCode = 0, totalRead = 0; + while (count > 0) { + int readSize = (count > unpPackedSize) ? (int) unpPackedSize + : count; + retCode = inputStream.read(addr, offset, readSize); + if (retCode < 0) { + throw new EOFException(); + } + if (subHead.isSplitAfter()) { + packedCRC = RarCRC.checkCrc((int) packedCRC, addr, offset, + retCode); + } + + curUnpRead += retCode; + totalRead += retCode; + offset += retCode; + count -= retCode; + unpPackedSize -= retCode; + archive.bytesReadRead(retCode); + if (unpPackedSize == 0 && subHead.isSplitAfter()) { + Volume nextVolume = archive.getVolumeManager().nextArchive( + archive, archive.getVolume()); + if (nextVolume == null) { + nextVolumeMissing = true; + return -1; + } + + FileHeader hd = this.getSubHeader(); + if (hd.getUnpVersion() >= 20 && hd.getFileCRC() != 0xffffffff + && this.getPackedCRC() != ~hd.getFileCRC()) { + throw new RarException(RarExceptionType.crcError); + } + UnrarCallback callback = archive.getUnrarCallback(); + if ((callback != null) + && !callback.isNextVolumeReady(nextVolume)) { + return -1; + } + archive.setVolume(nextVolume); + hd = archive.nextFileHeader(); + if (hd == null) { + return -1; + } + this.init(hd); + } else { + break; + } + } + + if (retCode != -1) { + retCode = totalRead; + } + return retCode; + + } + + public void unpWrite(byte[] addr, int offset, int count) throws IOException { + if (!testMode) { + // DestFile->Write(Addr,Count); + outputStream.write(addr, offset, count); + } + + curUnpWrite += count; + + if (!skipUnpCRC) { + if (archive.isOldFormat()) { + unpFileCRC = RarCRC + .checkOldCrc((short) unpFileCRC, addr, count); + } else { + unpFileCRC = RarCRC.checkCrc((int) unpFileCRC, addr, offset, + count); + } + } + // if (!skipArcCRC) { + // archive.updateDataCRC(Addr, offset, ReadSize); + // } + } + + public void setPackedSizeToRead(long size) { + unpPackedSize = size; + } + + public void setTestMode(boolean mode) { + testMode = mode; + } + + public void setSkipUnpCRC(boolean skip) { + skipUnpCRC = skip; + } + + public void setSubHeader(FileHeader hd) { + subHead = hd; + + } + + public long getCurPackRead() { + return curPackRead; + } + + public void setCurPackRead(long curPackRead) { + this.curPackRead = curPackRead; + } + + public long getCurPackWrite() { + return curPackWrite; + } + + public void setCurPackWrite(long curPackWrite) { + this.curPackWrite = curPackWrite; + } + + public long getCurUnpRead() { + return curUnpRead; + } + + public void setCurUnpRead(long curUnpRead) { + this.curUnpRead = curUnpRead; + } + + public long getCurUnpWrite() { + return curUnpWrite; + } + + public void setCurUnpWrite(long curUnpWrite) { + this.curUnpWrite = curUnpWrite; + } + + public int getDecryption() { + return decryption; + } + + public void setDecryption(int decryption) { + this.decryption = decryption; + } + + public int getEncryption() { + return encryption; + } + + public void setEncryption(int encryption) { + this.encryption = encryption; + } + + public boolean isNextVolumeMissing() { + return nextVolumeMissing; + } + + public void setNextVolumeMissing(boolean nextVolumeMissing) { + this.nextVolumeMissing = nextVolumeMissing; + } + + public long getPackedCRC() { + return packedCRC; + } + + public void setPackedCRC(long packedCRC) { + this.packedCRC = packedCRC; + } + + public long getPackFileCRC() { + return packFileCRC; + } + + public void setPackFileCRC(long packFileCRC) { + this.packFileCRC = packFileCRC; + } + + public boolean isPackVolume() { + return packVolume; + } + + public void setPackVolume(boolean packVolume) { + this.packVolume = packVolume; + } + + public long getProcessedArcSize() { + return processedArcSize; + } + + public void setProcessedArcSize(long processedArcSize) { + this.processedArcSize = processedArcSize; + } + + public long getTotalArcSize() { + return totalArcSize; + } + + public void setTotalArcSize(long totalArcSize) { + this.totalArcSize = totalArcSize; + } + + public long getTotalPackRead() { + return totalPackRead; + } + + public void setTotalPackRead(long totalPackRead) { + this.totalPackRead = totalPackRead; + } + + public long getUnpArcSize() { + return unpArcSize; + } + + public void setUnpArcSize(long unpArcSize) { + this.unpArcSize = unpArcSize; + } + + public long getUnpFileCRC() { + return unpFileCRC; + } + + public void setUnpFileCRC(long unpFileCRC) { + this.unpFileCRC = unpFileCRC; + } + + public boolean isUnpVolume() { + return unpVolume; + } + + public void setUnpVolume(boolean unpVolume) { + this.unpVolume = unpVolume; + } + + public FileHeader getSubHeader() { + return subHead; + } + + // public void setEncryption(int method, char[] Password, byte[] Salt, + // boolean encrypt, boolean handsOffHash) + // { + // + // } + // + // public void setAV15Encryption() + // { + // + // } + // + // public void setCmt13Encryption() + // { + // + // } +} -- cgit v1.2.3