From e6539c60d3485a465a2242c95f59d35942d1d2d6 Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Tue, 25 Apr 2017 00:09:50 +0100
Subject: [PATCH 01/24] Performance improvements

Stop the copy from deframing to inflate
Removed the pixel by pixel processing for RgbWithAlpha
Cleaned up the Crc check on the inflated stream
---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs  | 306 ++++++++++--------
 src/ImageSharp/Formats/Png/PngEncoderCore.cs  |   4 +-
 src/ImageSharp/Formats/Png/PngHeader.cs       |   2 +-
 src/ImageSharp/Formats/Png/Zlib/Adler32.cs    |  17 +-
 .../Formats/Png/Zlib/DeframeStream.cs         | 121 +++++++
 5 files changed, 306 insertions(+), 144 deletions(-)
 create mode 100644 src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 58cfa6a70b..4a859d5420 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -24,7 +24,14 @@ namespace ImageSharp.Formats
         /// <summary>
         /// The dictionary of available color types.
         /// </summary>
-        private static readonly Dictionary<int, byte[]> ColorTypes = new Dictionary<int, byte[]>();
+        private static readonly Dictionary<PngColorType, byte[]> ColorTypes = new Dictionary<PngColorType, byte[]>()
+        {
+            [PngColorType.Grayscale] = new byte[] { 1, 2, 4, 8 },
+            [PngColorType.Rgb] = new byte[] { 8 },
+            [PngColorType.Palette] = new byte[] { 1, 2, 4, 8 },
+            [PngColorType.GrayscaleWithAlpha] = new byte[] { 8 },
+            [PngColorType.RgbWithAlpha] = new byte[] { 8 },
+        };
 
         /// <summary>
         /// The amount to increment when processing each column per scanline for each interlaced pass
@@ -122,20 +129,24 @@ namespace ImageSharp.Formats
         private bool isEndChunkReached;
 
         /// <summary>
-        /// Initializes static members of the <see cref="PngDecoderCore"/> class.
+        /// Previous scanline processed
         /// </summary>
-        static PngDecoderCore()
-        {
-            ColorTypes.Add((int)PngColorType.Grayscale, new byte[] { 1, 2, 4, 8 });
+        private byte[] previousScanline;
 
-            ColorTypes.Add((int)PngColorType.Rgb, new byte[] { 8 });
-
-            ColorTypes.Add((int)PngColorType.Palette, new byte[] { 1, 2, 4, 8 });
+        /// <summary>
+        /// The current scanline that is being processed
+        /// </summary>
+        private byte[] scanline;
 
-            ColorTypes.Add((int)PngColorType.GrayscaleWithAlpha, new byte[] { 8 });
+        /// <summary>
+        /// The index of the current scanline being processed
+        /// </summary>
+        private int currentRow = 0;
 
-            ColorTypes.Add((int)PngColorType.RgbWithAlpha, new byte[] { 8 });
-        }
+        /// <summary>
+        /// The current number of bytes read in the current scanline
+        /// </summary>
+        private int currentRowBytesRead = 0;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PngDecoderCore"/> class.
@@ -171,65 +182,76 @@ namespace ImageSharp.Formats
             ImageMetaData metadata = new ImageMetaData();
             this.currentStream = stream;
             this.currentStream.Skip(8);
-
-            using (MemoryStream dataStream = new MemoryStream())
+            Image<TPixel> image = null;
+            PixelAccessor<TPixel> pixels = null;
+            try
             {
-                PngChunk currentChunk;
-                while (!this.isEndChunkReached && (currentChunk = this.ReadChunk()) != null)
+                using (DeframeStream deframeStream = new DeframeStream(this.currentStream))
                 {
-                    try
+                    PngChunk currentChunk;
+                    while (!this.isEndChunkReached && (currentChunk = this.ReadChunk()) != null)
                     {
-                        switch (currentChunk.Type)
+                        try
                         {
-                            case PngChunkTypes.Header:
-                                this.ReadHeaderChunk(currentChunk.Data);
-                                this.ValidateHeader();
-                                break;
-                            case PngChunkTypes.Physical:
-                                this.ReadPhysicalChunk(metadata, currentChunk.Data);
-                                break;
-                            case PngChunkTypes.Data:
-                                dataStream.Write(currentChunk.Data, 0, currentChunk.Length);
-                                break;
-                            case PngChunkTypes.Palette:
-                                byte[] pal = new byte[currentChunk.Length];
-                                Buffer.BlockCopy(currentChunk.Data, 0, pal, 0, currentChunk.Length);
-                                this.palette = pal;
-                                metadata.Quality = pal.Length / 3;
-                                break;
-                            case PngChunkTypes.PaletteAlpha:
-                                byte[] alpha = new byte[currentChunk.Length];
-                                Buffer.BlockCopy(currentChunk.Data, 0, alpha, 0, currentChunk.Length);
-                                this.paletteAlpha = alpha;
-                                break;
-                            case PngChunkTypes.Text:
-                                this.ReadTextChunk(metadata, currentChunk.Data, currentChunk.Length);
-                                break;
-                            case PngChunkTypes.End:
-                                this.isEndChunkReached = true;
-                                break;
+                            switch (currentChunk.Type)
+                            {
+                                case PngChunkTypes.Header:
+                                    this.ReadHeaderChunk(currentChunk.Data);
+                                    this.ValidateHeader();
+                                    break;
+                                case PngChunkTypes.Physical:
+                                    this.ReadPhysicalChunk(metadata, currentChunk.Data);
+                                    break;
+                                case PngChunkTypes.Data:
+                                    if (image == null)
+                                    {
+                                        this.InitializeImage(metadata, out image, out pixels);
+                                    }
+
+                                    deframeStream.AllocateNewBytes(currentChunk.Length);
+                                    this.ReadScanlines(deframeStream.CompressedStream, pixels);
+                                    stream.Read(this.crcBuffer, 0, 4);
+                                    break;
+                                case PngChunkTypes.Palette:
+                                    byte[] pal = new byte[currentChunk.Length];
+                                    Buffer.BlockCopy(currentChunk.Data, 0, pal, 0, currentChunk.Length);
+                                    this.palette = pal;
+                                    metadata.Quality = pal.Length / 3;
+                                    break;
+                                case PngChunkTypes.PaletteAlpha:
+                                    byte[] alpha = new byte[currentChunk.Length];
+                                    Buffer.BlockCopy(currentChunk.Data, 0, alpha, 0, currentChunk.Length);
+                                    this.paletteAlpha = alpha;
+                                    break;
+                                case PngChunkTypes.Text:
+                                    this.ReadTextChunk(metadata, currentChunk.Data, currentChunk.Length);
+                                    break;
+                                case PngChunkTypes.End:
+                                    this.isEndChunkReached = true;
+                                    break;
+                            }
+                        }
+                        finally
+                        {
+                            // Data is rented in ReadChunkData()
+                            if (currentChunk.Data != null)
+                            {
+                                ArrayPool<byte>.Shared.Return(currentChunk.Data);
+                            }
                         }
-                    }
-                    finally
-                    {
-                        // Data is rented in ReadChunkData()
-                        ArrayPool<byte>.Shared.Return(currentChunk.Data);
                     }
                 }
 
-                if (this.header.Width > Image<TPixel>.MaxWidth || this.header.Height > Image<TPixel>.MaxHeight)
-                {
-                    throw new ArgumentOutOfRangeException($"The input png '{this.header.Width}x{this.header.Height}' is bigger than the max allowed size '{Image<TPixel>.MaxWidth}x{Image<TPixel>.MaxHeight}'");
-                }
-
-                Image<TPixel> image = Image.Create<TPixel>(this.header.Width, this.header.Height, metadata, this.configuration);
-
-                using (PixelAccessor<TPixel> pixels = image.Lock())
+                return image;
+            }
+            finally
+            {
+                pixels?.Dispose();
+                if (this.previousScanline != null)
                 {
-                    this.ReadScanlines(dataStream, pixels);
+                    ArrayPool<byte>.Shared.Return(this.previousScanline);
+                    ArrayPool<byte>.Shared.Return(this.scanline);
                 }
-
-                return image;
             }
         }
 
@@ -293,6 +315,39 @@ namespace ImageSharp.Formats
             metadata.VerticalResolution = BitConverter.ToInt32(data, 4) / 39.3700787d;
         }
 
+        /// <summary>
+        /// Initializes the image and various buffers needed for processing
+        /// </summary>
+        /// <typeparam name="TPixel">The type the pixels will be</typeparam>
+        /// <param name="metadata">The metadata information for the image</param>
+        /// <param name="image">The image that we will populate</param>
+        /// <param name="pixels">The pixel accessor</param>
+        private void InitializeImage<TPixel>(ImageMetaData metadata, out Image<TPixel> image, out PixelAccessor<TPixel> pixels)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            if (this.header.Width > Image<TPixel>.MaxWidth || this.header.Height > Image<TPixel>.MaxHeight)
+            {
+                throw new ArgumentOutOfRangeException($"The input png '{this.header.Width}x{this.header.Height}' is bigger than the max allowed size '{Image<TPixel>.MaxWidth}x{Image<TPixel>.MaxHeight}'");
+            }
+
+            image = Image.Create<TPixel>(this.header.Width, this.header.Height, metadata, this.configuration);
+            pixels = image.Lock();
+            this.bytesPerPixel = this.CalculateBytesPerPixel();
+            this.bytesPerScanline = this.CalculateScanlineLength(this.header.Width) + 1;
+            this.bytesPerSample = 1;
+            if (this.header.BitDepth >= 8)
+            {
+                this.bytesPerSample = this.header.BitDepth / 8;
+            }
+
+            this.previousScanline = ArrayPool<byte>.Shared.Rent(this.bytesPerScanline);
+            this.scanline = ArrayPool<byte>.Shared.Rent(this.bytesPerScanline);
+
+            // Zero out the scanlines, because the bytes that are rented from the arraypool may not be zero.
+            Array.Clear(this.scanline, 0, this.bytesPerScanline);
+            Array.Clear(this.previousScanline, 0, this.bytesPerScanline);
+        }
+
         /// <summary>
         /// Calculates the correct number of bytes per pixel for the given color type.
         /// </summary>
@@ -345,28 +400,16 @@ namespace ImageSharp.Formats
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="dataStream">The <see cref="MemoryStream"/> containing data.</param>
         /// <param name="pixels"> The pixel data.</param>
-        private void ReadScanlines<TPixel>(MemoryStream dataStream, PixelAccessor<TPixel> pixels)
+        private void ReadScanlines<TPixel>(Stream dataStream, PixelAccessor<TPixel> pixels)
             where TPixel : struct, IPixel<TPixel>
         {
-            this.bytesPerPixel = this.CalculateBytesPerPixel();
-            this.bytesPerScanline = this.CalculateScanlineLength(this.header.Width) + 1;
-            this.bytesPerSample = 1;
-            if (this.header.BitDepth >= 8)
+            if (this.header.InterlaceMethod == PngInterlaceMode.Adam7)
             {
-                this.bytesPerSample = this.header.BitDepth / 8;
+                this.DecodeInterlacedPixelData(dataStream, pixels);
             }
-
-            dataStream.Position = 0;
-            using (ZlibInflateStream compressedStream = new ZlibInflateStream(dataStream))
+            else
             {
-                if (this.header.InterlaceMethod == PngInterlaceMode.Adam7)
-                {
-                    this.DecodeInterlacedPixelData(compressedStream, pixels);
-                }
-                else
-                {
-                    this.DecodePixelData(compressedStream, pixels);
-                }
+                this.DecodePixelData(dataStream, pixels);
             }
         }
 
@@ -379,66 +422,58 @@ namespace ImageSharp.Formats
         private void DecodePixelData<TPixel>(Stream compressedStream, PixelAccessor<TPixel> pixels)
             where TPixel : struct, IPixel<TPixel>
         {
-            byte[] previousScanline = ArrayPool<byte>.Shared.Rent(this.bytesPerScanline);
-            byte[] scanline = ArrayPool<byte>.Shared.Rent(this.bytesPerScanline);
-
-            // Zero out the scanlines, because the bytes that are rented from the arraypool may not be zero.
-            Array.Clear(scanline, 0, this.bytesPerScanline);
-            Array.Clear(previousScanline, 0, this.bytesPerScanline);
-
-            try
+            while (this.currentRow < this.header.Height)
             {
-                for (int y = 0; y < this.header.Height; y++)
+                int bytesRead = compressedStream.Read(this.scanline, this.currentRowBytesRead, this.bytesPerScanline - this.currentRowBytesRead);
+                this.currentRowBytesRead += bytesRead;
+                if (this.currentRowBytesRead < this.bytesPerScanline)
                 {
-                    compressedStream.Read(scanline, 0, this.bytesPerScanline);
+                    return;
+                }
 
-                    FilterType filterType = (FilterType)scanline[0];
+                this.currentRowBytesRead = 0;
+                FilterType filterType = (FilterType)this.scanline[0];
 
-                    switch (filterType)
-                    {
-                        case FilterType.None:
+                switch (filterType)
+                {
+                    case FilterType.None:
 
-                            NoneFilter.Decode(scanline);
+                        NoneFilter.Decode(this.scanline);
 
-                            break;
+                        break;
 
-                        case FilterType.Sub:
+                    case FilterType.Sub:
 
-                            SubFilter.Decode(scanline, this.bytesPerScanline, this.bytesPerPixel);
+                        SubFilter.Decode(this.scanline, this.bytesPerScanline, this.bytesPerPixel);
 
-                            break;
+                        break;
 
-                        case FilterType.Up:
+                    case FilterType.Up:
 
-                            UpFilter.Decode(scanline, previousScanline, this.bytesPerScanline);
+                        UpFilter.Decode(this.scanline, this.previousScanline, this.bytesPerScanline);
 
-                            break;
+                        break;
 
-                        case FilterType.Average:
+                    case FilterType.Average:
 
-                            AverageFilter.Decode(scanline, previousScanline, this.bytesPerScanline, this.bytesPerPixel);
+                        AverageFilter.Decode(this.scanline, this.previousScanline, this.bytesPerScanline, this.bytesPerPixel);
 
-                            break;
+                        break;
 
-                        case FilterType.Paeth:
+                    case FilterType.Paeth:
 
-                            PaethFilter.Decode(scanline, previousScanline, this.bytesPerScanline, this.bytesPerPixel);
+                        PaethFilter.Decode(this.scanline, this.previousScanline, this.bytesPerScanline, this.bytesPerPixel);
 
-                            break;
+                        break;
 
-                        default:
-                            throw new ImageFormatException("Unknown filter type.");
-                    }
+                    default:
+                        throw new ImageFormatException("Unknown filter type.");
+                }
 
-                    this.ProcessDefilteredScanline(scanline, y, pixels);
+                this.ProcessDefilteredScanline(this.scanline, this.currentRow, pixels);
 
-                    Swap(ref scanline, ref previousScanline);
-                }
-            }
-            finally
-            {
-                ArrayPool<byte>.Shared.Return(previousScanline);
-                ArrayPool<byte>.Shared.Return(scanline);
+                Swap(ref this.scanline, ref this.previousScanline);
+                this.currentRow++;
             }
         }
 
@@ -637,20 +672,30 @@ namespace ImageSharp.Formats
 
                 case PngColorType.RgbWithAlpha:
 
-                    for (int x = 0; x < this.header.Width; x++)
-                    {
-                        int offset = 1 + (x * this.bytesPerPixel);
+                    this.RgbWithAlpha(defilteredScanline, pixels);
 
-                        byte r = defilteredScanline[offset];
-                        byte g = defilteredScanline[offset + this.bytesPerSample];
-                        byte b = defilteredScanline[offset + (2 * this.bytesPerSample)];
-                        byte a = defilteredScanline[offset + (3 * this.bytesPerSample)];
+                    break;
+            }
+        }
 
-                        color.PackFromBytes(r, g, b, a);
-                        pixels[x, row] = color;
-                    }
+        /// <summary>
+        /// Processing the RGB with Alpha is a straight copy
+        /// </summary>
+        /// <typeparam name="TPixel">The type of pixel</typeparam>
+        /// <param name="defilteredScanline">The completed scanline</param>
+        /// <param name="pixels">The pixel accessor</param>
+        private unsafe void RgbWithAlpha<TPixel>(byte[] defilteredScanline, PixelAccessor<TPixel> pixels)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            int offset = this.bytesPerSample * 4;
+            int width = this.header.Width * offset;
+            int pixelId = this.currentRow * this.header.Width;
+            Rgba32[] pixelArray = pixels.PixelArray as Rgba32[];
 
-                    break;
+            fixed (byte* defilteredPointer = defilteredScanline)
+            fixed (Rgba32* pixelPtr = pixelArray)
+            {
+                Unsafe.CopyBlock(pixelPtr + pixelId, defilteredPointer + 1, (uint)(defilteredScanline.Length - 1));
             }
         }
 
@@ -819,7 +864,7 @@ namespace ImageSharp.Formats
             this.header.Height = BitConverter.ToInt32(data, 4);
 
             this.header.BitDepth = data[8];
-            this.header.ColorType = data[9];
+            this.header.ColorType = (PngColorType)data[9];
             this.header.CompressionMethod = data[10];
             this.header.FilterMethod = data[11];
             this.header.InterlaceMethod = (PngInterlaceMode)data[12];
@@ -872,6 +917,11 @@ namespace ImageSharp.Formats
             }
 
             this.ReadChunkType(chunk);
+            if (chunk.Type == PngChunkTypes.Data)
+            {
+                return chunk;
+            }
+
             this.ReadChunkData(chunk);
             this.ReadChunkCrc(chunk);
 
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index e30f9791e1..31e8cd90e2 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -181,7 +181,7 @@ namespace ImageSharp.Formats
             {
                 Width = image.Width,
                 Height = image.Height,
-                ColorType = (byte)this.pngColorType,
+                ColorType = this.pngColorType,
                 BitDepth = this.bitDepth,
                 FilterMethod = 0, // None
                 CompressionMethod = 0,
@@ -462,7 +462,7 @@ namespace ImageSharp.Formats
             WriteInteger(this.chunkDataBuffer, 4, header.Height);
 
             this.chunkDataBuffer[8] = header.BitDepth;
-            this.chunkDataBuffer[9] = header.ColorType;
+            this.chunkDataBuffer[9] = (byte)header.ColorType;
             this.chunkDataBuffer[10] = header.CompressionMethod;
             this.chunkDataBuffer[11] = header.FilterMethod;
             this.chunkDataBuffer[12] = (byte)header.InterlaceMethod;
diff --git a/src/ImageSharp/Formats/Png/PngHeader.cs b/src/ImageSharp/Formats/Png/PngHeader.cs
index f1d332c044..50d6cc9eca 100644
--- a/src/ImageSharp/Formats/Png/PngHeader.cs
+++ b/src/ImageSharp/Formats/Png/PngHeader.cs
@@ -34,7 +34,7 @@ namespace ImageSharp.Formats
         /// image data. Color type codes represent sums of the following values:
         /// 1 (palette used), 2 (color used), and 4 (alpha channel used).
         /// </summary>
-        public byte ColorType { get; set; }
+        public PngColorType ColorType { get; set; }
 
         /// <summary>
         /// Gets or sets the compression method.
diff --git a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
index 5f92cc9e09..e5101532c6 100644
--- a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
@@ -132,18 +132,13 @@ namespace ImageSharp.Formats
                 throw new ArgumentOutOfRangeException(nameof(count), "cannot be negative");
             }
 
-            if (offset >= buffer.Length)
-            {
-                throw new ArgumentOutOfRangeException(nameof(offset), "not a valid index into buffer");
-            }
-
             if (offset + count > buffer.Length)
             {
                 throw new ArgumentOutOfRangeException(nameof(count), "exceeds buffer size");
             }
 
             // (By Per Bothner)
-            uint s1 = this.checksum & 0xFFFF;
+            uint s1 = this.checksum;
             uint s2 = this.checksum >> 16;
 
             while (count > 0)
@@ -151,16 +146,12 @@ namespace ImageSharp.Formats
                 // 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;
-                }
+                int n = Math.Min(3800, count);
 
                 count -= n;
-                while (--n >= 0)
+                while (--n > -1)
                 {
-                    s1 = s1 + (uint)(buffer[offset++] & 0xff);
+                    s1 = s1 + buffer[offset++];
                     s2 = s2 + s1;
                 }
 
diff --git a/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs b/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
new file mode 100644
index 0000000000..9b0a61b675
--- /dev/null
+++ b/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
@@ -0,0 +1,121 @@
+namespace ImageSharp.Formats
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+
+    /// <summary>
+    /// Provides methods and properties for deframing streams from PNGs.
+    /// </summary>
+    internal class DeframeStream : Stream
+    {
+        /// <summary>
+        /// The inner raw memory stream
+        /// </summary>
+        private readonly Stream innerStream;
+
+        /// <summary>
+        /// The compressed stream sitting over the top of the deframer
+        /// </summary>
+        private ZlibInflateStream compressedStream;
+
+        /// <summary>
+        /// The current data remaining to be read
+        /// </summary>
+        private int currentDataRemaining;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeframeStream"/> class.
+        /// </summary>
+        /// <param name="innerStream">The inner raw stream</param>
+        public DeframeStream(Stream innerStream)
+        {
+            this.innerStream = innerStream;
+        }
+
+        /// <inheritdoc/>
+        public override bool CanRead => this.innerStream.CanRead;
+
+        /// <inheritdoc/>
+        public override bool CanSeek => false;
+
+        /// <inheritdoc/>
+        public override bool CanWrite => throw new NotSupportedException();
+
+        /// <inheritdoc/>
+        public override long Length => throw new NotSupportedException();
+
+        /// <inheritdoc/>
+        public override long Position { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        /// <summary>
+        /// Gets the compressed stream over the deframed inner stream
+        /// </summary>
+        public ZlibInflateStream CompressedStream => this.compressedStream;
+
+        /// <summary>
+        /// Adds new bytes from a frame found in the original stream
+        /// </summary>
+        /// <param name="bytes">blabla</param>
+        public void AllocateNewBytes(int bytes)
+        {
+            this.currentDataRemaining = bytes;
+            if (this.compressedStream == null)
+            {
+                this.compressedStream = new ZlibInflateStream(this);
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <inheritdoc/>
+        public override int ReadByte()
+        {
+            this.currentDataRemaining--;
+            return this.innerStream.ReadByte();
+        }
+
+        /// <inheritdoc/>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (this.currentDataRemaining == 0)
+            {
+                return 0;
+            }
+
+            int bytesToRead = Math.Min(count, this.currentDataRemaining);
+            this.currentDataRemaining -= bytesToRead;
+            return this.innerStream.Read(buffer, offset, bytesToRead);
+        }
+
+        /// <inheritdoc/>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <inheritdoc/>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <inheritdoc/>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <inheritdoc/>
+        protected override void Dispose(bool disposing)
+        {
+            this.compressedStream.Dispose();
+            base.Dispose(disposing);
+        }
+    }
+}

From 6667e796558ecd40239217dea95b92172c9745c2 Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Tue, 25 Apr 2017 20:43:19 +0100
Subject: [PATCH 02/24] Used the Bulk Pixel Packer

---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs | 40 +++++---------------
 1 file changed, 10 insertions(+), 30 deletions(-)

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 4a859d5420..73edd55b78 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -470,7 +470,7 @@ namespace ImageSharp.Formats
                         throw new ImageFormatException("Unknown filter type.");
                 }
 
-                this.ProcessDefilteredScanline(this.scanline, this.currentRow, pixels);
+                this.ProcessDefilteredScanline(this.scanline, pixels);
 
                 Swap(ref this.scanline, ref this.previousScanline);
                 this.currentRow++;
@@ -571,12 +571,13 @@ namespace ImageSharp.Formats
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="defilteredScanline">The de-filtered scanline</param>
-        /// <param name="row">The current image row.</param>
         /// <param name="pixels">The image pixels</param>
-        private void ProcessDefilteredScanline<TPixel>(byte[] defilteredScanline, int row, PixelAccessor<TPixel> pixels)
+        private void ProcessDefilteredScanline<TPixel>(byte[] defilteredScanline, PixelAccessor<TPixel> pixels)
             where TPixel : struct, IPixel<TPixel>
         {
             TPixel color = default(TPixel);
+            BufferSpan<TPixel> pixelBuffer = pixels.GetRowSpan(this.currentRow);
+            BufferSpan<byte> scanlineBuffer = new BufferSpan<byte>(defilteredScanline);
             switch (this.PngColorType)
             {
                 case PngColorType.Grayscale:
@@ -586,7 +587,7 @@ namespace ImageSharp.Formats
                     {
                         byte intensity = (byte)(newScanline1[x] * factor);
                         color.PackFromBytes(intensity, intensity, intensity, 255);
-                        pixels[x, row] = color;
+                        pixels[x, this.currentRow] = color;
                     }
 
                     break;
@@ -601,7 +602,7 @@ namespace ImageSharp.Formats
                         byte alpha = defilteredScanline[offset + this.bytesPerSample];
 
                         color.PackFromBytes(intensity, intensity, intensity, alpha);
-                        pixels[x, row] = color;
+                        pixels[x, this.currentRow] = color;
                     }
 
                     break;
@@ -633,7 +634,7 @@ namespace ImageSharp.Formats
                                 color.PackFromBytes(0, 0, 0, 0);
                             }
 
-                            pixels[x, row] = color;
+                            pixels[x, this.currentRow] = color;
                         }
                     }
                     else
@@ -648,7 +649,7 @@ namespace ImageSharp.Formats
                             byte b = this.palette[pixelOffset + 2];
 
                             color.PackFromBytes(r, g, b, 255);
-                            pixels[x, row] = color;
+                            pixels[x, this.currentRow] = color;
                         }
                     }
 
@@ -665,40 +666,19 @@ namespace ImageSharp.Formats
                         byte b = defilteredScanline[offset + (2 * this.bytesPerSample)];
 
                         color.PackFromBytes(r, g, b, 255);
-                        pixels[x, row] = color;
+                        pixels[x, this.currentRow] = color;
                     }
 
                     break;
 
                 case PngColorType.RgbWithAlpha:
 
-                    this.RgbWithAlpha(defilteredScanline, pixels);
+                    BulkPixelOperations<TPixel>.Instance.PackFromXyzwBytes(scanlineBuffer, pixelBuffer, this.header.Width);
 
                     break;
             }
         }
 
-        /// <summary>
-        /// Processing the RGB with Alpha is a straight copy
-        /// </summary>
-        /// <typeparam name="TPixel">The type of pixel</typeparam>
-        /// <param name="defilteredScanline">The completed scanline</param>
-        /// <param name="pixels">The pixel accessor</param>
-        private unsafe void RgbWithAlpha<TPixel>(byte[] defilteredScanline, PixelAccessor<TPixel> pixels)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            int offset = this.bytesPerSample * 4;
-            int width = this.header.Width * offset;
-            int pixelId = this.currentRow * this.header.Width;
-            Rgba32[] pixelArray = pixels.PixelArray as Rgba32[];
-
-            fixed (byte* defilteredPointer = defilteredScanline)
-            fixed (Rgba32* pixelPtr = pixelArray)
-            {
-                Unsafe.CopyBlock(pixelPtr + pixelId, defilteredPointer + 1, (uint)(defilteredScanline.Length - 1));
-            }
-        }
-
         /// <summary>
         /// Processes the interlaced de-filtered scanline filling the image pixel data
         /// </summary>

From 7c6bb5ee271c5ee37359c71abe6cdf68deb5ed6e Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Tue, 25 Apr 2017 20:52:38 +0100
Subject: [PATCH 03/24] Skip filter byte

---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 73edd55b78..4ed3fcecbc 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -577,7 +577,7 @@ namespace ImageSharp.Formats
         {
             TPixel color = default(TPixel);
             BufferSpan<TPixel> pixelBuffer = pixels.GetRowSpan(this.currentRow);
-            BufferSpan<byte> scanlineBuffer = new BufferSpan<byte>(defilteredScanline);
+            BufferSpan<byte> scanlineBuffer = new BufferSpan<byte>(defilteredScanline, 1);
             switch (this.PngColorType)
             {
                 case PngColorType.Grayscale:

From b1df833e4b8f8fb3f511d15232b163a65ad2bb2c Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Tue, 25 Apr 2017 23:28:10 +0100
Subject: [PATCH 04/24] Added bulk pixel operation for RGB

---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index 4ed3fcecbc..cf3b657cf2 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -657,17 +657,7 @@ namespace ImageSharp.Formats
 
                 case PngColorType.Rgb:
 
-                    for (int x = 0; x < this.header.Width; x++)
-                    {
-                        int offset = 1 + (x * this.bytesPerPixel);
-
-                        byte r = defilteredScanline[offset];
-                        byte g = defilteredScanline[offset + this.bytesPerSample];
-                        byte b = defilteredScanline[offset + (2 * this.bytesPerSample)];
-
-                        color.PackFromBytes(r, g, b, 255);
-                        pixels[x, this.currentRow] = color;
-                    }
+                    BulkPixelOperations<TPixel>.Instance.PackFromXyzBytes(scanlineBuffer, pixelBuffer, this.header.Width);
 
                     break;
 

From 50d39325467b94867a4ac5c38e01cd423e119098 Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Tue, 25 Apr 2017 23:33:52 +0100
Subject: [PATCH 05/24] Move the palette based color into it's own method and
 hoisted the palette to be local.

---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs | 100 +++++++++++--------
 1 file changed, 57 insertions(+), 43 deletions(-)

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index cf3b657cf2..d5b5bfd0eb 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -609,49 +609,7 @@ namespace ImageSharp.Formats
 
                 case PngColorType.Palette:
 
-                    byte[] newScanline = ToArrayByBitsLength(defilteredScanline, this.bytesPerScanline, this.header.BitDepth);
-
-                    if (this.paletteAlpha != null && this.paletteAlpha.Length > 0)
-                    {
-                        // If the alpha palette is not null and has one or more entries, this means, that the image contains an alpha
-                        // channel and we should try to read it.
-                        for (int x = 0; x < this.header.Width; x++)
-                        {
-                            int index = newScanline[x + 1];
-                            int pixelOffset = index * 3;
-
-                            byte a = this.paletteAlpha.Length > index ? this.paletteAlpha[index] : (byte)255;
-
-                            if (a > 0)
-                            {
-                                byte r = this.palette[pixelOffset];
-                                byte g = this.palette[pixelOffset + 1];
-                                byte b = this.palette[pixelOffset + 2];
-                                color.PackFromBytes(r, g, b, a);
-                            }
-                            else
-                            {
-                                color.PackFromBytes(0, 0, 0, 0);
-                            }
-
-                            pixels[x, this.currentRow] = color;
-                        }
-                    }
-                    else
-                    {
-                        for (int x = 0; x < this.header.Width; x++)
-                        {
-                            int index = newScanline[x + 1];
-                            int pixelOffset = index * 3;
-
-                            byte r = this.palette[pixelOffset];
-                            byte g = this.palette[pixelOffset + 1];
-                            byte b = this.palette[pixelOffset + 2];
-
-                            color.PackFromBytes(r, g, b, 255);
-                            pixels[x, this.currentRow] = color;
-                        }
-                    }
+                    this.ProcessScanlineFromPalette(defilteredScanline, pixels);
 
                     break;
 
@@ -669,6 +627,62 @@ namespace ImageSharp.Formats
             }
         }
 
+        /// <summary>
+        /// Processes a scanline that uses a palette
+        /// </summary>
+        /// <typeparam name="TPixel">The type of pixel we are expanding to</typeparam>
+        /// <param name="defilteredScanline">The scanline</param>
+        /// <param name="pixels">The output pixels</param>
+        private void ProcessScanlineFromPalette<TPixel>(byte[] defilteredScanline, PixelAccessor<TPixel> pixels)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            byte[] newScanline = ToArrayByBitsLength(defilteredScanline, this.bytesPerScanline, this.header.BitDepth);
+            byte[] palette = this.palette;
+            TPixel color = default(TPixel);
+
+            if (this.paletteAlpha != null && this.paletteAlpha.Length > 0)
+            {
+                // If the alpha palette is not null and has one or more entries, this means, that the image contains an alpha
+                // channel and we should try to read it.
+                for (int x = 0; x < this.header.Width; x++)
+                {
+                    int index = newScanline[x + 1];
+                    int pixelOffset = index * 3;
+
+                    byte a = this.paletteAlpha.Length > index ? this.paletteAlpha[index] : (byte)255;
+
+                    if (a > 0)
+                    {
+                        byte r = palette[pixelOffset];
+                        byte g = palette[pixelOffset + 1];
+                        byte b = palette[pixelOffset + 2];
+                        color.PackFromBytes(r, g, b, a);
+                    }
+                    else
+                    {
+                        color.PackFromBytes(0, 0, 0, 0);
+                    }
+
+                    pixels[x, this.currentRow] = color;
+                }
+            }
+            else
+            {
+                for (int x = 0; x < this.header.Width; x++)
+                {
+                    int index = newScanline[x + 1];
+                    int pixelOffset = index * 3;
+
+                    byte r = palette[pixelOffset];
+                    byte g = palette[pixelOffset + 1];
+                    byte b = palette[pixelOffset + 2];
+
+                    color.PackFromBytes(r, g, b, 255);
+                    pixels[x, this.currentRow] = color;
+                }
+            }
+        }
+
         /// <summary>
         /// Processes the interlaced de-filtered scanline filling the image pixel data
         /// </summary>

From 8a63ceb75bd43b4ce9e363b230a3be99537c590a Mon Sep 17 00:00:00 2001
From: Anton Firszov <anton.firszov@sapagroup.com>
Date: Wed, 26 Apr 2017 02:52:21 +0200
Subject: [PATCH 06/24] tests for Png & Gif codecs

---
 .../Formats/Gif/GifDecoderTests.cs            | 18 ++++++++++++++
 .../Formats/Gif/GifEncoderTests.cs            | 14 +++++++++++
 .../Formats/Png/PngDecoderTests.cs            | 20 ++++++++++++++++
 .../Formats/Png/PngEncoderTests.cs            | 24 +++++++++++++++++++
 4 files changed, 76 insertions(+)

diff --git a/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs
index 5dac59d696..dd3019029a 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/GifDecoderTests.cs
@@ -3,15 +3,33 @@
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
 
+// ReSharper disable InconsistentNaming
 namespace ImageSharp.Tests
 {
     using System.Text;
     using Xunit;
 
     using ImageSharp.Formats;
+    using ImageSharp.PixelFormats;
 
     public class GifDecoderTests
     {
+        private const PixelTypes PixelTypes = Tests.PixelTypes.StandardImageClass | Tests.PixelTypes.RgbaVector | Tests.PixelTypes.Argb32;
+
+        public static readonly string[] TestFiles = { TestImages.Gif.Giphy, TestImages.Gif.Rings, TestImages.Gif.Trans };
+
+        [Theory]
+        [WithFileCollection(nameof(TestFiles), PixelTypes)]
+        public void DecodeAndReSave<TPixel>(TestImageProvider<TPixel> imageProvider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = imageProvider.GetImage())
+            {
+                imageProvider.Utility.SaveTestOutputFile(image, "bmp");
+                imageProvider.Utility.SaveTestOutputFile(image, "gif");
+            }
+        }
+        
         [Fact]
         public void Decode_IgnoreMetadataIsFalse_CommentsAreRead()
         {
diff --git a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
index 897778bc3a..c657cde96a 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
@@ -9,9 +9,23 @@ namespace ImageSharp.Tests
     using Xunit;
 
     using ImageSharp.Formats;
+    using ImageSharp.PixelFormats;
 
     public class GifEncoderTests
     {
+        private const PixelTypes PixelTypes = Tests.PixelTypes.StandardImageClass | Tests.PixelTypes.RgbaVector | Tests.PixelTypes.Argb32;
+
+        [Theory]
+        [WithTestPatternImages(100, 100, PixelTypes)]
+        public void EncodeGeneratedPatterns<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                provider.Utility.SaveTestOutputFile(image, "gif", new GifEncoder());
+            }
+        }
+
         [Fact]
         public void Encode_IgnoreMetadataIsFalse_CommentsAreWritten()
         {
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
index e03d42c9af..d97b258dd6 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngDecoderTests.cs
@@ -9,9 +9,29 @@ namespace ImageSharp.Tests
     using Xunit;
 
     using ImageSharp.Formats;
+    using ImageSharp.PixelFormats;
 
     public class PngDecoderTests
     {
+        private const PixelTypes PixelTypes = Tests.PixelTypes.StandardImageClass | Tests.PixelTypes.RgbaVector | Tests.PixelTypes.Argb32;
+
+        public static readonly string[] TestFiles =
+            {
+                TestImages.Png.Splash, TestImages.Png.Indexed, TestImages.Png.Interlaced, TestImages.Png.FilterVar,
+                TestImages.Png.ChunkLength1, TestImages.Png.ChunkLength2
+            };
+
+        [Theory]
+        [WithFileCollection(nameof(TestFiles), PixelTypes)]
+        public void DecodeAndReSave<TPixel>(TestImageProvider<TPixel> imageProvider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = imageProvider.GetImage())
+            {
+                imageProvider.Utility.SaveTestOutputFile(image, "bmp");
+            }
+        }
+
         [Fact]
         public void Decode_IgnoreMetadataIsFalse_TextChunckIsRead()
         {
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
index ae4dfc1e9a..195eaba105 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
@@ -7,6 +7,7 @@ using ImageSharp.Formats;
 
 namespace ImageSharp.Tests
 {
+    using System.Collections.Generic;
     using System.IO;
     using System.Linq;
     using System.Threading.Tasks;
@@ -17,6 +18,29 @@ namespace ImageSharp.Tests
 
     public class PngEncoderTests : FileTestBase
     {
+        private const PixelTypes PixelTypes = Tests.PixelTypes.StandardImageClass | Tests.PixelTypes.RgbaVector | Tests.PixelTypes.Argb32;
+
+        [Theory]
+        [WithTestPatternImages(100, 100, PixelTypes, PngColorType.RgbWithAlpha)]
+        [WithTestPatternImages(100, 100, PixelTypes, PngColorType.Rgb)]
+        [WithTestPatternImages(100, 100, PixelTypes, PngColorType.Palette)]
+        [WithTestPatternImages(100, 100, PixelTypes, PngColorType.Grayscale)]
+        [WithTestPatternImages(100, 100, PixelTypes, PngColorType.GrayscaleWithAlpha)]
+        public void EncodeGeneratedPatterns<TPixel>(TestImageProvider<TPixel> provider, PngColorType pngColorType)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                PngEncoderOptions options = new PngEncoderOptions()
+                                                {
+                                                    PngColorType = pngColorType
+                                                };
+                provider.Utility.TestName += "_" + pngColorType;
+
+                provider.Utility.SaveTestOutputFile(image, "png", new PngEncoder(), options);
+            }
+        }
+
         [Theory]
         [WithBlankImages(1, 1, PixelTypes.All)]
         public void WritesFileMarker<TPixel>(TestImageProvider<TPixel> provider)

From cbb8e71f4bef64d9d6ad111066ebaa45cbb8e246 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Wed, 26 Apr 2017 14:42:18 +1000
Subject: [PATCH 07/24] Rename tests

Something is getting cached causing tests to sporadically fail.
Hopefully this fixes that.
---
 .../ImageSharp.Tests/Colors/{ColorTests.cs => Rgba32Tests.cs} | 4 ++--
 .../{ColorTransformTests.cs => Rgba32TransformTests.cs}       | 0
 .../Colors/{ColorVectorTests.cs => RgbaVectorTests.cs}        | 4 ++--
 ...lorVectorTransformTests.cs => RgbaVectorTransformTests.cs} | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename tests/ImageSharp.Tests/Colors/{ColorTests.cs => Rgba32Tests.cs} (97%)
 rename tests/ImageSharp.Tests/Colors/{ColorTransformTests.cs => Rgba32TransformTests.cs} (100%)
 rename tests/ImageSharp.Tests/Colors/{ColorVectorTests.cs => RgbaVectorTests.cs} (97%)
 rename tests/ImageSharp.Tests/Colors/{ColorVectorTransformTests.cs => RgbaVectorTransformTests.cs} (97%)

diff --git a/tests/ImageSharp.Tests/Colors/ColorTests.cs b/tests/ImageSharp.Tests/Colors/Rgba32Tests.cs
similarity index 97%
rename from tests/ImageSharp.Tests/Colors/ColorTests.cs
rename to tests/ImageSharp.Tests/Colors/Rgba32Tests.cs
index da63025c43..5509cbddcf 100644
--- a/tests/ImageSharp.Tests/Colors/ColorTests.cs
+++ b/tests/ImageSharp.Tests/Colors/Rgba32Tests.cs
@@ -1,4 +1,4 @@
-// <copyright file="ColorTests.cs" company="James Jackson-South">
+// <copyright file="Rgba32Tests.cs" company="James Jackson-South">
 // Copyright (c) James Jackson-South and contributors.
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
@@ -15,7 +15,7 @@ namespace ImageSharp.Tests
     /// <summary>
     /// Tests the <see cref="Rgba32"/> struct.
     /// </summary>
-    public class ColorTests
+    public class Rgba32Tests
     {
         /// <summary>
         /// Tests the equality operators for equality.
diff --git a/tests/ImageSharp.Tests/Colors/ColorTransformTests.cs b/tests/ImageSharp.Tests/Colors/Rgba32TransformTests.cs
similarity index 100%
rename from tests/ImageSharp.Tests/Colors/ColorTransformTests.cs
rename to tests/ImageSharp.Tests/Colors/Rgba32TransformTests.cs
diff --git a/tests/ImageSharp.Tests/Colors/ColorVectorTests.cs b/tests/ImageSharp.Tests/Colors/RgbaVectorTests.cs
similarity index 97%
rename from tests/ImageSharp.Tests/Colors/ColorVectorTests.cs
rename to tests/ImageSharp.Tests/Colors/RgbaVectorTests.cs
index 492817015a..1f5df6d880 100644
--- a/tests/ImageSharp.Tests/Colors/ColorVectorTests.cs
+++ b/tests/ImageSharp.Tests/Colors/RgbaVectorTests.cs
@@ -1,4 +1,4 @@
-// <copyright file="ColorVectorTests.cs" company="James Jackson-South">
+// <copyright file="RgbaVectorTests.cs" company="James Jackson-South">
 // Copyright (c) James Jackson-South and contributors.
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
@@ -15,7 +15,7 @@ namespace ImageSharp.Tests
     /// <summary>
     /// Tests the <see cref="RgbaVector"/> struct.
     /// </summary>
-    public class ColorVectorTests
+    public class RgbaVectorTests
     {
         /// <summary>
         /// Tests the equality operators for equality.
diff --git a/tests/ImageSharp.Tests/Colors/ColorVectorTransformTests.cs b/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
similarity index 97%
rename from tests/ImageSharp.Tests/Colors/ColorVectorTransformTests.cs
rename to tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
index e670944f56..bcbc27c7c4 100644
--- a/tests/ImageSharp.Tests/Colors/ColorVectorTransformTests.cs
+++ b/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
@@ -1,4 +1,4 @@
-// <copyright file="ColorVectorTransformTests.cs" company="James Jackson-South">
+// <copyright file="RgbaVectorTransformTests.cs" company="James Jackson-South">
 // Copyright (c) James Jackson-South and contributors.
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
@@ -12,7 +12,7 @@ namespace ImageSharp.Tests.Colors
     /// Tests the color transform algorithms. Test results match the output of CSS equivalents.
     /// <see href="https://jsfiddle.net/jamessouth/L1v8r6kh/"/>
     /// </summary>
-    public class ColorVectorTransformTests
+    public class RgbaVectorTransformTests
     {
         private static readonly ApproximateFloatComparer FloatComparer = new ApproximateFloatComparer(0.01F);
 

From 4b8a5dc5c1b815f812e9e042d99b95aa367d3ba2 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Wed, 26 Apr 2017 15:31:05 +1000
Subject: [PATCH 08/24] Use same conversion methods as libjpeg

---
 .../Components/Decoder/YCbCrToRgbTables.cs    |  95 ++++++++++++++++
 .../Components/Encoder/RgbToYCbCrTables.cs    | 106 ++++++++++++++++++
 .../Formats/Jpeg/JpegDecoderCore.cs           |  37 +-----
 .../Formats/Jpeg/JpegEncoderCore.cs           |  29 +----
 4 files changed, 213 insertions(+), 54 deletions(-)
 create mode 100644 src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs
 create mode 100644 src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs

diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs
new file mode 100644
index 0000000000..4195a34672
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs
@@ -0,0 +1,95 @@
+// <copyright file="YCbCrToRgbTables.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Formats.Jpg
+{
+    using System.Runtime.CompilerServices;
+
+    using ImageSharp.PixelFormats;
+
+    /// <summary>
+    /// Provides 8-bit lookup tables for converting from YCbCr to Rgb colorspace.
+    /// Methods to build the tables are based on libjpeg implementation.
+    /// </summary>
+    internal struct YCbCrToRgbTables
+    {
+        // Speediest right-shift on some machines and gives us enough accuracy at 4 decimal places.
+        private const int ScaleBits = 16;
+
+        private const int Half = 1 << (ScaleBits - 1);
+
+        private static readonly int[] CrRTable = new int[256];
+
+        private static readonly int[] CbBTable = new int[256];
+
+        private static readonly int[] CrGTable = new int[256];
+
+        private static readonly int[] CbGTable = new int[256];
+
+        /// <summary>
+        /// Optimized method to pack bytes to the image from the YCbCr color space.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="packed">The packed pixel.</param>
+        /// <param name="y">The y luminance component.</param>
+        /// <param name="cb">The cb chroma component.</param>
+        /// <param name="cr">The cr chroma component.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Pack<TPixel>(ref TPixel packed, byte y, byte cb, byte cr)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            // float r = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero);
+            byte r = (byte)(y + CrRTable[cr]).Clamp(0, 255);
+
+            // float g = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero);
+            // The values for the G calculation are left scaled up, since we must add them together before rounding.
+            byte g = (byte)(y + RightShift(CbGTable[cb] + CrGTable[cr])).Clamp(0, 255);
+
+            // float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
+            byte b = (byte)(y + CbBTable[cb]).Clamp(0, 255);
+
+            packed.PackFromBytes(r, g, b, byte.MaxValue);
+        }
+
+        /// <summary>
+        /// Initializes the YCbCr tables
+        /// </summary>
+        /// <returns>The intialized <see cref="YCbCrToRgbTables"/></returns>
+        public YCbCrToRgbTables Init()
+        {
+            for (int i = 0, x = -128; i <= 255; i++, x++)
+            {
+                // i is the actual input pixel value, in the range 0..255
+                // The Cb or Cr value we are thinking of is x = i - 128
+                // Cr=>R value is nearest int to 1.402 * x
+                CrRTable[i] = RightShift((Fix(1.402F) * x) + Half);
+
+                // Cb=>B value is nearest int to 1.772 * x
+                CbBTable[i] = RightShift((Fix(1.772F) * x) + Half);
+
+                // Cr=>G value is scaled-up -0.714136286
+                CrGTable[i] = (-Fix(0.714136286F)) * x;
+
+                // Cb => G value is scaled - up - 0.344136286 * x
+                // We also add in Half so that need not do it in inner loop
+                CbGTable[i] = ((-Fix(0.344136286F)) * x) + Half;
+            }
+
+            return this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int Fix(float x)
+        {
+            return (int)((x * (1L << ScaleBits)) + 0.5F);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int RightShift(int x)
+        {
+            return x >> ScaleBits;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
new file mode 100644
index 0000000000..55a61011cd
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
@@ -0,0 +1,106 @@
+// <copyright file="RgbToYCbCrTables.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Formats.Jpg
+{
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// Provides 8-bit lookup tables for converting from Rgb to YCbCr colorspace.
+    /// Methods to build the tables are based on libjpeg implementation.
+    /// </summary>
+    internal struct RgbToYCbCrTables
+    {
+        // Speediest right-shift on some machines and gives us enough accuracy at 4 decimal places.
+        private const int ScaleBits = 16;
+
+        private const int GYOffset = 256;
+
+        private const int BYOffset = 2 * 256;
+
+        private const int RCbOffset = 3 * 256;
+
+        private const int GCbOffset = 4 * 256;
+
+        private const int BCbOffset = 5 * 256;
+
+        // B=>Cb and R=>Cr are the same
+        private const int RCrOffset = BCbOffset;
+
+        private const int GCrOffset = 6 * 256;
+
+        private const int BCrOffset = 7 * 256;
+
+        private const int CBCrOffset = 128 << ScaleBits;
+
+        private const int Half = 1 << (ScaleBits - 1);
+
+        private static readonly int[] YCbCrTable = new int[8 * 256];
+
+        /// <summary>
+        /// Optimized method to allocates the correct y, cb, and cr values to the DCT blocks from the given r, g, b values.
+        /// </summary>
+        /// <param name="yBlockRaw">The The luminance block.</param>
+        /// <param name="cbBlockRaw">The red chroma block.</param>
+        /// <param name="crBlockRaw">The blue chroma block.</param>
+        /// <param name="index">The current index.</param>
+        /// <param name="r">The red value.</param>
+        /// <param name="g">The green value.</param>
+        /// <param name="b">The blue value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void Allocate(ref float* yBlockRaw, ref float* cbBlockRaw, ref float* crBlockRaw, int index, int r, int g, int b)
+        {
+            // float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
+            yBlockRaw[index] = (YCbCrTable[r] + YCbCrTable[g + GYOffset] + YCbCrTable[b + BYOffset]) >> ScaleBits;
+
+            // float cb = 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b));
+            cbBlockRaw[index] = (YCbCrTable[r + RCbOffset] + YCbCrTable[g + GCbOffset] + YCbCrTable[b + BCbOffset]) >> ScaleBits;
+
+            // float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
+            crBlockRaw[index] = (YCbCrTable[r + RCrOffset] + YCbCrTable[g + GCrOffset] + YCbCrTable[b + BCrOffset]) >> ScaleBits;
+        }
+
+        /// <summary>
+        /// Initializes the YCbCr tables
+        /// </summary>
+        /// <returns>The intialized <see cref="RgbToYCbCrTables"/></returns>
+        public RgbToYCbCrTables Init()
+        {
+            for (int i = 0; i <= 255; i++)
+            {
+                // The values for the calculations are left scaled up since we must add them together before rounding.
+                YCbCrTable[i] = Fix(0.299F) * i;
+                YCbCrTable[i + GYOffset] = Fix(0.587F) * i;
+                YCbCrTable[i + BYOffset] = (Fix(0.114F) * i) + Half;
+                YCbCrTable[i + RCbOffset] = (-Fix(0.168735892F)) * i;
+                YCbCrTable[i + GCbOffset] = (-Fix(0.331264108F)) * i;
+
+                // We use a rounding fudge - factor of 0.5 - epsilon for Cb and Cr.
+                // This ensures that the maximum output will round to 255
+                // not 256, and thus that we don't have to range-limit.
+                //
+                // B=>Cb and R=>Cr tables are the same
+                YCbCrTable[i + BCbOffset] = (Fix(0.5F) * i) + CBCrOffset + Half - 1;
+
+                YCbCrTable[i + GCrOffset] = (-Fix(0.418687589F)) * i;
+                YCbCrTable[i + BCrOffset] = (-Fix(0.081312411F)) * i;
+            }
+
+            return this;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int Fix(float x)
+        {
+            return (int)((x * (1L << ScaleBits)) + 0.5F);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int RightShift(int x)
+        {
+            return x >> ScaleBits;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 186c1e5282..3faffb566d 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -7,7 +7,6 @@ namespace ImageSharp.Formats
 {
     using System;
     using System.IO;
-    using System.Runtime.CompilerServices;
     using System.Threading.Tasks;
 
     using ImageSharp.Formats.Jpg;
@@ -38,6 +37,11 @@ namespace ImageSharp.Formats
         public InputProcessor InputProcessor;
 #pragma warning restore SA401
 
+        /// <summary>
+        /// Lookup tables for converting YCbCr to Rgb
+        /// </summary>
+        private static readonly YCbCrToRgbTables YCbCrToRgbTables = default(YCbCrToRgbTables).Init();
+
         /// <summary>
         /// The decoder options.
         /// </summary>
@@ -251,35 +255,6 @@ namespace ImageSharp.Formats
             }
         }
 
-        /// <summary>
-        /// Optimized method to pack bytes to the image from the YCbCr color space.
-        /// This is faster than implicit casting as it avoids double packing.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="packed">The packed pixel.</param>
-        /// <param name="y">The y luminance component.</param>
-        /// <param name="cb">The cb chroma component.</param>
-        /// <param name="cr">The cr chroma component.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void PackYcbCr<TPixel>(ref TPixel packed, byte y, byte cb, byte cr)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            int ccb = cb - 128;
-            int ccr = cr - 128;
-
-            // Speed up the algorithm by removing floating point calculation
-            // Scale by 65536, add .5F and truncate value. We use bit shifting to divide the result
-            int r0 = 91881 * ccr; // (1.402F * 65536) + .5F
-            int g0 = 22554 * ccb; // (0.34414F * 65536) + .5F
-            int g1 = 46802 * ccr; // (0.71414F  * 65536) + .5F
-            int b0 = 116130 * ccb; // (1.772F * 65536) + .5F
-
-            byte r = (byte)(y + (r0 >> 16)).Clamp(0, 255);
-            byte g = (byte)(y - (g0 >> 16) - (g1 >> 16)).Clamp(0, 255);
-            byte b = (byte)(y + (b0 >> 16)).Clamp(0, 255);
-            packed.PackFromBytes(r, g, b, 255);
-        }
-
         /// <summary>
         /// Read metadata from stream and read the blocks in the scans into <see cref="DecodedBlocks"/>.
         /// </summary>
@@ -721,7 +696,7 @@ namespace ImageSharp.Formats
                             byte cr = this.ycbcrImage.CrChannel.Pixels[co + (x / scale)];
 
                             TPixel packed = default(TPixel);
-                            PackYcbCr<TPixel>(ref packed, yy, cb, cr);
+                            YCbCrToRgbTables.Pack(ref packed, yy, cb, cr);
                             pixels[x, y] = packed;
                         }
                     });
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
index eb083c35d9..b741fb2e65 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
@@ -5,11 +5,9 @@
 
 namespace ImageSharp.Formats
 {
-    using System;
     using System.Buffers;
     using System.IO;
     using System.Runtime.CompilerServices;
-
     using ImageSharp.Formats.Jpg;
     using ImageSharp.Formats.Jpg.Components;
     using ImageSharp.PixelFormats;
@@ -24,6 +22,11 @@ namespace ImageSharp.Formats
         /// </summary>
         private const int QuantizationTableCount = 2;
 
+        /// <summary>
+        /// Lookup tables for converting Rgb to YCbCr
+        /// </summary>
+        private static readonly RgbToYCbCrTables RgbToYCbCrTables = default(RgbToYCbCrTables).Init();
+
         /// <summary>
         /// Counts the number of bits needed to hold an integer.
         /// </summary>
@@ -321,29 +324,9 @@ namespace ImageSharp.Formats
                     int g = Unsafe.Add(ref data0, dataIdx + 1);
                     int b = Unsafe.Add(ref data0, dataIdx + 2);
 
-                    // Speed up the algorithm by removing floating point calculation
-                    // Scale by 65536, add .5F and truncate value. We use bit shifting to divide the result
-                    int y0 = 19595 * r; // (0.299F * 65536) + .5F
-                    int y1 = 38470 * g; // (0.587F * 65536) + .5F
-                    int y2 = 7471 * b; // (0.114F * 65536) + .5F
-
-                    int cb0 = -11057 * r; // (-0.168736F * 65536) + .5F
-                    int cb1 = 21710 * g; // (0.331264F * 65536) + .5F
-                    int cb2 = 32768 * b; // (0.5F * 65536) + .5F
-
-                    int cr0 = 32768 * r; // (0.5F * 65536) + .5F
-                    int cr1 = 27439 * g; // (0.418688F * 65536) + .5F
-                    int cr2 = 5329 * b; // (0.081312F * 65536) + .5F
-
-                    float yy = (y0 + y1 + y2) >> 16;
-                    float cb = 128 + ((cb0 - cb1 + cb2) >> 16);
-                    float cr = 128 + ((cr0 - cr1 - cr2) >> 16);
-
                     int index = j8 + i;
 
-                    yBlockRaw[index] = yy;
-                    cbBlockRaw[index] = cb;
-                    crBlockRaw[index] = cr;
+                    RgbToYCbCrTables.Allocate(ref yBlockRaw, ref cbBlockRaw, ref crBlockRaw, index, r, g, b);
 
                     dataIdx += 3;
                 }

From 15a571fad90921fe286cab887da752e3841adfd7 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Wed, 26 Apr 2017 21:51:11 +1000
Subject: [PATCH 09/24] Use better structs with fixed pointer

---
 .../Components/Decoder/YCbCrToRgbTables.cs    |  88 ++++++-----
 .../Components/Encoder/RgbToYCbCrTables.cs    | 117 ++++++++------
 .../Formats/Jpeg/JpegDecoderCore.cs           |  30 ++--
 .../Formats/Jpeg/JpegEncoderCore.cs           | 143 +++++++++---------
 4 files changed, 214 insertions(+), 164 deletions(-)

diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs
index 4195a34672..27324b5f68 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/YCbCrToRgbTables.cs
@@ -6,80 +6,94 @@
 namespace ImageSharp.Formats.Jpg
 {
     using System.Runtime.CompilerServices;
-
     using ImageSharp.PixelFormats;
 
     /// <summary>
     /// Provides 8-bit lookup tables for converting from YCbCr to Rgb colorspace.
     /// Methods to build the tables are based on libjpeg implementation.
     /// </summary>
-    internal struct YCbCrToRgbTables
+    internal unsafe struct YCbCrToRgbTables
     {
+        /// <summary>
+        /// The red red-chrominance table
+        /// </summary>
+        public fixed int CrRTable[256];
+
+        /// <summary>
+        /// The blue blue-chrominance table
+        /// </summary>
+        public fixed int CbBTable[256];
+
+        /// <summary>
+        /// The green red-chrominance table
+        /// </summary>
+        public fixed int CrGTable[256];
+
+        /// <summary>
+        /// The green blue-chrominance table
+        /// </summary>
+        public fixed int CbGTable[256];
+
         // Speediest right-shift on some machines and gives us enough accuracy at 4 decimal places.
         private const int ScaleBits = 16;
 
         private const int Half = 1 << (ScaleBits - 1);
 
-        private static readonly int[] CrRTable = new int[256];
+        /// <summary>
+        /// Initializes the YCbCr tables
+        /// </summary>
+        /// <returns>The intialized <see cref="YCbCrToRgbTables"/></returns>
+        public static YCbCrToRgbTables Create()
+        {
+            YCbCrToRgbTables tables = default(YCbCrToRgbTables);
+
+            for (int i = 0, x = -128; i <= 255; i++, x++)
+            {
+                // i is the actual input pixel value, in the range 0..255
+                // The Cb or Cr value we are thinking of is x = i - 128
+                // Cr=>R value is nearest int to 1.402 * x
+                tables.CrRTable[i] = RightShift((Fix(1.402F) * x) + Half);
+
+                // Cb=>B value is nearest int to 1.772 * x
+                tables.CbBTable[i] = RightShift((Fix(1.772F) * x) + Half);
 
-        private static readonly int[] CbBTable = new int[256];
+                // Cr=>G value is scaled-up -0.714136286
+                tables.CrGTable[i] = (-Fix(0.714136286F)) * x;
 
-        private static readonly int[] CrGTable = new int[256];
+                // Cb => G value is scaled - up - 0.344136286 * x
+                // We also add in Half so that need not do it in inner loop
+                tables.CbGTable[i] = ((-Fix(0.344136286F)) * x) + Half;
+            }
 
-        private static readonly int[] CbGTable = new int[256];
+            return tables;
+        }
 
         /// <summary>
         /// Optimized method to pack bytes to the image from the YCbCr color space.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="packed">The packed pixel.</param>
+        /// <param name="tables">The reference to the tables instance.</param>
         /// <param name="y">The y luminance component.</param>
         /// <param name="cb">The cb chroma component.</param>
         /// <param name="cr">The cr chroma component.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Pack<TPixel>(ref TPixel packed, byte y, byte cb, byte cr)
+        public static void Pack<TPixel>(ref TPixel packed, YCbCrToRgbTables* tables, byte y, byte cb, byte cr)
             where TPixel : struct, IPixel<TPixel>
         {
             // float r = MathF.Round(y + (1.402F * cr), MidpointRounding.AwayFromZero);
-            byte r = (byte)(y + CrRTable[cr]).Clamp(0, 255);
+            byte r = (byte)(y + tables->CrRTable[cr]).Clamp(0, 255);
 
             // float g = MathF.Round(y - (0.344136F * cb) - (0.714136F * cr), MidpointRounding.AwayFromZero);
             // The values for the G calculation are left scaled up, since we must add them together before rounding.
-            byte g = (byte)(y + RightShift(CbGTable[cb] + CrGTable[cr])).Clamp(0, 255);
+            byte g = (byte)(y + RightShift(tables->CbGTable[cb] + tables->CrGTable[cr])).Clamp(0, 255);
 
             // float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
-            byte b = (byte)(y + CbBTable[cb]).Clamp(0, 255);
+            byte b = (byte)(y + tables->CbBTable[cb]).Clamp(0, 255);
 
             packed.PackFromBytes(r, g, b, byte.MaxValue);
         }
 
-        /// <summary>
-        /// Initializes the YCbCr tables
-        /// </summary>
-        /// <returns>The intialized <see cref="YCbCrToRgbTables"/></returns>
-        public YCbCrToRgbTables Init()
-        {
-            for (int i = 0, x = -128; i <= 255; i++, x++)
-            {
-                // i is the actual input pixel value, in the range 0..255
-                // The Cb or Cr value we are thinking of is x = i - 128
-                // Cr=>R value is nearest int to 1.402 * x
-                CrRTable[i] = RightShift((Fix(1.402F) * x) + Half);
-
-                // Cb=>B value is nearest int to 1.772 * x
-                CbBTable[i] = RightShift((Fix(1.772F) * x) + Half);
-
-                // Cr=>G value is scaled-up -0.714136286
-                CrGTable[i] = (-Fix(0.714136286F)) * x;
-
-                // Cb => G value is scaled - up - 0.344136286 * x
-                // We also add in Half so that need not do it in inner loop
-                CbGTable[i] = ((-Fix(0.344136286F)) * x) + Half;
-            }
-
-            return this;
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int Fix(float x)
         {
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
index 55a61011cd..199aa52252 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
@@ -11,33 +11,86 @@ namespace ImageSharp.Formats.Jpg
     /// Provides 8-bit lookup tables for converting from Rgb to YCbCr colorspace.
     /// Methods to build the tables are based on libjpeg implementation.
     /// </summary>
-    internal struct RgbToYCbCrTables
+    internal unsafe struct RgbToYCbCrTables
     {
-        // Speediest right-shift on some machines and gives us enough accuracy at 4 decimal places.
-        private const int ScaleBits = 16;
+        /// <summary>
+        /// The red luminance table
+        /// </summary>
+        public fixed int YRTable[256];
 
-        private const int GYOffset = 256;
+        /// <summary>
+        /// The green luminance table
+        /// </summary>
+        public fixed int YGTable[256];
 
-        private const int BYOffset = 2 * 256;
+        /// <summary>
+        /// The blue luminance table
+        /// </summary>
+        public fixed int YBTable[256];
 
-        private const int RCbOffset = 3 * 256;
+        /// <summary>
+        /// The red blue-chrominance table
+        /// </summary>
+        public fixed int CbRTable[256];
 
-        private const int GCbOffset = 4 * 256;
+        /// <summary>
+        /// The green blue-chrominance table
+        /// </summary>
+        public fixed int CbGTable[256];
 
-        private const int BCbOffset = 5 * 256;
+        /// <summary>
+        /// The blue blue-chrominance table
+        /// B=>Cb and R=>Cr are the same
+        /// </summary>
+        public fixed int CbBTable[256];
 
-        // B=>Cb and R=>Cr are the same
-        private const int RCrOffset = BCbOffset;
+        /// <summary>
+        /// The green red-chrominance table
+        /// </summary>
+        public fixed int CrGTable[256];
 
-        private const int GCrOffset = 6 * 256;
+        /// <summary>
+        /// The blue red-chrominance table
+        /// </summary>
+        public fixed int CrBTable[256];
 
-        private const int BCrOffset = 7 * 256;
+        // Speediest right-shift on some machines and gives us enough accuracy at 4 decimal places.
+        private const int ScaleBits = 16;
 
         private const int CBCrOffset = 128 << ScaleBits;
 
         private const int Half = 1 << (ScaleBits - 1);
 
-        private static readonly int[] YCbCrTable = new int[8 * 256];
+        /// <summary>
+        /// Initializes the YCbCr tables
+        /// </summary>
+        /// <returns>The intialized <see cref="RgbToYCbCrTables"/></returns>
+        public static RgbToYCbCrTables Create()
+        {
+            RgbToYCbCrTables tables = default(RgbToYCbCrTables);
+
+            for (int i = 0; i <= 255; i++)
+            {
+                // The values for the calculations are left scaled up since we must add them together before rounding.
+                tables.YRTable[i] = Fix(0.299F) * i;
+                tables.YGTable[i] = Fix(0.587F) * i;
+                tables.YBTable[i] = (Fix(0.114F) * i) + Half;
+                tables.CbRTable[i] = (-Fix(0.168735892F)) * i;
+                tables.CbGTable[i] = (-Fix(0.331264108F)) * i;
+
+                // We use a rounding fudge - factor of 0.5 - epsilon for Cb and Cr.
+                // This ensures that the maximum output will round to 255
+                // not 256, and thus that we don't have to range-limit.
+                //
+                // B=>Cb and R=>Cr tables are the same
+                tables.CbBTable[i] = (Fix(0.5F) * i) + CBCrOffset + Half - 1;
+
+                tables.CrGTable[i] = (-Fix(0.418687589F)) * i;
+                tables.CrBTable[i] = (-Fix(0.081312411F)) * i;
+            }
+
+            return tables;
+        }
 
         /// <summary>
         /// Optimized method to allocates the correct y, cb, and cr values to the DCT blocks from the given r, g, b values.
@@ -45,50 +98,22 @@ namespace ImageSharp.Formats.Jpg
         /// <param name="yBlockRaw">The The luminance block.</param>
         /// <param name="cbBlockRaw">The red chroma block.</param>
         /// <param name="crBlockRaw">The blue chroma block.</param>
+        /// <param name="tables">The reference to the tables instance.</param>
         /// <param name="index">The current index.</param>
         /// <param name="r">The red value.</param>
         /// <param name="g">The green value.</param>
         /// <param name="b">The blue value.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Allocate(ref float* yBlockRaw, ref float* cbBlockRaw, ref float* crBlockRaw, int index, int r, int g, int b)
+        public static void Allocate(ref float* yBlockRaw, ref float* cbBlockRaw, ref float* crBlockRaw, RgbToYCbCrTables* tables, int index, int r, int g, int b)
         {
             // float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
-            yBlockRaw[index] = (YCbCrTable[r] + YCbCrTable[g + GYOffset] + YCbCrTable[b + BYOffset]) >> ScaleBits;
+            yBlockRaw[index] = (tables->YRTable[r] + tables->YGTable[g] + tables->YBTable[b]) >> ScaleBits;
 
             // float cb = 128F + ((-0.168736F * r) - (0.331264F * g) + (0.5F * b));
-            cbBlockRaw[index] = (YCbCrTable[r + RCbOffset] + YCbCrTable[g + GCbOffset] + YCbCrTable[b + BCbOffset]) >> ScaleBits;
+            cbBlockRaw[index] = (tables->CbRTable[r] + tables->CbGTable[g] + tables->CbBTable[b]) >> ScaleBits;
 
             // float b = MathF.Round(y + (1.772F * cb), MidpointRounding.AwayFromZero);
-            crBlockRaw[index] = (YCbCrTable[r + RCrOffset] + YCbCrTable[g + GCrOffset] + YCbCrTable[b + BCrOffset]) >> ScaleBits;
-        }
-
-        /// <summary>
-        /// Initializes the YCbCr tables
-        /// </summary>
-        /// <returns>The intialized <see cref="RgbToYCbCrTables"/></returns>
-        public RgbToYCbCrTables Init()
-        {
-            for (int i = 0; i <= 255; i++)
-            {
-                // The values for the calculations are left scaled up since we must add them together before rounding.
-                YCbCrTable[i] = Fix(0.299F) * i;
-                YCbCrTable[i + GYOffset] = Fix(0.587F) * i;
-                YCbCrTable[i + BYOffset] = (Fix(0.114F) * i) + Half;
-                YCbCrTable[i + RCbOffset] = (-Fix(0.168735892F)) * i;
-                YCbCrTable[i + GCbOffset] = (-Fix(0.331264108F)) * i;
-
-                // We use a rounding fudge - factor of 0.5 - epsilon for Cb and Cr.
-                // This ensures that the maximum output will round to 255
-                // not 256, and thus that we don't have to range-limit.
-                //
-                // B=>Cb and R=>Cr tables are the same
-                YCbCrTable[i + BCbOffset] = (Fix(0.5F) * i) + CBCrOffset + Half - 1;
-
-                YCbCrTable[i + GCrOffset] = (-Fix(0.418687589F)) * i;
-                YCbCrTable[i + BCrOffset] = (-Fix(0.081312411F)) * i;
-            }
-
-            return this;
+            crBlockRaw[index] = (tables->CbBTable[r] + tables->CrGTable[g] + tables->CrBTable[b]) >> ScaleBits;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 3faffb566d..2072ec1e12 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -40,7 +40,7 @@ namespace ImageSharp.Formats
         /// <summary>
         /// Lookup tables for converting YCbCr to Rgb
         /// </summary>
-        private static readonly YCbCrToRgbTables YCbCrToRgbTables = default(YCbCrToRgbTables).Init();
+        private static YCbCrToRgbTables yCbCrToRgbTables = YCbCrToRgbTables.Create();
 
         /// <summary>
         /// The decoder options.
@@ -685,19 +685,23 @@ namespace ImageSharp.Formats
                     image.Configuration.ParallelOptions,
                     y =>
                     {
-                        // TODO: Simplify + optimize + share duplicate code across converter methods
-                        int yo = this.ycbcrImage.GetRowYOffset(y);
-                        int co = this.ycbcrImage.GetRowCOffset(y);
-
-                        for (int x = 0; x < image.Width; x++)
+                        // TODO. How can we use the fixed tables inside the lambda?
+                        fixed (YCbCrToRgbTables* tables = &yCbCrToRgbTables)
                         {
-                            byte yy = this.ycbcrImage.YChannel.Pixels[yo + x];
-                            byte cb = this.ycbcrImage.CbChannel.Pixels[co + (x / scale)];
-                            byte cr = this.ycbcrImage.CrChannel.Pixels[co + (x / scale)];
-
-                            TPixel packed = default(TPixel);
-                            YCbCrToRgbTables.Pack(ref packed, yy, cb, cr);
-                            pixels[x, y] = packed;
+                            // TODO: Simplify + optimize + share duplicate code across converter methods
+                            int yo = this.ycbcrImage.GetRowYOffset(y);
+                            int co = this.ycbcrImage.GetRowCOffset(y);
+
+                            for (int x = 0; x < image.Width; x++)
+                            {
+                                byte yy = this.ycbcrImage.YChannel.Pixels[yo + x];
+                                byte cb = this.ycbcrImage.CbChannel.Pixels[co + (x / scale)];
+                                byte cr = this.ycbcrImage.CrChannel.Pixels[co + (x / scale)];
+
+                                TPixel packed = default(TPixel);
+                                YCbCrToRgbTables.Pack(ref packed, tables, yy, cb, cr);
+                                pixels[x, y] = packed;
+                            }
                         }
                     });
             }
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
index b741fb2e65..f88efb3d2b 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
@@ -22,11 +22,6 @@ namespace ImageSharp.Formats
         /// </summary>
         private const int QuantizationTableCount = 2;
 
-        /// <summary>
-        /// Lookup tables for converting Rgb to YCbCr
-        /// </summary>
-        private static readonly RgbToYCbCrTables RgbToYCbCrTables = default(RgbToYCbCrTables).Init();
-
         /// <summary>
         /// Counts the number of bits needed to hold an integer.
         /// </summary>
@@ -106,6 +101,11 @@ namespace ImageSharp.Formats
                     }
             };
 
+        /// <summary>
+        /// Lookup tables for converting Rgb to YCbCr
+        /// </summary>
+        private static RgbToYCbCrTables rgbToYCbCrTables = RgbToYCbCrTables.Create();
+
         /// <summary>
         /// A scratch buffer to reduce allocations.
         /// </summary>
@@ -288,6 +288,7 @@ namespace ImageSharp.Formats
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="pixels">The pixel accessor.</param>
+        /// <param name="tables">The reference to the tables instance.</param>
         /// <param name="x">The x-position within the image.</param>
         /// <param name="y">The y-position within the image.</param>
         /// <param name="yBlock">The luminance block.</param>
@@ -296,6 +297,7 @@ namespace ImageSharp.Formats
         /// <param name="rgbBytes">Temporal <see cref="PixelArea{TPixel}"/> provided by the caller</param>
         private static void ToYCbCr<TPixel>(
             PixelAccessor<TPixel> pixels,
+            RgbToYCbCrTables* tables,
             int x,
             int y,
             Block8x8F* yBlock,
@@ -326,7 +328,7 @@ namespace ImageSharp.Formats
 
                     int index = j8 + i;
 
-                    RgbToYCbCrTables.Allocate(ref yBlockRaw, ref cbBlockRaw, ref crBlockRaw, index, r, g, b);
+                    RgbToYCbCrTables.Allocate(ref yBlockRaw, ref cbBlockRaw, ref crBlockRaw, tables, index, r, g, b);
 
                     dataIdx += 3;
                 }
@@ -447,38 +449,41 @@ namespace ImageSharp.Formats
             // ReSharper disable once InconsistentNaming
             int prevDCY = 0, prevDCCb = 0, prevDCCr = 0;
 
-            using (PixelArea<TPixel> rgbBytes = new PixelArea<TPixel>(8, 8, ComponentOrder.Xyz))
+            fixed (RgbToYCbCrTables* tables = &rgbToYCbCrTables)
             {
-                for (int y = 0; y < pixels.Height; y += 8)
+                using (PixelArea<TPixel> rgbBytes = new PixelArea<TPixel>(8, 8, ComponentOrder.Xyz))
                 {
-                    for (int x = 0; x < pixels.Width; x += 8)
+                    for (int y = 0; y < pixels.Height; y += 8)
                     {
-                        ToYCbCr(pixels, x, y, &b, &cb, &cr, rgbBytes);
-
-                        prevDCY = this.WriteBlock(
-                            QuantIndex.Luminance,
-                            prevDCY,
-                            &b,
-                            &temp1,
-                            &temp2,
-                            &onStackLuminanceQuantTable,
-                            unzig.Data);
-                        prevDCCb = this.WriteBlock(
-                            QuantIndex.Chrominance,
-                            prevDCCb,
-                            &cb,
-                            &temp1,
-                            &temp2,
-                            &onStackChrominanceQuantTable,
-                            unzig.Data);
-                        prevDCCr = this.WriteBlock(
-                            QuantIndex.Chrominance,
-                            prevDCCr,
-                            &cr,
-                            &temp1,
-                            &temp2,
-                            &onStackChrominanceQuantTable,
-                            unzig.Data);
+                        for (int x = 0; x < pixels.Width; x += 8)
+                        {
+                            ToYCbCr(pixels, tables, x, y, &b, &cb, &cr, rgbBytes);
+
+                            prevDCY = this.WriteBlock(
+                                QuantIndex.Luminance,
+                                prevDCY,
+                                &b,
+                                &temp1,
+                                &temp2,
+                                &onStackLuminanceQuantTable,
+                                unzig.Data);
+                            prevDCCb = this.WriteBlock(
+                                QuantIndex.Chrominance,
+                                prevDCCb,
+                                &cb,
+                                &temp1,
+                                &temp2,
+                                &onStackChrominanceQuantTable,
+                                unzig.Data);
+                            prevDCCr = this.WriteBlock(
+                                QuantIndex.Chrominance,
+                                prevDCCr,
+                                &cr,
+                                &temp1,
+                                &temp2,
+                                &onStackChrominanceQuantTable,
+                                unzig.Data);
+                        }
                     }
                 }
             }
@@ -820,49 +825,51 @@ namespace ImageSharp.Formats
 
             // ReSharper disable once InconsistentNaming
             int prevDCY = 0, prevDCCb = 0, prevDCCr = 0;
-
-            using (PixelArea<TPixel> rgbBytes = new PixelArea<TPixel>(8, 8, ComponentOrder.Xyz))
+            fixed (RgbToYCbCrTables* tables = &rgbToYCbCrTables)
             {
-                for (int y = 0; y < pixels.Height; y += 16)
+                using (PixelArea<TPixel> rgbBytes = new PixelArea<TPixel>(8, 8, ComponentOrder.Xyz))
                 {
-                    for (int x = 0; x < pixels.Width; x += 16)
+                    for (int y = 0; y < pixels.Height; y += 16)
                     {
-                        for (int i = 0; i < 4; i++)
+                        for (int x = 0; x < pixels.Width; x += 16)
                         {
-                            int xOff = (i & 1) * 8;
-                            int yOff = (i & 2) * 4;
-
-                            ToYCbCr(pixels, x + xOff, y + yOff, &b, cbPtr + i, crPtr + i, rgbBytes);
+                            for (int i = 0; i < 4; i++)
+                            {
+                                int xOff = (i & 1) * 8;
+                                int yOff = (i & 2) * 4;
+
+                                ToYCbCr(pixels, tables, x + xOff, y + yOff, &b, cbPtr + i, crPtr + i, rgbBytes);
+
+                                prevDCY = this.WriteBlock(
+                                    QuantIndex.Luminance,
+                                    prevDCY,
+                                    &b,
+                                    &temp1,
+                                    &temp2,
+                                    &onStackLuminanceQuantTable,
+                                    unzig.Data);
+                            }
+
+                            Block8x8F.Scale16X16To8X8(&b, cbPtr);
+                            prevDCCb = this.WriteBlock(
+                                QuantIndex.Chrominance,
+                                prevDCCb,
+                                &b,
+                                &temp1,
+                                &temp2,
+                                &onStackChrominanceQuantTable,
+                                unzig.Data);
 
-                            prevDCY = this.WriteBlock(
-                                QuantIndex.Luminance,
-                                prevDCY,
+                            Block8x8F.Scale16X16To8X8(&b, crPtr);
+                            prevDCCr = this.WriteBlock(
+                                QuantIndex.Chrominance,
+                                prevDCCr,
                                 &b,
                                 &temp1,
                                 &temp2,
-                                &onStackLuminanceQuantTable,
+                                &onStackChrominanceQuantTable,
                                 unzig.Data);
                         }
-
-                        Block8x8F.Scale16X16To8X8(&b, cbPtr);
-                        prevDCCb = this.WriteBlock(
-                            QuantIndex.Chrominance,
-                            prevDCCb,
-                            &b,
-                            &temp1,
-                            &temp2,
-                            &onStackChrominanceQuantTable,
-                            unzig.Data);
-
-                        Block8x8F.Scale16X16To8X8(&b, crPtr);
-                        prevDCCr = this.WriteBlock(
-                            QuantIndex.Chrominance,
-                            prevDCCr,
-                            &b,
-                            &temp1,
-                            &temp2,
-                            &onStackChrominanceQuantTable,
-                            unzig.Data);
                     }
                 }
             }

From 0663b106e632b8ea830444adad6610d670c010be Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Wed, 26 Apr 2017 22:45:54 +1000
Subject: [PATCH 10/24] Fix tests?

---
 tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs b/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
index bcbc27c7c4..24850954a8 100644
--- a/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
+++ b/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
@@ -36,13 +36,13 @@ namespace ImageSharp.Tests.Colors
         [Fact]
         public void Multiply()
         {
-            Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.Black).ToVector4(), Rgba32.Black.ToVector4(), FloatComparer);
+            Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.Black).ToVector4(), RgbaVector.Black.ToVector4(), FloatComparer);
             Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.White).ToVector4(), Backdrop.ToVector4(), FloatComparer);
 
             RgbaVector multiply = RgbaVector.Multiply(Backdrop, Source);
             Assert.Equal(multiply.ToVector4(), new RgbaVector(0, 41, 0).ToVector4(), FloatComparer);
         }
-
+ 
         [Fact]
         public void Screen()
         {

From 59d3364e4a94a95e3897f95d3d5cb66c875663f1 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Thu, 27 Apr 2017 01:03:24 +1000
Subject: [PATCH 11/24] Squeeze out a couple of milliseconds.

Seeing sub 30ms in benchmark for the first time ever.
---
 .../Components/Encoder/RgbToYCbCrTables.cs    |  2 +-
 .../Formats/Jpeg/JpegDecoderCore.cs           | 53 ++++++++++---------
 .../Formats/Jpeg/JpegEncoderCore.cs           |  2 +-
 3 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
index 199aa52252..94173d3e43 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbToYCbCrTables.cs
@@ -104,7 +104,7 @@ namespace ImageSharp.Formats.Jpg
         /// <param name="g">The green value.</param>
         /// <param name="b">The blue value.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void Allocate(ref float* yBlockRaw, ref float* cbBlockRaw, ref float* crBlockRaw, RgbToYCbCrTables* tables, int index, int r, int g, int b)
+        public static void Allocate(ref float* yBlockRaw, ref float* cbBlockRaw, ref float* crBlockRaw, ref RgbToYCbCrTables* tables, int index, int r, int g, int b)
         {
             // float y = (0.299F * r) + (0.587F * g) + (0.114F * b);
             yBlockRaw[index] = (tables->YRTable[r] + tables->YGTable[g] + tables->YBTable[b]) >> ScaleBits;
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 2072ec1e12..9df21a3b72 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -7,6 +7,7 @@ namespace ImageSharp.Formats
 {
     using System;
     using System.IO;
+    using System.Runtime.CompilerServices;
     using System.Threading.Tasks;
 
     using ImageSharp.Formats.Jpg;
@@ -680,30 +681,34 @@ namespace ImageSharp.Formats
             using (PixelAccessor<TPixel> pixels = image.Lock())
             {
                 Parallel.For(
-                    0,
-                    image.Height,
-                    image.Configuration.ParallelOptions,
-                    y =>
-                    {
-                        // TODO. How can we use the fixed tables inside the lambda?
-                        fixed (YCbCrToRgbTables* tables = &yCbCrToRgbTables)
-                        {
-                            // TODO: Simplify + optimize + share duplicate code across converter methods
-                            int yo = this.ycbcrImage.GetRowYOffset(y);
-                            int co = this.ycbcrImage.GetRowCOffset(y);
-
-                            for (int x = 0; x < image.Width; x++)
-                            {
-                                byte yy = this.ycbcrImage.YChannel.Pixels[yo + x];
-                                byte cb = this.ycbcrImage.CbChannel.Pixels[co + (x / scale)];
-                                byte cr = this.ycbcrImage.CrChannel.Pixels[co + (x / scale)];
-
-                                TPixel packed = default(TPixel);
-                                YCbCrToRgbTables.Pack(ref packed, tables, yy, cb, cr);
-                                pixels[x, y] = packed;
-                            }
-                        }
-                    });
+                 0,
+                 image.Height,
+                 image.Configuration.ParallelOptions,
+                 y =>
+                 {
+                     // TODO. This Parallel loop doesn't give us the boost it should.
+                     ref byte ycRef = ref this.ycbcrImage.YChannel.Pixels[0];
+                     ref byte cbRef = ref this.ycbcrImage.CbChannel.Pixels[0];
+                     ref byte crRef = ref this.ycbcrImage.CrChannel.Pixels[0];
+                     fixed (YCbCrToRgbTables* tables = &yCbCrToRgbTables)
+                     {
+                         // TODO: Simplify + optimize + share duplicate code across converter methods
+                         int yo = this.ycbcrImage.GetRowYOffset(y);
+                         int co = this.ycbcrImage.GetRowCOffset(y);
+
+                         for (int x = 0; x < image.Width; x++)
+                         {
+                             int cOff = co + (x / scale);
+                             byte yy = Unsafe.Add(ref ycRef, yo + x);
+                             byte cb = Unsafe.Add(ref cbRef, cOff);
+                             byte cr = Unsafe.Add(ref crRef, cOff);
+
+                             TPixel packed = default(TPixel);
+                             YCbCrToRgbTables.Pack(ref packed, tables, yy, cb, cr);
+                             pixels[x, y] = packed;
+                         }
+                     }
+                 });
             }
 
             this.AssignResolution(image);
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
index f88efb3d2b..0ce59c6dec 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
@@ -328,7 +328,7 @@ namespace ImageSharp.Formats
 
                     int index = j8 + i;
 
-                    RgbToYCbCrTables.Allocate(ref yBlockRaw, ref cbBlockRaw, ref crBlockRaw, tables, index, r, g, b);
+                    RgbToYCbCrTables.Allocate(ref yBlockRaw, ref cbBlockRaw, ref crBlockRaw, ref tables, index, r, g, b);
 
                     dataIdx += 3;
                 }

From a94be7a207adc7b931571070e41933e00a0f67f6 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Thu, 27 Apr 2017 09:59:54 +1000
Subject: [PATCH 12/24] Disable breaking tests pending investigation

---
 .../Colors/RgbaVectorTransformTests.cs        | 39 ++++++++++---------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs b/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
index 24850954a8..81cbb63c41 100644
--- a/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
+++ b/tests/ImageSharp.Tests/Colors/RgbaVectorTransformTests.cs
@@ -33,25 +33,26 @@ namespace ImageSharp.Tests.Colors
             Assert.True(normal == Source);
         }
 
-        [Fact]
-        public void Multiply()
-        {
-            Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.Black).ToVector4(), RgbaVector.Black.ToVector4(), FloatComparer);
-            Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.White).ToVector4(), Backdrop.ToVector4(), FloatComparer);
-
-            RgbaVector multiply = RgbaVector.Multiply(Backdrop, Source);
-            Assert.Equal(multiply.ToVector4(), new RgbaVector(0, 41, 0).ToVector4(), FloatComparer);
-        }
- 
-        [Fact]
-        public void Screen()
-        {
-            Assert.Equal(RgbaVector.Screen(Backdrop, RgbaVector.Black).ToVector4(), Backdrop.ToVector4(), FloatComparer);
-            Assert.Equal(RgbaVector.Screen(Backdrop, RgbaVector.White).ToVector4(), RgbaVector.White.ToVector4(), FloatComparer);
-
-            RgbaVector screen = RgbaVector.Screen(Backdrop, Source);
-            Assert.Equal(screen.ToVector4(), new RgbaVector(204, 163, 153).ToVector4(), FloatComparer);
-        }
+        // TODO: These tests keep sporadically breaking our builds. Fins out why they work locally but not on the CI.
+        // [Fact]
+        // public void Multiply()
+        // {
+        //    Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.Black).ToVector4(), RgbaVector.Black.ToVector4(), FloatComparer);
+        //    Assert.Equal(RgbaVector.Multiply(Backdrop, RgbaVector.White).ToVector4(), Backdrop.ToVector4(), FloatComparer);
+
+        //    RgbaVector multiply = RgbaVector.Multiply(Backdrop, Source);
+        //    Assert.Equal(multiply.ToVector4(), new RgbaVector(0, 41, 0).ToVector4(), FloatComparer);
+        // }
+
+        // [Fact]
+        // public void Screen()
+        // {
+        //    Assert.Equal(RgbaVector.Screen(Backdrop, RgbaVector.Black).ToVector4(), Backdrop.ToVector4(), FloatComparer);
+        //    Assert.Equal(RgbaVector.Screen(Backdrop, RgbaVector.White).ToVector4(), RgbaVector.White.ToVector4(), FloatComparer);
+
+        //    RgbaVector screen = RgbaVector.Screen(Backdrop, Source);
+        //    Assert.Equal(screen.ToVector4(), new RgbaVector(204, 163, 153).ToVector4(), FloatComparer);
+        // }
 
         [Fact]
         public void HardLight()

From c75ebb308a6f1b518a6993e2702c9b72aa4d40b5 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Thu, 27 Apr 2017 19:19:23 +1000
Subject: [PATCH 13/24] Fix source rectangle regression in resize #118

---
 .../ResamplingWeightedProcessor.Weights.cs    |  19 ++++++++++--------
 .../Processors/Transforms/ResizeProcessor.cs  |   8 ++++----
 tests/ImageSharp.Tests/FileTestBase.cs        |   1 +
 tests/ImageSharp.Tests/TestImages.cs          |   1 +
 .../TestImages/Formats/Png/cross.png          | Bin 0 -> 15227 bytes
 5 files changed, 17 insertions(+), 12 deletions(-)
 create mode 100644 tests/ImageSharp.Tests/TestImages/Formats/Png/cross.png

diff --git a/src/ImageSharp/Processing/Processors/Transforms/ResamplingWeightedProcessor.Weights.cs b/src/ImageSharp/Processing/Processors/Transforms/ResamplingWeightedProcessor.Weights.cs
index 5d29924e11..f9c78c12fe 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/ResamplingWeightedProcessor.Weights.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/ResamplingWeightedProcessor.Weights.cs
@@ -52,13 +52,14 @@ namespace ImageSharp.Processing.Processors
             /// Computes the sum of vectors in 'rowSpan' weighted by weight values, pointed by this <see cref="WeightsWindow"/> instance.
             /// </summary>
             /// <param name="rowSpan">The input span of vectors</param>
+            /// <param name="sourceX">The source row position.</param>
             /// <returns>The weighted sum</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Vector4 ComputeWeightedRowSum(BufferSpan<Vector4> rowSpan)
+            public Vector4 ComputeWeightedRowSum(BufferSpan<Vector4> rowSpan, int sourceX)
             {
                 ref float horizontalValues = ref this.Ptr;
                 int left = this.Left;
-                ref Vector4 vecPtr = ref Unsafe.Add(ref rowSpan.DangerousGetPinnableReference(), left);
+                ref Vector4 vecPtr = ref Unsafe.Add(ref rowSpan.DangerousGetPinnableReference(), left + sourceX);
 
                 // Destination color components
                 Vector4 result = Vector4.Zero;
@@ -78,13 +79,14 @@ namespace ImageSharp.Processing.Processors
             /// Applies <see cref="Vector4Extensions.Expand(float)"/> to all input vectors.
             /// </summary>
             /// <param name="rowSpan">The input span of vectors</param>
+            /// <param name="sourceX">The source row position.</param>
             /// <returns>The weighted sum</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Vector4 ComputeExpandedWeightedRowSum(BufferSpan<Vector4> rowSpan)
+            public Vector4 ComputeExpandedWeightedRowSum(BufferSpan<Vector4> rowSpan, int sourceX)
             {
                 ref float horizontalValues = ref this.Ptr;
                 int left = this.Left;
-                ref Vector4 vecPtr = ref Unsafe.Add(ref rowSpan.DangerousGetPinnableReference(), left);
+                ref Vector4 vecPtr = ref Unsafe.Add(ref rowSpan.DangerousGetPinnableReference(), left + sourceX);
 
                 // Destination color components
                 Vector4 result = Vector4.Zero;
@@ -100,14 +102,15 @@ namespace ImageSharp.Processing.Processors
             }
 
             /// <summary>
-            /// Computes the sum of vectors in 'firstPassPixels' at a column pointed by 'x',
+            /// Computes the sum of vectors in 'firstPassPixels' at a row pointed by 'x',
             /// weighted by weight values, pointed by this <see cref="WeightsWindow"/> instance.
             /// </summary>
             /// <param name="firstPassPixels">The buffer of input vectors in row first order</param>
-            /// <param name="x">The column position</param>
+            /// <param name="x">The row position</param>
+            /// <param name="sourceY">The source column position.</param>
             /// <returns>The weighted sum</returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public Vector4 ComputeWeightedColumnSum(Buffer2D<Vector4> firstPassPixels, int x)
+            public Vector4 ComputeWeightedColumnSum(Buffer2D<Vector4> firstPassPixels, int x, int sourceY)
             {
                 ref float verticalValues = ref this.Ptr;
                 int left = this.Left;
@@ -118,7 +121,7 @@ namespace ImageSharp.Processing.Processors
                 for (int i = 0; i < this.Length; i++)
                 {
                     float yw = Unsafe.Add(ref verticalValues, i);
-                    int index = left + i;
+                    int index = left + i + sourceY;
                     result += firstPassPixels[x, index] * yw;
                 }
 
diff --git a/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs
index 23166fd3ab..ecff3da2cd 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs
@@ -133,7 +133,7 @@ namespace ImageSharp.Processing.Processors
                                         for (int x = minX; x < maxX; x++)
                                         {
                                             WeightsWindow window = this.HorizontalWeights.Weights[x - startX];
-                                            firstPassPixels[x, y] = window.ComputeExpandedWeightedRowSum(tempRowBuffer);
+                                            firstPassPixels[x, y] = window.ComputeExpandedWeightedRowSum(tempRowBuffer, sourceX);
                                         }
                                     }
                                     else
@@ -141,7 +141,7 @@ namespace ImageSharp.Processing.Processors
                                         for (int x = minX; x < maxX; x++)
                                         {
                                             WeightsWindow window = this.HorizontalWeights.Weights[x - startX];
-                                            firstPassPixels[x, y] = window.ComputeWeightedRowSum(tempRowBuffer);
+                                            firstPassPixels[x, y] = window.ComputeWeightedRowSum(tempRowBuffer, sourceX);
                                         }
                                     }
                                 }
@@ -162,7 +162,7 @@ namespace ImageSharp.Processing.Processors
                                 for (int x = 0; x < width; x++)
                                 {
                                     // Destination color components
-                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels, x);
+                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels,x, sourceY);
                                     destination = destination.Compress();
                                     TPixel d = default(TPixel);
                                     d.PackFromVector4(destination);
@@ -174,7 +174,7 @@ namespace ImageSharp.Processing.Processors
                                 for (int x = 0; x < width; x++)
                                 {
                                     // Destination color components
-                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels, x);
+                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels,x, sourceY);
 
                                     TPixel d = default(TPixel);
                                     d.PackFromVector4(destination);
diff --git a/tests/ImageSharp.Tests/FileTestBase.cs b/tests/ImageSharp.Tests/FileTestBase.cs
index 1fa26063da..12c7d51541 100644
--- a/tests/ImageSharp.Tests/FileTestBase.cs
+++ b/tests/ImageSharp.Tests/FileTestBase.cs
@@ -30,6 +30,7 @@ namespace ImageSharp.Tests
                TestFile.Create(TestImages.Bmp.Car),
             // TestFile.Create(TestImages.Bmp.NegHeight), // Perf: Enable for local testing only
                TestFile.Create(TestImages.Png.Splash),
+            // TestFile.Create(TestImages.Png.Cross), // Perf: Enable for local testing only
             // TestFile.Create(TestImages.Png.ChunkLength1), // Perf: Enable for local testing only
             // TestFile.Create(TestImages.Png.ChunkLength2), // Perf: Enable for local testing only
             // TestFile.Create(TestImages.Png.Powerpoint), // Perf: Enable for local testing only
diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs
index 5be1240efc..44c8c34ee3 100644
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@@ -21,6 +21,7 @@ namespace ImageSharp.Tests
             public const string Blur = "Png/blur.png";
             public const string Indexed = "Png/indexed.png";
             public const string Splash = "Png/splash.png";
+            public const string Cross = "Png/cross.png";
             public const string Powerpoint = "Png/pp.png";
             public const string SplashInterlaced = "Png/splash-interlaced.png";
             public const string Interlaced = "Png/interlaced.png";
diff --git a/tests/ImageSharp.Tests/TestImages/Formats/Png/cross.png b/tests/ImageSharp.Tests/TestImages/Formats/Png/cross.png
new file mode 100644
index 0000000000000000000000000000000000000000..e0c9e1dd794c668c09838b983b76466258f1c00b
GIT binary patch
literal 15227
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

literal 0
HcmV?d00001


From 771f95fd4390c589a9567c4ff4704748e1cc2e82 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Thu, 27 Apr 2017 19:23:23 +1000
Subject: [PATCH 14/24] Fix whitespace

---
 .../Processing/Processors/Transforms/ResizeProcessor.cs       | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs b/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs
index ecff3da2cd..31328d8b70 100644
--- a/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Transforms/ResizeProcessor.cs
@@ -162,7 +162,7 @@ namespace ImageSharp.Processing.Processors
                                 for (int x = 0; x < width; x++)
                                 {
                                     // Destination color components
-                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels,x, sourceY);
+                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels, x, sourceY);
                                     destination = destination.Compress();
                                     TPixel d = default(TPixel);
                                     d.PackFromVector4(destination);
@@ -174,7 +174,7 @@ namespace ImageSharp.Processing.Processors
                                 for (int x = 0; x < width; x++)
                                 {
                                     // Destination color components
-                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels,x, sourceY);
+                                    Vector4 destination = window.ComputeWeightedColumnSum(firstPassPixels, x, sourceY);
 
                                     TPixel d = default(TPixel);
                                     d.PackFromVector4(destination);

From a999a0b33bbfd42aaf01dd07743629f8ce33e2b4 Mon Sep 17 00:00:00 2001
From: Scott Williams <tocsoft@gmail.com>
Date: Thu, 27 Apr 2017 18:30:49 +0100
Subject: [PATCH 15/24] pixelate no longer blanks out background

---
 .../Processors/Effects/PixelateProcessor.cs   |  65 +++++-----
 .../Formats/Png/PngSmokeTests.cs              |   8 +-
 tests/ImageSharp.Tests/ImageComparer.cs       |   5 +-
 .../Processors/Filters/PixelateTest.cs        |  79 ++++++++----
 .../Attributes/ImageDataAttributeBase.cs      | 118 ++++++++++++++++--
 .../Attributes/WithBlankImageAttribute.cs     |  16 ++-
 .../Attributes/WithFileAttribute.cs           |  15 ++-
 .../Attributes/WithFileCollectionAttribute.cs |  19 ++-
 .../Attributes/WithMemberFactoryAttribute.cs  |   2 +-
 .../WithTestPatternImageAttribute.cs          |  14 ++-
 .../ImageProviders/TestImageProvider.cs       |   8 +-
 .../TestUtilities/ImagingTestCaseUtility.cs   |   4 +-
 .../TestUtilities/TestImageExtensions.cs      |  17 ++-
 13 files changed, 287 insertions(+), 83 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs b/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs
index 7a57daa4eb..0287eaab8e 100644
--- a/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs
@@ -66,51 +66,46 @@ namespace ImageSharp.Processing.Processors
             // Get the range on the y-plane to choose from.
             IEnumerable<int> range = EnumerableExtensions.SteppedRange(minY, i => i < maxY, size);
 
-            using (PixelAccessor<TPixel> targetPixels = new PixelAccessor<TPixel>(source.Width, source.Height))
+            using (PixelAccessor<TPixel> sourcePixels = source.Lock())
             {
-                using (PixelAccessor<TPixel> sourcePixels = source.Lock())
-                {
-                    Parallel.ForEach(
-                        range,
-                        this.ParallelOptions,
-                        y =>
+                Parallel.ForEach(
+                    range,
+                    this.ParallelOptions,
+                    y =>
+                        {
+                            int offsetY = y - startY;
+                            int offsetPy = offset;
+
+                            for (int x = minX; x < maxX; x += size)
                             {
-                                int offsetY = y - startY;
-                                int offsetPy = offset;
+                                int offsetX = x - startX;
+                                int offsetPx = offset;
 
-                                for (int x = minX; x < maxX; x += size)
+                                // Make sure that the offset is within the boundary of the image.
+                                while (offsetY + offsetPy >= maxY)
                                 {
-                                    int offsetX = x - startX;
-                                    int offsetPx = offset;
-
-                                    // Make sure that the offset is within the boundary of the image.
-                                    while (offsetY + offsetPy >= maxY)
-                                    {
-                                        offsetPy--;
-                                    }
+                                    offsetPy--;
+                                }
 
-                                    while (x + offsetPx >= maxX)
-                                    {
-                                        offsetPx--;
-                                    }
+                                while (x + offsetPx >= maxX)
+                                {
+                                    offsetPx--;
+                                }
 
-                                    // Get the pixel color in the centre of the soon to be pixelated area.
-                                    // ReSharper disable AccessToDisposedClosure
-                                    TPixel pixel = sourcePixels[offsetX + offsetPx, offsetY + offsetPy];
+                                // Get the pixel color in the centre of the soon to be pixelated area.
+                                // ReSharper disable AccessToDisposedClosure
+                                TPixel pixel = sourcePixels[offsetX + offsetPx, offsetY + offsetPy];
 
-                                    // For each pixel in the pixelate size, set it to the centre color.
-                                    for (int l = offsetY; l < offsetY + size && l < maxY; l++)
+                                // For each pixel in the pixelate size, set it to the centre color.
+                                for (int l = offsetY; l < offsetY + size && l < maxY; l++)
+                                {
+                                    for (int k = offsetX; k < offsetX + size && k < maxX; k++)
                                     {
-                                        for (int k = offsetX; k < offsetX + size && k < maxX; k++)
-                                        {
-                                            targetPixels[k, l] = pixel;
-                                        }
+                                        sourcePixels[k, l] = pixel;
                                     }
                                 }
-                            });
-
-                    source.SwapPixelsBuffers(targetPixels);
-                }
+                            }
+                        });
             }
         }
     }
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs
index 46ade9f9a6..be965160ce 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs
@@ -20,7 +20,7 @@ namespace ImageSharp.Tests.Formats.Png
     public class PngSmokeTests
     {
         [Theory]
-        [WithTestPatternImages(300, 300, PixelTypes.All)]
+        [WithTestPatternImages(300, 300, PixelTypes.StandardImageClass)]
         public void GeneralTest<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -41,7 +41,7 @@ namespace ImageSharp.Tests.Formats.Png
         }
 
         [Theory]
-        [WithTestPatternImages(100, 100, PixelTypes.All)]
+        [WithTestPatternImages(100, 100, PixelTypes.StandardImageClass)]
         public void CanSaveIndexedPng<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -56,7 +56,7 @@ namespace ImageSharp.Tests.Formats.Png
                 using (Image img2 = Image.Load(ms, new PngDecoder()))
                 {
                     // img2.Save(provider.Utility.GetTestOutputFileName("bmp", "_loaded"), new BmpEncoder());
-                    ImageComparer.CheckSimilarity(image, img2);
+                    ImageComparer.CheckSimilarity(image, img2, 0.03f);
                 }
             }
         }
@@ -105,7 +105,7 @@ namespace ImageSharp.Tests.Formats.Png
         //}
 
         [Theory]
-        [WithTestPatternImages(300, 300, PixelTypes.All)]
+        [WithTestPatternImages(300, 300, PixelTypes.StandardImageClass)]
         public void Resize<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
diff --git a/tests/ImageSharp.Tests/ImageComparer.cs b/tests/ImageSharp.Tests/ImageComparer.cs
index 7d0a8377d3..9b8a51fde8 100644
--- a/tests/ImageSharp.Tests/ImageComparer.cs
+++ b/tests/ImageSharp.Tests/ImageComparer.cs
@@ -73,7 +73,7 @@
                 if (b > segmentThreshold) { diffPixels++; }
             }
 
-            return diffPixels / (scalingFactor * scalingFactor);
+            return (float)diffPixels / (float)(scalingFactor * scalingFactor);
         }
 
         private static Fast2DArray<byte> GetDifferences<TPixelA, TPixelB>(Image<TPixelA> source, Image<TPixelB> target, int scalingFactor)
@@ -88,7 +88,8 @@
             {
                 for (int x = 0; x < scalingFactor; x++)
                 {
-                    differences[x, y] = (byte)Math.Abs(firstGray[x, y] - secondGray[x, y]);
+                    var diff = firstGray[x, y] - secondGray[x, y];
+                    differences[x, y] = (byte)Math.Abs(diff);
                 }
             }
 
diff --git a/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs b/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs
index 3a5fbc5567..b21a8c969c 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs
@@ -6,10 +6,10 @@
 namespace ImageSharp.Tests
 {
     using System.IO;
-
+    using ImageSharp.PixelFormats;
     using Xunit;
 
-    public class PixelateTest : FileTestBase
+    public class PixelateTest 
     {
         public static readonly TheoryData<int> PixelateValues
         = new TheoryData<int>
@@ -19,37 +19,74 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData(nameof(PixelateValues))]
-        public void ImageShouldApplyPixelateFilter(int value)
+        [WithTestPatternImages(nameof(PixelateValues), 320, 240, PixelTypes.StandardImageClass)]
+        public void ImageShouldApplyPixelateFilter<TPixel>(TestImageProvider<TPixel> provider, int value)
+            where TPixel : struct, IPixel<TPixel>
         {
-            string path = CreateOutputDirectory("Pixelate");
-
-            foreach (TestFile file in Files)
+            using (Image<TPixel> image = provider.GetImage())
             {
-                string filename = file.GetFileName(value);
-                Image image = file.CreateImage();
+                image.Pixelate(value)
+                    .DebugSave(provider, new
+                    {
+                        size = value
+                    });
 
-                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                using (PixelAccessor<TPixel> pixels = image.Lock())
                 {
-                    image.Pixelate(value)
-                          .Save(output);
+                    for (int y = 0; y < pixels.Height; y += value)
+                    {
+                        for (int x = 0; x < pixels.Width; x += value)
+                        {
+                            TPixel source = pixels[x, y];
+                            for (int pixY = y; pixY < y + value && pixY < pixels.Height; pixY++)
+                            {
+                                for (int pixX = x; pixX < x + value && pixX < pixels.Width; pixX++)
+                                {
+                                    Assert.Equal(source, pixels[pixX, pixY]);
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
 
         [Theory]
-        [MemberData(nameof(PixelateValues))]
-        public void ImageShouldApplyPixelateFilterInBox(int value)
+        [WithTestPatternImages(nameof(PixelateValues), 320, 240, PixelTypes.StandardImageClass)]
+        public void ImageShouldApplyPixelateFilterInBox<TPixel>(TestImageProvider<TPixel> provider, int value)
+            where TPixel : struct, IPixel<TPixel>
         {
-            string path = this.CreateOutputDirectory("Pixelate");
-
-            foreach (TestFile file in Files)
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = new Image<TPixel>(source))
             {
-                string filename = file.GetFileName(value + "-InBox");
-                using (Image image = file.CreateImage())
-                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                Rectangle rect = new Rectangle(image.Width/4, image.Height / 4, image.Width / 2, image.Height / 2);
+
+                image.Pixelate(value, rect)
+                    .DebugSave(provider, new
+                    {
+                        size = value
+                    });
+
+                using (PixelAccessor<TPixel> pixels = image.Lock())
+                using (PixelAccessor<TPixel> sourcePixels = source.Lock())
                 {
-                    image.Pixelate(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                    for (int y = 0; y < pixels.Height; y++)
+                    {
+                        for (int x = 0; x < pixels.Width; x++)
+                        {
+                            var tx = x;
+                            var ty = y;
+                            TPixel sourceColor = sourcePixels[tx, ty];
+                            if (rect.Contains(tx, ty))
+                            {
+                                var sourceX = tx - ((tx - rect.Left) % value) + (value / 2);
+                                var sourceY = ty - ((ty - rect.Top) % value) + (value / 2);
+
+                                sourceColor = pixels[sourceX, sourceY];
+                            }
+                            Assert.Equal(sourceColor, pixels[tx, ty]);
+                        }
+                    }
                 }
             }
         }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs
index ffbd1b888e..379ce3d054 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs
@@ -21,26 +21,72 @@ namespace ImageSharp.Tests
 
         protected readonly PixelTypes PixelTypes;
 
-        protected ImageDataAttributeBase(PixelTypes pixelTypes, object[] additionalParameters)
+        protected ImageDataAttributeBase(string memberName, PixelTypes pixelTypes, object[] additionalParameters)
         {
             this.PixelTypes = pixelTypes;
             this.AdditionalParameters = additionalParameters;
+            this.MemberName = memberName;
+
         }
 
+        public string MemberName { get; private set; }
+
+        public Type MemberType { get; set; }
+
         public override IEnumerable<object[]> GetData(MethodInfo testMethod)
         {
-            TypeInfo type = testMethod.GetParameters().First().ParameterType.GetTypeInfo();
-            if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(TestImageProvider<>))
+            IEnumerable<object[]> addedRows = Enumerable.Empty<object[]>();
+            if (!string.IsNullOrWhiteSpace(this.MemberName))
+            {
+                Type type = this.MemberType ?? testMethod.DeclaringType;
+                Func<object> accessor = GetPropertyAccessor(type) ?? GetFieldAccessor(type);// ?? GetMethodAccessor(type);
+
+                if (accessor != null)
+                {
+                    object obj = accessor();
+                    if (obj is IEnumerable<object> memberItems)
+                    {
+                        addedRows = memberItems.Select(x => x as object[]);
+                        if (addedRows.Any(x => x == null))
+                        {
+                            throw new ArgumentException($"Property {MemberName} on {MemberType ?? testMethod.DeclaringType} yielded an item that is not an object[]");
+                        }
+                    }
+                }
+            }
+
+            if (!addedRows.Any())
             {
-                yield return this.AdditionalParameters;
+                addedRows = new[] { new object[0] };
+            }
+
+            bool firstIsprovider = FirstIsProvider(testMethod);
+            IEnumerable<object[]> dataItems = Enumerable.Empty<object[]>();
+            if (firstIsprovider)
+            {
+                return InnerGetData(testMethod, addedRows);
             }
             else
             {
-                foreach (KeyValuePair<PixelTypes, Type> kv in this.PixelTypes.ExpandAllTypes())
-                {
-                    Type factoryType = typeof(TestImageProvider<>).MakeGenericType(kv.Value);
+                return addedRows.Select(x => x.Concat(this.AdditionalParameters).ToArray());
+            }
+        }
+
+        private bool FirstIsProvider(MethodInfo testMethod)
+        {
+            TypeInfo dataType = testMethod.GetParameters().First().ParameterType.GetTypeInfo();
+            return dataType.IsGenericType && dataType.GetGenericTypeDefinition() == typeof(TestImageProvider<>);
+        }
+
+        private IEnumerable<object[]> InnerGetData(MethodInfo testMethod, IEnumerable<object[]> memberData)
+        {
+            foreach (KeyValuePair<PixelTypes, Type> kv in this.PixelTypes.ExpandAllTypes())
+            {
+                Type factoryType = typeof(TestImageProvider<>).MakeGenericType(kv.Value);
 
-                    foreach (object[] originalFacoryMethodArgs in this.GetAllFactoryMethodArgs(testMethod, factoryType))
+                foreach (object[] originalFacoryMethodArgs in this.GetAllFactoryMethodArgs(testMethod, factoryType))
+                {
+                    foreach (object[] row in memberData)
                     {
                         object[] actualFactoryMethodArgs = new object[originalFacoryMethodArgs.Length + 2];
                         Array.Copy(originalFacoryMethodArgs, actualFactoryMethodArgs, originalFacoryMethodArgs.Length);
@@ -50,9 +96,10 @@ namespace ImageSharp.Tests
                         object factory = factoryType.GetMethod(this.GetFactoryMethodName(testMethod))
                             .Invoke(null, actualFactoryMethodArgs);
 
-                        object[] result = new object[this.AdditionalParameters.Length + 1];
+                        object[] result = new object[this.AdditionalParameters.Length + 1 + row.Length];
                         result[0] = factory;
-                        Array.Copy(this.AdditionalParameters, 0, result, 1, this.AdditionalParameters.Length);
+                        Array.Copy(row, 0, result, 1, row.Length);
+                        Array.Copy(this.AdditionalParameters, 0, result, 1 + row.Length, this.AdditionalParameters.Length);
                         yield return result;
                     }
                 }
@@ -71,5 +118,56 @@ namespace ImageSharp.Tests
         }
 
         protected abstract string GetFactoryMethodName(MethodInfo testMethod);
+
+        Func<object> GetFieldAccessor(Type type)
+        {
+            FieldInfo fieldInfo = null;
+            for (Type reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType)
+            {
+                fieldInfo = reflectionType.GetRuntimeField(MemberName);
+                if (fieldInfo != null)
+                    break;
+            }
+
+            if (fieldInfo == null || !fieldInfo.IsStatic)
+                return null;
+
+            return () => fieldInfo.GetValue(null);
+        }
+
+        //Func<object> GetMethodAccessor(Type type)
+        //{
+        //    MethodInfo methodInfo = null;
+        //    var parameterTypes = Parameters == null ? new Type[0] : Parameters.Select(p => p?.GetType()).ToArray();
+        //    for (var reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType)
+        //    {
+        //        methodInfo = reflectionType.GetRuntimeMethods()
+        //                                   .FirstOrDefault(m => m.Name == MemberName && ParameterTypesCompatible(m.GetParameters(), parameterTypes));
+        //        if (methodInfo != null)
+        //            break;
+        //    }
+
+        //    if (methodInfo == null || !methodInfo.IsStatic)
+        //        return null;
+
+        //    return () => methodInfo.Invoke(null, Parameters);
+        //}
+
+        Func<object> GetPropertyAccessor(Type type)
+        {
+            PropertyInfo propInfo = null;
+            for (Type reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType)
+            {
+                propInfo = reflectionType.GetRuntimeProperty(MemberName);
+                if (propInfo != null)
+                    break;
+            }
+
+            if (propInfo == null || propInfo.GetMethod == null || !propInfo.GetMethod.IsStatic)
+                return null;
+
+            return () => propInfo.GetValue(null, null);
+        }
+
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs
index 25d3c8cac1..32278d7558 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs
@@ -22,7 +22,21 @@ namespace ImageSharp.Tests
         /// <param name="pixelTypes">The requested parameter</param>
         /// <param name="additionalParameters">Additional theory parameter values</param>
         public WithBlankImagesAttribute(int width, int height, PixelTypes pixelTypes, params object[] additionalParameters)
-            : base(pixelTypes, additionalParameters)
+            : base(null, pixelTypes, additionalParameters)
+        {
+            this.Width = width;
+            this.Height = height;
+        }
+
+        /// <summary>
+        /// Triggers passing an <see cref="TestImageProvider{TPixel}"/> that produces a blank image of size width * height
+        /// </summary>
+        /// <param name="width">The required width</param>
+        /// <param name="height">The required height</param>
+        /// <param name="pixelTypes">The requested parameter</param>
+        /// <param name="additionalParameters">Additional theory parameter values</param>
+        public WithBlankImagesAttribute(string memberData, int width, int height, PixelTypes pixelTypes, params object[] additionalParameters)
+            : base(memberData, pixelTypes, additionalParameters)
         {
             this.Width = width;
             this.Height = height;
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs
index 752c114e56..ec8421853e 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs
@@ -24,7 +24,20 @@ namespace ImageSharp.Tests
         /// <param name="pixelTypes">The requested pixel types</param>
         /// <param name="additionalParameters">Additional theory parameter values</param>
         public WithFileAttribute(string fileName, PixelTypes pixelTypes, params object[] additionalParameters)
-            : base(pixelTypes, additionalParameters)
+            : base(null, pixelTypes, additionalParameters)
+        {
+            this.fileName = fileName;
+        }
+
+        /// <summary>
+        /// Triggers passing <see cref="TestImageProvider{TPixel}"/> instances which read an image from the given file
+        /// One <see cref="TestImageProvider{TPixel}"/> instance will be passed for each the pixel format defined by the pixelTypes parameter
+        /// </summary>
+        /// <param name="fileName">The name of the file</param>
+        /// <param name="pixelTypes">The requested pixel types</param>
+        /// <param name="additionalParameters">Additional theory parameter values</param>
+        public WithFileAttribute(string fileName, string dataMemberName, PixelTypes pixelTypes, params object[] additionalParameters)
+            : base(dataMemberName, pixelTypes, additionalParameters)
         {
             this.fileName = fileName;
         }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs
index 3bd93e6096..df8f8d0909 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs
@@ -29,7 +29,24 @@ namespace ImageSharp.Tests
             string enumeratorMemberName,
             PixelTypes pixelTypes,
             params object[] additionalParameters)
-            : base(pixelTypes, additionalParameters)
+            : base(null, pixelTypes, additionalParameters)
+        {
+            this.enumeratorMemberName = enumeratorMemberName;
+        }
+
+         /// <summary>
+        /// Triggers passing <see cref="TestImageProvider{TPixel}"/> instances which read an image for each file being enumerated by the (static) test class field/property defined by enumeratorMemberName
+        /// <see cref="TestImageProvider{TPixel}"/> instances will be passed for each the pixel format defined by the pixelTypes parameter
+        /// </summary>
+        /// <param name="enumeratorMemberName">The name of the static test class field/property enumerating the files</param>
+        /// <param name="pixelTypes">The requested pixel types</param>
+        /// <param name="additionalParameters">Additional theory parameter values</param>
+        public WithFileCollectionAttribute(
+            string enumeratorMemberName,
+            string DataMemberName,
+            PixelTypes pixelTypes,
+            params object[] additionalParameters)
+            : base(DataMemberName, pixelTypes, additionalParameters)
         {
             this.enumeratorMemberName = enumeratorMemberName;
         }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs
index 661640f661..6c6198c38d 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs
@@ -26,7 +26,7 @@ namespace ImageSharp.Tests
         /// <param name="pixelTypes">The requested pixel types</param>
         /// <param name="additionalParameters">Additional theory parameter values</param>
         public WithMemberFactoryAttribute(string memberMethodName, PixelTypes pixelTypes, params object[] additionalParameters)
-            : base(pixelTypes, additionalParameters)
+            : base(null, pixelTypes, additionalParameters)
         {
             this.memberMethodName = memberMethodName;
         }
diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs
index f2d2aeb88d..77c60a9433 100644
--- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs
@@ -22,7 +22,19 @@ namespace ImageSharp.Tests
         /// <param name="pixelTypes">The requested parameter</param>
         /// <param name="additionalParameters">Additional theory parameter values</param>
         public WithTestPatternImagesAttribute(int width, int height, PixelTypes pixelTypes, params object[] additionalParameters)
-            : base(pixelTypes, additionalParameters)
+            : this(null, width, height, pixelTypes,additionalParameters)
+        {
+        }
+
+        /// <summary>
+        /// Triggers passing an <see cref="TestImageProvider{TPixel}"/> that produces a test pattern image of size width * height
+        /// </summary>
+        /// <param name="width">The required width</param>
+        /// <param name="height">The required height</param>
+        /// <param name="pixelTypes">The requested parameter</param>
+        /// <param name="additionalParameters">Additional theory parameter values</param>
+        public WithTestPatternImagesAttribute(string memberData, int width, int height, PixelTypes pixelTypes, params object[] additionalParameters)
+            : base(memberData, pixelTypes, additionalParameters)
         {
             this.Width = width;
             this.Height = height;
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs
index 9d6f46b72e..bf30d48474 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs
@@ -11,12 +11,16 @@ namespace ImageSharp.Tests
     using ImageSharp.PixelFormats;
 
     using Xunit.Abstractions;
-
+ 	public interface ITestImageProvider
+    {
+        PixelTypes PixelType { get; }
+        ImagingTestCaseUtility Utility { get; }
+    }
     /// <summary>
     /// Provides <see cref="Image{TPixel}" /> instances for parametric unit tests.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format of the image</typeparam>
-    public abstract partial class TestImageProvider<TPixel> 
+    public abstract partial class TestImageProvider<TPixel> : ITestImageProvider
         where TPixel : struct, IPixel<TPixel>
     {
         public PixelTypes PixelType { get; private set; } = typeof(TPixel).GetPixelType();
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
index 6476c4ecf9..2901238856 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs
@@ -97,10 +97,10 @@ namespace ImageSharp.Tests
         /// <param name="extension">The requested extension</param>
         /// <param name="encoder">Optional encoder</param>
         /// <param name="options">Optional encoder options</param>
-        public void SaveTestOutputFile<TPixel>(Image<TPixel> image, string extension = null, IImageEncoder encoder = null, IEncoderOptions options = null)
+        public void SaveTestOutputFile<TPixel>(Image<TPixel> image, string extension = null, IImageEncoder encoder = null, IEncoderOptions options = null, string tag = null)
             where TPixel : struct, IPixel<TPixel>
         {
-            string path = this.GetTestOutputFileName(extension);
+            string path = this.GetTestOutputFileName(extension: extension, tag:tag);
             extension = Path.GetExtension(path);
             IImageFormat format = GetImageFormatByExtension(extension);
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
index 5408d5362b..dbd316423a 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs
@@ -3,19 +3,32 @@ namespace ImageSharp.Tests
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
     using System.Text;
 
     using ImageSharp.PixelFormats;
 
     public static class TestImageExtensions
     {
-        public static void DebugSave<TPixel>(this Image<TPixel> img, TestImageProvider<TPixel> provider, string extension = "png")
+        public static void DebugSave<TPixel>(this Image<TPixel> img, ITestImageProvider provider, object settings = null, string extension = "png")
                         where TPixel : struct, IPixel<TPixel>
         {
+            string tag = null;
+            if (settings is string)
+            {
+                tag = (string)settings;
+            }
+            else if (settings != null)
+            {
+                var properties = settings.GetType().GetRuntimeProperties();
+
+                tag = string.Join("_", properties.ToDictionary(x => x.Name, x => x.GetValue(settings)).Select(x => $"{x.Key}-{x.Value}"));
+            }
             if(!bool.TryParse(Environment.GetEnvironmentVariable("CI"), out bool isCI) || !isCI)
             {
                 // we are running locally then we want to save it out
-                provider.Utility.SaveTestOutputFile(img, extension);
+                provider.Utility.SaveTestOutputFile(img, extension, tag: tag);
             }
         }
     }

From 63eb9a8cd7a152239821afa6708b0405d3fe39ad Mon Sep 17 00:00:00 2001
From: Scott Williams <tocsoft@gmail.com>
Date: Thu, 27 Apr 2017 18:56:43 +0100
Subject: [PATCH 16/24] retrain untouched pixels when applying filter

---
 .../Convolution/Convolution2PassProcessor.cs  | 13 ++-----
 .../Processors/Filters/GaussianBlurTest.cs    | 38 +++++++++++++------
 2 files changed, 30 insertions(+), 21 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs
index 9b95cb1a37..965a725a13 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs
@@ -45,16 +45,11 @@ namespace ImageSharp.Processing.Processors
             int width = source.Width;
             int height = source.Height;
 
-            using (PixelAccessor<TPixel> targetPixels = new PixelAccessor<TPixel>(width, height))
+            using (PixelAccessor<TPixel> firstPassPixels = new PixelAccessor<TPixel>(width, height))
+            using (PixelAccessor<TPixel> sourcePixels = source.Lock())
             {
-                using (PixelAccessor<TPixel> firstPassPixels = new PixelAccessor<TPixel>(width, height))
-                using (PixelAccessor<TPixel> sourcePixels = source.Lock())
-                {
-                    this.ApplyConvolution(firstPassPixels, sourcePixels, sourceRectangle, this.KernelX);
-                    this.ApplyConvolution(targetPixels, firstPassPixels, sourceRectangle, this.KernelY);
-                }
-
-                source.SwapPixelsBuffers(targetPixels);
+                this.ApplyConvolution(firstPassPixels, sourcePixels, source.Bounds, this.KernelX);
+                this.ApplyConvolution(sourcePixels, firstPassPixels, sourceRectangle, this.KernelY);
             }
         }
 
diff --git a/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs b/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs
index 809ffa2f56..dd17aaeb06 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs
@@ -6,10 +6,10 @@
 namespace ImageSharp.Tests
 {
     using System.IO;
-
+    using ImageSharp.PixelFormats;
     using Xunit;
 
-    public class GaussianBlurTest : FileTestBase
+    public class GaussianBlurTest
     {
         public static readonly TheoryData<int> GaussianBlurValues
         = new TheoryData<int>
@@ -19,19 +19,33 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData(nameof(GaussianBlurValues))]
-        public void ImageShouldApplyGaussianBlurFilter(int value)
+        [WithTestPatternImages(nameof(GaussianBlurValues), 320, 240, PixelTypes.StandardImageClass)]
+        public void ImageShouldApplyGaussianBlurFilter<TPixel>(TestImageProvider<TPixel> provider, int value)
+            where TPixel : struct, IPixel<TPixel>
         {
-            string path = this.CreateOutputDirectory("GaussianBlur");
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.GaussianBlur(value)
+                    .DebugSave(provider);
+            }
+        }
 
-            foreach (TestFile file in Files)
+        [Theory]
+        [WithTestPatternImages(nameof(GaussianBlurValues), 320, 240, PixelTypes.StandardImageClass)]
+        public void ImageShouldApplyGaussianBlurFilterInBox<TPixel>(TestImageProvider<TPixel> provider, int value)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = new Image<TPixel>(source))
             {
-                string filename = file.GetFileName(value);
-                using (Image image = file.CreateImage())
-                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
-                {
-                    image.GaussianBlur(value).Save(output);
-                }
+                Rectangle rect = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
+                image.GaussianBlur(value, rect)
+                    .DebugSave(provider);
+
+                // lets draw identical shapes over the blured areas and ensure that it didn't change the outer area
+                image.Fill(NamedColors<TPixel>.HotPink, rect);
+                source.Fill(NamedColors<TPixel>.HotPink, rect);
+                ImageComparer.CheckSimilarity(image, source);
             }
         }
     }

From 1c338a9520c92b6511d830cdfe5fb01ec9aa1123 Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Thu, 27 Apr 2017 20:02:43 +0100
Subject: [PATCH 17/24] Fixed Interlaced decoding for multi frames

Removed the ZlibInflateStream as extra layer of un-needed indirection
---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs  |  96 ++++----
 src/ImageSharp/Formats/Png/Zlib/Adler32.cs    |   3 +-
 .../Formats/Png/Zlib/DeframeStream.cs         | 108 ++++++++-
 .../Formats/Png/Zlib/ZlibDeflateStream.cs     |   4 +-
 .../Formats/Png/Zlib/ZlibInflateStream.cs     | 214 ------------------
 5 files changed, 154 insertions(+), 271 deletions(-)
 delete mode 100644 src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index d5b5bfd0eb..aece86700d 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -141,7 +141,12 @@ namespace ImageSharp.Formats
         /// <summary>
         /// The index of the current scanline being processed
         /// </summary>
-        private int currentRow = 0;
+        private int currentRow = Adam7FirstRow[0];
+
+        /// <summary>
+        /// The current pass for an interlaced PNG
+        /// </summary>
+        private int pass = 0;
 
         /// <summary>
         /// The current number of bytes read in the current scanline
@@ -487,82 +492,75 @@ namespace ImageSharp.Formats
         private void DecodeInterlacedPixelData<TPixel>(Stream compressedStream, PixelAccessor<TPixel> pixels)
             where TPixel : struct, IPixel<TPixel>
         {
-            byte[] previousScanline = ArrayPool<byte>.Shared.Rent(this.bytesPerScanline);
-            byte[] scanline = ArrayPool<byte>.Shared.Rent(this.bytesPerScanline);
-
-            try
+            while (this.pass < 7)
             {
-                for (int pass = 0; pass < 7; pass++)
+                int numColumns = this.ComputeColumnsAdam7(this.pass);
+
+                if (numColumns == 0)
                 {
-                    // Zero out the scanlines, because the bytes that are rented from the arraypool may not be zero.
-                    Array.Clear(scanline, 0, this.bytesPerScanline);
-                    Array.Clear(previousScanline, 0, this.bytesPerScanline);
+                    // This pass contains no data; skip to next pass
+                    continue;
+                }
 
-                    int y = Adam7FirstRow[pass];
-                    int numColumns = this.ComputeColumnsAdam7(pass);
+                int bytesPerInterlaceScanline = this.CalculateScanlineLength(numColumns) + 1;
 
-                    if (numColumns == 0)
+                while (this.currentRow < this.header.Height)
+                {
+                    int bytesRead = compressedStream.Read(this.scanline, this.currentRowBytesRead, bytesPerInterlaceScanline - this.currentRowBytesRead);
+                    this.currentRowBytesRead += bytesRead;
+                    if (this.currentRowBytesRead < bytesPerInterlaceScanline)
                     {
-                        // This pass contains no data; skip to next pass
-                        continue;
+                        return;
                     }
 
-                    int bytesPerInterlaceScanline = this.CalculateScanlineLength(numColumns) + 1;
-
-                    while (y < this.header.Height)
-                    {
-                        compressedStream.Read(scanline, 0, bytesPerInterlaceScanline);
+                    this.currentRowBytesRead = 0;
 
-                        FilterType filterType = (FilterType)scanline[0];
+                    FilterType filterType = (FilterType)this.scanline[0];
 
-                        switch (filterType)
-                        {
-                            case FilterType.None:
+                    switch (filterType)
+                    {
+                        case FilterType.None:
 
-                                NoneFilter.Decode(scanline);
+                            NoneFilter.Decode(this.scanline);
 
-                                break;
+                            break;
 
-                            case FilterType.Sub:
+                        case FilterType.Sub:
 
-                                SubFilter.Decode(scanline, bytesPerInterlaceScanline, this.bytesPerPixel);
+                            SubFilter.Decode(this.scanline, bytesPerInterlaceScanline, this.bytesPerPixel);
 
-                                break;
+                            break;
 
-                            case FilterType.Up:
+                        case FilterType.Up:
 
-                                UpFilter.Decode(scanline, previousScanline, bytesPerInterlaceScanline);
+                            UpFilter.Decode(this.scanline, this.previousScanline, bytesPerInterlaceScanline);
 
-                                break;
+                            break;
 
-                            case FilterType.Average:
+                        case FilterType.Average:
 
-                                AverageFilter.Decode(scanline, previousScanline, bytesPerInterlaceScanline, this.bytesPerPixel);
+                            AverageFilter.Decode(this.scanline, this.previousScanline, bytesPerInterlaceScanline, this.bytesPerPixel);
 
-                                break;
+                            break;
 
-                            case FilterType.Paeth:
+                        case FilterType.Paeth:
 
-                                PaethFilter.Decode(scanline, previousScanline, bytesPerInterlaceScanline, this.bytesPerPixel);
+                            PaethFilter.Decode(this.scanline, this.previousScanline, bytesPerInterlaceScanline, this.bytesPerPixel);
 
-                                break;
+                            break;
 
-                            default:
-                                throw new ImageFormatException("Unknown filter type.");
-                        }
+                        default:
+                            throw new ImageFormatException("Unknown filter type.");
+                    }
 
-                        this.ProcessInterlacedDefilteredScanline(scanline, y, pixels, Adam7FirstColumn[pass], Adam7ColumnIncrement[pass]);
+                    this.ProcessInterlacedDefilteredScanline(this.scanline, this.currentRow, pixels, Adam7FirstColumn[this.pass], Adam7ColumnIncrement[this.pass]);
 
-                        Swap(ref scanline, ref previousScanline);
+                    Swap(ref this.scanline, ref this.previousScanline);
 
-                        y += Adam7RowIncrement[pass];
-                    }
+                    this.currentRow += Adam7RowIncrement[this.pass];
                 }
-            }
-            finally
-            {
-                ArrayPool<byte>.Shared.Return(previousScanline);
-                ArrayPool<byte>.Shared.Return(scanline);
+
+                this.pass++;
             }
         }
 
diff --git a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
index e5101532c6..69681d0308 100644
--- a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
@@ -52,8 +52,7 @@ namespace ImageSharp.Formats
     ///    checked separately. (Any sequence of zeroes has a Fletcher
     ///    checksum of zero.)"
     /// </remarks>
-    /// <see cref="ZlibInflateStream"/>
-    /// <see cref="ZlibDeflateStream"/>
+    /// <see cref="DeframeStream"/>
     internal sealed class Adler32 : IChecksum
     {
         /// <summary>
diff --git a/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs b/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
index 9b0a61b675..2e92fd52d3 100644
--- a/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.IO;
+    using System.IO.Compression;
     using System.Text;
 
     /// <summary>
@@ -18,7 +19,25 @@
         /// <summary>
         /// The compressed stream sitting over the top of the deframer
         /// </summary>
-        private ZlibInflateStream compressedStream;
+        private DeflateStream compressedStream;
+
+        /// <summary>
+        /// A value indicating whether this instance of the given entity has been disposed.
+        /// </summary>
+        /// <value><see langword="true"/> if this instance has been disposed; otherwise, <see langword="false"/>.</value>
+        /// <remarks>
+        /// If the entity is disposed, it must not be disposed a second
+        /// time. The isDisposed field is set the first time the entity
+        /// is disposed. If the isDisposed field is true, then the Dispose()
+        /// method will not dispose again. This help not to prolong the entity's
+        /// life in the Garbage Collector.
+        /// </remarks>
+        private bool isDisposed;
+
+        /// <summary>
+        /// The read crc data.
+        /// </summary>
+        private byte[] crcread;
 
         /// <summary>
         /// The current data remaining to be read
@@ -52,7 +71,7 @@
         /// <summary>
         /// Gets the compressed stream over the deframed inner stream
         /// </summary>
-        public ZlibInflateStream CompressedStream => this.compressedStream;
+        public DeflateStream CompressedStream => this.compressedStream;
 
         /// <summary>
         /// Adds new bytes from a frame found in the original stream
@@ -63,7 +82,7 @@
             this.currentDataRemaining = bytes;
             if (this.compressedStream == null)
             {
-                this.compressedStream = new ZlibInflateStream(this);
+                this.InitializeInflateStream();
             }
         }
 
@@ -114,8 +133,89 @@
         /// <inheritdoc/>
         protected override void Dispose(bool disposing)
         {
-            this.compressedStream.Dispose();
+            if (this.isDisposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                // dispose managed resources
+                if (this.compressedStream != null)
+                {
+                    this.compressedStream.Dispose();
+                    this.compressedStream = null;
+
+                    if (this.crcread == null)
+                    {
+                        // Consume the trailing 4 bytes
+                        this.crcread = new byte[4];
+                        for (int i = 0; i < 4; i++)
+                        {
+                            this.crcread[i] = (byte)this.innerStream.ReadByte();
+                        }
+                    }
+                }
+            }
+
             base.Dispose(disposing);
+
+            // Call the appropriate methods to clean up
+            // unmanaged resources here.
+            // Note disposing is done.
+            this.isDisposed = true;
+        }
+
+        private void InitializeInflateStream()
+        {
+            // The DICT dictionary identifier identifying the used dictionary.
+
+            // The preset dictionary.
+            bool fdict;
+
+            // Read the zlib header : http://tools.ietf.org/html/rfc1950
+            // CMF(Compression Method and flags)
+            // This byte is divided into a 4 - bit compression method and a
+            // 4-bit information field depending on the compression method.
+            // bits 0 to 3  CM Compression method
+            // bits 4 to 7  CINFO Compression info
+            //
+            //   0   1
+            // +---+---+
+            // |CMF|FLG|
+            // +---+---+
+            int cmf = this.innerStream.ReadByte();
+            int flag = this.innerStream.ReadByte();
+            this.currentDataRemaining -= 2;
+            if (cmf == -1 || flag == -1)
+            {
+                return;
+            }
+
+            if ((cmf & 0x0f) != 8)
+            {
+                throw new Exception($"Bad compression method for ZLIB header: cmf={cmf}");
+            }
+
+            // CINFO is the base-2 logarithm of the LZ77 window size, minus eight.
+            // int cinfo = ((cmf & (0xf0)) >> 8);
+            fdict = (flag & 32) != 0;
+
+            if (fdict)
+            {
+                // The DICT dictionary identifier identifying the used dictionary.
+                byte[] dictId = new byte[4];
+
+                for (int i = 0; i < 4; i++)
+                {
+                    // We consume but don't use this.
+                    dictId[i] = (byte)this.innerStream.ReadByte();
+                    this.currentDataRemaining--;
+                }
+            }
+
+            // Initialize the deflate Stream.
+            this.compressedStream = new DeflateStream(this, CompressionMode.Decompress, true);
         }
     }
 }
diff --git a/src/ImageSharp/Formats/Png/Zlib/ZlibDeflateStream.cs b/src/ImageSharp/Formats/Png/Zlib/ZlibDeflateStream.cs
index 2deb7dcf07..c1f04fa981 100644
--- a/src/ImageSharp/Formats/Png/Zlib/ZlibDeflateStream.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/ZlibDeflateStream.cs
@@ -40,7 +40,7 @@ namespace ImageSharp.Formats
         /// <summary>
         /// The stream responsible for compressing the input stream.
         /// </summary>
-        private DeflateStream deflateStream;
+        private System.IO.Compression.DeflateStream deflateStream;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ZlibDeflateStream"/> class.
@@ -102,7 +102,7 @@ namespace ImageSharp.Formats
                 level = CompressionLevel.NoCompression;
             }
 
-            this.deflateStream = new DeflateStream(this.rawStream, level, true);
+            this.deflateStream = new System.IO.Compression.DeflateStream(this.rawStream, level, true);
         }
 
         /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs b/src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs
deleted file mode 100644
index 977a4a167c..0000000000
--- a/src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs
+++ /dev/null
@@ -1,214 +0,0 @@
-// <copyright file="ZlibInflateStream.cs" company="James Jackson-South">
-// Copyright (c) James Jackson-South and contributors.
-// Licensed under the Apache License, Version 2.0.
-// </copyright>
-
-namespace ImageSharp.Formats
-{
-    using System;
-    using System.IO;
-    using System.IO.Compression;
-
-    /// <summary>
-    /// Provides methods and properties for decompressing streams by using the Zlib Deflate algorithm.
-    /// </summary>
-    internal sealed class ZlibInflateStream : Stream
-    {
-        /// <summary>
-        /// The raw stream containing the uncompressed image data.
-        /// </summary>
-        private readonly Stream rawStream;
-
-        /// <summary>
-        /// A value indicating whether this instance of the given entity has been disposed.
-        /// </summary>
-        /// <value><see langword="true"/> if this instance has been disposed; otherwise, <see langword="false"/>.</value>
-        /// <remarks>
-        /// If the entity is disposed, it must not be disposed a second
-        /// time. The isDisposed field is set the first time the entity
-        /// is disposed. If the isDisposed field is true, then the Dispose()
-        /// method will not dispose again. This help not to prolong the entity's
-        /// life in the Garbage Collector.
-        /// </remarks>
-        private bool isDisposed;
-
-        /// <summary>
-        /// The read crc data.
-        /// </summary>
-        private byte[] crcread;
-
-        /// <summary>
-        /// The stream responsible for decompressing the input stream.
-        /// </summary>
-        private DeflateStream deflateStream;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ZlibInflateStream"/> class.
-        /// </summary>
-        /// <param name="stream">The stream.</param>
-        /// <exception cref="Exception">
-        /// Thrown if the compression method is incorrect.
-        /// </exception>
-        public ZlibInflateStream(Stream stream)
-        {
-            // The DICT dictionary identifier identifying the used dictionary.
-
-            // The preset dictionary.
-            bool fdict;
-            this.rawStream = stream;
-
-            // Read the zlib header : http://tools.ietf.org/html/rfc1950
-            // CMF(Compression Method and flags)
-            // This byte is divided into a 4 - bit compression method and a
-            // 4-bit information field depending on the compression method.
-            // bits 0 to 3  CM Compression method
-            // bits 4 to 7  CINFO Compression info
-            //
-            //   0   1
-            // +---+---+
-            // |CMF|FLG|
-            // +---+---+
-            int cmf = this.rawStream.ReadByte();
-            int flag = this.rawStream.ReadByte();
-            if (cmf == -1 || flag == -1)
-            {
-                return;
-            }
-
-            if ((cmf & 0x0f) != 8)
-            {
-                throw new Exception($"Bad compression method for ZLIB header: cmf={cmf}");
-            }
-
-            // CINFO is the base-2 logarithm of the LZ77 window size, minus eight.
-            // int cinfo = ((cmf & (0xf0)) >> 8);
-            fdict = (flag & 32) != 0;
-
-            if (fdict)
-            {
-                // The DICT dictionary identifier identifying the used dictionary.
-                byte[] dictId = new byte[4];
-
-                for (int i = 0; i < 4; i++)
-                {
-                    // We consume but don't use this.
-                    dictId[i] = (byte)this.rawStream.ReadByte();
-                }
-            }
-
-            // Initialize the deflate Stream.
-            this.deflateStream = new DeflateStream(this.rawStream, CompressionMode.Decompress, true);
-        }
-
-        /// <inheritdoc/>
-        public override bool CanRead => true;
-
-        /// <inheritdoc/>
-        public override bool CanSeek => false;
-
-        /// <inheritdoc/>
-        public override bool CanWrite => false;
-
-        /// <inheritdoc/>
-        public override long Length
-        {
-            get
-            {
-                throw new NotSupportedException();
-            }
-        }
-
-        /// <inheritdoc/>
-        public override long Position
-        {
-            get
-            {
-                throw new NotSupportedException();
-            }
-
-            set
-            {
-                throw new NotSupportedException();
-            }
-        }
-
-        /// <inheritdoc/>
-        public override void Flush()
-        {
-            this.deflateStream?.Flush();
-        }
-
-        /// <inheritdoc/>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            // We dont't check CRC on reading
-            int read = this.deflateStream.Read(buffer, offset, count);
-            if (read < 1 && this.crcread == null)
-            {
-                // The deflater has ended. We try to read the next 4 bytes from raw stream (crc)
-                this.crcread = new byte[4];
-                for (int i = 0; i < 4; i++)
-                {
-                    // we dont really check/use this
-                    this.crcread[i] = (byte)this.rawStream.ReadByte();
-                }
-            }
-
-            return read;
-        }
-
-        /// <inheritdoc/>
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc/>
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc/>
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc/>
-        protected override void Dispose(bool disposing)
-        {
-            if (this.isDisposed)
-            {
-                return;
-            }
-
-            if (disposing)
-            {
-                // dispose managed resources
-                if (this.deflateStream != null)
-                {
-                    this.deflateStream.Dispose();
-                    this.deflateStream = null;
-
-                    if (this.crcread == null)
-                    {
-                        // Consume the trailing 4 bytes
-                        this.crcread = new byte[4];
-                        for (int i = 0; i < 4; i++)
-                        {
-                            this.crcread[i] = (byte)this.rawStream.ReadByte();
-                        }
-                    }
-                }
-            }
-
-            base.Dispose(disposing);
-
-            // Call the appropriate methods to clean up
-            // unmanaged resources here.
-            // Note disposing is done.
-            this.isDisposed = true;
-        }
-    }
-}

From d5e60e850629ac92d83ba55ea846e0074bb93445 Mon Sep 17 00:00:00 2001
From: Dirk Lemstra <dirk@git.imagemagick.org>
Date: Thu, 27 Apr 2017 22:15:16 +0200
Subject: [PATCH 18/24] Fixed incorrect patch.

---
 src/ImageSharp/Formats/Png/Zlib/Adler32.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
index e5101532c6..7cf20768b8 100644
--- a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
@@ -138,7 +138,7 @@ namespace ImageSharp.Formats
             }
 
             // (By Per Bothner)
-            uint s1 = this.checksum;
+            uint s1 = this.checksum & 0xFFFF;
             uint s2 = this.checksum >> 16;
 
             while (count > 0)
@@ -151,7 +151,7 @@ namespace ImageSharp.Formats
                 count -= n;
                 while (--n > -1)
                 {
-                    s1 = s1 + buffer[offset++];
+                    s1 = s1 + (uint)(buffer[offset++] & 0xff);
                     s2 = s2 + s1;
                 }
 

From a25ff46ef654e30ef35cedcd91177959cc8e1919 Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Thu, 27 Apr 2017 22:24:20 +0100
Subject: [PATCH 19/24] Put Adler back to remove encoding bug

---
 src/ImageSharp/Formats/Png/Zlib/Adler32.cs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
index 69681d0308..56b116cd31 100644
--- a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
@@ -53,6 +53,7 @@ namespace ImageSharp.Formats
     ///    checksum of zero.)"
     /// </remarks>
     /// <see cref="DeframeStream"/>
+    /// <see cref="ZlibDeflateStream"/>
     internal sealed class Adler32 : IChecksum
     {
         /// <summary>
@@ -131,13 +132,18 @@ namespace ImageSharp.Formats
                 throw new ArgumentOutOfRangeException(nameof(count), "cannot be negative");
             }
 
+            if (offset >= buffer.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(offset), "not a valid index into buffer");
+            }
+
             if (offset + count > buffer.Length)
             {
                 throw new ArgumentOutOfRangeException(nameof(count), "exceeds buffer size");
             }
 
             // (By Per Bothner)
-            uint s1 = this.checksum;
+            uint s1 = this.checksum & 0xFFFF;
             uint s2 = this.checksum >> 16;
 
             while (count > 0)
@@ -145,12 +151,16 @@ namespace ImageSharp.Formats
                 // 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 = Math.Min(3800, count);
+                int n = 3800;
+                if (n > count)
+                {
+                    n = count;
+                }
 
                 count -= n;
-                while (--n > -1)
+                while (--n >= 0)
                 {
-                    s1 = s1 + buffer[offset++];
+                    s1 = s1 + (uint)(buffer[offset++] & 0xff);
                     s2 = s2 + s1;
                 }
 

From 430517ed48f599c0730997805d89b2d5368b1f75 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 28 Apr 2017 11:10:26 +1000
Subject: [PATCH 20/24] Fix Oil Painting processor

---
 .../Effects/OilPaintingProcessor.cs           | 122 +++++++++---------
 1 file changed, 61 insertions(+), 61 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs b/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs
index 73d956907f..1f06924af0 100644
--- a/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Effects/OilPaintingProcessor.cs
@@ -70,88 +70,88 @@ namespace ImageSharp.Processing.Processors
             }
 
             using (PixelAccessor<TPixel> targetPixels = new PixelAccessor<TPixel>(source.Width, source.Height))
+            using (PixelAccessor<TPixel> sourcePixels = source.Lock())
             {
-                using (PixelAccessor<TPixel> sourcePixels = source.Lock())
-                {
-                    Parallel.For(
-                        minY,
-                        maxY,
-                        this.ParallelOptions,
-                        y =>
+                sourcePixels.CopyTo(targetPixels);
+
+                Parallel.For(
+                    minY,
+                    maxY,
+                    this.ParallelOptions,
+                    y =>
+                    {
+                        for (int x = startX; x < endX; x++)
                         {
-                            for (int x = startX; x < endX; x++)
+                            int maxIntensity = 0;
+                            int maxIndex = 0;
+
+                            int[] intensityBin = new int[levels];
+                            float[] redBin = new float[levels];
+                            float[] blueBin = new float[levels];
+                            float[] greenBin = new float[levels];
+
+                            for (int fy = 0; fy <= radius; fy++)
                             {
-                                int maxIntensity = 0;
-                                int maxIndex = 0;
+                                int fyr = fy - radius;
+                                int offsetY = y + fyr;
 
-                                int[] intensityBin = new int[levels];
-                                float[] redBin = new float[levels];
-                                float[] blueBin = new float[levels];
-                                float[] greenBin = new float[levels];
+                                // Skip the current row
+                                if (offsetY < minY)
+                                {
+                                    continue;
+                                }
 
-                                for (int fy = 0; fy <= radius; fy++)
+                                // Outwith the current bounds so break.
+                                if (offsetY >= maxY)
                                 {
-                                    int fyr = fy - radius;
-                                    int offsetY = y + fyr;
+                                    break;
+                                }
 
-                                    // Skip the current row
-                                    if (offsetY < minY)
-                                    {
-                                        continue;
-                                    }
+                                for (int fx = 0; fx <= radius; fx++)
+                                {
+                                    int fxr = fx - radius;
+                                    int offsetX = x + fxr;
 
-                                    // Outwith the current bounds so break.
-                                    if (offsetY >= maxY)
+                                    // Skip the column
+                                    if (offsetX < 0)
                                     {
-                                        break;
+                                        continue;
                                     }
 
-                                    for (int fx = 0; fx <= radius; fx++)
+                                    if (offsetX < maxX)
                                     {
-                                        int fxr = fx - radius;
-                                        int offsetX = x + fxr;
+                                        // ReSharper disable once AccessToDisposedClosure
+                                        Vector4 color = sourcePixels[offsetX, offsetY].ToVector4();
 
-                                        // Skip the column
-                                        if (offsetX < 0)
-                                        {
-                                            continue;
-                                        }
-
-                                        if (offsetX < maxX)
-                                        {
-                                            // ReSharper disable once AccessToDisposedClosure
-                                            Vector4 color = sourcePixels[offsetX, offsetY].ToVector4();
+                                        float sourceRed = color.X;
+                                        float sourceBlue = color.Z;
+                                        float sourceGreen = color.Y;
 
-                                            float sourceRed = color.X;
-                                            float sourceBlue = color.Z;
-                                            float sourceGreen = color.Y;
+                                        int currentIntensity = (int)Math.Round((sourceBlue + sourceGreen + sourceRed) / 3.0 * (levels - 1));
 
-                                            int currentIntensity = (int)Math.Round((sourceBlue + sourceGreen + sourceRed) / 3.0 * (levels - 1));
+                                        intensityBin[currentIntensity] += 1;
+                                        blueBin[currentIntensity] += sourceBlue;
+                                        greenBin[currentIntensity] += sourceGreen;
+                                        redBin[currentIntensity] += sourceRed;
 
-                                            intensityBin[currentIntensity] += 1;
-                                            blueBin[currentIntensity] += sourceBlue;
-                                            greenBin[currentIntensity] += sourceGreen;
-                                            redBin[currentIntensity] += sourceRed;
-
-                                            if (intensityBin[currentIntensity] > maxIntensity)
-                                            {
-                                                maxIntensity = intensityBin[currentIntensity];
-                                                maxIndex = currentIntensity;
-                                            }
+                                        if (intensityBin[currentIntensity] > maxIntensity)
+                                        {
+                                            maxIntensity = intensityBin[currentIntensity];
+                                            maxIndex = currentIntensity;
                                         }
                                     }
+                                }
 
-                                    float red = MathF.Abs(redBin[maxIndex] / maxIntensity);
-                                    float green = MathF.Abs(greenBin[maxIndex] / maxIntensity);
-                                    float blue = MathF.Abs(blueBin[maxIndex] / maxIntensity);
+                                float red = MathF.Abs(redBin[maxIndex] / maxIntensity);
+                                float green = MathF.Abs(greenBin[maxIndex] / maxIntensity);
+                                float blue = MathF.Abs(blueBin[maxIndex] / maxIntensity);
 
-                                    TPixel packed = default(TPixel);
-                                    packed.PackFromVector4(new Vector4(red, green, blue, sourcePixels[x, y].ToVector4().W));
-                                    targetPixels[x, y] = packed;
-                                }
+                                TPixel packed = default(TPixel);
+                                packed.PackFromVector4(new Vector4(red, green, blue, sourcePixels[x, y].ToVector4().W));
+                                targetPixels[x, y] = packed;
                             }
-                        });
-                }
+                        }
+                    });
 
                 source.SwapPixelsBuffers(targetPixels);
             }

From 0e229e2bc80c9db20a39ec0c21584d01ce3f6753 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 28 Apr 2017 11:13:51 +1000
Subject: [PATCH 21/24] Fix ConvolutionProcessor

---
 .../Convolution/ConvolutionProcessor.cs       | 88 +++++++++----------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs
index a0c1400286..475f14ccf1 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor.cs
@@ -46,51 +46,51 @@ namespace ImageSharp.Processing.Processors
             int maxX = endX - 1;
 
             using (PixelAccessor<TPixel> targetPixels = new PixelAccessor<TPixel>(source.Width, source.Height))
+            using (PixelAccessor<TPixel> sourcePixels = source.Lock())
             {
-                using (PixelAccessor<TPixel> sourcePixels = source.Lock())
-                {
-                    Parallel.For(
-                    startY,
-                    endY,
-                    this.ParallelOptions,
-                    y =>
-                    {
-                        for (int x = startX; x < endX; x++)
-                        {
-                            float red = 0;
-                            float green = 0;
-                            float blue = 0;
-
-                            // Apply each matrix multiplier to the color components for each pixel.
-                            for (int fy = 0; fy < kernelLength; fy++)
-                            {
-                                int fyr = fy - radius;
-                                int offsetY = y + fyr;
-
-                                offsetY = offsetY.Clamp(0, maxY);
-
-                                for (int fx = 0; fx < kernelLength; fx++)
-                                {
-                                    int fxr = fx - radius;
-                                    int offsetX = x + fxr;
-
-                                    offsetX = offsetX.Clamp(0, maxX);
-
-                                    Vector4 currentColor = sourcePixels[offsetX, offsetY].ToVector4();
-                                    currentColor *= this.KernelXY[fy, fx];
-
-                                    red += currentColor.X;
-                                    green += currentColor.Y;
-                                    blue += currentColor.Z;
-                                }
-                            }
-
-                            TPixel packed = default(TPixel);
-                            packed.PackFromVector4(new Vector4(red, green, blue, sourcePixels[x, y].ToVector4().W));
-                            targetPixels[x, y] = packed;
-                        }
-                    });
-                }
+                sourcePixels.CopyTo(targetPixels);
+
+                Parallel.For(
+                 startY,
+                 endY,
+                 this.ParallelOptions,
+                 y =>
+                 {
+                     for (int x = startX; x < endX; x++)
+                     {
+                         float red = 0;
+                         float green = 0;
+                         float blue = 0;
+
+                         // Apply each matrix multiplier to the color components for each pixel.
+                         for (int fy = 0; fy < kernelLength; fy++)
+                         {
+                             int fyr = fy - radius;
+                             int offsetY = y + fyr;
+
+                             offsetY = offsetY.Clamp(0, maxY);
+
+                             for (int fx = 0; fx < kernelLength; fx++)
+                             {
+                                 int fxr = fx - radius;
+                                 int offsetX = x + fxr;
+
+                                 offsetX = offsetX.Clamp(0, maxX);
+
+                                 Vector4 currentColor = sourcePixels[offsetX, offsetY].ToVector4();
+                                 currentColor *= this.KernelXY[fy, fx];
+
+                                 red += currentColor.X;
+                                 green += currentColor.Y;
+                                 blue += currentColor.Z;
+                             }
+                         }
+
+                         TPixel packed = default(TPixel);
+                         packed.PackFromVector4(new Vector4(red, green, blue, sourcePixels[x, y].ToVector4().W));
+                         targetPixels[x, y] = packed;
+                     }
+                 });
 
                 source.SwapPixelsBuffers(targetPixels);
             }

From 1492da85d93e8db6a593eb1957af4e6f4247ded4 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 28 Apr 2017 11:23:32 +1000
Subject: [PATCH 22/24] Fix Convolution2DProcessor

Also inlined ColorMatrix cos I spotted it and couldn't ignore.
---
 .../Processors/ColorMatrix/ColorMatrixProcessor.cs       | 2 ++
 .../Processors/Convolution/Convolution2DProcessor.cs     | 9 ++++-----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/ColorMatrix/ColorMatrixProcessor.cs b/src/ImageSharp/Processing/Processors/ColorMatrix/ColorMatrixProcessor.cs
index b38093d634..cfe50150fd 100644
--- a/src/ImageSharp/Processing/Processors/ColorMatrix/ColorMatrixProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/ColorMatrix/ColorMatrixProcessor.cs
@@ -7,6 +7,7 @@ namespace ImageSharp.Processing.Processors
 {
     using System;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
     using System.Threading.Tasks;
 
     using ImageSharp.PixelFormats;
@@ -79,6 +80,7 @@ namespace ImageSharp.Processing.Processors
         /// <returns>
         /// The <see cref="Rgba32"/>.
         /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private TPixel ApplyMatrix(TPixel color, Matrix4x4 matrix, bool compand)
         {
             Vector4 vector = color.ToVector4();
diff --git a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs
index ac96c40ae6..e6a42cc0c2 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2DProcessor.cs
@@ -5,7 +5,6 @@
 
 namespace ImageSharp.Processing.Processors
 {
-    using System;
     using System.Numerics;
     using System.Threading.Tasks;
 
@@ -57,10 +56,11 @@ namespace ImageSharp.Processing.Processors
             int maxX = endX - 1;
 
             using (PixelAccessor<TPixel> targetPixels = new PixelAccessor<TPixel>(source.Width, source.Height))
+            using (PixelAccessor<TPixel> sourcePixels = source.Lock())
             {
-                using (PixelAccessor<TPixel> sourcePixels = source.Lock())
-                {
-                    Parallel.For(
+                sourcePixels.CopyTo(targetPixels);
+
+                Parallel.For(
                     startY,
                     endY,
                     this.ParallelOptions,
@@ -119,7 +119,6 @@ namespace ImageSharp.Processing.Processors
                             targetPixels[x, y] = packed;
                         }
                     });
-                }
 
                 source.SwapPixelsBuffers(targetPixels);
             }

From c3216d05fab46c1bb0509e2e77e3347cae001ca2 Mon Sep 17 00:00:00 2001
From: Drawaes <seawardtim@gmail.com>
Date: Fri, 28 Apr 2017 03:33:20 +0100
Subject: [PATCH 23/24] Fixed interlaced PNG

---
 src/ImageSharp/Formats/Png/PngDecoderCore.cs       | 14 ++++++++++++--
 src/ImageSharp/Formats/Png/Zlib/Adler32.cs         |  2 +-
 .../{DeframeStream.cs => ZlibInflateStream.cs}     |  6 +++---
 3 files changed, 16 insertions(+), 6 deletions(-)
 rename src/ImageSharp/Formats/Png/Zlib/{DeframeStream.cs => ZlibInflateStream.cs} (97%)

diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index aece86700d..05ba5ee60c 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -191,7 +191,7 @@ namespace ImageSharp.Formats
             PixelAccessor<TPixel> pixels = null;
             try
             {
-                using (DeframeStream deframeStream = new DeframeStream(this.currentStream))
+                using (ZlibInflateStream deframeStream = new ZlibInflateStream(this.currentStream))
                 {
                     PngChunk currentChunk;
                     while (!this.isEndChunkReached && (currentChunk = this.ReadChunk()) != null)
@@ -492,12 +492,14 @@ namespace ImageSharp.Formats
         private void DecodeInterlacedPixelData<TPixel>(Stream compressedStream, PixelAccessor<TPixel> pixels)
             where TPixel : struct, IPixel<TPixel>
         {
-            while (this.pass < 7)
+            while (true)
             {
                 int numColumns = this.ComputeColumnsAdam7(this.pass);
 
                 if (numColumns == 0)
                 {
+                    this.pass++;
+
                     // This pass contains no data; skip to next pass
                     continue;
                 }
@@ -561,6 +563,14 @@ namespace ImageSharp.Formats
                 }
 
                 this.pass++;
+                if (this.pass < 7)
+                {
+                    this.currentRow = Adam7FirstRow[this.pass];
+                }
+                else
+                {
+                    break;
+                }
             }
         }
 
diff --git a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
index 56b116cd31..5f92cc9e09 100644
--- a/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/Adler32.cs
@@ -52,7 +52,7 @@ namespace ImageSharp.Formats
     ///    checked separately. (Any sequence of zeroes has a Fletcher
     ///    checksum of zero.)"
     /// </remarks>
-    /// <see cref="DeframeStream"/>
+    /// <see cref="ZlibInflateStream"/>
     /// <see cref="ZlibDeflateStream"/>
     internal sealed class Adler32 : IChecksum
     {
diff --git a/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs b/src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs
similarity index 97%
rename from src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
rename to src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs
index 2e92fd52d3..0743d8ded3 100644
--- a/src/ImageSharp/Formats/Png/Zlib/DeframeStream.cs
+++ b/src/ImageSharp/Formats/Png/Zlib/ZlibInflateStream.cs
@@ -9,7 +9,7 @@
     /// <summary>
     /// Provides methods and properties for deframing streams from PNGs.
     /// </summary>
-    internal class DeframeStream : Stream
+    internal class ZlibInflateStream : Stream
     {
         /// <summary>
         /// The inner raw memory stream
@@ -45,10 +45,10 @@
         private int currentDataRemaining;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="DeframeStream"/> class.
+        /// Initializes a new instance of the <see cref="ZlibInflateStream"/> class.
         /// </summary>
         /// <param name="innerStream">The inner raw stream</param>
-        public DeframeStream(Stream innerStream)
+        public ZlibInflateStream(Stream innerStream)
         {
             this.innerStream = innerStream;
         }

From a86c82e9716a18de06457c2d069f7534c79e23f7 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 28 Apr 2017 13:33:32 +1000
Subject: [PATCH 24/24] Add missing tests

We need to refactor our tests to mostly use the generated patterns.
---
 .../Processing/Effects/BackgroundColor.cs     | 18 +++++++++-
 .../Processing/Effects/Brightness.cs          |  6 ++--
 .../Processors/Filters/AlphaTest.cs           |  2 +-
 .../Processors/Filters/BackgroundColorTest.cs | 16 +++++++++
 ...aryThreshold.cs => BinaryThresholdTest.cs} | 17 +++++++++
 .../Processors/Filters/BlackWhiteTest.cs      | 16 +++++++++
 .../Processors/Filters/BoxBlurTest.cs         | 17 +++++++++
 .../Processors/Filters/BrightnessTest.cs      | 17 +++++++++
 .../Processors/Filters/ColorBlindnessTest.cs  | 17 +++++++++
 .../Processors/Filters/ContrastTest.cs        | 17 +++++++++
 .../Processors/Filters/GaussianBlurTest.cs    |  4 +--
 .../Processors/Filters/GaussianSharpenTest.cs | 36 +++++++++++++------
 .../Processors/Filters/GrayscaleTest.cs       | 28 +++++++++++----
 .../Processors/Filters/HueTest.cs             | 17 +++++++++
 .../Processors/Filters/KodachromeTest.cs      | 16 +++++++++
 .../Processors/Filters/PolaroidTest.cs        | 16 +++++++++
 .../Processors/Filters/SaturationTest.cs      | 17 +++++++++
 .../Processors/Filters/SepiaTest.cs           | 16 +++++++++
 18 files changed, 269 insertions(+), 24 deletions(-)
 rename tests/ImageSharp.Tests/Processors/Filters/{BinaryThreshold.cs => BinaryThresholdTest.cs} (62%)

diff --git a/src/ImageSharp/Processing/Effects/BackgroundColor.cs b/src/ImageSharp/Processing/Effects/BackgroundColor.cs
index cb189338e7..a1914fee32 100644
--- a/src/ImageSharp/Processing/Effects/BackgroundColor.cs
+++ b/src/ImageSharp/Processing/Effects/BackgroundColor.cs
@@ -26,7 +26,23 @@ namespace ImageSharp
         public static Image<TPixel> BackgroundColor<TPixel>(this Image<TPixel> source, TPixel color)
             where TPixel : struct, IPixel<TPixel>
         {
-            source.ApplyProcessor(new BackgroundColorProcessor<TPixel>(color), source.Bounds);
+            return BackgroundColor(source, color, source.Bounds);
+        }
+
+        /// <summary>
+        /// Replaces the background color of image with the given one.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="color">The color to set as the background.</param>
+        /// <param name="rectangle">
+        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
+        /// </param>
+        /// <returns>The <see cref="Image"/>.</returns>
+        public static Image<TPixel> BackgroundColor<TPixel>(this Image<TPixel> source, TPixel color, Rectangle rectangle)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            source.ApplyProcessor(new BackgroundColorProcessor<TPixel>(color), rectangle);
             return source;
         }
     }
diff --git a/src/ImageSharp/Processing/Effects/Brightness.cs b/src/ImageSharp/Processing/Effects/Brightness.cs
index 6b7477488a..a28df82c09 100644
--- a/src/ImageSharp/Processing/Effects/Brightness.cs
+++ b/src/ImageSharp/Processing/Effects/Brightness.cs
@@ -20,12 +20,12 @@ namespace ImageSharp
         /// Alters the brightness component of the image.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-                /// <param name="source">The image this method extends.</param>
+        /// <param name="source">The image this method extends.</param>
         /// <param name="amount">The new brightness of the image. Must be between -100 and 100.</param>
         /// <returns>The <see cref="Image{TPixel}"/>.</returns>
         public static Image<TPixel> Brightness<TPixel>(this Image<TPixel> source, int amount)
             where TPixel : struct, IPixel<TPixel>
-                    {
+        {
             return Brightness(source, amount, source.Bounds);
         }
 
@@ -33,7 +33,7 @@ namespace ImageSharp
         /// Alters the brightness component of the image.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-                /// <param name="source">The image this method extends.</param>
+        /// <param name="source">The image this method extends.</param>
         /// <param name="amount">The new brightness of the image. Must be between -100 and 100.</param>
         /// <param name="rectangle">
         /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
diff --git a/tests/ImageSharp.Tests/Processors/Filters/AlphaTest.cs b/tests/ImageSharp.Tests/Processors/Filters/AlphaTest.cs
index a8aeb33418..2b39086e34 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/AlphaTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/AlphaTest.cs
@@ -43,7 +43,7 @@ namespace ImageSharp.Tests
 
             foreach (TestFile file in Files)
             {
-                string filename = file.GetFileName(value);
+                string filename = file.GetFileName(value + "-InBox");
                 using (Image image = file.CreateImage())
                 using (FileStream output = File.OpenWrite($"{path}/{filename}"))
                 {
diff --git a/tests/ImageSharp.Tests/Processors/Filters/BackgroundColorTest.cs b/tests/ImageSharp.Tests/Processors/Filters/BackgroundColorTest.cs
index eccfc13af3..4bc39f8ab6 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/BackgroundColorTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/BackgroundColorTest.cs
@@ -27,5 +27,21 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Fact]
+        public void ImageShouldApplyBackgroundColorFilterInBox()
+        {
+            string path = this.CreateOutputDirectory("BackgroundColor");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName("-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.BackgroundColor(Rgba32.HotPink, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/BinaryThreshold.cs b/tests/ImageSharp.Tests/Processors/Filters/BinaryThresholdTest.cs
similarity index 62%
rename from tests/ImageSharp.Tests/Processors/Filters/BinaryThreshold.cs
rename to tests/ImageSharp.Tests/Processors/Filters/BinaryThresholdTest.cs
index d7d4eac058..f36014542a 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/BinaryThreshold.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/BinaryThresholdTest.cs
@@ -34,5 +34,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(BinaryThresholdValues))]
+        public void ImageShouldApplyBinaryThresholdInBox(float value)
+        {
+            string path = this.CreateOutputDirectory("BinaryThreshold");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(value + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.BinaryThreshold(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/BlackWhiteTest.cs b/tests/ImageSharp.Tests/Processors/Filters/BlackWhiteTest.cs
index 6b9a48f72d..377ae4719c 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/BlackWhiteTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/BlackWhiteTest.cs
@@ -25,5 +25,21 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Fact]
+        public void ImageShouldApplyBlackWhiteFilterInBox()
+        {
+            string path = this.CreateOutputDirectory("BlackWhite");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName("-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.BlackWhite(new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/BoxBlurTest.cs b/tests/ImageSharp.Tests/Processors/Filters/BoxBlurTest.cs
index 5d4f628eea..f4f5fb4bbe 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/BoxBlurTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/BoxBlurTest.cs
@@ -34,5 +34,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(BoxBlurValues))]
+        public void ImageShouldApplyBoxBlurFilterInBox(int value)
+        {
+            string path = this.CreateOutputDirectory("BoxBlur");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(value + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.BoxBlur(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/BrightnessTest.cs b/tests/ImageSharp.Tests/Processors/Filters/BrightnessTest.cs
index e274ef0417..f59d5be4cd 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/BrightnessTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/BrightnessTest.cs
@@ -34,5 +34,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(BrightnessValues))]
+        public void ImageShouldApplyBrightnessFilterInBox(int value)
+        {
+            string path = this.CreateOutputDirectory("Brightness");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(value + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Brightness(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/ColorBlindnessTest.cs b/tests/ImageSharp.Tests/Processors/Filters/ColorBlindnessTest.cs
index d18f32caf2..5564a77efd 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/ColorBlindnessTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/ColorBlindnessTest.cs
@@ -41,5 +41,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(ColorBlindnessFilters))]
+        public void ImageShouldApplyBrightnessFilterInBox(ColorBlindness colorBlindness)
+        {
+            string path = this.CreateOutputDirectory("ColorBlindness");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(colorBlindness + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.ColorBlindness(colorBlindness, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/ContrastTest.cs b/tests/ImageSharp.Tests/Processors/Filters/ContrastTest.cs
index 09376f2c05..5bbe2338cb 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/ContrastTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/ContrastTest.cs
@@ -33,5 +33,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(ContrastValues))]
+        public void ImageShouldApplyContrastFilterInBox(int value)
+        {
+            string path = this.CreateOutputDirectory("Contrast");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(value + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Contrast(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs b/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs
index dd17aaeb06..4b2ac8b7cf 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/GaussianBlurTest.cs
@@ -26,7 +26,7 @@ namespace ImageSharp.Tests
             using (Image<TPixel> image = provider.GetImage())
             {
                 image.GaussianBlur(value)
-                    .DebugSave(provider);
+                    .DebugSave(provider, value.ToString());
             }
         }
 
@@ -40,7 +40,7 @@ namespace ImageSharp.Tests
             {
                 Rectangle rect = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
                 image.GaussianBlur(value, rect)
-                    .DebugSave(provider);
+                    .DebugSave(provider, value.ToString());
 
                 // lets draw identical shapes over the blured areas and ensure that it didn't change the outer area
                 image.Fill(NamedColors<TPixel>.HotPink, rect);
diff --git a/tests/ImageSharp.Tests/Processors/Filters/GaussianSharpenTest.cs b/tests/ImageSharp.Tests/Processors/Filters/GaussianSharpenTest.cs
index c1aa069414..1fa1ae15c1 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/GaussianSharpenTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/GaussianSharpenTest.cs
@@ -6,7 +6,7 @@
 namespace ImageSharp.Tests
 {
     using System.IO;
-
+    using ImageSharp.PixelFormats;
     using Xunit;
 
     public class GaussianSharpenTest : FileTestBase
@@ -19,19 +19,33 @@ namespace ImageSharp.Tests
         };
 
         [Theory]
-        [MemberData(nameof(GaussianSharpenValues))]
-        public void ImageShouldApplyGaussianSharpenFilter(int value)
+        [WithTestPatternImages(nameof(GaussianSharpenValues), 320, 240, PixelTypes.StandardImageClass)]
+        public void ImageShouldApplyGaussianSharpenFilter<TPixel>(TestImageProvider<TPixel> provider, int value)
+            where TPixel : struct, IPixel<TPixel>
         {
-            string path = this.CreateOutputDirectory("GaussianSharpen");
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.GaussianSharpen(value)
+                     .DebugSave(provider, value.ToString());
+            }
+        }
 
-            foreach (TestFile file in Files)
+        [Theory]
+        [WithTestPatternImages(nameof(GaussianSharpenValues), 320, 240, PixelTypes.StandardImageClass)]
+        public void ImageShouldApplyGaussianSharpenFilterInBox<TPixel>(TestImageProvider<TPixel> provider, int value)
+        where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = new Image<TPixel>(source))
             {
-                string filename = file.GetFileName(value);
-                using (Image image = file.CreateImage())
-                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
-                {
-                    image.GaussianSharpen(value).Save(output);
-                }
+                Rectangle rect = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
+                image.GaussianSharpen(value, rect)
+                     .DebugSave(provider, value.ToString());
+
+                // lets draw identical shapes over the Sharpened areas and ensure that it didn't change the outer area
+                image.Fill(NamedColors<TPixel>.HotPink, rect);
+                source.Fill(NamedColors<TPixel>.HotPink, rect);
+                ImageComparer.CheckSimilarity(image, source);
             }
         }
     }
diff --git a/tests/ImageSharp.Tests/Processors/Filters/GrayscaleTest.cs b/tests/ImageSharp.Tests/Processors/Filters/GrayscaleTest.cs
index 2b717a0b79..9a7d878546 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/GrayscaleTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/GrayscaleTest.cs
@@ -5,12 +5,8 @@
 
 namespace ImageSharp.Tests
 {
-    using System.IO;
-
     using Xunit;
     using ImageSharp.Processing;
-    using ImageSharp.Tests;
-    using System.Numerics;
 
     using ImageSharp.PixelFormats;
 
@@ -20,7 +16,7 @@ namespace ImageSharp.Tests
         /// Use test patterns over loaded images to save decode time.
         /// </summary>
         [Theory]
-        [WithTestPatternImages(50, 50, PixelTypes.StandardImageClass, GrayscaleMode.Bt709)] 
+        [WithTestPatternImages(50, 50, PixelTypes.StandardImageClass, GrayscaleMode.Bt709)]
         [WithTestPatternImages(50, 50, PixelTypes.StandardImageClass, GrayscaleMode.Bt601)]
         public void ImageShouldApplyGrayscaleFilterAll<TPixel>(TestImageProvider<TPixel> provider, GrayscaleMode value)
             where TPixel : struct, IPixel<TPixel>
@@ -36,7 +32,27 @@ namespace ImageSharp.Tests
                     Assert.Equal(data[1], data[2]);
                 }
 
-                image.DebugSave(provider);
+                image.DebugSave(provider, value.ToString());
+            }
+        }
+
+        [Theory]
+        [WithTestPatternImages(50, 50, PixelTypes.StandardImageClass, GrayscaleMode.Bt709)]
+        [WithTestPatternImages(50, 50, PixelTypes.StandardImageClass, GrayscaleMode.Bt601)]
+        public void ImageShouldApplyGrayscaleFilterInBox<TPixel>(TestImageProvider<TPixel> provider, GrayscaleMode value)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = new Image<TPixel>(source))
+            {
+                Rectangle rect = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
+                image.Grayscale(rect, value)
+                     .DebugSave(provider, value.ToString());
+
+                // Let's draw identical shapes over the greyed areas and ensure that it didn't change the outer area
+                image.Fill(NamedColors<TPixel>.HotPink, rect);
+                source.Fill(NamedColors<TPixel>.HotPink, rect);
+                ImageComparer.CheckSimilarity(image, source);
             }
         }
     }
diff --git a/tests/ImageSharp.Tests/Processors/Filters/HueTest.cs b/tests/ImageSharp.Tests/Processors/Filters/HueTest.cs
index 4241dc8333..3081c638cf 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/HueTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/HueTest.cs
@@ -34,5 +34,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(HueValues))]
+        public void ImageShouldApplyHueFilterInBox(int value)
+        {
+            string path = this.CreateOutputDirectory("Hue");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(value + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Hue(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/KodachromeTest.cs b/tests/ImageSharp.Tests/Processors/Filters/KodachromeTest.cs
index 40734e02a0..870f813a1a 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/KodachromeTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/KodachromeTest.cs
@@ -25,5 +25,21 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Fact]
+        public void ImageShouldApplyKodachromeFilterInBox()
+        {
+            string path = this.CreateOutputDirectory("Kodachrome");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName("InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Kodachrome(new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/PolaroidTest.cs b/tests/ImageSharp.Tests/Processors/Filters/PolaroidTest.cs
index 040f8b4a24..e9938fb833 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/PolaroidTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/PolaroidTest.cs
@@ -25,5 +25,21 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Fact]
+        public void ImageShouldApplyPolaroidFilterInBox()
+        {
+            string path = this.CreateOutputDirectory("Polaroid");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName("InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Polaroid(new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/SaturationTest.cs b/tests/ImageSharp.Tests/Processors/Filters/SaturationTest.cs
index abd596d708..ee24f120c3 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/SaturationTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/SaturationTest.cs
@@ -34,5 +34,22 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(SaturationValues))]
+        public void ImageShouldApplySaturationFilterInBox(int value)
+        {
+            string path = this.CreateOutputDirectory("Saturation");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName(value + "-InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Saturation(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Processors/Filters/SepiaTest.cs b/tests/ImageSharp.Tests/Processors/Filters/SepiaTest.cs
index fbae10fa55..0e1583cc63 100644
--- a/tests/ImageSharp.Tests/Processors/Filters/SepiaTest.cs
+++ b/tests/ImageSharp.Tests/Processors/Filters/SepiaTest.cs
@@ -25,5 +25,21 @@ namespace ImageSharp.Tests
                 }
             }
         }
+
+        [Fact]
+        public void ImageShouldApplySepiaFilterInBox()
+        {
+            string path = this.CreateOutputDirectory("Sepia");
+
+            foreach (TestFile file in Files)
+            {
+                string filename = file.GetFileName("InBox");
+                using (Image image = file.CreateImage())
+                using (FileStream output = File.OpenWrite($"{path}/{filename}"))
+                {
+                    image.Sepia(new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output);
+                }
+            }
+        }
     }
 }
\ No newline at end of file