Introduce optimized conversion methods for RGBA-like types

src/ImageSharp.Drawing/Processing/BrushApplicator.cs

@@ -89,7 +89,7 @@ internal virtual void Apply(Span<float> scanline, int x, int y)
                 }
 
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
+                this.Blender.Blend(this.Target.Configuration, destinationRow, destinationRow, overlaySpan, amountSpan);
             }
         }
     }

src/ImageSharp.Drawing/Processing/ImageBrush{TPixel}.cs

@@ -140,7 +140,12 @@ internal override void Apply(Span<float> scanline, int x, int y)
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(this.source.MemoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
+                    this.Blender.Blend(
+                        this.source.Configuration,
+                        destinationRow,
+                        destinationRow,
+                        overlaySpan,
+                        amountSpan);
                 }
             }
         }

src/ImageSharp.Drawing/Processing/PatternBrush{TPixel}.cs

@@ -170,7 +170,12 @@ internal override void Apply(Span<float> scanline, int x, int y)
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
+                    this.Blender.Blend(
+                        this.Target.Configuration,
+                        destinationRow,
+                        destinationRow,
+                        overlaySpan,
+                        amountSpan);
                 }
             }
         }

src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs

@@ -79,8 +79,6 @@ protected override void OnFrameApply(ImageFrame<TPixelDst> source, Rectangle sou
 
             int width = maxX - minX;
 
-            MemoryAllocator memoryAllocator = this.Image.GetConfiguration().MemoryAllocator;
-
             var workingRect = Rectangle.FromLTRB(minX, minY, maxX, maxY);
 
             ParallelHelper.IterateRows(
@@ -93,7 +91,7 @@ protected override void OnFrameApply(ImageFrame<TPixelDst> source, Rectangle sou
                             Span<TPixelDst> background = source.GetPixelRowSpan(y).Slice(minX, width);
                             Span<TPixelSrc> foreground =
                                 targetImage.GetPixelRowSpan(y - locationY).Slice(targetX, width);
-                            blender.Blend<TPixelSrc>(memoryAllocator, background, background, foreground, this.Opacity);
+                            blender.Blend<TPixelSrc>(configuration, background, background, foreground, this.Opacity);
                         }
                     });
         }

src/ImageSharp.Drawing/Processing/RecolorBrush{TPixel}.cs

@@ -158,7 +158,12 @@ internal override void Apply(Span<float> scanline, int x, int y)
                     }
 
                     Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
-                    this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, overlaySpan, amountSpan);
+                    this.Blender.Blend(
+                        this.Target.Configuration,
+                        destinationRow,
+                        destinationRow,
+                        overlaySpan,
+                        amountSpan);
                 }
             }
         }

src/ImageSharp.Drawing/Processing/SolidBrush{TPixel}.cs

@@ -92,10 +92,11 @@ internal override void Apply(Span<float> scanline, int x, int y)
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
 
                 MemoryAllocator memoryAllocator = this.Target.MemoryAllocator;
+                Configuration configuration = this.Target.Configuration;
 
                 if (this.Options.BlendPercentage == 1f)
                 {
-                    this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), scanline);
+                    this.Blender.Blend(configuration, destinationRow, destinationRow, this.Colors.GetSpan(), scanline);
                 }
                 else
                 {
@@ -108,7 +109,12 @@ internal override void Apply(Span<float> scanline, int x, int y)
                             amountSpan[i] = scanline[i] * this.Options.BlendPercentage;
                         }
 
-                        this.Blender.Blend(memoryAllocator, destinationRow, destinationRow, this.Colors.GetSpan(), amountSpan);
+                        this.Blender.Blend(
+                            configuration,
+                            destinationRow,
+                            destinationRow,
+                            this.Colors.GetSpan(),
+                            amountSpan);
                     }
                 }
             }

src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs

@@ -436,7 +436,11 @@ private void ReadRgb24<TPixel>(Buffer2D<TPixel> pixels, int width, int height, b
                     this.stream.Read(row);
                     int newY = Invert(y, height, inverted);
                     Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
-                    PixelOperations<TPixel>.Instance.FromBgr24Bytes(row.GetSpan(), pixelSpan, width);
+                    PixelOperations<TPixel>.Instance.FromBgr24Bytes(
+                        this.configuration,
+                        row.GetSpan(),
+                        pixelSpan,
+                        width);
                 }
             }
         }
@@ -461,7 +465,11 @@ private void ReadRgb32<TPixel>(Buffer2D<TPixel> pixels, int width, int height, b
                     this.stream.Read(row);
                     int newY = Invert(y, height, inverted);
                     Span<TPixel> pixelSpan = pixels.GetRowSpan(newY);
-                    PixelOperations<TPixel>.Instance.FromBgra32Bytes(row.GetSpan(), pixelSpan, width);
+                    PixelOperations<TPixel>.Instance.FromBgra32Bytes(
+                        this.configuration,
+                        row.GetSpan(),
+                        pixelSpan,
+                        width);
                 }
             }
         }

src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs

@@ -3,6 +3,8 @@
 
 using System;
 using System.IO;
+
+using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.MetaData;
@@ -23,6 +25,8 @@ internal sealed class BmpEncoderCore
 
         private readonly MemoryAllocator memoryAllocator;
 
+        private Configuration configuration;
+
         private BmpBitsPerPixel? bitsPerPixel;
 
         /// <summary>
@@ -48,6 +52,7 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));
 
+            this.configuration = image.GetConfiguration();
             ImageMetaData metaData = image.MetaData;
             BmpMetaData bmpMetaData = metaData.GetFormatMetaData(BmpFormat.Instance);
             this.bitsPerPixel = this.bitsPerPixel ?? bmpMetaData.BitsPerPixel;
@@ -163,7 +168,11 @@ private void Write32Bit<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
                 for (int y = pixels.Height - 1; y >= 0; y--)
                 {
                     Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
-                    PixelOperations<TPixel>.Instance.ToBgra32Bytes(pixelSpan, row.GetSpan(), pixelSpan.Length);
+                    PixelOperations<TPixel>.Instance.ToBgra32Bytes(
+                        this.configuration,
+                        pixelSpan,
+                        row.GetSpan(),
+                        pixelSpan.Length);
                     stream.Write(row.Array, 0, row.Length());
                 }
             }
@@ -183,7 +192,11 @@ private void Write24Bit<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
                 for (int y = pixels.Height - 1; y >= 0; y--)
                 {
                     Span<TPixel> pixelSpan = pixels.GetRowSpan(y);
-                    PixelOperations<TPixel>.Instance.ToBgr24Bytes(pixelSpan, row.GetSpan(), pixelSpan.Length);
+                    PixelOperations<TPixel>.Instance.ToBgr24Bytes(
+                        this.configuration,
+                        pixelSpan,
+                        row.GetSpan(),
+                        pixelSpan.Length);
                     stream.Write(row.Array, 0, row.Length());
                 }
             }

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -8,6 +8,7 @@
 using System.Runtime.InteropServices;
 using System.Text;
 
+using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.MetaData;
 using SixLabors.ImageSharp.PixelFormats;
@@ -26,6 +27,11 @@ internal sealed class GifEncoderCore
         /// </summary>
         private readonly MemoryAllocator memoryAllocator;
 
+        /// <summary>
+        /// Configuration bound to the encoding operation.
+        /// </summary>
+        private Configuration configuration;
+
         /// <summary>
         /// A reusable buffer used to reduce allocations.
         /// </summary>
@@ -81,14 +87,16 @@ public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));
 
+            this.configuration = image.GetConfiguration();
+
             ImageMetaData metaData = image.MetaData;
             this.gifMetaData = metaData.GetFormatMetaData(GifFormat.Instance);
             this.colorTableMode = this.colorTableMode ?? this.gifMetaData.ColorTableMode;
             bool useGlobalTable = this.colorTableMode.Equals(GifColorTableMode.Global);
 
             // Quantize the image returning a palette.
             QuantizedFrame<TPixel> quantized =
-                this.quantizer.CreateFrameQuantizer<TPixel>().QuantizeFrame(image.Frames.RootFrame);
+                this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()).QuantizeFrame(image.Frames.RootFrame);
 
             // Get the number of bits.
             this.bitDepth = ImageMaths.GetBitsNeededForColorDepth(quantized.Palette.Length).Clamp(1, 8);
@@ -151,7 +159,7 @@ private void EncodeGlobal<TPixel>(Image<TPixel> image, QuantizedFrame<TPixel> qu
                 else
                 {
                     using (QuantizedFrame<TPixel> paletteQuantized
-                        = palleteQuantizer.CreateFrameQuantizer(() => quantized.Palette).QuantizeFrame(frame))
+                        = palleteQuantizer.CreateFrameQuantizer(image.GetConfiguration(), () => quantized.Palette).QuantizeFrame(frame))
                     {
                         this.WriteImageData(paletteQuantized, stream);
                     }
@@ -171,15 +179,17 @@ private void EncodeLocal<TPixel>(Image<TPixel> image, QuantizedFrame<TPixel> qua
                 if (quantized is null)
                 {
                     // Allow each frame to be encoded at whatever color depth the frame designates if set.
-                    if (previousFrame != null
-                        && previousMeta.ColorTableLength != frameMetaData.ColorTableLength
-                        && frameMetaData.ColorTableLength > 0)
+                    if (previousFrame != null && previousMeta.ColorTableLength != frameMetaData.ColorTableLength
+                                              && frameMetaData.ColorTableLength > 0)
                     {
-                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>(frameMetaData.ColorTableLength).QuantizeFrame(frame);
+                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>(
+                            image.GetConfiguration(),
+                            frameMetaData.ColorTableLength).QuantizeFrame(frame);
                     }
                     else
                     {
-                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>().QuantizeFrame(frame);
+                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration())
+                            .QuantizeFrame(frame);
                     }
                 }
 
@@ -217,7 +227,7 @@ private int GetTransparentIndex<TPixel>(QuantizedFrame<TPixel> quantized)
             {
                 Span<Rgba32> rgbaSpan = rgbaBuffer.GetSpan();
                 ref Rgba32 paletteRef = ref MemoryMarshal.GetReference(rgbaSpan);
-                PixelOperations<TPixel>.Instance.ToRgba32(quantized.Palette, rgbaSpan);
+                PixelOperations<TPixel>.Instance.ToRgba32(this.configuration, quantized.Palette, rgbaSpan);
 
                 for (int i = quantized.Palette.Length - 1; i >= 0; i--)
                 {
@@ -319,7 +329,8 @@ private void WriteApplicationExtension(Stream stream, ushort repeatCount)
         /// <param name="stream">The stream to write to.</param>
         private void WriteComments(ImageMetaData metadata, Stream stream)
         {
-            if (!metadata.TryGetProperty(GifConstants.Comments, out ImageProperty property) || string.IsNullOrEmpty(property.Value))
+            if (!metadata.TryGetProperty(GifConstants.Comments, out ImageProperty property)
+                || string.IsNullOrEmpty(property.Value))
             {
                 return;
             }
@@ -417,7 +428,11 @@ private void WriteColorTable<TPixel>(QuantizedFrame<TPixel> image, Stream stream
 
             using (IManagedByteBuffer colorTable = this.memoryAllocator.AllocateManagedByteBuffer(colorTableLength))
             {
-                PixelOperations<TPixel>.Instance.ToRgb24Bytes(image.Palette.AsSpan(), colorTable.GetSpan(), pixelCount);
+                PixelOperations<TPixel>.Instance.ToRgb24Bytes(
+                    this.configuration,
+                    image.Palette.AsSpan(),
+                    colorTable.GetSpan(),
+                    pixelCount);
                 stream.Write(colorTable.Array, 0, colorTableLength);
             }
         }

src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegImagePostProcessor.cs

@@ -26,6 +26,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
     /// </summary>
     internal class JpegImagePostProcessor : IDisposable
     {
+        private readonly Configuration configuration;
+
         /// <summary>
         /// The number of block rows to be processed in one Step.
         /// </summary>
@@ -49,15 +51,17 @@ internal class JpegImagePostProcessor : IDisposable
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegImagePostProcessor"/> class.
         /// </summary>
-        /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/> to use for buffer allocations.</param>
+        /// <param name="configuration">The <see cref="Configuration"/> to configure internal operations.</param>
         /// <param name="rawJpeg">The <see cref="IRawJpegData"/> representing the uncompressed spectral Jpeg data</param>
-        public JpegImagePostProcessor(MemoryAllocator memoryAllocator, IRawJpegData rawJpeg)
+        public JpegImagePostProcessor(Configuration configuration, IRawJpegData rawJpeg)
         {
+            this.configuration = configuration;
             this.RawJpeg = rawJpeg;
             IJpegComponent c0 = rawJpeg.Components.First();
             this.NumberOfPostProcessorSteps = c0.SizeInBlocks.Height / BlockRowsPerStep;
             this.PostProcessorBufferSize = new Size(c0.SizeInBlocks.Width * 8, PixelRowsPerStep);
 
+            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
             this.ComponentProcessors = rawJpeg.Components.Select(c => new JpegComponentPostProcessor(memoryAllocator, this, c)).ToArray();
             this.rgbaBuffer = memoryAllocator.Allocate<Vector4>(rawJpeg.ImageSizeInPixels.Width);
             this.colorConverter = JpegColorConverter.GetConverter(rawJpeg.ColorSpace);
@@ -160,7 +164,7 @@ private void ConvertColorsInto<TPixel>(ImageFrame<TPixel> destination)
                 Span<TPixel> destRow = destination.GetPixelRowSpan(yy);
 
                 // TODO: Investigate if slicing is actually necessary
-                PixelOperations<TPixel>.Instance.FromVector4(this.rgbaBuffer.GetSpan().Slice(0, destRow.Length), destRow);
+                PixelOperations<TPixel>.Instance.FromVector4(this.configuration, this.rgbaBuffer.GetSpan().Slice(0, destRow.Length), destRow);
             }
         }
     }

src/ImageSharp/Formats/Jpeg/Components/Encoder/YCbCrForwardConverter{TPixel}.cs

@@ -53,12 +53,12 @@ public static YCbCrForwardConverter<TPixel> Create()
         /// <summary>
         /// Converts a 8x8 image area inside 'pixels' at position (x,y) placing the result members of the structure (<see cref="Y"/>, <see cref="Cb"/>, <see cref="Cr"/>)
         /// </summary>
-        public void Convert(IPixelSource<TPixel> pixels, int x, int y)
+        public void Convert(ImageFrame<TPixel> frame, int x, int y)
         {
-            this.pixelBlock.LoadAndStretchEdges(pixels, x, y);
+            this.pixelBlock.LoadAndStretchEdges(frame, x, y);
 
             Span<Rgb24> rgbSpan = this.rgbBlock.AsSpanUnsafe();
-            PixelOperations<TPixel>.Instance.ToRgb24(this.pixelBlock.AsSpanUnsafe(), rgbSpan);
+            PixelOperations<TPixel>.Instance.ToRgb24(frame.Configuration, this.pixelBlock.AsSpanUnsafe(), rgbSpan);
 
             ref float yBlockStart = ref Unsafe.As<Block8x8F, float>(ref this.Y);
             ref float cbBlockStart = ref Unsafe.As<Block8x8F, float>(ref this.Cb);

src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs

@@ -936,7 +936,7 @@ private ushort ReadUint16()
         private Image<TPixel> PostProcessIntoImage<TPixel>()
             where TPixel : struct, IPixel<TPixel>
         {
-            using (var postProcessor = new JpegImagePostProcessor(this.configuration.MemoryAllocator, this))
+            using (var postProcessor = new JpegImagePostProcessor(this.configuration, this))
             {
                 var image = new Image<TPixel>(this.configuration, this.ImageWidth, this.ImageHeight, this.MetaData);
                 postProcessor.PostProcess(image.Frames.RootFrame);

src/ImageSharp/Formats/Png/PngDecoderCore.cs

@@ -702,6 +702,7 @@ private void ProcessDefilteredScanline<TPixel>(ReadOnlySpan<byte> defilteredScan
 
                 case PngColorType.Rgb:
                     PngScanlineProcessor.ProcessRgbScanline(
+                        this.configuration,
                         this.header,
                         scanlineSpan,
                         rowSpan,
@@ -715,6 +716,7 @@ private void ProcessDefilteredScanline<TPixel>(ReadOnlySpan<byte> defilteredScan
 
                 case PngColorType.RgbWithAlpha:
                     PngScanlineProcessor.ProcessRgbaScanline(
+                        this.configuration,
                         this.header,
                         scanlineSpan,
                         rowSpan,