Merge pull request #1694 from br3aker/jpeg-decoder-memory

JpegDecoder: post-process baseline spectral data per MCU-row

src/ImageSharp/Common/Helpers/Numerics.cs

@@ -879,5 +879,13 @@ namespace SixLabors.ImageSharp
                 (IntPtr)(int)((value * 0x07C4ACDDu) >> 27)); // uint|long -> IntPtr cast on 32-bit platforms does expensive overflow checks not needed here
         }
 #endif
+
+        /// <summary>
+        /// Fast division with ceiling for <see cref="uint"/> numbers.
+        /// </summary>
+        /// <param name="value">Divident value.</param>
+        /// <param name="divisor">Divisor value.</param>
+        /// <returns>Ceiled division result.</returns>
+        public static uint DivideCeil(uint value, uint divisor) => (value + divisor - 1) / divisor;
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/HuffmanScanDecoder.cs

@@ -16,29 +16,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// </summary>
     internal class HuffmanScanDecoder
     {
-        private readonly JpegFrame frame;
-        private readonly HuffmanTable[] dcHuffmanTables;
-        private readonly HuffmanTable[] acHuffmanTables;
         private readonly BufferedReadStream stream;
-        private readonly JpegComponent[] components;
 
-        // The restart interval.
+        // Frame related
-        private readonly int restartInterval;
+        private JpegFrame frame;
-
+        private JpegComponent[] components;
-        // The number of interleaved components.
-        private readonly int componentsLength;
-
-        // The spectral selection start.
-        private readonly int spectralStart;
-
-        // The spectral selection end.
-        private readonly int spectralEnd;
-
-        // The successive approximation high bit end.
-        private readonly int successiveHigh;
 
-        // The successive approximation low bit end.
+        // The restart interval.
-        private readonly int successiveLow;
+        private int restartInterval;
 
         // How many mcu's are left to do.
         private int todo;
@@ -51,52 +36,57 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
         private HuffmanScanBuffer scanBuffer;
 
+        private readonly SpectralConverter spectralConverter;
+
         private CancellationToken cancellationToken;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="HuffmanScanDecoder"/> class.
         /// </summary>
         /// <param name="stream">The input stream.</param>
-        /// <param name="frame">The image frame.</param>
+        /// <param name="converter">Spectral to pixel converter.</param>
-        /// <param name="dcHuffmanTables">The DC Huffman tables.</param>
-        /// <param name="acHuffmanTables">The AC Huffman tables.</param>
-        /// <param name="componentsLength">The length of the components. Different to the array length.</param>
-        /// <param name="restartInterval">The reset interval.</param>
-        /// <param name="spectralStart">The spectral selection start.</param>
-        /// <param name="spectralEnd">The spectral selection end.</param>
-        /// <param name="successiveHigh">The successive approximation bit high end.</param>
-        /// <param name="successiveLow">The successive approximation bit low end.</param>
         /// <param name="cancellationToken">The token to monitor cancellation.</param>
         public HuffmanScanDecoder(
             BufferedReadStream stream,
-            JpegFrame frame,
+            SpectralConverter converter,
-            HuffmanTable[] dcHuffmanTables,
-            HuffmanTable[] acHuffmanTables,
-            int componentsLength,
-            int restartInterval,
-            int spectralStart,
-            int spectralEnd,
-            int successiveHigh,
-            int successiveLow,
             CancellationToken cancellationToken)
         {
             this.dctZigZag = ZigZag.CreateUnzigTable();
             this.stream = stream;
-            this.scanBuffer = new HuffmanScanBuffer(stream);
+            this.spectralConverter = converter;
-            this.frame = frame;
-            this.dcHuffmanTables = dcHuffmanTables;
-            this.acHuffmanTables = acHuffmanTables;
-            this.components = frame.Components;
-            this.componentsLength = componentsLength;
-            this.restartInterval = restartInterval;
-            this.todo = restartInterval;
-            this.spectralStart = spectralStart;
-            this.spectralEnd = spectralEnd;
-            this.successiveHigh = successiveHigh;
-            this.successiveLow = successiveLow;
             this.cancellationToken = cancellationToken;
         }
 
+        // huffman tables
+        public HuffmanTable[] DcHuffmanTables { get; set; }
+
+        public HuffmanTable[] AcHuffmanTables { get; set; }
+
+        // Reset interval
+        public int ResetInterval
+        {
+            set
+            {
+                this.restartInterval = value;
+                this.todo = value;
+            }
+        }
+
+        // The number of interleaved components.
+        public int ComponentsLength { get; set; }
+
+        // The spectral selection start.
+        public int SpectralStart { get; set; }
+
+        // The spectral selection end.
+        public int SpectralEnd { get; set; }
+
+        // The successive approximation high bit end.
+        public int SuccessiveHigh { get; set; }
+
+        // The successive approximation low bit end.
+        public int SuccessiveLow { get; set; }
+
         /// <summary>
         /// Decodes the entropy coded data.
         /// </summary>
@@ -104,6 +94,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         {
             this.cancellationToken.ThrowIfCancellationRequested();
 
+            this.scanBuffer = new HuffmanScanBuffer(this.stream);
+
+            bool fullScan = this.frame.Progressive || this.frame.MultiScan;
+            this.frame.AllocateComponents(fullScan);
+
             if (!this.frame.Progressive)
             {
                 this.ParseBaselineData();
@@ -119,15 +114,23 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             }
         }
 
+        public void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
+        {
+            this.frame = frame;
+            this.components = frame.Components;
+
+            this.spectralConverter.InjectFrameData(frame, jpegData);
+        }
+
         private void ParseBaselineData()
         {
-            if (this.componentsLength == 1)
+            if (this.ComponentsLength == this.frame.ComponentCount)
             {
-                this.ParseBaselineDataNonInterleaved();
+                this.ParseBaselineDataInterleaved();
             }
             else
             {
-                this.ParseBaselineDataInterleaved();
+                this.ParseBaselineDataNonInterleaved();
             }
         }
 
@@ -140,13 +143,13 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
             // Pre-derive the huffman table to avoid in-loop checks.
-            for (int i = 0; i < this.componentsLength; i++)
+            for (int i = 0; i < this.ComponentsLength; i++)
             {
                 int order = this.frame.ComponentOrder[i];
                 JpegComponent component = this.components[order];
 
-                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
-                ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
+                ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
                 dcHuffmanTable.Configure();
                 acHuffmanTable.Configure();
             }
@@ -155,18 +158,18 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             {
                 this.cancellationToken.ThrowIfCancellationRequested();
 
+                // decode from binary to spectral
                 for (int i = 0; i < mcusPerLine; i++)
                 {
                     // Scan an interleaved mcu... process components in order
-                    int mcuRow = mcu / mcusPerLine;
                     int mcuCol = mcu % mcusPerLine;
-                    for (int k = 0; k < this.componentsLength; k++)
+                    for (int k = 0; k < this.ComponentsLength; k++)
                     {
                         int order = this.frame.ComponentOrder[k];
                         JpegComponent component = this.components[order];
 
-                        ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                        ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
-                        ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
+                        ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
 
                         int h = component.HorizontalSamplingFactor;
                         int v = component.VerticalSamplingFactor;
@@ -175,14 +178,16 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                         // by the basic H and V specified for the component
                         for (int y = 0; y < v; y++)
                         {
-                            int blockRow = (mcuRow * v) + y;
+                            Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(y);
-                            Span<Block8x8> blockSpan = component.SpectralBlocks.GetRowSpan(blockRow);
                             ref Block8x8 blockRef = ref MemoryMarshal.GetReference(blockSpan);
 
                             for (int x = 0; x < h; x++)
                             {
                                 if (buffer.NoData)
                                 {
+                                    // It is very likely that some spectral data was decoded before we encountered EOI marker
+                                    // so we need to decode what's left and return (or maybe throw?)
+                                    this.spectralConverter.ConvertStrideBaseline();
                                     return;
                                 }
 
@@ -202,6 +207,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                     mcu++;
                     this.HandleRestart();
                 }
+
+                // convert from spectral to actual pixels via given converter
+                this.spectralConverter.ConvertStrideBaseline();
             }
         }
 
@@ -213,8 +221,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             int w = component.WidthInBlocks;
             int h = component.HeightInBlocks;
 
-            ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+            ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
-            ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
+            ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
             dcHuffmanTable.Configure();
             acHuffmanTable.Configure();
 
@@ -248,9 +256,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             // Logic has been adapted from libjpeg.
             // See Table B.3 – Scan header parameter size and values. itu-t81.pdf
             bool invalid = false;
-            if (this.spectralStart == 0)
+            if (this.SpectralStart == 0)
             {
-                if (this.spectralEnd != 0)
+                if (this.SpectralEnd != 0)
                 {
                     invalid = true;
                 }
@@ -258,22 +266,22 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             else
             {
                 // Need not check Ss/Se < 0 since they came from unsigned bytes.
-                if (this.spectralEnd < this.spectralStart || this.spectralEnd > 63)
+                if (this.SpectralEnd < this.SpectralStart || this.SpectralEnd > 63)
                 {
                     invalid = true;
                 }
 
                 // AC scans may have only one component.
-                if (this.componentsLength != 1)
+                if (this.ComponentsLength != 1)
                 {
                     invalid = true;
                 }
             }
 
-            if (this.successiveHigh != 0)
+            if (this.SuccessiveHigh != 0)
             {
                 // Successive approximation refinement scan: must have Al = Ah-1.
-                if (this.successiveHigh - 1 != this.successiveLow)
+                if (this.SuccessiveHigh - 1 != this.SuccessiveLow)
                 {
                     invalid = true;
                 }
@@ -281,14 +289,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
             // TODO: How does this affect 12bit jpegs.
             // According to libjpeg the range covers 8bit only?
-            if (this.successiveLow > 13)
+            if (this.SuccessiveLow > 13)
             {
                 invalid = true;
             }
 
             if (invalid)
             {
-                JpegThrowHelper.ThrowBadProgressiveScan(this.spectralStart, this.spectralEnd, this.successiveHigh, this.successiveLow);
+                JpegThrowHelper.ThrowBadProgressiveScan(this.SpectralStart, this.SpectralEnd, this.SuccessiveHigh, this.SuccessiveLow);
             }
         }
 
@@ -296,7 +304,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         {
             this.CheckProgressiveData();
 
-            if (this.componentsLength == 1)
+            if (this.ComponentsLength == 1)
             {
                 this.ParseProgressiveDataNonInterleaved();
             }
@@ -315,11 +323,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
             // Pre-derive the huffman table to avoid in-loop checks.
-            for (int k = 0; k < this.componentsLength; k++)
+            for (int k = 0; k < this.ComponentsLength; k++)
             {
                 int order = this.frame.ComponentOrder[k];
                 JpegComponent component = this.components[order];
-                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
                 dcHuffmanTable.Configure();
             }
 
@@ -330,11 +338,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                     // Scan an interleaved mcu... process components in order
                     int mcuRow = mcu / mcusPerLine;
                     int mcuCol = mcu % mcusPerLine;
-                    for (int k = 0; k < this.componentsLength; k++)
+                    for (int k = 0; k < this.ComponentsLength; k++)
                     {
                         int order = this.frame.ComponentOrder[k];
                         JpegComponent component = this.components[order];
-                        ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                        ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
 
                         int h = component.HorizontalSamplingFactor;
                         int v = component.VerticalSamplingFactor;
@@ -380,9 +388,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             int w = component.WidthInBlocks;
             int h = component.HeightInBlocks;
 
-            if (this.spectralStart == 0)
+            if (this.SpectralStart == 0)
             {
-                ref HuffmanTable dcHuffmanTable = ref this.dcHuffmanTables[component.DCHuffmanTableId];
+                ref HuffmanTable dcHuffmanTable = ref this.DcHuffmanTables[component.DCHuffmanTableId];
                 dcHuffmanTable.Configure();
 
                 for (int j = 0; j < h; j++)
@@ -410,7 +418,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             }
             else
             {
-                ref HuffmanTable acHuffmanTable = ref this.acHuffmanTables[component.ACHuffmanTableId];
+                ref HuffmanTable acHuffmanTable = ref this.AcHuffmanTables[component.ACHuffmanTableId];
                 acHuffmanTable.Configure();
 
                 for (int j = 0; j < h; j++)
@@ -489,7 +497,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             ref short blockDataRef = ref Unsafe.As<Block8x8, short>(ref block);
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
 
-            if (this.successiveHigh == 0)
+            if (this.SuccessiveHigh == 0)
             {
                 // First scan for DC coefficient, must be first
                 int s = buffer.DecodeHuffman(ref dcTable);
@@ -500,20 +508,20 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                 s += component.DcPredictor;
                 component.DcPredictor = s;
-                blockDataRef = (short)(s << this.successiveLow);
+                blockDataRef = (short)(s << this.SuccessiveLow);
             }
             else
             {
                 // Refinement scan for DC coefficient
                 buffer.CheckBits();
-                blockDataRef |= (short)(buffer.GetBits(1) << this.successiveLow);
+                blockDataRef |= (short)(buffer.GetBits(1) << this.SuccessiveLow);
             }
         }
 
         private void DecodeBlockProgressiveAC(ref Block8x8 block, ref HuffmanTable acTable)
         {
             ref short blockDataRef = ref Unsafe.As<Block8x8, short>(ref block);
-            if (this.successiveHigh == 0)
+            if (this.SuccessiveHigh == 0)
             {
                 // MCU decoding for AC initial scan (either spectral selection,
                 // or first pass of successive approximation).
@@ -525,9 +533,9 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 
                 ref HuffmanScanBuffer buffer = ref this.scanBuffer;
                 ref ZigZag zigzag = ref this.dctZigZag;
-                int start = this.spectralStart;
+                int start = this.SpectralStart;
-                int end = this.spectralEnd;
+                int end = this.SpectralEnd;
-                int low = this.successiveLow;
+                int low = this.SuccessiveLow;
 
                 for (int i = start; i <= end; ++i)
                 {
@@ -571,11 +579,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             // Refinement scan for these AC coefficients
             ref HuffmanScanBuffer buffer = ref this.scanBuffer;
             ref ZigZag zigzag = ref this.dctZigZag;
-            int start = this.spectralStart;
+            int start = this.SpectralStart;
-            int end = this.spectralEnd;
+            int end = this.SpectralEnd;
 
-            int p1 = 1 << this.successiveLow;
+            int p1 = 1 << this.SuccessiveLow;
-            int m1 = (-1) << this.successiveLow;
+            int m1 = (-1) << this.SuccessiveLow;
 
             int k = start;
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponent.cs

@@ -109,10 +109,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         public void Init()
         {
             this.WidthInBlocks = (int)MathF.Ceiling(
-                MathF.Ceiling(this.Frame.SamplesPerLine / 8F) * this.HorizontalSamplingFactor / this.Frame.MaxHorizontalFactor);
+                MathF.Ceiling(this.Frame.PixelWidth / 8F) * this.HorizontalSamplingFactor / this.Frame.MaxHorizontalFactor);
 
             this.HeightInBlocks = (int)MathF.Ceiling(
-                MathF.Ceiling(this.Frame.Scanlines / 8F) * this.VerticalSamplingFactor / this.Frame.MaxVerticalFactor);
+                MathF.Ceiling(this.Frame.PixelHeight / 8F) * this.VerticalSamplingFactor / this.Frame.MaxVerticalFactor);
 
             int blocksPerLineForMcu = this.Frame.McusPerLine * this.HorizontalSamplingFactor;
             int blocksPerColumnForMcu = this.Frame.McusPerColumn * this.VerticalSamplingFactor;
@@ -125,12 +125,20 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
             {
                 JpegThrowHelper.ThrowBadSampling();
             }
+        }
+
+        public void AllocateSpectral(bool fullScan)
+        {
+            if (this.SpectralBlocks != null)
+            {
+                // this method will be called each scan marker so we need to allocate only once
+                return;
+            }
 
-            int totalNumberOfBlocks = blocksPerColumnForMcu * (blocksPerLineForMcu + 1);
+            int spectralAllocWidth = this.SizeInBlocks.Width;
-            int width = this.WidthInBlocks + 1;
+            int spectralAllocHeight = fullScan ? this.SizeInBlocks.Height : this.VerticalSamplingFactor;
-            int height = totalNumberOfBlocks / width;
 
-            this.SpectralBlocks = this.memoryAllocator.Allocate2D<Block8x8>(width, height, AllocationOptions.Clean);
+            this.SpectralBlocks = this.memoryAllocator.Allocate2D<Block8x8>(spectralAllocWidth, spectralAllocHeight, AllocationOptions.Clean);
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegComponentPostProcessor.cs

@@ -2,15 +2,12 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
 using SixLabors.ImageSharp.Memory;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
 {
     /// <summary>
-    /// Encapsulates postprocessing data for one component for <see cref="JpegImagePostProcessor"/>.
+    /// Encapsulates spectral data to rgba32 processing for one component.
     /// </summary>
     internal class JpegComponentPostProcessor : IDisposable
     {
@@ -27,23 +24,20 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegComponentPostProcessor"/> class.
         /// </summary>
-        public JpegComponentPostProcessor(MemoryAllocator memoryAllocator, JpegImagePostProcessor imagePostProcessor, IJpegComponent component)
+        public JpegComponentPostProcessor(MemoryAllocator memoryAllocator, IRawJpegData rawJpeg, Size postProcessorBufferSize, IJpegComponent component)
         {
             this.Component = component;
-            this.ImagePostProcessor = imagePostProcessor;
+            this.RawJpeg = rawJpeg;
             this.blockAreaSize = this.Component.SubSamplingDivisors * 8;
             this.ColorBuffer = memoryAllocator.Allocate2DOveraligned<float>(
-                imagePostProcessor.PostProcessorBufferSize.Width,
+                postProcessorBufferSize.Width,
-                imagePostProcessor.PostProcessorBufferSize.Height,
+                postProcessorBufferSize.Height,
                 this.blockAreaSize.Height);
 
-            this.BlockRowsPerStep = JpegImagePostProcessor.BlockRowsPerStep / this.Component.SubSamplingDivisors.Height;
+            this.BlockRowsPerStep = postProcessorBufferSize.Height / 8 / this.Component.SubSamplingDivisors.Height;
         }
 
-        /// <summary>
+        public IRawJpegData RawJpeg { get; }
-        /// Gets the <see cref="JpegImagePostProcessor"/>
-        /// </summary>
-        public JpegImagePostProcessor ImagePostProcessor { get; }
 
         /// <summary>
         /// Gets the <see cref="Component"/>
@@ -66,26 +60,27 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         public int BlockRowsPerStep { get; }
 
         /// <inheritdoc />
-        public void Dispose()
+        public void Dispose() => this.ColorBuffer.Dispose();
-        {
-            this.ColorBuffer.Dispose();
-        }
 
         /// <summary>
         /// Invoke <see cref="JpegBlockPostProcessor"/> for <see cref="BlockRowsPerStep"/> block rows, copy the result into <see cref="ColorBuffer"/>.
         /// </summary>
-        public void CopyBlocksToColorBuffer()
+        public void CopyBlocksToColorBuffer(int step)
         {
-            var blockPp = new JpegBlockPostProcessor(this.ImagePostProcessor.RawJpeg, this.Component);
+            Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
-            float maximumValue = MathF.Pow(2, this.ImagePostProcessor.RawJpeg.Precision) - 1;
+
+            var blockPp = new JpegBlockPostProcessor(this.RawJpeg, this.Component);
+            float maximumValue = MathF.Pow(2, this.RawJpeg.Precision) - 1;
 
             int destAreaStride = this.ColorBuffer.Width;
 
+            int yBlockStart = step * this.BlockRowsPerStep;
+
             for (int y = 0; y < this.BlockRowsPerStep; y++)
             {
-                int yBlock = this.currentComponentRowInBlocks + y;
+                int yBlock = yBlockStart + y;
 
-                if (yBlock >= this.SizeInBlocks.Height)
+                if (yBlock >= spectralBuffer.Height)
                 {
                     break;
                 }
@@ -93,10 +88,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                 int yBuffer = y * this.blockAreaSize.Height;
 
                 Span<float> colorBufferRow = this.ColorBuffer.GetRowSpan(yBuffer);
-                Span<Block8x8> blockRow = this.Component.SpectralBlocks.GetRowSpan(yBlock);
+                Span<Block8x8> blockRow = spectralBuffer.GetRowSpan(yBlock);
 
                 // see: https://github.com/SixLabors/ImageSharp/issues/824
-                int widthInBlocks = Math.Min(this.Component.SpectralBlocks.Width, this.SizeInBlocks.Width);
+                int widthInBlocks = Math.Min(spectralBuffer.Width, this.SizeInBlocks.Width);
 
                 for (int xBlock = 0; xBlock < widthInBlocks; xBlock++)
                 {
@@ -107,7 +102,20 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                     blockPp.ProcessBlockColorsInto(ref block, ref destAreaOrigin, destAreaStride, maximumValue);
                 }
             }
+        }
+
+        public void ClearSpectralBuffers()
+        {
+            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;
         }
     }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegFrame.cs

@@ -20,6 +20,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         public bool Progressive { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the frame is encoded using multiple scans (SOS markers).
+        /// </summary>
+        /// <remarks>
+        /// This is true for progressive and baseline non-interleaved images.
+        /// </remarks>
+        public bool MultiScan { get; set; }
+
         /// <summary>
         /// Gets or sets the precision.
         /// </summary>
@@ -28,12 +36,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <summary>
         /// Gets or sets the number of scanlines within the frame.
         /// </summary>
-        public int Scanlines { get; set; }
+        public int PixelHeight { get; set; }
 
         /// <summary>
         /// Gets or sets the number of samples per scanline.
         /// </summary>
-        public int SamplesPerLine { get; set; }
+        public int PixelWidth { get; set; }
 
         /// <summary>
         /// Gets or sets the number of components within a frame. In progressive frames this value can range from only 1 to 4.
@@ -95,8 +103,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// </summary>
         public void InitComponents()
         {
-            this.McusPerLine = (int)MathF.Ceiling(this.SamplesPerLine / 8F / this.MaxHorizontalFactor);
+            this.McusPerLine = (int)Numerics.DivideCeil((uint)this.PixelWidth, (uint)this.MaxHorizontalFactor * 8);
-            this.McusPerColumn = (int)MathF.Ceiling(this.Scanlines / 8F / this.MaxVerticalFactor);
+            this.McusPerColumn = (int)Numerics.DivideCeil((uint)this.PixelHeight, (uint)this.MaxVerticalFactor * 8);
 
             for (int i = 0; i < this.ComponentCount; i++)
             {
@@ -104,5 +112,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
                 component.Init();
             }
         }
+
+        public void AllocateComponents(bool fullScan)
+        {
+            for (int i = 0; i < this.ComponentCount; i++)
+            {
+                JpegComponent component = this.Components[i];
+                component.AllocateSpectral(fullScan);
+            }
+        }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs

@@ -1,181 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Buffers;
-using System.Numerics;
-using System.Threading;
-using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
-using SixLabors.ImageSharp.PixelFormats;
-using JpegColorConverter = SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters.JpegColorConverter;
-
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
-{
-    /// <summary>
-    /// Encapsulates the execution od post-processing algorithms to be applied on a <see cref="IRawJpegData"/> to produce a valid <see cref="Image{TPixel}"/>: <br/>
-    /// (1) Dequantization <br/>
-    /// (2) IDCT <br/>
-    /// (3) Color conversion form one of the <see cref="JpegColorSpace"/>-s into a <see cref="Vector4"/> buffer of RGBA values <br/>
-    /// (4) Packing <see cref="Image{TPixel}"/> pixels from the <see cref="Vector4"/> buffer. <br/>
-    /// These operations are executed in <see cref="NumberOfPostProcessorSteps"/> steps.
-    /// <see cref="PixelRowsPerStep"/> image rows are converted in one step,
-    /// which means that size of the allocated memory is limited (does not depend on <see cref="ImageFrame.Height"/>).
-    /// </summary>
-    internal class JpegImagePostProcessor : IDisposable
-    {
-        private readonly Configuration configuration;
-
-        /// <summary>
-        /// The number of block rows to be processed in one Step.
-        /// </summary>
-        public const int BlockRowsPerStep = 4;
-
-        /// <summary>
-        /// The number of image pixel rows to be processed in one step.
-        /// </summary>
-        public const int PixelRowsPerStep = 4 * 8;
-
-        /// <summary>
-        /// Temporal buffer to store a row of colors.
-        /// </summary>
-        private readonly IMemoryOwner<Vector4> rgbaBuffer;
-
-        /// <summary>
-        /// The <see cref="JpegColorConverter"/> corresponding to the current <see cref="JpegColorSpace"/> determined by <see cref="IRawJpegData.ColorSpace"/>.
-        /// </summary>
-        private readonly JpegColorConverter colorConverter;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="JpegImagePostProcessor"/> class.
-        /// </summary>
-        /// <param name="configuration">The <see cref="Configuration"/> to configure internal operations.</param>
-        /// <param name="rawJpeg">The <see cref="IRawJpegData"/> representing the uncompressed spectral Jpeg data</param>
-        public JpegImagePostProcessor(Configuration configuration, IRawJpegData rawJpeg)
-        {
-            this.configuration = configuration;
-            this.RawJpeg = rawJpeg;
-            IJpegComponent c0 = rawJpeg.Components[0];
-            this.NumberOfPostProcessorSteps = c0.SizeInBlocks.Height / BlockRowsPerStep;
-            this.PostProcessorBufferSize = new Size(c0.SizeInBlocks.Width * 8, PixelRowsPerStep);
-
-            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
-
-            this.ComponentProcessors = new JpegComponentPostProcessor[rawJpeg.Components.Length];
-            for (int i = 0; i < rawJpeg.Components.Length; i++)
-            {
-                this.ComponentProcessors[i] = new JpegComponentPostProcessor(memoryAllocator, this, rawJpeg.Components[i]);
-            }
-
-            this.rgbaBuffer = memoryAllocator.Allocate<Vector4>(rawJpeg.ImageSizeInPixels.Width);
-            this.colorConverter = JpegColorConverter.GetConverter(rawJpeg.ColorSpace, rawJpeg.Precision);
-        }
-
-        /// <summary>
-        /// Gets the <see cref="JpegComponentPostProcessor"/> instances.
-        /// </summary>
-        public JpegComponentPostProcessor[] ComponentProcessors { get; }
-
-        /// <summary>
-        /// Gets the <see cref="IRawJpegData"/> to be processed.
-        /// </summary>
-        public IRawJpegData RawJpeg { get; }
-
-        /// <summary>
-        /// Gets the total number of post processor steps deduced from the height of the image and <see cref="PixelRowsPerStep"/>.
-        /// </summary>
-        public int NumberOfPostProcessorSteps { get; }
-
-        /// <summary>
-        /// Gets the size of the temporary buffers we need to allocate into <see cref="JpegComponentPostProcessor.ColorBuffer"/>.
-        /// </summary>
-        public Size PostProcessorBufferSize { get; }
-
-        /// <summary>
-        /// Gets the value of the counter that grows by each step by <see cref="PixelRowsPerStep"/>.
-        /// </summary>
-        public int PixelRowCounter { get; private set; }
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            foreach (JpegComponentPostProcessor cpp in this.ComponentProcessors)
-            {
-                cpp.Dispose();
-            }
-
-            this.rgbaBuffer.Dispose();
-        }
-
-        /// <summary>
-        /// Process all pixels into 'destination'. The image dimensions should match <see cref="RawJpeg"/>.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type</typeparam>
-        /// <param name="destination">The destination image</param>
-        /// <param name="cancellationToken">The token to request cancellation.</param>
-        public void PostProcess<TPixel>(ImageFrame<TPixel> destination, CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            this.PixelRowCounter = 0;
-
-            if (this.RawJpeg.ImageSizeInPixels != destination.Size())
-            {
-                throw new ArgumentException("Input image is not of the size of the processed one!");
-            }
-
-            while (this.PixelRowCounter < this.RawJpeg.ImageSizeInPixels.Height)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-                this.DoPostProcessorStep(destination);
-            }
-        }
-
-        /// <summary>
-        /// Execute one step processing <see cref="PixelRowsPerStep"/> pixel rows into 'destination'.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type</typeparam>
-        /// <param name="destination">The destination image.</param>
-        public void DoPostProcessorStep<TPixel>(ImageFrame<TPixel> destination)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            foreach (JpegComponentPostProcessor cpp in this.ComponentProcessors)
-            {
-                cpp.CopyBlocksToColorBuffer();
-            }
-
-            this.ConvertColorsInto(destination);
-
-            this.PixelRowCounter += PixelRowsPerStep;
-        }
-
-        /// <summary>
-        /// Convert and copy <see cref="PixelRowsPerStep"/> row of colors into 'destination' starting at row <see cref="PixelRowCounter"/>.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel type</typeparam>
-        /// <param name="destination">The destination image</param>
-        private void ConvertColorsInto<TPixel>(ImageFrame<TPixel> destination)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            int maxY = Math.Min(destination.Height, this.PixelRowCounter + PixelRowsPerStep);
-
-            var buffers = new Buffer2D<float>[this.ComponentProcessors.Length];
-            for (int i = 0; i < this.ComponentProcessors.Length; i++)
-            {
-                buffers[i] = this.ComponentProcessors[i].ColorBuffer;
-            }
-
-            for (int yy = this.PixelRowCounter; yy < maxY; yy++)
-            {
-                int y = yy - this.PixelRowCounter;
-
-                var values = new JpegColorConverter.ComponentValues(buffers, y);
-                this.colorConverter.ConvertToRgba(values, this.rgbaBuffer.GetSpan());
-
-                Span<TPixel> destRow = destination.GetPixelRowSpan(yy);
-
-                // TODO: Investigate if slicing is actually necessary
-                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, this.rgbaBuffer.GetSpan().Slice(0, destRow.Length), destRow);
-            }
-        }
-    }
-}

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    /// <summary>
+    /// Converter used to convert jpeg spectral data.
+    /// </summary>
+    /// <remarks>
+    /// This is tightly coupled with <see cref="HuffmanScanDecoder"/> and <see cref="JpegDecoderCore"/>.
+    /// </remarks>
+    internal abstract class SpectralConverter
+    {
+        /// <summary>
+        /// Injects jpeg image decoding metadata.
+        /// </summary>
+        /// <remarks>
+        /// This is guaranteed to be called only once at SOF marker by <see cref="HuffmanScanDecoder"/>.
+        /// </remarks>
+        /// <param name="frame"><see cref="JpegFrame"/> instance containing decoder-specific parameters.</param>
+        /// <param name="jpegData"><see cref="IRawJpegData"/> instance containing decoder-specific parameters.</param>
+        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.
+        /// </summary>
+        /// <remarks>
+        /// Spectral 'stride' doesn't particularly mean 'single stride'.
+        /// Actual stride height depends on the subsampling factor of the given component.
+        /// </remarks>
+        public abstract void ConvertStrideBaseline();
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/SpectralConverter{TPixel}.cs

@@ -0,0 +1,146 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers;
+using System.Numerics;
+using System.Threading;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    internal sealed class SpectralConverter<TPixel> : SpectralConverter, IDisposable
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        private readonly Configuration configuration;
+
+        private CancellationToken cancellationToken;
+
+        private JpegComponentPostProcessor[] componentProcessors;
+
+        private JpegColorConverter colorConverter;
+
+        private IMemoryOwner<Vector4> rgbaBuffer;
+
+        private Buffer2D<TPixel> pixelBuffer;
+
+        private int blockRowsPerStep;
+
+        private int pixelRowsPerStep;
+
+        private int pixelRowCounter;
+
+        public SpectralConverter(Configuration configuration, CancellationToken cancellationToken)
+        {
+            this.configuration = configuration;
+            this.cancellationToken = cancellationToken;
+        }
+
+        private bool Converted => this.pixelRowCounter >= this.pixelBuffer.Height;
+
+        public Buffer2D<TPixel> PixelBuffer
+        {
+            get
+            {
+                if (!this.Converted)
+                {
+                    int steps = (int)Math.Ceiling(this.pixelBuffer.Height / (float)this.pixelRowsPerStep);
+
+                    for (int step = 0; step < steps; step++)
+                    {
+                        this.cancellationToken.ThrowIfCancellationRequested();
+                        this.ConvertNextStride(step);
+                    }
+                }
+
+                return this.pixelBuffer;
+            }
+        }
+
+        public override void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
+        {
+            MemoryAllocator allocator = this.configuration.MemoryAllocator;
+
+            // iteration data
+            IJpegComponent c0 = frame.Components[0];
+
+            const int blockPixelHeight = 8;
+            this.blockRowsPerStep = c0.SamplingFactors.Height;
+            this.pixelRowsPerStep = this.blockRowsPerStep * blockPixelHeight;
+
+            // pixel buffer for resulting image
+            this.pixelBuffer = allocator.Allocate2D<TPixel>(frame.PixelWidth, frame.PixelHeight, AllocationOptions.Clean);
+
+            // component processors from spectral to Rgba32
+            var postProcessorBufferSize = new Size(c0.SizeInBlocks.Width * 8, this.pixelRowsPerStep);
+            this.componentProcessors = new JpegComponentPostProcessor[frame.Components.Length];
+            for (int i = 0; i < this.componentProcessors.Length; i++)
+            {
+                this.componentProcessors[i] = new JpegComponentPostProcessor(allocator, jpegData, postProcessorBufferSize, frame.Components[i]);
+            }
+
+            // single 'stride' rgba32 buffer for conversion between spectral and TPixel
+            this.rgbaBuffer = allocator.Allocate<Vector4>(frame.PixelWidth);
+
+            // color converter from Rgba32 to TPixel
+            this.colorConverter = JpegColorConverter.GetConverter(jpegData.ColorSpace, frame.Precision);
+        }
+
+        public override void ConvertStrideBaseline()
+        {
+            // Convert next pixel stride using single spectral `stride'
+            // Note that zero passing eliminates the need of virtual call from JpegComponentPostProcessor
+            this.ConvertNextStride(spectralStep: 0);
+
+            // Clear spectral stride - this is VERY important as jpeg possibly won't fill entire buffer each stride
+            // Which leads to decoding artifacts
+            // Note that this code clears all buffers of the post processors, it's their responsibility to allocate only single stride
+            foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
+            {
+                cpp.ClearSpectralBuffers();
+            }
+        }
+
+        public void Dispose()
+        {
+            if (this.componentProcessors != null)
+            {
+                foreach (JpegComponentPostProcessor cpp in this.componentProcessors)
+                {
+                    cpp.Dispose();
+                }
+            }
+
+            this.rgbaBuffer?.Dispose();
+        }
+
+        private void ConvertNextStride(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;
+            }
+
+            for (int yy = this.pixelRowCounter; yy < maxY; yy++)
+            {
+                int y = yy - this.pixelRowCounter;
+
+                var values = new JpegColorConverter.ComponentValues(buffers, y);
+                this.colorConverter.ConvertToRgba(values, this.rgbaBuffer.GetSpan());
+
+                Span<TPixel> destRow = this.pixelBuffer.GetRowSpan(yy);
+
+                // TODO: Investigate if slicing is actually necessary
+                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, this.rgbaBuffer.GetSpan().Slice(0, destRow.Length), destRow);
+            }
+
+            this.pixelRowCounter += this.pixelRowsPerStep;
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -97,6 +97,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </summary>
         private AdobeMarker adobe;
 
+        /// <summary>
+        /// Scan decoder.
+        /// </summary>
+        private HuffmanScanDecoder scanDecoder;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegDecoderCore" /> class.
         /// </summary>
@@ -213,18 +218,23 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            this.ParseStream(stream, cancellationToken: cancellationToken);
+            using var spectralConverter = new SpectralConverter<TPixel>(this.Configuration, cancellationToken);
+
+            var scanDecoder = new HuffmanScanDecoder(stream, spectralConverter, cancellationToken);
+
+            this.ParseStream(stream, scanDecoder, cancellationToken);
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
             this.InitDerivedMetadataProperties();
-            return this.PostProcessIntoImage<TPixel>(cancellationToken);
+
+            return new Image<TPixel>(this.Configuration, spectralConverter.PixelBuffer, this.Metadata);
         }
 
         /// <inheritdoc/>
         public IImageInfo Identify(BufferedReadStream stream, CancellationToken cancellationToken)
         {
-            this.ParseStream(stream, true, cancellationToken);
+            this.ParseStream(stream, scanDecoder: null, cancellationToken);
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitIptcProfile();
@@ -234,13 +244,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         }
 
         /// <summary>
-        /// Parses the input stream for file markers
+        /// Parses the input stream for file markers.
         /// </summary>
-        /// <param name="stream">The input stream</param>
+        /// <param name="stream">The input stream.</param>
-        /// <param name="metadataOnly">Whether to decode metadata only.</param>
+        /// <param name="scanDecoder">Scan decoder used exclusively to decode SOS marker.</param>
         /// <param name="cancellationToken">The token to monitor cancellation.</param>
-        public void ParseStream(BufferedReadStream stream, bool metadataOnly = false, CancellationToken cancellationToken = default)
+        internal void ParseStream(BufferedReadStream stream, HuffmanScanDecoder scanDecoder, CancellationToken cancellationToken)
         {
+            bool metadataOnly = scanDecoder == null;
+
+            this.scanDecoder = scanDecoder;
+
             this.Metadata = new ImageMetadata();
 
             // Check for the Start Of Image marker.
@@ -852,19 +866,22 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 Extended = frameMarker.Marker == JpegConstants.Markers.SOF1,
                 Progressive = frameMarker.Marker == JpegConstants.Markers.SOF2,
                 Precision = this.temp[0],
-                Scanlines = (this.temp[1] << 8) | this.temp[2],
+                PixelHeight = (this.temp[1] << 8) | this.temp[2],
-                SamplesPerLine = (this.temp[3] << 8) | this.temp[4],
+                PixelWidth = (this.temp[3] << 8) | this.temp[4],
                 ComponentCount = this.temp[5]
             };
 
-            if (this.Frame.SamplesPerLine == 0 || this.Frame.Scanlines == 0)
+            if (this.Frame.PixelWidth == 0 || this.Frame.PixelHeight == 0)
             {
-                JpegThrowHelper.ThrowInvalidImageDimensions(this.Frame.SamplesPerLine, this.Frame.Scanlines);
+                JpegThrowHelper.ThrowInvalidImageDimensions(this.Frame.PixelWidth, this.Frame.PixelHeight);
             }
 
-            this.ImageSizeInPixels = new Size(this.Frame.SamplesPerLine, this.Frame.Scanlines);
+            this.ImageSizeInPixels = new Size(this.Frame.PixelWidth, this.Frame.PixelHeight);
             this.ComponentCount = this.Frame.ComponentCount;
 
+            this.ColorSpace = this.DeduceJpegColorSpace();
+            this.Metadata.GetJpegMetadata().ColorType = this.ColorSpace == JpegColorSpace.Grayscale ? JpegColorType.Luminance : JpegColorType.YCbCr;
+
             if (!metadataOnly)
             {
                 remaining -= length;
@@ -881,7 +898,6 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                 this.Frame.ComponentIds = new byte[this.ComponentCount];
                 this.Frame.ComponentOrder = new byte[this.ComponentCount];
                 this.Frame.Components = new JpegComponent[this.ComponentCount];
-                this.ColorSpace = this.DeduceJpegColorSpace();
 
                 int maxH = 0;
                 int maxV = 0;
@@ -912,10 +928,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
                 this.Frame.MaxHorizontalFactor = maxH;
                 this.Frame.MaxVerticalFactor = maxV;
-                this.ColorSpace = this.DeduceJpegColorSpace();
-                this.Metadata.GetJpegMetadata().ColorType = this.ColorSpace == JpegColorSpace.Grayscale ? JpegColorType.Luminance : JpegColorType.YCbCr;
                 this.Frame.InitComponents();
+
                 this.ImageSizeInMCU = new Size(this.Frame.McusPerLine, this.Frame.McusPerColumn);
+
+                // This can be injected in SOF marker callback
+                this.scanDecoder.InjectFrameData(this.Frame, this);
             }
         }
 
@@ -1016,6 +1034,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
 
             int selectorsCount = stream.ReadByte();
+            this.Frame.MultiScan = this.Frame.ComponentCount != selectorsCount;
             for (int i = 0; i < selectorsCount; i++)
             {
                 int componentIndex = -1;
@@ -1049,20 +1068,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             int spectralEnd = this.temp[1];
             int successiveApproximation = this.temp[2];
 
-            var sd = new HuffmanScanDecoder(
+            // All the comments below are for separate refactoring PR
-                stream,
+            // Main reason it's not fixed here is to make this commit less intrusive
-                this.Frame,
+
-                this.dcHuffmanTables,
+            // Huffman tables can be calculated directly in the scan decoder class
-                this.acHuffmanTables,
+            this.scanDecoder.DcHuffmanTables = this.dcHuffmanTables;
-                selectorsCount,
+            this.scanDecoder.AcHuffmanTables = this.acHuffmanTables;
-                this.resetInterval,
+
-                spectralStart,
+            // This can be injectd in DRI marker callback
-                spectralEnd,
+            this.scanDecoder.ResetInterval = this.resetInterval;
-                successiveApproximation >> 4,
+
-                successiveApproximation & 15,
+            // This can be passed as ParseEntropyCodedData() parameter as it is used only there
-                cancellationToken);
+            this.scanDecoder.ComponentsLength = selectorsCount;
-
+
-            sd.ParseEntropyCodedData();
+            // This is okay to inject here, might be good to wrap it in a separate struct but not really necessary
+            this.scanDecoder.SpectralStart = spectralStart;
+            this.scanDecoder.SpectralEnd = spectralEnd;
+            this.scanDecoder.SuccessiveHigh = successiveApproximation >> 4;
+            this.scanDecoder.SuccessiveLow = successiveApproximation & 15;
+
+            this.scanDecoder.ParseEntropyCodedData();
         }
 
         /// <summary>
@@ -1087,32 +1112,5 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             stream.Read(this.markerBuffer, 0, 2);
             return BinaryPrimitives.ReadUInt16BigEndian(this.markerBuffer);
         }
-
-        /// <summary>
-        /// Post processes the pixels into the destination image.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        private Image<TPixel> PostProcessIntoImage<TPixel>(CancellationToken cancellationToken)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            if (this.ImageWidth == 0 || this.ImageHeight == 0)
-            {
-                JpegThrowHelper.ThrowInvalidImageDimensions(this.ImageWidth, this.ImageHeight);
-            }
-
-            var image = Image.CreateUninitialized<TPixel>(
-                this.Configuration,
-                this.ImageWidth,
-                this.ImageHeight,
-                this.Metadata);
-
-            using (var postProcessor = new JpegImagePostProcessor(this.Configuration, this))
-            {
-                postProcessor.PostProcess(image.Frames.RootFrame, cancellationToken);
-            }
-
-            return image;
-        }
     }
 }

src/ImageSharp/Image{TPixel}.cs

@@ -87,6 +87,21 @@ namespace SixLabors.ImageSharp
             this.frames = new ImageFrameCollection<TPixel>(this, width, height, default(TPixel));
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Image{TPixel}"/> class
+        /// wrapping an external <see cref="Buffer2D{TPixel}"/> pixel bufferx.
+        /// </summary>
+        /// <param name="configuration">The configuration providing initialization code which allows extending the library.</param>
+        /// <param name="pixelBuffer">Pixel buffer.</param>
+        /// <param name="metadata">The images metadata.</param>
+        internal Image(
+            Configuration configuration,
+            Buffer2D<TPixel> pixelBuffer,
+            ImageMetadata metadata)
+            : this(configuration, pixelBuffer.FastMemoryGroup, pixelBuffer.Width, pixelBuffer.Height, metadata)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Image{TPixel}"/> class
         /// wrapping an external <see cref="MemoryGroup{T}"/>.

tests/ImageSharp.Benchmarks/Codecs/Jpeg/DecodeJpegParseStreamOnly.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using BenchmarkDotNet.Attributes;
 using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Tests;
 using SDSize = System.Drawing.Size;
@@ -39,21 +40,46 @@ namespace SixLabors.ImageSharp.Benchmarks.Codecs.Jpeg
             using var bufferedStream = new BufferedReadStream(Configuration.Default, memoryStream);
 
             var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder { IgnoreMetadata = true });
-            decoder.ParseStream(bufferedStream);
+            var scanDecoder = new HuffmanScanDecoder(bufferedStream, new NoopSpectralConverter(), cancellationToken: default);
+            decoder.ParseStream(bufferedStream, scanDecoder, cancellationToken: default);
             decoder.Dispose();
         }
-    }
 
-    /*
+        // We want to test only stream parsing and scan decoding, we don't need to convert spectral data to actual pixels
-    |                      Method |        Job |       Runtime |            TestImage |     Mean |     Error |    StdDev | Ratio |   Gen 0 | Gen 1 | Gen 2 | Allocated |
+        // Nor we need to allocate final pixel buffer
-    |---------------------------- |----------- |-------------- |--------------------- |---------:|----------:|----------:|------:|--------:|------:|------:|----------:|
+        // Note: this still introduces virtual method call overhead for baseline interleaved images
-    |       'System.Drawing FULL' | Job-HITJFX |    .NET 4.7.2 | Jpg/b(...)e.jpg [21] | 5.828 ms | 0.9885 ms | 0.0542 ms |  1.00 | 46.8750 |     - |     - |  211566 B |
+        // There's no way to eliminate it as spectral conversion is built into the scan decoding loop for memory footprint reduction
-    | JpegDecoderCore.ParseStream | Job-HITJFX |    .NET 4.7.2 | Jpg/b(...)e.jpg [21] | 5.833 ms | 0.2923 ms | 0.0160 ms |  1.00 |       - |     - |     - |   12416 B |
+        private class NoopSpectralConverter : SpectralConverter
-    |                             |            |               |                      |          |           |           |       |         |       |       |           |
+        {
-    |       'System.Drawing FULL' | Job-WPSKZD | .NET Core 2.1 | Jpg/b(...)e.jpg [21] | 6.018 ms | 2.1374 ms | 0.1172 ms |  1.00 | 46.8750 |     - |     - |  210768 B |
+            public override void ConvertStrideBaseline()
-    | JpegDecoderCore.ParseStream | Job-WPSKZD | .NET Core 2.1 | Jpg/b(...)e.jpg [21] | 4.382 ms | 0.9009 ms | 0.0494 ms |  0.73 |       - |     - |     - |   12360 B |
+            {
-    |                             |            |               |                      |          |           |           |       |         |       |       |           |
+            }
-    |       'System.Drawing FULL' | Job-ZLSNRP | .NET Core 3.1 | Jpg/b(...)e.jpg [21] | 5.714 ms | 0.4078 ms | 0.0224 ms |  1.00 |       - |     - |     - |     176 B |
+
-    | JpegDecoderCore.ParseStream | Job-ZLSNRP | .NET Core 3.1 | Jpg/b(...)e.jpg [21] | 4.239 ms | 1.0943 ms | 0.0600 ms |  0.74 |       - |     - |     - |   12406 B |
+            public override void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
-    */
+            {
+            }
+        }
+    }
 }
+
+/*
+BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19042.1083 (20H2/October2020Update)
+Intel Core i7-6700K CPU 4.00GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
+.NET SDK=6.0.100-preview.3.21202.5
+  [Host]     : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
+  Job-VAJCIU : .NET Core 2.1.26 (CoreCLR 4.6.29812.02, CoreFX 4.6.29812.01), X64 RyuJIT
+  Job-INPXCR : .NET Core 3.1.13 (CoreCLR 4.700.21.11102, CoreFX 4.700.21.11602), X64 RyuJIT
+  Job-JRCLOJ : .NET Framework 4.8 (4.8.4390.0), X64 RyuJIT
+
+IterationCount=3  LaunchCount=1  WarmupCount=3
+|                      Method |        Job |              Runtime |             TestImage |     Mean |     Error |    StdDev | Ratio |   Gen 0 | Gen 1 | Gen 2 | Allocated |
+|---------------------------- |----------- |--------------------- |---------------------- |---------:|----------:|----------:|------:|--------:|------:|------:|----------:|
+|       'System.Drawing FULL' | Job-VAJCIU |        .NET Core 2.1 | Jpg/baseline/Lake.jpg | 5.196 ms | 0.7520 ms | 0.0412 ms |  1.00 | 46.8750 |     - |     - | 210,768 B |
+| JpegDecoderCore.ParseStream | Job-VAJCIU |        .NET Core 2.1 | Jpg/baseline/Lake.jpg | 3.467 ms | 0.0784 ms | 0.0043 ms |  0.67 |       - |     - |     - |  12,416 B |
+|                             |            |                      |                       |          |           |           |       |         |       |       |           |
+|       'System.Drawing FULL' | Job-INPXCR |        .NET Core 3.1 | Jpg/baseline/Lake.jpg | 5.201 ms | 0.4105 ms | 0.0225 ms |  1.00 |       - |     - |     - |     183 B |
+| JpegDecoderCore.ParseStream | Job-INPXCR |        .NET Core 3.1 | Jpg/baseline/Lake.jpg | 3.349 ms | 0.0468 ms | 0.0026 ms |  0.64 |       - |     - |     - |  12,408 B |
+|                             |            |                      |                       |          |           |           |       |         |       |       |           |
+|       'System.Drawing FULL' | Job-JRCLOJ | .NET Framework 4.7.2 | Jpg/baseline/Lake.jpg | 5.164 ms | 0.6524 ms | 0.0358 ms |  1.00 | 46.8750 |     - |     - | 211,571 B |
+| JpegDecoderCore.ParseStream | Job-JRCLOJ | .NET Framework 4.7.2 | Jpg/baseline/Lake.jpg | 4.548 ms | 0.3357 ms | 0.0184 ms |  0.88 |       - |     - |     - |  12,480 B |
+*/

tests/ImageSharp.Tests.ProfilingSandbox/Program.cs

@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Diagnostics;
 using SixLabors.ImageSharp.Tests.Formats.Jpg;
 using SixLabors.ImageSharp.Tests.PixelFormats.PixelOperations;
 using SixLabors.ImageSharp.Tests.ProfilingBenchmarks;

tests/ImageSharp.Tests/Common/NumericsTests.cs

@@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Tests.Common
             int expected = 0;
             int actual = Numerics.Log2(value);
 
-            Assert.True(expected == actual, $"Expected: {expected}, Actual: {actual}");
+            Assert.Equal(expected, actual);
         }
 
         [Fact]
@@ -47,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests.Common
                 int expected = i;
                 int actual = Numerics.Log2(value);
 
-                Assert.True(expected == actual, $"Expected: {expected}, Actual: {actual}");
+                Assert.Equal(expected, actual);
             }
         }
 
@@ -66,7 +66,35 @@ namespace SixLabors.ImageSharp.Tests.Common
                 int expected = Log2_ReferenceImplementation(value);
                 int actual = Numerics.Log2(value);
 
-                Assert.True(expected == actual, $"Expected: {expected}, Actual: {actual}");
+                Assert.Equal(expected, actual);
+            }
+        }
+
+        private static uint DivideCeil_ReferenceImplementation(uint value, uint divisor) => (uint)MathF.Ceiling((float)value / divisor);
+
+        [Fact]
+        public void DivideCeil_DivideZero()
+        {
+            uint expected = 0;
+            uint actual = Numerics.DivideCeil(0, 100);
+
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(1, 100)]
+        public void DivideCeil_RandomValues(int seed, int count)
+        {
+            var rng = new Random(seed);
+            for (int i = 0; i < count; i++)
+            {
+                uint value = (uint)rng.Next();
+                uint divisor = (uint)rng.Next();
+
+                uint expected = DivideCeil_ReferenceImplementation(value, divisor);
+                uint actual = Numerics.DivideCeil(value, divisor);
+
+                Assert.True(expected == actual, $"Expected: {expected}\nActual: {actual}\n{value} / {divisor} = {expected}");
             }
         }
     }

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs

@@ -17,8 +17,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 TestImages.Jpeg.Baseline.Jpeg400,
                 TestImages.Jpeg.Baseline.Turtle420,
                 TestImages.Jpeg.Baseline.Testorig420,
-
-                // BUG: The following image has a high difference compared to the expected output: 1.0096%
                 TestImages.Jpeg.Baseline.Jpeg420Small,
                 TestImages.Jpeg.Issues.Fuzz.AccessViolationException922,
                 TestImages.Jpeg.Baseline.Jpeg444,
@@ -101,7 +99,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 [TestImages.Jpeg.Baseline.Bad.BadRST] = 0.0589f / 100,
 
                 [TestImages.Jpeg.Baseline.Testorig420] = 0.38f / 100,
-                [TestImages.Jpeg.Baseline.Jpeg420Small] = 1.1f / 100,
+                [TestImages.Jpeg.Baseline.Jpeg420Small] = 0.287f / 100,
                 [TestImages.Jpeg.Baseline.Turtle420] = 1.0f / 100,
 
                 // Progressive:

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs

@@ -6,7 +6,6 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.IO;
 using SixLabors.ImageSharp.Memory;
@@ -79,7 +78,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             using var ms = new MemoryStream(bytes);
             using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
             var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
-            decoder.ParseStream(bufferedStream);
+            using Image<Rgba32> image = decoder.Decode<Rgba32>(bufferedStream, cancellationToken: default);
 
             // I don't know why these numbers are different. All I know is that the decoder works
             // and spectral data is exactly correct also.
@@ -132,10 +131,10 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [InlineData(0)]
         [InlineData(0.5)]
         [InlineData(0.9)]
-        public async Task Decode_IsCancellable(int percentageOfStreamReadToCancel)
+        public async Task DecodeAsync_IsCancellable(int percentageOfStreamReadToCancel)
         {
             var cts = new CancellationTokenSource();
-            var file = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Jpeg.Baseline.Jpeg420Small);
+            string file = Path.Combine(TestEnvironment.InputImagesDirectoryFullPath, TestImages.Jpeg.Baseline.Jpeg420Small);
             using var pausedStream = new PausedStream(file);
             pausedStream.OnWaiting(s =>
             {

tests/ImageSharp.Tests/Formats/Jpg/JpegImagePostProcessorTests.cs

@@ -1,97 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-using SixLabors.ImageSharp.Formats.Jpeg;
-using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
-using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils;
-using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
-
-using Xunit;
-using Xunit.Abstractions;
-
-namespace SixLabors.ImageSharp.Tests.Formats.Jpg
-{
-    [Trait("Format", "Jpg")]
-    public class JpegImagePostProcessorTests
-    {
-        public static string[] BaselineTestJpegs =
-            {
-                TestImages.Jpeg.Baseline.Calliphora,
-                TestImages.Jpeg.Baseline.Cmyk,
-                TestImages.Jpeg.Baseline.Ycck,
-                TestImages.Jpeg.Baseline.Jpeg400,
-                TestImages.Jpeg.Baseline.Testorig420,
-                TestImages.Jpeg.Baseline.Jpeg444,
-            };
-
-        public JpegImagePostProcessorTests(ITestOutputHelper output)
-        {
-            this.Output = output;
-        }
-
-        private ITestOutputHelper Output { get; }
-
-        private static void SaveBuffer<TPixel>(JpegComponentPostProcessor cp, TestImageProvider<TPixel> provider)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            using (Image<Rgba32> image = cp.ColorBuffer.ToGrayscaleImage(1f / 255f))
-            {
-                image.DebugSave(provider, $"-C{cp.Component.Index}-");
-            }
-        }
-
-        [Theory]
-        [WithFile(TestImages.Jpeg.Baseline.Calliphora, PixelTypes.Rgba32)]
-        [WithFile(TestImages.Jpeg.Baseline.Testorig420, PixelTypes.Rgba32)]
-        public void DoProcessorStep<TPixel>(TestImageProvider<TPixel> provider)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            string imageFile = provider.SourceFileOrDescription;
-            using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile))
-            using (var pp = new JpegImagePostProcessor(Configuration.Default, decoder))
-            using (var imageFrame = new ImageFrame<Rgba32>(Configuration.Default, decoder.ImageWidth, decoder.ImageHeight))
-            {
-                pp.DoPostProcessorStep(imageFrame);
-
-                JpegComponentPostProcessor[] cp = pp.ComponentProcessors;
-
-                SaveBuffer(cp[0], provider);
-                SaveBuffer(cp[1], provider);
-                SaveBuffer(cp[2], provider);
-            }
-        }
-
-        [Theory]
-        [WithFileCollection(nameof(BaselineTestJpegs), PixelTypes.Rgba32)]
-        public void PostProcess<TPixel>(TestImageProvider<TPixel> provider)
-            where TPixel : unmanaged, IPixel<TPixel>
-        {
-            string imageFile = provider.SourceFileOrDescription;
-            using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile))
-            using (var pp = new JpegImagePostProcessor(Configuration.Default, decoder))
-            using (var image = new Image<Rgba32>(decoder.ImageWidth, decoder.ImageHeight))
-            {
-                pp.PostProcess(image.Frames.RootFrame, default);
-
-                image.DebugSave(provider);
-
-                ImagingTestCaseUtility testUtil = provider.Utility;
-                testUtil.TestGroupName = nameof(JpegDecoderTests);
-                testUtil.TestName = JpegDecoderTests.DecodeBaselineJpegOutputName;
-
-                using (Image<TPixel> referenceImage =
-                    provider.GetReferenceOutputImage<TPixel>(appendPixelTypeToFileName: false))
-                {
-                    ImageSimilarityReport report = ImageComparer.Exact.CompareImagesOrFrames(referenceImage, image);
-
-                    this.Output.WriteLine($"*** {imageFile} ***");
-                    this.Output.WriteLine($"Difference: {report.DifferencePercentageString}");
-
-                    // ReSharper disable once PossibleInvalidOperationException
-                    Assert.True(report.TotalNormalizedDifference.Value < 0.005f);
-                }
-            }
-        }
-    }
-}

tests/ImageSharp.Tests/Formats/Jpg/ParseStreamTests.cs

@@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         {
             var expectedColorSpace = (JpegColorSpace)expectedColorSpaceValue;
 
-            using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile))
+            using (JpegDecoderCore decoder = JpegFixture.ParseJpegStream(imageFile, metaDataOnly: true))
             {
                 Assert.Equal(expectedColorSpace, decoder.ColorSpace);
             }

tests/ImageSharp.Tests/Formats/Jpg/SpectralJpegTests.cs

@@ -4,9 +4,12 @@
 using System;
 using System.IO;
 using System.Linq;
-
+using System.Threading;
 using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
 using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils;
 
@@ -44,20 +47,25 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         public static readonly string[] AllTestJpegs = BaselineTestJpegs.Concat(ProgressiveTestJpegs).ToArray();
 
         [Theory(Skip = "Debug only, enable manually!")]
+        //[Theory]
         [WithFileCollection(nameof(AllTestJpegs), PixelTypes.Rgba32)]
         public void Decoder_ParseStream_SaveSpectralResult<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
+            // Calculating data from ImageSharp
-
             byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
 
+            var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
             using var ms = new MemoryStream(sourceBytes);
             using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
-            decoder.ParseStream(bufferedStream);
 
-            var data = LibJpegTools.SpectralData.LoadFromImageSharpDecoder(decoder);
+            // internal scan decoder which we substitute to assert spectral correctness
-            VerifyJpeg.SaveSpectralImage(provider, data);
+            var debugConverter = new DebugSpectralConverter<TPixel>();
+            var scanDecoder = new HuffmanScanDecoder(bufferedStream, debugConverter, cancellationToken: default);
+
+            // This would parse entire image
+            decoder.ParseStream(bufferedStream, scanDecoder, cancellationToken: default);
+            VerifyJpeg.SaveSpectralImage(provider, debugConverter.SpectralData);
         }
 
         [Theory]
@@ -70,25 +78,31 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 return;
             }
 
-            var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
+            // Expected data from libjpeg
+            LibJpegTools.SpectralData libJpegData = LibJpegTools.ExtractSpectralData(provider.SourceFileOrDescription);
 
+            // Calculating data from ImageSharp
             byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
 
+            var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
             using var ms = new MemoryStream(sourceBytes);
             using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
-            decoder.ParseStream(bufferedStream);
 
-            var imageSharpData = LibJpegTools.SpectralData.LoadFromImageSharpDecoder(decoder);
+            // internal scan decoder which we substitute to assert spectral correctness
-            this.VerifySpectralCorrectnessImpl(provider, imageSharpData);
+            var debugConverter = new DebugSpectralConverter<TPixel>();
+            var scanDecoder = new HuffmanScanDecoder(bufferedStream, debugConverter, cancellationToken: default);
+
+            // This would parse entire image
+            decoder.ParseStream(bufferedStream, scanDecoder, cancellationToken: default);
+
+            // Actual verification
+            this.VerifySpectralCorrectnessImpl(libJpegData, debugConverter.SpectralData);
         }
 
-        private void VerifySpectralCorrectnessImpl<TPixel>(
+        private void VerifySpectralCorrectnessImpl(
-            TestImageProvider<TPixel> provider,
+            LibJpegTools.SpectralData libJpegData,
             LibJpegTools.SpectralData imageSharpData)
-            where TPixel : unmanaged, IPixel<TPixel>
         {
-            LibJpegTools.SpectralData libJpegData = LibJpegTools.ExtractSpectralData(provider.SourceFileOrDescription);
-
             bool equality = libJpegData.Equals(imageSharpData);
             this.Output.WriteLine("Spectral data equality: " + equality);
 
@@ -108,11 +122,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 LibJpegTools.ComponentData libJpegComponent = libJpegData.Components[i];
                 LibJpegTools.ComponentData imageSharpComponent = imageSharpData.Components[i];
 
-                (double total, double average) diff = LibJpegTools.CalculateDifference(libJpegComponent, imageSharpComponent);
+                (double total, double average) = LibJpegTools.CalculateDifference(libJpegComponent, imageSharpComponent);
 
-                this.Output.WriteLine($"Component{i}: {diff}");
+                this.Output.WriteLine($"Component{i}: [total: {total} | average: {average}]");
-                averageDifference += diff.average;
+                averageDifference += average;
-                totalDifference += diff.total;
+                totalDifference += total;
                 tolerance += libJpegComponent.SpectralBlocks.DangerousGetSingleSpan().Length;
             }
 
@@ -126,5 +140,71 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 
             Assert.True(totalDifference < tolerance);
         }
+
+        private class DebugSpectralConverter<TPixel> : SpectralConverter
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            private JpegFrame frame;
+
+            private LibJpegTools.SpectralData spectralData;
+
+            private int baselineScanRowCounter;
+
+            public LibJpegTools.SpectralData SpectralData
+            {
+                get
+                {
+                    // Due to underlying architecture, baseline interleaved jpegs would inject spectral data during parsing
+                    // Progressive and multi-scan images must be loaded manually
+                    if (this.frame.Progressive || this.frame.MultiScan)
+                    {
+                        LibJpegTools.ComponentData[] components = this.spectralData.Components;
+                        for (int i = 0; i < components.Length; i++)
+                        {
+                            components[i].LoadSpectral(this.frame.Components[i]);
+                        }
+                    }
+
+                    return this.spectralData;
+                }
+            }
+
+            public override void ConvertStrideBaseline()
+            {
+                // This would be called only for baseline non-interleaved images
+                // We must copy spectral strides here
+                LibJpegTools.ComponentData[] components = this.spectralData.Components;
+                for (int i = 0; i < components.Length; i++)
+                {
+                    components[i].LoadSpectralStride(this.frame.Components[i].SpectralBlocks, this.baselineScanRowCounter);
+                }
+
+                this.baselineScanRowCounter++;
+
+                // As spectral buffers are reused for each stride decoding - we need to manually clear it like it's done in SpectralConverter<TPixel>
+                foreach (JpegComponent component in this.frame.Components)
+                {
+                    Buffer2D<Block8x8> spectralBlocks = component.SpectralBlocks;
+                    for (int i = 0; i < spectralBlocks.Height; i++)
+                    {
+                        spectralBlocks.GetRowSpan(i).Clear();
+                    }
+                }
+            }
+
+            public override void InjectFrameData(JpegFrame frame, IRawJpegData jpegData)
+            {
+                this.frame = frame;
+
+                var spectralComponents = new LibJpegTools.ComponentData[frame.ComponentCount];
+                for (int i = 0; i < spectralComponents.Length; i++)
+                {
+                    JpegComponent component = frame.Components[i];
+                    spectralComponents[i] = new LibJpegTools.ComponentData(component.WidthInBlocks, component.HeightInBlocks, component.Index);
+                }
+
+                this.spectralData = new LibJpegTools.SpectralData(spectralComponents);
+            }
+        }
     }
 }

tests/ImageSharp.Tests/Formats/Jpg/SpectralToPixelConversionTests.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.IO;
+using System.Linq;
+using SixLabors.ImageSharp.Formats.Jpeg;
+using SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder;
+using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace SixLabors.ImageSharp.Tests.Formats.Jpg
+{
+    [Trait("Format", "Jpg")]
+    public class SpectralToPixelConversionTests
+    {
+        public static readonly string[] BaselineTestJpegs =
+            {
+                TestImages.Jpeg.Baseline.Calliphora, TestImages.Jpeg.Baseline.Cmyk, TestImages.Jpeg.Baseline.Jpeg400,
+                TestImages.Jpeg.Baseline.Jpeg444, TestImages.Jpeg.Baseline.Testorig420,
+                TestImages.Jpeg.Baseline.Jpeg420Small, TestImages.Jpeg.Baseline.Bad.BadEOF,
+                TestImages.Jpeg.Baseline.MultiScanBaselineCMYK
+            };
+
+        public SpectralToPixelConversionTests(ITestOutputHelper output)
+        {
+            this.Output = output;
+        }
+
+        private ITestOutputHelper Output { get; }
+
+        [Theory]
+        [WithFileCollection(nameof(BaselineTestJpegs), PixelTypes.Rgba32)]
+        public void Decoder_PixelBufferComparison<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            // Stream
+            byte[] sourceBytes = TestFile.Create(provider.SourceFileOrDescription).Bytes;
+            using var ms = new MemoryStream(sourceBytes);
+            using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
+
+            // Decoding
+            using var converter = new SpectralConverter<TPixel>(Configuration.Default, cancellationToken: default);
+            var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
+            var scanDecoder = new HuffmanScanDecoder(bufferedStream, converter, cancellationToken: default);
+            decoder.ParseStream(bufferedStream, scanDecoder, cancellationToken: default);
+
+            // Test metadata
+            provider.Utility.TestGroupName = nameof(JpegDecoderTests);
+            provider.Utility.TestName = JpegDecoderTests.DecodeBaselineJpegOutputName;
+
+            // Comparison
+            using (Image<TPixel> image = new Image<TPixel>(Configuration.Default, converter.PixelBuffer, new ImageMetadata()))
+            using (Image<TPixel> referenceImage = provider.GetReferenceOutputImage<TPixel>(appendPixelTypeToFileName: false))
+            {
+                ImageSimilarityReport report = ImageComparer.Exact.CompareImagesOrFrames(referenceImage, image);
+
+                this.Output.WriteLine($"*** {provider.SourceFileOrDescription} ***");
+                this.Output.WriteLine($"Difference: {report.DifferencePercentageString}");
+
+                // ReSharper disable once PossibleInvalidOperationException
+                Assert.True(report.TotalNormalizedDifference.Value < 0.005f);
+            }
+        }
+    }
+}

tests/ImageSharp.Tests/Formats/Jpg/Utils/JpegFixture.cs

@@ -9,6 +9,7 @@ using System.Text;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.IO;
+using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -196,7 +197,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils
             using var bufferedStream = new BufferedReadStream(Configuration.Default, ms);
 
             var decoder = new JpegDecoderCore(Configuration.Default, new JpegDecoder());
-            decoder.ParseStream(bufferedStream, metaDataOnly);
+            if (metaDataOnly)
+            {
+                decoder.Identify(bufferedStream, cancellationToken: default);
+            }
+            else
+            {
+                using Image<Rgba32> image = decoder.Decode<Rgba32>(bufferedStream, cancellationToken: default);
+            }
 
             return decoder;
         }

tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.ComponentData.cs

@@ -56,23 +56,48 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils
                 this.SpectralBlocks[x, y] = new Block8x8(data);
             }
 
-            public static ComponentData Load(JpegComponent c, int index)
+            public void LoadSpectralStride(Buffer2D<Block8x8> data, int strideIndex)
             {
-                var result = new ComponentData(
+                int startIndex = strideIndex * data.Height;
-                    c.WidthInBlocks,
+
-                    c.HeightInBlocks,
+                int endIndex = Math.Min(this.HeightInBlocks, startIndex + data.Height);
-                    index);
 
-                for (int y = 0; y < result.HeightInBlocks; y++)
+                for (int y = startIndex; y < endIndex; y++)
                 {
-                    Span<Block8x8> blockRow = c.SpectralBlocks.GetRowSpan(y);
+                    Span<Block8x8> blockRow = data.GetRowSpan(y - startIndex);
-                    for (int x = 0; x < result.WidthInBlocks; x++)
+                    for (int x = 0; x < this.WidthInBlocks; x++)
                     {
-                        short[] data = blockRow[x].ToArray();
+                        short[] block = blockRow[x].ToArray();
-                        result.MakeBlock(data, y, x);
+
+                        // x coordinate stays the same - we load entire stride
+                        // y coordinate is tricky as we load single stride to full buffer - offset is needed
+                        this.MakeBlock(block, y, x);
                     }
                 }
+            }
+
+            public void LoadSpectral(JpegComponent c)
+            {
+                Buffer2D<Block8x8> data = c.SpectralBlocks;
+                for (int y = 0; y < this.HeightInBlocks; y++)
+                {
+                    Span<Block8x8> blockRow = data.GetRowSpan(y);
+                    for (int x = 0; x < this.WidthInBlocks; x++)
+                    {
+                        short[] block = blockRow[x].ToArray();
+                        this.MakeBlock(block, y, x);
+                    }
+                }
+            }
+
+            public static ComponentData Load(JpegComponent c, int index)
+            {
+                var result = new ComponentData(
+                    c.WidthInBlocks,
+                    c.HeightInBlocks,
+                    index);
 
+                result.LoadSpectral(c);
                 return result;
             }
 

tests/ImageSharp.Tests/Formats/Jpg/Utils/LibJpegTools.SpectralData.cs

@@ -29,14 +29,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg.Utils
                 this.Components = components;
             }
 
-            public static SpectralData LoadFromImageSharpDecoder(JpegDecoderCore decoder)
-            {
-                JpegComponent[] srcComponents = decoder.Frame.Components;
-                LibJpegTools.ComponentData[] destComponents = srcComponents.Select(LibJpegTools.ComponentData.Load).ToArray();
-
-                return new SpectralData(destComponents);
-            }
-
             public Image<Rgba32> TryCreateRGBSpectralImage()
             {
                 if (this.ComponentCount != 3)

tests/Images/External/ReferenceOutput/JpegDecoderTests/DecodeBaselineJpeg_jpeg420small.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a76832570111a868ea6cb6e8287aae1976c575c94c63880c74346a4b5db5d305
+oid sha256:2b5e1d91fb6dc1ddb696fbee63331ba9c6ef3548b619c005887e60c5b01f4981
-size 27007
+size 27303