diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8.Intrinsic.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8.Intrinsic.cs
new file mode 100644
index 000000000..002d382dc
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8.Intrinsic.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components
+{
+    internal unsafe partial struct Block8x8
+    {
+        [FieldOffset(0)]
+        public Vector128<short> V0;
+        [FieldOffset(16)]
+        public Vector128<short> V1;
+        [FieldOffset(32)]
+        public Vector128<short> V2;
+        [FieldOffset(48)]
+        public Vector128<short> V3;
+        [FieldOffset(64)]
+        public Vector128<short> V4;
+        [FieldOffset(80)]
+        public Vector128<short> V5;
+        [FieldOffset(96)]
+        public Vector128<short> V6;
+        [FieldOffset(112)]
+        public Vector128<short> V7;
+
+        [FieldOffset(0)]
+        public Vector256<short> V01;
+        [FieldOffset(32)]
+        public Vector256<short> V23;
+        [FieldOffset(64)]
+        public Vector256<short> V45;
+        [FieldOffset(96)]
+        public Vector256<short> V67;
+    }
+}
+#endif
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs
index 27bb2fc3c..4b03f9f7b 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8.cs
@@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
     /// </summary>
     // ReSharper disable once InconsistentNaming
     [StructLayout(LayoutKind.Explicit)]
-    internal unsafe struct Block8x8 : IEquatable<Block8x8>
+    internal unsafe partial struct Block8x8
     {
         /// <summary>
         /// A number of scalar coefficients in a <see cref="Block8x8F"/>
@@ -36,34 +36,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         private fixed short data[Size];
 #pragma warning restore IDE0051
 
-#if SUPPORTS_RUNTIME_INTRINSICS
-        [FieldOffset(0)]
-        public Vector128<short> V0;
-        [FieldOffset(16)]
-        public Vector128<short> V1;
-        [FieldOffset(32)]
-        public Vector128<short> V2;
-        [FieldOffset(48)]
-        public Vector128<short> V3;
-        [FieldOffset(64)]
-        public Vector128<short> V4;
-        [FieldOffset(80)]
-        public Vector128<short> V5;
-        [FieldOffset(96)]
-        public Vector128<short> V6;
-        [FieldOffset(112)]
-        public Vector128<short> V7;
-
-        [FieldOffset(0)]
-        public Vector256<short> V01;
-        [FieldOffset(32)]
-        public Vector256<short> V23;
-        [FieldOffset(64)]
-        public Vector256<short> V45;
-        [FieldOffset(96)]
-        public Vector256<short> V67;
-#endif
-
         /// <summary>
         /// Gets or sets a <see cref="short"/> value at the given index
         /// </summary>
@@ -102,74 +74,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             set => this[(y * 8) + x] = value;
         }
 
-        public static bool operator ==(Block8x8 left, Block8x8 right) => left.Equals(right);
-
-        public static bool operator !=(Block8x8 left, Block8x8 right) => !left.Equals(right);
-
-        /// <summary>
-        /// Multiply all elements by a given <see cref="int"/>
-        /// </summary>
-        public static Block8x8 operator *(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val *= value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Divide all elements by a given <see cref="int"/>
-        /// </summary>
-        public static Block8x8 operator /(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val /= value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Add an <see cref="int"/> to all elements
-        /// </summary>
-        public static Block8x8 operator +(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val += value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Subtract an <see cref="int"/> from all elements
-        /// </summary>
-        public static Block8x8 operator -(Block8x8 block, int value)
-        {
-            Block8x8 result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                int val = result[i];
-                val -= value;
-                result[i] = (short)val;
-            }
-
-            return result;
-        }
-
         public static Block8x8 Load(Span<short> data)
         {
             Unsafe.SkipInit(out Block8x8 result);
@@ -260,26 +164,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             return sb.ToString();
         }
 
-        /// <inheritdoc />
-        public bool Equals(Block8x8 other)
-        {
-            for (int i = 0; i < Size; i++)
-            {
-                if (this[i] != other[i])
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /// <inheritdoc />
-        public override bool Equals(object obj) => obj is Block8x8 other && this.Equals(other);
-
-        /// <inheritdoc />
-        public override int GetHashCode() => (this[0] * 31) + this[1];
-
         /// <summary>
         /// Returns index of the last non-zero element in given matrix.
         /// </summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
index 02f5a1324..f25286447 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs
@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -98,58 +97,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             set => this[(y * 8) + x] = value;
         }
 
-        public static Block8x8F operator *(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val *= value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
-        public static Block8x8F operator /(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val /= value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
-        public static Block8x8F operator +(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val += value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
-        public static Block8x8F operator -(Block8x8F block, float value)
-        {
-            Block8x8F result = block;
-            for (int i = 0; i < Size; i++)
-            {
-                float val = result[i];
-                val -= value;
-                result[i] = val;
-            }
-
-            return result;
-        }
-
         public static Block8x8F Load(Span<float> data)
         {
             Block8x8F result = default;
@@ -157,13 +104,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             return result;
         }
 
-        public static Block8x8F Load(Span<int> data)
-        {
-            Block8x8F result = default;
-            result.LoadFrom(data);
-            return result;
-        }
-
         /// <summary>
         /// Load raw 32bit floating point data from source.
         /// </summary>
@@ -177,15 +117,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             Unsafe.CopyBlock(ref d, ref s, Size * sizeof(float));
         }
 
-        /// <summary>
-        /// Load raw 32bit floating point data from source.
-        /// </summary>
-        /// <param name="blockPtr">Block pointer</param>
-        /// <param name="source">Source</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static unsafe void LoadFrom(Block8x8F* blockPtr, Span<float> source)
-            => blockPtr->LoadFrom(source);
-
         /// <summary>
         /// Load raw 32bit floating point data from source
         /// </summary>
@@ -202,44 +133,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
-        /// <summary>
-        /// Copy raw 32bit floating point data to dest,
-        /// </summary>
-        /// <param name="dest">Destination</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public void ScaledCopyTo(Span<float> dest)
-        {
-            ref byte d = ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(dest));
-            ref byte s = ref Unsafe.As<Block8x8F, byte>(ref this);
-
-            Unsafe.CopyBlock(ref d, ref s, Size * sizeof(float));
-        }
-
-        /// <summary>
-        /// Convert scalars to byte-s and copy to dest,
-        /// </summary>
-        /// <param name="blockPtr">Pointer to block</param>
-        /// <param name="dest">Destination</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static unsafe void ScaledCopyTo(Block8x8F* blockPtr, Span<byte> dest)
-        {
-            float* fPtr = (float*)blockPtr;
-            for (int i = 0; i < Size; i++)
-            {
-                dest[i] = (byte)*fPtr;
-                fPtr++;
-            }
-        }
-
-        /// <summary>
-        /// Copy raw 32bit floating point data to dest.
-        /// </summary>
-        /// <param name="blockPtr">The block pointer.</param>
-        /// <param name="dest">The destination.</param>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static unsafe void ScaledCopyTo(Block8x8F* blockPtr, Span<float> dest)
-            => blockPtr->ScaledCopyTo(dest);
-
         /// <summary>
         /// Copy raw 32bit floating point data to dest
         /// </summary>
@@ -253,22 +146,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             }
         }
 
-        /// <summary>
-        /// Copy raw 32bit floating point data to dest
-        /// </summary>
-        /// <param name="dest">Destination</param>
-        public unsafe void ScaledCopyTo(Span<int> dest)
-        {
-            fixed (Vector4* ptr = &this.V0L)
-            {
-                var fp = (float*)ptr;
-                for (int i = 0; i < Size; i++)
-                {
-                    dest[i] = (int)fp[i];
-                }
-            }
-        }
-
         public float[] ToArray()
         {
             float[] result = new float[Size];
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
index 11ea4cda8..dad46861e 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
@@ -197,6 +197,23 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// </summary>
             public readonly Span<float> Component3;
 
+            /// <summary>
+            /// Initializes a new instance of the <see cref="ComponentValues"/> struct.
+            /// </summary>
+            /// <param name="componentProcessors">The 1-4 sized list of component post processors.</param>
+            /// <param name="row">The row to convert</param>
+            public ComponentValues(IReadOnlyList<JpegComponentPostProcessor> componentProcessors, int row)
+            {
+                this.ComponentCount = componentProcessors.Count;
+
+                this.Component0 = componentProcessors[0].GetColorBufferRowSpan(row);
+
+                // In case of grayscale, Component1 and Component2 point to Component0 memory area
+                this.Component1 = this.ComponentCount > 1 ? componentProcessors[1].GetColorBufferRowSpan(row) : this.Component0;
+                this.Component2 = this.ComponentCount > 2 ? componentProcessors[2].GetColorBufferRowSpan(row) : this.Component0;
+                this.Component3 = this.ComponentCount > 3 ? componentProcessors[3].GetColorBufferRowSpan(row) : Span<float>.Empty;
+            }
+
             /// <summary>
             /// Initializes a new instance of the <see cref="ComponentValues"/> struct.
             /// </summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/IRawJpegData.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/IRawJpegData.cs
index 0b80acc5d..33815e539 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/IRawJpegData.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/IRawJpegData.cs
@@ -5,7 +5,6 @@ using System;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
-    /// <inheritdoc />
     /// <summary>
     /// Represents decompressed, unprocessed jpeg data with spectral space <see cref="IJpegComponent" />-s.
     /// </summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs
deleted file mode 100644
index 15f212b40..000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Memory;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
-{
-    /// <summary>
-    /// Encapsulates the implementation of processing "raw" jpeg buffers into Jpeg image channels.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct JpegBlockPostProcessor
-    {
-        /// <summary>
-        /// Source block
-        /// </summary>
-        public Block8x8F SourceBlock;
-
-        /// <summary>
-        /// The quantization table as <see cref="Block8x8F"/>.
-        /// </summary>
-        public Block8x8F DequantiazationTable;
-
-        /// <summary>
-        /// Defines the horizontal and vertical scale we need to apply to the 8x8 sized block.
-        /// </summary>
-        private Size subSamplingDivisors;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="JpegBlockPostProcessor"/> struct.
-        /// </summary>
-        /// <param name="decoder">The raw jpeg data.</param>
-        /// <param name="component">The raw component.</param>
-        public JpegBlockPostProcessor(IRawJpegData decoder, IJpegComponent component)
-        {
-            int qtIndex = component.QuantizationTableIndex;
-            this.DequantiazationTable = decoder.QuantizationTables[qtIndex];
-            this.subSamplingDivisors = component.SubSamplingDivisors;
-
-            this.SourceBlock = default;
-        }
-
-        /// <summary>
-        /// Processes 'sourceBlock' producing Jpeg color channel values from spectral values:
-        /// - Dequantize
-        /// - Applying IDCT
-        /// - Level shift by +maximumValue/2, clip to [0, maximumValue]
-        /// - Copy the resulting color values into 'destArea' scaling up the block by amount defined in <see cref="subSamplingDivisors"/>.
-        /// </summary>
-        /// <param name="sourceBlock">The source block.</param>
-        /// <param name="destAreaOrigin">Reference to the origin of the destination pixel area.</param>
-        /// <param name="destAreaStride">The width of the destination pixel buffer.</param>
-        /// <param name="maximumValue">The maximum value derived from the bitdepth.</param>
-        public void ProcessBlockColorsInto(
-            ref Block8x8 sourceBlock,
-            ref float destAreaOrigin,
-            int destAreaStride,
-            float maximumValue)
-        {
-            ref Block8x8F block = ref this.SourceBlock;
-            block.LoadFrom(ref sourceBlock);
-
-            // Dequantize:
-            block.MultiplyInPlace(ref this.DequantiazationTable);
-
-            FastFloatingPointDCT.TransformIDCT(ref block);
-
-            // To conform better to libjpeg we actually NEED TO loose precision here.
-            // This is because they store blocks as Int16 between all the operations.
-            // To be "more accurate", we need to emulate this by rounding!
-            block.NormalizeColorsAndRoundInPlace(maximumValue);
-
-            block.ScaledCopyTo(
-                ref destAreaOrigin,
-                destAreaStride,
-                this.subSamplingDivisors.Width,
-                this.subSamplingDivisors.Height);
-        }
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs
index 9a659d621..3e04e80b7 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs
@@ -11,11 +11,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// </summary>
     internal class JpegComponentPostProcessor : IDisposable
     {
-        /// <summary>
-        /// Points to the current row in <see cref="Component"/>.
-        /// </summary>
-        private int currentComponentRowInBlocks;
-
         /// <summary>
         /// The size of the area in <see cref="ColorBuffer"/> corresponding to one 8x8 Jpeg block
         /// </summary>
@@ -26,6 +21,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         private readonly JpegFrame frame;
 
+        /// <summary>
+        /// Gets the maximal number of block rows being processed in one step.
+        /// </summary>
+        private readonly int blockRowsPerStep;
+
+        /// <summary>
+        /// Gets the <see cref="IJpegComponent"/> component containing decoding meta information.
+        /// </summary>
+        private readonly IJpegComponent component;
+
+        /// <summary>
+        /// Gets the <see cref="IRawJpegData"/> instance containing decoding meta information.
+        /// </summary>
+        private readonly IRawJpegData rawJpeg;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegComponentPostProcessor"/> class.
         /// </summary>
@@ -33,98 +43,87 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         {
             this.frame = frame;
 
-            this.Component = component;
-            this.RawJpeg = rawJpeg;
-            this.blockAreaSize = this.Component.SubSamplingDivisors * 8;
+            this.component = component;
+            this.rawJpeg = rawJpeg;
+            this.blockAreaSize = this.component.SubSamplingDivisors * 8;
             this.ColorBuffer = memoryAllocator.Allocate2DOveraligned<float>(
                 postProcessorBufferSize.Width,
                 postProcessorBufferSize.Height,
                 this.blockAreaSize.Height);
 
-            this.BlockRowsPerStep = postProcessorBufferSize.Height / 8 / this.Component.SubSamplingDivisors.Height;
+            this.blockRowsPerStep = postProcessorBufferSize.Height / 8 / this.component.SubSamplingDivisors.Height;
         }
 
-        public IRawJpegData RawJpeg { get; }
-
-        /// <summary>
-        /// Gets the <see cref="Component"/>
-        /// </summary>
-        public IJpegComponent Component { get; }
-
         /// <summary>
         /// Gets the temporary working buffer of color values.
         /// </summary>
         public Buffer2D<float> ColorBuffer { get; }
 
-        /// <summary>
-        /// Gets <see cref="IJpegComponent.SizeInBlocks"/>
-        /// </summary>
-        public Size SizeInBlocks => this.Component.SizeInBlocks;
-
-        /// <summary>
-        /// Gets the maximal number of block rows being processed in one step.
-        /// </summary>
-        public int BlockRowsPerStep { get; }
-
         /// <inheritdoc />
         public void Dispose() => this.ColorBuffer.Dispose();
 
         /// <summary>
-        /// Invoke <see cref="JpegBlockPostProcessor"/> for <see cref="BlockRowsPerStep"/> block rows, copy the result into <see cref="ColorBuffer"/>.
+        /// Convert raw spectral DCT data to color data and copy it to the color buffer <see cref="ColorBuffer"/>.
         /// </summary>
-        public void CopyBlocksToColorBuffer(int step)
+        public void CopyBlocksToColorBuffer(int spectralStep)
         {
-            Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
-
-            var blockPp = new JpegBlockPostProcessor(this.RawJpeg, this.Component);
+            Buffer2D<Block8x8> spectralBuffer = this.component.SpectralBlocks;
 
             float maximumValue = this.frame.MaxColorChannelValue;
 
             int destAreaStride = this.ColorBuffer.Width;
 
-            int yBlockStart = step * this.BlockRowsPerStep;
+            int yBlockStart = spectralStep * this.blockRowsPerStep;
 
-            for (int y = 0; y < this.BlockRowsPerStep; y++)
-            {
-                int yBlock = yBlockStart + y;
+            Size subSamplingDivisors = this.component.SubSamplingDivisors;
 
-                if (yBlock >= spectralBuffer.Height)
-                {
-                    break;
-                }
+            Block8x8F dequantTable = this.rawJpeg.QuantizationTables[this.component.QuantizationTableIndex];
+            Block8x8F workspaceBlock = default;
 
+            for (int y = 0; y < this.blockRowsPerStep; y++)
+            {
                 int yBuffer = y * this.blockAreaSize.Height;
 
                 Span<float> colorBufferRow = this.ColorBuffer.GetRowSpan(yBuffer);
-                Span<Block8x8> blockRow = spectralBuffer.GetRowSpan(yBlock);
+                Span<Block8x8> blockRow = spectralBuffer.GetRowSpan(yBlockStart + y);
 
-                // see: https://github.com/SixLabors/ImageSharp/issues/824
-                int widthInBlocks = Math.Min(spectralBuffer.Width, this.SizeInBlocks.Width);
-
-                for (int xBlock = 0; xBlock < widthInBlocks; xBlock++)
+                for (int xBlock = 0; xBlock < spectralBuffer.Width; xBlock++)
                 {
-                    ref Block8x8 block = ref blockRow[xBlock];
-                    int xBuffer = xBlock * this.blockAreaSize.Width;
-                    ref float destAreaOrigin = ref colorBufferRow[xBuffer];
-
-                    blockPp.ProcessBlockColorsInto(ref block, ref destAreaOrigin, destAreaStride, maximumValue);
+                    // Integer to float
+                    workspaceBlock.LoadFrom(ref blockRow[xBlock]);
+
+                    // Dequantize
+                    workspaceBlock.MultiplyInPlace(ref dequantTable);
+
+                    // Convert from spectral to color
+                    FastFloatingPointDCT.TransformIDCT(ref workspaceBlock);
+
+                    // To conform better to libjpeg we actually NEED TO loose precision here.
+                    // This is because they store blocks as Int16 between all the operations.
+                    // To be "more accurate", we need to emulate this by rounding!
+                    workspaceBlock.NormalizeColorsAndRoundInPlace(maximumValue);
+
+                    // Write to color buffer acording to sampling factors
+                    int xColorBufferStart = xBlock * this.blockAreaSize.Width;
+                    workspaceBlock.ScaledCopyTo(
+                        ref colorBufferRow[xColorBufferStart],
+                        destAreaStride,
+                        subSamplingDivisors.Width,
+                        subSamplingDivisors.Height);
                 }
             }
         }
 
         public void ClearSpectralBuffers()
         {
-            Buffer2D<Block8x8> spectralBlocks = this.Component.SpectralBlocks;
+            Buffer2D<Block8x8> spectralBlocks = this.component.SpectralBlocks;
             for (int i = 0; i < spectralBlocks.Height; i++)
             {
                 spectralBlocks.GetRowSpan(i).Clear();
             }
         }
 
-        public void CopyBlocksToColorBuffer()
-        {
-            this.CopyBlocksToColorBuffer(this.currentComponentRowInBlocks);
-            this.currentComponentRowInBlocks += this.BlockRowsPerStep;
-        }
+        public Span<float> GetColorBufferRowSpan(int row) =>
+            this.ColorBuffer.GetRowSpan(row);
     }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs
index 4e74f6226..1eb74ff80 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs
@@ -6,11 +6,8 @@ using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
     /// <summary>
-    /// Converter used to convert jpeg spectral data.
+    /// Converter used to convert jpeg spectral data to color pixels.
     /// </summary>
-    /// <remarks>
-    /// This is tightly coupled with <see cref="HuffmanScanDecoder"/> and <see cref="JpegDecoderCore"/>.
-    /// </remarks>
     internal abstract class SpectralConverter
     {
         /// <summary>
@@ -30,12 +27,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         public abstract void InjectFrameData(JpegFrame frame, IRawJpegData jpegData);
 
         /// <summary>
-        /// Called once per spectral stride for each component in <see cref="HuffmanScanDecoder"/>.
-        /// This is called only for baseline interleaved jpegs.
+        /// Converts single spectral jpeg stride to color stride in baseline
+        /// decoding mode.
         /// </summary>
         /// <remarks>
+        /// Called once per decoded spectral stride in <see cref="HuffmanScanDecoder"/>
+        /// only for baseline interleaved jpeg images.
         /// Spectral 'stride' doesn't particularly mean 'single stride'.
-        /// Actual stride height depends on the subsampling factor of the given component.
+        /// Actual stride height depends on the subsampling factor of the given image.
         /// </remarks>
         public abstract void ConvertStrideBaseline();
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
index 2e965e0ac..0003437e7 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Buffers;
 using System.Linq;
-using System.Numerics;
 using System.Threading;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
 using SixLabors.ImageSharp.Memory;
@@ -12,35 +11,78 @@ using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
+    /// <inheritdoc/>
+    /// <remarks>
+    /// Color decoding scheme:
+    /// <list type = "bullet|number|table" >
+    /// <listheader>
+    ///     <item>1. Decode spectral data to Jpeg color space</item>
+    ///     <item>2. Convert from Jpeg color space to RGB</item>
+    ///     <item>3. Convert from RGB to target pixel space</item>
+    /// </listheader>
+    /// </list>
+    /// </remarks>
     internal class SpectralConverter<TPixel> : SpectralConverter, IDisposable
         where TPixel : unmanaged, IPixel<TPixel>
     {
+        /// <summary>
+        /// <see cref="Configuration"/> instance associated with current
+        /// decoding routine.
+        /// </summary>
         private readonly Configuration configuration;
 
-        private readonly CancellationToken cancellationToken;
-
+        /// <summary>
+        /// Jpeg component converters from decompressed spectral to color data.
+        /// </summary>
         private JpegComponentPostProcessor[] componentProcessors;
 
+        /// <summary>
+        /// Color converter from jpeg color space to target pixel color space.
+        /// </summary>
         private JpegColorConverter colorConverter;
 
-        // private IMemoryOwner<Vector4> rgbaBuffer;
+        /// <summary>
+        /// Intermediate buffer of RGB components used in color conversion.
+        /// </summary>
         private IMemoryOwner<byte> rgbBuffer;
 
+        /// <summary>
+        /// Proxy buffer used in packing from RGB to target TPixel pixels.
+        /// </summary>
         private IMemoryOwner<TPixel> paddedProxyPixelRow;
 
+        /// <summary>
+        /// Resulting 2D pixel buffer.
+        /// </summary>
         private Buffer2D<TPixel> pixelBuffer;
 
+        /// <summary>
+        /// How many pixel rows are processed in one 'stride'.
+        /// </summary>
         private int pixelRowsPerStep;
 
+        /// <summary>
+        /// How many pixel rows were processed.
+        /// </summary>
         private int pixelRowCounter;
 
-        public SpectralConverter(Configuration configuration, CancellationToken cancellationToken)
-        {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpectralConverter{TPixel}" /> class.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        public SpectralConverter(Configuration configuration) =>
             this.configuration = configuration;
-            this.cancellationToken = cancellationToken;
-        }
 
-        public Buffer2D<TPixel> GetPixelBuffer()
+        /// <summary>
+        /// Gets converted pixel buffer.
+        /// </summary>
+        /// <remarks>
+        /// For non-baseline interleaved jpeg this method does a 'lazy' spectral
+        /// conversion from spectral to color.
+        /// </remarks>
+        /// <param name="cancellationToken">Cancellation token.</param>
+        /// <returns>Pixel buffer.</returns>
+        public Buffer2D<TPixel> GetPixelBuffer(CancellationToken cancellationToken)
         {
             if (!this.Converted)
             {
@@ -48,7 +90,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                 for (int step = 0; step < steps; step++)
                 {
-                    this.cancellationToken.ThrowIfCancellationRequested();
+                    cancellationToken.ThrowIfCancellationRequested();
                     this.ConvertStride(step);
                 }
             }
@@ -102,30 +144,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             }
         }
 
-        /// <inheritdoc/>
-        public void Dispose()
-        {
-            if (this.componentProcessors != null)
-            {
-                foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
-                {
-                    cpp.Dispose();
-                }
-            }
-
-            this.rgbBuffer?.Dispose();
-            this.paddedProxyPixelRow?.Dispose();
-        }
-
+        /// <summary>
+        /// Converts single spectral jpeg stride to color stride.
+        /// </summary>
+        /// <param name="spectralStep">Spectral stride index.</param>
         private void ConvertStride(int spectralStep)
         {
             int maxY = Math.Min(this.pixelBuffer.Height, this.pixelRowCounter + this.pixelRowsPerStep);
 
-            var buffers = new Buffer2D<float>[this.componentProcessors.Length];
             for (int i = 0; i < this.componentProcessors.Length; i++)
             {
                 this.componentProcessors[i].CopyBlocksToColorBuffer(spectralStep);
-                buffers[i] = this.componentProcessors[i].ColorBuffer;
             }
 
             int width = this.pixelBuffer.Width;
@@ -134,7 +163,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             {
                 int y = yy - this.pixelRowCounter;
 
-                var values = new JpegColorConverter.ComponentValues(buffers, y);
+                var values = new JpegColorConverter.ComponentValues(this.componentProcessors, y);
 
                 this.colorConverter.ConvertToRgbInplace(values);
                 values = values.Slice(0, width); // slice away Jpeg padding
@@ -164,5 +193,20 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
             this.pixelRowCounter += this.pixelRowsPerStep;
         }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            if (this.componentProcessors != null)
+            {
+                foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
+                {
+                    cpp.Dispose();
+                }
+            }
+
+            this.rgbBuffer?.Dispose();
+            this.paddedProxyPixelRow?.Dispose();
+        }
     }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs
index b3cdbf0a0..d71a62ec9 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/HuffmanScanEncoder.cs
@@ -278,11 +278,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             // ReSharper disable once InconsistentNaming
             int prevDCY = 0;
 
-            var pixelConverter = LuminanceForwardConverter<TPixel>.Create();
             ImageFrame<TPixel> frame = pixels.Frames.RootFrame;
             Buffer2D<TPixel> pixelBuffer = frame.PixelBuffer;
             RowOctet<TPixel> currentRows = default;
 
+            var pixelConverter = new LuminanceForwardConverter<TPixel>(frame);
+
             for (int y = 0; y < pixels.Height; y += 8)
             {
                 cancellationToken.ThrowIfCancellationRequested();
@@ -290,7 +291,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
 
                 for (int x = 0; x < pixels.Width; x += 8)
                 {
-                    pixelConverter.Convert(frame, x, y, ref currentRows);
+                    pixelConverter.Convert(x, y, ref currentRows);
 
                     prevDCY = this.WriteBlock(
                         QuantIndex.Luminance,
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/LuminanceForwardConverter{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/LuminanceForwardConverter{TPixel}.cs
index fc5b9a868..6c402fcfd 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/LuminanceForwardConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/LuminanceForwardConverter{TPixel}.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
 
@@ -15,39 +16,63 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
     internal ref struct LuminanceForwardConverter<TPixel>
         where TPixel : unmanaged, IPixel<TPixel>
     {
+        /// <summary>
+        /// Number of pixels processed per single <see cref="Convert(int, int, ref RowOctet{TPixel})"/> call
+        /// </summary>
+        private const int PixelsPerSample = 8 * 8;
+
         /// <summary>
         /// The Y component
         /// </summary>
         public Block8x8F Y;
 
         /// <summary>
-        /// Temporal 8x8 block to hold TPixel data
+        /// Temporal 64-pixel span to hold unconverted TPixel data.
+        /// </summary>
+        private readonly Span<TPixel> pixelSpan;
+
+        /// <summary>
+        /// Temporal 64-byte span to hold converted <see cref="L8"/> data.
+        /// </summary>
+        private readonly Span<L8> l8Span;
+
+        /// <summary>
+        /// Sampled pixel buffer size.
         /// </summary>
-        private GenericBlock8x8<TPixel> pixelBlock;
+        private readonly Size samplingAreaSize;
 
         /// <summary>
-        /// Temporal RGB block
+        /// <see cref="Configuration"/> for internal operations.
         /// </summary>
-        private GenericBlock8x8<L8> l8Block;
+        private readonly Configuration config;
 
-        public static LuminanceForwardConverter<TPixel> Create()
+        public LuminanceForwardConverter(ImageFrame<TPixel> frame)
         {
-            var result = default(LuminanceForwardConverter<TPixel>);
-            return result;
+            this.Y = default;
+
+            this.pixelSpan = new TPixel[PixelsPerSample].AsSpan();
+            this.l8Span = new L8[PixelsPerSample].AsSpan();
+
+            this.samplingAreaSize = new Size(frame.Width, frame.Height);
+            this.config = frame.GetConfiguration();
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(8, 8);
+
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x,y) placing the result members of the structure (<see cref="Y"/>)
         /// </summary>
-        public void Convert(ImageFrame<TPixel> frame, int x, int y, ref RowOctet<TPixel> currentRows)
+        public void Convert(int x, int y, ref RowOctet<TPixel> currentRows)
         {
-            this.pixelBlock.LoadAndStretchEdges(frame.PixelBuffer, x, y, ref currentRows);
+            YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);
 
-            Span<L8> l8Span = this.l8Block.AsSpanUnsafe();
-            PixelOperations<TPixel>.Instance.ToL8(frame.GetConfiguration(), this.pixelBlock.AsSpanUnsafe(), l8Span);
+            PixelOperations<TPixel>.Instance.ToL8(this.config, this.pixelSpan, this.l8Span);
 
             ref Block8x8F yBlock = ref this.Y;
-            ref L8 l8Start = ref l8Span[0];
+            ref L8 l8Start = ref MemoryMarshal.GetReference(this.l8Span);
 
             for (int i = 0; i < Block8x8F.Size; i++)
             {
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbForwardConverter{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbForwardConverter{TPixel}.cs
index 0be1076e2..789277d7d 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbForwardConverter{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/RgbForwardConverter{TPixel}.cs
@@ -26,11 +26,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// </summary>
         private const int RgbSpanByteSize = PixelsPerSample * 3;
 
-        /// <summary>
-        /// <see cref="Size"/> of sampling area from given frame pixel buffer.
-        /// </summary>
-        private static readonly Size SampleSize = new Size(8, 8);
-
         /// <summary>
         /// The Red component.
         /// </summary>
@@ -81,6 +76,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             this.config = frame.GetConfiguration();
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(8, 8);
+
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x, y) to Rgb24.
         /// </summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter420{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter420{TPixel}.cs
index bfeafcbb3..3a878f3c6 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter420{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter420{TPixel}.cs
@@ -25,11 +25,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// </summary>
         private const int RgbSpanByteSize = PixelsPerSample * 3;
 
-        /// <summary>
-        /// <see cref="Size"/> of sampling area from given frame pixel buffer
-        /// </summary>
-        private static readonly Size SampleSize = new Size(16, 8);
-
         /// <summary>
         /// The left Y component
         /// </summary>
@@ -102,6 +97,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             }
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(16, 8);
+
         public void Convert(int x, int y, ref RowOctet<TPixel> currentRows, int idx)
         {
             YCbCrForwardConverter<TPixel>.LoadAndStretchEdges(currentRows, this.pixelSpan, new Point(x, y), SampleSize, this.samplingAreaSize);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter444{TPixel}.cs b/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter444{TPixel}.cs
index 2dbd1a2dc..5f7725bdd 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter444{TPixel}.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter444{TPixel}.cs
@@ -25,11 +25,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
         /// </summary>
         private const int RgbSpanByteSize = PixelsPerSample * 3;
 
-        /// <summary>
-        /// <see cref="Size"/> of sampling area from given frame pixel buffer
-        /// </summary>
-        private static readonly Size SampleSize = new Size(8, 8);
-
         /// <summary>
         /// The Y component
         /// </summary>
@@ -96,6 +91,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Encoder
             }
         }
 
+        /// <summary>
+        /// Gets size of sampling area from given frame pixel buffer.
+        /// </summary>
+        private static Size SampleSize => new(8, 8);
+
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x,y) placing the result members of the structure (<see cref="Y"/>, <see cref="Cb"/>, <see cref="Cr"/>)
         /// </summary>
diff --git a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.Generated.cs b/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.Generated.cs
deleted file mode 100644
index 213c48ff3..000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.Generated.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-// <auto-generated />
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components
-{
-	internal unsafe partial struct GenericBlock8x8<T>
-    {
-        #pragma warning disable 169
-
-        // It's not allowed use fix-sized buffers with generics, need to place all the fields manually:
-        private T _y0_x0, _y0_x1, _y0_x2, _y0_x3, _y0_x4, _y0_x5, _y0_x6, _y0_x7;
-        private T _y1_x0, _y1_x1, _y1_x2, _y1_x3, _y1_x4, _y1_x5, _y1_x6, _y1_x7;
-        private T _y2_x0, _y2_x1, _y2_x2, _y2_x3, _y2_x4, _y2_x5, _y2_x6, _y2_x7;
-        private T _y3_x0, _y3_x1, _y3_x2, _y3_x3, _y3_x4, _y3_x5, _y3_x6, _y3_x7;
-        private T _y4_x0, _y4_x1, _y4_x2, _y4_x3, _y4_x4, _y4_x5, _y4_x6, _y4_x7;
-        private T _y5_x0, _y5_x1, _y5_x2, _y5_x3, _y5_x4, _y5_x5, _y5_x6, _y5_x7;
-        private T _y6_x0, _y6_x1, _y6_x2, _y6_x3, _y6_x4, _y6_x5, _y6_x6, _y6_x7;
-        private T _y7_x0, _y7_x1, _y7_x2, _y7_x3, _y7_x4, _y7_x5, _y7_x6, _y7_x7;
-
-        #pragma warning restore 169
-	}
-}
diff --git a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.Generated.tt b/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.Generated.tt
deleted file mode 100644
index e69de29bb..000000000
diff --git a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs b/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs
deleted file mode 100644
index 42c01d770..000000000
--- a/src/ImageSharp/Formats/Jpeg/Components/GenericBlock8x8.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.PixelFormats;
-
-// ReSharper disable InconsistentNaming
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components
-{
-    /// <summary>
-    /// A generic 8x8 block implementation, useful for manipulating custom 8x8 pixel data.
-    /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
-    internal unsafe partial struct GenericBlock8x8<T>
-        where T : unmanaged
-    {
-        public const int Size = 64;
-
-        /// <summary>
-        /// FOR TESTING ONLY!
-        /// Gets or sets a <see cref="Rgb24"/> value at the given index
-        /// </summary>
-        /// <param name="idx">The index</param>
-        /// <returns>The value</returns>
-        public T this[int idx]
-        {
-            get
-            {
-                ref T selfRef = ref Unsafe.As<GenericBlock8x8<T>, T>(ref this);
-                return Unsafe.Add(ref selfRef, idx);
-            }
-
-            set
-            {
-                ref T selfRef = ref Unsafe.As<GenericBlock8x8<T>, T>(ref this);
-                Unsafe.Add(ref selfRef, idx) = value;
-            }
-        }
-
-        /// <summary>
-        /// FOR TESTING ONLY!
-        /// Gets or sets a value in a row+column of the 8x8 block
-        /// </summary>
-        /// <param name="x">The x position index in the row</param>
-        /// <param name="y">The column index</param>
-        /// <returns>The value</returns>
-        public T this[int x, int y]
-        {
-            get => this[(y * 8) + x];
-            set => this[(y * 8) + x] = value;
-        }
-
-        /// <summary>
-        /// Load a 8x8 region of an image into the block.
-        /// The "outlying" area of the block will be stretched out with pixels on the right and bottom edge of the image.
-        /// </summary>
-        public void LoadAndStretchEdges(Buffer2D<T> source, int sourceX, int sourceY, ref RowOctet<T> currentRows)
-        {
-            int width = Math.Min(8, source.Width - sourceX);
-            int height = Math.Min(8, source.Height - sourceY);
-
-            if (width <= 0 || height <= 0)
-            {
-                return;
-            }
-
-            uint byteWidth = (uint)width * (uint)Unsafe.SizeOf<T>();
-            int remainderXCount = 8 - width;
-
-            ref byte blockStart = ref Unsafe.As<GenericBlock8x8<T>, byte>(ref this);
-            int blockRowSizeInBytes = 8 * Unsafe.SizeOf<T>();
-
-            for (int y = 0; y < height; y++)
-            {
-                Span<T> row = currentRows[y];
-
-                ref byte s = ref Unsafe.As<T, byte>(ref row[sourceX]);
-                ref byte d = ref Unsafe.Add(ref blockStart, y * blockRowSizeInBytes);
-
-                Unsafe.CopyBlock(ref d, ref s, byteWidth);
-
-                ref T last = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref d), width - 1);
-
-                for (int x = 1; x <= remainderXCount; x++)
-                {
-                    Unsafe.Add(ref last, x) = last;
-                }
-            }
-
-            int remainderYCount = 8 - height;
-
-            if (remainderYCount == 0)
-            {
-                return;
-            }
-
-            ref byte lastRowStart = ref Unsafe.Add(ref blockStart, (height - 1) * blockRowSizeInBytes);
-
-            for (int y = 1; y <= remainderYCount; y++)
-            {
-                ref byte remStart = ref Unsafe.Add(ref lastRowStart, blockRowSizeInBytes * y);
-                Unsafe.CopyBlock(ref remStart, ref lastRowStart, (uint)blockRowSizeInBytes);
-            }
-        }
-
-        /// <summary>
-        /// Only for on-stack instances!
-        /// </summary>
-        public Span<T> AsSpanUnsafe()
-        {
-#if SUPPORTS_CREATESPAN
-            Span<GenericBlock8x8<T>> s = MemoryMarshal.CreateSpan(ref this, 1);
-            return MemoryMarshal.Cast<GenericBlock8x8<T>, T>(s);
-#else
-            return new Span<T>(Unsafe.AsPointer(ref this), Size);
-#endif
-        }
-    }
-}
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 73763f4ab..4be6731cc 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -175,7 +175,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration, cancellationToken);
+            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration);
 
             var scanDecoder = new HuffmanScanDecoder(stream, spectralConverter, cancellationToken);
 
@@ -185,7 +185,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.InitIptcProfile();
             this.InitDerivedMetadataProperties();
 
-            return new Image<TPixel>(this.Configuration, spectralConverter.GetPixelBuffer(), this.Metadata);
+            return new Image<TPixel>(
+                this.Configuration,
+                spectralConverter.GetPixelBuffer(cancellationToken),
+                this.Metadata);
         }
 
         /// <inheritdoc/>
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
index 9a0607584..c64fc8ad1 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/JpegTiffCompression.cs
@@ -55,17 +55,17 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
             {
                 using var jpegDecoder = new JpegDecoderCore(this.configuration, new JpegDecoder());
 
-                // TODO: Should we pass through the CancellationToken from the tiff decoder?
                 // If the PhotometricInterpretation is YCbCr we explicitly assume the JPEG data is in RGB color space.
                 // There seems no other way to determine that the JPEG data is RGB colorspace (no APP14 marker, componentId's are not RGB).
                 using SpectralConverter<Rgb24> spectralConverter = this.photometricInterpretation == TiffPhotometricInterpretation.YCbCr ?
-                    new RgbJpegSpectralConverter<Rgb24>(this.configuration, CancellationToken.None) : new SpectralConverter<Rgb24>(this.configuration, CancellationToken.None);
+                    new RgbJpegSpectralConverter<Rgb24>(this.configuration) : new SpectralConverter<Rgb24>(this.configuration);
                 var scanDecoder = new HuffmanScanDecoder(stream, spectralConverter, CancellationToken.None);
                 jpegDecoder.LoadTables(this.jpegTables, scanDecoder);
                 scanDecoder.ResetInterval = 0;
                 jpegDecoder.ParseStream(stream, scanDecoder, CancellationToken.None);
 
-                CopyImageBytesToBuffer(buffer, spectralConverter.GetPixelBuffer());
+                // TODO: Should we pass through the CancellationToken from the tiff decoder?
+                CopyImageBytesToBuffer(buffer, spectralConverter.GetPixelBuffer(CancellationToken.None));
             }
             else
             {
diff --git a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/RgbJpegSpectralConverter.cs b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/RgbJpegSpectralConverter.cs
index aefec7fa3..3b5833c10 100644
--- a/src/ImageSharp/Formats/Tiff/Compression/Decompressors/RgbJpegSpectralConverter.cs
+++ b/src/ImageSharp/Formats/Tiff/Compression/Decompressors/RgbJpegSpectralConverter.cs
@@ -21,9 +21,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Compression.Decompressors
         /// This Spectral converter will always convert the pixel data to RGB color.
         /// </summary>
         /// <param name="configuration">The configuration.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        public RgbJpegSpectralConverter(Configuration configuration, CancellationToken cancellationToken)
-            : base(configuration, cancellationToken)
+        public RgbJpegSpectralConverter(Configuration configuration)
+            : base(configuration)
         {
         }
 
diff --git a/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs b/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs
index b8986f66f..8fa4ab7a1 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/LossyUtils.cs
@@ -32,15 +32,48 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
         public static int Vp8_Sse4X4(Span<byte> a, Span<byte> b)
         {
 #if SUPPORTS_RUNTIME_INTRINSICS
+            if (Avx2.IsSupported)
+            {
+                // Load values.
+                ref byte aRef = ref MemoryMarshal.GetReference(a);
+                ref byte bRef = ref MemoryMarshal.GetReference(b);
+                var a0 = Vector256.Create(
+                    Unsafe.As<byte, Vector128<byte>>(ref aRef),
+                    Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps)));
+                var a1 = Vector256.Create(
+                    Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps * 2)),
+                    Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps * 3)));
+                var b0 = Vector256.Create(
+                    Unsafe.As<byte, Vector128<byte>>(ref bRef),
+                    Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps)));
+                var b1 = Vector256.Create(
+                    Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps * 2)),
+                    Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps * 3)));
+
+                // Combine pair of lines.
+                Vector256<int> a01 = Avx2.UnpackLow(a0.AsInt32(), a1.AsInt32());
+                Vector256<int> b01 = Avx2.UnpackLow(b0.AsInt32(), b1.AsInt32());
+
+                // Convert to 16b.
+                Vector256<byte> a01s = Avx2.UnpackLow(a01.AsByte(), Vector256<byte>.Zero);
+                Vector256<byte> b01s = Avx2.UnpackLow(b01.AsByte(), Vector256<byte>.Zero);
+
+                // subtract, square and accumulate.
+                Vector256<byte> d0 = Avx2.SubtractSaturate(a01s, b01s);
+                Vector256<int> e0 = Avx2.MultiplyAddAdjacent(d0.AsInt16(), d0.AsInt16());
+
+                return Numerics.ReduceSum(e0);
+            }
+
             if (Sse2.IsSupported)
             {
                 // Load values.
                 ref byte aRef = ref MemoryMarshal.GetReference(a);
+                ref byte bRef = ref MemoryMarshal.GetReference(b);
                 Vector128<byte> a0 = Unsafe.As<byte, Vector128<byte>>(ref aRef);
                 Vector128<byte> a1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps));
                 Vector128<byte> a2 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps * 2));
                 Vector128<byte> a3 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref aRef, WebpConstants.Bps * 3));
-                ref byte bRef = ref MemoryMarshal.GetReference(b);
                 Vector128<byte> b0 = Unsafe.As<byte, Vector128<byte>>(ref bRef);
                 Vector128<byte> b1 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps));
                 Vector128<byte> b2 = Unsafe.As<byte, Vector128<byte>>(ref Unsafe.Add(ref bRef, WebpConstants.Bps * 2));
@@ -67,7 +100,6 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
 
                 return Numerics.ReduceSum(sum);
             }
-            else
 #endif
             {
                 return Vp8_SseNxN(a, b, 4, 4);
diff --git a/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs b/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs
index fcd61f2c0..eb8d92110 100644
--- a/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs
+++ b/src/ImageSharp/Formats/Webp/Lossy/Vp8EncIterator.cs
@@ -358,7 +358,6 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy
             int kThreshold = 8 + ((17 - 8) * q / 100);
             int k;
             Span<uint> dc = stackalloc uint[16];
-            Span<ushort> tmp = stackalloc ushort[16];
             uint m;
             uint m2;
             for (k = 0; k < 16; k += 4)
diff --git a/src/ImageSharp/ImageSharp.csproj b/src/ImageSharp/ImageSharp.csproj
index 6ad20713d..f90e40edb 100644
--- a/src/ImageSharp/ImageSharp.csproj
+++ b/src/ImageSharp/ImageSharp.csproj
@@ -70,11 +70,6 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>Block8x8F.Generated.tt</DependentUpon>
     </Compile>
-    <Compile Update="Formats\Jpeg\Components\GenericBlock8x8.Generated.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>GenericBlock8x8.Generated.tt</DependentUpon>
-    </Compile>
     <Compile Update="Formats\Jpeg\Components\Block8x8F.Generated.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -167,10 +162,6 @@
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Block8x8F.Generated.cs</LastGenOutput>
     </None>
-    <None Update="Formats\Jpeg\Components\GenericBlock8x8.Generated.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>GenericBlock8x8.Generated.cs</LastGenOutput>
-    </None>
     <None Update="Formats\Jpeg\Components\Block8x8F.Generated.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Block8x8F.Generated.cs</LastGenOutput>
diff --git a/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs b/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs
index e6e82b981..079d24c47 100644
--- a/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs
+++ b/tests/ImageSharp.Tests.ProfilingSandbox/Program.cs
@@ -47,12 +47,6 @@ namespace SixLabors.ImageSharp.Tests.ProfilingSandbox
             benchmarks.EncodeJpeg_SingleMidSize();
         }
 
-        private static void RunJpegColorProfilingTests()
-        {
-            new JpegColorConverterTests(new ConsoleOutput()).BenchmarkYCbCr(false);
-            new JpegColorConverterTests(new ConsoleOutput()).BenchmarkYCbCr(true);
-        }
-
         private static void RunResizeProfilingTest()
         {
             var test = new ResizeProfilingBenchmarks(new ConsoleOutput());
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
index 8f5f10f19..ae7e81254 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8FTests.cs
@@ -114,56 +114,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             // PrintLinearData((Span<float>)mirror);
         }
 
-        [Fact]
-        public unsafe void Load_Store_FloatArray_Ptr()
-        {
-            float[] data = new float[Block8x8F.Size];
-            float[] mirror = new float[Block8x8F.Size];
-
-            for (int i = 0; i < Block8x8F.Size; i++)
-            {
-                data[i] = i;
-            }
-
-            this.Measure(
-                Times,
-                () =>
-                {
-                    var b = default(Block8x8F);
-                    Block8x8F.LoadFrom(&b, data);
-                    Block8x8F.ScaledCopyTo(&b, mirror);
-                });
-
-            Assert.Equal(data, mirror);
-
-            // PrintLinearData((Span<float>)mirror);
-        }
-
-        [Fact]
-        public void Load_Store_IntArray()
-        {
-            int[] data = new int[Block8x8F.Size];
-            int[] mirror = new int[Block8x8F.Size];
-
-            for (int i = 0; i < Block8x8F.Size; i++)
-            {
-                data[i] = i;
-            }
-
-            this.Measure(
-                Times,
-                () =>
-                {
-                    var v = default(Block8x8F);
-                    v.LoadFrom(data);
-                    v.ScaledCopyTo(mirror);
-                });
-
-            Assert.Equal(data, mirror);
-
-            // PrintLinearData((Span<int>)mirror);
-        }
-
         [Fact]
         public void TransposeInplace()
         {
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs
index b13a196cb..094622070 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/Block8x8Tests.cs
@@ -70,20 +70,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             Assert.Equal(data, result);
         }
 
-        [Fact]
-        public void Equality_WhenTrue()
-        {
-            short[] data = Create8x8ShortData();
-            var block1 = Block8x8.Load(data);
-            var block2 = Block8x8.Load(data);
-
-            block1[0] = 42;
-            block2[0] = 42;
-
-            Assert.Equal(block1, block2);
-            Assert.Equal(block1.GetHashCode(), block2.GetHashCode());
-        }
-
         [Fact]
         public void Equality_WhenFalse()
         {
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs b/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs
deleted file mode 100644
index d5ee2a2b8..000000000
--- a/tests/ImageSharp.Tests/Formats/Jpg/GenericBlock8x8Tests.cs
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using SixLabors.ImageSharp.Formats.Jpeg.Components;
-using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.PixelFormats;
-
-using Xunit;
-
-namespace SixLabors.ImageSharp.Tests.Formats.Jpg
-{
-    [Trait("Format", "Jpg")]
-    public class GenericBlock8x8Tests
-    {
-        public static Image<TPixel> CreateTestImage<TPixel>()
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            var image = new Image<TPixel>(10, 10);
-            Buffer2D<TPixel> pixels = image.GetRootFramePixelBuffer();
-            for (int i = 0; i < 10; i++)
-            {
-                for (int j = 0; j < 10; j++)
-                {
-                    var rgba = new Rgba32((byte)(i + 1), (byte)(j + 1), 200, 255);
-                    var color = default(TPixel);
-                    color.FromRgba32(rgba);
-
-                    pixels[i, j] = color;
-                }
-            }
-
-            return image;
-        }
-
-        [Theory]
-        [WithMemberFactory(nameof(CreateTestImage), PixelTypes.Rgb24 | PixelTypes.Rgba32 /* | PixelTypes.Rgba32 | PixelTypes.Argb32*/)]
-        public void LoadAndStretchCorners_FromOrigo<TPixel>(TestImageProvider<TPixel> provider)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            using (Image<TPixel> s = provider.GetImage())
-            {
-                var d = default(GenericBlock8x8<TPixel>);
-                RowOctet<TPixel> rowOctet = default;
-                rowOctet.Update(s.GetRootFramePixelBuffer(), 0);
-                d.LoadAndStretchEdges(s.Frames.RootFrame.PixelBuffer, 0, 0, ref rowOctet);
-
-                TPixel a = s.Frames.RootFrame[0, 0];
-                TPixel b = d[0, 0];
-
-                Assert.Equal(s[0, 0], d[0, 0]);
-                Assert.Equal(s[1, 0], d[1, 0]);
-                Assert.Equal(s[7, 0], d[7, 0]);
-                Assert.Equal(s[0, 1], d[0, 1]);
-                Assert.Equal(s[1, 1], d[1, 1]);
-                Assert.Equal(s[7, 0], d[7, 0]);
-                Assert.Equal(s[0, 7], d[0, 7]);
-                Assert.Equal(s[7, 7], d[7, 7]);
-            }
-        }
-
-        [Theory]
-        [WithMemberFactory(nameof(CreateTestImage), PixelTypes.Rgb24 | PixelTypes.Rgba32)]
-        public void LoadAndStretchCorners_WithOffset<TPixel>(TestImageProvider<TPixel> provider)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            using (Image<TPixel> s = provider.GetImage())
-            {
-                var d = default(GenericBlock8x8<TPixel>);
-                RowOctet<TPixel> rowOctet = default;
-                rowOctet.Update(s.GetRootFramePixelBuffer(), 7);
-
-                d.LoadAndStretchEdges(s.Frames.RootFrame.PixelBuffer, 6, 7, ref rowOctet);
-
-                Assert.Equal(s[6, 7], d[0, 0]);
-                Assert.Equal(s[6, 8], d[0, 1]);
-                Assert.Equal(s[7, 8], d[1, 1]);
-
-                Assert.Equal(s[6, 9], d[0, 2]);
-                Assert.Equal(s[6, 9], d[0, 3]);
-                Assert.Equal(s[6, 9], d[0, 7]);
-
-                Assert.Equal(s[7, 9], d[1, 2]);
-                Assert.Equal(s[7, 9], d[1, 3]);
-                Assert.Equal(s[7, 9], d[1, 7]);
-
-                Assert.Equal(s[9, 9], d[3, 2]);
-                Assert.Equal(s[9, 9], d[3, 3]);
-                Assert.Equal(s[9, 9], d[3, 7]);
-
-                Assert.Equal(s[9, 7], d[3, 0]);
-                Assert.Equal(s[9, 7], d[4, 0]);
-                Assert.Equal(s[9, 7], d[7, 0]);
-
-                Assert.Equal(s[9, 9], d[3, 2]);
-                Assert.Equal(s[9, 9], d[4, 2]);
-                Assert.Equal(s[9, 9], d[7, 2]);
-
-                Assert.Equal(s[9, 9], d[4, 3]);
-                Assert.Equal(s[9, 9], d[7, 7]);
-            }
-        }
-
-        [Fact]
-        public void Indexer()
-        {
-            var block = default(GenericBlock8x8<Rgb24>);
-            Span<Rgb24> span = block.AsSpanUnsafe();
-            Assert.Equal(64, span.Length);
-
-            for (int i = 0; i < 64; i++)
-            {
-                span[i] = new Rgb24((byte)i, (byte)(2 * i), (byte)(3 * i));
-            }
-
-            var expected00 = new Rgb24(0, 0, 0);
-            var expected07 = new Rgb24(7, 14, 21);
-            var expected11 = new Rgb24(9, 18, 27);
-            var expected77 = new Rgb24(63, 126, 189);
-            var expected67 = new Rgb24(62, 124, 186);
-
-            Assert.Equal(expected00, block[0, 0]);
-            Assert.Equal(expected07, block[7, 0]);
-            Assert.Equal(expected11, block[1, 1]);
-            Assert.Equal(expected67, block[6, 7]);
-            Assert.Equal(expected77, block[7, 7]);
-        }
-    }
-}
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
index 4e0970e3b..d6dc57e83 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegColorConverterTests.cs
@@ -340,32 +340,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 seed);
         }
 
-        // Benchmark, for local execution only
-        // [Theory]
-        // [InlineData(false)]
-        // [InlineData(true)]
-        public void BenchmarkYCbCr(bool simd)
-        {
-            int count = 2053;
-            int times = 50000;
-
-            JpegColorConverter.ComponentValues values = CreateRandomValues(3, count, 1);
-            var result = new Vector4[count];
-
-            JpegColorConverter converter = simd ? (JpegColorConverter)new JpegColorConverter.FromYCbCrVector4(8) : new JpegColorConverter.FromYCbCrBasic(8);
-
-            // Warm up:
-            converter.ConvertToRgbInplace(values);
-
-            using (new MeasureGuard(this.Output, $"{converter.GetType().Name} x {times}"))
-            {
-                for (int i = 0; i < times; i++)
-                {
-                    converter.ConvertToRgbInplace(values);
-                }
-            }
-        }
-
         private static JpegColorConverter.ComponentValues CreateRandomValues(
             int componentCount,
             int inputBufferLength,
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs
index 8920d42d4..9eb3c0103 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.FastFloatingPointDCT.cs
@@ -94,7 +94,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 
                 Block8x8F expected = ReferenceImplementations.AccurateDCT.TransformFDCT(ref source);
                 Block8x8F actual = ReferenceImplementations.LLM_FloatingPoint_DCT.TransformFDCT_UpscaleBy8(ref source);
-                actual /= 8;
+                actual.MultiplyInPlace(0.125f);
 
                 this.CompareBlocks(expected, actual, 1f);
             }
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.StandardIntegerDCT.cs b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.StandardIntegerDCT.cs
index 6e25334f2..02f8ba388 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.StandardIntegerDCT.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/ReferenceImplementationsTests.StandardIntegerDCT.cs
@@ -51,11 +51,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 
                 Block8x8F expected = ReferenceImplementations.AccurateDCT.TransformFDCT(ref source);
 
-                source += 128;
+                source.AddInPlace(128f);
                 Block8x8 temp = source.RoundAsInt16Block();
                 Block8x8 actual8 = ReferenceImplementations.StandardIntegerDCT.Subtract128_TransformFDCT_Upscale8(ref temp);
                 Block8x8F actual = actual8.AsFloatBlock();
-                actual /= 8;
+                actual.MultiplyInPlace(0.125f);
 
                 this.CompareBlocks(expected, actual, 1f);
             }
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs
index f0f92d763..0071c623c 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs
@@ -3,6 +3,7 @@
 
 using System.IO;
 using System.Linq;
+using System.Threading;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.IO;
@@ -43,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
 
             // Decoding
-            using var converter = new SpectralConverter<TPixel>(Configuration.Default, cancellationToken: default);
+            using var converter = new SpectralConverter<TPixel>(Configuration.Default);
             var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
             var scanDecoder = new HuffmanScanDecoder(bufferedStream, converter, cancellationToken: default);
             decoder.ParseStream(bufferedStream, scanDecoder, cancellationToken: default);
@@ -53,7 +54,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             provider.Utility.TestName = JpegDecoderTests.DecodeBaselineJpegOutputName;
 
             // Comparison
-            using (Image<TPixel> image = new Image<TPixel>(Configuration.Default, converter.GetPixelBuffer(), new ImageMetadata()))
+            using (Image<TPixel> image = new Image<TPixel>(Configuration.Default, converter.GetPixelBuffer(CancellationToken.None), new ImageMetadata()))
             using (Image<TPixel> referenceImage = provider.GetReferenceOutputImage<TPixel>(appendPixelTypeToFileName: false))
             {
                 ImageSimilarityReport report = ImageComparer.Exact.CompareImagesOrFrames(referenceImage, image);
diff --git a/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs b/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs
index 907b18300..defd5af6c 100644
--- a/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Formats/WebP/LossyUtilsTests.cs
@@ -104,7 +104,10 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp
         public void Vp8Sse4X4_WithHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunVp8Sse4X4Test, HwIntrinsics.AllowAll);
 
         [Fact]
-        public void Vp8Sse4X4_WithoutHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunVp8Sse4X4Test, HwIntrinsics.DisableHWIntrinsic);
+        public void Vp8Sse4X4_WithoutSSE2_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunVp8Sse4X4Test, HwIntrinsics.DisableSSE2);
+
+        [Fact]
+        public void Vp8Sse4X4_WithoutAVX2_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunVp8Sse4X4Test, HwIntrinsics.DisableAVX2);
 
         [Fact]
         public void Mean16x4_WithHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunMean16x4Test, HwIntrinsics.AllowAll);