Fix Vp8Residual costs calculation

src/ImageSharp/Formats/Webp/Lossy/Vp8BandProbas.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Text.Json.Serialization;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 /// <summary>
@@ -20,6 +22,13 @@ public Vp8BandProbas()
         }
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Vp8BandProbas"/> class.
+    /// Only used for unit tests.
+    /// </summary>
+    [JsonConstructor]
+    public Vp8BandProbas(Vp8ProbaArray[] probabilities) => this.Probabilities = probabilities;
+
     /// <summary>
     /// Gets the Probabilities.
     /// </summary>

src/ImageSharp/Formats/Webp/Lossy/Vp8CostArray.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Text.Json.Serialization;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 internal class Vp8CostArray
@@ -10,5 +12,12 @@ internal class Vp8CostArray
     /// </summary>
     public Vp8CostArray() => this.Costs = new ushort[67 + 1];
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Vp8CostArray"/> class.
+    /// Only used for unit tests.
+    /// </summary>
+    [JsonConstructor]
+    public Vp8CostArray(ushort[] costs) => this.Costs = costs;
+
     public ushort[] Costs { get; }
 }

src/ImageSharp/Formats/Webp/Lossy/Vp8Costs.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Text.Json.Serialization;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 internal class Vp8Costs
@@ -17,6 +19,13 @@ public Vp8Costs()
         }
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Vp8Costs"/> class.
+    /// Only used for unit tests.
+    /// </summary>
+    [JsonConstructor]
+    public Vp8Costs(Vp8CostArray[] costs) => this.Costs = costs;
+
     /// <summary>
     /// Gets the Costs.
     /// </summary>

src/ImageSharp/Formats/Webp/Lossy/Vp8ProbaArray.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Text.Json.Serialization;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 /// <summary>
@@ -13,6 +15,13 @@ internal class Vp8ProbaArray
     /// </summary>
     public Vp8ProbaArray() => this.Probabilities = new byte[WebpConstants.NumProbas];
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Vp8ProbaArray"/> class.
+    /// Only used for unit tests.
+    /// </summary>
+    [JsonConstructor]
+    public Vp8ProbaArray(byte[] probabilities) => this.Probabilities = probabilities;
+
     /// <summary>
     /// Gets the probabilities.
     /// </summary>

src/ImageSharp/Formats/Webp/Lossy/Vp8Residual.cs

@@ -7,6 +7,7 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using System.Text.Json.Serialization;
 
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
@@ -15,6 +16,22 @@ namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 /// </summary>
 internal class Vp8Residual
 {
+    public Vp8Residual()
+    {
+    }
+
+    [JsonConstructor]
+    public Vp8Residual(int first, int last, int coeffType, short[] coeffs, Vp8BandProbas[] prob, Vp8Stats[] stats, Vp8Costs[] costs)
+    {
+        this.First = first;
+        this.Last = last;
+        this.CoeffType = coeffType;
+        this.Coeffs = coeffs;
+        this.Prob = prob;
+        this.Stats = stats;
+        this.Costs = costs;
+    }
+
     public int First { get; set; }
 
     public int Last { get; set; }
@@ -156,7 +173,7 @@ public int GetResidualCost(int ctx0)
             return LossyUtils.Vp8BitCost(0, (byte)p0);
         }
 
-        if (Avx2.IsSupported)
+        if (Sse2.IsSupported)
         {
             Span<byte> scratch = stackalloc byte[32];
             Span<byte> ctxs = scratch.Slice(0, 16);
@@ -165,19 +182,23 @@ public int GetResidualCost(int ctx0)
 
             // Precompute clamped levels and contexts, packed to 8b.
             ref short outputRef = ref MemoryMarshal.GetReference<short>(this.Coeffs);
-            Vector256<short> c0 = Unsafe.As<short, Vector256<byte>>(ref outputRef).AsInt16();
-            Vector256<short> d0 = Avx2.Subtract(Vector256<short>.Zero, c0);
-            Vector256<short> e0 = Avx2.Max(c0, d0); // abs(v), 16b
-            Vector256<sbyte> f = Avx2.PackSignedSaturate(e0, e0);
-            Vector256<byte> g = Avx2.Min(f.AsByte(), Vector256.Create((byte)2));
-            Vector256<byte> h = Avx2.Min(f.AsByte(), Vector256.Create((byte)67)); // clampLevel in [0..67]
+            Vector128<short> c0 = Unsafe.As<short, Vector128<byte>>(ref outputRef).AsInt16();
+            Vector128<short> c1 = Unsafe.As<short, Vector128<byte>>(ref Unsafe.Add(ref outputRef, 8)).AsInt16();
+            Vector128<short> d0 = Sse2.Subtract(Vector128<short>.Zero, c0);
+            Vector128<short> d1 = Sse2.Subtract(Vector128<short>.Zero, c1);
+            Vector128<short> e0 = Sse2.Max(c0, d0); // abs(v), 16b
+            Vector128<short> e1 = Sse2.Max(c1, d1);
+            Vector128<sbyte> f = Sse2.PackSignedSaturate(e0, e1);
+            Vector128<byte> g = Sse2.Min(f.AsByte(), Vector128.Create((byte)2)); // context = 0, 1, 2
+            Vector128<byte> h = Sse2.Min(f.AsByte(), Vector128.Create((byte)67)); // clampLevel in [0..67]
 
             ref byte ctxsRef = ref MemoryMarshal.GetReference(ctxs);
             ref byte levelsRef = ref MemoryMarshal.GetReference(levels);
             ref ushort absLevelsRef = ref MemoryMarshal.GetReference(absLevels);
-            Unsafe.As<byte, Vector128<byte>>(ref ctxsRef) = g.GetLower();
-            Unsafe.As<byte, Vector128<byte>>(ref levelsRef) = h.GetLower();
-            Unsafe.As<ushort, Vector256<ushort>>(ref absLevelsRef) = e0.AsUInt16();
+            Unsafe.As<byte, Vector128<byte>>(ref ctxsRef) = g;
+            Unsafe.As<byte, Vector128<byte>>(ref levelsRef) = h;
+            Unsafe.As<ushort, Vector128<ushort>>(ref absLevelsRef) = e0.AsUInt16();
+            Unsafe.As<ushort, Vector128<ushort>>(ref Unsafe.Add(ref absLevelsRef, 8)) = e1.AsUInt16();
 
             int level;
             int flevel;

src/ImageSharp/Formats/Webp/Lossy/Vp8Stats.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Text.Json.Serialization;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 internal class Vp8Stats
@@ -17,5 +19,12 @@ public Vp8Stats()
         }
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Vp8Stats"/> class.
+    /// Only used for unit tests.
+    /// </summary>
+    [JsonConstructor]
+    public Vp8Stats(Vp8StatsArray[] stats) => this.Stats = stats;
+
     public Vp8StatsArray[] Stats { get; }
 }

src/ImageSharp/Formats/Webp/Lossy/Vp8StatsArray.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Text.Json.Serialization;
+
 namespace SixLabors.ImageSharp.Formats.Webp.Lossy;
 
 internal class Vp8StatsArray
@@ -10,5 +12,12 @@ internal class Vp8StatsArray
     /// </summary>
     public Vp8StatsArray() => this.Stats = new uint[WebpConstants.NumProbas];
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Vp8StatsArray"/> class.
+    /// Only used for unit tests.
+    /// </summary>
+    [JsonConstructor]
+    public Vp8StatsArray(uint[] stats) => this.Stats = stats;
+
     public uint[] Stats { get; }
 }

tests/ImageSharp.Tests/Formats/WebP/Vp8ResidualTests.cs

@@ -1,6 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using System.Runtime.Intrinsics.X86;
+using System.Text.Json;
+using SixLabors.ImageSharp.Formats.Webp;
 using SixLabors.ImageSharp.Formats.Webp.Lossy;
 using SixLabors.ImageSharp.Tests.TestUtilities;
 
@@ -9,10 +12,134 @@ namespace SixLabors.ImageSharp.Tests.Formats.Webp;
 [Trait("Format", "Webp")]
 public class Vp8ResidualTests
 {
+    [Fact]
+    public void GetResidualCost_Works()
+    {
+        if (!Sse2.IsSupported)
+        {
+            // JsonSerializer without SSE2 does not seem to work, skip test then.
+            return;
+        }
+
+        // arrange
+        int ctx0 = 0;
+        int expected = 20911;
+        string jsonString = File.ReadAllText(Path.Combine("TestDataWebp", "Vp8Residual.json"));
+        Vp8Residual residual = JsonSerializer.Deserialize<Vp8Residual>(jsonString);
+
+        // act
+        int actual = residual.GetResidualCost(ctx0);
+
+        // assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Serialization_Works()
+    {
+        if (!Sse2.IsSupported)
+        {
+            // JsonSerializer without SSE2 does not seem to work, skip test then.
+            return;
+        }
+
+        // arrange
+        Vp8Residual expected = new();
+        Vp8EncProba encProb = new();
+        Random rand = new(439);
+        CreateRandomProbas(encProb, rand);
+        CreateCosts(encProb, rand);
+        expected.Init(1, 0, encProb);
+        for (int i = 0; i < expected.Coeffs.Length; i++)
+        {
+            expected.Coeffs[i] = (byte)rand.Next(255);
+        }
+
+        // act
+        string jsonString = JsonSerializer.Serialize(expected);
+        Vp8Residual actual = JsonSerializer.Deserialize<Vp8Residual>(jsonString);
+
+        // assert
+        Assert.Equal(expected.CoeffType, actual.CoeffType);
+        Assert.Equal(expected.Coeffs, actual.Coeffs);
+        Assert.Equal(expected.Costs.Length, actual.Costs.Length);
+        Assert.Equal(expected.First, actual.First);
+        Assert.Equal(expected.Last, actual.Last);
+        Assert.Equal(expected.Stats.Length, actual.Stats.Length);
+        for (int i = 0; i < expected.Stats.Length; i++)
+        {
+            Vp8StatsArray[] expectedStats = expected.Stats[i].Stats;
+            Vp8StatsArray[] actualStats = actual.Stats[i].Stats;
+            Assert.Equal(expectedStats.Length, actualStats.Length);
+            for (int j = 0; j < expectedStats.Length; j++)
+            {
+                Assert.Equal(expectedStats[j].Stats, actualStats[j].Stats);
+            }
+        }
+
+        Assert.Equal(expected.Prob.Length, actual.Prob.Length);
+        for (int i = 0; i < expected.Prob.Length; i++)
+        {
+            Vp8ProbaArray[] expectedProbabilities = expected.Prob[i].Probabilities;
+            Vp8ProbaArray[] actualProbabilities = actual.Prob[i].Probabilities;
+            Assert.Equal(expectedProbabilities.Length, actualProbabilities.Length);
+            for (int j = 0; j < expectedProbabilities.Length; j++)
+            {
+                Assert.Equal(expectedProbabilities[j].Probabilities, actualProbabilities[j].Probabilities);
+            }
+        }
+
+        for (int i = 0; i < expected.Costs.Length; i++)
+        {
+            Vp8CostArray[] expectedCosts = expected.Costs[i].Costs;
+            Vp8CostArray[] actualCosts = actual.Costs[i].Costs;
+            Assert.Equal(expectedCosts.Length, actualCosts.Length);
+            for (int j = 0; j < expectedCosts.Length; j++)
+            {
+                Assert.Equal(expectedCosts[j].Costs, actualCosts[j].Costs);
+            }
+        }
+    }
+
+    private static void CreateRandomProbas(Vp8EncProba probas, Random rand)
+    {
+        for (int t = 0; t < WebpConstants.NumTypes; ++t)
+        {
+            for (int b = 0; b < WebpConstants.NumBands; ++b)
+            {
+                for (int c = 0; c < WebpConstants.NumCtx; ++c)
+                {
+                    for (int p = 0; p < WebpConstants.NumProbas; ++p)
+                    {
+                        probas.Coeffs[t][b].Probabilities[c].Probabilities[p] = (byte)rand.Next(255);
+                    }
+                }
+            }
+        }
+    }
+
+    private static void CreateCosts(Vp8EncProba probas, Random rand)
+    {
+        for (int i = 0; i < probas.RemappedCosts.Length; i++)
+        {
+            for (int j = 0; j < probas.RemappedCosts[i].Length; j++)
+            {
+                for (int k = 0; k < probas.RemappedCosts[i][j].Costs.Length; k++)
+                {
+                    ushort[] costs = probas.RemappedCosts[i][j].Costs[k].Costs;
+                    for (int m = 0; m < costs.Length; m++)
+                    {
+                        costs[m] = (byte)rand.Next(255);
+                    }
+                }
+            }
+        }
+    }
+
     private static void RunSetCoeffsTest()
     {
         // arrange
-        var residual = new Vp8Residual();
+        Vp8Residual residual = new();
         short[] coeffs = { 110, 0, -2, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0 };
 
         // act
@@ -23,11 +150,8 @@ private static void RunSetCoeffsTest()
     }
 
     [Fact]
-    public void RunSetCoeffsTest_Works() => RunSetCoeffsTest();
-
-    [Fact]
-    public void RunSetCoeffsTest_WithHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunSetCoeffsTest, HwIntrinsics.AllowAll);
+    public void SetCoeffsTest_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunSetCoeffsTest, HwIntrinsics.AllowAll);
 
     [Fact]
-    public void RunSetCoeffsTest_WithoutHardwareIntrinsics_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunSetCoeffsTest, HwIntrinsics.DisableHWIntrinsic);
+    public void SetCoeffsTest_WithoutSSE2_Works() => FeatureTestRunner.RunWithHwIntrinsicsFeature(RunSetCoeffsTest, HwIntrinsics.DisableSSE2);
 }

tests/ImageSharp.Tests/ImageSharp.Tests.csproj

@@ -56,6 +56,9 @@
     <None Update="TestFonts\SixLaborsSampleAB.woff">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="TestDataWebp\Vp8Residual.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="xunit.runner.json">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>