Remove SharpZipLib dependency

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: 24ab057fa4e1b0fada4c09071c537962db4b50e9

src/ImageProcessor/Formats/Png/PngDecoder.cs

@@ -31,7 +31,7 @@ namespace ImageProcessor.Formats
     ///     <item>Palette Index with alpha (8 bit).</item>
     ///     <item>Palette Index without alpha (8 bit).</item>
     /// </list>
-    /// </para> 
+    /// </para>
     /// </remarks>
     public class PngDecoder : IImageDecoder
     {

src/ImageProcessor/Formats/Png/PngDecoderCore.cs

@@ -16,8 +16,8 @@ namespace ImageProcessor.Formats
     using System.Linq;
     using System.Text;
 
-    using ICSharpCode.SharpZipLib.Checksums;
+    //using ICSharpCode.SharpZipLib.Checksums;
-    using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
+    //using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
 
     /// <summary>
     /// Performs the png decoding operation.

src/ImageProcessor/Formats/Png/PngEncoder.cs

@@ -8,8 +8,8 @@ namespace ImageProcessor.Formats
     using System;
     using System.IO;
 
-    using ICSharpCode.SharpZipLib.Checksums;
+    //using ICSharpCode.SharpZipLib.Checksums;
-    using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
+    //using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
 
     /// <summary>
     /// Image encoder for writing image data to a stream in png format.

src/ImageProcessor/Formats/Png/Zlib/Adler32.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/Crc32.cs

@@ -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;
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/DeflateStrategy.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/Deflater.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/DeflaterConstants.cs

@@ -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 };
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/DeflaterEngine.cs

@@ -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 &amp; 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 &amp; 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 &lt;= 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;
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/DeflaterHuffman.cs

@@ -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;
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/DeflaterOutputStream.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/DeflaterPending.cs

@@ -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)
+        {
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/GeneralBitFlags.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/IChecksum.cs

@@ -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);
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/Inflater.cs

@@ -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;
+            }
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/InflaterDynHeader.cs

@@ -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
+
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/InflaterHuffmanTree.cs

@@ -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;
+                }
+            }
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/InflaterInputBuffer.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/InflaterInputStream.cs

@@ -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
+    }
+}
+

src/ImageProcessor/Formats/Png/Zlib/OutputWindow.cs

@@ -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;
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/PendingBuffer.cs

@@ -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;
+        }
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/StreamManipulator.cs

@@ -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
+    }
+}

src/ImageProcessor/Formats/Png/Zlib/ZipConstants.cs

@@ -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);
+            }
+        }
+    }
+}

src/ImageProcessor/ImageProcessor.csproj

@@ -17,14 +17,15 @@
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
-    <NuGetPackageImportStamp>cfa9b76b</NuGetPackageImportStamp>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;NOCRYPTO;PCL</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <DocumentationFile>bin\Debug\ImageProcessor.XML</DocumentationFile>
@@ -40,6 +41,9 @@
   </PropertyGroup>
   <ItemGroup>
     <!-- A reference to the entire .NET Framework is automatically included -->
+    <Analyzer Include="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\analyzers\dotnet\cs\Newtonsoft.Json.dll" />
+    <Analyzer Include="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\analyzers\dotnet\cs\StyleCop.Analyzers.CodeFixes.dll" />
+    <Analyzer Include="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\analyzers\dotnet\cs\StyleCop.Analyzers.dll" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Colors\Cmyk.cs" />
@@ -57,6 +61,26 @@
     <Compile Include="Filters\ColorMatrix\Invert.cs" />
     <Compile Include="Filters\Contrast.cs" />
     <Compile Include="Filters\ImageFilterExtensions.cs" />
+    <Compile Include="Formats\Png\Zlib\Adler32.cs" />
+    <Compile Include="Formats\Png\Zlib\InflaterDynHeader.cs" />
+    <Compile Include="Formats\Png\Zlib\InflaterHuffmanTree.cs" />
+    <Compile Include="Formats\Png\Zlib\Crc32.cs" />
+    <Compile Include="Formats\Png\Zlib\Deflater.cs" />
+    <Compile Include="Formats\Png\Zlib\DeflaterConstants.cs" />
+    <Compile Include="Formats\Png\Zlib\DeflaterEngine.cs" />
+    <Compile Include="Formats\Png\Zlib\DeflaterHuffman.cs" />
+    <Compile Include="Formats\Png\Zlib\DeflaterOutputStream.cs" />
+    <Compile Include="Formats\Png\Zlib\DeflaterPending.cs" />
+    <Compile Include="Formats\Png\Zlib\DeflateStrategy.cs" />
+    <Compile Include="Formats\Png\Zlib\GeneralBitFlags.cs" />
+    <Compile Include="Formats\Png\Zlib\IChecksum.cs" />
+    <Compile Include="Formats\Png\Zlib\Inflater.cs" />
+    <Compile Include="Formats\Png\Zlib\InflaterInputBuffer.cs" />
+    <Compile Include="Formats\Png\Zlib\InflaterInputStream.cs" />
+    <Compile Include="Formats\Png\Zlib\OutputWindow.cs" />
+    <Compile Include="Formats\Png\Zlib\PendingBuffer.cs" />
+    <Compile Include="Formats\Png\Zlib\StreamManipulator.cs" />
+    <Compile Include="Formats\Png\Zlib\ZipConstants.cs" />
     <Compile Include="ImageExtensions.cs" />
     <Compile Include="ParallelImageProcessor.cs" />
     <Compile Include="IImageProcessor.cs" />
@@ -211,12 +235,6 @@
     <Compile Include="Samplers\Resamplers\IResampler.cs" />
     <Compile Include="Samplers\Resize.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <Reference Include="ICSharpCode.SharpZipLib.Portable, Version=0.86.0.51802, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\SharpZipLib.Portable.0.86.0.0002\lib\portable-net45+netcore45+wp8+win8+wpa81+MonoTouch+MonoAndroid\ICSharpCode.SharpZipLib.Portable.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-  </ItemGroup>
   <ItemGroup>
     <None Include="Formats\Gif\README.md" />
     <None Include="Formats\Jpg\README.md" />
@@ -227,18 +245,15 @@
     <None Include="Formats\Bmp\README.md" />
     <None Include="Formats\Png\README.md" />
   </ItemGroup>
-  <ItemGroup>
+  <ItemGroup />
-    <Analyzer Include="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\analyzers\dotnet\cs\Newtonsoft.Json.dll" />
-    <Analyzer Include="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\analyzers\dotnet\cs\StyleCop.Analyzers.dll" />
-  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+  <Import Project="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\build\StyleCop.Analyzers.targets" Condition="Exists('..\..\packages\StyleCop.Analyzers.1.0.0-beta015\build\StyleCop.Analyzers.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
     <Error Condition="!Exists('..\..\packages\StyleCop.Analyzers.1.0.0-beta015\build\StyleCop.Analyzers.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\StyleCop.Analyzers.1.0.0-beta015\build\StyleCop.Analyzers.targets'))" />
   </Target>
-  <Import Project="..\..\packages\StyleCop.Analyzers.1.0.0-beta015\build\StyleCop.Analyzers.targets" Condition="Exists('..\..\packages\StyleCop.Analyzers.1.0.0-beta015\build\StyleCop.Analyzers.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">

src/ImageProcessor/ImageProcessor.csproj.DotSettings

@@ -14,5 +14,7 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=formats_005Cjpg/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=formats_005Cjpg_005Clibjpeg/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=formats_005Cpng/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=formats_005Cpng_005Czlib/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=formats_005Cpng_005Czlib2/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=numerics/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=samplers_005Cresamplers/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

src/ImageProcessor/packages.config

@@ -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="portable45-net45+win8+wp8+wpa81" developmentDependency="true" />
-  <package id="StyleCop.Analyzers" version="1.0.0-beta015" targetFramework="portable-net45+dnxcore50+win+wpa81+wp80" developmentDependency="true" />
 </packages>