Jpeg downscaling decoding

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterAvx.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 #if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
@@ -25,7 +26,9 @@ protected JpegColorConverterAvx(JpegColorSpace colorSpace, int precision)
             {
             }
 
-            public override bool IsAvailable => Avx.IsSupported;
+            public sealed override bool IsAvailable => Avx.IsSupported;
+
+            public sealed override int ElementsPerBatch => Vector256<float>.Count;
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterBase.cs

@@ -35,6 +35,15 @@ protected JpegColorConverterBase(JpegColorSpace colorSpace, int precision)
         /// </summary>
         public abstract bool IsAvailable { get; }
 
+        /// <summary>
+        /// Gets a value indicating how many pixels are processed in a single batch.
+        /// </summary>
+        /// <remarks>
+        /// This generaly should be equal to register size,
+        /// e.g. 1 for scalar implementation, 8 for AVX implementation and so on.
+        /// </remarks>
+        public abstract int ElementsPerBatch { get; }
+
         /// <summary>
         /// Gets the <see cref="JpegColorSpace"/> of this converter.
         /// </summary>
@@ -219,7 +228,7 @@ public ComponentValues(IReadOnlyList<Buffer2D<float>> componentBuffers, int row)
             /// </summary>
             /// <param name="processors">List of component color processors.</param>
             /// <param name="row">Row to convert</param>
-            public ComponentValues(IReadOnlyList<JpegComponentPostProcessor> processors, int row)
+            public ComponentValues(IReadOnlyList<ComponentProcessor> processors, int row)
             {
                 DebugGuard.MustBeGreaterThan(processors.Count, 0, nameof(processors));
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterScalar.cs

@@ -16,7 +16,9 @@ protected JpegColorConverterScalar(JpegColorSpace colorSpace, int precision)
             {
             }
 
-            public override bool IsAvailable => true;
+            public sealed override bool IsAvailable => true;
+
+            public sealed override int ElementsPerBatch => 1;
         }
     }
 }

src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverterVector.cs

@@ -17,7 +17,7 @@ internal abstract partial class JpegColorConverterBase
         /// Even though real life data is guaranteed to be of size
         /// divisible by 8 newer SIMD instructions like AVX512 won't work with
         /// such data out of the box. These converters have fallback code
-        /// for 'remainder' data.
+        /// for remainder data.
         /// </remarks>
         internal abstract class JpegColorConverterVector : JpegColorConverterBase
         {
@@ -28,7 +28,9 @@ protected JpegColorConverterVector(JpegColorSpace colorSpace, int precision)
 
             public sealed override bool IsAvailable => Vector.IsHardwareAccelerated && Vector<float>.Count % 4 == 0;
 
-            public override void ConvertToRgbInplace(in ComponentValues values)
+            public sealed override int ElementsPerBatch => Vector<float>.Count;
+
+            public sealed override void ConvertToRgbInplace(in ComponentValues values)
             {
                 DebugGuard.IsTrue(this.IsAvailable, $"{this.GetType().Name} converter is not supported on current hardware.");
 

src/ImageSharp/Formats/Jpeg/Components/Decoder/ComponentProcessors/ComponentProcessor.cs

@@ -0,0 +1,47 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    internal abstract class ComponentProcessor : IDisposable
+    {
+        public ComponentProcessor(MemoryAllocator memoryAllocator, JpegFrame frame, Size postProcessorBufferSize, IJpegComponent component, int blockSize)
+        {
+            this.Frame = frame;
+            this.Component = component;
+
+            this.BlockAreaSize = component.SubSamplingDivisors * blockSize;
+            this.ColorBuffer = memoryAllocator.Allocate2DOveraligned<float>(
+                postProcessorBufferSize.Width,
+                postProcessorBufferSize.Height,
+                this.BlockAreaSize.Height);
+        }
+
+        protected JpegFrame Frame { get; }
+
+        protected IJpegComponent Component { get; }
+
+        protected Buffer2D<float> ColorBuffer { get; }
+
+        protected Size BlockAreaSize { get; }
+
+        public abstract void CopyBlocksToColorBuffer(int spectralStep);
+
+        public void ClearSpectralBuffers()
+        {
+            Buffer2D<Block8x8> spectralBlocks = this.Component.SpectralBlocks;
+            for (int i = 0; i < spectralBlocks.Height; i++)
+            {
+                spectralBlocks.DangerousGetRowSpan(i).Clear();
+            }
+        }
+
+        public Span<float> GetColorBufferRowSpan(int row) =>
+            this.ColorBuffer.DangerousGetRowSpan(row);
+
+        public void Dispose() => this.ColorBuffer.Dispose();
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ComponentProcessors/DirectComponentProcessor.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    internal sealed class DirectComponentProcessor : ComponentProcessor
+    {
+        private readonly IRawJpegData rawJpeg;
+
+        public DirectComponentProcessor(MemoryAllocator memoryAllocator, JpegFrame frame, IRawJpegData rawJpeg, Size postProcessorBufferSize, IJpegComponent component)
+            : base(memoryAllocator, frame, postProcessorBufferSize, component, blockSize: 8)
+            => this.rawJpeg = rawJpeg;
+
+        public override void CopyBlocksToColorBuffer(int spectralStep)
+        {
+            Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
+
+            float maximumValue = this.Frame.MaxColorChannelValue;
+
+            int destAreaStride = this.ColorBuffer.Width;
+
+            int blocksRowsPerStep = this.Component.SamplingFactors.Height;
+
+            int yBlockStart = spectralStep * blocksRowsPerStep;
+
+            Size subSamplingDivisors = this.Component.SubSamplingDivisors;
+
+            Block8x8F dequantTable = this.rawJpeg.QuantizationTables[this.Component.QuantizationTableIndex];
+            Block8x8F workspaceBlock = default;
+
+            for (int y = 0; y < blocksRowsPerStep; y++)
+            {
+                int yBuffer = y * this.BlockAreaSize.Height;
+
+                Span<float> colorBufferRow = this.ColorBuffer.DangerousGetRowSpan(yBuffer);
+                Span<Block8x8> blockRow = spectralBuffer.DangerousGetRowSpan(yBlockStart + y);
+
+                for (int xBlock = 0; xBlock < spectralBuffer.Width; xBlock++)
+                {
+                    // Integer to float
+                    workspaceBlock.LoadFrom(ref blockRow[xBlock]);
+
+                    // Dequantize
+                    workspaceBlock.MultiplyInPlace(ref dequantTable);
+
+                    // Convert from spectral to color
+                    FastFloatingPointDCT.TransformIDCT(ref workspaceBlock);
+
+                    // To conform better to libjpeg we actually NEED TO loose precision here.
+                    // This is because they store blocks as Int16 between all the operations.
+                    // To be "more accurate", we need to emulate this by rounding!
+                    workspaceBlock.NormalizeColorsAndRoundInPlace(maximumValue);
+
+                    // Write to color buffer acording to sampling factors
+                    int xColorBufferStart = xBlock * this.BlockAreaSize.Width;
+                    workspaceBlock.ScaledCopyTo(
+                        ref colorBufferRow[xColorBufferStart],
+                        destAreaStride,
+                        subSamplingDivisors.Width,
+                        subSamplingDivisors.Height);
+                }
+            }
+        }
+    }
+}

src/ImageSharp/Formats/Jpeg/Components/Decoder/ComponentProcessors/DownScalingComponentProcessor8.cs

@@ -0,0 +1,92 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Memory;
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    internal sealed class DownScalingComponentProcessor8 : ComponentProcessor
+    {
+        private readonly float dcDequantizer;
+
+        public DownScalingComponentProcessor8(MemoryAllocator memoryAllocator, JpegFrame frame, IRawJpegData rawJpeg, Size postProcessorBufferSize, IJpegComponent component)
+            : base(memoryAllocator, frame, postProcessorBufferSize, component, 1)
+            => this.dcDequantizer = rawJpeg.QuantizationTables[component.QuantizationTableIndex][0];
+
+        public override void CopyBlocksToColorBuffer(int spectralStep)
+        {
+            Buffer2D<Block8x8> spectralBuffer = this.Component.SpectralBlocks;
+
+            float maximumValue = this.Frame.MaxColorChannelValue;
+            float normalizationValue = MathF.Ceiling(maximumValue / 2);
+
+            int destAreaStride = this.ColorBuffer.Width;
+
+            int blocksRowsPerStep = this.Component.SamplingFactors.Height;
+            Size subSamplingDivisors = this.Component.SubSamplingDivisors;
+
+            int yBlockStart = spectralStep * blocksRowsPerStep;
+
+            for (int y = 0; y < blocksRowsPerStep; y++)
+            {
+                int yBuffer = y * this.BlockAreaSize.Height;
+
+                Span<float> colorBufferRow = this.ColorBuffer.DangerousGetRowSpan(yBuffer);
+                Span<Block8x8> blockRow = spectralBuffer.DangerousGetRowSpan(yBlockStart + y);
+
+                for (int xBlock = 0; xBlock < spectralBuffer.Width; xBlock++)
+                {
+                    // get direct current term - averaged 8x8 pixel value
+                    float dc = blockRow[xBlock][0];
+
+                    // dequantization
+                    dc *= this.dcDequantizer;
+
+                    // Normalize & round
+                    dc = (float)Math.Round(Numerics.Clamp(dc + normalizationValue, 0, maximumValue));
+
+                    // Save to the intermediate buffer
+                    int xColorBufferStart = xBlock * this.BlockAreaSize.Width;
+                    ScaledCopyTo(
+                        dc,
+                        ref colorBufferRow[xColorBufferStart],
+                        destAreaStride,
+                        subSamplingDivisors.Width,
+                        subSamplingDivisors.Height);
+                }
+            }
+        }
+
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void ScaledCopyTo(float value, ref float destRef, int destStrideWidth, int horizontalScale, int verticalScale)
+        {
+            if (horizontalScale == 1 && verticalScale == 1)
+            {
+                Unsafe.Add(ref destRef, 0) = value;
+                return;
+            }
+
+            if (horizontalScale == 2 && verticalScale == 2)
+            {
+                Unsafe.Add(ref destRef, 0) = value;
+                Unsafe.Add(ref destRef, 1) = value;
+                Unsafe.Add(ref destRef, 0 + destStrideWidth) = value;
+                Unsafe.Add(ref destRef, 1 + destStrideWidth) = value;
+                return;
+            }
+
+            // TODO: Optimize: implement all cases with scale-specific, loopless code!
+            for (int y = 0; y < verticalScale; y++)
+            {
+                for (int x = 0; x < horizontalScale; x++)
+                {
+                    Unsafe.Add(ref destRef, x) = value;
+                }
+
+                destRef = ref Unsafe.Add(ref destRef, destStrideWidth);
+            }
+        }
+    }
+}