Merge pull request #2355 from SixLabors/bp/fixCalcModeScore

Fix mode score calculation for SSE2/AVX2 version

Author: JimBobSquarePants

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

@@ -14,7 +14,7 @@ internal static class LossyUtils
 {
     // Note: method name in libwebp reference implementation is called VP8SSE16x16.
     [MethodImpl(InliningOptions.ShortMethod)]
-    public static int Vp8_Sse16X16(Span<byte> a, Span<byte> b)
+    public static int Vp8_Sse16x16(Span<byte> a, Span<byte> b)
     {
         if (Avx2.IsSupported)
         {
@@ -31,7 +31,7 @@ public static int Vp8_Sse16X16(Span<byte> a, Span<byte> b)
 
     // Note: method name in libwebp reference implementation is called VP8SSE16x8.
     [MethodImpl(InliningOptions.ShortMethod)]
-    public static int Vp8_Sse16X8(Span<byte> a, Span<byte> b)
+    public static int Vp8_Sse16x8(Span<byte> a, Span<byte> b)
     {
         if (Avx2.IsSupported)
         {
@@ -48,7 +48,7 @@ public static int Vp8_Sse16X8(Span<byte> a, Span<byte> b)
 
     // Note: method name in libwebp reference implementation is called VP8SSE4x4.
     [MethodImpl(InliningOptions.ShortMethod)]
-    public static int Vp8_Sse4X4(Span<byte> a, Span<byte> b)
+    public static int Vp8_Sse4x4(Span<byte> a, Span<byte> b)
     {
         if (Avx2.IsSupported)
         {
@@ -77,8 +77,8 @@ public static int Vp8_Sse4X4(Span<byte> a, Span<byte> b)
             Vector256<byte> b01s = Avx2.UnpackLow(b01.AsByte(), Vector256<byte>.Zero);
 
             // subtract, square and accumulate.
-            Vector256<byte> d0 = Avx2.SubtractSaturate(a01s, b01s);
-            Vector256<int> e0 = Avx2.MultiplyAddAdjacent(d0.AsInt16(), d0.AsInt16());
+            Vector256<short> d0 = Avx2.SubtractSaturate(a01s.AsInt16(), b01s.AsInt16());
+            Vector256<int> e0 = Avx2.MultiplyAddAdjacent(d0, d0);
 
             return Numerics.ReduceSum(e0);
         }
@@ -110,10 +110,10 @@ public static int Vp8_Sse4X4(Span<byte> a, Span<byte> b)
             Vector128<byte> b23s = Sse2.UnpackLow(b23.AsByte(), Vector128<byte>.Zero);
 
             // subtract, square and accumulate.
-            Vector128<byte> d0 = Sse2.SubtractSaturate(a01s, b01s);
-            Vector128<byte> d1 = Sse2.SubtractSaturate(a23s, b23s);
-            Vector128<int> e0 = Sse2.MultiplyAddAdjacent(d0.AsInt16(), d0.AsInt16());
-            Vector128<int> e1 = Sse2.MultiplyAddAdjacent(d1.AsInt16(), d1.AsInt16());
+            Vector128<short> d0 = Sse2.SubtractSaturate(a01s.AsInt16(), b01s.AsInt16());
+            Vector128<short> d1 = Sse2.SubtractSaturate(a23s.AsInt16(), b23s.AsInt16());
+            Vector128<int> e0 = Sse2.MultiplyAddAdjacent(d0, d0);
+            Vector128<int> e1 = Sse2.MultiplyAddAdjacent(d1, d1);
             Vector128<int> sum = Sse2.Add(e0, e1);
 
             return Numerics.ReduceSum(sum);
@@ -126,18 +126,16 @@ public static int Vp8_Sse4X4(Span<byte> a, Span<byte> b)
     public static int Vp8_SseNxN(Span<byte> a, Span<byte> b, int w, int h)
     {
         int count = 0;
-        int aOffset = 0;
-        int bOffset = 0;
+        int offset = 0;
         for (int y = 0; y < h; y++)
         {
             for (int x = 0; x < w; x++)
             {
-                int diff = a[aOffset + x] - b[bOffset + x];
+                int diff = a[offset + x] - b[offset + x];
                 count += diff * diff;
             }
 
-            aOffset += WebpConstants.Bps;
-            bOffset += WebpConstants.Bps;
+            offset += WebpConstants.Bps;
         }
 
         return count;

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

@@ -53,7 +53,7 @@ public static void PickBestIntra16(Vp8EncIterator it, ref Vp8ModeScore rd, Vp8Se
             rdCur.Nz = (uint)ReconstructIntra16(it, dqm, rdCur, tmpDst, mode);
 
             // Measure RD-score.
-            rdCur.D = LossyUtils.Vp8_Sse16X16(src, tmpDst);
+            rdCur.D = LossyUtils.Vp8_Sse16x16(src, tmpDst);
             rdCur.SD = tlambda != 0 ? Mult8B(tlambda, LossyUtils.Vp8Disto16X16(src, tmpDst, WeightY, scratch)) : 0;
             rdCur.H = WebpConstants.Vp8FixedCostsI16[mode];
             rdCur.R = it.GetCostLuma16(rdCur, proba, res);
@@ -145,7 +145,7 @@ public static bool PickBestIntra4(Vp8EncIterator it, ref Vp8ModeScore rd, Vp8Seg
                 rdTmp.Nz = (uint)ReconstructIntra4(it, dqm, tmpLevels, src, tmpDst, mode);
 
                 // Compute RD-score.
-                rdTmp.D = LossyUtils.Vp8_Sse4X4(src, tmpDst);
+                rdTmp.D = LossyUtils.Vp8_Sse4x4(src, tmpDst);
                 rdTmp.SD = tlambda != 0 ? Mult8B(tlambda, LossyUtils.Vp8Disto4X4(src, tmpDst, WeightY, scratch)) : 0;
                 rdTmp.H = modeCosts[mode];
 
@@ -235,7 +235,7 @@ public static void PickBestUv(Vp8EncIterator it, ref Vp8ModeScore rd, Vp8Segment
             rdUv.Nz = (uint)ReconstructUv(it, dqm, rdUv, tmpDst, mode);
 
             // Compute RD-score
-            rdUv.D = LossyUtils.Vp8_Sse16X8(src, tmpDst);
+            rdUv.D = LossyUtils.Vp8_Sse16x8(src, tmpDst);
             rdUv.SD = 0;    // not calling TDisto here: it tends to flatten areas.
             rdUv.H = WebpConstants.Vp8FixedCostsUv[mode];
             rdUv.R = it.GetCostUv(rdUv, proba, res);
@@ -389,7 +389,7 @@ public static void RefineUsingDistortion(Vp8EncIterator it, Vp8SegmentInfo[] seg
             for (mode = 0; mode < WebpConstants.NumPredModes; ++mode)
             {
                 Span<byte> reference = it.YuvP.AsSpan(Vp8Encoding.Vp8I16ModeOffsets[mode]);
-                long score = (LossyUtils.Vp8_Sse16X16(src, reference) * WebpConstants.RdDistoMult) + (WebpConstants.Vp8FixedCostsI16[mode] * lambdaDi16);
+                long score = (LossyUtils.Vp8_Sse16x16(src, reference) * WebpConstants.RdDistoMult) + (WebpConstants.Vp8FixedCostsI16[mode] * lambdaDi16);
 
                 if (mode > 0 && WebpConstants.Vp8FixedCostsI16[mode] > bitLimit)
                 {
@@ -436,7 +436,7 @@ public static void RefineUsingDistortion(Vp8EncIterator it, Vp8SegmentInfo[] seg
                 for (mode = 0; mode < WebpConstants.NumBModes; ++mode)
                 {
                     Span<byte> reference = it.YuvP.AsSpan(Vp8Encoding.Vp8I4ModeOffsets[mode]);
-                    long score = (LossyUtils.Vp8_Sse4X4(src, reference) * WebpConstants.RdDistoMult) + (modeCosts[mode] * lambdaDi4);
+                    long score = (LossyUtils.Vp8_Sse4x4(src, reference) * WebpConstants.RdDistoMult) + (modeCosts[mode] * lambdaDi4);
                     if (score < bestI4Score)
                     {
                         bestI4Mode = mode;
@@ -485,7 +485,7 @@ public static void RefineUsingDistortion(Vp8EncIterator it, Vp8SegmentInfo[] seg
             for (mode = 0; mode < WebpConstants.NumPredModes; ++mode)
             {
                 Span<byte> reference = it.YuvP.AsSpan(Vp8Encoding.Vp8UvModeOffsets[mode]);
-                long score = (LossyUtils.Vp8_Sse16X8(src, reference) * WebpConstants.RdDistoMult) + (WebpConstants.Vp8FixedCostsUv[mode] * lambdaDuv);
+                long score = (LossyUtils.Vp8_Sse16x8(src, reference) * WebpConstants.RdDistoMult) + (WebpConstants.Vp8FixedCostsUv[mode] * lambdaDuv);
                 if (score < bestUvScore)
                 {
                     bestMode = mode;