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

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

@@ -109,10 +109,10 @@ public void Dispose()
         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 @@ public void Init()
             {
                 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 width = this.WidthInBlocks + 1;
-            int height = totalNumberOfBlocks / width;
+            int spectralAllocWidth = this.SizeInBlocks.Width;
+            int spectralAllocHeight = fullScan ? this.SizeInBlocks.Height : this.VerticalSamplingFactor;
 
-            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,9 +2,6 @@
 // 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
@@ -27,23 +24,20 @@ internal class JpegComponentPostProcessor : IDisposable
         /// <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,
-                imagePostProcessor.PostProcessorBufferSize.Height,
+                postProcessorBufferSize.Width,
+                postProcessorBufferSize.Height,
                 this.blockAreaSize.Height);
 
-            this.BlockRowsPerStep = JpegImagePostProcessor.BlockRowsPerStep / this.Component.SubSamplingDivisors.Height;
+            this.BlockRowsPerStep = postProcessorBufferSize.Height / 8 / this.Component.SubSamplingDivisors.Height;
         }
 
-        /// <summary>
-        /// Gets the <see cref="JpegImagePostProcessor"/>
-        /// </summary>
-        public JpegImagePostProcessor ImagePostProcessor { get; }
+        public IRawJpegData RawJpeg { get; }
 
         /// <summary>
         /// Gets the <see cref="Component"/>
@@ -66,37 +60,38 @@ public JpegComponentPostProcessor(MemoryAllocator memoryAllocator, JpegImagePost
         public int BlockRowsPerStep { get; }
 
         /// <inheritdoc />
-        public void Dispose()
-        {
-            this.ColorBuffer.Dispose();
-        }
+        public void 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);
-            float maximumValue = MathF.Pow(2, this.ImagePostProcessor.RawJpeg.Precision) - 1;
+            Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
+
+            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;
                 }
 
                 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 @@ public void CopyBlocksToColorBuffer()
                     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

@@ -28,12 +28,12 @@ internal sealed class JpegFrame : IDisposable
         /// <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,14 +95,23 @@ public void Dispose()
         /// </summary>
         public void InitComponents()
         {
-            this.McusPerLine = (int)MathF.Ceiling(this.SamplesPerLine / 8F / this.MaxHorizontalFactor);
-            this.McusPerColumn = (int)MathF.Ceiling(this.Scanlines / 8F / this.MaxVerticalFactor);
+            this.McusPerLine = (int)MathF.Ceiling(this.PixelWidth / 8F / this.MaxHorizontalFactor);
+            this.McusPerColumn = (int)MathF.Ceiling(this.PixelHeight / 8F / this.MaxVerticalFactor);
 
             for (int i = 0; i < this.ComponentCount; i++)
             {
                 JpegComponent component = this.Components[i];
                 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

@@ -5,7 +5,6 @@
 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;
@@ -19,7 +18,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// (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,
+    /// <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
@@ -29,12 +28,12 @@ internal class JpegImagePostProcessor : IDisposable
         /// <summary>
         /// The number of block rows to be processed in one Step.
         /// </summary>
-        public const int BlockRowsPerStep = 4;
+        private readonly int blockRowsPerStep;
 
         /// <summary>
         /// The number of image pixel rows to be processed in one step.
         /// </summary>
-        public const int PixelRowsPerStep = 4 * 8;
+        private readonly int pixelRowsPerStep;
 
         /// <summary>
         /// Temporal buffer to store a row of colors.
@@ -56,15 +55,18 @@ 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.blockRowsPerStep = c0.SamplingFactors.Height;
+            this.pixelRowsPerStep = this.blockRowsPerStep * 8;
+
+            this.NumberOfPostProcessorSteps = c0.SizeInBlocks.Height / this.blockRowsPerStep;
 
+            var postProcessorBufferSize = new Size(c0.SizeInBlocks.Width * 8, this.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.ComponentProcessors[i] = new JpegComponentPostProcessor(memoryAllocator, this.RawJpeg, postProcessorBufferSize, rawJpeg.Components[i]);
             }
 
             this.rgbaBuffer = memoryAllocator.Allocate<Vector4>(rawJpeg.ImageSizeInPixels.Width);
@@ -82,17 +84,12 @@ public JpegImagePostProcessor(Configuration configuration, IRawJpegData rawJpeg)
         public IRawJpegData RawJpeg { get; }
 
         /// <summary>
-        /// Gets the total number of post processor steps deduced from the height of the image and <see cref="PixelRowsPerStep"/>.
+        /// 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"/>.
+        /// Gets the value of the counter that grows by each step by <see cref="pixelRowsPerStep"/>.
         /// </summary>
         public int PixelRowCounter { get; private set; }
 
@@ -131,36 +128,20 @@ public void PostProcess<TPixel>(ImageFrame<TPixel> destination, CancellationToke
         }
 
         /// <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"/>.
+        /// Execute one step processing <see cref="pixelRowsPerStep"/> pixel rows into 'destination'.
+        /// 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)
+        public void DoPostProcessorStep<TPixel>(ImageFrame<TPixel> destination)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            int maxY = Math.Min(destination.Height, this.PixelRowCounter + PixelRowsPerStep);
+            int maxY = Math.Min(destination.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();
                 buffers[i] = this.ComponentProcessors[i].ColorBuffer;
             }
 
@@ -176,6 +157,8 @@ private void ConvertColorsInto<TPixel>(ImageFrame<TPixel> destination)
                 // 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/Components/Decoder/SpectralConverter.cs

@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    internal abstract class SpectralConverter : IDisposable
+    {
+        public abstract void InjectFrameData(JpegFrame frame, IRawJpegData jpegData);
+
+        public abstract void ConvertStrideBaseline();
+
+        public abstract void Dispose();
+    }
+}