Merge branch 'main' into js/parallel-cleanup

Author: JimBobSquarePants

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopy.cs

@@ -13,31 +13,31 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
 internal partial struct Block8x8F
 {
     /// <summary>
-    /// <see cref="Vector128{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/> and <see cref="RoundInPlace()"/>.
+    /// <see cref="Vector128{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/>.
     /// </summary>
     /// <param name="maximum">The maximum value to normalize to.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void NormalizeColorsAndRoundInPlaceVector128(float maximum)
+    public void NormalizeColorsInPlaceVector128(float maximum)
     {
         Vector128<float> max = Vector128.Create(maximum);
         Vector128<float> off = Vector128.Ceiling(max * .5F);
 
-        this.V0L = NormalizeAndRoundVector128(this.V0L.AsVector128(), off, max).AsVector4();
-        this.V0R = NormalizeAndRoundVector128(this.V0R.AsVector128(), off, max).AsVector4();
-        this.V1L = NormalizeAndRoundVector128(this.V1L.AsVector128(), off, max).AsVector4();
-        this.V1R = NormalizeAndRoundVector128(this.V1R.AsVector128(), off, max).AsVector4();
-        this.V2L = NormalizeAndRoundVector128(this.V2L.AsVector128(), off, max).AsVector4();
-        this.V2R = NormalizeAndRoundVector128(this.V2R.AsVector128(), off, max).AsVector4();
-        this.V3L = NormalizeAndRoundVector128(this.V3L.AsVector128(), off, max).AsVector4();
-        this.V3R = NormalizeAndRoundVector128(this.V3R.AsVector128(), off, max).AsVector4();
-        this.V4L = NormalizeAndRoundVector128(this.V4L.AsVector128(), off, max).AsVector4();
-        this.V4R = NormalizeAndRoundVector128(this.V4R.AsVector128(), off, max).AsVector4();
-        this.V5L = NormalizeAndRoundVector128(this.V5L.AsVector128(), off, max).AsVector4();
-        this.V5R = NormalizeAndRoundVector128(this.V5R.AsVector128(), off, max).AsVector4();
-        this.V6L = NormalizeAndRoundVector128(this.V6L.AsVector128(), off, max).AsVector4();
-        this.V6R = NormalizeAndRoundVector128(this.V6R.AsVector128(), off, max).AsVector4();
-        this.V7L = NormalizeAndRoundVector128(this.V7L.AsVector128(), off, max).AsVector4();
-        this.V7R = NormalizeAndRoundVector128(this.V7R.AsVector128(), off, max).AsVector4();
+        this.V0L = NormalizeVector128(this.V0L.AsVector128(), off, max).AsVector4();
+        this.V0R = NormalizeVector128(this.V0R.AsVector128(), off, max).AsVector4();
+        this.V1L = NormalizeVector128(this.V1L.AsVector128(), off, max).AsVector4();
+        this.V1R = NormalizeVector128(this.V1R.AsVector128(), off, max).AsVector4();
+        this.V2L = NormalizeVector128(this.V2L.AsVector128(), off, max).AsVector4();
+        this.V2R = NormalizeVector128(this.V2R.AsVector128(), off, max).AsVector4();
+        this.V3L = NormalizeVector128(this.V3L.AsVector128(), off, max).AsVector4();
+        this.V3R = NormalizeVector128(this.V3R.AsVector128(), off, max).AsVector4();
+        this.V4L = NormalizeVector128(this.V4L.AsVector128(), off, max).AsVector4();
+        this.V4R = NormalizeVector128(this.V4R.AsVector128(), off, max).AsVector4();
+        this.V5L = NormalizeVector128(this.V5L.AsVector128(), off, max).AsVector4();
+        this.V5R = NormalizeVector128(this.V5R.AsVector128(), off, max).AsVector4();
+        this.V6L = NormalizeVector128(this.V6L.AsVector128(), off, max).AsVector4();
+        this.V6R = NormalizeVector128(this.V6R.AsVector128(), off, max).AsVector4();
+        this.V7L = NormalizeVector128(this.V7L.AsVector128(), off, max).AsVector4();
+        this.V7R = NormalizeVector128(this.V7R.AsVector128(), off, max).AsVector4();
     }
 
     /// <summary>
@@ -71,8 +71,8 @@ public void LoadFromInt16ExtendedVector128(ref Block8x8 source)
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector128<float> NormalizeAndRoundVector128(Vector128<float> value, Vector128<float> off, Vector128<float> max)
-        => Vector128_.RoundToNearestInteger(Vector128_.Clamp(value + off, Vector128<float>.Zero, max));
+    private static Vector128<float> NormalizeVector128(Vector128<float> value, Vector128<float> off, Vector128<float> max)
+        => Vector128_.Clamp(value + off, Vector128<float>.Zero, max);
 
     private static void MultiplyIntoInt16Vector128(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
     {

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector128.cs

@@ -39,23 +39,23 @@ internal partial struct Block8x8F
 #pragma warning restore SA1310 // Field names should not contain underscore
 
     /// <summary>
-    /// <see cref="Vector256{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/> and <see cref="RoundInPlace()"/>.
+    /// <see cref="Vector256{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/>.
     /// </summary>
     /// <param name="maximum">The maximum value to normalize to.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void NormalizeColorsAndRoundInPlaceVector256(float maximum)
+    public void NormalizeColorsInPlaceVector256(float maximum)
     {
         Vector256<float> max = Vector256.Create(maximum);
         Vector256<float> off = Vector256.Ceiling(max * .5F);
 
-        this.V256_0 = NormalizeAndRoundVector256(this.V256_0, off, max);
-        this.V256_1 = NormalizeAndRoundVector256(this.V256_1, off, max);
-        this.V256_2 = NormalizeAndRoundVector256(this.V256_2, off, max);
-        this.V256_3 = NormalizeAndRoundVector256(this.V256_3, off, max);
-        this.V256_4 = NormalizeAndRoundVector256(this.V256_4, off, max);
-        this.V256_5 = NormalizeAndRoundVector256(this.V256_5, off, max);
-        this.V256_6 = NormalizeAndRoundVector256(this.V256_6, off, max);
-        this.V256_7 = NormalizeAndRoundVector256(this.V256_7, off, max);
+        this.V256_0 = NormalizeVector256(this.V256_0, off, max);
+        this.V256_1 = NormalizeVector256(this.V256_1, off, max);
+        this.V256_2 = NormalizeVector256(this.V256_2, off, max);
+        this.V256_3 = NormalizeVector256(this.V256_3, off, max);
+        this.V256_4 = NormalizeVector256(this.V256_4, off, max);
+        this.V256_5 = NormalizeVector256(this.V256_5, off, max);
+        this.V256_6 = NormalizeVector256(this.V256_6, off, max);
+        this.V256_7 = NormalizeVector256(this.V256_7, off, max);
     }
 
     /// <summary>
@@ -95,10 +95,10 @@ public void LoadFromInt16ExtendedVector256(ref Block8x8 source)
     }
 
     [MethodImpl(InliningOptions.ShortMethod)]
-    private static Vector256<float> NormalizeAndRoundVector256(Vector256<float> value, Vector256<float> off, Vector256<float> max)
-        => Vector256_.RoundToNearestInteger(Vector256_.Clamp(value + off, Vector256<float>.Zero, max));
+    private static Vector256<float> NormalizeVector256(Vector256<float> value, Vector256<float> off, Vector256<float> max)
+        => Vector256_.Clamp(value + off, Vector256<float>.Zero, max);
 
-    private static unsafe void MultiplyIntoInt16Vector256(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
+    private static void MultiplyIntoInt16Vector256(ref Block8x8F a, ref Block8x8F b, ref Block8x8 dest)
     {
         DebugGuard.IsTrue(Vector256.IsHardwareAccelerated, "Vector256 support is required to run this operation!");
 

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Vector256.cs

@@ -132,7 +132,7 @@ public unsafe void LoadFrom(Span<int> source)
     /// </summary>
     /// <param name="dest">Destination</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public unsafe void ScaledCopyTo(float[] dest)
+    public readonly void ScaledCopyTo(float[] dest)
     {
         DebugGuard.MustBeGreaterThanOrEqualTo(dest.Length, Size, "dest is too small");
 
@@ -193,7 +193,7 @@ public void MultiplyInPlace(float value)
     /// </summary>
     /// <param name="other">The other block.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public unsafe void MultiplyInPlace(ref Block8x8F other)
+    public void MultiplyInPlace(ref Block8x8F other)
     {
         if (Vector256.IsHardwareAccelerated)
         {
@@ -324,62 +324,43 @@ public Block8x8 RoundAsInt16Block()
     }
 
     /// <summary>
-    /// Level shift by +maximum/2, clip to [0..maximum], and round all the values in the block.
+    /// Level shift by +maximum/2, clip to [0, maximum]
     /// </summary>
-    /// <param name="maximum">The maximum value.</param>
-    public void NormalizeColorsAndRoundInPlace(float maximum)
+    /// <param name="maximum">The maximum value to normalize to.</param>
+    public void NormalizeColorsInPlace(float maximum)
     {
         if (Vector256.IsHardwareAccelerated)
         {
-            this.NormalizeColorsAndRoundInPlaceVector256(maximum);
+            this.NormalizeColorsInPlaceVector256(maximum);
+            return;
         }
         else if (Vector128.IsHardwareAccelerated)
         {
-            this.NormalizeColorsAndRoundInPlaceVector128(maximum);
+            this.NormalizeColorsInPlaceVector128(maximum);
+            return;
         }
         else
         {
-            this.NormalizeColorsInPlace(maximum);
-            this.RoundInPlace();
-        }
-    }
-
-    /// <summary>
-    /// Level shift by +maximum/2, clip to [0, maximum]
-    /// </summary>
-    /// <param name="maximum">The maximum value to normalize to.</param>
-    public void NormalizeColorsInPlace(float maximum)
-    {
-        Vector4 min = Vector4.Zero;
-        Vector4 max = new(maximum);
-        Vector4 off = new(MathF.Ceiling(maximum * 0.5F));
-
-        this.V0L = Vector4.Clamp(this.V0L + off, min, max);
-        this.V0R = Vector4.Clamp(this.V0R + off, min, max);
-        this.V1L = Vector4.Clamp(this.V1L + off, min, max);
-        this.V1R = Vector4.Clamp(this.V1R + off, min, max);
-        this.V2L = Vector4.Clamp(this.V2L + off, min, max);
-        this.V2R = Vector4.Clamp(this.V2R + off, min, max);
-        this.V3L = Vector4.Clamp(this.V3L + off, min, max);
-        this.V3R = Vector4.Clamp(this.V3R + off, min, max);
-        this.V4L = Vector4.Clamp(this.V4L + off, min, max);
-        this.V4R = Vector4.Clamp(this.V4R + off, min, max);
-        this.V5L = Vector4.Clamp(this.V5L + off, min, max);
-        this.V5R = Vector4.Clamp(this.V5R + off, min, max);
-        this.V6L = Vector4.Clamp(this.V6L + off, min, max);
-        this.V6R = Vector4.Clamp(this.V6R + off, min, max);
-        this.V7L = Vector4.Clamp(this.V7L + off, min, max);
-        this.V7R = Vector4.Clamp(this.V7R + off, min, max);
-    }
-
-    /// <summary>
-    /// Rounds all values in the block.
-    /// </summary>
-    public void RoundInPlace()
-    {
-        for (int i = 0; i < Size; i++)
-        {
-            this[i] = MathF.Round(this[i]);
+            Vector4 min = Vector4.Zero;
+            Vector4 max = new(maximum);
+            Vector4 off = new(MathF.Ceiling(maximum * 0.5F));
+
+            this.V0L = Vector4.Clamp(this.V0L + off, min, max);
+            this.V0R = Vector4.Clamp(this.V0R + off, min, max);
+            this.V1L = Vector4.Clamp(this.V1L + off, min, max);
+            this.V1R = Vector4.Clamp(this.V1R + off, min, max);
+            this.V2L = Vector4.Clamp(this.V2L + off, min, max);
+            this.V2R = Vector4.Clamp(this.V2R + off, min, max);
+            this.V3L = Vector4.Clamp(this.V3L + off, min, max);
+            this.V3R = Vector4.Clamp(this.V3R + off, min, max);
+            this.V4L = Vector4.Clamp(this.V4L + off, min, max);
+            this.V4R = Vector4.Clamp(this.V4R + off, min, max);
+            this.V5L = Vector4.Clamp(this.V5L + off, min, max);
+            this.V5R = Vector4.Clamp(this.V5R + off, min, max);
+            this.V6L = Vector4.Clamp(this.V6L + off, min, max);
+            this.V6R = Vector4.Clamp(this.V6R + off, min, max);
+            this.V7L = Vector4.Clamp(this.V7L + off, min, max);
+            this.V7R = Vector4.Clamp(this.V7R + off, min, max);
         }
     }
 
@@ -533,7 +514,7 @@ public bool EqualsToScalar(int value)
     }
 
     /// <inheritdoc />
-    public bool Equals(Block8x8F other)
+    public readonly bool Equals(Block8x8F other)
         => this.V0L == other.V0L
         && this.V0R == other.V0R
         && this.V1L == other.V1L

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs

@@ -53,10 +53,10 @@ public override void CopyBlocksToColorBuffer(int spectralStep)
                 // Convert from spectral to color
                 FloatingPointDCT.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);
+                // Normalize into the component sample range without quantizing away
+                // fractional precision. The later color conversion / final pack stage
+                // performs the only rounding we actually need for output samples.
+                workspaceBlock.NormalizeColorsInPlace(maximumValue);
 
                 // Write to color buffer acording to sampling factors
                 int xColorBufferStart = xBlock * this.BlockAreaSize.Width;