mirror of https://github.com/SixLabors/ImageSharp
Browse Source
Removed dependency so we can shift to net 4.6 portable. Lot's of cleanup of imported files to do. Former-commit-id: 6df14b0cb658da0f97d9d2fa0d0c4602631026f8 Former-commit-id: e6a28195aa496e32e5a84bc064156657ee973baf Former-commit-id: 24ab057fa4e1b0fada4c09071c537962db4b50e9pull/17/head
James Jackson-South
10 years ago
26 changed files with 6726 additions and 21 deletions
@ -0,0 +1,192 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
///
|
|||
/// The specification for Adler32 may be found in RFC 1950.
|
|||
/// ZLIB Compressed Data Format Specification version 3.3)
|
|||
///
|
|||
///
|
|||
/// From that document:
|
|||
///
|
|||
/// "ADLER32 (Adler-32 checksum)
|
|||
/// This contains a checksum value of the uncompressed data
|
|||
/// (excluding any dictionary data) computed according to Adler-32
|
|||
/// algorithm. This algorithm is a 32-bit extension and improvement
|
|||
/// of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
|
|||
/// standard.
|
|||
///
|
|||
/// Adler-32 is composed of two sums accumulated per byte: s1 is
|
|||
/// the sum of all bytes, s2 is the sum of all s1 values. Both sums
|
|||
/// are done modulo 65521. s1 is initialized to 1, s2 to zero. The
|
|||
/// Adler-32 checksum is stored as s2*65536 + s1 in most-
|
|||
/// significant-byte first (network) order."
|
|||
///
|
|||
/// "8.2. The Adler-32 algorithm
|
|||
///
|
|||
/// The Adler-32 algorithm is much faster than the CRC32 algorithm yet
|
|||
/// still provides an extremely low probability of undetected errors.
|
|||
///
|
|||
/// The modulo on unsigned long accumulators can be delayed for 5552
|
|||
/// bytes, so the modulo operation time is negligible. If the bytes
|
|||
/// are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
|
|||
/// and order sensitive, unlike the first sum, which is just a
|
|||
/// checksum. That 65521 is prime is important to avoid a possible
|
|||
/// large class of two-byte errors that leave the check unchanged.
|
|||
/// (The Fletcher checksum uses 255, which is not prime and which also
|
|||
/// makes the Fletcher check insensitive to single byte changes 0 -
|
|||
/// 255.)
|
|||
///
|
|||
/// The sum s1 is initialized to 1 instead of zero to make the length
|
|||
/// of the sequence part of s2, so that the length does not have to be
|
|||
/// checked separately. (Any sequence of zeroes has a Fletcher
|
|||
/// checksum of zero.)"
|
|||
/// </summary>
|
|||
/// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream"/>
|
|||
/// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Streams.DeflaterOutputStream"/>
|
|||
public sealed class Adler32 : IChecksum |
|||
{ |
|||
/// <summary>
|
|||
/// largest prime smaller than 65536
|
|||
/// </summary>
|
|||
const uint BASE = 65521; |
|||
|
|||
/// <summary>
|
|||
/// Returns the Adler32 data checksum computed so far.
|
|||
/// </summary>
|
|||
public long Value |
|||
{ |
|||
get |
|||
{ |
|||
return this.checksum; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Adler32"/> class.
|
|||
/// Creates a new instance of the Adler32 class.
|
|||
/// The checksum starts off with a value of 1.
|
|||
/// </summary>
|
|||
public Adler32() |
|||
{ |
|||
this.Reset(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the Adler32 checksum to the initial value.
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
this.checksum = 1; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the checksum with a byte value.
|
|||
/// </summary>
|
|||
/// <param name="value">
|
|||
/// The data value to add. The high byte of the int is ignored.
|
|||
/// </param>
|
|||
public void Update(int value) |
|||
{ |
|||
// We could make a length 1 byte array and call update again, but I
|
|||
// would rather not have that overhead
|
|||
uint s1 = this.checksum & 0xFFFF; |
|||
uint s2 = this.checksum >> 16; |
|||
|
|||
s1 = (s1 + ((uint)value & 0xFF)) % BASE; |
|||
s2 = (s1 + s2) % BASE; |
|||
|
|||
this.checksum = (s2 << 16) + s1; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the checksum with an array of bytes.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// The source of the data to update with.
|
|||
/// </param>
|
|||
public void Update(byte[] buffer) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException("buffer"); |
|||
} |
|||
|
|||
this.Update(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the checksum with the bytes taken from the array.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// an array of bytes
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// the start of the data used for this update
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// the number of bytes to use for this update
|
|||
/// </param>
|
|||
public void Update(byte[] buffer, int offset, int count) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException("buffer"); |
|||
} |
|||
|
|||
if (offset < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("offset", "cannot be negative"); |
|||
} |
|||
|
|||
if (count < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("count", "cannot be negative"); |
|||
} |
|||
|
|||
if (offset >= buffer.Length) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("offset", "not a valid index into buffer"); |
|||
} |
|||
|
|||
if (offset + count > buffer.Length) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("count", "exceeds buffer size"); |
|||
} |
|||
|
|||
//(By Per Bothner)
|
|||
uint s1 = this.checksum & 0xFFFF; |
|||
uint s2 = this.checksum >> 16; |
|||
|
|||
while (count > 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 > count) |
|||
{ |
|||
n = count; |
|||
} |
|||
count -= n; |
|||
while (--n >= 0) |
|||
{ |
|||
s1 = s1 + (uint)(buffer[offset++] & 0xff); |
|||
s2 = s2 + s1; |
|||
} |
|||
s1 %= BASE; |
|||
s2 %= BASE; |
|||
} |
|||
|
|||
this.checksum = (s2 << 16) | s1; |
|||
} |
|||
|
|||
#region Instance Fields
|
|||
uint checksum; |
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,194 @@ |
|||
// <copyright file="Crc32.cs" company="James South">
|
|||
// Copyright © James South and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
// </copyright>
|
|||
|
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
|
|||
/// x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
|
|||
///
|
|||
/// Polynomials over GF(2) are represented in binary, one bit per coefficient,
|
|||
/// with the lowest powers in the most significant bit. Then adding polynomials
|
|||
/// is just exclusive-or, and multiplying a polynomial by x is a right shift by
|
|||
/// one. If we call the above polynomial p, and represent a byte as the
|
|||
/// polynomial q, also with the lowest power in the most significant bit (so the
|
|||
/// byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
|
|||
/// where a mod b means the remainder after dividing a by b.
|
|||
///
|
|||
/// This calculation is done using the shift-register method of multiplying and
|
|||
/// taking the remainder. The register is initialized to zero, and for each
|
|||
/// incoming bit, x^32 is added mod p to the register if the bit is a one (where
|
|||
/// x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
|
|||
/// x (which is shifting right by one and adding x^32 mod p if the bit shifted
|
|||
/// out is a one). We start with the highest power (least significant bit) of
|
|||
/// q and repeat for all eight bits of q.
|
|||
///
|
|||
/// The table is simply the CRC of all possible eight bit values. This is all
|
|||
/// the information needed to generate CRC's on data a byte at a time for all
|
|||
/// combinations of CRC register values and incoming bytes.
|
|||
/// </summary>
|
|||
public sealed class Crc32 : IChecksum |
|||
{ |
|||
const uint CrcSeed = 0xFFFFFFFF; |
|||
|
|||
readonly static uint[] CrcTable = new uint[] { |
|||
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, |
|||
0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, |
|||
0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, |
|||
0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, |
|||
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, |
|||
0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, |
|||
0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, |
|||
0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, |
|||
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, |
|||
0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, |
|||
0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, |
|||
0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, |
|||
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, |
|||
0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, |
|||
0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, |
|||
0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, |
|||
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, |
|||
0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, |
|||
0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, |
|||
0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, |
|||
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, |
|||
0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, |
|||
0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, |
|||
0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, |
|||
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, |
|||
0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, |
|||
0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, |
|||
0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, |
|||
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, |
|||
0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, |
|||
0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, |
|||
0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, |
|||
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, |
|||
0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, |
|||
0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, |
|||
0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, |
|||
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, |
|||
0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, |
|||
0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, |
|||
0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, |
|||
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, |
|||
0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, |
|||
0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, |
|||
0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, |
|||
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, |
|||
0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, |
|||
0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, |
|||
0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, |
|||
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, |
|||
0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, |
|||
0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, |
|||
0x2D02EF8D |
|||
}; |
|||
|
|||
internal static uint ComputeCrc32(uint oldCrc, byte value) |
|||
{ |
|||
return (uint)(Crc32.CrcTable[(oldCrc ^ value) & 0xFF] ^ (oldCrc >> 8)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The crc data checksum so far.
|
|||
/// </summary>
|
|||
uint crc; |
|||
|
|||
/// <summary>
|
|||
/// Returns the CRC32 data checksum computed so far.
|
|||
/// </summary>
|
|||
public long Value |
|||
{ |
|||
get |
|||
{ |
|||
return (long)this.crc; |
|||
} |
|||
set |
|||
{ |
|||
this.crc = (uint)value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the CRC32 data checksum as if no update was ever called.
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
this.crc = 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the checksum with the int bval.
|
|||
/// </summary>
|
|||
/// <param name = "value">
|
|||
/// the byte is taken as the lower 8 bits of value
|
|||
/// </param>
|
|||
public void Update(int value) |
|||
{ |
|||
this.crc ^= CrcSeed; |
|||
this.crc = CrcTable[(this.crc ^ value) & 0xFF] ^ (this.crc >> 8); |
|||
this.crc ^= CrcSeed; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Updates the checksum with the bytes taken from the array.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// buffer an array of bytes
|
|||
/// </param>
|
|||
public void Update(byte[] buffer) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException("buffer"); |
|||
} |
|||
|
|||
this.Update(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Adds the byte array to the data checksum.
|
|||
/// </summary>
|
|||
/// <param name = "buffer">
|
|||
/// The buffer which contains the data
|
|||
/// </param>
|
|||
/// <param name = "offset">
|
|||
/// The offset in the buffer where the data starts
|
|||
/// </param>
|
|||
/// <param name = "count">
|
|||
/// The number of data bytes to update the CRC with.
|
|||
/// </param>
|
|||
public void Update(byte[] buffer, int offset, int count) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException("buffer"); |
|||
} |
|||
|
|||
if (count < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("count", "Count cannot be less than zero"); |
|||
} |
|||
|
|||
if (offset < 0 || offset + count > buffer.Length) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("offset"); |
|||
} |
|||
|
|||
this.crc ^= CrcSeed; |
|||
|
|||
while (--count >= 0) |
|||
{ |
|||
this.crc = CrcTable[(this.crc ^ buffer[offset++]) & 0xFF] ^ (this.crc >> 8); |
|||
} |
|||
|
|||
this.crc ^= CrcSeed; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
/// <summary>
|
|||
/// Strategies for deflater
|
|||
/// </summary>
|
|||
public enum DeflateStrategy |
|||
{ |
|||
/// <summary>
|
|||
/// The default strategy
|
|||
/// </summary>
|
|||
Default = 0, |
|||
|
|||
/// <summary>
|
|||
/// This strategy will only allow longer string repetitions. It is
|
|||
/// useful for random data with a small character set.
|
|||
/// </summary>
|
|||
Filtered = 1, |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
HuffmanOnly = 2 |
|||
} |
|||
} |
|||
@ -0,0 +1,555 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
//using ICSharpCode.SharpZipLib.Zip.Compression;
|
|||
|
|||
/// <summary>
|
|||
/// This is the Deflater class. The deflater class compresses input
|
|||
/// with the deflate algorithm described in RFC 1951. It has several
|
|||
/// compression levels and three different strategies described below.
|
|||
///
|
|||
/// This class is <i>not</i> thread safe. This is inherent in the API, due
|
|||
/// to the split of deflate and setInput.
|
|||
///
|
|||
/// author of the original java version : Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class Deflater |
|||
{ |
|||
#region Deflater Documentation
|
|||
/* |
|||
* 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) |
|||
* |
|||
*/ |
|||
#endregion
|
|||
#region Public Constants
|
|||
/// <summary>
|
|||
/// The best and slowest compression level. This tries to find very
|
|||
/// long and distant string repetitions.
|
|||
/// </summary>
|
|||
public const int BEST_COMPRESSION = 9; |
|||
|
|||
/// <summary>
|
|||
/// The worst but fastest compression level.
|
|||
/// </summary>
|
|||
public const int BEST_SPEED = 1; |
|||
|
|||
/// <summary>
|
|||
/// The default compression level.
|
|||
/// </summary>
|
|||
public const int DEFAULT_COMPRESSION = -1; |
|||
|
|||
/// <summary>
|
|||
/// This level won't compress at all but output uncompressed blocks.
|
|||
/// </summary>
|
|||
public const int NO_COMPRESSION = 0; |
|||
|
|||
/// <summary>
|
|||
/// The compression method. This is the only method supported so far.
|
|||
/// There is no need to use this constant at all.
|
|||
/// </summary>
|
|||
public const int DEFLATED = 8; |
|||
#endregion
|
|||
#region Local Constants
|
|||
private const int IS_SETDICT = 0x01; |
|||
private const int IS_FLUSHING = 0x04; |
|||
private const int IS_FINISHING = 0x08; |
|||
|
|||
private const int INIT_STATE = 0x00; |
|||
private const int SETDICT_STATE = 0x01; |
|||
// private static int INIT_FINISHING_STATE = 0x08;
|
|||
// private static int SETDICT_FINISHING_STATE = 0x09;
|
|||
private const int BUSY_STATE = 0x10; |
|||
private const int FLUSHING_STATE = 0x14; |
|||
private const int FINISHING_STATE = 0x1c; |
|||
private const int FINISHED_STATE = 0x1e; |
|||
private const int CLOSED_STATE = 0x7f; |
|||
#endregion
|
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Creates a new deflater with default compression level.
|
|||
/// </summary>
|
|||
public Deflater() : this(DEFAULT_COMPRESSION, false) |
|||
{ |
|||
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Creates a new deflater with given compression level.
|
|||
/// </summary>
|
|||
/// <param name="level">
|
|||
/// the compression level, a value between NO_COMPRESSION
|
|||
/// and BEST_COMPRESSION, or DEFAULT_COMPRESSION.
|
|||
/// </param>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">if lvl is out of range.</exception>
|
|||
public Deflater(int level) : this(level, false) |
|||
{ |
|||
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Creates a new deflater with given compression level.
|
|||
/// </summary>
|
|||
/// <param name="level">
|
|||
/// the compression level, a value between NO_COMPRESSION
|
|||
/// and BEST_COMPRESSION.
|
|||
/// </param>
|
|||
/// <param name="noZlibHeaderOrFooter">
|
|||
/// true, if we should suppress the Zlib/RFC1950 header at the
|
|||
/// beginning and the adler checksum at the end of the output. This is
|
|||
/// useful for the GZIP/PKZIP formats.
|
|||
/// </param>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">if lvl is out of range.</exception>
|
|||
public Deflater(int level, bool noZlibHeaderOrFooter) |
|||
{ |
|||
if (level == DEFAULT_COMPRESSION) |
|||
{ |
|||
level = 6; |
|||
} |
|||
else if (level < NO_COMPRESSION || level > BEST_COMPRESSION) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("level"); |
|||
} |
|||
|
|||
pending = new DeflaterPending(); |
|||
engine = new DeflaterEngine(pending); |
|||
this.noZlibHeaderOrFooter = noZlibHeaderOrFooter; |
|||
SetStrategy(DeflateStrategy.Default); |
|||
SetLevel(level); |
|||
Reset(); |
|||
} |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Resets the deflater. The deflater acts afterwards as if it was
|
|||
/// just created with the same compression level and strategy as it
|
|||
/// had before.
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
state = (noZlibHeaderOrFooter ? BUSY_STATE : INIT_STATE); |
|||
totalOut = 0; |
|||
pending.Reset(); |
|||
engine.Reset(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current adler checksum of the data that was processed so far.
|
|||
/// </summary>
|
|||
public int Adler |
|||
{ |
|||
get |
|||
{ |
|||
return engine.Adler; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of input bytes processed so far.
|
|||
/// </summary>
|
|||
public long TotalIn |
|||
{ |
|||
get |
|||
{ |
|||
return engine.TotalIn; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of output bytes so far.
|
|||
/// </summary>
|
|||
public long TotalOut |
|||
{ |
|||
get |
|||
{ |
|||
return totalOut; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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().
|
|||
/// </summary>
|
|||
public void Flush() |
|||
{ |
|||
state |= IS_FLUSHING; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
public void Finish() |
|||
{ |
|||
state |= (IS_FLUSHING | IS_FINISHING); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true if the stream was finished and no more output bytes
|
|||
/// are available.
|
|||
/// </summary>
|
|||
public bool IsFinished |
|||
{ |
|||
get |
|||
{ |
|||
return (state == FINISHED_STATE) && pending.IsFlushed; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true, if the input buffer is empty.
|
|||
/// You should then call setInput().
|
|||
/// NOTE: This method can also return true when the stream
|
|||
/// was finished.
|
|||
/// </summary>
|
|||
public bool IsNeedingInput |
|||
{ |
|||
get |
|||
{ |
|||
return engine.NeedsInput(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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>.
|
|||
/// </summary>
|
|||
/// <param name="input">
|
|||
/// the buffer containing the input data.
|
|||
/// </param>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// if the buffer was finished() or ended().
|
|||
/// </exception>
|
|||
public void SetInput(byte[] input) |
|||
{ |
|||
SetInput(input, 0, input.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="input">
|
|||
/// the buffer containing the input data.
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// the start of the data.
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// the number of data bytes of input.
|
|||
/// </param>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// if the buffer was Finish()ed or if previous input is still pending.
|
|||
/// </exception>
|
|||
public void SetInput(byte[] input, int offset, int count) |
|||
{ |
|||
if ((state & IS_FINISHING) != 0) |
|||
{ |
|||
throw new InvalidOperationException("Finish() already called"); |
|||
} |
|||
engine.SetInput(input, offset, count); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="level">
|
|||
/// the new compression level.
|
|||
/// </param>
|
|||
public void SetLevel(int level) |
|||
{ |
|||
if (level == DEFAULT_COMPRESSION) |
|||
{ |
|||
level = 6; |
|||
} |
|||
else if (level < NO_COMPRESSION || level > BEST_COMPRESSION) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("level"); |
|||
} |
|||
|
|||
if (this.level != level) |
|||
{ |
|||
this.level = level; |
|||
engine.SetLevel(level); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get current compression level
|
|||
/// </summary>
|
|||
/// <returns>Returns the current compression level</returns>
|
|||
public int GetLevel() |
|||
{ |
|||
return level; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="strategy">
|
|||
/// The new compression strategy.
|
|||
/// </param>
|
|||
public void SetStrategy(DeflateStrategy strategy) |
|||
{ |
|||
engine.Strategy = strategy; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Deflates the current input block with to the given array.
|
|||
/// </summary>
|
|||
/// <param name="output">
|
|||
/// The buffer where compressed data is stored
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The number of compressed bytes added to the output, or 0 if either
|
|||
/// IsNeedingInput() or IsFinished returns true or length is zero.
|
|||
/// </returns>
|
|||
public int Deflate(byte[] output) |
|||
{ |
|||
return Deflate(output, 0, output.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Deflates the current input block to the given array.
|
|||
/// </summary>
|
|||
/// <param name="output">
|
|||
/// Buffer to store the compressed data.
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// Offset into the output array.
|
|||
/// </param>
|
|||
/// <param name="length">
|
|||
/// The maximum number of bytes that may be stored.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The number of compressed bytes added to the output, or 0 if either
|
|||
/// needsInput() or finished() returns true or length is zero.
|
|||
/// </returns>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// If Finish() was previously called.
|
|||
/// </exception>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">
|
|||
/// If offset or length don't match the array length.
|
|||
/// </exception>
|
|||
public int Deflate(byte[] output, int offset, int length) |
|||
{ |
|||
int origLength = length; |
|||
|
|||
if (state == CLOSED_STATE) |
|||
{ |
|||
throw new InvalidOperationException("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.Adler; |
|||
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 |
|||
* is needed by the zlib inflater, and we must fill |
|||
* the next byte, so that all bits are flushed. |
|||
*/ |
|||
int neededbits = 8 + ((-pending.BitCount) & 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(); |
|||
|
|||
// Compressed data is complete. Write footer information if required.
|
|||
if (!noZlibHeaderOrFooter) |
|||
{ |
|||
int adler = engine.Adler; |
|||
pending.WriteShortMSB(adler >> 16); |
|||
pending.WriteShortMSB(adler & 0xffff); |
|||
} |
|||
state = FINISHED_STATE; |
|||
} |
|||
} |
|||
} |
|||
return origLength - length; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the dictionary which should be used in the deflate process.
|
|||
/// This call is equivalent to <code>setDictionary(dict, 0, dict.Length)</code>.
|
|||
/// </summary>
|
|||
/// <param name="dictionary">
|
|||
/// the dictionary.
|
|||
/// </param>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// if SetInput () or Deflate () were already called or another dictionary was already set.
|
|||
/// </exception>
|
|||
public void SetDictionary(byte[] dictionary) |
|||
{ |
|||
SetDictionary(dictionary, 0, dictionary.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the dictionary which should be used in the deflate process.
|
|||
/// The dictionary is 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.
|
|||
/// </summary>
|
|||
/// <param name="dictionary">
|
|||
/// The dictionary data
|
|||
/// </param>
|
|||
/// <param name="index">
|
|||
/// The index where dictionary information commences.
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// The number of bytes in the dictionary.
|
|||
/// </param>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// If SetInput () or Deflate() were already called or another dictionary was already set.
|
|||
/// </exception>
|
|||
public void SetDictionary(byte[] dictionary, int index, int count) |
|||
{ |
|||
if (state != INIT_STATE) |
|||
{ |
|||
throw new InvalidOperationException(); |
|||
} |
|||
|
|||
state = SETDICT_STATE; |
|||
engine.SetDictionary(dictionary, index, count); |
|||
} |
|||
|
|||
#region Instance Fields
|
|||
/// <summary>
|
|||
/// Compression level.
|
|||
/// </summary>
|
|||
int level; |
|||
|
|||
/// <summary>
|
|||
/// If true no Zlib/RFC1950 headers or footers are generated
|
|||
/// </summary>
|
|||
bool noZlibHeaderOrFooter; |
|||
|
|||
/// <summary>
|
|||
/// The current state.
|
|||
/// </summary>
|
|||
int state; |
|||
|
|||
/// <summary>
|
|||
/// The total bytes of output written.
|
|||
/// </summary>
|
|||
long totalOut; |
|||
|
|||
/// <summary>
|
|||
/// The pending output.
|
|||
/// </summary>
|
|||
DeflaterPending pending; |
|||
|
|||
/// <summary>
|
|||
/// The deflater engine.
|
|||
/// </summary>
|
|||
DeflaterEngine engine; |
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,145 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// This class contains constants used for deflation.
|
|||
/// </summary>
|
|||
public class DeflaterConstants |
|||
{ |
|||
/// <summary>
|
|||
/// Set to true to enable debugging
|
|||
/// </summary>
|
|||
public const bool DEBUGGING = false; |
|||
|
|||
/// <summary>
|
|||
/// Written to Zip file to identify a stored block
|
|||
/// </summary>
|
|||
public const int STORED_BLOCK = 0; |
|||
|
|||
/// <summary>
|
|||
/// Identifies static tree in Zip file
|
|||
/// </summary>
|
|||
public const int STATIC_TREES = 1; |
|||
|
|||
/// <summary>
|
|||
/// Identifies dynamic tree in Zip file
|
|||
/// </summary>
|
|||
public const int DYN_TREES = 2; |
|||
|
|||
/// <summary>
|
|||
/// Header flag indicating a preset dictionary for deflation
|
|||
/// </summary>
|
|||
public const int PRESET_DICT = 0x20; |
|||
|
|||
/// <summary>
|
|||
/// Sets internal buffer sizes for Huffman encoding
|
|||
/// </summary>
|
|||
public const int DEFAULT_MEM_LEVEL = 8; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int MAX_MATCH = 258; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int MIN_MATCH = 3; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int MAX_WBITS = 15; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int WSIZE = 1 << MAX_WBITS; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int WMASK = WSIZE - 1; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int HASH_BITS = DEFAULT_MEM_LEVEL + 7; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int HASH_SIZE = 1 << HASH_BITS; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int HASH_MASK = HASH_SIZE - 1; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int HASH_SHIFT = (HASH_BITS + MIN_MATCH - 1) / MIN_MATCH; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int MAX_DIST = WSIZE - MIN_LOOKAHEAD; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int PENDING_BUF_SIZE = 1 << (DEFAULT_MEM_LEVEL + 8); |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public static int MAX_BLOCK_SIZE = Math.Min(65535, PENDING_BUF_SIZE - 5); |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int DEFLATE_STORED = 0; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int DEFLATE_FAST = 1; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public const int DEFLATE_SLOW = 2; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public static int[] GOOD_LENGTH = { 0, 4, 4, 4, 4, 8, 8, 8, 32, 32 }; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public static int[] MAX_LAZY = { 0, 4, 5, 6, 4, 16, 16, 32, 128, 258 }; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public static int[] NICE_LENGTH = { 0, 8, 16, 32, 16, 32, 128, 128, 258, 258 }; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public static int[] MAX_CHAIN = { 0, 4, 8, 32, 16, 32, 128, 256, 1024, 4096 }; |
|||
|
|||
/// <summary>
|
|||
/// Internal compression engine constant
|
|||
/// </summary>
|
|||
public static int[] COMPR_FUNC = { 0, 1, 1, 1, 1, 2, 2, 2, 2, 2 }; |
|||
} |
|||
} |
|||
@ -0,0 +1,757 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// Low level compression engine for deflate algorithm which uses a 32K sliding window
|
|||
/// with secondary compression from Huffman/Shannon-Fano codes.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// 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.
|
|||
/// </remarks>
|
|||
public class DeflaterEngine : DeflaterConstants |
|||
{ |
|||
/// <summary>
|
|||
/// ne more than the maximum upper bounds.
|
|||
/// </summary>
|
|||
private const int TooFar = 4096; |
|||
|
|||
/// <summary>
|
|||
/// <code>prev[index & WMASK]</code> 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.
|
|||
/// </summary>
|
|||
private readonly short[] previousIndex; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
private readonly short[] head; |
|||
|
|||
/// <summary>
|
|||
/// Hash index of string to be inserted.
|
|||
/// </summary>
|
|||
private int insertHashIndex; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DeflaterEngine"/> class with a pending buffer.
|
|||
/// </summary>
|
|||
/// <param name="pending">The pending buffer to use</param>>
|
|||
public DeflaterEngine(DeflaterPending pending) |
|||
{ |
|||
this.pending = pending; |
|||
this.huffman = new DeflaterHuffman(pending); |
|||
this.adler = new Adler32(); |
|||
|
|||
this.window = new byte[2 * WSIZE]; |
|||
this.head = new short[HASH_SIZE]; |
|||
this.previousIndex = new short[WSIZE]; |
|||
|
|||
// We start at index 1, to avoid an implementation deficiency, that
|
|||
// we cannot build a repeat pattern at index 0.
|
|||
this.blockStart = this.strstart = 1; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get current value of Adler checksum
|
|||
/// </summary>
|
|||
public int Adler => unchecked((int)this.adler.Value); |
|||
|
|||
/// <summary>
|
|||
/// Total data processed
|
|||
/// </summary>
|
|||
public long TotalIn => this.totalIn; |
|||
|
|||
/// <summary>
|
|||
/// Get or sets the <see cref="DeflateStrategy"/>
|
|||
/// </summary>
|
|||
public DeflateStrategy Strategy { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Deflate drives actual compression of data
|
|||
/// </summary>
|
|||
/// <param name="flush">True to flush input buffers</param>
|
|||
/// <param name="finish">Finish deflation with the current input.</param>
|
|||
/// <returns>Returns true if progress has been made.</returns>
|
|||
public bool Deflate(bool flush, bool finish) |
|||
{ |
|||
bool progress; |
|||
do |
|||
{ |
|||
this.FillWindow(); |
|||
bool canFlush = flush && (this.inputOff == this.inputEnd); |
|||
|
|||
switch (this.compressionFunction) |
|||
{ |
|||
case DEFLATE_STORED: |
|||
progress = this.DeflateStored(canFlush, finish); |
|||
break; |
|||
case DEFLATE_FAST: |
|||
progress = this.DeflateFast(canFlush, finish); |
|||
break; |
|||
case DEFLATE_SLOW: |
|||
progress = this.DeflateSlow(canFlush, finish); |
|||
break; |
|||
default: |
|||
throw new InvalidOperationException("unknown compressionFunction"); |
|||
} |
|||
} |
|||
while (this.pending.IsFlushed && progress); // repeat while we have no pending output and progress was made
|
|||
return progress; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets input data to be deflated. Should only be called when <code>NeedsInput()</code>
|
|||
/// returns true
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer containing input data.</param>
|
|||
/// <param name="offset">The offset of the first byte of data.</param>
|
|||
/// <param name="count">The number of bytes of data to use as input.</param>
|
|||
public void SetInput(byte[] buffer, int offset, int count) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException(nameof(buffer)); |
|||
} |
|||
|
|||
if (offset < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException(nameof(offset)); |
|||
} |
|||
|
|||
if (count < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException(nameof(count)); |
|||
} |
|||
|
|||
if (this.inputOff < this.inputEnd) |
|||
{ |
|||
throw new InvalidOperationException("Old input was not completely processed"); |
|||
} |
|||
|
|||
int end = offset + count; |
|||
|
|||
// We want to throw an ArrayIndexOutOfBoundsException early. The
|
|||
// check is very tricky: it also handles integer wrap around.
|
|||
if ((offset > end) || (end > buffer.Length)) |
|||
{ |
|||
throw new ArgumentOutOfRangeException(nameof(count)); |
|||
} |
|||
|
|||
this.inputBuf = buffer; |
|||
this.inputOff = offset; |
|||
this.inputEnd = end; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determines if more <see cref="SetInput">input</see> is needed.
|
|||
/// </summary>
|
|||
/// <returns>Return true if input is needed via <see cref="SetInput">SetInput</see></returns>
|
|||
public bool NeedsInput() |
|||
{ |
|||
return this.inputEnd == this.inputOff; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set compression dictionary
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer containing the dictionary data</param>
|
|||
/// <param name="offset">The offset in the buffer for the first byte of data</param>
|
|||
/// <param name="length">The length of the dictionary data.</param>
|
|||
public void SetDictionary(byte[] buffer, int offset, int length) |
|||
{ |
|||
this.adler.Update(buffer, offset, length); |
|||
if (length < MIN_MATCH) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
if (length > MAX_DIST) |
|||
{ |
|||
offset += length - MAX_DIST; |
|||
length = MAX_DIST; |
|||
} |
|||
|
|||
Array.Copy(buffer, offset, this.window, this.strstart, length); |
|||
|
|||
this.UpdateHash(); |
|||
--length; |
|||
while (--length > 0) |
|||
{ |
|||
this.InsertString(); |
|||
this.strstart++; |
|||
} |
|||
|
|||
this.strstart += 2; |
|||
this.blockStart = this.strstart; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reset internal state
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
this.huffman.Reset(); |
|||
this.adler.Reset(); |
|||
this.blockStart = this.strstart = 1; |
|||
this.lookahead = 0; |
|||
this.totalIn = 0; |
|||
this.prevAvailable = false; |
|||
this.matchLen = MIN_MATCH - 1; |
|||
|
|||
for (int i = 0; i < HASH_SIZE; i++) |
|||
{ |
|||
this.head[i] = 0; |
|||
} |
|||
|
|||
for (int i = 0; i < WSIZE; i++) |
|||
{ |
|||
this.previousIndex[i] = 0; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reset Adler checksum
|
|||
/// </summary>
|
|||
public void ResetAdler() |
|||
{ |
|||
this.adler.Reset(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set the deflate level (0-9)
|
|||
/// </summary>
|
|||
/// <param name="level">The value to set the level to.</param>
|
|||
public void SetLevel(int level) |
|||
{ |
|||
if ((level < 0) || (level > 9)) |
|||
{ |
|||
throw new ArgumentOutOfRangeException(nameof(level)); |
|||
} |
|||
|
|||
this.goodLength = GOOD_LENGTH[level]; |
|||
this.maxLazy = MAX_LAZY[level]; |
|||
this.niceLength = NICE_LENGTH[level]; |
|||
this.maxChain = MAX_CHAIN[level]; |
|||
|
|||
if (COMPR_FUNC[level] != this.compressionFunction) |
|||
{ |
|||
switch (this.compressionFunction) |
|||
{ |
|||
case DEFLATE_STORED: |
|||
if (this.strstart > this.blockStart) |
|||
{ |
|||
this.huffman.FlushStoredBlock(this.window, this.blockStart, this.strstart - this.blockStart, false); |
|||
this.blockStart = this.strstart; |
|||
} |
|||
|
|||
this.UpdateHash(); |
|||
break; |
|||
|
|||
case DEFLATE_FAST: |
|||
if (this.strstart > this.blockStart) |
|||
{ |
|||
this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, |
|||
false); |
|||
this.blockStart = this.strstart; |
|||
} |
|||
|
|||
break; |
|||
|
|||
case DEFLATE_SLOW: |
|||
if (this.prevAvailable) |
|||
{ |
|||
this.huffman.TallyLit(this.window[this.strstart - 1] & 0xff); |
|||
} |
|||
|
|||
if (this.strstart > this.blockStart) |
|||
{ |
|||
this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, false); |
|||
this.blockStart = this.strstart; |
|||
} |
|||
|
|||
this.prevAvailable = false; |
|||
this.matchLen = MIN_MATCH - 1; |
|||
break; |
|||
} |
|||
|
|||
this.compressionFunction = COMPR_FUNC[level]; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Fill the window
|
|||
/// </summary>
|
|||
public 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 (this.strstart >= WSIZE + MAX_DIST) |
|||
{ |
|||
this.SlideWindow(); |
|||
} |
|||
|
|||
// If there is not enough lookahead, but still some input left,
|
|||
// read in the input
|
|||
while (this.lookahead < MIN_LOOKAHEAD && this.inputOff < this.inputEnd) |
|||
{ |
|||
int more = (2 * WSIZE) - this.lookahead - this.strstart; |
|||
|
|||
if (more > this.inputEnd - this.inputOff) |
|||
{ |
|||
more = this.inputEnd - this.inputOff; |
|||
} |
|||
|
|||
Array.Copy(this.inputBuf, this.inputOff, this.window, this.strstart + this.lookahead, more); |
|||
this.adler.Update(this.inputBuf, this.inputOff, more); |
|||
|
|||
this.inputOff += more; |
|||
this.totalIn += more; |
|||
this.lookahead += more; |
|||
} |
|||
|
|||
if (this.lookahead >= MIN_MATCH) |
|||
{ |
|||
this.UpdateHash(); |
|||
} |
|||
} |
|||
|
|||
private void UpdateHash() |
|||
{ |
|||
this.insertHashIndex = (this.window[this.strstart] << HASH_SHIFT) ^ this.window[this.strstart + 1]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Inserts the current string in the head hash and returns the previous
|
|||
/// value for this hash.
|
|||
/// </summary>
|
|||
/// <returns>The previous hash value</returns>
|
|||
private int InsertString() |
|||
{ |
|||
short match; |
|||
int hash = ((this.insertHashIndex << HASH_SHIFT) ^ this.window[this.strstart + (MIN_MATCH - 1)]) & HASH_MASK; |
|||
|
|||
this.previousIndex[this.strstart & WMASK] = match = this.head[hash]; |
|||
this.head[hash] = unchecked((short)this.strstart); |
|||
this.insertHashIndex = hash; |
|||
return match & 0xffff; |
|||
} |
|||
|
|||
private void SlideWindow() |
|||
{ |
|||
Array.Copy(this.window, WSIZE, this.window, 0, WSIZE); |
|||
this.matchStart -= WSIZE; |
|||
this.strstart -= WSIZE; |
|||
this.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 = this.head[i] & 0xffff; |
|||
this.head[i] = (short)(m >= WSIZE ? (m - WSIZE) : 0); |
|||
} |
|||
|
|||
// Slide the prev table.
|
|||
for (int i = 0; i < WSIZE; i++) |
|||
{ |
|||
int m = this.previousIndex[i] & 0xffff; |
|||
this.previousIndex[i] = (short)(m >= WSIZE ? (m - WSIZE) : 0); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Find the best (longest) string in the window matching the
|
|||
/// string starting at strstart.
|
|||
///
|
|||
/// Preconditions:
|
|||
/// <code>
|
|||
/// strstart + MAX_MATCH <= window.length.</code>
|
|||
/// </summary>
|
|||
/// <param name="curMatch">The current match.</param>
|
|||
/// <returns>True if a match greater than the minimum length is found</returns>
|
|||
private bool FindLongestMatch(int curMatch) |
|||
{ |
|||
int chainLength = this.maxChain; |
|||
int length = this.niceLength; |
|||
short[] previous = this.previousIndex; |
|||
int scan = this.strstart; |
|||
int bestEnd = this.strstart + this.matchLen; |
|||
int bestLength = Math.Max(this.matchLen, MIN_MATCH - 1); |
|||
|
|||
int limit = Math.Max(this.strstart - MAX_DIST, 0); |
|||
|
|||
int strend = this.strstart + MAX_MATCH - 1; |
|||
byte scanEnd1 = this.window[bestEnd - 1]; |
|||
byte scanEnd = this.window[bestEnd]; |
|||
|
|||
// Do not waste too much time if we already have a good match:
|
|||
if (bestLength >= this.goodLength) |
|||
{ |
|||
chainLength >>= 2; |
|||
} |
|||
|
|||
// Do not look for matches beyond the end of the input. This is necessary
|
|||
// to make deflate deterministic.
|
|||
if (length > this.lookahead) |
|||
{ |
|||
length = this.lookahead; |
|||
} |
|||
|
|||
do |
|||
{ |
|||
if (this.window[curMatch + bestLength] != scanEnd || |
|||
this.window[curMatch + bestLength - 1] != scanEnd1 || |
|||
this.window[curMatch] != this.window[scan] || |
|||
this.window[curMatch + 1] != this.window[scan + 1]) |
|||
{ |
|||
continue; |
|||
} |
|||
|
|||
int match = curMatch + 2; |
|||
scan += 2; |
|||
|
|||
// We check for insufficient lookahead only every 8th comparison;
|
|||
// the 256th check will be made at strstart + 258.
|
|||
while ( |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
this.window[++scan] == this.window[++match] && |
|||
(scan < strend)) |
|||
{ |
|||
// Do nothing
|
|||
} |
|||
|
|||
if (scan > bestEnd) |
|||
{ |
|||
this.matchStart = curMatch; |
|||
bestEnd = scan; |
|||
bestLength = scan - this.strstart; |
|||
|
|||
if (bestLength >= length) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
scanEnd1 = this.window[bestEnd - 1]; |
|||
scanEnd = this.window[bestEnd]; |
|||
} |
|||
|
|||
scan = this.strstart; |
|||
} while ((curMatch = previous[curMatch & WMASK] & 0xffff) > limit && --chainLength != 0); |
|||
|
|||
this.matchLen = Math.Min(bestLength, this.lookahead); |
|||
return this.matchLen >= MIN_MATCH; |
|||
} |
|||
|
|||
private bool DeflateStored(bool flush, bool finish) |
|||
{ |
|||
if (!flush && (this.lookahead == 0)) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
this.strstart += this.lookahead; |
|||
this.lookahead = 0; |
|||
|
|||
int storedLength = this.strstart - this.blockStart; |
|||
|
|||
if ((storedLength >= MAX_BLOCK_SIZE) || // Block is full
|
|||
(this.blockStart < WSIZE && storedLength >= MAX_DIST) || // Block may move out of window
|
|||
flush) |
|||
{ |
|||
bool lastBlock = finish; |
|||
if (storedLength > MAX_BLOCK_SIZE) |
|||
{ |
|||
storedLength = MAX_BLOCK_SIZE; |
|||
lastBlock = false; |
|||
} |
|||
|
|||
this.huffman.FlushStoredBlock(this.window, this.blockStart, storedLength, lastBlock); |
|||
this.blockStart += storedLength; |
|||
return !lastBlock; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
private bool DeflateFast(bool flush, bool finish) |
|||
{ |
|||
if (this.lookahead < MIN_LOOKAHEAD && !flush) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
while (this.lookahead >= MIN_LOOKAHEAD || flush) |
|||
{ |
|||
if (this.lookahead == 0) |
|||
{ |
|||
// We are flushing everything
|
|||
this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, finish); |
|||
this.blockStart = this.strstart; |
|||
return false; |
|||
} |
|||
|
|||
if (this.strstart > (2 * WSIZE) - MIN_LOOKAHEAD) |
|||
{ |
|||
/* slide window, as FindLongestMatch needs this. |
|||
* This should only happen when flushing and the window |
|||
* is almost full. |
|||
*/ |
|||
this.SlideWindow(); |
|||
} |
|||
|
|||
int hashHead; |
|||
if (this.lookahead >= MIN_MATCH && |
|||
(hashHead = this.InsertString()) != 0 && |
|||
this.Strategy != DeflateStrategy.HuffmanOnly && |
|||
this.strstart - hashHead <= MAX_DIST && |
|||
this.FindLongestMatch(hashHead)) |
|||
{ |
|||
// longestMatch sets matchStart and matchLen
|
|||
bool full = this.huffman.TallyDist(this.strstart - this.matchStart, this.matchLen); |
|||
|
|||
this.lookahead -= this.matchLen; |
|||
if (this.matchLen <= this.maxLazy && this.lookahead >= MIN_MATCH) |
|||
{ |
|||
while (--this.matchLen > 0) |
|||
{ |
|||
++this.strstart; |
|||
this.InsertString(); |
|||
} |
|||
|
|||
++this.strstart; |
|||
} |
|||
else |
|||
{ |
|||
this.strstart += this.matchLen; |
|||
if (this.lookahead >= MIN_MATCH - 1) |
|||
{ |
|||
this.UpdateHash(); |
|||
} |
|||
} |
|||
|
|||
this.matchLen = MIN_MATCH - 1; |
|||
if (!full) |
|||
{ |
|||
continue; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// No match found
|
|||
this.huffman.TallyLit(this.window[this.strstart] & 0xff); |
|||
++this.strstart; |
|||
--this.lookahead; |
|||
} |
|||
|
|||
if (this.huffman.IsFull()) |
|||
{ |
|||
bool lastBlock = finish && (this.lookahead == 0); |
|||
this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, lastBlock); |
|||
this.blockStart = this.strstart; |
|||
return !lastBlock; |
|||
} |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
private bool DeflateSlow(bool flush, bool finish) |
|||
{ |
|||
if (this.lookahead < MIN_LOOKAHEAD && !flush) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
while (this.lookahead >= MIN_LOOKAHEAD || flush) |
|||
{ |
|||
if (this.lookahead == 0) |
|||
{ |
|||
if (this.prevAvailable) |
|||
{ |
|||
this.huffman.TallyLit(this.window[this.strstart - 1] & 0xff); |
|||
} |
|||
|
|||
this.prevAvailable = false; |
|||
|
|||
// We are flushing everything
|
|||
this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, |
|||
finish); |
|||
this.blockStart = this.strstart; |
|||
return false; |
|||
} |
|||
|
|||
if (this.strstart >= (2 * WSIZE) - MIN_LOOKAHEAD) |
|||
{ |
|||
// slide window, as FindLongestMatch needs this.
|
|||
// This should only happen when flushing and the window
|
|||
// is almost full.
|
|||
this.SlideWindow(); |
|||
} |
|||
|
|||
int prevMatch = this.matchStart; |
|||
int prevLen = this.matchLen; |
|||
if (this.lookahead >= MIN_MATCH) |
|||
{ |
|||
|
|||
int hashHead = this.InsertString(); |
|||
|
|||
if (this.Strategy != DeflateStrategy.HuffmanOnly && |
|||
hashHead != 0 && |
|||
this.strstart - hashHead <= MAX_DIST && |
|||
this.FindLongestMatch(hashHead)) |
|||
{ |
|||
|
|||
// longestMatch sets matchStart and matchLen
|
|||
|
|||
// Discard match if too small and too far away
|
|||
if (this.matchLen <= 5 && (this.Strategy == DeflateStrategy.Filtered || (this.matchLen == MIN_MATCH && this.strstart - this.matchStart > TooFar))) |
|||
{ |
|||
this.matchLen = MIN_MATCH - 1; |
|||
} |
|||
} |
|||
} |
|||
|
|||
// previous match was better
|
|||
if ((prevLen >= MIN_MATCH) && (this.matchLen <= prevLen)) |
|||
{ |
|||
this.huffman.TallyDist(this.strstart - 1 - prevMatch, prevLen); |
|||
prevLen -= 2; |
|||
do |
|||
{ |
|||
this.strstart++; |
|||
this.lookahead--; |
|||
if (this.lookahead >= MIN_MATCH) |
|||
{ |
|||
this.InsertString(); |
|||
} |
|||
} while (--prevLen > 0); |
|||
|
|||
this.strstart++; |
|||
this.lookahead--; |
|||
this.prevAvailable = false; |
|||
this.matchLen = MIN_MATCH - 1; |
|||
} |
|||
else |
|||
{ |
|||
if (this.prevAvailable) |
|||
{ |
|||
this.huffman.TallyLit(this.window[this.strstart - 1] & 0xff); |
|||
} |
|||
|
|||
this.prevAvailable = true; |
|||
this.strstart++; |
|||
this.lookahead--; |
|||
} |
|||
|
|||
if (this.huffman.IsFull()) |
|||
{ |
|||
int len = this.strstart - this.blockStart; |
|||
if (this.prevAvailable) |
|||
{ |
|||
len--; |
|||
} |
|||
|
|||
bool lastBlock = finish && (this.lookahead == 0) && !this.prevAvailable; |
|||
this.huffman.FlushBlock(this.window, this.blockStart, len, lastBlock); |
|||
this.blockStart += len; |
|||
return !lastBlock; |
|||
} |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
private int matchStart; |
|||
|
|||
// Length of best match
|
|||
private int matchLen; |
|||
|
|||
// Set if previous match exists
|
|||
private bool prevAvailable; |
|||
|
|||
private int blockStart; |
|||
|
|||
/// <summary>
|
|||
/// Points to the current character in the window.
|
|||
/// </summary>
|
|||
private int strstart; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
private int lookahead; |
|||
|
|||
/// <summary>
|
|||
/// This array contains the part of the uncompressed stream that
|
|||
/// is of relevance. The current character is indexed by strstart.
|
|||
/// </summary>
|
|||
private byte[] window; |
|||
|
|||
private int maxChain; |
|||
|
|||
private int maxLazy; |
|||
|
|||
private int niceLength; |
|||
|
|||
private int goodLength; |
|||
|
|||
/// <summary>
|
|||
/// The current compression function.
|
|||
/// </summary>
|
|||
private int compressionFunction; |
|||
|
|||
/// <summary>
|
|||
/// The input data for compression.
|
|||
/// </summary>
|
|||
private byte[] inputBuf; |
|||
|
|||
/// <summary>
|
|||
/// The total bytes of input read.
|
|||
/// </summary>
|
|||
private long totalIn; |
|||
|
|||
/// <summary>
|
|||
/// The offset into inputBuf, where input data starts.
|
|||
/// </summary>
|
|||
private int inputOff; |
|||
|
|||
/// <summary>
|
|||
/// The end offset of the input data.
|
|||
/// </summary>
|
|||
private int inputEnd; |
|||
|
|||
private DeflaterPending pending; |
|||
|
|||
private DeflaterHuffman huffman; |
|||
|
|||
/// <summary>
|
|||
/// The adler checksum
|
|||
/// </summary>
|
|||
private Adler32 adler; |
|||
} |
|||
} |
|||
@ -0,0 +1,958 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// This is the DeflaterHuffman class.
|
|||
///
|
|||
/// This class is <i>not</i> thread safe. This is inherent in the API, due
|
|||
/// to the split of Deflate and SetInput.
|
|||
///
|
|||
/// author of the original java version : Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class DeflaterHuffman |
|||
{ |
|||
const int BUFSIZE = 1 << (DeflaterConstants.DEFAULT_MEM_LEVEL + 6); |
|||
const int LITERAL_NUM = 286; |
|||
|
|||
// Number of distance codes
|
|||
const int DIST_NUM = 30; |
|||
// Number of codes used to transfer bit lengths
|
|||
const int BITLEN_NUM = 19; |
|||
|
|||
// repeat previous bit length 3-6 times (2 bits of repeat count)
|
|||
const int REP_3_6 = 16; |
|||
// repeat a zero length 3-10 times (3 bits of repeat count)
|
|||
const int REP_3_10 = 17; |
|||
// repeat a zero length 11-138 times (7 bits of repeat count)
|
|||
const int REP_11_138 = 18; |
|||
|
|||
const int EOF_SYMBOL = 256; |
|||
|
|||
// The lengths of the bit length codes are sent in order of decreasing
|
|||
// probability, to avoid transmitting the lengths for unused bit length codes.
|
|||
static readonly int[] BL_ORDER = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; |
|||
|
|||
static readonly byte[] bit4Reverse = |
|||
{ |
|||
0, |
|||
8, |
|||
4, |
|||
12, |
|||
2, |
|||
10, |
|||
6, |
|||
14, |
|||
1, |
|||
9, |
|||
5, |
|||
13, |
|||
3, |
|||
11, |
|||
7, |
|||
15 |
|||
}; |
|||
|
|||
static short[] staticLCodes; |
|||
static byte[] staticLLength; |
|||
static short[] staticDCodes; |
|||
static byte[] staticDLength; |
|||
|
|||
class Tree |
|||
{ |
|||
#region Instance Fields
|
|||
public short[] freqs; |
|||
|
|||
public byte[] length; |
|||
|
|||
public int minNumCodes; |
|||
|
|||
public int numCodes; |
|||
|
|||
short[] codes; |
|||
int[] bl_counts; |
|||
int maxLength; |
|||
DeflaterHuffman dh; |
|||
#endregion
|
|||
|
|||
#region Constructors
|
|||
public Tree(DeflaterHuffman dh, int elems, int minCodes, int maxLength) |
|||
{ |
|||
this.dh = dh; |
|||
this.minNumCodes = minCodes; |
|||
this.maxLength = maxLength; |
|||
freqs = new short[elems]; |
|||
bl_counts = new int[maxLength]; |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Resets the internal state of the tree
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
for (int i = 0; i < freqs.Length; i++) |
|||
{ |
|||
freqs[i] = 0; |
|||
} |
|||
codes = null; |
|||
length = null; |
|||
} |
|||
|
|||
public void WriteSymbol(int code) |
|||
{ |
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// freqs[code]--;
|
|||
// // Console.Write("writeSymbol("+freqs.length+","+code+"): ");
|
|||
// }
|
|||
dh.pending.WriteBits(codes[code] & 0xffff, length[code]); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Check that all frequencies are zero
|
|||
/// </summary>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// At least one frequency is non-zero
|
|||
/// </exception>
|
|||
public void CheckEmpty() |
|||
{ |
|||
bool empty = true; |
|||
for (int i = 0; i < freqs.Length; i++) |
|||
{ |
|||
if (freqs[i] != 0) |
|||
{ |
|||
//Console.WriteLine("freqs[" + i + "] == " + freqs[i]);
|
|||
empty = false; |
|||
} |
|||
} |
|||
|
|||
if (!empty) |
|||
{ |
|||
throw new InvalidOperationException("!Empty"); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Set static codes and length
|
|||
/// </summary>
|
|||
/// <param name="staticCodes">new codes</param>
|
|||
/// <param name="staticLengths">length for new codes</param>
|
|||
public void SetStaticCodes(short[] staticCodes, byte[] staticLengths) |
|||
{ |
|||
codes = staticCodes; |
|||
length = staticLengths; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Build dynamic codes and lengths
|
|||
/// </summary>
|
|||
public void BuildCodes() |
|||
{ |
|||
int numSymbols = freqs.Length; |
|||
int[] nextCode = new int[maxLength]; |
|||
int code = 0; |
|||
|
|||
codes = new short[freqs.Length]; |
|||
|
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("buildCodes: "+freqs.Length);
|
|||
// }
|
|||
|
|||
for (int bits = 0; bits < maxLength; bits++) |
|||
{ |
|||
nextCode[bits] = code; |
|||
code += bl_counts[bits] << (15 - bits); |
|||
|
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("bits: " + ( bits + 1) + " count: " + bl_counts[bits]
|
|||
// +" nextCode: "+code);
|
|||
// }
|
|||
} |
|||
|
|||
#if DebugDeflation
|
|||
if ( DeflaterConstants.DEBUGGING && (code != 65536) ) |
|||
{ |
|||
throw new ImageFormatException("Inconsistent bl_counts!"); |
|||
} |
|||
#endif
|
|||
for (int i = 0; i < numCodes; i++) |
|||
{ |
|||
int bits = length[i]; |
|||
if (bits > 0) |
|||
{ |
|||
|
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("codes["+i+"] = rev(" + nextCode[bits-1]+"),
|
|||
// +bits);
|
|||
// }
|
|||
|
|||
codes[i] = BitReverse(nextCode[bits - 1]); |
|||
nextCode[bits - 1] += 1 << (16 - bits); |
|||
} |
|||
} |
|||
} |
|||
|
|||
public 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 ImageFormatException("Heap invariant violated"); |
|||
} |
|||
|
|||
BuildLength(childs); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get encoded length
|
|||
/// </summary>
|
|||
/// <returns>Encoded length, the sum of frequencies * lengths</returns>
|
|||
public int GetEncodedLength() |
|||
{ |
|||
int len = 0; |
|||
for (int i = 0; i < freqs.Length; i++) |
|||
{ |
|||
len += freqs[i] * length[i]; |
|||
} |
|||
return len; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Scan a literal or distance tree to determine the frequencies of the codes
|
|||
/// in the bit length tree.
|
|||
/// </summary>
|
|||
public 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] += (short)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]++; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write tree values
|
|||
/// </summary>
|
|||
/// <param name="blTree">Tree to write</param>
|
|||
public 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); |
|||
dh.pending.WriteBits(count - 3, 2); |
|||
} |
|||
else if (count <= 10) |
|||
{ |
|||
blTree.WriteSymbol(REP_3_10); |
|||
dh.pending.WriteBits(count - 3, 3); |
|||
} |
|||
else |
|||
{ |
|||
blTree.WriteSymbol(REP_11_138); |
|||
dh.pending.WriteBits(count - 11, 7); |
|||
} |
|||
} |
|||
} |
|||
|
|||
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) {
|
|||
// //Console.WriteLine("Tree "+freqs.Length+" lengths:");
|
|||
// for (int i=0; i < numLeafs; i++) {
|
|||
// //Console.WriteLine("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
|
|||
// number 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) {
|
|||
// //Console.WriteLine("*** After overflow elimination. ***");
|
|||
// for (int i=0; i < numLeafs; i++) {
|
|||
// //Console.WriteLine("Node "+childs[2*i]+" freq: "+freqs[childs[2*i]]
|
|||
// + " len: "+length[childs[2*i]]);
|
|||
// }
|
|||
// }
|
|||
} |
|||
|
|||
} |
|||
|
|||
#region Instance Fields
|
|||
/// <summary>
|
|||
/// Pending buffer to use
|
|||
/// </summary>
|
|||
public DeflaterPending pending; |
|||
|
|||
Tree literalTree; |
|||
Tree distTree; |
|||
Tree blTree; |
|||
|
|||
// Buffer for distances
|
|||
short[] d_buf; |
|||
byte[] l_buf; |
|||
int last_lit; |
|||
int extra_bits; |
|||
#endregion
|
|||
|
|||
static DeflaterHuffman() |
|||
{ |
|||
// 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; |
|||
} |
|||
|
|||
// Distance 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; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Construct instance with pending buffer
|
|||
/// </summary>
|
|||
/// <param name="pending">Pending buffer to use</param>
|
|||
public DeflaterHuffman(DeflaterPending pending) |
|||
{ |
|||
this.pending = pending; |
|||
|
|||
literalTree = new Tree(this, LITERAL_NUM, 257, 15); |
|||
distTree = new Tree(this, DIST_NUM, 1, 15); |
|||
blTree = new Tree(this, BITLEN_NUM, 4, 7); |
|||
|
|||
d_buf = new short[BUFSIZE]; |
|||
l_buf = new byte[BUFSIZE]; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reset internal state
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
last_lit = 0; |
|||
extra_bits = 0; |
|||
literalTree.Reset(); |
|||
distTree.Reset(); |
|||
blTree.Reset(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write all trees to pending buffer
|
|||
/// </summary>
|
|||
/// <param name="blTreeCodes">The number/rank of treecodes to send.</param>
|
|||
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 DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING) { |
|||
blTree.CheckEmpty(); |
|||
} |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Compress current buffer writing data to pending buffer
|
|||
/// </summary>
|
|||
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) {
|
|||
// Console.Write("["+(dist+1)+","+(litlen+3)+"]: ");
|
|||
// }
|
|||
|
|||
int lc = Lcode(litlen); |
|||
literalTree.WriteSymbol(lc); |
|||
|
|||
int bits = (lc - 261) / 4; |
|||
if (bits > 0 && bits <= 5) |
|||
{ |
|||
pending.WriteBits(litlen & ((1 << bits) - 1), bits); |
|||
} |
|||
|
|||
int dc = Dcode(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) {
|
|||
// Console.Write("("+(char)litlen+"): ");
|
|||
// } else {
|
|||
// Console.Write("{"+litlen+"}: ");
|
|||
// }
|
|||
// }
|
|||
literalTree.WriteSymbol(litlen); |
|||
} |
|||
} |
|||
|
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING) { |
|||
Console.Write("EOF: "); |
|||
} |
|||
#endif
|
|||
literalTree.WriteSymbol(EOF_SYMBOL); |
|||
|
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING) { |
|||
literalTree.CheckEmpty(); |
|||
distTree.CheckEmpty(); |
|||
} |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Flush block to output with no compression
|
|||
/// </summary>
|
|||
/// <param name="stored">Data to write</param>
|
|||
/// <param name="storedOffset">Index of first byte to write</param>
|
|||
/// <param name="storedLength">Count of bytes to write</param>
|
|||
/// <param name="lastBlock">True if this is the last block</param>
|
|||
public void FlushStoredBlock(byte[] stored, int storedOffset, int storedLength, bool lastBlock) |
|||
{ |
|||
#if DebugDeflation
|
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("Flushing stored block "+ storedLength);
|
|||
// }
|
|||
#endif
|
|||
pending.WriteBits((DeflaterConstants.STORED_BLOCK << 1) + (lastBlock ? 1 : 0), 3); |
|||
pending.AlignToByte(); |
|||
pending.WriteShort(storedLength); |
|||
pending.WriteShort(~storedLength); |
|||
pending.WriteBlock(stored, storedOffset, storedLength); |
|||
Reset(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Flush block to output with compression
|
|||
/// </summary>
|
|||
/// <param name="stored">Data to flush</param>
|
|||
/// <param name="storedOffset">Index of first byte to flush</param>
|
|||
/// <param name="storedLength">Count of bytes to flush</param>
|
|||
/// <param name="lastBlock">True if this is the last block</param>
|
|||
public void FlushBlock(byte[] stored, int storedOffset, int storedLength, bool 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 (storedOffset >= 0 && storedLength + 4 < opt_len >> 3) |
|||
{ |
|||
// Store Block
|
|||
|
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("Storing, since " + storedLength + " < " + opt_len
|
|||
// + " <= " + static_len);
|
|||
// }
|
|||
FlushStoredBlock(stored, storedOffset, storedLength, 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(); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get value indicating if internal buffer is full
|
|||
/// </summary>
|
|||
/// <returns>true if buffer is full</returns>
|
|||
public bool IsFull() |
|||
{ |
|||
return last_lit >= BUFSIZE; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add literal to buffer
|
|||
/// </summary>
|
|||
/// <param name="literal">Literal value to add to buffer.</param>
|
|||
/// <returns>Value indicating internal buffer is full</returns>
|
|||
public bool TallyLit(int literal) |
|||
{ |
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// if (lit > 32 && lit < 127) {
|
|||
// //Console.WriteLine("("+(char)lit+")");
|
|||
// } else {
|
|||
// //Console.WriteLine("{"+lit+"}");
|
|||
// }
|
|||
// }
|
|||
d_buf[last_lit] = 0; |
|||
l_buf[last_lit++] = (byte)literal; |
|||
literalTree.freqs[literal]++; |
|||
return IsFull(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add distance code and length to literal and distance trees
|
|||
/// </summary>
|
|||
/// <param name="distance">Distance code</param>
|
|||
/// <param name="length">Length</param>
|
|||
/// <returns>Value indicating if internal buffer is full</returns>
|
|||
public bool TallyDist(int distance, int length) |
|||
{ |
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("[" + distance + "," + length + "]");
|
|||
// }
|
|||
|
|||
d_buf[last_lit] = (short)distance; |
|||
l_buf[last_lit++] = (byte)(length - 3); |
|||
|
|||
int lc = Lcode(length - 3); |
|||
literalTree.freqs[lc]++; |
|||
if (lc >= 265 && lc < 285) |
|||
{ |
|||
extra_bits += (lc - 261) / 4; |
|||
} |
|||
|
|||
int dc = Dcode(distance - 1); |
|||
distTree.freqs[dc]++; |
|||
if (dc >= 4) |
|||
{ |
|||
extra_bits += dc / 2 - 1; |
|||
} |
|||
return IsFull(); |
|||
} |
|||
|
|||
|
|||
/// <summary>
|
|||
/// Reverse the bits of a 16 bit value.
|
|||
/// </summary>
|
|||
/// <param name="toReverse">Value to reverse bits</param>
|
|||
/// <returns>Value with bits reversed</returns>
|
|||
public static short BitReverse(int toReverse) |
|||
{ |
|||
return (short)(bit4Reverse[toReverse & 0xF] << 12 | |
|||
bit4Reverse[(toReverse >> 4) & 0xF] << 8 | |
|||
bit4Reverse[(toReverse >> 8) & 0xF] << 4 | |
|||
bit4Reverse[toReverse >> 12]); |
|||
} |
|||
|
|||
static int Lcode(int length) |
|||
{ |
|||
if (length == 255) |
|||
{ |
|||
return 285; |
|||
} |
|||
|
|||
int code = 257; |
|||
while (length >= 8) |
|||
{ |
|||
code += 4; |
|||
length >>= 1; |
|||
} |
|||
return code + length; |
|||
} |
|||
|
|||
static int Dcode(int distance) |
|||
{ |
|||
int code = 0; |
|||
while (distance >= 4) |
|||
{ |
|||
code += 2; |
|||
distance >>= 1; |
|||
} |
|||
return code + distance; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,577 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
using System.IO; |
|||
|
|||
/// <summary>
|
|||
/// A special stream deflating or compressing the bytes that are
|
|||
/// written to it. It uses a Deflater to perform actual deflating.<br/>
|
|||
/// Authors of the original java version : Tom Tromey, Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class DeflaterOutputStream : Stream |
|||
{ |
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Creates a new DeflaterOutputStream with a default Deflater and default buffer size.
|
|||
/// </summary>
|
|||
/// <param name="baseOutputStream">
|
|||
/// the output stream where deflated output should be written.
|
|||
/// </param>
|
|||
public DeflaterOutputStream(Stream baseOutputStream) |
|||
: this(baseOutputStream, new Deflater(), 512) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Creates a new DeflaterOutputStream with the given Deflater and
|
|||
/// default buffer size.
|
|||
/// </summary>
|
|||
/// <param name="baseOutputStream">
|
|||
/// the output stream where deflated output should be written.
|
|||
/// </param>
|
|||
/// <param name="deflater">
|
|||
/// the underlying deflater.
|
|||
/// </param>
|
|||
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater) |
|||
: this(baseOutputStream, deflater, 512) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Creates a new DeflaterOutputStream with the given Deflater and
|
|||
/// buffer size.
|
|||
/// </summary>
|
|||
/// <param name="baseOutputStream">
|
|||
/// The output stream where deflated output is written.
|
|||
/// </param>
|
|||
/// <param name="deflater">
|
|||
/// The underlying deflater to use
|
|||
/// </param>
|
|||
/// <param name="bufferSize">
|
|||
/// The buffer size in bytes to use when deflating (minimum value 512)
|
|||
/// </param>
|
|||
/// <exception cref="ArgumentOutOfRangeException">
|
|||
/// bufsize is less than or equal to zero.
|
|||
/// </exception>
|
|||
/// <exception cref="ArgumentException">
|
|||
/// baseOutputStream does not support writing
|
|||
/// </exception>
|
|||
/// <exception cref="ArgumentNullException">
|
|||
/// deflater instance is null
|
|||
/// </exception>
|
|||
public DeflaterOutputStream(Stream baseOutputStream, Deflater deflater, int bufferSize) |
|||
{ |
|||
if (baseOutputStream == null) |
|||
{ |
|||
throw new ArgumentNullException("baseOutputStream"); |
|||
} |
|||
|
|||
if (baseOutputStream.CanWrite == false) |
|||
{ |
|||
throw new ArgumentException("Must support writing", "baseOutputStream"); |
|||
} |
|||
|
|||
if (deflater == null) |
|||
{ |
|||
throw new ArgumentNullException("deflater"); |
|||
} |
|||
|
|||
if (bufferSize < 512) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("bufferSize"); |
|||
} |
|||
|
|||
baseOutputStream_ = baseOutputStream; |
|||
buffer_ = new byte[bufferSize]; |
|||
deflater_ = deflater; |
|||
} |
|||
#endregion
|
|||
|
|||
#region Public API
|
|||
/// <summary>
|
|||
/// Finishes the stream by calling finish() on the deflater.
|
|||
/// </summary>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// Not all input is deflated
|
|||
/// </exception>
|
|||
public virtual void Finish() |
|||
{ |
|||
deflater_.Finish(); |
|||
while (!deflater_.IsFinished) |
|||
{ |
|||
int len = deflater_.Deflate(buffer_, 0, buffer_.Length); |
|||
if (len <= 0) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (keys != null) |
|||
{ |
|||
EncryptBlock(buffer_, 0, len); |
|||
} |
|||
|
|||
baseOutputStream_.Write(buffer_, 0, len); |
|||
} |
|||
|
|||
if (!deflater_.IsFinished) |
|||
{ |
|||
throw new ImageFormatException("Can't deflate all input?"); |
|||
} |
|||
|
|||
baseOutputStream_.Flush(); |
|||
|
|||
if (keys != null) |
|||
{ |
|||
keys = null; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get/set flag indicating ownership of the underlying stream.
|
|||
/// When the flag is true <see cref="Dispose"></see> will close the underlying stream also.
|
|||
/// </summary>
|
|||
public bool IsStreamOwner |
|||
{ |
|||
get { return isStreamOwner_; } |
|||
set { isStreamOwner_ = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Allows client to determine if an entry can be patched after its added
|
|||
/// </summary>
|
|||
public bool CanPatchEntries |
|||
{ |
|||
get |
|||
{ |
|||
return baseOutputStream_.CanSeek; |
|||
} |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
#region Encryption
|
|||
|
|||
string password; |
|||
|
|||
uint[] keys; |
|||
|
|||
/// <summary>
|
|||
/// Get/set the password used for encryption.
|
|||
/// </summary>
|
|||
/// <remarks>When set to null or if the password is empty no encryption is performed</remarks>
|
|||
public string Password |
|||
{ |
|||
get |
|||
{ |
|||
return password; |
|||
} |
|||
set |
|||
{ |
|||
if ((value != null) && (value.Length == 0)) |
|||
{ |
|||
password = null; |
|||
} |
|||
else |
|||
{ |
|||
password = value; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Encrypt a block of data
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// Data to encrypt. NOTE the original contents of the buffer are lost
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// Offset of first byte in buffer to encrypt
|
|||
/// </param>
|
|||
/// <param name="length">
|
|||
/// Number of bytes in buffer to encrypt
|
|||
/// </param>
|
|||
protected void EncryptBlock(byte[] buffer, int offset, int length) |
|||
{ |
|||
for (int i = offset; i < offset + length; ++i) |
|||
{ |
|||
byte oldbyte = buffer[i]; |
|||
buffer[i] ^= EncryptByte(); |
|||
UpdateKeys(oldbyte); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initializes encryption keys based on given <paramref name="password"/>.
|
|||
/// </summary>
|
|||
/// <param name="password">The password.</param>
|
|||
protected void InitializePassword(string password) |
|||
{ |
|||
keys = new uint[] { |
|||
0x12345678, |
|||
0x23456789, |
|||
0x34567890 |
|||
}; |
|||
|
|||
byte[] rawPassword = ZipConstants.ConvertToArray(password); |
|||
|
|||
for (int i = 0; i < rawPassword.Length; ++i) |
|||
{ |
|||
UpdateKeys((byte)rawPassword[i]); |
|||
} |
|||
} |
|||
|
|||
#if !NET_1_1 && !NETCF_2_0 && !NOCRYPTO
|
|||
/// <summary>
|
|||
/// Initializes encryption keys based on given password.
|
|||
/// </summary>
|
|||
protected void InitializeAESPassword(ZipEntry entry, string rawPassword, |
|||
out byte[] salt, out byte[] pwdVerifier) { |
|||
salt = new byte[entry.AESSaltLen]; |
|||
// Salt needs to be cryptographically random, and unique per file
|
|||
if (_aesRnd == null) |
|||
_aesRnd = new RNGCryptoServiceProvider(); |
|||
_aesRnd.GetBytes(salt); |
|||
int blockSize = entry.AESKeySize / 8; // bits to bytes
|
|||
|
|||
cryptoTransform_ = new ZipAESTransform(rawPassword, salt, blockSize, true); |
|||
pwdVerifier = ((ZipAESTransform)cryptoTransform_).PwdVerifier; |
|||
} |
|||
#endif
|
|||
|
|||
#if NETCF_1_0 || NOCRYPTO
|
|||
|
|||
/// <summary>
|
|||
/// Encrypt a single byte
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// The encrypted value
|
|||
/// </returns>
|
|||
protected byte EncryptByte() |
|||
{ |
|||
uint temp = ((keys[2] & 0xFFFF) | 2); |
|||
return (byte)((temp * (temp ^ 1)) >> 8); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Update encryption keys
|
|||
/// </summary>
|
|||
protected void UpdateKeys(byte ch) |
|||
{ |
|||
keys[0] = Crc32.ComputeCrc32(keys[0], ch); |
|||
keys[1] = keys[1] + (byte)keys[0]; |
|||
keys[1] = keys[1] * 134775813 + 1; |
|||
keys[2] = Crc32.ComputeCrc32(keys[2], (byte)(keys[1] >> 24)); |
|||
} |
|||
#endif
|
|||
|
|||
#endregion
|
|||
|
|||
#region Deflation Support
|
|||
/// <summary>
|
|||
/// Deflates everything in the input buffers. This will call
|
|||
/// <code>def.deflate()</code> until all bytes from the input buffers
|
|||
/// are processed.
|
|||
/// </summary>
|
|||
protected void Deflate() |
|||
{ |
|||
while (!deflater_.IsNeedingInput) |
|||
{ |
|||
int deflateCount = deflater_.Deflate(buffer_, 0, buffer_.Length); |
|||
|
|||
if (deflateCount <= 0) |
|||
{ |
|||
break; |
|||
} |
|||
#if NETCF_1_0 || NOCRYPTO
|
|||
if (keys != null) |
|||
#else
|
|||
if (cryptoTransform_ != null) |
|||
#endif
|
|||
{ |
|||
EncryptBlock(buffer_, 0, deflateCount); |
|||
} |
|||
|
|||
baseOutputStream_.Write(buffer_, 0, deflateCount); |
|||
} |
|||
|
|||
if (!deflater_.IsNeedingInput) |
|||
{ |
|||
throw new ImageFormatException("DeflaterOutputStream can't deflate all input?"); |
|||
} |
|||
} |
|||
#endregion
|
|||
|
|||
#region Stream Overrides
|
|||
/// <summary>
|
|||
/// Gets value indicating stream can be read from
|
|||
/// </summary>
|
|||
public override bool CanRead |
|||
{ |
|||
get |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating if seeking is supported for this stream
|
|||
/// This property always returns false
|
|||
/// </summary>
|
|||
public override bool CanSeek |
|||
{ |
|||
get |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get value indicating if this stream supports writing
|
|||
/// </summary>
|
|||
public override bool CanWrite |
|||
{ |
|||
get |
|||
{ |
|||
return baseOutputStream_.CanWrite; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get current length of stream
|
|||
/// </summary>
|
|||
public override long Length |
|||
{ |
|||
get |
|||
{ |
|||
return baseOutputStream_.Length; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the current position within the stream.
|
|||
/// </summary>
|
|||
/// <exception cref="NotSupportedException">Any attempt to set position</exception>
|
|||
public override long Position |
|||
{ |
|||
get |
|||
{ |
|||
return baseOutputStream_.Position; |
|||
} |
|||
set |
|||
{ |
|||
throw new NotSupportedException("Position property not supported"); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the current position of this stream to the given value. Not supported by this class!
|
|||
/// </summary>
|
|||
/// <param name="offset">The offset relative to the <paramref name="origin"/> to seek.</param>
|
|||
/// <param name="origin">The <see cref="SeekOrigin"/> 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("DeflaterOutputStream Seek not supported"); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the length of this stream to the given value. Not supported by this class!
|
|||
/// </summary>
|
|||
/// <param name="value">The new stream length.</param>
|
|||
/// <exception cref="NotSupportedException">Any access</exception>
|
|||
public override void SetLength(long value) |
|||
{ |
|||
throw new NotSupportedException("DeflaterOutputStream SetLength not supported"); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read a byte from stream advancing position by one
|
|||
/// </summary>
|
|||
/// <returns>The byte read cast to an int. THe value is -1 if at the end of the stream.</returns>
|
|||
/// <exception cref="NotSupportedException">Any access</exception>
|
|||
public override int ReadByte() |
|||
{ |
|||
throw new NotSupportedException("DeflaterOutputStream ReadByte not supported"); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read a block of bytes from stream
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to store read data in.</param>
|
|||
/// <param name="offset">The offset to start storing at.</param>
|
|||
/// <param name="count">The maximum number of bytes to read.</param>
|
|||
/// <returns>The actual number of bytes read. Zero if end of stream is detected.</returns>
|
|||
/// <exception cref="NotSupportedException">Any access</exception>
|
|||
public override int Read(byte[] buffer, int offset, int count) |
|||
{ |
|||
throw new NotSupportedException("DeflaterOutputStream Read not supported"); |
|||
} |
|||
#if !PCL
|
|||
/// <summary>
|
|||
/// Asynchronous reads are not supported a NotSupportedException is always thrown
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to read into.</param>
|
|||
/// <param name="offset">The offset to start storing data at.</param>
|
|||
/// <param name="count">The number of bytes to read</param>
|
|||
/// <param name="callback">The async callback to use.</param>
|
|||
/// <param name="state">The state to use.</param>
|
|||
/// <returns>Returns an <see cref="IAsyncResult"/></returns>
|
|||
/// <exception cref="NotSupportedException">Any access</exception>
|
|||
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) |
|||
{ |
|||
throw new NotSupportedException("DeflaterOutputStream BeginRead not currently supported"); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Asynchronous writes arent supported, a NotSupportedException is always thrown
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to write.</param>
|
|||
/// <param name="offset">The offset to begin writing at.</param>
|
|||
/// <param name="count">The number of bytes to write.</param>
|
|||
/// <param name="callback">The <see cref="AsyncCallback"/> to use.</param>
|
|||
/// <param name="state">The state object.</param>
|
|||
/// <returns>Returns an IAsyncResult.</returns>
|
|||
/// <exception cref="NotSupportedException">Any access</exception>
|
|||
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state) |
|||
{ |
|||
throw new NotSupportedException("BeginWrite is not supported"); |
|||
} |
|||
#endif
|
|||
/// <summary>
|
|||
/// Flushes the stream by calling <see cref="DeflaterOutputStream.Flush">Flush</see> on the deflater and then
|
|||
/// on the underlying stream. This ensures that all bytes are flushed.
|
|||
/// </summary>
|
|||
public override void Flush() |
|||
{ |
|||
deflater_.Flush(); |
|||
Deflate(); |
|||
baseOutputStream_.Flush(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calls <see cref="Finish"/> and closes the underlying
|
|||
/// stream when <see cref="IsStreamOwner"></see> is true.
|
|||
/// </summary>
|
|||
#if !PCL
|
|||
public override void Close() |
|||
{ |
|||
if (!isClosed_) |
|||
{ |
|||
isClosed_ = true; |
|||
|
|||
try { |
|||
Finish(); |
|||
#if NETCF_1_0 || NOCRYPTO
|
|||
keys =null; |
|||
#else
|
|||
if ( cryptoTransform_ != null ) { |
|||
GetAuthCodeIfAES(); |
|||
cryptoTransform_.Dispose(); |
|||
cryptoTransform_ = null; |
|||
} |
|||
#endif
|
|||
} |
|||
finally { |
|||
if( isStreamOwner_ ) { |
|||
baseOutputStream_.Close(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
#else
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
base.Dispose(disposing); |
|||
if (disposing && !isClosed_) |
|||
{ |
|||
isClosed_ = true; |
|||
|
|||
try |
|||
{ |
|||
Finish(); |
|||
keys = null; |
|||
} |
|||
finally |
|||
{ |
|||
if (isStreamOwner_) |
|||
{ |
|||
baseOutputStream_.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
#endif
|
|||
|
|||
private void GetAuthCodeIfAES() |
|||
{ |
|||
#if !NET_1_1 && !NETCF_2_0 && !NOCRYPTO
|
|||
if (cryptoTransform_ is ZipAESTransform) { |
|||
AESAuthCode = ((ZipAESTransform)cryptoTransform_).GetAuthCode(); |
|||
} |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes a single byte to the compressed output stream.
|
|||
/// </summary>
|
|||
/// <param name="value">
|
|||
/// The byte value.
|
|||
/// </param>
|
|||
public override void WriteByte(byte value) |
|||
{ |
|||
byte[] b = new byte[1]; |
|||
b[0] = value; |
|||
Write(b, 0, 1); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Writes bytes from an array to the compressed stream.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// The byte array
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// The offset into the byte array where to start.
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// The number of bytes to write.
|
|||
/// </param>
|
|||
public override void Write(byte[] buffer, int offset, int count) |
|||
{ |
|||
deflater_.SetInput(buffer, offset, count); |
|||
Deflate(); |
|||
} |
|||
#endregion
|
|||
|
|||
#region Instance Fields
|
|||
/// <summary>
|
|||
/// This buffer is used temporarily to retrieve the bytes from the
|
|||
/// deflater and write them to the underlying output stream.
|
|||
/// </summary>
|
|||
byte[] buffer_; |
|||
|
|||
/// <summary>
|
|||
/// The deflater which is used to deflate the stream.
|
|||
/// </summary>
|
|||
protected Deflater deflater_; |
|||
|
|||
/// <summary>
|
|||
/// Base stream the deflater depends on.
|
|||
/// </summary>
|
|||
protected Stream baseOutputStream_; |
|||
|
|||
bool isClosed_; |
|||
|
|||
bool isStreamOwner_ = true; |
|||
#endregion
|
|||
|
|||
#region Static Fields
|
|||
|
|||
#if !NET_1_1 && !NETCF_2_0 && !NOCRYPTO
|
|||
// Static to help ensure that multiple files within a zip will get different random salt
|
|||
private static RNGCryptoServiceProvider _aesRnd; |
|||
#endif
|
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,19 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
/// <summary>
|
|||
/// This class stores the pending output of the Deflater.
|
|||
///
|
|||
/// author of the original java version : Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class DeflaterPending : PendingBuffer |
|||
{ |
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="DeflaterPending"/> class.
|
|||
/// Construct instance with default buffer size
|
|||
/// </summary>
|
|||
public DeflaterPending() |
|||
: base(DeflaterConstants.PENDING_BUF_SIZE) |
|||
{ |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,92 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// Defines the contents of the general bit flags field for an archive entry.
|
|||
/// </summary>
|
|||
[Flags] |
|||
public enum GeneralBitFlags |
|||
{ |
|||
/// <summary>
|
|||
/// Bit 0 if set indicates that the file is encrypted
|
|||
/// </summary>
|
|||
Encrypted = 0x0001, |
|||
|
|||
/// <summary>
|
|||
/// Bits 1 and 2 - Two bits defining the compression method (only for Method 6 Imploding and 8,9 Deflating)
|
|||
/// </summary>
|
|||
Method = 0x0006, |
|||
|
|||
/// <summary>
|
|||
/// Bit 3 if set indicates a trailing data desciptor is appended to the entry data
|
|||
/// </summary>
|
|||
Descriptor = 0x0008, |
|||
|
|||
/// <summary>
|
|||
/// Bit 4 is reserved for use with method 8 for enhanced deflation
|
|||
/// </summary>
|
|||
ReservedPKware4 = 0x0010, |
|||
|
|||
/// <summary>
|
|||
/// Bit 5 if set indicates the file contains Pkzip compressed patched data.
|
|||
/// Requires version 2.7 or greater.
|
|||
/// </summary>
|
|||
Patched = 0x0020, |
|||
|
|||
/// <summary>
|
|||
/// Bit 6 if set indicates strong encryption has been used for this entry.
|
|||
/// </summary>
|
|||
StrongEncryption = 0x0040, |
|||
|
|||
/// <summary>
|
|||
/// Bit 7 is currently unused
|
|||
/// </summary>
|
|||
Unused7 = 0x0080, |
|||
|
|||
/// <summary>
|
|||
/// Bit 8 is currently unused
|
|||
/// </summary>
|
|||
Unused8 = 0x0100, |
|||
|
|||
/// <summary>
|
|||
/// Bit 9 is currently unused
|
|||
/// </summary>
|
|||
Unused9 = 0x0200, |
|||
|
|||
/// <summary>
|
|||
/// Bit 10 is currently unused
|
|||
/// </summary>
|
|||
Unused10 = 0x0400, |
|||
|
|||
/// <summary>
|
|||
/// Bit 11 if set indicates the filename and
|
|||
/// comment fields for this file must be encoded using UTF-8.
|
|||
/// </summary>
|
|||
UnicodeText = 0x0800, |
|||
|
|||
/// <summary>
|
|||
/// Bit 12 is documented as being reserved by PKware for enhanced compression.
|
|||
/// </summary>
|
|||
EnhancedCompress = 0x1000, |
|||
|
|||
/// <summary>
|
|||
/// Bit 13 if set indicates that values in the local header are masked to hide
|
|||
/// their actual values, and the central directory is encrypted.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// Used when encrypting the central directory contents.
|
|||
/// </remarks>
|
|||
HeaderMasked = 0x2000, |
|||
|
|||
/// <summary>
|
|||
/// Bit 14 is documented as being reserved for use by PKware
|
|||
/// </summary>
|
|||
ReservedPkware14 = 0x4000, |
|||
|
|||
/// <summary>
|
|||
/// Bit 15 is documented as being reserved for use by PKware
|
|||
/// </summary>
|
|||
ReservedPkware15 = 0x8000 |
|||
} |
|||
} |
|||
@ -0,0 +1,60 @@ |
|||
// <copyright file="IChecksum.cs" company="James South">
|
|||
// Copyright © James South and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
// </copyright>
|
|||
|
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
public interface IChecksum |
|||
{ |
|||
/// <summary>
|
|||
/// Returns the data checksum computed so far.
|
|||
/// </summary>
|
|||
long Value |
|||
{ |
|||
get; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets the data checksum as if no update was ever called.
|
|||
/// </summary>
|
|||
void Reset(); |
|||
|
|||
/// <summary>
|
|||
/// Adds one byte to the data checksum.
|
|||
/// </summary>
|
|||
/// <param name = "value">
|
|||
/// the data value to add. The high byte of the int is ignored.
|
|||
/// </param>
|
|||
void Update(int value); |
|||
|
|||
/// <summary>
|
|||
/// Updates the data checksum with the bytes taken from the array.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// buffer an array of bytes
|
|||
/// </param>
|
|||
void Update(byte[] buffer); |
|||
|
|||
/// <summary>
|
|||
/// Adds the byte array to the data checksum.
|
|||
/// </summary>
|
|||
/// <param name = "buffer">
|
|||
/// The buffer which contains the data
|
|||
/// </param>
|
|||
/// <param name = "offset">
|
|||
/// The offset in the buffer where the data starts
|
|||
/// </param>
|
|||
/// <param name = "count">
|
|||
/// the number of data bytes to add.
|
|||
/// </param>
|
|||
void Update(byte[] buffer, int offset, int count); |
|||
} |
|||
} |
|||
@ -0,0 +1,872 @@ |
|||
namespace ImageProcessor.Formats { |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// Inflater is used to decompress data that has been compressed according
|
|||
/// to the "deflate" standard described in rfc1951.
|
|||
///
|
|||
/// By default Zlib (rfc1950) headers and footers are expected in the input.
|
|||
/// You can use constructor <code> public Inflater(bool noHeader)</code> passing true
|
|||
/// if there is no Zlib header information
|
|||
///
|
|||
/// 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>IsNeedingInput() returns true because the input buffer is empty.
|
|||
/// You have to provide more input with <code>SetInput()</code>.
|
|||
/// NOTE: IsNeedingInput() also returns true when, the stream is finished.
|
|||
/// </li>
|
|||
/// <li>IsNeedingDictionary() returns true, you have to provide a preset
|
|||
/// dictionary with <code>SetDictionary()</code>.</li>
|
|||
/// <li>IsFinished 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 of the original java version : John Leuner, Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class Inflater |
|||
{ |
|||
#region Constants/Readonly
|
|||
/// <summary>
|
|||
/// Copy lengths for literal codes 257..285
|
|||
/// </summary>
|
|||
static readonly 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 |
|||
}; |
|||
|
|||
/// <summary>
|
|||
/// Extra bits for literal codes 257..285
|
|||
/// </summary>
|
|||
static readonly 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 |
|||
}; |
|||
|
|||
/// <summary>
|
|||
/// Copy offsets for distance codes 0..29
|
|||
/// </summary>
|
|||
static readonly 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 |
|||
}; |
|||
|
|||
/// <summary>
|
|||
/// Extra bits for distance codes
|
|||
/// </summary>
|
|||
static readonly 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 |
|||
}; |
|||
|
|||
/// <summary>
|
|||
/// These are the possible states for an inflater
|
|||
/// </summary>
|
|||
const int DECODE_HEADER = 0; |
|||
const int DECODE_DICT = 1; |
|||
const int DECODE_BLOCKS = 2; |
|||
const int DECODE_STORED_LEN1 = 3; |
|||
const int DECODE_STORED_LEN2 = 4; |
|||
const int DECODE_STORED = 5; |
|||
const int DECODE_DYN_HEADER = 6; |
|||
const int DECODE_HUFFMAN = 7; |
|||
const int DECODE_HUFFMAN_LENBITS = 8; |
|||
const int DECODE_HUFFMAN_DIST = 9; |
|||
const int DECODE_HUFFMAN_DISTBITS = 10; |
|||
const int DECODE_CHKSUM = 11; |
|||
const int FINISHED = 12; |
|||
#endregion
|
|||
|
|||
#region Instance Fields
|
|||
/// <summary>
|
|||
/// This variable contains the current state.
|
|||
/// </summary>
|
|||
int mode; |
|||
|
|||
/// <summary>
|
|||
/// The adler checksum of the dictionary or of the decompressed
|
|||
/// stream, as it is written in the header resp. footer of the
|
|||
/// compressed stream.
|
|||
/// Only valid if mode is DECODE_DICT or DECODE_CHKSUM.
|
|||
/// </summary>
|
|||
int readAdler; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
int neededBits; |
|||
int repLength; |
|||
int repDist; |
|||
int uncomprLen; |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
bool isLastBlock; |
|||
|
|||
/// <summary>
|
|||
/// The total number of inflated bytes.
|
|||
/// </summary>
|
|||
long totalOut; |
|||
|
|||
/// <summary>
|
|||
/// The total number of bytes set with setInput(). This is not the
|
|||
/// value returned by the TotalIn property, since this also includes the
|
|||
/// unprocessed input.
|
|||
/// </summary>
|
|||
long totalIn; |
|||
|
|||
/// <summary>
|
|||
/// This variable stores the noHeader flag that was given to the constructor.
|
|||
/// True means, that the inflated stream doesn't contain a Zlib header or
|
|||
/// footer.
|
|||
/// </summary>
|
|||
bool noHeader; |
|||
|
|||
StreamManipulator input; |
|||
OutputWindow outputWindow; |
|||
InflaterDynHeader dynHeader; |
|||
InflaterHuffmanTree litlenTree, distTree; |
|||
Adler32 adler; |
|||
#endregion
|
|||
|
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Creates a new inflater or RFC1951 decompressor
|
|||
/// RFC1950/Zlib headers and footers will be expected in the input data
|
|||
/// </summary>
|
|||
public Inflater() : this(false) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Creates a new inflater.
|
|||
/// </summary>
|
|||
/// <param name="noHeader">
|
|||
/// True if no RFC1950/Zlib header and footer fields are expected in the input data
|
|||
///
|
|||
/// This is used for GZIPed/Zipped input.
|
|||
///
|
|||
/// For compatibility with
|
|||
/// Sun JDK you should provide one byte of input more than needed in
|
|||
/// this case.
|
|||
/// </param>
|
|||
public Inflater(bool noHeader) |
|||
{ |
|||
this.noHeader = noHeader; |
|||
this.adler = new Adler32(); |
|||
input = new StreamManipulator(); |
|||
outputWindow = new OutputWindow(); |
|||
mode = noHeader ? DECODE_BLOCKS : DECODE_HEADER; |
|||
} |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Resets the inflater so that a new stream can be decompressed. All
|
|||
/// pending input and output will be discarded.
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
mode = noHeader ? DECODE_BLOCKS : DECODE_HEADER; |
|||
totalIn = 0; |
|||
totalOut = 0; |
|||
input.Reset(); |
|||
outputWindow.Reset(); |
|||
dynHeader = null; |
|||
litlenTree = null; |
|||
distTree = null; |
|||
isLastBlock = false; |
|||
adler.Reset(); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes a zlib/RFC1950 header.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// False if more input is needed.
|
|||
/// </returns>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// The header is invalid.
|
|||
/// </exception>
|
|||
private bool DecodeHeader() |
|||
{ |
|||
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 ImageFormatException("Header checksum illegal"); |
|||
} |
|||
|
|||
if ((header & 0x0f00) != (Deflater.DEFLATED << 8)) |
|||
{ |
|||
throw new ImageFormatException("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; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the dictionary checksum after the deflate header.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// False if more input is needed.
|
|||
/// </returns>
|
|||
private bool 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; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the huffman encoded symbols in the input stream.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// false if more input is needed, true if output window is
|
|||
/// full or the current block ends.
|
|||
/// </returns>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// if deflated stream is invalid.
|
|||
/// </exception>
|
|||
private bool DecodeHuffman() |
|||
{ |
|||
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 (Exception) |
|||
{ |
|||
throw new ImageFormatException("Illegal rep length code"); |
|||
} |
|||
goto case DECODE_HUFFMAN_LENBITS; // 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; |
|||
goto case 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 (Exception) |
|||
{ |
|||
throw new ImageFormatException("Illegal rep dist code"); |
|||
} |
|||
|
|||
goto case DECODE_HUFFMAN_DISTBITS; // 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 ImageFormatException("Inflater unknown mode"); |
|||
} |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the adler checksum after the deflate stream.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// false if more input is needed.
|
|||
/// </returns>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// If checksum doesn't match.
|
|||
/// </exception>
|
|||
private bool DecodeChksum() |
|||
{ |
|||
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.Value != readAdler) |
|||
{ |
|||
throw new ImageFormatException("Adler chksum doesn't match: " + (int)adler.Value + " vs. " + readAdler); |
|||
} |
|||
|
|||
mode = FINISHED; |
|||
return false; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Decodes the deflated stream.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// false if more input is needed, or if finished.
|
|||
/// </returns>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// if deflated stream is invalid.
|
|||
/// </exception>
|
|||
private bool Decode() |
|||
{ |
|||
switch (mode) |
|||
{ |
|||
case DECODE_HEADER: |
|||
return DecodeHeader(); |
|||
|
|||
case DECODE_DICT: |
|||
return DecodeDict(); |
|||
|
|||
case DECODE_CHKSUM: |
|||
return DecodeChksum(); |
|||
|
|||
case DECODE_BLOCKS: |
|||
if (isLastBlock) |
|||
{ |
|||
if (noHeader) |
|||
{ |
|||
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 ImageFormatException("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; |
|||
} |
|||
goto case 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 ImageFormatException("broken uncompressed block"); |
|||
} |
|||
mode = DECODE_STORED; |
|||
} |
|||
goto case 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.IsNeedingInput; |
|||
} |
|||
|
|||
case DECODE_DYN_HEADER: |
|||
if (!dynHeader.Decode(input)) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
litlenTree = dynHeader.BuildLitLenTree(); |
|||
distTree = dynHeader.BuildDistTree(); |
|||
mode = DECODE_HUFFMAN; |
|||
goto case 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 ImageFormatException("Inflater.Decode unknown mode"); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// The dictionary.
|
|||
/// </param>
|
|||
public void SetDictionary(byte[] buffer) |
|||
{ |
|||
SetDictionary(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// The dictionary.
|
|||
/// </param>
|
|||
/// <param name="index">
|
|||
/// The index into buffer where the dictionary starts.
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// The number of bytes in the dictionary.
|
|||
/// </param>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// No dictionary is needed.
|
|||
/// </exception>
|
|||
/// <exception cref="ImageFormatException">
|
|||
/// The adler checksum for the buffer is invalid
|
|||
/// </exception>
|
|||
public void SetDictionary(byte[] buffer, int index, int count) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException(nameof(buffer)); |
|||
} |
|||
|
|||
if (index < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException(nameof(index)); |
|||
} |
|||
|
|||
if (count < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException(nameof(count)); |
|||
} |
|||
|
|||
if (!IsNeedingDictionary) |
|||
{ |
|||
throw new InvalidOperationException("Dictionary is not needed"); |
|||
} |
|||
|
|||
adler.Update(buffer, index, count); |
|||
|
|||
if ((int)adler.Value != readAdler) |
|||
{ |
|||
throw new ImageFormatException("Wrong adler checksum"); |
|||
} |
|||
adler.Reset(); |
|||
outputWindow.CopyDict(buffer, index, count); |
|||
mode = DECODE_BLOCKS; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the input. This should only be called, if needsInput()
|
|||
/// returns true.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// the input.
|
|||
/// </param>
|
|||
public void SetInput(byte[] buffer) |
|||
{ |
|||
SetInput(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Sets the input. This should only be called, if needsInput()
|
|||
/// returns true.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// The source of input data
|
|||
/// </param>
|
|||
/// <param name="index">
|
|||
/// The index into buffer where the input starts.
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// The number of bytes of input to use.
|
|||
/// </param>
|
|||
/// <exception cref="System.InvalidOperationException">
|
|||
/// No input is needed.
|
|||
/// </exception>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">
|
|||
/// The index and/or count are wrong.
|
|||
/// </exception>
|
|||
public void SetInput(byte[] buffer, int index, int count) |
|||
{ |
|||
input.SetInput(buffer, index, count); |
|||
totalIn += (long)count; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Inflates the compressed stream to the output buffer. If this
|
|||
/// returns 0, you should check, whether IsNeedingDictionary(),
|
|||
/// IsNeedingInput() or IsFinished() returns true, to determine why no
|
|||
/// further output is produced.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// the output buffer.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The number of bytes written to the buffer, 0 if no further
|
|||
/// output can be produced.
|
|||
/// </returns>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">
|
|||
/// if buffer has length 0.
|
|||
/// </exception>
|
|||
/// <exception cref="System.FormatException">
|
|||
/// if deflated stream is invalid.
|
|||
/// </exception>
|
|||
public int Inflate(byte[] buffer) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException(nameof(buffer)); |
|||
} |
|||
|
|||
return Inflate(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="buffer">
|
|||
/// the output buffer.
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// the offset in buffer where storing starts.
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// the maximum number of bytes to output.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// the number of bytes written to the buffer, 0 if no further output can be produced.
|
|||
/// </returns>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">
|
|||
/// if count is less than 0.
|
|||
/// </exception>
|
|||
/// <exception cref="System.ArgumentOutOfRangeException">
|
|||
/// if the index and / or count are wrong.
|
|||
/// </exception>
|
|||
/// <exception cref="System.FormatException">
|
|||
/// if deflated stream is invalid.
|
|||
/// </exception>
|
|||
public int Inflate(byte[] buffer, int offset, int count) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException(nameof(buffer)); |
|||
} |
|||
|
|||
if (count < 0) |
|||
{ |
|||
#if NETCF_1_0
|
|||
throw new ArgumentOutOfRangeException("count"); |
|||
#else
|
|||
throw new ArgumentOutOfRangeException(nameof(count), "count cannot be negative"); |
|||
#endif
|
|||
} |
|||
|
|||
if (offset < 0) |
|||
{ |
|||
#if NETCF_1_0
|
|||
throw new ArgumentOutOfRangeException("offset"); |
|||
#else
|
|||
throw new ArgumentOutOfRangeException(nameof(offset), "offset cannot be negative"); |
|||
#endif
|
|||
} |
|||
|
|||
if (offset + count > buffer.Length) |
|||
{ |
|||
throw new ArgumentException("count exceeds buffer bounds"); |
|||
} |
|||
|
|||
// Special case: count may be zero
|
|||
if (count == 0) |
|||
{ |
|||
if (!IsFinished) |
|||
{ // -jr- 08-Nov-2003 INFLATE_BUG fix..
|
|||
Decode(); |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
int bytesCopied = 0; |
|||
|
|||
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: |
|||
* IsNeedingInput() and not IsFinished() |
|||
* implies more output can be produced. |
|||
*/ |
|||
int more = outputWindow.CopyOutput(buffer, offset, count); |
|||
if (more > 0) |
|||
{ |
|||
adler.Update(buffer, offset, more); |
|||
offset += more; |
|||
bytesCopied += more; |
|||
totalOut += (long)more; |
|||
count -= more; |
|||
if (count == 0) |
|||
{ |
|||
return bytesCopied; |
|||
} |
|||
} |
|||
} |
|||
} while (Decode() || ((outputWindow.GetAvailable() > 0) && (mode != DECODE_CHKSUM))); |
|||
return bytesCopied; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true, if the input buffer is empty.
|
|||
/// You should then call setInput().
|
|||
/// NOTE: This method also returns true when the stream is finished.
|
|||
/// </summary>
|
|||
public bool IsNeedingInput |
|||
{ |
|||
get |
|||
{ |
|||
return input.IsNeedingInput; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true, if a preset dictionary is needed to inflate the input.
|
|||
/// </summary>
|
|||
public bool IsNeedingDictionary |
|||
{ |
|||
get |
|||
{ |
|||
return mode == DECODE_DICT && neededBits == 0; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true, if the inflater has finished. This means, that no
|
|||
/// input is needed and no output can be produced.
|
|||
/// </summary>
|
|||
public bool IsFinished |
|||
{ |
|||
get |
|||
{ |
|||
return mode == FINISHED && outputWindow.GetAvailable() == 0; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// the adler checksum.
|
|||
/// </returns>
|
|||
public int Adler |
|||
{ |
|||
get |
|||
{ |
|||
return IsNeedingDictionary ? readAdler : (int)adler.Value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of output bytes returned by Inflate().
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// the total number of output bytes.
|
|||
/// </returns>
|
|||
public long TotalOut |
|||
{ |
|||
get |
|||
{ |
|||
return totalOut; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the total number of processed compressed input bytes.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// The total number of bytes of processed input bytes.
|
|||
/// </returns>
|
|||
public long TotalIn |
|||
{ |
|||
get |
|||
{ |
|||
return totalIn - (long)RemainingInput; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of unprocessed input bytes. Useful, if the end of the
|
|||
/// stream is reached and you want to further process the bytes after
|
|||
/// the deflate stream.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// The number of bytes of the input which have not been processed.
|
|||
/// </returns>
|
|||
public int RemainingInput |
|||
{ |
|||
// TODO: This should be a long?
|
|||
get |
|||
{ |
|||
return input.AvailableBytes; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,196 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
class InflaterDynHeader |
|||
{ |
|||
#region Constants
|
|||
const int LNUM = 0; |
|||
const int DNUM = 1; |
|||
const int BLNUM = 2; |
|||
const int BLLENS = 3; |
|||
const int LENS = 4; |
|||
const int REPS = 5; |
|||
|
|||
static readonly int[] repMin = { 3, 3, 11 }; |
|||
static readonly int[] repBits = { 2, 3, 7 }; |
|||
|
|||
static readonly int[] BL_ORDER = |
|||
{ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; |
|||
|
|||
#endregion
|
|||
|
|||
#region Constructors
|
|||
public InflaterDynHeader() |
|||
{ |
|||
} |
|||
#endregion
|
|||
|
|||
public bool Decode(StreamManipulator input) |
|||
{ |
|||
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; |
|||
goto case 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; |
|||
goto case 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; |
|||
goto case 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; |
|||
goto case 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 ImageFormatException(); |
|||
} |
|||
} |
|||
repSymbol = symbol - 16; |
|||
} |
|||
mode = REPS; |
|||
goto case 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 ImageFormatException(); |
|||
} |
|||
while (count-- > 0) |
|||
{ |
|||
litdistLens[ptr++] = lastLen; |
|||
} |
|||
|
|||
if (ptr == num) |
|||
{ |
|||
/* Finished */ |
|||
return true; |
|||
} |
|||
} |
|||
mode = LENS; |
|||
goto decode_loop; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public InflaterHuffmanTree BuildLitLenTree() |
|||
{ |
|||
byte[] litlenLens = new byte[lnum]; |
|||
Array.Copy(litdistLens, 0, litlenLens, 0, lnum); |
|||
return new InflaterHuffmanTree(litlenLens); |
|||
} |
|||
|
|||
public InflaterHuffmanTree BuildDistTree() |
|||
{ |
|||
byte[] distLens = new byte[dnum]; |
|||
Array.Copy(litdistLens, lnum, distLens, 0, dnum); |
|||
return new InflaterHuffmanTree(distLens); |
|||
} |
|||
|
|||
#region Instance Fields
|
|||
byte[] blLens; |
|||
byte[] litdistLens; |
|||
|
|||
InflaterHuffmanTree blTree; |
|||
|
|||
/// <summary>
|
|||
/// The current decode mode
|
|||
/// </summary>
|
|||
int mode; |
|||
int lnum, dnum, blnum, num; |
|||
int repSymbol; |
|||
byte lastLen; |
|||
int ptr; |
|||
#endregion
|
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,225 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// Huffman tree used for inflation
|
|||
/// </summary>
|
|||
public class InflaterHuffmanTree |
|||
{ |
|||
#region Constants
|
|||
const int MAX_BITLEN = 15; |
|||
#endregion
|
|||
|
|||
#region Instance Fields
|
|||
short[] tree; |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Literal length tree
|
|||
/// </summary>
|
|||
public static InflaterHuffmanTree defLitLenTree; |
|||
|
|||
/// <summary>
|
|||
/// Distance tree
|
|||
/// </summary>
|
|||
public static InflaterHuffmanTree defDistTree; |
|||
|
|||
static InflaterHuffmanTree() |
|||
{ |
|||
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 (Exception) |
|||
{ |
|||
throw new ImageFormatException("InflaterHuffmanTree: static tree length illegal"); |
|||
} |
|||
} |
|||
|
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Constructs a Huffman tree from the array of code lengths.
|
|||
/// </summary>
|
|||
/// <param name = "codeLengths">
|
|||
/// the array of code lengths
|
|||
/// </param>
|
|||
public InflaterHuffmanTree(byte[] codeLengths) |
|||
{ |
|||
BuildTree(codeLengths); |
|||
} |
|||
#endregion
|
|||
|
|||
void BuildTree(byte[] codeLengths) |
|||
{ |
|||
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); |
|||
} |
|||
} |
|||
|
|||
/* -jr comment this out! doesnt work for dynamic trees and pkzip 2.04g |
|||
if (code != 65536) |
|||
{ |
|||
throw new SharpZipBaseException("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)); |
|||
} |
|||
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reads the next symbol from input. The symbol is encoded using the
|
|||
/// huffman tree.
|
|||
/// </summary>
|
|||
/// <param name="input">
|
|||
/// input the input source.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// the next symbol, or -1 if not enough input is available.
|
|||
/// </returns>
|
|||
public int GetSymbol(StreamManipulator input) |
|||
{ |
|||
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.AvailableBits; |
|||
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.AvailableBits; |
|||
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,326 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
using System.IO; |
|||
|
|||
//using ICSharpCode.SharpZipLib.Zip;
|
|||
//using ICSharpCode.SharpZipLib.Zip.Compression;
|
|||
|
|||
/// <summary>
|
|||
/// An input buffer customised for use by <see cref="InflaterInputStream"/>
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The buffer supports decryption of incoming data.
|
|||
/// </remarks>
|
|||
public class InflaterInputBuffer |
|||
{ |
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Initialise a new instance of <see cref="InflaterInputBuffer"/> with a default buffer size
|
|||
/// </summary>
|
|||
/// <param name="stream">The stream to buffer.</param>
|
|||
public InflaterInputBuffer(Stream stream) : this(stream, 4096) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Initialise a new instance of <see cref="InflaterInputBuffer"/>
|
|||
/// </summary>
|
|||
/// <param name="stream">The stream to buffer.</param>
|
|||
/// <param name="bufferSize">The size to use for the buffer</param>
|
|||
/// <remarks>A minimum buffer size of 1KB is permitted. Lower sizes are treated as 1KB.</remarks>
|
|||
public InflaterInputBuffer(Stream stream, int bufferSize) |
|||
{ |
|||
inputStream = stream; |
|||
if (bufferSize < 1024) |
|||
{ |
|||
bufferSize = 1024; |
|||
} |
|||
rawData = new byte[bufferSize]; |
|||
clearText = rawData; |
|||
} |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Get the length of bytes bytes in the <see cref="RawData"/>
|
|||
/// </summary>
|
|||
public int RawLength |
|||
{ |
|||
get |
|||
{ |
|||
return rawLength; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get the contents of the raw data buffer.
|
|||
/// </summary>
|
|||
/// <remarks>This may contain encrypted data.</remarks>
|
|||
public byte[] RawData |
|||
{ |
|||
get |
|||
{ |
|||
return rawData; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get the number of useable bytes in <see cref="ClearText"/>
|
|||
/// </summary>
|
|||
public int ClearTextLength |
|||
{ |
|||
get |
|||
{ |
|||
return clearTextLength; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get the contents of the clear text buffer.
|
|||
/// </summary>
|
|||
public byte[] ClearText |
|||
{ |
|||
get |
|||
{ |
|||
return clearText; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get/set the number of bytes available
|
|||
/// </summary>
|
|||
public int Available |
|||
{ |
|||
get { return available; } |
|||
set { available = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Call <see cref="Inflater.SetInput(byte[], int, int)"/> passing the current clear text buffer contents.
|
|||
/// </summary>
|
|||
/// <param name="inflater">The inflater to set input for.</param>
|
|||
public void SetInflaterInput(Inflater inflater) |
|||
{ |
|||
if (available > 0) |
|||
{ |
|||
inflater.SetInput(clearText, clearTextLength - available, available); |
|||
available = 0; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Fill the buffer from the underlying input stream.
|
|||
/// </summary>
|
|||
public void Fill() |
|||
{ |
|||
rawLength = 0; |
|||
int toRead = rawData.Length; |
|||
|
|||
while (toRead > 0) |
|||
{ |
|||
int count = inputStream.Read(rawData, rawLength, toRead); |
|||
if (count <= 0) |
|||
{ |
|||
break; |
|||
} |
|||
rawLength += count; |
|||
toRead -= count; |
|||
} |
|||
|
|||
#if !NETCF_1_0 && !NOCRYPTO
|
|||
if (cryptoTransform != null) |
|||
{ |
|||
clearTextLength = cryptoTransform.TransformBlock(rawData, 0, rawLength, clearText, 0); |
|||
} |
|||
else |
|||
#endif
|
|||
{ |
|||
clearTextLength = rawLength; |
|||
} |
|||
|
|||
available = clearTextLength; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read a buffer directly from the input stream
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer to fill</param>
|
|||
/// <returns>Returns the number of bytes read.</returns>
|
|||
public int ReadRawBuffer(byte[] buffer) |
|||
{ |
|||
return ReadRawBuffer(buffer, 0, buffer.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read a buffer directly from the input stream
|
|||
/// </summary>
|
|||
/// <param name="outBuffer">The buffer to read into</param>
|
|||
/// <param name="offset">The offset to start reading data into.</param>
|
|||
/// <param name="length">The number of bytes to read.</param>
|
|||
/// <returns>Returns the number of bytes read.</returns>
|
|||
public int ReadRawBuffer(byte[] outBuffer, int offset, int length) |
|||
{ |
|||
if (length < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("length"); |
|||
} |
|||
|
|||
int currentOffset = offset; |
|||
int currentLength = length; |
|||
|
|||
while (currentLength > 0) |
|||
{ |
|||
if (available <= 0) |
|||
{ |
|||
Fill(); |
|||
if (available <= 0) |
|||
{ |
|||
return 0; |
|||
} |
|||
} |
|||
int toCopy = Math.Min(currentLength, available); |
|||
System.Array.Copy(rawData, rawLength - (int)available, outBuffer, currentOffset, toCopy); |
|||
currentOffset += toCopy; |
|||
currentLength -= toCopy; |
|||
available -= toCopy; |
|||
} |
|||
return length; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read clear text data from the input stream.
|
|||
/// </summary>
|
|||
/// <param name="outBuffer">The buffer to add data to.</param>
|
|||
/// <param name="offset">The offset to start adding data at.</param>
|
|||
/// <param name="length">The number of bytes to read.</param>
|
|||
/// <returns>Returns the number of bytes actually read.</returns>
|
|||
public int ReadClearTextBuffer(byte[] outBuffer, int offset, int length) |
|||
{ |
|||
if (length < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("length"); |
|||
} |
|||
|
|||
int currentOffset = offset; |
|||
int currentLength = length; |
|||
|
|||
while (currentLength > 0) |
|||
{ |
|||
if (available <= 0) |
|||
{ |
|||
Fill(); |
|||
if (available <= 0) |
|||
{ |
|||
return 0; |
|||
} |
|||
} |
|||
|
|||
int toCopy = Math.Min(currentLength, available); |
|||
Array.Copy(clearText, clearTextLength - (int)available, outBuffer, currentOffset, toCopy); |
|||
currentOffset += toCopy; |
|||
currentLength -= toCopy; |
|||
available -= toCopy; |
|||
} |
|||
return length; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read a <see cref="byte"/> from the input stream.
|
|||
/// </summary>
|
|||
/// <returns>Returns the byte read.</returns>
|
|||
public int ReadLeByte() |
|||
{ |
|||
if (available <= 0) |
|||
{ |
|||
Fill(); |
|||
if (available <= 0) |
|||
{ |
|||
throw new ImageFormatException("EOF in header"); |
|||
} |
|||
} |
|||
byte result = rawData[rawLength - available]; |
|||
available -= 1; |
|||
return result; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read an <see cref="short"/> in little endian byte order.
|
|||
/// </summary>
|
|||
/// <returns>The short value read case to an int.</returns>
|
|||
public int ReadLeShort() |
|||
{ |
|||
return ReadLeByte() | (ReadLeByte() << 8); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read an <see cref="int"/> in little endian byte order.
|
|||
/// </summary>
|
|||
/// <returns>The int value read.</returns>
|
|||
public int ReadLeInt() |
|||
{ |
|||
return ReadLeShort() | (ReadLeShort() << 16); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Read a <see cref="long"/> in little endian byte order.
|
|||
/// </summary>
|
|||
/// <returns>The long value read.</returns>
|
|||
public long ReadLeLong() |
|||
{ |
|||
return (uint)ReadLeInt() | ((long)ReadLeInt() << 32); |
|||
} |
|||
|
|||
#if !NETCF_1_0 && !NOCRYPTO
|
|||
/// <summary>
|
|||
/// Get/set the <see cref="ICryptoTransform"/> to apply to any data.
|
|||
/// </summary>
|
|||
/// <remarks>Set this value to null to have no transform applied.</remarks>
|
|||
public ICryptoTransform CryptoTransform |
|||
{ |
|||
set |
|||
{ |
|||
cryptoTransform = value; |
|||
if (cryptoTransform != null) |
|||
{ |
|||
if (rawData == clearText) |
|||
{ |
|||
if (internalClearText == null) |
|||
{ |
|||
internalClearText = new byte[rawData.Length]; |
|||
} |
|||
clearText = internalClearText; |
|||
} |
|||
clearTextLength = rawLength; |
|||
if (available > 0) |
|||
{ |
|||
cryptoTransform.TransformBlock(rawData, rawLength - available, available, clearText, rawLength - available); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
clearText = rawData; |
|||
clearTextLength = rawLength; |
|||
} |
|||
} |
|||
} |
|||
#endif
|
|||
|
|||
#region Instance Fields
|
|||
int rawLength; |
|||
byte[] rawData; |
|||
|
|||
int clearTextLength; |
|||
byte[] clearText; |
|||
#if !NETCF_1_0 && !NOCRYPTO
|
|||
byte[] internalClearText; |
|||
#endif
|
|||
|
|||
int available; |
|||
|
|||
#if !NETCF_1_0 && !NOCRYPTO
|
|||
ICryptoTransform cryptoTransform; |
|||
#endif
|
|||
Stream inputStream; |
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,407 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
using System.IO; |
|||
|
|||
//using ICSharpCode.SharpZipLib;
|
|||
//using ICSharpCode.SharpZipLib.Zip;
|
|||
//using ICSharpCode.SharpZipLib.Zip.Compression;
|
|||
|
|||
/// <summary>
|
|||
/// This filter stream is used to decompress data compressed using the "deflate"
|
|||
/// format. The "deflate" format is described in RFC 1951.
|
|||
///
|
|||
/// This stream may form the basis for other decompression filters, such
|
|||
/// as the <see cref="ICSharpCode.SharpZipLib.GZip.GZipInputStream">GZipInputStream</see>.
|
|||
///
|
|||
/// Author of the original java version : John Leuner.
|
|||
/// </summary>
|
|||
public class InflaterInputStream : Stream |
|||
{ |
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Create an InflaterInputStream with the default decompressor
|
|||
/// and a default buffer size of 4KB.
|
|||
/// </summary>
|
|||
/// <param name = "baseInputStream">
|
|||
/// The InputStream to read bytes from
|
|||
/// </param>
|
|||
public InflaterInputStream(Stream baseInputStream) |
|||
: this(baseInputStream, new Inflater(), 4096) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Create an InflaterInputStream with the specified decompressor
|
|||
/// and a default buffer size of 4KB.
|
|||
/// </summary>
|
|||
/// <param name = "baseInputStream">
|
|||
/// The source of input data
|
|||
/// </param>
|
|||
/// <param name = "inf">
|
|||
/// The decompressor used to decompress data read from baseInputStream
|
|||
/// </param>
|
|||
public InflaterInputStream(Stream baseInputStream, Inflater inf) |
|||
: this(baseInputStream, inf, 4096) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Create an InflaterInputStream with the specified decompressor and the specified buffer size.
|
|||
/// </summary>
|
|||
/// <param name = "baseInputStream">
|
|||
/// The InputStream to read bytes from
|
|||
/// </param>
|
|||
/// <param name = "inflater">
|
|||
/// The decompressor to use
|
|||
/// </param>
|
|||
/// <param name = "bufferSize">
|
|||
/// Size of the buffer to use
|
|||
/// </param>
|
|||
public InflaterInputStream(Stream baseInputStream, Inflater inflater, int bufferSize) |
|||
{ |
|||
if (baseInputStream == null) |
|||
{ |
|||
throw new ArgumentNullException("baseInputStream"); |
|||
} |
|||
|
|||
if (inflater == null) |
|||
{ |
|||
throw new ArgumentNullException("inflater"); |
|||
} |
|||
|
|||
if (bufferSize <= 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("bufferSize"); |
|||
} |
|||
|
|||
this.baseInputStream = baseInputStream; |
|||
this.inf = inflater; |
|||
|
|||
inputBuffer = new InflaterInputBuffer(baseInputStream, bufferSize); |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Get/set flag indicating ownership of underlying stream.
|
|||
/// When the flag is true <see cref="Dispose"/> will close the underlying stream also.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// The default value is true.
|
|||
/// </remarks>
|
|||
public bool IsStreamOwner |
|||
{ |
|||
get { return isStreamOwner; } |
|||
set { isStreamOwner = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Skip specified number of bytes of uncompressed data
|
|||
/// </summary>
|
|||
/// <param name ="count">
|
|||
/// Number of bytes to skip
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The number of bytes skipped, zero if the end of
|
|||
/// stream has been reached
|
|||
/// </returns>
|
|||
/// <exception cref="ArgumentOutOfRangeException">
|
|||
/// <paramref name="count">The number of bytes</paramref> to skip is less than or equal to zero.
|
|||
/// </exception>
|
|||
public long Skip(long count) |
|||
{ |
|||
if (count <= 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("count"); |
|||
} |
|||
|
|||
// v0.80 Skip by seeking if underlying stream supports it...
|
|||
if (baseInputStream.CanSeek) |
|||
{ |
|||
baseInputStream.Seek(count, SeekOrigin.Current); |
|||
return count; |
|||
} |
|||
else |
|||
{ |
|||
int length = 2048; |
|||
if (count < length) |
|||
{ |
|||
length = (int)count; |
|||
} |
|||
|
|||
byte[] tmp = new byte[length]; |
|||
int readCount = 1; |
|||
long toSkip = count; |
|||
|
|||
while ((toSkip > 0) && (readCount > 0)) |
|||
{ |
|||
if (toSkip < length) |
|||
{ |
|||
length = (int)toSkip; |
|||
} |
|||
|
|||
readCount = baseInputStream.Read(tmp, 0, length); |
|||
toSkip -= readCount; |
|||
} |
|||
|
|||
return count - toSkip; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clear any cryptographic state.
|
|||
/// </summary>
|
|||
protected void StopDecrypting() |
|||
{ |
|||
#if !NETCF_1_0 && !NOCRYPTO
|
|||
inputBuffer.CryptoTransform = null; |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns 0 once the end of the stream (EOF) has been reached.
|
|||
/// Otherwise returns 1.
|
|||
/// </summary>
|
|||
public virtual int Available |
|||
{ |
|||
get |
|||
{ |
|||
return inf.IsFinished ? 0 : 1; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Fills the buffer with more data to decompress.
|
|||
/// </summary>
|
|||
/// <exception cref="SharpZipBaseException">
|
|||
/// Stream ends early
|
|||
/// </exception>
|
|||
protected void Fill() |
|||
{ |
|||
// Protect against redundant calls
|
|||
if (inputBuffer.Available <= 0) |
|||
{ |
|||
inputBuffer.Fill(); |
|||
if (inputBuffer.Available <= 0) |
|||
{ |
|||
throw new ImageFormatException("Unexpected EOF"); |
|||
} |
|||
} |
|||
inputBuffer.SetInflaterInput(inf); |
|||
} |
|||
|
|||
#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 inputBuffer.RawLength; |
|||
} |
|||
} |
|||
|
|||
/// <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"); |
|||
} |
|||
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
base.Dispose(disposing); |
|||
if (disposing && !isClosed) |
|||
{ |
|||
isClosed = true; |
|||
if (isStreamOwner) |
|||
{ |
|||
baseInputStream.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <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>
|
|||
/// <exception cref="SharpZipBaseException">
|
|||
/// Inflater needs a dictionary
|
|||
/// </exception>
|
|||
public override int Read(byte[] buffer, int offset, int count) |
|||
{ |
|||
if (inf.IsNeedingDictionary) |
|||
{ |
|||
throw new ImageFormatException("Need a dictionary"); |
|||
} |
|||
|
|||
int remainingBytes = count; |
|||
while (true) |
|||
{ |
|||
int bytesRead = inf.Inflate(buffer, offset, remainingBytes); |
|||
offset += bytesRead; |
|||
remainingBytes -= bytesRead; |
|||
|
|||
if (remainingBytes == 0 || inf.IsFinished) |
|||
{ |
|||
break; |
|||
} |
|||
|
|||
if (inf.IsNeedingInput) |
|||
{ |
|||
Fill(); |
|||
} |
|||
else if (bytesRead == 0) |
|||
{ |
|||
throw new ImageFormatException("Dont know what to do"); |
|||
} |
|||
} |
|||
return count - remainingBytes; |
|||
} |
|||
#endregion
|
|||
|
|||
#region Instance Fields
|
|||
/// <summary>
|
|||
/// Decompressor for this stream
|
|||
/// </summary>
|
|||
protected Inflater inf; |
|||
|
|||
/// <summary>
|
|||
/// <see cref="InflaterInputBuffer">Input buffer</see> for this stream.
|
|||
/// </summary>
|
|||
protected InflaterInputBuffer inputBuffer; |
|||
|
|||
/// <summary>
|
|||
/// Base stream the inflater reads from.
|
|||
/// </summary>
|
|||
private Stream baseInputStream; |
|||
|
|||
/// <summary>
|
|||
/// The compressed size
|
|||
/// </summary>
|
|||
protected long csize; |
|||
|
|||
/// <summary>
|
|||
/// Flag indicating wether this instance has been closed or not.
|
|||
/// </summary>
|
|||
bool isClosed; |
|||
|
|||
/// <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; |
|||
#endregion
|
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,217 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// 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.<br/>
|
|||
/// Author of the original java version : John Leuner
|
|||
/// </summary>
|
|||
public class OutputWindow |
|||
{ |
|||
#region Constants
|
|||
const int WindowSize = 1 << 15; |
|||
const int WindowMask = WindowSize - 1; |
|||
#endregion
|
|||
|
|||
#region Instance Fields
|
|||
byte[] window = new byte[WindowSize]; //The window is 2^15 bytes
|
|||
int windowEnd; |
|||
int windowFilled; |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Write a byte to this output window
|
|||
/// </summary>
|
|||
/// <param name="value">value to write</param>
|
|||
/// <exception cref="InvalidOperationException">
|
|||
/// if window is full
|
|||
/// </exception>
|
|||
public void Write(int value) |
|||
{ |
|||
if (windowFilled++ == WindowSize) |
|||
{ |
|||
throw new InvalidOperationException("Window full"); |
|||
} |
|||
window[windowEnd++] = (byte)value; |
|||
windowEnd &= WindowMask; |
|||
} |
|||
|
|||
|
|||
private void SlowRepeat(int repStart, int length, int distance) |
|||
{ |
|||
while (length-- > 0) |
|||
{ |
|||
window[windowEnd++] = window[repStart++]; |
|||
windowEnd &= WindowMask; |
|||
repStart &= WindowMask; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Append a byte pattern already in the window itself
|
|||
/// </summary>
|
|||
/// <param name="length">length of pattern to copy</param>
|
|||
/// <param name="distance">distance from end of window pattern occurs</param>
|
|||
/// <exception cref="InvalidOperationException">
|
|||
/// If the repeated data overflows the window
|
|||
/// </exception>
|
|||
public void Repeat(int length, int distance) |
|||
{ |
|||
if ((windowFilled += length) > WindowSize) |
|||
{ |
|||
throw new InvalidOperationException("Window full"); |
|||
} |
|||
|
|||
int repStart = (windowEnd - distance) & WindowMask; |
|||
int border = WindowSize - length; |
|||
if ((repStart <= border) && (windowEnd < border)) |
|||
{ |
|||
if (length <= distance) |
|||
{ |
|||
System.Array.Copy(window, repStart, window, windowEnd, length); |
|||
windowEnd += length; |
|||
} |
|||
else |
|||
{ |
|||
// We have to copy manually, since the repeat pattern overlaps.
|
|||
while (length-- > 0) |
|||
{ |
|||
window[windowEnd++] = window[repStart++]; |
|||
} |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
SlowRepeat(repStart, length, distance); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Copy from input manipulator to internal window
|
|||
/// </summary>
|
|||
/// <param name="input">source of data</param>
|
|||
/// <param name="length">length of data to copy</param>
|
|||
/// <returns>the number of bytes copied</returns>
|
|||
public int CopyStored(StreamManipulator input, int length) |
|||
{ |
|||
length = Math.Min(Math.Min(length, WindowSize - windowFilled), input.AvailableBytes); |
|||
int copied; |
|||
|
|||
int tailLen = WindowSize - windowEnd; |
|||
if (length > tailLen) |
|||
{ |
|||
copied = input.CopyBytes(window, windowEnd, tailLen); |
|||
if (copied == tailLen) |
|||
{ |
|||
copied += input.CopyBytes(window, 0, length - tailLen); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
copied = input.CopyBytes(window, windowEnd, length); |
|||
} |
|||
|
|||
windowEnd = (windowEnd + copied) & WindowMask; |
|||
windowFilled += copied; |
|||
return copied; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Copy dictionary to window
|
|||
/// </summary>
|
|||
/// <param name="dictionary">source dictionary</param>
|
|||
/// <param name="offset">offset of start in source dictionary</param>
|
|||
/// <param name="length">length of dictionary</param>
|
|||
/// <exception cref="InvalidOperationException">
|
|||
/// If window isnt empty
|
|||
/// </exception>
|
|||
public void CopyDict(byte[] dictionary, int offset, int length) |
|||
{ |
|||
if (dictionary == null) |
|||
{ |
|||
throw new ArgumentNullException("dictionary"); |
|||
} |
|||
|
|||
if (windowFilled > 0) |
|||
{ |
|||
throw new InvalidOperationException(); |
|||
} |
|||
|
|||
if (length > WindowSize) |
|||
{ |
|||
offset += length - WindowSize; |
|||
length = WindowSize; |
|||
} |
|||
System.Array.Copy(dictionary, offset, window, 0, length); |
|||
windowEnd = length & WindowMask; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get remaining unfilled space in window
|
|||
/// </summary>
|
|||
/// <returns>Number of bytes left in window</returns>
|
|||
public int GetFreeSpace() |
|||
{ |
|||
return WindowSize - windowFilled; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get bytes available for output in window
|
|||
/// </summary>
|
|||
/// <returns>Number of bytes filled</returns>
|
|||
public int GetAvailable() |
|||
{ |
|||
return windowFilled; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Copy contents of window to output
|
|||
/// </summary>
|
|||
/// <param name="output">buffer to copy to</param>
|
|||
/// <param name="offset">offset to start at</param>
|
|||
/// <param name="len">number of bytes to count</param>
|
|||
/// <returns>The number of bytes copied</returns>
|
|||
/// <exception cref="InvalidOperationException">
|
|||
/// If a window underflow occurs
|
|||
/// </exception>
|
|||
public int CopyOutput(byte[] output, int offset, int len) |
|||
{ |
|||
int copyEnd = windowEnd; |
|||
if (len > windowFilled) |
|||
{ |
|||
len = windowFilled; |
|||
} |
|||
else |
|||
{ |
|||
copyEnd = (windowEnd - windowFilled + len) & WindowMask; |
|||
} |
|||
|
|||
int copied = len; |
|||
int tailLen = len - copyEnd; |
|||
|
|||
if (tailLen > 0) |
|||
{ |
|||
System.Array.Copy(window, WindowSize - tailLen, output, offset, tailLen); |
|||
offset += tailLen; |
|||
len = copyEnd; |
|||
} |
|||
System.Array.Copy(window, copyEnd - len, output, offset, len); |
|||
windowFilled -= copied; |
|||
if (windowFilled < 0) |
|||
{ |
|||
throw new InvalidOperationException(); |
|||
} |
|||
return copied; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reset by clearing window so <see cref="GetAvailable">GetAvailable</see> returns 0
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
windowFilled = windowEnd = 0; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,263 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
/// <summary>
|
|||
/// This class is general purpose class for writing data to a buffer.
|
|||
///
|
|||
/// It allows you to write bits as well as bytes
|
|||
/// Based on DeflaterPending.java
|
|||
///
|
|||
/// author of the original java version : Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class PendingBuffer |
|||
{ |
|||
#region Instance Fields
|
|||
/// <summary>
|
|||
/// Internal work buffer
|
|||
/// </summary>
|
|||
byte[] buffer_; |
|||
|
|||
int start; |
|||
int end; |
|||
|
|||
uint bits; |
|||
int bitCount; |
|||
#endregion
|
|||
|
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// construct instance using default buffer size of 4096
|
|||
/// </summary>
|
|||
public PendingBuffer() : this(4096) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// construct instance using specified buffer size
|
|||
/// </summary>
|
|||
/// <param name="bufferSize">
|
|||
/// size to use for internal buffer
|
|||
/// </param>
|
|||
public PendingBuffer(int bufferSize) |
|||
{ |
|||
buffer_ = new byte[bufferSize]; |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Clear internal state/buffers
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
start = end = bitCount = 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write a byte to buffer
|
|||
/// </summary>
|
|||
/// <param name="value">
|
|||
/// The value to write
|
|||
/// </param>
|
|||
public void WriteByte(int value) |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
#endif
|
|||
buffer_[end++] = unchecked((byte)value); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write a short value to buffer LSB first
|
|||
/// </summary>
|
|||
/// <param name="value">
|
|||
/// The value to write.
|
|||
/// </param>
|
|||
public void WriteShort(int value) |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
#endif
|
|||
buffer_[end++] = unchecked((byte)value); |
|||
buffer_[end++] = unchecked((byte)(value >> 8)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// write an integer LSB first
|
|||
/// </summary>
|
|||
/// <param name="value">The value to write.</param>
|
|||
public void WriteInt(int value) |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
#endif
|
|||
buffer_[end++] = unchecked((byte)value); |
|||
buffer_[end++] = unchecked((byte)(value >> 8)); |
|||
buffer_[end++] = unchecked((byte)(value >> 16)); |
|||
buffer_[end++] = unchecked((byte)(value >> 24)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write a block of data to buffer
|
|||
/// </summary>
|
|||
/// <param name="block">data to write</param>
|
|||
/// <param name="offset">offset of first byte to write</param>
|
|||
/// <param name="length">number of bytes to write</param>
|
|||
public void WriteBlock(byte[] block, int offset, int length) |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
#endif
|
|||
System.Array.Copy(block, offset, buffer_, end, length); |
|||
end += length; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The number of bits written to the buffer
|
|||
/// </summary>
|
|||
public int BitCount |
|||
{ |
|||
get |
|||
{ |
|||
return bitCount; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Align internal buffer on a byte boundary
|
|||
/// </summary>
|
|||
public void AlignToByte() |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
#endif
|
|||
if (bitCount > 0) |
|||
{ |
|||
buffer_[end++] = unchecked((byte)bits); |
|||
if (bitCount > 8) |
|||
{ |
|||
buffer_[end++] = unchecked((byte)(bits >> 8)); |
|||
} |
|||
} |
|||
bits = 0; |
|||
bitCount = 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write bits to internal buffer
|
|||
/// </summary>
|
|||
/// <param name="b">source of bits</param>
|
|||
/// <param name="count">number of bits to write</param>
|
|||
public void WriteBits(int b, int count) |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
|
|||
// if (DeflaterConstants.DEBUGGING) {
|
|||
// //Console.WriteLine("writeBits("+b+","+count+")");
|
|||
// }
|
|||
#endif
|
|||
bits |= (uint)(b << bitCount); |
|||
bitCount += count; |
|||
if (bitCount >= 16) |
|||
{ |
|||
buffer_[end++] = unchecked((byte)bits); |
|||
buffer_[end++] = unchecked((byte)(bits >> 8)); |
|||
bits >>= 16; |
|||
bitCount -= 16; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Write a short value to internal buffer most significant byte first
|
|||
/// </summary>
|
|||
/// <param name="s">value to write</param>
|
|||
public void WriteShortMSB(int s) |
|||
{ |
|||
#if DebugDeflation
|
|||
if (DeflaterConstants.DEBUGGING && (start != 0) ) |
|||
{ |
|||
throw new SharpZipBaseException("Debug check: start != 0"); |
|||
} |
|||
#endif
|
|||
buffer_[end++] = unchecked((byte)(s >> 8)); |
|||
buffer_[end++] = unchecked((byte)s); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Indicates if buffer has been flushed
|
|||
/// </summary>
|
|||
public bool IsFlushed |
|||
{ |
|||
get |
|||
{ |
|||
return end == 0; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Flushes the pending buffer into the given output array. If the
|
|||
/// output array is to small, only a partial flush is done.
|
|||
/// </summary>
|
|||
/// <param name="output">The output array.</param>
|
|||
/// <param name="offset">The offset into output array.</param>
|
|||
/// <param name="length">The maximum number of bytes to store.</param>
|
|||
/// <returns>The number of bytes flushed.</returns>
|
|||
public int Flush(byte[] output, int offset, int length) |
|||
{ |
|||
if (bitCount >= 8) |
|||
{ |
|||
buffer_[end++] = unchecked((byte)bits); |
|||
bits >>= 8; |
|||
bitCount -= 8; |
|||
} |
|||
|
|||
if (length > end - start) |
|||
{ |
|||
length = end - start; |
|||
System.Array.Copy(buffer_, start, output, offset, length); |
|||
start = 0; |
|||
end = 0; |
|||
} |
|||
else |
|||
{ |
|||
System.Array.Copy(buffer_, start, output, offset, length); |
|||
start += length; |
|||
} |
|||
return length; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert internal buffer to byte array.
|
|||
/// Buffer is empty on completion
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// The internal buffer contents converted to a byte array.
|
|||
/// </returns>
|
|||
public byte[] ToByteArray() |
|||
{ |
|||
byte[] result = new byte[end - start]; |
|||
System.Array.Copy(buffer_, start, result, 0, result.Length); |
|||
start = 0; |
|||
end = 0; |
|||
return result; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,279 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System; |
|||
|
|||
/// <summary>
|
|||
/// This class allows us to retrieve a specified number of bits from
|
|||
/// the input buffer, as well as copy big byte blocks.
|
|||
///
|
|||
/// 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.
|
|||
///
|
|||
/// There are some optimizations in this class, for example, you must
|
|||
/// never peek more than 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.
|
|||
///
|
|||
/// authors of the original java version : John Leuner, Jochen Hoenicke
|
|||
/// </summary>
|
|||
public class StreamManipulator |
|||
{ |
|||
#region Constructors
|
|||
/// <summary>
|
|||
/// Constructs a default StreamManipulator with all buffers empty
|
|||
/// </summary>
|
|||
public StreamManipulator() |
|||
{ |
|||
} |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// Get the next sequence of bits but don't increase input pointer. bitCount must be
|
|||
/// less or equal 16 and if this call succeeds, you must drop
|
|||
/// at least n - 8 bits in the next call.
|
|||
/// </summary>
|
|||
/// <param name="bitCount">The number of bits to peek.</param>
|
|||
/// <returns>
|
|||
/// the value of the bits, or -1 if not enough bits available. */
|
|||
/// </returns>
|
|||
public int PeekBits(int bitCount) |
|||
{ |
|||
if (bitsInBuffer_ < bitCount) |
|||
{ |
|||
if (windowStart_ == windowEnd_) |
|||
{ |
|||
return -1; // ok
|
|||
} |
|||
buffer_ |= (uint)((window_[windowStart_++] & 0xff | |
|||
(window_[windowStart_++] & 0xff) << 8) << bitsInBuffer_); |
|||
bitsInBuffer_ += 16; |
|||
} |
|||
return (int)(buffer_ & ((1 << bitCount) - 1)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// 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.
|
|||
/// </summary>
|
|||
/// <param name="bitCount">The number of bits to drop.</param>
|
|||
public void DropBits(int bitCount) |
|||
{ |
|||
buffer_ >>= bitCount; |
|||
bitsInBuffer_ -= bitCount; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the next n bits and increases input pointer. This is equivalent
|
|||
/// to <see cref="PeekBits"/> followed by <see cref="DropBits"/>, except for correct error handling.
|
|||
/// </summary>
|
|||
/// <param name="bitCount">The number of bits to retrieve.</param>
|
|||
/// <returns>
|
|||
/// the value of the bits, or -1 if not enough bits available.
|
|||
/// </returns>
|
|||
public int GetBits(int bitCount) |
|||
{ |
|||
int bits = PeekBits(bitCount); |
|||
if (bits >= 0) |
|||
{ |
|||
DropBits(bitCount); |
|||
} |
|||
return bits; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of bits available in the bit buffer. This must be
|
|||
/// only called when a previous PeekBits() returned -1.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// the number of bits available.
|
|||
/// </returns>
|
|||
public int AvailableBits |
|||
{ |
|||
get |
|||
{ |
|||
return bitsInBuffer_; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the number of bytes available.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// The number of bytes available.
|
|||
/// </returns>
|
|||
public int AvailableBytes |
|||
{ |
|||
get |
|||
{ |
|||
return windowEnd_ - windowStart_ + (bitsInBuffer_ >> 3); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Skips to the next byte boundary.
|
|||
/// </summary>
|
|||
public void SkipToByteBoundary() |
|||
{ |
|||
buffer_ >>= (bitsInBuffer_ & 7); |
|||
bitsInBuffer_ &= ~7; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns true when SetInput can be called
|
|||
/// </summary>
|
|||
public bool IsNeedingInput |
|||
{ |
|||
get |
|||
{ |
|||
return windowStart_ == windowEnd_; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Copies 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.
|
|||
/// </summary>
|
|||
/// <param name="output">
|
|||
/// The buffer to copy bytes to.
|
|||
/// </param>
|
|||
/// <param name="offset">
|
|||
/// The offset in the buffer at which copying starts
|
|||
/// </param>
|
|||
/// <param name="length">
|
|||
/// The length to copy, 0 is allowed.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The number of bytes copied, 0 if no bytes were available.
|
|||
/// </returns>
|
|||
/// <exception cref="ArgumentOutOfRangeException">
|
|||
/// Length is less than zero
|
|||
/// </exception>
|
|||
/// <exception cref="InvalidOperationException">
|
|||
/// Bit buffer isnt byte aligned
|
|||
/// </exception>
|
|||
public int CopyBytes(byte[] output, int offset, int length) |
|||
{ |
|||
if (length < 0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("length"); |
|||
} |
|||
|
|||
if ((bitsInBuffer_ & 7) != 0) |
|||
{ |
|||
// bits_in_buffer may only be 0 or a multiple of 8
|
|||
throw new InvalidOperationException("Bit buffer is not byte aligned!"); |
|||
} |
|||
|
|||
int count = 0; |
|||
while ((bitsInBuffer_ > 0) && (length > 0)) |
|||
{ |
|||
output[offset++] = (byte)buffer_; |
|||
buffer_ >>= 8; |
|||
bitsInBuffer_ -= 8; |
|||
length--; |
|||
count++; |
|||
} |
|||
|
|||
if (length == 0) |
|||
{ |
|||
return count; |
|||
} |
|||
|
|||
int avail = windowEnd_ - windowStart_; |
|||
if (length > avail) |
|||
{ |
|||
length = avail; |
|||
} |
|||
System.Array.Copy(window_, windowStart_, output, offset, length); |
|||
windowStart_ += length; |
|||
|
|||
if (((windowStart_ - windowEnd_) & 1) != 0) |
|||
{ |
|||
// We always want an even number of bytes in input, see peekBits
|
|||
buffer_ = (uint)(window_[windowStart_++] & 0xff); |
|||
bitsInBuffer_ = 8; |
|||
} |
|||
return count + length; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Resets state and empties internal buffers
|
|||
/// </summary>
|
|||
public void Reset() |
|||
{ |
|||
buffer_ = 0; |
|||
windowStart_ = windowEnd_ = bitsInBuffer_ = 0; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add more input for consumption.
|
|||
/// Only call when IsNeedingInput returns true
|
|||
/// </summary>
|
|||
/// <param name="buffer">data to be input</param>
|
|||
/// <param name="offset">offset of first byte of input</param>
|
|||
/// <param name="count">number of bytes of input to add.</param>
|
|||
public void SetInput(byte[] buffer, int offset, int count) |
|||
{ |
|||
if (buffer == null) |
|||
{ |
|||
throw new ArgumentNullException("buffer"); |
|||
} |
|||
|
|||
if (offset < 0) |
|||
{ |
|||
#if NETCF_1_0
|
|||
throw new ArgumentOutOfRangeException("offset"); |
|||
#else
|
|||
throw new ArgumentOutOfRangeException("offset", "Cannot be negative"); |
|||
#endif
|
|||
} |
|||
|
|||
if (count < 0) |
|||
{ |
|||
#if NETCF_1_0
|
|||
throw new ArgumentOutOfRangeException("count"); |
|||
#else
|
|||
throw new ArgumentOutOfRangeException("count", "Cannot be negative"); |
|||
#endif
|
|||
} |
|||
|
|||
if (windowStart_ < windowEnd_) |
|||
{ |
|||
throw new InvalidOperationException("Old input was not completely processed"); |
|||
} |
|||
|
|||
int end = offset + count; |
|||
|
|||
// We want to throw an ArrayIndexOutOfBoundsException early.
|
|||
// Note the check also handles integer wrap around.
|
|||
if ((offset > end) || (end > buffer.Length)) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("count"); |
|||
} |
|||
|
|||
if ((count & 1) != 0) |
|||
{ |
|||
// We always want an even number of bytes in input, see PeekBits
|
|||
buffer_ |= (uint)((buffer[offset++] & 0xff) << bitsInBuffer_); |
|||
bitsInBuffer_ += 8; |
|||
} |
|||
|
|||
window_ = buffer; |
|||
windowStart_ = offset; |
|||
windowEnd_ = end; |
|||
} |
|||
|
|||
#region Instance Fields
|
|||
private byte[] window_; |
|||
private int windowStart_; |
|||
private int windowEnd_; |
|||
|
|||
private uint buffer_; |
|||
private int bitsInBuffer_; |
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,329 @@ |
|||
namespace ImageProcessor.Formats |
|||
{ |
|||
using System.Text; |
|||
|
|||
/// <summary>
|
|||
/// This class contains constants used for Zip format files
|
|||
/// </summary>
|
|||
public static class ZipConstants |
|||
{ |
|||
#region Versions
|
|||
/// <summary>
|
|||
/// The version made by field for entries in the central header when created by this library
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is also the Zip version for the library when comparing against the version required to extract
|
|||
/// for an entry. </remarks>
|
|||
public const int VersionMadeBy = 51; // was 45 before AES
|
|||
|
|||
/// <summary>
|
|||
/// The minimum version required to support strong encryption
|
|||
/// </summary>
|
|||
public const int VersionStrongEncryption = 50; |
|||
|
|||
/// <summary>
|
|||
/// Version indicating AES encryption
|
|||
/// </summary>
|
|||
public const int VERSION_AES = 51; |
|||
|
|||
/// <summary>
|
|||
/// The version required for Zip64 extensions (4.5 or higher)
|
|||
/// </summary>
|
|||
public const int VersionZip64 = 45; |
|||
#endregion
|
|||
|
|||
#region Header Sizes
|
|||
/// <summary>
|
|||
/// Size of local entry header (excluding variable length fields at end)
|
|||
/// </summary>
|
|||
public const int LocalHeaderBaseSize = 30; |
|||
|
|||
/// <summary>
|
|||
/// Size of Zip64 data descriptor
|
|||
/// </summary>
|
|||
public const int Zip64DataDescriptorSize = 24; |
|||
|
|||
/// <summary>
|
|||
/// Size of data descriptor
|
|||
/// </summary>
|
|||
public const int DataDescriptorSize = 16; |
|||
|
|||
/// <summary>
|
|||
/// Size of central header entry (excluding variable fields)
|
|||
/// </summary>
|
|||
public const int CentralHeaderBaseSize = 46; |
|||
|
|||
/// <summary>
|
|||
/// Size of end of central record (excluding variable fields)
|
|||
/// </summary>
|
|||
public const int EndOfCentralRecordBaseSize = 22; |
|||
|
|||
/// <summary>
|
|||
/// Size of 'classic' cryptographic header stored before any entry data
|
|||
/// </summary>
|
|||
public const int CryptoHeaderSize = 12; |
|||
#endregion
|
|||
|
|||
#region Header Signatures
|
|||
|
|||
/// <summary>
|
|||
/// Signature for local entry header
|
|||
/// </summary>
|
|||
public const int LocalHeaderSignature = 'P' | ('K' << 8) | (3 << 16) | (4 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for spanning entry
|
|||
/// </summary>
|
|||
public const int SpanningSignature = 'P' | ('K' << 8) | (7 << 16) | (8 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for temporary spanning entry
|
|||
/// </summary>
|
|||
public const int SpanningTempSignature = 'P' | ('K' << 8) | ('0' << 16) | ('0' << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for data descriptor
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is only used where the length, Crc, or compressed size isnt known when the
|
|||
/// entry is created and the output stream doesnt support seeking.
|
|||
/// The local entry cannot be 'patched' with the correct values in this case
|
|||
/// so the values are recorded after the data prefixed by this header, as well as in the central directory.
|
|||
/// </remarks>
|
|||
public const int DataDescriptorSignature = 'P' | ('K' << 8) | (7 << 16) | (8 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for central header
|
|||
/// </summary>
|
|||
public const int CentralHeaderSignature = 'P' | ('K' << 8) | (1 << 16) | (2 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for Zip64 central file header
|
|||
/// </summary>
|
|||
public const int Zip64CentralFileHeaderSignature = 'P' | ('K' << 8) | (6 << 16) | (6 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for Zip64 central directory locator
|
|||
/// </summary>
|
|||
public const int Zip64CentralDirLocatorSignature = 'P' | ('K' << 8) | (6 << 16) | (7 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Signature for archive extra data signature (were headers are encrypted).
|
|||
/// </summary>
|
|||
public const int ArchiveExtraDataSignature = 'P' | ('K' << 8) | (6 << 16) | (7 << 24); |
|||
|
|||
/// <summary>
|
|||
/// Central header digitial signature
|
|||
/// </summary>
|
|||
public const int CentralHeaderDigitalSignature = 'P' | ('K' << 8) | (5 << 16) | (5 << 24); |
|||
|
|||
/// <summary>
|
|||
/// End of central directory record signature
|
|||
/// </summary>
|
|||
public const int EndOfCentralDirectorySignature = 'P' | ('K' << 8) | (5 << 16) | (6 << 24); |
|||
|
|||
#endregion
|
|||
|
|||
#if NETCF_1_0 || NETCF_2_0
|
|||
// This isnt so great but is better than nothing.
|
|||
// Trying to work out an appropriate OEM code page would be good.
|
|||
// 850 is a good default for english speakers particularly in Europe.
|
|||
static int defaultCodePage = CultureInfo.CurrentCulture.TextInfo.ANSICodePage; |
|||
#elif PCL
|
|||
static Encoding defaultEncoding = Encoding.UTF8; |
|||
#else
|
|||
/// <remarks>
|
|||
/// Get OEM codepage from NetFX, which parses the NLP file with culture info table etc etc.
|
|||
/// But sometimes it yields the special value of 1 which is nicknamed <c>CodePageNoOEM</c> in <see cref="Encoding"/> sources (might also mean <c>CP_OEMCP</c>, but Encoding puts it so).
|
|||
/// This was observed on Ukranian and Hindu systems.
|
|||
/// Given this value, <see cref="Encoding.GetEncoding(int)"/> throws an <see cref="ArgumentException"/>.
|
|||
/// So replace it with some fallback, e.g. 437 which is the default cpcp in a console in a default Windows installation.
|
|||
/// </remarks>
|
|||
static int defaultCodePage = |
|||
// these values cause ArgumentException in subsequent calls to Encoding::GetEncoding()
|
|||
((Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage == 1) || (Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage == 2) || (Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage == 3) || (Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage == 42)) |
|||
? 437 // The default OEM encoding in a console in a default Windows installation, as a fallback.
|
|||
: Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage; |
|||
#endif
|
|||
#if !PCL
|
|||
/// <summary>
|
|||
/// Default encoding used for string conversion. 0 gives the default system OEM code page.
|
|||
/// Dont use unicode encodings if you want to be Zip compatible!
|
|||
/// Using the default code page isnt the full solution neccessarily
|
|||
/// there are many variable factors, codepage 850 is often a good choice for
|
|||
/// European users, however be careful about compatability.
|
|||
/// </summary>
|
|||
public static int DefaultCodePage { |
|||
get { |
|||
return defaultCodePage; |
|||
} |
|||
set { |
|||
if ((value < 0) || (value > 65535) || |
|||
(value == 1) || (value == 2) || (value == 3) || (value == 42)) { |
|||
throw new ArgumentOutOfRangeException("value"); |
|||
} |
|||
|
|||
defaultCodePage = value; |
|||
} |
|||
} |
|||
#else
|
|||
/// <summary>
|
|||
/// PCL don't support CodePage so we used Encoding instead of
|
|||
/// </summary>
|
|||
public static Encoding DefaultEncoding |
|||
{ |
|||
get |
|||
{ |
|||
return defaultEncoding; |
|||
} |
|||
set |
|||
{ |
|||
defaultEncoding = value; |
|||
} |
|||
} |
|||
#endif
|
|||
|
|||
/// <summary>
|
|||
/// Convert a portion of a byte array to a string.
|
|||
/// </summary>
|
|||
/// <param name="data">
|
|||
/// Data to convert to string
|
|||
/// </param>
|
|||
/// <param name="count">
|
|||
/// Number of bytes to convert starting from index 0
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// data[0]..data[count - 1] converted to a string
|
|||
/// </returns>
|
|||
public static string ConvertToString(byte[] data, int count) |
|||
{ |
|||
if (data == null) |
|||
{ |
|||
return string.Empty; |
|||
} |
|||
#if !PCL
|
|||
return Encoding.GetEncoding(DefaultCodePage).GetString(data, 0, count); |
|||
#else
|
|||
return DefaultEncoding.GetString(data, 0, count); |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert a byte array to string
|
|||
/// </summary>
|
|||
/// <param name="data">
|
|||
/// Byte array to convert
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// <paramref name="data">data</paramref>converted to a string
|
|||
/// </returns>
|
|||
public static string ConvertToString(byte[] data) |
|||
{ |
|||
if (data == null) |
|||
{ |
|||
return string.Empty; |
|||
} |
|||
return ConvertToString(data, data.Length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert a byte array to string
|
|||
/// </summary>
|
|||
/// <param name="flags">The applicable general purpose bits flags</param>
|
|||
/// <param name="data">
|
|||
/// Byte array to convert
|
|||
/// </param>
|
|||
/// <param name="count">The number of bytes to convert.</param>
|
|||
/// <returns>
|
|||
/// <paramref name="data">data</paramref>converted to a string
|
|||
/// </returns>
|
|||
public static string ConvertToStringExt(int flags, byte[] data, int count) |
|||
{ |
|||
if (data == null) |
|||
{ |
|||
return string.Empty; |
|||
} |
|||
|
|||
if ((flags & (int)GeneralBitFlags.UnicodeText) != 0) |
|||
{ |
|||
return Encoding.UTF8.GetString(data, 0, count); |
|||
} |
|||
else |
|||
{ |
|||
return ConvertToString(data, count); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert a byte array to string
|
|||
/// </summary>
|
|||
/// <param name="data">
|
|||
/// Byte array to convert
|
|||
/// </param>
|
|||
/// <param name="flags">The applicable general purpose bits flags</param>
|
|||
/// <returns>
|
|||
/// <paramref name="data">data</paramref>converted to a string
|
|||
/// </returns>
|
|||
public static string ConvertToStringExt(int flags, byte[] data) |
|||
{ |
|||
if (data == null) |
|||
{ |
|||
return string.Empty; |
|||
} |
|||
|
|||
if ((flags & (int)GeneralBitFlags.UnicodeText) != 0) |
|||
{ |
|||
return Encoding.UTF8.GetString(data, 0, data.Length); |
|||
} |
|||
else |
|||
{ |
|||
return ConvertToString(data, data.Length); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert a string to a byte array
|
|||
/// </summary>
|
|||
/// <param name="str">
|
|||
/// String to convert to an array
|
|||
/// </param>
|
|||
/// <returns>Converted array</returns>
|
|||
public static byte[] ConvertToArray(string str) |
|||
{ |
|||
if (str == null) |
|||
{ |
|||
return new byte[0]; |
|||
} |
|||
#if !PCL
|
|||
return Encoding.GetEncoding(DefaultCodePage).GetBytes(str); |
|||
#else
|
|||
return DefaultEncoding.GetBytes(str); |
|||
#endif
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert a string to a byte array
|
|||
/// </summary>
|
|||
/// <param name="flags">The applicable <see cref="GeneralBitFlags">general purpose bits flags</see></param>
|
|||
/// <param name="str">
|
|||
/// String to convert to an array
|
|||
/// </param>
|
|||
/// <returns>Converted array</returns>
|
|||
public static byte[] ConvertToArray(int flags, string str) |
|||
{ |
|||
if (str == null) |
|||
{ |
|||
return new byte[0]; |
|||
} |
|||
|
|||
if ((flags & (int)GeneralBitFlags.UnicodeText) != 0) |
|||
{ |
|||
return Encoding.UTF8.GetBytes(str); |
|||
} |
|||
else |
|||
{ |
|||
return ConvertToArray(str); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,5 +1,4 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<packages> |
|||
<package id="SharpZipLib.Portable" version="0.86.0.0002" targetFramework="portable-net45+win8+wp8" /> |
|||
<package id="StyleCop.Analyzers" version="1.0.0-beta015" targetFramework="portable-net45+dnxcore50+win+wpa81+wp80" developmentDependency="true" /> |
|||
<package id="StyleCop.Analyzers" version="1.0.0-beta015" targetFramework="portable45-net45+win8+wp8+wpa81" developmentDependency="true" /> |
|||
</packages> |
|||
Loading…
Reference in new issue