You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
546 lines
21 KiB
546 lines
21 KiB
// Zlib.cs |
|
// ------------------------------------------------------------------ |
|
// |
|
// Copyright (c) 2009-2011 Dino Chiesa and Microsoft Corporation. |
|
// All rights reserved. |
|
// |
|
// This code module is part of DotNetZip, a zipfile class library. |
|
// |
|
// ------------------------------------------------------------------ |
|
// |
|
// This code is licensed under the Microsoft Public License. |
|
// See the file License.txt for the license details. |
|
// More info on: http://dotnetzip.codeplex.com |
|
// |
|
// ------------------------------------------------------------------ |
|
// |
|
// Last Saved: <2011-August-03 19:52:28> |
|
// |
|
// ------------------------------------------------------------------ |
|
// |
|
// This module defines classes for ZLIB compression and |
|
// decompression. This code is derived from the jzlib implementation of |
|
// zlib, but significantly modified. The object model is not the same, |
|
// and many of the behaviors are new or different. Nonetheless, in |
|
// keeping with the license for jzlib, the copyright to that code is |
|
// included below. |
|
// |
|
// ------------------------------------------------------------------ |
|
// |
|
// The following notice applies to jzlib: |
|
// |
|
// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved. |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are met: |
|
// |
|
// 1. Redistributions of source code must retain the above copyright notice, |
|
// this list of conditions and the following disclaimer. |
|
// |
|
// 2. Redistributions in binary form must reproduce the above copyright |
|
// notice, this list of conditions and the following disclaimer in |
|
// the documentation and/or other materials provided with the distribution. |
|
// |
|
// 3. The names of the authors may not be used to endorse or promote products |
|
// derived from this software without specific prior written permission. |
|
// |
|
// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, |
|
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
|
// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, |
|
// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, |
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, |
|
// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
|
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
|
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
|
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
// |
|
// ----------------------------------------------------------------------- |
|
// |
|
// jzlib is based on zlib-1.1.3. |
|
// |
|
// The following notice applies to zlib: |
|
// |
|
// ----------------------------------------------------------------------- |
|
// |
|
// Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler |
|
// |
|
// The ZLIB software is provided 'as-is', without any express or implied |
|
// warranty. In no event will the authors be held liable for any damages |
|
// arising from the use of this software. |
|
// |
|
// Permission is granted to anyone to use this software for any purpose, |
|
// including commercial applications, and to alter it and redistribute it |
|
// freely, subject to the following restrictions: |
|
// |
|
// 1. The origin of this software must not be misrepresented; you must not |
|
// claim that you wrote the original software. If you use this software |
|
// in a product, an acknowledgment in the product documentation would be |
|
// appreciated but is not required. |
|
// 2. Altered source versions must be plainly marked as such, and must not be |
|
// misrepresented as being the original software. |
|
// 3. This notice may not be removed or altered from any source distribution. |
|
// |
|
// Jean-loup Gailly jloup@gzip.org |
|
// Mark Adler madler@alumni.caltech.edu |
|
// |
|
// ----------------------------------------------------------------------- |
|
|
|
|
|
|
|
using System; |
|
using Interop=System.Runtime.InteropServices; |
|
|
|
namespace BestHTTP.Decompression.Zlib |
|
{ |
|
|
|
/// <summary> |
|
/// Describes how to flush the current deflate operation. |
|
/// </summary> |
|
/// <remarks> |
|
/// The different FlushType values are useful when using a Deflate in a streaming application. |
|
/// </remarks> |
|
public enum FlushType |
|
{ |
|
/// <summary>No flush at all.</summary> |
|
None = 0, |
|
|
|
/// <summary>Closes the current block, but doesn't flush it to |
|
/// the output. Used internally only in hypothetical |
|
/// scenarios. This was supposed to be removed by Zlib, but it is |
|
/// still in use in some edge cases. |
|
/// </summary> |
|
Partial, |
|
|
|
/// <summary> |
|
/// Use this during compression to specify that all pending output should be |
|
/// flushed to the output buffer and the output should be aligned on a byte |
|
/// boundary. You might use this in a streaming communication scenario, so that |
|
/// the decompressor can get all input data available so far. When using this |
|
/// with a ZlibCodec, <c>AvailableBytesIn</c> will be zero after the call if |
|
/// enough output space has been provided before the call. Flushing will |
|
/// degrade compression and so it should be used only when necessary. |
|
/// </summary> |
|
Sync, |
|
|
|
/// <summary> |
|
/// Use this during compression to specify that all output should be flushed, as |
|
/// with <c>FlushType.Sync</c>, but also, the compression state should be reset |
|
/// so that decompression can restart from this point if previous compressed |
|
/// data has been damaged or if random access is desired. Using |
|
/// <c>FlushType.Full</c> too often can significantly degrade the compression. |
|
/// </summary> |
|
Full, |
|
|
|
/// <summary>Signals the end of the compression/decompression stream.</summary> |
|
Finish, |
|
} |
|
|
|
|
|
/// <summary> |
|
/// The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress. |
|
/// </summary> |
|
public enum CompressionLevel |
|
{ |
|
/// <summary> |
|
/// None means that the data will be simply stored, with no change at all. |
|
/// If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None |
|
/// cannot be opened with the default zip reader. Use a different CompressionLevel. |
|
/// </summary> |
|
None= 0, |
|
/// <summary> |
|
/// Same as None. |
|
/// </summary> |
|
Level0 = 0, |
|
|
|
/// <summary> |
|
/// The fastest but least effective compression. |
|
/// </summary> |
|
BestSpeed = 1, |
|
|
|
/// <summary> |
|
/// A synonym for BestSpeed. |
|
/// </summary> |
|
Level1 = 1, |
|
|
|
/// <summary> |
|
/// A little slower, but better, than level 1. |
|
/// </summary> |
|
Level2 = 2, |
|
|
|
/// <summary> |
|
/// A little slower, but better, than level 2. |
|
/// </summary> |
|
Level3 = 3, |
|
|
|
/// <summary> |
|
/// A little slower, but better, than level 3. |
|
/// </summary> |
|
Level4 = 4, |
|
|
|
/// <summary> |
|
/// A little slower than level 4, but with better compression. |
|
/// </summary> |
|
Level5 = 5, |
|
|
|
/// <summary> |
|
/// The default compression level, with a good balance of speed and compression efficiency. |
|
/// </summary> |
|
Default = 6, |
|
/// <summary> |
|
/// A synonym for Default. |
|
/// </summary> |
|
Level6 = 6, |
|
|
|
/// <summary> |
|
/// Pretty good compression! |
|
/// </summary> |
|
Level7 = 7, |
|
|
|
/// <summary> |
|
/// Better compression than Level7! |
|
/// </summary> |
|
Level8 = 8, |
|
|
|
/// <summary> |
|
/// The "best" compression, where best means greatest reduction in size of the input data stream. |
|
/// This is also the slowest compression. |
|
/// </summary> |
|
BestCompression = 9, |
|
|
|
/// <summary> |
|
/// A synonym for BestCompression. |
|
/// </summary> |
|
Level9 = 9, |
|
} |
|
|
|
/// <summary> |
|
/// Describes options for how the compression algorithm is executed. Different strategies |
|
/// work better on different sorts of data. The strategy parameter can affect the compression |
|
/// ratio and the speed of compression but not the correctness of the compresssion. |
|
/// </summary> |
|
public enum CompressionStrategy |
|
{ |
|
/// <summary> |
|
/// The default strategy is probably the best for normal data. |
|
/// </summary> |
|
Default = 0, |
|
|
|
/// <summary> |
|
/// The <c>Filtered</c> strategy is intended to be used most effectively with data produced by a |
|
/// filter or predictor. By this definition, filtered data consists mostly of small |
|
/// values with a somewhat random distribution. In this case, the compression algorithm |
|
/// is tuned to compress them better. The effect of <c>Filtered</c> is to force more Huffman |
|
/// coding and less string matching; it is a half-step between <c>Default</c> and <c>HuffmanOnly</c>. |
|
/// </summary> |
|
Filtered = 1, |
|
|
|
/// <summary> |
|
/// Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no |
|
/// string matching. |
|
/// </summary> |
|
HuffmanOnly = 2, |
|
} |
|
|
|
|
|
/// <summary> |
|
/// An enum to specify the direction of transcoding - whether to compress or decompress. |
|
/// </summary> |
|
public enum CompressionMode |
|
{ |
|
/// <summary> |
|
/// Used to specify that the stream should compress the data. |
|
/// </summary> |
|
Compress= 0, |
|
/// <summary> |
|
/// Used to specify that the stream should decompress the data. |
|
/// </summary> |
|
Decompress = 1, |
|
} |
|
|
|
|
|
/// <summary> |
|
/// A general purpose exception class for exceptions in the Zlib library. |
|
/// </summary> |
|
[Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000E")] |
|
internal class ZlibException : System.Exception |
|
{ |
|
/// <summary> |
|
/// The ZlibException class captures exception information generated |
|
/// by the Zlib library. |
|
/// </summary> |
|
public ZlibException() |
|
: base() |
|
{ |
|
} |
|
|
|
/// <summary> |
|
/// This ctor collects a message attached to the exception. |
|
/// </summary> |
|
/// <param name="s">the message for the exception.</param> |
|
public ZlibException(System.String s) |
|
: base(s) |
|
{ |
|
} |
|
} |
|
|
|
|
|
internal class SharedUtils |
|
{ |
|
/// <summary> |
|
/// Performs an unsigned bitwise right shift with the specified number |
|
/// </summary> |
|
/// <param name="number">Number to operate on</param> |
|
/// <param name="bits">Ammount of bits to shift</param> |
|
/// <returns>The resulting number from the shift operation</returns> |
|
public static int URShift(int number, int bits) |
|
{ |
|
return (int)((uint)number >> bits); |
|
} |
|
|
|
#if NOT |
|
/// <summary> |
|
/// Performs an unsigned bitwise right shift with the specified number |
|
/// </summary> |
|
/// <param name="number">Number to operate on</param> |
|
/// <param name="bits">Ammount of bits to shift</param> |
|
/// <returns>The resulting number from the shift operation</returns> |
|
public static long URShift(long number, int bits) |
|
{ |
|
return (long) ((UInt64)number >> bits); |
|
} |
|
#endif |
|
|
|
/// <summary> |
|
/// Reads a number of characters from the current source TextReader and writes |
|
/// the data to the target array at the specified index. |
|
/// </summary> |
|
/// |
|
/// <param name="sourceTextReader">The source TextReader to read from</param> |
|
/// <param name="target">Contains the array of characteres read from the source TextReader.</param> |
|
/// <param name="start">The starting index of the target array.</param> |
|
/// <param name="count">The maximum number of characters to read from the source TextReader.</param> |
|
/// |
|
/// <returns> |
|
/// The number of characters read. The number will be less than or equal to |
|
/// count depending on the data available in the source TextReader. Returns -1 |
|
/// if the end of the stream is reached. |
|
/// </returns> |
|
public static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, byte[] target, int start, int count) |
|
{ |
|
// Returns 0 bytes if not enough space in target |
|
if (target.Length == 0) return 0; |
|
|
|
char[] charArray = new char[target.Length]; |
|
int bytesRead = sourceTextReader.Read(charArray, start, count); |
|
|
|
// Returns -1 if EOF |
|
if (bytesRead == 0) return -1; |
|
|
|
for (int index = start; index < start + bytesRead; index++) |
|
target[index] = (byte)charArray[index]; |
|
|
|
return bytesRead; |
|
} |
|
|
|
|
|
internal static byte[] ToByteArray(System.String sourceString) |
|
{ |
|
return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString); |
|
} |
|
|
|
|
|
internal static char[] ToCharArray(byte[] byteArray) |
|
{ |
|
return System.Text.UTF8Encoding.UTF8.GetChars(byteArray); |
|
} |
|
} |
|
|
|
internal static class InternalConstants |
|
{ |
|
internal static readonly int MAX_BITS = 15; |
|
internal static readonly int BL_CODES = 19; |
|
internal static readonly int D_CODES = 30; |
|
internal static readonly int LITERALS = 256; |
|
internal static readonly int LENGTH_CODES = 29; |
|
internal static readonly int L_CODES = (LITERALS + 1 + LENGTH_CODES); |
|
|
|
// Bit length codes must not exceed MAX_BL_BITS bits |
|
internal static readonly int MAX_BL_BITS = 7; |
|
|
|
// repeat previous bit length 3-6 times (2 bits of repeat count) |
|
internal static readonly int REP_3_6 = 16; |
|
|
|
// repeat a zero length 3-10 times (3 bits of repeat count) |
|
internal static readonly int REPZ_3_10 = 17; |
|
|
|
// repeat a zero length 11-138 times (7 bits of repeat count) |
|
internal static readonly int REPZ_11_138 = 18; |
|
|
|
} |
|
|
|
internal sealed class StaticTree |
|
{ |
|
internal static readonly short[] lengthAndLiteralsTreeCodes = new short[] { |
|
12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8, |
|
28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8, |
|
2, 8, 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8, |
|
18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8, |
|
10, 8, 138, 8, 74, 8, 202, 8, 42, 8, 170, 8, 106, 8, 234, 8, |
|
26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8, |
|
6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8, |
|
22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8, |
|
14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8, |
|
30, 8, 158, 8, 94, 8, 222, 8, 62, 8, 190, 8, 126, 8, 254, 8, |
|
1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8, |
|
17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113, 8, 241, 8, |
|
9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8, |
|
25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8, |
|
5, 8, 133, 8, 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8, |
|
21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8, |
|
13, 8, 141, 8, 77, 8, 205, 8, 45, 8, 173, 8, 109, 8, 237, 8, |
|
29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8, |
|
19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9, |
|
51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9, |
|
11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9, |
|
43, 9, 299, 9, 171, 9, 427, 9, 107, 9, 363, 9, 235, 9, 491, 9, |
|
27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9, |
|
59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379, 9, 251, 9, 507, 9, |
|
7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9, |
|
39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9, |
|
23, 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9, |
|
55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9, |
|
15, 9, 271, 9, 143, 9, 399, 9, 79, 9, 335, 9, 207, 9, 463, 9, |
|
47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9, |
|
31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, 223, 9, 479, 9, |
|
63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9, |
|
0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7, |
|
8, 7, 72, 7, 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7, |
|
4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7, |
|
3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8, 99, 8, 227, 8 |
|
}; |
|
|
|
internal static readonly short[] distTreeCodes = new short[] { |
|
0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5, |
|
2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5, |
|
1, 5, 17, 5, 9, 5, 25, 5, 5, 5, 21, 5, 13, 5, 29, 5, |
|
3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5 }; |
|
|
|
internal static readonly StaticTree Literals; |
|
internal static readonly StaticTree Distances; |
|
internal static readonly StaticTree BitLengths; |
|
|
|
internal short[] treeCodes; // static tree or null |
|
internal int[] extraBits; // extra bits for each code or null |
|
internal int extraBase; // base index for extra_bits |
|
internal int elems; // max number of elements in the tree |
|
internal int maxLength; // max bit length for the codes |
|
|
|
private StaticTree(short[] treeCodes, int[] extraBits, int extraBase, int elems, int maxLength) |
|
{ |
|
this.treeCodes = treeCodes; |
|
this.extraBits = extraBits; |
|
this.extraBase = extraBase; |
|
this.elems = elems; |
|
this.maxLength = maxLength; |
|
} |
|
static StaticTree() |
|
{ |
|
Literals = new StaticTree(lengthAndLiteralsTreeCodes, ZTree.ExtraLengthBits, InternalConstants.LITERALS + 1, InternalConstants.L_CODES, InternalConstants.MAX_BITS); |
|
Distances = new StaticTree(distTreeCodes, ZTree.ExtraDistanceBits, 0, InternalConstants.D_CODES, InternalConstants.MAX_BITS); |
|
BitLengths = new StaticTree(null, ZTree.extra_blbits, 0, InternalConstants.BL_CODES, InternalConstants.MAX_BL_BITS); |
|
} |
|
} |
|
|
|
|
|
|
|
/// <summary> |
|
/// Computes an Adler-32 checksum. |
|
/// </summary> |
|
/// <remarks> |
|
/// The Adler checksum is similar to a CRC checksum, but faster to compute, though less |
|
/// reliable. It is used in producing RFC1950 compressed streams. The Adler checksum |
|
/// is a required part of the "ZLIB" standard. Applications will almost never need to |
|
/// use this class directly. |
|
/// </remarks> |
|
/// |
|
/// <exclude/> |
|
public sealed class Adler |
|
{ |
|
// largest prime smaller than 65536 |
|
private static readonly uint BASE = 65521; |
|
// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 |
|
private static readonly int NMAX = 5552; |
|
|
|
|
|
#pragma warning disable 3001 |
|
#pragma warning disable 3002 |
|
|
|
/// <summary> |
|
/// Calculates the Adler32 checksum. |
|
/// </summary> |
|
/// <remarks> |
|
/// <para> |
|
/// This is used within ZLIB. You probably don't need to use this directly. |
|
/// </para> |
|
/// </remarks> |
|
/// <example> |
|
/// To compute an Adler32 checksum on a byte array: |
|
/// <code> |
|
/// var adler = Adler.Adler32(0, null, 0, 0); |
|
/// adler = Adler.Adler32(adler, buffer, index, length); |
|
/// </code> |
|
/// </example> |
|
public static uint Adler32(uint adler, byte[] buf, int index, int len) |
|
{ |
|
if (buf == null) |
|
return 1; |
|
|
|
uint s1 = (uint) (adler & 0xffff); |
|
uint s2 = (uint) ((adler >> 16) & 0xffff); |
|
|
|
while (len > 0) |
|
{ |
|
int k = len < NMAX ? len : NMAX; |
|
len -= k; |
|
while (k >= 16) |
|
{ |
|
//s1 += (buf[index++] & 0xff); s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
s1 += buf[index++]; s2 += s1; |
|
k -= 16; |
|
} |
|
if (k != 0) |
|
{ |
|
do |
|
{ |
|
s1 += buf[index++]; |
|
s2 += s1; |
|
} |
|
while (--k != 0); |
|
} |
|
s1 %= BASE; |
|
s2 %= BASE; |
|
} |
|
return (uint)((s2 << 16) | s1); |
|
} |
|
#pragma warning restore 3001 |
|
#pragma warning restore 3002 |
|
|
|
} |
|
|
|
} |