599 lines
21 KiB
C#
599 lines
21 KiB
C#
// LzwInputStream.cs
|
||
//
|
||
// Copyright (C) 2009 Gabriel Burca
|
||
//
|
||
// This program 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
|
||
// of the License, or (at your option) any later version.
|
||
//
|
||
// This program 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 this program; 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.
|
||
|
||
using System;
|
||
using System.IO;
|
||
|
||
namespace ICSharpCode.SharpZipLib.LZW
|
||
{
|
||
|
||
/// <summary>
|
||
/// This filter stream is used to decompress a LZW format stream.
|
||
/// Specifically, a stream that uses the LZC compression method.
|
||
/// This file format is usually associated with the .Z file extension.
|
||
///
|
||
/// See http://en.wikipedia.org/wiki/Compress
|
||
/// See http://wiki.wxwidgets.org/Development:_Z_File_Format
|
||
///
|
||
/// The file header consists of 3 (or optionally 4) bytes. The first two bytes
|
||
/// contain the magic marker "0x1f 0x9d", followed by a byte of flags.
|
||
///
|
||
/// Based on Java code by Ronald Tschalar, which in turn was based on the unlzw.c
|
||
/// code in the gzip package.
|
||
/// </summary>
|
||
/// <example> This sample shows how to unzip a compressed file
|
||
/// <code>
|
||
/// using System;
|
||
/// using System.IO;
|
||
///
|
||
/// using ICSharpCode.SharpZipLib.Core;
|
||
/// using ICSharpCode.SharpZipLib.LZW;
|
||
///
|
||
/// class MainClass
|
||
/// {
|
||
/// public static void Main(string[] args)
|
||
/// {
|
||
/// using (Stream inStream = new LzwInputStream(File.OpenRead(args[0])))
|
||
/// using (FileStream outStream = File.Create(Path.GetFileNameWithoutExtension(args[0]))) {
|
||
/// byte[] buffer = new byte[4096];
|
||
/// StreamUtils.Copy(inStream, outStream, buffer);
|
||
/// // OR
|
||
/// inStream.Read(buffer, 0, buffer.Length);
|
||
/// // now do something with the buffer
|
||
/// }
|
||
/// }
|
||
/// }
|
||
/// </code>
|
||
/// </example>
|
||
public class LzwInputStream : Stream
|
||
{
|
||
/// <summary>
|
||
/// Get/set flag indicating ownership of underlying stream.
|
||
/// When the flag is true <see cref="Close"/> will close the underlying stream also.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// The default value is true.
|
||
/// </remarks>
|
||
public bool IsStreamOwner
|
||
{
|
||
get { return isStreamOwner; }
|
||
set { isStreamOwner = value; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Creates a LzwInputStream
|
||
/// </summary>
|
||
/// <param name="baseInputStream">
|
||
/// The stream to read compressed data from (baseInputStream LZW format)
|
||
/// </param>
|
||
public LzwInputStream(Stream baseInputStream) {
|
||
this.baseInputStream = baseInputStream;
|
||
}
|
||
|
||
/// <summary>
|
||
/// See <see cref="System.IO.Stream.ReadByte"/>
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public override int ReadByte() {
|
||
int b = Read(one, 0, 1);
|
||
if (b == 1)
|
||
return (one[0] & 0xff);
|
||
return -1;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Reads decompressed data into the provided buffer byte array
|
||
/// </summary>
|
||
/// <param name ="buffer">
|
||
/// The array to read and decompress data into
|
||
/// </param>
|
||
/// <param name ="offset">
|
||
/// The offset indicating where the data should be placed
|
||
/// </param>
|
||
/// <param name ="count">
|
||
/// The number of bytes to decompress
|
||
/// </param>
|
||
/// <returns>The number of bytes read. Zero signals the end of stream</returns>
|
||
public override int Read(byte[] buffer, int offset, int count) {
|
||
if (!headerParsed) ParseHeader();
|
||
|
||
if (eof) return -1;
|
||
int start = offset;
|
||
|
||
/* Using local copies of various variables speeds things up by as
|
||
* much as 30% in Java! Performance not tested in C#.
|
||
*/
|
||
int[] lTabPrefix = tabPrefix;
|
||
byte[] lTabSuffix = tabSuffix;
|
||
byte[] lStack = stack;
|
||
int lNBits = nBits;
|
||
int lMaxCode = maxCode;
|
||
int lMaxMaxCode = maxMaxCode;
|
||
int lBitMask = bitMask;
|
||
int lOldCode = oldCode;
|
||
byte lFinChar = finChar;
|
||
int lStackP = stackP;
|
||
int lFreeEnt = freeEnt;
|
||
byte[] lData = data;
|
||
int lBitPos = bitPos;
|
||
|
||
|
||
// empty stack if stuff still left
|
||
int sSize = lStack.Length - lStackP;
|
||
if (sSize > 0) {
|
||
int num = (sSize >= count) ? count : sSize;
|
||
Array.Copy(lStack, lStackP, buffer, offset, num);
|
||
offset += num;
|
||
count -= num;
|
||
lStackP += num;
|
||
}
|
||
|
||
if (count == 0) {
|
||
stackP = lStackP;
|
||
return offset - start;
|
||
}
|
||
|
||
|
||
// loop, filling local buffer until enough data has been decompressed
|
||
MainLoop: do {
|
||
if (end < EXTRA) {
|
||
Fill();
|
||
}
|
||
|
||
int bitIn = (got > 0) ? (end - end % lNBits) << 3 :
|
||
(end << 3) - (lNBits - 1);
|
||
|
||
while (lBitPos < bitIn) {
|
||
#region A
|
||
// handle 1-byte reads correctly
|
||
if (count == 0) {
|
||
nBits = lNBits;
|
||
maxCode = lMaxCode;
|
||
maxMaxCode = lMaxMaxCode;
|
||
bitMask = lBitMask;
|
||
oldCode = lOldCode;
|
||
finChar = lFinChar;
|
||
stackP = lStackP;
|
||
freeEnt = lFreeEnt;
|
||
bitPos = lBitPos;
|
||
|
||
return offset - start;
|
||
}
|
||
|
||
// check for code-width expansion
|
||
if (lFreeEnt > lMaxCode) {
|
||
int nBytes = lNBits << 3;
|
||
lBitPos = (lBitPos - 1) +
|
||
nBytes - (lBitPos - 1 + nBytes) % nBytes;
|
||
|
||
lNBits++;
|
||
lMaxCode = (lNBits == maxBits) ? lMaxMaxCode :
|
||
(1 << lNBits) - 1;
|
||
|
||
lBitMask = (1 << lNBits) - 1;
|
||
lBitPos = ResetBuf(lBitPos);
|
||
goto MainLoop;
|
||
}
|
||
#endregion
|
||
|
||
#region B
|
||
// read next code
|
||
int pos = lBitPos >> 3;
|
||
int code = (((lData[pos] & 0xFF) |
|
||
((lData[pos + 1] & 0xFF) << 8) |
|
||
((lData[pos + 2] & 0xFF) << 16)) >>
|
||
(lBitPos & 0x7)) & lBitMask;
|
||
|
||
lBitPos += lNBits;
|
||
|
||
// handle first iteration
|
||
if (lOldCode == -1) {
|
||
if (code >= 256) throw new LzwException("corrupt input: " + code + " > 255");
|
||
|
||
lFinChar = (byte) (lOldCode = code);
|
||
buffer[offset++] = lFinChar;
|
||
count--;
|
||
continue;
|
||
}
|
||
|
||
// handle CLEAR code
|
||
if (code == TBL_CLEAR && blockMode) {
|
||
Array.Copy(zeros, 0, lTabPrefix, 0, zeros.Length);
|
||
lFreeEnt = TBL_FIRST - 1;
|
||
|
||
int nBytes = lNBits << 3;
|
||
lBitPos = (lBitPos - 1) + nBytes - (lBitPos - 1 + nBytes) % nBytes;
|
||
lNBits = LzwConstants.INIT_BITS;
|
||
lMaxCode = (1 << lNBits) - 1;
|
||
lBitMask = lMaxCode;
|
||
|
||
// Code tables reset
|
||
|
||
lBitPos = ResetBuf(lBitPos);
|
||
goto MainLoop;
|
||
}
|
||
#endregion
|
||
|
||
#region C
|
||
// setup
|
||
int inCode = code;
|
||
lStackP = lStack.Length;
|
||
|
||
// Handle KwK case
|
||
if (code >= lFreeEnt) {
|
||
if (code > lFreeEnt) {
|
||
throw new LzwException("corrupt input: code=" + code +
|
||
", freeEnt=" + lFreeEnt);
|
||
}
|
||
|
||
lStack[--lStackP] = lFinChar;
|
||
code = lOldCode;
|
||
}
|
||
|
||
// Generate output characters in reverse order
|
||
while (code >= 256) {
|
||
lStack[--lStackP] = lTabSuffix[code];
|
||
code = lTabPrefix[code];
|
||
}
|
||
|
||
lFinChar = lTabSuffix[code];
|
||
buffer[offset++] = lFinChar;
|
||
count--;
|
||
|
||
// And put them out in forward order
|
||
sSize = lStack.Length - lStackP;
|
||
int num = (sSize >= count) ? count : sSize;
|
||
Array.Copy(lStack, lStackP, buffer, offset, num);
|
||
offset += num;
|
||
count -= num;
|
||
lStackP += num;
|
||
#endregion
|
||
|
||
#region D
|
||
// generate new entry in table
|
||
if (lFreeEnt < lMaxMaxCode) {
|
||
lTabPrefix[lFreeEnt] = lOldCode;
|
||
lTabSuffix[lFreeEnt] = lFinChar;
|
||
lFreeEnt++;
|
||
}
|
||
|
||
// Remember previous code
|
||
lOldCode = inCode;
|
||
|
||
// if output buffer full, then return
|
||
if (count == 0) {
|
||
nBits = lNBits;
|
||
maxCode = lMaxCode;
|
||
bitMask = lBitMask;
|
||
oldCode = lOldCode;
|
||
finChar = lFinChar;
|
||
stackP = lStackP;
|
||
freeEnt = lFreeEnt;
|
||
bitPos = lBitPos;
|
||
|
||
return offset - start;
|
||
}
|
||
#endregion
|
||
} // while
|
||
|
||
lBitPos = ResetBuf(lBitPos);
|
||
|
||
} while (got > 0); // do..while
|
||
|
||
nBits = lNBits;
|
||
maxCode = lMaxCode;
|
||
bitMask = lBitMask;
|
||
oldCode = lOldCode;
|
||
finChar = lFinChar;
|
||
stackP = lStackP;
|
||
freeEnt = lFreeEnt;
|
||
bitPos = lBitPos;
|
||
|
||
eof = true;
|
||
return offset - start;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Moves the unread data in the buffer to the beginning and resets
|
||
/// the pointers.
|
||
/// </summary>
|
||
/// <param name="bitPosition"></param>
|
||
/// <returns></returns>
|
||
private int ResetBuf(int bitPosition) {
|
||
int pos = bitPosition >> 3;
|
||
Array.Copy(data, pos, data, 0, end - pos);
|
||
end -= pos;
|
||
return 0;
|
||
}
|
||
|
||
|
||
private void Fill() {
|
||
got = baseInputStream.Read(data, end, data.Length - 1 - end);
|
||
if (got > 0) {
|
||
end += got;
|
||
}
|
||
}
|
||
|
||
|
||
private void ParseHeader() {
|
||
headerParsed = true;
|
||
|
||
byte[] hdr = new byte[LzwConstants.HDR_SIZE];
|
||
|
||
int result = baseInputStream.Read(hdr, 0, hdr.Length);
|
||
|
||
// Check the magic marker
|
||
if (result < 0)
|
||
throw new LzwException("Failed to read LZW header");
|
||
|
||
if (hdr[0] != (LzwConstants.MAGIC >> 8) || hdr[1] != (LzwConstants.MAGIC & 0xff)) {
|
||
throw new LzwException(String.Format(
|
||
"Wrong LZW header. Magic bytes don't match. 0x{0:x2} 0x{1:x2}",
|
||
hdr[0], hdr[1]));
|
||
}
|
||
|
||
// Check the 3rd header byte
|
||
blockMode = (hdr[2] & LzwConstants.BLOCK_MODE_MASK) > 0;
|
||
maxBits = hdr[2] & LzwConstants.BIT_MASK;
|
||
|
||
if (maxBits > LzwConstants.MAX_BITS) {
|
||
throw new LzwException("Stream compressed with " + maxBits +
|
||
" bits, but decompression can only handle " +
|
||
LzwConstants.MAX_BITS + " bits.");
|
||
}
|
||
|
||
if ((hdr[2] & LzwConstants.RESERVED_MASK) > 0) {
|
||
throw new LzwException("Unsupported bits set in the header.");
|
||
}
|
||
|
||
// Initialize variables
|
||
maxMaxCode = 1 << maxBits;
|
||
nBits = LzwConstants.INIT_BITS;
|
||
maxCode = (1 << nBits) - 1;
|
||
bitMask = maxCode;
|
||
oldCode = -1;
|
||
finChar = 0;
|
||
freeEnt = blockMode ? TBL_FIRST : 256;
|
||
|
||
tabPrefix = new int[1 << maxBits];
|
||
tabSuffix = new byte[1 << maxBits];
|
||
stack = new byte[1 << maxBits];
|
||
stackP = stack.Length;
|
||
|
||
for (int idx = 255; idx >= 0; idx--)
|
||
tabSuffix[idx] = (byte)idx;
|
||
}
|
||
|
||
#region Stream Overrides
|
||
/// <summary>
|
||
/// Gets a value indicating whether the current stream supports reading
|
||
/// </summary>
|
||
public override bool CanRead
|
||
{
|
||
get
|
||
{
|
||
return baseInputStream.CanRead;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets a value of false indicating seeking is not supported for this stream.
|
||
/// </summary>
|
||
public override bool CanSeek
|
||
{
|
||
get
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets a value of false indicating that this stream is not writeable.
|
||
/// </summary>
|
||
public override bool CanWrite
|
||
{
|
||
get
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// A value representing the length of the stream in bytes.
|
||
/// </summary>
|
||
public override long Length
|
||
{
|
||
get
|
||
{
|
||
return got;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// The current position within the stream.
|
||
/// Throws a NotSupportedException when attempting to set the position
|
||
/// </summary>
|
||
/// <exception cref="NotSupportedException">Attempting to set the position</exception>
|
||
public override long Position
|
||
{
|
||
get
|
||
{
|
||
return baseInputStream.Position;
|
||
}
|
||
set
|
||
{
|
||
throw new NotSupportedException("InflaterInputStream Position not supported");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Flushes the baseInputStream
|
||
/// </summary>
|
||
public override void Flush()
|
||
{
|
||
baseInputStream.Flush();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sets the position within the current stream
|
||
/// Always throws a NotSupportedException
|
||
/// </summary>
|
||
/// <param name="offset">The relative offset to seek to.</param>
|
||
/// <param name="origin">The <see cref="SeekOrigin"/> defining where to seek from.</param>
|
||
/// <returns>The new position in the stream.</returns>
|
||
/// <exception cref="NotSupportedException">Any access</exception>
|
||
public override long Seek(long offset, SeekOrigin origin)
|
||
{
|
||
throw new NotSupportedException("Seek not supported");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Set the length of the current stream
|
||
/// Always throws a NotSupportedException
|
||
/// </summary>
|
||
/// <param name="value">The new length value for the stream.</param>
|
||
/// <exception cref="NotSupportedException">Any access</exception>
|
||
public override void SetLength(long value)
|
||
{
|
||
throw new NotSupportedException("InflaterInputStream SetLength not supported");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Writes a sequence of bytes to stream and advances the current position
|
||
/// This method always throws a NotSupportedException
|
||
/// </summary>
|
||
/// <param name="buffer">Thew buffer containing data to write.</param>
|
||
/// <param name="offset">The offset of the first byte to write.</param>
|
||
/// <param name="count">The number of bytes to write.</param>
|
||
/// <exception cref="NotSupportedException">Any access</exception>
|
||
public override void Write(byte[] buffer, int offset, int count)
|
||
{
|
||
throw new NotSupportedException("InflaterInputStream Write not supported");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Writes one byte to the current stream and advances the current position
|
||
/// Always throws a NotSupportedException
|
||
/// </summary>
|
||
/// <param name="value">The byte to write.</param>
|
||
/// <exception cref="NotSupportedException">Any access</exception>
|
||
public override void WriteByte(byte value)
|
||
{
|
||
throw new NotSupportedException("InflaterInputStream WriteByte not supported");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Entry point to begin an asynchronous write. Always throws a NotSupportedException.
|
||
/// </summary>
|
||
/// <param name="buffer">The buffer to write data from</param>
|
||
/// <param name="offset">Offset of first byte to write</param>
|
||
/// <param name="count">The maximum number of bytes to write</param>
|
||
/// <param name="callback">The method to be called when the asynchronous write operation is completed</param>
|
||
/// <param name="state">A user-provided object that distinguishes this particular asynchronous write request from other requests</param>
|
||
/// <returns>An <see cref="System.IAsyncResult">IAsyncResult</see> that references the asynchronous write</returns>
|
||
/// <exception cref="NotSupportedException">Any access</exception>
|
||
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
|
||
{
|
||
throw new NotSupportedException("InflaterInputStream BeginWrite not supported");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Closes the input stream. When <see cref="IsStreamOwner"></see>
|
||
/// is true the underlying stream is also closed.
|
||
/// </summary>
|
||
public override void Close()
|
||
{
|
||
if (!isClosed)
|
||
{
|
||
isClosed = true;
|
||
if (isStreamOwner)
|
||
{
|
||
baseInputStream.Close();
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Instance Fields
|
||
|
||
Stream baseInputStream;
|
||
|
||
/// <summary>
|
||
/// Flag indicating wether this instance is designated the stream owner.
|
||
/// When closing if this flag is true the underlying stream is closed.
|
||
/// </summary>
|
||
bool isStreamOwner = true;
|
||
|
||
/// <summary>
|
||
/// Flag indicating wether this instance has been closed or not.
|
||
/// </summary>
|
||
bool isClosed;
|
||
|
||
readonly byte[] one = new byte[1];
|
||
bool headerParsed;
|
||
|
||
// string table stuff
|
||
private const int TBL_CLEAR = 0x100;
|
||
private const int TBL_FIRST = TBL_CLEAR + 1;
|
||
|
||
private int[] tabPrefix;
|
||
private byte[] tabSuffix;
|
||
private readonly int[] zeros = new int[256];
|
||
private byte[] stack;
|
||
|
||
// various state
|
||
private bool blockMode;
|
||
private int nBits;
|
||
private int maxBits;
|
||
private int maxMaxCode;
|
||
private int maxCode;
|
||
private int bitMask;
|
||
private int oldCode;
|
||
private byte finChar;
|
||
private int stackP;
|
||
private int freeEnt;
|
||
|
||
// input buffer
|
||
private readonly byte[] data = new byte[1024 * 8];
|
||
private int bitPos;
|
||
private int end;
|
||
int got;
|
||
private bool eof;
|
||
private const int EXTRA = 64;
|
||
#endregion
|
||
}
|
||
}
|