drop all PixelExtensions usages in product code,

keep in test code for now.

src/ImageSharp/Formats/Png/PngEncoderCore.cs

@@ -386,9 +386,10 @@ namespace SixLabors.ImageSharp.Formats.Png
                 {
                     // 8 bit grayscale + alpha
                     // TODO: Should we consider in the future a GrayAlpha16 type.
+                    Rgba32 rgba = default;
                     for (int x = 0, o = 0; x < rowSpan.Length; x++, o += 2)
                     {
-                        var rgba = Unsafe.Add(ref rowSpanRef, x).ToRgba32();
+                        Unsafe.Add(ref rowSpanRef, x).ToRgba32(ref rgba);
                         Unsafe.Add(ref rawScanlineSpanRef, o) = ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
                         Unsafe.Add(ref rawScanlineSpanRef, o + 1) = rgba.A;
                     }
@@ -645,12 +646,14 @@ namespace SixLabors.ImageSharp.Formats.Png
                 ref byte alphaTableRef = ref MemoryMarshal.GetReference(alphaTable.GetSpan());
                 Span<byte> quantizedSpan = quantized.GetPixelSpan();
 
+                Rgba32 rgba = default;
+
                 for (int i = 0; i < paletteLength; i++)
                 {
                     if (quantizedSpan.IndexOf((byte)i) > -1)
                     {
                         int offset = i * 3;
-                        var rgba = palette[i].ToRgba32();
+                        palette[i].ToRgba32(ref rgba);
 
                         byte alpha = rgba.A;
 

src/ImageSharp/PixelFormats/IPixel.cs

@@ -115,18 +115,4 @@ namespace SixLabors.ImageSharp.PixelFormats
         /// <param name="source">The <see cref="Rgba64"/> value.</param>
         void PackFromRgba64(Rgba64 source);
     }
-
-    /// <summary>
-    /// Temporary extension methods for compatibility
-    /// </summary>
-    internal static class PixelExtensions
-    {
-        public static Rgba32 ToRgba32<TPixel>(this TPixel pixel)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            Rgba32 result = default;
-            pixel.ToRgba32(ref result);
-            return result;
-        }
-    }
 }

src/ImageSharp/PixelFormats/PixelExtensions.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.PixelFormats
+{
+    /// <summary>
+    /// Low-performance extension methods to help conversion syntax, suitable for testing purposes.
+    /// </summary>
+    internal static class PixelExtensions
+    {
+        /// <summary>
+        /// Returns the result of <see cref="IPixel.ToRgba32"/> as a new <see cref="Rgba32"/> instance.
+        /// </summary>
+        public static Rgba32 ToRgba32<TPixel>(this TPixel pixel)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            Rgba32 result = default;
+            pixel.ToRgba32(ref result);
+            return result;
+        }
+    }
+}

src/ImageSharp/Processing/Processors/Binarization/BinaryErrorDiffusionProcessor.cs

@@ -88,7 +88,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
             // Collect the values before looping so we can reduce our calculation count for identical sibling pixels
             TPixel sourcePixel = source[startX, startY];
             TPixel previousPixel = sourcePixel;
-            var rgba = sourcePixel.ToRgba32();
+            Rgba32 rgba = default;
+            sourcePixel.ToRgba32(ref rgba);
 
             // Convert to grayscale using ITU-R Recommendation BT.709 if required
             byte luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
@@ -105,7 +106,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
                     // rather than calculating it again. This is an inexpensive optimization.
                     if (!previousPixel.Equals(sourcePixel))
                     {
-                        rgba = sourcePixel.ToRgba32();
+                        sourcePixel.ToRgba32(ref rgba);
                         luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
 
                         // Setup the previous pointer

src/ImageSharp/Processing/Processors/Binarization/BinaryOrderedDitherProcessor.cs

@@ -67,7 +67,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
             // Collect the values before looping so we can reduce our calculation count for identical sibling pixels
             TPixel sourcePixel = source[startX, startY];
             TPixel previousPixel = sourcePixel;
-            var rgba = sourcePixel.ToRgba32();
+            Rgba32 rgba = default;
+            sourcePixel.ToRgba32(ref rgba);
 
             // Convert to grayscale using ITU-R Recommendation BT.709 if required
             byte luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
@@ -84,7 +85,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
                     // rather than calculating it again. This is an inexpensive optimization.
                     if (!previousPixel.Equals(sourcePixel))
                     {
-                        rgba = sourcePixel.ToRgba32();
+                        sourcePixel.ToRgba32(ref rgba);
                         luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
 
                         // Setup the previous pointer

src/ImageSharp/Processing/Processors/Binarization/BinaryThresholdProcessor.cs

@@ -80,6 +80,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
                 configuration,
                 rows =>
                     {
+                        Rgba32 rgba = default;
                         for (int y = rows.Min; y < rows.Max; y++)
                         {
                             Span<TPixel> row = source.GetPixelRowSpan(y);
@@ -87,7 +88,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Binarization
                             for (int x = startX; x < endX; x++)
                             {
                                 ref TPixel color = ref row[x];
-                                var rgba = color.ToRgba32();
+                                color.ToRgba32(ref rgba);
 
                                 // Convert to grayscale using ITU-R Recommendation BT.709 if required
                                 byte luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);

src/ImageSharp/Processing/Processors/Dithering/ErrorDiffusionPaletteProcessor.cs

@@ -76,7 +76,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
             TPixel sourcePixel = source[startX, startY];
             TPixel previousPixel = sourcePixel;
             PixelPair<TPixel> pair = this.GetClosestPixelPair(ref sourcePixel);
-            var rgba = sourcePixel.ToRgba32();
+            Rgba32 rgba = default;
+            sourcePixel.ToRgba32(ref rgba);
 
             // Convert to grayscale using ITU-R Recommendation BT.709 if required
             byte luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
@@ -101,7 +102,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
                             continue;
                         }
 
-                        rgba = sourcePixel.ToRgba32();
+                        sourcePixel.ToRgba32(ref rgba);
                         luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
 
                         // Setup the previous pointer

src/ImageSharp/Processing/Processors/Dithering/OrderedDitherPaletteProcessor.cs

@@ -53,7 +53,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
             TPixel sourcePixel = source[startX, startY];
             TPixel previousPixel = sourcePixel;
             PixelPair<TPixel> pair = this.GetClosestPixelPair(ref sourcePixel);
-            var rgba = sourcePixel.ToRgba32();
+            Rgba32 rgba = default;
+            sourcePixel.ToRgba32(ref rgba);
 
             // Convert to grayscale using ITU-R Recommendation BT.709 if required
             byte luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
@@ -78,7 +79,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
                             continue;
                         }
 
-                        rgba = sourcePixel.ToRgba32();
+                        sourcePixel.ToRgba32(ref rgba);
                         luminance = isAlphaOnly ? rgba.A : ImageMaths.Get8BitBT709Luminance(rgba.R, rgba.G, rgba.B);
 
                         // Setup the previous pointer

src/ImageSharp/Processing/Processors/Quantization/OctreeFrameQuantizer{TPixel}.cs

@@ -154,7 +154,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
                 return this.GetClosestPixel(ref pixel);
             }
 
-            var rgba = pixel.ToRgba32();
+            Rgba32 rgba = default;
+            pixel.ToRgba32(ref rgba);
             if (rgba.Equals(default))
             {
                 return this.transparentIndex;
@@ -434,7 +435,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
                     {
                         // Go to the next level down in the tree
                         int shift = 7 - level;
-                        var rgba = pixel.ToRgba32();
+                        Rgba32 rgba = default;
+                        pixel.ToRgba32(ref rgba);
 
                         int index = ((rgba.B & Mask[level]) >> (shift - 2))
                                     | ((rgba.G & Mask[level]) >> (shift - 1))
@@ -529,7 +531,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
                     if (!this.leaf)
                     {
                         int shift = 7 - level;
-                        var rgba = pixel.ToRgba32();
+                        Rgba32 rgba = default;
+                        pixel.ToRgba32(ref rgba);
 
                         int pixelIndex = ((rgba.B & Mask[level]) >> (shift - 2))
                                          | ((rgba.G & Mask[level]) >> (shift - 1))
@@ -556,7 +559,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public void Increment(ref TPixel pixel)
                 {
-                    var rgba = pixel.ToRgba32();
+                    Rgba32 rgba = default;
+                    pixel.ToRgba32(ref rgba);
                     this.pixelCount++;
                     this.red += rgba.R;
                     this.green += rgba.G;

src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs

@@ -879,7 +879,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             }
 
             // Expected order r->g->b->a
-            var rgba = pixel.ToRgba32();
+            Rgba32 rgba = default;
+            pixel.ToRgba32(ref rgba);
 
             int r = rgba.R >> (8 - IndexBits);
             int g = rgba.G >> (8 - IndexBits);

tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs

@@ -46,7 +46,8 @@ namespace SixLabors.ImageSharp.Benchmarks.ColorSpaces.Bulk
             {
                 TPixel c = s[i];
                 int i4 = i * 4;
-                var rgba = c.ToRgba32();
+                Rgba32 rgba = default;
+                c.ToRgba32(ref rgba);
                 d[i4] = rgba.R;
                 d[i4 + 1] = rgba.G;
                 d[i4 + 2] = rgba.B;

tests/ImageSharp.Tests/Processing/Transforms/AffineTransformTests.cs

@@ -240,7 +240,8 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
             var white = new Rgb24(255, 255, 255);
             foreach (TPixel pixel in data)
             {
-                var rgba = pixel.ToRgba32();
+                Rgba32 rgba = default;
+                pixel.ToRgba32(ref rgba);
                 if (rgba.A == 0)
                 {
                     continue;