Add Vector128 rounding

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

@@ -3,6 +3,7 @@
 
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
 
 // <auto-generated />
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
@@ -37,38 +38,66 @@ internal partial struct Block8x8F
     }
 
     /// <summary>
-    /// AVX2-only variant for executing <see cref="NormalizeColorsInPlace"/> and <see cref="RoundInPlace"/> in one step.
+    /// <see cref="Vector256{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/> and <see cref="RoundInPlace()"/>.
     /// </summary>
+    /// <param name="maximum">The maximum value to normalize to.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-    public void NormalizeColorsAndRoundInPlaceVector8(float maximum)
+    public void NormalizeColorsAndRoundInPlaceVector256(float maximum)
     {
-        var off = new Vector<float>(MathF.Ceiling(maximum * 0.5F));
+        Vector256<float> off =  Vector256.Create(MathF.Ceiling(maximum * 0.5F));
-        var max = new Vector<float>(maximum);
+        Vector256<float> max = Vector256.Create(maximum);
 
-        ref Vector<float> row0 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V0L);
+        ref Vector256<float> row0 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V0L);
-        row0 = NormalizeAndRound(row0, off, max);
+        row0 = NormalizeAndRoundVector256(row0, off, max);
 
-        ref Vector<float> row1 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V1L);
+        ref Vector256<float> row1 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V1L);
-        row1 = NormalizeAndRound(row1, off, max);
+        row1 = NormalizeAndRoundVector256(row1, off, max);
 
-        ref Vector<float> row2 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V2L);
+        ref Vector256<float> row2 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V2L);
-        row2 = NormalizeAndRound(row2, off, max);
+        row2 = NormalizeAndRoundVector256(row2, off, max);
 
-        ref Vector<float> row3 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V3L);
+        ref Vector256<float> row3 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V3L);
-        row3 = NormalizeAndRound(row3, off, max);
+        row3 = NormalizeAndRoundVector256(row3, off, max);
 
-        ref Vector<float> row4 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V4L);
+        ref Vector256<float> row4 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V4L);
-        row4 = NormalizeAndRound(row4, off, max);
+        row4 = NormalizeAndRoundVector256(row4, off, max);
 
-        ref Vector<float> row5 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V5L);
+        ref Vector256<float> row5 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V5L);
-        row5 = NormalizeAndRound(row5, off, max);
+        row5 = NormalizeAndRoundVector256(row5, off, max);
 
-        ref Vector<float> row6 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V6L);
+        ref Vector256<float> row6 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V6L);
-        row6 = NormalizeAndRound(row6, off, max);
+        row6 = NormalizeAndRoundVector256(row6, off, max);
 
-        ref Vector<float> row7 = ref Unsafe.As<Vector4, Vector<float>>(ref this.V7L);
+        ref Vector256<float> row7 = ref Unsafe.As<Vector4, Vector256<float>>(ref this.V7L);
-        row7 = NormalizeAndRound(row7, off, max);
+        row7 = NormalizeAndRoundVector256(row7, off, max);
+    }
 
+    /// <summary>
+    /// <see cref="Vector128{Single}"/> version of <see cref="NormalizeColorsInPlace(float)"/> and <see cref="RoundInPlace()"/>.
+    /// </summary>
+    /// <param name="maximum">The maximum value to normalize to.</param>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public void NormalizeColorsAndRoundInPlaceVector128(float maximum)
+    {
+        Vector128<float> off = Vector128.Create(MathF.Ceiling(maximum * 0.5F));
+        Vector128<float> max = Vector128.Create(maximum);
+
+        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();
     }
 
     /// <summary>

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.Generated.tt

@@ -1,103 +0,0 @@
-<#
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-#>
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#@ output extension=".cs" #>
-// Copyright (c) Six Labors.
-// Licensed under the Six Labors Split License.
-
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-// <auto-generated />
-<#
-char[] coordz = {'X', 'Y', 'Z', 'W'};
-#>
-namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
-
-internal partial struct Block8x8F
-{
-	/// <summary>
-    /// Level shift by +maximum/2, clip to [0, maximum]
-    /// </summary>
-    public void NormalizeColorsInPlace(float maximum)
-    {
-        var CMin4 = new Vector4(0F);
-        var CMax4 = new Vector4(maximum);
-        var COff4 = new Vector4(MathF.Ceiling(maximum * 0.5F));
-
-        <#
-
-		PushIndent("        ");
-
-        for (int i = 0; i < 8; i++)
-        {
-            for (int j = 0; j < 2; j++)
-            {
-				char side = j == 0 ? 'L' : 'R';
-				Write($"this.V{i}{side} = Numerics.Clamp(this.V{i}{side} + COff4, CMin4, CMax4);\r\n");
-            }
-        }
-		PopIndent();
-		#>
-    }
-
-    /// <summary>
-    /// AVX2-only variant for executing <see cref="NormalizeColorsInPlace"/> and <see cref="RoundInPlace"/> in one step.
-    /// </summary>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public void NormalizeColorsAndRoundInPlaceVector8(float maximum)
-    {
-        var off = new Vector<float>(MathF.Ceiling(maximum * 0.5F));
-        var max = new Vector<float>(maximum);
-        <#
-
-        for (int i = 0; i < 8; i++)
-        {
-            #>
-
-        ref Vector<float> row<#=i#> = ref Unsafe.As<Vector4, Vector<float>>(ref this.V<#=i#>L);
-        row<#=i#> = NormalizeAndRound(row<#=i#>, off, max);
-            <#
-        }
-		#>
-
-    }
-
-    /// <summary>
-    /// Fill the block from 'source' doing short -> float conversion.
-    /// </summary>
-    public void LoadFromInt16Scalar(ref Block8x8 source)
-    {
-        ref short selfRef = ref Unsafe.As<Block8x8, short>(ref source);
-
-        <#
-		PushIndent("        ");
-        for (int j = 0; j < 8; j++)
-        {
-            for (int i = 0; i < 8; i++)
-            {
-                char destCoord = coordz[i % 4];
-                char destSide = (i / 4) % 2 == 0 ? 'L' : 'R';
-
-				if(j > 0 && i == 0){
-				WriteLine("");
-				}
-
-                char srcCoord = coordz[j % 4];
-                char srcSide = (j / 4) % 2 == 0 ? 'L' : 'R';
-
-                var expression = $"this.V{j}{destSide}.{destCoord} =  Unsafe.Add(ref selfRef, {j*8+i});\r\n";
-				Write(expression);
-
-            }
-        }
-		PopIndent();
-		#>
-    }
-}

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

@@ -8,6 +8,8 @@ using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using System.Text;
 using SixLabors.ImageSharp.Common.Helpers;
+using Vector128_ = SixLabors.ImageSharp.Common.Helpers.Vector128Utilities;
+using Vector256_ = SixLabors.ImageSharp.Common.Helpers.Vector256Utilities;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components;
@@ -332,22 +334,13 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
     /// <param name="maximum">The maximum value.</param>
     public void NormalizeColorsAndRoundInPlace(float maximum)
     {
-        if (SimdUtils.HasVector8)
+        if (Vector256.IsHardwareAccelerated)
         {
-            this.NormalizeColorsAndRoundInPlaceVector8(maximum);
+            this.NormalizeColorsAndRoundInPlaceVector256(maximum);
-        }
-        else
-        {
-            this.NormalizeColorsInPlace(maximum);
-            this.RoundInPlace();
-        }
         }
-
+        else if (Vector128.IsHardwareAccelerated)
-    public void DE_NormalizeColors(float maximum)
-    {
-        if (SimdUtils.HasVector8)
         {
-            this.NormalizeColorsAndRoundInPlaceVector8(maximum);
+            this.NormalizeColorsAndRoundInPlaceVector128(maximum);
         }
         else
         {
@@ -590,4 +583,22 @@ internal partial struct Block8x8F : IEquatable<Block8x8F>
         row = Vector.Min(row, max);
         return row.FastRound();
     }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static Vector256<float> NormalizeAndRoundVector256(Vector256<float> row, Vector256<float> off, Vector256<float> max)
+    {
+        row += off;
+        row = Vector256.Max(row, Vector256<float>.Zero);
+        row = Vector256.Min(row, max);
+        return Vector256_.RoundToNearestInteger(row);
+    }
+
+    [MethodImpl(InliningOptions.ShortMethod)]
+    private static Vector128<float> NormalizeAndRoundVector128(Vector128<float> row, Vector128<float> off, Vector128<float> max)
+    {
+        row += off;
+        row = Vector128.Max(row, Vector128<float>.Zero);
+        row = Vector128.Min(row, max);
+        return Vector128_.RoundToNearestInteger(row);
+    }
 }

src/ImageSharp/ImageSharp.csproj

@@ -56,16 +56,6 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>ImageMetadataExtensions.tt</DependentUpon>
     </Compile>
-    <Compile Update="Formats\Jpeg\Components\Block8x8F.Generated.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Block8x8F.Generated.tt</DependentUpon>
-    </Compile>
-    <Compile Update="Formats\Jpeg\Components\Block8x8F.Generated.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Block8x8F.Generated.tt</DependentUpon>
-    </Compile>
     <Compile Update="PixelFormats\PixelImplementations\PixelOperations\Generated\Abgr32.PixelOperations.Generated.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
@@ -158,14 +148,6 @@
       <LastGenOutput>ImageMetadataExtensions.cs</LastGenOutput>
       <Generator>TextTemplatingFileGenerator</Generator>
     </None>
-    <None Update="Formats\Jpeg\Components\Block8x8F.Generated.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Block8x8F.Generated.cs</LastGenOutput>
-    </None>
-    <None Update="Formats\Jpeg\Components\Block8x8F.Generated.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>Block8x8F.Generated.cs</LastGenOutput>
-    </None>
     <None Update="PixelFormats\PixelImplementations\PixelOperations\Generated\Abgr32.PixelOperations.Generated.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>Abgr32.PixelOperations.Generated.cs</LastGenOutput>

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

@@ -3,6 +3,7 @@
 
 // Uncomment this to turn unit tests into benchmarks:
 // #define BENCHMARKING
+using System.Runtime.Intrinsics;
 using SixLabors.ImageSharp.Formats.Jpeg.Components;
 using SixLabors.ImageSharp.Tests.Formats.Jpg.Utils;
 using SixLabors.ImageSharp.Tests.TestUtilities;
@@ -24,11 +25,22 @@ public partial class Block8x8FTests : JpegFixture
     {
     }
 
-    private bool SkipOnNonAvx2Runner()
+    private bool SkipOnNonVector256Runner()
     {
-        if (!SimdUtils.HasVector8)
+        if (!Vector256.IsHardwareAccelerated)
         {
-            this.Output.WriteLine("AVX2 not supported, skipping!");
+            this.Output.WriteLine("Vector256 not supported, skipping!");
+            return true;
+        }
+
+        return false;
+    }
+
+    private bool SkipOnNonVector128Runner()
+    {
+        if (!Vector128.IsHardwareAccelerated)
+        {
+            this.Output.WriteLine("Vector128 not supported, skipping!");
             return true;
         }
 
@@ -172,9 +184,33 @@ public partial class Block8x8FTests : JpegFixture
     [Theory]
     [InlineData(1)]
     [InlineData(2)]
-    public void NormalizeColorsAndRoundAvx2(int seed)
+    public void NormalizeColorsAndRoundVector256(int seed)
+    {
+        if (this.SkipOnNonVector256Runner())
+        {
+            return;
+        }
+
+        Block8x8F source = CreateRandomFloatBlock(-200, 200, seed);
+
+        Block8x8F expected = source;
+        expected.NormalizeColorsInPlace(255);
+        expected.RoundInPlace();
+
+        Block8x8F actual = source;
+        actual.NormalizeColorsAndRoundInPlaceVector256(255);
+
+        this.Output.WriteLine(expected.ToString());
+        this.Output.WriteLine(actual.ToString());
+        this.CompareBlocks(expected, actual, 0);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    public void NormalizeColorsAndRoundVector128(int seed)
     {
-        if (this.SkipOnNonAvx2Runner())
+        if (this.SkipOnNonVector128Runner())
         {
             return;
         }
@@ -186,7 +222,7 @@ public partial class Block8x8FTests : JpegFixture
         expected.RoundInPlace();
 
         Block8x8F actual = source;
-        actual.NormalizeColorsAndRoundInPlaceVector8(255);
+        actual.NormalizeColorsAndRoundInPlaceVector128(255);
 
         this.Output.WriteLine(expected.ToString());
         this.Output.WriteLine(actual.ToString());
@@ -206,7 +242,7 @@ public partial class Block8x8FTests : JpegFixture
             Block8x8F source = CreateRandomFloatBlock(-2000, 2000, srcSeed);
 
             // Quantization code is used only in jpeg where it's guaranteed that
-            // qunatization valus are greater than 1
+            // quantization values are greater than 1
             // Quantize method supports negative numbers by very small numbers can cause troubles
             Block8x8F quant = CreateRandomFloatBlock(1, 2000, qtSeed);
 
@@ -345,7 +381,7 @@ public partial class Block8x8FTests : JpegFixture
     [Fact]
     public void LoadFromUInt16Scalar()
     {
-        if (this.SkipOnNonAvx2Runner())
+        if (this.SkipOnNonVector256Runner())
         {
             return;
         }
@@ -366,7 +402,7 @@ public partial class Block8x8FTests : JpegFixture
     [Fact]
     public void LoadFromUInt16ExtendedAvx2()
     {
-        if (this.SkipOnNonAvx2Runner())
+        if (this.SkipOnNonVector256Runner())
         {
             return;
         }