diff --git a/src/ImageSharp.Drawing/Processing/DrawImageExtensions.cs b/src/ImageSharp.Drawing/Processing/DrawImageExtensions.cs
index 8ccbe22acb..a8ee4d90bc 100644
--- a/src/ImageSharp.Drawing/Processing/DrawImageExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/DrawImageExtensions.cs
@@ -1,121 +1,137 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.ImageSharp.Processing.Processors.Drawing;
-using SixLabors.Primitives;
-
-namespace SixLabors.ImageSharp.Processing
-{
-    /// <summary>
-    /// Adds extensions that allow the drawing of images to the <see cref="Image{TPixel}"/> type.
-    /// </summary>
-    public static class DrawImageExtensions
-    {
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="image">The image to blend with the currently processing image.</param>
-        /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, float opacity)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, Point.Empty, GraphicsOptions.Default.ColorBlendingMode, GraphicsOptions.Default.AlphaCompositionMode, opacity));
-
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="image">The image to blend with the currently processing image.</param>
-        /// <param name="colorBlending">The blending mode.</param>
-        /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, PixelColorBlendingMode colorBlending, float opacity)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, Point.Empty, colorBlending, GraphicsOptions.Default.AlphaCompositionMode, opacity));
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
 
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image this method extends.</param>
-        /// <param name="image">The image to blend with the currently processing image.</param>
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors.Drawing;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Processing
+{
+    /// <summary>
+    /// Adds extensions that allow the drawing of images to the <see cref="Image{TPixel}"/> type.
+    /// </summary>
+    public static class DrawImageExtensions
+    {
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
+        /// </summary>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="image">The image to blend with the currently processing image.</param>
+        /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, float opacity)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, Point.Empty, GraphicsOptions.Default.ColorBlendingMode, GraphicsOptions.Default.AlphaCompositionMode, opacity));
+
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
+        /// </summary>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="image">The image to blend with the currently processing image.</param>
+        /// <param name="colorBlending">The blending mode.</param>
+        /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, PixelColorBlendingMode colorBlending, float opacity)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, Point.Empty, colorBlending, GraphicsOptions.Default.AlphaCompositionMode, opacity));
+
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
+        /// </summary>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="image">The image to blend with the currently processing image.</param>
         /// <param name="colorBlending">The color blending mode.</param>
-        /// <param name="alphaComposition">The alpha composition mode.</param>
-        /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, PixelColorBlendingMode colorBlending, PixelAlphaCompositionMode alphaComposition, float opacity)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, Point.Empty, colorBlending, alphaComposition, opacity));
+        /// <param name="alphaComposition">The alpha composition mode.</param>
+        /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, PixelColorBlendingMode colorBlending, PixelAlphaCompositionMode alphaComposition, float opacity)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, Point.Empty, colorBlending, alphaComposition, opacity));
 
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
+        /// </summary>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
         /// <param name="source">The image this method extends.</param>
-        /// <param name="image">The image to blend with the currently processing image.</param>
+        /// <param name="image">The image to blend with the currently processing image.</param>
         /// <param name="options">The options, including the blending type and blending amount.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, GraphicsOptions options)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, Point.Empty, options.ColorBlendingMode, options.AlphaCompositionMode, options.BlendPercentage));
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, GraphicsOptions options)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, Point.Empty, options.ColorBlendingMode, options.AlphaCompositionMode, options.BlendPercentage));
 
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image this method extends.</param>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
+        /// <param name="source">The image this method extends.</param>
         /// <param name="image">The image to blend with the currently processing image.</param>
-        /// <param name="location">The location to draw the blended image.</param>
+        /// <param name="location">The location to draw the blended image.</param>
         /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, Point location, float opacity)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, location, GraphicsOptions.Default.ColorBlendingMode, GraphicsOptions.Default.AlphaCompositionMode, opacity));
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, Point location, float opacity)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, location, GraphicsOptions.Default.ColorBlendingMode, GraphicsOptions.Default.AlphaCompositionMode, opacity));
 
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image this method extends.</param>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
+        /// <param name="source">The image this method extends.</param>
         /// <param name="image">The image to blend with the currently processing image.</param>
-        /// <param name="location">The location to draw the blended image.</param>
-        /// <param name="colorBlending">The color blending to apply.</param>
+        /// <param name="location">The location to draw the blended image.</param>
+        /// <param name="colorBlending">The color blending to apply.</param>
         /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, Point location, PixelColorBlendingMode colorBlending, float opacity)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, location, colorBlending, GraphicsOptions.Default.AlphaCompositionMode, opacity));
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, Point location, PixelColorBlendingMode colorBlending, float opacity)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, location, colorBlending, GraphicsOptions.Default.AlphaCompositionMode, opacity));
 
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image this method extends.</param>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
+        /// <param name="source">The image this method extends.</param>
         /// <param name="image">The image to blend with the currently processing image.</param>
-        /// <param name="location">The location to draw the blended image.</param>
+        /// <param name="location">The location to draw the blended image.</param>
         /// <param name="colorBlending">The color blending to apply.</param>
-        /// <param name="alphaComposition">The alpha composition mode.</param>
+        /// <param name="alphaComposition">The alpha composition mode.</param>
         /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, Point location, PixelColorBlendingMode colorBlending, PixelAlphaCompositionMode alphaComposition, float opacity)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, location, colorBlending, alphaComposition, opacity));
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, Point location, PixelColorBlendingMode colorBlending, PixelAlphaCompositionMode alphaComposition, float opacity)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, location, colorBlending, alphaComposition, opacity));
 
-        /// <summary>
-        /// Draws the given image together with the current one by blending their pixels.
+        /// <summary>
+        /// Draws the given image together with the current one by blending their pixels.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <typeparam name="TPixelDst">The pixel format of the destination image.</typeparam>
+        /// <typeparam name="TPixelSrc">The pixel format of the source image.</typeparam>
         /// <param name="source">The image this method extends.</param>
         /// <param name="image">The image to blend with the currently processing image.</param>
         /// <param name="location">The location to draw the blended image.</param>
-        /// <param name="options">The options containing the blend mode and opacity.</param>
-        /// <returns>The <see cref="Image{TPixel}"/>.</returns>
-        public static IImageProcessingContext<TPixel> DrawImage<TPixel>(this IImageProcessingContext<TPixel> source, Image<TPixel> image, Point location, GraphicsOptions options)
-            where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new DrawImageProcessor<TPixel>(image, location, options.ColorBlendingMode, options.AlphaCompositionMode, options.BlendPercentage));
-    }
+        /// <param name="options">The options containing the blend mode and opacity.</param>
+        /// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
+        public static IImageProcessingContext<TPixelDst> DrawImage<TPixelDst, TPixelSrc>(this IImageProcessingContext<TPixelDst> source, Image<TPixelSrc> image, Point location, GraphicsOptions options)
+            where TPixelDst : struct, IPixel<TPixelDst>
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+            => source.ApplyProcessor(new DrawImageProcessor<TPixelDst, TPixelSrc>(image, location, options.ColorBlendingMode, options.AlphaCompositionMode, options.BlendPercentage));
+    }
 }
\ No newline at end of file
diff --git a/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs b/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs
index 324d25e097..4e6018e07a 100644
--- a/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs
+++ b/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs
@@ -15,32 +15,34 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
     /// <summary>
     /// Combines two images together by blending the pixels.
     /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class DrawImageProcessor<TPixel> : ImageProcessor<TPixel>
-        where TPixel : struct, IPixel<TPixel>
+    /// <typeparam name="TPixelDst">The pixel format of destination image.</typeparam>
+    /// <typeparam name="TPixelSrc">The pixel format os source image.</typeparam>
+    internal class DrawImageProcessor<TPixelDst, TPixelSrc> : ImageProcessor<TPixelDst>
+        where TPixelDst : struct, IPixel<TPixelDst>
+        where TPixelSrc : struct, IPixel<TPixelSrc>
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="DrawImageProcessor{TPixel}"/> class.
+        /// Initializes a new instance of the <see cref="DrawImageProcessor{TPixelDst, TPixelSrc}"/> class.
         /// </summary>
         /// <param name="image">The image to blend with the currently processing image.</param>
         /// <param name="location">The location to draw the blended image.</param>
         /// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
         /// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
         /// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
-        public DrawImageProcessor(Image<TPixel> image, Point location, PixelColorBlendingMode colorBlendingMode, PixelAlphaCompositionMode alphaCompositionMode, float opacity)
+        public DrawImageProcessor(Image<TPixelSrc> image, Point location, PixelColorBlendingMode colorBlendingMode, PixelAlphaCompositionMode alphaCompositionMode, float opacity)
         {
             Guard.MustBeBetweenOrEqualTo(opacity, 0, 1, nameof(opacity));
 
             this.Image = image;
             this.Opacity = opacity;
-            this.Blender = PixelOperations<TPixel>.Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
+            this.Blender = PixelOperations<TPixelDst>.Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
             this.Location = location;
         }
 
         /// <summary>
         /// Gets the image to blend
         /// </summary>
-        public Image<TPixel> Image { get; }
+        public Image<TPixelSrc> Image { get; }
 
         /// <summary>
         /// Gets the opacity of the image to blend
@@ -50,7 +52,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
         /// <summary>
         /// Gets the pixel blender
         /// </summary>
-        public PixelBlender<TPixel> Blender { get; }
+        public PixelBlender<TPixelDst> Blender { get; }
 
         /// <summary>
         /// Gets the location to draw the blended image
@@ -58,10 +60,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
         public Point Location { get; }
 
         /// <inheritdoc/>
-        protected override void OnFrameApply(ImageFrame<TPixel> source, Rectangle sourceRectangle, Configuration configuration)
+        protected override void OnFrameApply(ImageFrame<TPixelDst> source, Rectangle sourceRectangle, Configuration configuration)
         {
-            Image<TPixel> targetImage = this.Image;
-            PixelBlender<TPixel> blender = this.Blender;
+            Image<TPixelSrc> targetImage = this.Image;
+            PixelBlender<TPixelDst> blender = this.Blender;
             int locationY = this.Location.Y;
 
             // Align start/end positions.
@@ -76,23 +78,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
 
             int width = maxX - minX;
 
-            MemoryAllocator memoryAllocator = this.Image.GetConfiguration().MemoryAllocator;
-
-            using (IMemoryOwner<float> amount = memoryAllocator.Allocate<float>(width))
-            {
-                amount.GetSpan().Fill(this.Opacity);
-
-                ParallelFor.WithConfiguration(
-                    minY,
-                    maxY,
-                    configuration,
-                    y =>
-                        {
-                            Span<TPixel> background = source.GetPixelRowSpan(y).Slice(minX, width);
-                            Span<TPixel> foreground = targetImage.GetPixelRowSpan(y - locationY).Slice(targetX, width);
-                            blender.Blend(memoryAllocator, background, background, foreground, amount.GetSpan());
-                        });
-            }
+            MemoryAllocator memoryAllocator = this.Image.GetConfiguration().MemoryAllocator;
+
+            ParallelFor.WithConfiguration(
+                minY,
+                maxY,
+                configuration,
+                y =>
+                    {
+                        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);
+                    });
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLchuv.cs b/src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLchuv.cs
index a44541bdb5..49c25462ea 100644
--- a/src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLchuv.cs
+++ b/src/ImageSharp/ColorSpaces/Conversion/ColorSpaceConverter.CieLchuv.cs
@@ -144,7 +144,7 @@ namespace SixLabors.ImageSharp.ColorSpaces.Conversion
         /// </summary>
         /// <param name="color">The color to convert.</param>
         /// <returns>The <see cref="CieLchuv"/></returns>
-        public CieLchuv ToCieLchuv(Rgb color)
+        public CieLchuv ToCieLchuv(in Rgb color)
         {
             CieXyz xyzColor = this.ToCieXyz(color);
             return this.ToCieLchuv(xyzColor);
diff --git a/src/ImageSharp/Common/Extensions/ComparableExtensions.cs b/src/ImageSharp/Common/Extensions/ComparableExtensions.cs
index d6dade7703..1b0f8ad095 100644
--- a/src/ImageSharp/Common/Extensions/ComparableExtensions.cs
+++ b/src/ImageSharp/Common/Extensions/ComparableExtensions.cs
@@ -137,17 +137,6 @@ namespace SixLabors.ImageSharp
             return value;
         }
 
-        /// <summary>
-        /// Converts an <see cref="int"/> to a <see cref="byte"/> first restricting the value between the
-        /// minimum and maximum allowable ranges.
-        /// </summary>
-        /// <param name="value">The <see cref="int"/> this method extends.</param>
-        /// <returns>The <see cref="byte"/></returns>
-        public static byte ToByte(this int value)
-        {
-            return (byte)value.Clamp(0, 255);
-        }
-
         /// <summary>
         /// Converts an <see cref="float"/> to a <see cref="byte"/> first restricting the value between the
         /// minimum and maximum allowable ranges.
diff --git a/src/ImageSharp/Common/Helpers/ImageMaths.cs b/src/ImageSharp/Common/Helpers/ImageMaths.cs
index 3c48488ecc..c15e0a7329 100644
--- a/src/ImageSharp/Common/Helpers/ImageMaths.cs
+++ b/src/ImageSharp/Common/Helpers/ImageMaths.cs
@@ -36,10 +36,15 @@ namespace SixLabors.ImageSharp
         /// The <see cref="int"/>
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int GetBitsNeededForColorDepth(int colors)
-        {
-            return Math.Max(1, (int)Math.Ceiling(Math.Log(colors, 2)));
-        }
+        public static int GetBitsNeededForColorDepth(int colors) => Math.Max(1, (int)Math.Ceiling(Math.Log(colors, 2)));
+
+        /// <summary>
+        /// Returns how many colors will be created by the specified number of bits.
+        /// </summary>
+        /// <param name="bitDepth">The bit depth.</param>
+        /// <returns>The <see cref="int"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int GetColorCountForBitDepth(int bitDepth) => 1 << bitDepth;
 
         /// <summary>
         /// Implementation of 1D Gaussian G(x) function
@@ -132,10 +137,7 @@ namespace SixLabors.ImageSharp
         /// The bounding <see cref="Rectangle"/>.
         /// </returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Rectangle GetBoundingRectangle(Point topLeft, Point bottomRight)
-        {
-            return new Rectangle(topLeft.X, topLeft.Y, bottomRight.X - topLeft.X, bottomRight.Y - topLeft.Y);
-        }
+        public static Rectangle GetBoundingRectangle(Point topLeft, Point bottomRight) => new Rectangle(topLeft.X, topLeft.Y, bottomRight.X - topLeft.X, bottomRight.Y - topLeft.Y);
 
         /// <summary>
         /// Finds the bounding rectangle based on the first instance of any color component other
diff --git a/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs b/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
index 0029a6b68d..618999c87d 100644
--- a/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpBitsPerPixel.cs
@@ -6,16 +6,16 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Enumerates the available bits per pixel for bitmap.
     /// </summary>
-    public enum BmpBitsPerPixel
+    public enum BmpBitsPerPixel : short
     {
         /// <summary>
         /// 24 bits per pixel. Each pixel consists of 3 bytes.
         /// </summary>
-        Pixel24 = 3,
+        Pixel24 = 24,
 
         /// <summary>
         /// 32 bits per pixel. Each pixel consists of 4 bytes.
         /// </summary>
-        Pixel32 = 4
+        Pixel32 = 32
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Bmp/BmpConfigurationModule.cs b/src/ImageSharp/Formats/Bmp/BmpConfigurationModule.cs
index 956acc1578..57117cc075 100644
--- a/src/ImageSharp/Formats/Bmp/BmpConfigurationModule.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpConfigurationModule.cs
@@ -9,11 +9,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     public sealed class BmpConfigurationModule : IConfigurationModule
     {
         /// <inheritdoc/>
-        public void Configure(Configuration config)
+        public void Configure(Configuration configuration)
         {
-            config.ImageFormatsManager.SetEncoder(ImageFormats.Bmp, new BmpEncoder());
-            config.ImageFormatsManager.SetDecoder(ImageFormats.Bmp, new BmpDecoder());
-            config.ImageFormatsManager.AddImageFormatDetector(new BmpImageFormatDetector());
+            configuration.ImageFormatsManager.SetEncoder(BmpFormat.Instance, new BmpEncoder());
+            configuration.ImageFormatsManager.SetDecoder(BmpFormat.Instance, new BmpDecoder());
+            configuration.ImageFormatsManager.AddImageFormatDetector(new BmpImageFormatDetector());
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
index d67beb0368..71852acddd 100644
--- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
@@ -175,10 +175,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// <param name="inverted">Whether the bitmap is inverted.</param>
         /// <returns>The <see cref="int"/> representing the inverted value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int Invert(int y, int height, bool inverted)
-        {
-            return (!inverted) ? height - y - 1 : y;
-        }
+        private static int Invert(int y, int height, bool inverted) => (!inverted) ? height - y - 1 : y;
 
         /// <summary>
         /// Calculates the amount of bytes to pad a row.
@@ -206,10 +203,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// <param name="value">The masked and shifted value</param>
         /// <returns>The <see cref="byte"/></returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static byte GetBytesFrom5BitValue(int value)
-        {
-            return (byte)((value << 3) | (value >> 2));
-        }
+        private static byte GetBytesFrom5BitValue(int value) => (byte)((value << 3) | (value >> 2));
 
         /// <summary>
         /// Looks up color values and builds the image from de-compressed RLE8 data.
@@ -524,8 +518,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             }
 
             // Resolution is stored in PPM.
-            var meta = new ImageMetaData();
-            meta.ResolutionUnits = PixelResolutionUnit.PixelsPerMeter;
+            var meta = new ImageMetaData
+            {
+                ResolutionUnits = PixelResolutionUnit.PixelsPerMeter
+            };
             if (this.infoHeader.XPelsPerMeter > 0 && this.infoHeader.YPelsPerMeter > 0)
             {
                 meta.HorizontalResolution = this.infoHeader.XPelsPerMeter;
@@ -540,6 +536,16 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             this.metaData = meta;
 
+            short bitsPerPixel = this.infoHeader.BitsPerPixel;
+            var bmpMetaData = this.metaData.GetFormatMetaData(BmpFormat.Instance);
+
+            // We can only encode at these bit rates so far.
+            if (bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel24)
+                || bitsPerPixel.Equals((short)BmpBitsPerPixel.Pixel32))
+            {
+                bmpMetaData.BitsPerPixel = (BmpBitsPerPixel)bitsPerPixel;
+            }
+
             // skip the remaining header because we can't read those parts
             this.stream.Skip(skipAmount);
         }
@@ -585,11 +591,11 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
             if (this.infoHeader.ClrUsed == 0)
             {
-                if (this.infoHeader.BitsPerPixel == 1 ||
-                    this.infoHeader.BitsPerPixel == 4 ||
-                    this.infoHeader.BitsPerPixel == 8)
+                if (this.infoHeader.BitsPerPixel == 1
+                    || this.infoHeader.BitsPerPixel == 4
+                    || this.infoHeader.BitsPerPixel == 8)
                 {
-                    colorMapSize = (int)Math.Pow(2, this.infoHeader.BitsPerPixel) * 4;
+                    colorMapSize = ImageMaths.GetColorCountForBitDepth(this.infoHeader.BitsPerPixel) * 4;
                 }
             }
             else
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoder.cs b/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
index 23b01ae9e8..b1a66accec 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoder.cs
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// <summary>
         /// Gets or sets the number of bits per pixel.
         /// </summary>
-        public BmpBitsPerPixel BitsPerPixel { get; set; } = BmpBitsPerPixel.Pixel24;
+        public BmpBitsPerPixel? BitsPerPixel { get; set; }
 
         /// <inheritdoc/>
         public void Encode<TPixel>(Image<TPixel> image, Stream stream)
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index b49b8a8959..44e42528cf 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -21,10 +21,10 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// </summary>
         private int padding;
 
-        private readonly BmpBitsPerPixel bitsPerPixel;
-
         private readonly MemoryAllocator memoryAllocator;
 
+        private BmpBitsPerPixel? bitsPerPixel;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="BmpEncoderCore"/> class.
         /// </summary>
@@ -48,37 +48,39 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));
 
-            // Cast to int will get the bytes per pixel
-            short bpp = (short)(8 * (int)this.bitsPerPixel);
+            ImageMetaData metaData = image.MetaData;
+            BmpMetaData bmpMetaData = metaData.GetFormatMetaData(BmpFormat.Instance);
+            this.bitsPerPixel = this.bitsPerPixel ?? bmpMetaData.BitsPerPixel;
+
+            short bpp = (short)this.bitsPerPixel;
             int bytesPerLine = 4 * (((image.Width * bpp) + 31) / 32);
-            this.padding = bytesPerLine - (image.Width * (int)this.bitsPerPixel);
+            this.padding = bytesPerLine - (int)(image.Width * (bpp / 8F));
 
             // Set Resolution.
-            ImageMetaData meta = image.MetaData;
             int hResolution = 0;
             int vResolution = 0;
 
-            if (meta.ResolutionUnits != PixelResolutionUnit.AspectRatio)
+            if (metaData.ResolutionUnits != PixelResolutionUnit.AspectRatio)
             {
-                if (meta.HorizontalResolution > 0 && meta.VerticalResolution > 0)
+                if (metaData.HorizontalResolution > 0 && metaData.VerticalResolution > 0)
                 {
-                    switch (meta.ResolutionUnits)
+                    switch (metaData.ResolutionUnits)
                     {
                         case PixelResolutionUnit.PixelsPerInch:
 
-                            hResolution = (int)Math.Round(UnitConverter.InchToMeter(meta.HorizontalResolution));
-                            vResolution = (int)Math.Round(UnitConverter.InchToMeter(meta.VerticalResolution));
+                            hResolution = (int)Math.Round(UnitConverter.InchToMeter(metaData.HorizontalResolution));
+                            vResolution = (int)Math.Round(UnitConverter.InchToMeter(metaData.VerticalResolution));
                             break;
 
                         case PixelResolutionUnit.PixelsPerCentimeter:
 
-                            hResolution = (int)Math.Round(UnitConverter.CmToMeter(meta.HorizontalResolution));
-                            vResolution = (int)Math.Round(UnitConverter.CmToMeter(meta.VerticalResolution));
+                            hResolution = (int)Math.Round(UnitConverter.CmToMeter(metaData.HorizontalResolution));
+                            vResolution = (int)Math.Round(UnitConverter.CmToMeter(metaData.VerticalResolution));
                             break;
 
                         case PixelResolutionUnit.PixelsPerMeter:
-                            hResolution = (int)Math.Round(meta.HorizontalResolution);
-                            vResolution = (int)Math.Round(meta.VerticalResolution);
+                            hResolution = (int)Math.Round(metaData.HorizontalResolution);
+                            vResolution = (int)Math.Round(metaData.VerticalResolution);
 
                             break;
                     }
@@ -145,10 +147,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
             }
         }
 
-        private IManagedByteBuffer AllocateRow(int width, int bytesPerPixel)
-        {
-            return this.memoryAllocator.AllocatePaddedPixelRowBuffer(width, bytesPerPixel, this.padding);
-        }
+        private IManagedByteBuffer AllocateRow(int width, int bytesPerPixel) => this.memoryAllocator.AllocatePaddedPixelRowBuffer(width, bytesPerPixel, this.padding);
 
         /// <summary>
         /// Writes the 32bit color palette to the stream.
diff --git a/src/ImageSharp/Formats/Bmp/BmpFormat.cs b/src/ImageSharp/Formats/Bmp/BmpFormat.cs
index 64c6574c1e..a5eaab8ebf 100644
--- a/src/ImageSharp/Formats/Bmp/BmpFormat.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpFormat.cs
@@ -8,8 +8,17 @@ namespace SixLabors.ImageSharp.Formats.Bmp
     /// <summary>
     /// Registers the image encoders, decoders and mime type detectors for the bmp format.
     /// </summary>
-    internal sealed class BmpFormat : IImageFormat
+    public sealed class BmpFormat : IImageFormat<BmpMetaData>
     {
+        private BmpFormat()
+        {
+        }
+
+        /// <summary>
+        /// Gets the current instance.
+        /// </summary>
+        public static BmpFormat Instance { get; } = new BmpFormat();
+
         /// <inheritdoc/>
         public string Name => "BMP";
 
@@ -21,5 +30,8 @@ namespace SixLabors.ImageSharp.Formats.Bmp
 
         /// <inheritdoc/>
         public IEnumerable<string> FileExtensions => BmpConstants.FileExtensions;
+
+        /// <inheritdoc/>
+        public BmpMetaData CreateDefaultFormatMetaData() => new BmpMetaData();
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Bmp/BmpImageFormatDetector.cs b/src/ImageSharp/Formats/Bmp/BmpImageFormatDetector.cs
index bb884019b7..6a740d47d1 100644
--- a/src/ImageSharp/Formats/Bmp/BmpImageFormatDetector.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpImageFormatDetector.cs
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// <inheritdoc/>
         public IImageFormat DetectFormat(ReadOnlySpan<byte> header)
         {
-            return this.IsSupportedFileFormat(header) ? ImageFormats.Bmp : null;
+            return this.IsSupportedFileFormat(header) ? BmpFormat.Instance : null;
         }
 
         private bool IsSupportedFileFormat(ReadOnlySpan<byte> header)
diff --git a/src/ImageSharp/Formats/Bmp/BmpMetaData.cs b/src/ImageSharp/Formats/Bmp/BmpMetaData.cs
new file mode 100644
index 0000000000..3d678c13e1
--- /dev/null
+++ b/src/ImageSharp/Formats/Bmp/BmpMetaData.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Bmp
+{
+    /// <summary>
+    /// Provides Bmp specific metadata information for the image.
+    /// </summary>
+    public class BmpMetaData
+    {
+        /// <summary>
+        /// Gets or sets the number of bits per pixel.
+        /// </summary>
+        public BmpBitsPerPixel BitsPerPixel { get; set; } = BmpBitsPerPixel.Pixel24;
+
+        // TODO: Colors used once we support encoding palette bmps.
+    }
+}
diff --git a/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs b/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
index 56952f0356..f62504d08f 100644
--- a/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Bmp/IBmpEncoderOptions.cs
@@ -12,6 +12,6 @@ namespace SixLabors.ImageSharp.Formats.Bmp
         /// <summary>
         /// Gets the number of bits per pixel.
         /// </summary>
-        BmpBitsPerPixel BitsPerPixel { get; }
+        BmpBitsPerPixel? BitsPerPixel { get; }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Bmp/ImageExtensions.cs b/src/ImageSharp/Formats/Bmp/ImageExtensions.cs
index 57e4615bad..aa1c353db2 100644
--- a/src/ImageSharp/Formats/Bmp/ImageExtensions.cs
+++ b/src/ImageSharp/Formats/Bmp/ImageExtensions.cs
@@ -34,6 +34,6 @@ namespace SixLabors.ImageSharp
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
         public static void SaveAsBmp<TPixel>(this Image<TPixel> source, Stream stream, BmpEncoder encoder)
             where TPixel : struct, IPixel<TPixel>
-                        => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(ImageFormats.Bmp));
+                        => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(BmpFormat.Instance));
     }
 }
diff --git a/src/ImageSharp/Formats/Gif/GifColorTableMode.cs b/src/ImageSharp/Formats/Gif/GifColorTableMode.cs
index aa41928633..95b3335626 100644
--- a/src/ImageSharp/Formats/Gif/GifColorTableMode.cs
+++ b/src/ImageSharp/Formats/Gif/GifColorTableMode.cs
@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Formats.Gif
 {
     /// <summary>
-    /// Provides enumeration for the available Gif color table modes.
+    /// Provides enumeration for the available color table modes.
     /// </summary>
     public enum GifColorTableMode
     {
diff --git a/src/ImageSharp/Formats/Gif/GifConfigurationModule.cs b/src/ImageSharp/Formats/Gif/GifConfigurationModule.cs
index 0bb62779eb..861d3e0368 100644
--- a/src/ImageSharp/Formats/Gif/GifConfigurationModule.cs
+++ b/src/ImageSharp/Formats/Gif/GifConfigurationModule.cs
@@ -9,12 +9,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
     public sealed class GifConfigurationModule : IConfigurationModule
     {
         /// <inheritdoc/>
-        public void Configure(Configuration config)
+        public void Configure(Configuration configuration)
         {
-            config.ImageFormatsManager.SetEncoder(ImageFormats.Gif, new GifEncoder());
-            config.ImageFormatsManager.SetDecoder(ImageFormats.Gif, new GifDecoder());
-
-            config.ImageFormatsManager.AddImageFormatDetector(new GifImageFormatDetector());
+            configuration.ImageFormatsManager.SetEncoder(GifFormat.Instance, new GifEncoder());
+            configuration.ImageFormatsManager.SetDecoder(GifFormat.Instance, new GifDecoder());
+            configuration.ImageFormatsManager.AddImageFormatDetector(new GifImageFormatDetector());
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/GifConstants.cs b/src/ImageSharp/Formats/Gif/GifConstants.cs
index 0dbd39b992..8167d0d2e0 100644
--- a/src/ImageSharp/Formats/Gif/GifConstants.cs
+++ b/src/ImageSharp/Formats/Gif/GifConstants.cs
@@ -41,20 +41,25 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// </summary>
         public const byte ApplicationExtensionLabel = 0xFF;
 
+        /// <summary>
+        /// The application block size.
+        /// </summary>
+        public const byte ApplicationBlockSize = 11;
+
         /// <summary>
         /// The application identification.
         /// </summary>
-        public const string ApplicationIdentification = "NETSCAPE2.0";
+        public const string NetscapeApplicationIdentification = "NETSCAPE2.0";
 
         /// <summary>
         /// The ASCII encoded application identification bytes.
         /// </summary>
-        internal static readonly byte[] ApplicationIdentificationBytes = Encoding.UTF8.GetBytes(ApplicationIdentification);
+        internal static readonly byte[] NetscapeApplicationIdentificationBytes = Encoding.UTF8.GetBytes(NetscapeApplicationIdentification);
 
         /// <summary>
-        /// The application block size.
+        /// The Netscape looping application sub block size.
         /// </summary>
-        public const byte ApplicationBlockSize = 11;
+        public const byte NetscapeLoopingSubBlockSize = 3;
 
         /// <summary>
         /// The comment label.
diff --git a/src/ImageSharp/Formats/Gif/GifDecoder.cs b/src/ImageSharp/Formats/Gif/GifDecoder.cs
index ac451a3550..42c76d6400 100644
--- a/src/ImageSharp/Formats/Gif/GifDecoder.cs
+++ b/src/ImageSharp/Formats/Gif/GifDecoder.cs
@@ -3,6 +3,7 @@
 
 using System.IO;
 using System.Text;
+using SixLabors.ImageSharp.MetaData;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace SixLabors.ImageSharp.Formats.Gif
diff --git a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
index 2a4d981ebb..207f126f9e 100644
--- a/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifDecoderCore.cs
@@ -56,10 +56,20 @@ namespace SixLabors.ImageSharp.Formats.Gif
         private GifGraphicControlExtension graphicsControlExtension;
 
         /// <summary>
-        /// The metadata
+        /// The image desciptor.
+        /// </summary>
+        private GifImageDescriptor imageDescriptor;
+
+        /// <summary>
+        /// The abstract metadata.
         /// </summary>
         private ImageMetaData metaData;
 
+        /// <summary>
+        /// The gif specific metadata.
+        /// </summary>
+        private GifMetaData gifMetaData;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GifDecoderCore"/> class.
         /// </summary>
@@ -120,8 +130,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                     }
                     else if (nextFlag == GifConstants.ExtensionIntroducer)
                     {
-                        int label = stream.ReadByte();
-                        switch (label)
+                        switch (stream.ReadByte())
                         {
                             case GifConstants.GraphicControlLabel:
                                 this.ReadGraphicalControlExtension();
@@ -130,11 +139,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                                 this.ReadComments();
                                 break;
                             case GifConstants.ApplicationExtensionLabel:
-
-                                // The application extension length should be 11 but we've got test images that incorrectly
-                                // set this to 252.
-                                int appLength = stream.ReadByte();
-                                this.Skip(appLength); // No need to read.
+                                this.ReadApplicationExtension();
                                 break;
                             case GifConstants.PlainTextLabel:
                                 int plainLength = stream.ReadByte();
@@ -178,13 +183,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 {
                     if (nextFlag == GifConstants.ImageLabel)
                     {
-                        // Skip image block
-                        this.Skip(0);
+                        this.ReadImageDescriptor();
                     }
                     else if (nextFlag == GifConstants.ExtensionIntroducer)
                     {
-                        int label = stream.ReadByte();
-                        switch (label)
+                        switch (stream.ReadByte())
                         {
                             case GifConstants.GraphicControlLabel:
 
@@ -195,11 +198,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                                 this.ReadComments();
                                 break;
                             case GifConstants.ApplicationExtensionLabel:
-
-                                // The application extension length should be 11 but we've got test images that incorrectly
-                                // set this to 252.
-                                int appLength = stream.ReadByte();
-                                this.Skip(appLength); // No need to read.
+                                this.ReadApplicationExtension();
                                 break;
                             case GifConstants.PlainTextLabel:
                                 int plainLength = stream.ReadByte();
@@ -224,7 +223,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 this.globalColorTable?.Dispose();
             }
 
-            return new ImageInfo(new PixelTypeInfo(this.logicalScreenDescriptor.BitsPerPixel), this.logicalScreenDescriptor.Width, this.logicalScreenDescriptor.Height, this.metaData);
+            return new ImageInfo(
+                new PixelTypeInfo(this.logicalScreenDescriptor.BitsPerPixel),
+                this.logicalScreenDescriptor.Width,
+                this.logicalScreenDescriptor.Height,
+                this.metaData);
         }
 
         /// <summary>
@@ -238,14 +241,13 @@ namespace SixLabors.ImageSharp.Formats.Gif
         }
 
         /// <summary>
-        /// Reads the image descriptor
+        /// Reads the image descriptor.
         /// </summary>
-        /// <returns><see cref="GifImageDescriptor"/></returns>
-        private GifImageDescriptor ReadImageDescriptor()
+        private void ReadImageDescriptor()
         {
             this.stream.Read(this.buffer, 0, 9);
 
-            return GifImageDescriptor.Parse(this.buffer);
+            this.imageDescriptor = GifImageDescriptor.Parse(this.buffer);
         }
 
         /// <summary>
@@ -258,6 +260,41 @@ namespace SixLabors.ImageSharp.Formats.Gif
             this.logicalScreenDescriptor = GifLogicalScreenDescriptor.Parse(this.buffer);
         }
 
+        /// <summary>
+        /// Reads the application extension block parsing any animation information
+        /// if present.
+        /// </summary>
+        private void ReadApplicationExtension()
+        {
+            int appLength = this.stream.ReadByte();
+
+            // If the length is 11 then it's a valid extension and most likely
+            // a NETSCAPE or ANIMEXTS extension. We want the loop count from this.
+            if (appLength == GifConstants.ApplicationBlockSize)
+            {
+                this.stream.Skip(appLength);
+                int subBlockSize = this.stream.ReadByte();
+
+                // TODO: There's also a NETSCAPE buffer extension.
+                // http://www.vurdalakov.net/misc/gif/netscape-buffering-application-extension
+                if (subBlockSize == GifConstants.NetscapeLoopingSubBlockSize)
+                {
+                    this.stream.Read(this.buffer, 0, GifConstants.NetscapeLoopingSubBlockSize);
+                    this.gifMetaData.RepeatCount = GifNetscapeLoopingApplicationExtension.Parse(this.buffer.AsSpan(1)).RepeatCount;
+                    this.stream.Skip(1); // Skip the terminator.
+                    return;
+                }
+
+                // Could be XMP or something else not supported yet.
+                // Back up and skip.
+                this.stream.Position -= appLength + 1;
+                this.Skip(appLength);
+                return;
+            }
+
+            this.Skip(appLength); // Not supported by any known decoder.
+        }
+
         /// <summary>
         /// Skips the designated number of bytes in the stream.
         /// </summary>
@@ -312,25 +349,25 @@ namespace SixLabors.ImageSharp.Formats.Gif
         private void ReadFrame<TPixel>(ref Image<TPixel> image, ref ImageFrame<TPixel> previousFrame)
             where TPixel : struct, IPixel<TPixel>
         {
-            GifImageDescriptor imageDescriptor = this.ReadImageDescriptor();
+            this.ReadImageDescriptor();
 
             IManagedByteBuffer localColorTable = null;
             IManagedByteBuffer indices = null;
             try
             {
                 // Determine the color table for this frame. If there is a local one, use it otherwise use the global color table.
-                if (imageDescriptor.LocalColorTableFlag)
+                if (this.imageDescriptor.LocalColorTableFlag)
                 {
-                    int length = imageDescriptor.LocalColorTableSize * 3;
+                    int length = this.imageDescriptor.LocalColorTableSize * 3;
                     localColorTable = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(length, AllocationOptions.Clean);
                     this.stream.Read(localColorTable.Array, 0, length);
                 }
 
-                indices = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(imageDescriptor.Width * imageDescriptor.Height, AllocationOptions.Clean);
+                indices = this.configuration.MemoryAllocator.AllocateManagedByteBuffer(this.imageDescriptor.Width * this.imageDescriptor.Height, AllocationOptions.Clean);
 
-                this.ReadFrameIndices(imageDescriptor, indices.GetSpan());
+                this.ReadFrameIndices(this.imageDescriptor, indices.GetSpan());
                 ReadOnlySpan<Rgb24> colorTable = MemoryMarshal.Cast<byte, Rgb24>((localColorTable ?? this.globalColorTable).GetSpan());
-                this.ReadFrameColors(ref image, ref previousFrame, indices.GetSpan(), colorTable, imageDescriptor);
+                this.ReadFrameColors(ref image, ref previousFrame, indices.GetSpan(), colorTable, this.imageDescriptor);
 
                 // Skip any remaining blocks
                 this.Skip(0);
@@ -388,7 +425,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
             }
             else
             {
-                if (this.graphicsControlExtension.DisposalMethod == DisposalMethod.RestoreToPrevious)
+                if (this.graphicsControlExtension.DisposalMethod == GifDisposalMethod.RestoreToPrevious)
                 {
                     prevFrame = previousFrame;
                 }
@@ -471,7 +508,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
             previousFrame = currentFrame ?? image.Frames.RootFrame;
 
-            if (this.graphicsControlExtension.DisposalMethod == DisposalMethod.RestoreToBackground)
+            if (this.graphicsControlExtension.DisposalMethod == GifDisposalMethod.RestoreToBackground)
             {
                 this.restoreArea = new Rectangle(descriptor.Left, descriptor.Top, descriptor.Width, descriptor.Height);
             }
@@ -503,12 +540,25 @@ namespace SixLabors.ImageSharp.Formats.Gif
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void SetFrameMetaData(ImageFrameMetaData meta)
         {
+            GifFrameMetaData gifMeta = meta.GetFormatMetaData(GifFormat.Instance);
             if (this.graphicsControlExtension.DelayTime > 0)
             {
-                meta.FrameDelay = this.graphicsControlExtension.DelayTime;
+                gifMeta.FrameDelay = this.graphicsControlExtension.DelayTime;
+            }
+
+            // Frames can either use the global table or their own local table.
+            if (this.logicalScreenDescriptor.GlobalColorTableFlag
+                && this.logicalScreenDescriptor.GlobalColorTableSize > 0)
+            {
+                gifMeta.ColorTableLength = this.logicalScreenDescriptor.GlobalColorTableSize;
+            }
+            else if (this.imageDescriptor.LocalColorTableFlag
+                && this.imageDescriptor.LocalColorTableSize > 0)
+            {
+                gifMeta.ColorTableLength = this.imageDescriptor.LocalColorTableSize;
             }
 
-            meta.DisposalMethod = this.graphicsControlExtension.DisposalMethod;
+            gifMeta.DisposalMethod = this.graphicsControlExtension.DisposalMethod;
         }
 
         /// <summary>
@@ -552,10 +602,15 @@ namespace SixLabors.ImageSharp.Formats.Gif
             }
 
             this.metaData = meta;
+            this.gifMetaData = meta.GetFormatMetaData(GifFormat.Instance);
+            this.gifMetaData.ColorTableMode = this.logicalScreenDescriptor.GlobalColorTableFlag
+            ? GifColorTableMode.Global
+            : GifColorTableMode.Local;
 
             if (this.logicalScreenDescriptor.GlobalColorTableFlag)
             {
                 int globalColorTableLength = this.logicalScreenDescriptor.GlobalColorTableSize * 3;
+                this.gifMetaData.GlobalColorTableLength = globalColorTableLength;
 
                 this.globalColorTable = this.MemoryAllocator.AllocateManagedByteBuffer(globalColorTableLength, AllocationOptions.Clean);
 
diff --git a/src/ImageSharp/Formats/Gif/DisposalMethod.cs b/src/ImageSharp/Formats/Gif/GifDisposalMethod.cs
similarity index 97%
rename from src/ImageSharp/Formats/Gif/DisposalMethod.cs
rename to src/ImageSharp/Formats/Gif/GifDisposalMethod.cs
index 5d3e1b4d89..982340db66 100644
--- a/src/ImageSharp/Formats/Gif/DisposalMethod.cs
+++ b/src/ImageSharp/Formats/Gif/GifDisposalMethod.cs
@@ -8,7 +8,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
     /// in an animation sequence.
     /// <see href="http://www.w3.org/Graphics/GIF/spec-gif89a.txt"/> section 23
     /// </summary>
-    public enum DisposalMethod
+    public enum GifDisposalMethod
     {
         /// <summary>
         /// No disposal specified.
diff --git a/src/ImageSharp/Formats/Gif/GifEncoder.cs b/src/ImageSharp/Formats/Gif/GifEncoder.cs
index e8e28ccdd8..4210b08765 100644
--- a/src/ImageSharp/Formats/Gif/GifEncoder.cs
+++ b/src/ImageSharp/Formats/Gif/GifEncoder.cs
@@ -14,11 +14,6 @@ namespace SixLabors.ImageSharp.Formats.Gif
     /// </summary>
     public sealed class GifEncoder : IImageEncoder, IGifEncoderOptions
     {
-        /// <summary>
-        /// Gets or sets a value indicating whether the metadata should be ignored when the image is being encoded.
-        /// </summary>
-        public bool IgnoreMetadata { get; set; } = false;
-
         /// <summary>
         /// Gets or sets the encoding that should be used when writing comments.
         /// </summary>
@@ -33,7 +28,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Gets or sets the color table mode: Global or local.
         /// </summary>
-        public GifColorTableMode ColorTableMode { get; set; }
+        public GifColorTableMode? ColorTableMode { get; set; }
 
         /// <inheritdoc/>
         public void Encode<TPixel>(Image<TPixel> image, Stream stream)
diff --git a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
index 5532900355..ae0366e6e6 100644
--- a/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
+++ b/src/ImageSharp/Formats/Gif/GifEncoderCore.cs
@@ -2,7 +2,6 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Buffers.Binary;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -44,17 +43,17 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// The color table mode: Global or local.
         /// </summary>
-        private readonly GifColorTableMode colorTableMode;
+        private GifColorTableMode? colorTableMode;
 
         /// <summary>
-        /// A flag indicating whether to ingore the metadata when writing the image.
+        /// The number of bits requires to store the color palette.
         /// </summary>
-        private readonly bool ignoreMetadata;
+        private int bitDepth;
 
         /// <summary>
-        /// The number of bits requires to store the color palette.
+        /// Gif specific meta data.
         /// </summary>
-        private int bitDepth;
+        private GifMetaData gifMetaData;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="GifEncoderCore"/> class.
@@ -67,7 +66,6 @@ namespace SixLabors.ImageSharp.Formats.Gif
             this.textEncoding = options.TextEncoding ?? GifConstants.DefaultEncoding;
             this.quantizer = options.Quantizer;
             this.colorTableMode = options.ColorTableMode;
-            this.ignoreMetadata = options.IgnoreMetadata;
         }
 
         /// <summary>
@@ -82,6 +80,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));
 
+            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);
@@ -94,8 +97,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
             // Write the LSD.
             int index = this.GetTransparentIndex(quantized);
-            bool useGlobalTable = this.colorTableMode.Equals(GifColorTableMode.Global);
-            this.WriteLogicalScreenDescriptor(image, index, useGlobalTable, stream);
+            this.WriteLogicalScreenDescriptor(metaData, image.Width, image.Height, index, useGlobalTable, stream);
 
             if (useGlobalTable)
             {
@@ -103,12 +105,12 @@ namespace SixLabors.ImageSharp.Formats.Gif
             }
 
             // Write the comments.
-            this.WriteComments(image.MetaData, stream);
+            this.WriteComments(metaData, stream);
 
             // Write application extension to allow additional frames.
             if (image.Frames.Count > 1)
             {
-                this.WriteApplicationExtension(stream, image.MetaData.RepeatCount);
+                this.WriteApplicationExtension(stream, this.gifMetaData.RepeatCount);
             }
 
             if (useGlobalTable)
@@ -136,8 +138,9 @@ namespace SixLabors.ImageSharp.Formats.Gif
             for (int i = 0; i < image.Frames.Count; i++)
             {
                 ImageFrame<TPixel> frame = image.Frames[i];
-
-                this.WriteGraphicalControlExtension(frame.MetaData, transparencyIndex, stream);
+                ImageFrameMetaData metaData = frame.MetaData;
+                GifFrameMetaData frameMetaData = metaData.GetFormatMetaData(GifFormat.Instance);
+                this.WriteGraphicalControlExtension(frameMetaData, transparencyIndex, stream);
                 this.WriteImageDescriptor(frame, false, stream);
 
                 if (i == 0)
@@ -146,7 +149,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 }
                 else
                 {
-                    using (QuantizedFrame<TPixel> paletteQuantized = palleteQuantizer.CreateFrameQuantizer(() => quantized.Palette).QuantizeFrame(frame))
+                    using (QuantizedFrame<TPixel> paletteQuantized
+                        = palleteQuantizer.CreateFrameQuantizer(() => quantized.Palette).QuantizeFrame(frame))
                     {
                         this.WriteImageData(paletteQuantized, stream);
                     }
@@ -157,20 +161,37 @@ namespace SixLabors.ImageSharp.Formats.Gif
         private void EncodeLocal<TPixel>(Image<TPixel> image, QuantizedFrame<TPixel> quantized, Stream stream)
             where TPixel : struct, IPixel<TPixel>
         {
+            ImageFrame<TPixel> previousFrame = null;
+            GifFrameMetaData previousMeta = null;
             foreach (ImageFrame<TPixel> frame in image.Frames)
             {
+                ImageFrameMetaData metaData = frame.MetaData;
+                GifFrameMetaData frameMetaData = metaData.GetFormatMetaData(GifFormat.Instance);
                 if (quantized is null)
                 {
-                    quantized = this.quantizer.CreateFrameQuantizer<TPixel>().QuantizeFrame(frame);
+                    // 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)
+                    {
+                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>(frameMetaData.ColorTableLength).QuantizeFrame(frame);
+                    }
+                    else
+                    {
+                        quantized = this.quantizer.CreateFrameQuantizer<TPixel>().QuantizeFrame(frame);
+                    }
                 }
 
-                this.WriteGraphicalControlExtension(frame.MetaData, this.GetTransparentIndex(quantized), stream);
+                this.bitDepth = ImageMaths.GetBitsNeededForColorDepth(quantized.Palette.Length).Clamp(1, 8);
+                this.WriteGraphicalControlExtension(frameMetaData, this.GetTransparentIndex(quantized), stream);
                 this.WriteImageDescriptor(frame, true, stream);
                 this.WriteColorTable(quantized, stream);
                 this.WriteImageData(quantized, stream);
 
                 quantized?.Dispose();
                 quantized = null; // So next frame can regenerate it
+                previousFrame = frame;
+                previousMeta = frameMetaData;
             }
         }
 
@@ -210,21 +231,24 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// </summary>
         /// <param name="stream">The stream to write to.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void WriteHeader(Stream stream)
-        {
-            stream.Write(GifConstants.MagicNumber, 0, GifConstants.MagicNumber.Length);
-        }
+        private void WriteHeader(Stream stream) => stream.Write(GifConstants.MagicNumber, 0, GifConstants.MagicNumber.Length);
 
         /// <summary>
         /// Writes the logical screen descriptor to the stream.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="image">The image to encode.</param>
+        /// <param name="metaData">The image metadata.</param>
+        /// <param name="width">The image width.</param>
+        /// <param name="height">The image height.</param>
         /// <param name="transparencyIndex">The transparency index to set the default background index to.</param>
         /// <param name="useGlobalTable">Whether to use a global or local color table.</param>
         /// <param name="stream">The stream to write to.</param>
-        private void WriteLogicalScreenDescriptor<TPixel>(Image<TPixel> image, int transparencyIndex, bool useGlobalTable, Stream stream)
-            where TPixel : struct, IPixel<TPixel>
+        private void WriteLogicalScreenDescriptor(
+            ImageMetaData metaData,
+            int width,
+            int height,
+            int transparencyIndex,
+            bool useGlobalTable,
+            Stream stream)
         {
             byte packedValue = GifLogicalScreenDescriptor.GetPackedValue(useGlobalTable, this.bitDepth - 1, false, this.bitDepth - 1);
 
@@ -237,13 +261,12 @@ namespace SixLabors.ImageSharp.Formats.Gif
             //            1..255 -   Value used in the computation.
             //
             // Aspect Ratio = (Pixel Aspect Ratio + 15) / 64
-            ImageMetaData meta = image.MetaData;
             byte ratio = 0;
 
-            if (meta.ResolutionUnits == PixelResolutionUnit.AspectRatio)
+            if (metaData.ResolutionUnits == PixelResolutionUnit.AspectRatio)
             {
-                double hr = meta.HorizontalResolution;
-                double vr = meta.VerticalResolution;
+                double hr = metaData.HorizontalResolution;
+                double vr = metaData.VerticalResolution;
                 if (hr != vr)
                 {
                     if (hr > vr)
@@ -258,8 +281,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
             }
 
             var descriptor = new GifLogicalScreenDescriptor(
-                width: (ushort)image.Width,
-                height: (ushort)image.Height,
+                width: (ushort)width,
+                height: (ushort)height,
                 packed: packedValue,
                 backgroundColorIndex: unchecked((byte)transparencyIndex),
                 ratio);
@@ -279,25 +302,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
             // Application Extension Header
             if (repeatCount != 1)
             {
-                this.buffer[0] = GifConstants.ExtensionIntroducer;
-                this.buffer[1] = GifConstants.ApplicationExtensionLabel;
-                this.buffer[2] = GifConstants.ApplicationBlockSize;
-
-                // Write NETSCAPE2.0
-                GifConstants.ApplicationIdentificationBytes.AsSpan().CopyTo(this.buffer.AsSpan(3, 11));
-
-                // Application Data ----
-                this.buffer[14] = 3; // Application block length
-                this.buffer[15] = 1; // Data sub-block index (always 1)
-
-                // 0 means loop indefinitely. Count is set as play n + 1 times.
-                repeatCount = (ushort)Math.Max(0, repeatCount - 1);
-
-                BinaryPrimitives.WriteUInt16LittleEndian(this.buffer.AsSpan(16, 2), repeatCount); // Repeat count for images.
-
-                this.buffer[18] = GifConstants.Terminator; // Terminator
-
-                stream.Write(this.buffer, 0, 19);
+                var loopingExtension = new GifNetscapeLoopingApplicationExtension(repeatCount);
+                this.WriteExtension(loopingExtension, stream);
             }
         }
 
@@ -308,11 +314,6 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <param name="stream">The stream to write to.</param>
         private void WriteComments(ImageMetaData metadata, Stream stream)
         {
-            if (this.ignoreMetadata)
-            {
-                return;
-            }
-
             if (!metadata.TryGetProperty(GifConstants.Comments, out ImageProperty property) || string.IsNullOrEmpty(property.Value))
             {
                 return;
@@ -337,7 +338,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <param name="metaData">The metadata of the image or frame.</param>
         /// <param name="transparencyIndex">The index of the color in the color palette to make transparent.</param>
         /// <param name="stream">The stream to write to.</param>
-        private void WriteGraphicalControlExtension(ImageFrameMetaData metaData, int transparencyIndex, Stream stream)
+        private void WriteGraphicalControlExtension(GifFrameMetaData metaData, int transparencyIndex, Stream stream)
         {
             byte packedValue = GifGraphicControlExtension.GetPackedValue(
                 disposalMethod: metaData.DisposalMethod,
@@ -382,7 +383,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 localColorTableFlag: hasColorTable,
                 interfaceFlag: false,
                 sortFlag: false,
-                localColorTableSize: (byte)this.bitDepth);
+                localColorTableSize: this.bitDepth - 1);
 
             var descriptor = new GifImageDescriptor(
                 left: 0,
@@ -407,7 +408,8 @@ namespace SixLabors.ImageSharp.Formats.Gif
         {
             int pixelCount = image.Palette.Length;
 
-            int colorTableLength = (int)Math.Pow(2, this.bitDepth) * 3; // The maximium number of colors for the bit depth
+            // The maximium number of colors for the bit depth
+            int colorTableLength = ImageMaths.GetColorCountForBitDepth(this.bitDepth) * 3;
             Rgb24 rgb = default;
 
             using (IManagedByteBuffer colorTable = this.memoryAllocator.AllocateManagedByteBuffer(colorTableLength))
diff --git a/src/ImageSharp/Formats/Gif/GifFormat.cs b/src/ImageSharp/Formats/Gif/GifFormat.cs
index 6353690f47..07d4a54547 100644
--- a/src/ImageSharp/Formats/Gif/GifFormat.cs
+++ b/src/ImageSharp/Formats/Gif/GifFormat.cs
@@ -8,8 +8,17 @@ namespace SixLabors.ImageSharp.Formats.Gif
     /// <summary>
     /// Registers the image encoders, decoders and mime type detectors for the gif format.
     /// </summary>
-    internal sealed class GifFormat : IImageFormat
+    public sealed class GifFormat : IImageFormat<GifMetaData, GifFrameMetaData>
     {
+        private GifFormat()
+        {
+        }
+
+        /// <summary>
+        /// Gets the current instance.
+        /// </summary>
+        public static GifFormat Instance { get; } = new GifFormat();
+
         /// <inheritdoc/>
         public string Name => "GIF";
 
@@ -21,5 +30,11 @@ namespace SixLabors.ImageSharp.Formats.Gif
 
         /// <inheritdoc/>
         public IEnumerable<string> FileExtensions => GifConstants.FileExtensions;
+
+        /// <inheritdoc/>
+        public GifMetaData CreateDefaultFormatMetaData() => new GifMetaData();
+
+        /// <inheritdoc/>
+        public GifFrameMetaData CreateDefaultFormatFrameMetaData() => new GifFrameMetaData();
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/GifFrameMetaData.cs b/src/ImageSharp/Formats/Gif/GifFrameMetaData.cs
new file mode 100644
index 0000000000..cc04d48314
--- /dev/null
+++ b/src/ImageSharp/Formats/Gif/GifFrameMetaData.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Gif
+{
+    /// <summary>
+    /// Provides Gif specific metadata information for the image frame.
+    /// </summary>
+    public class GifFrameMetaData
+    {
+        /// <summary>
+        /// Gets or sets the length of the color table for paletted images.
+        /// If not 0, then this field indicates the maximum number of colors to use when quantizing the
+        /// image frame.
+        /// </summary>
+        public int ColorTableLength { get; set; }
+
+        /// <summary>
+        /// Gets or sets the frame delay for animated images.
+        /// If not 0, when utilized in Gif animation, this field specifies the number of hundredths (1/100) of a second to
+        /// wait before continuing with the processing of the Data Stream.
+        /// The clock starts ticking immediately after the graphic is rendered.
+        /// </summary>
+        public int FrameDelay { get; set; }
+
+        /// <summary>
+        /// Gets or sets the disposal method for animated images.
+        /// Primarily used in Gif animation, this field indicates the way in which the graphic is to
+        /// be treated after being displayed.
+        /// </summary>
+        public GifDisposalMethod DisposalMethod { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/GifImageFormatDetector.cs b/src/ImageSharp/Formats/Gif/GifImageFormatDetector.cs
index bfbd334b01..b8f9a03f1a 100644
--- a/src/ImageSharp/Formats/Gif/GifImageFormatDetector.cs
+++ b/src/ImageSharp/Formats/Gif/GifImageFormatDetector.cs
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <inheritdoc/>
         public IImageFormat DetectFormat(ReadOnlySpan<byte> header)
         {
-            return this.IsSupportedFileFormat(header) ? ImageFormats.Gif : null;
+            return this.IsSupportedFileFormat(header) ? GifFormat.Instance : null;
         }
 
         private bool IsSupportedFileFormat(ReadOnlySpan<byte> header)
diff --git a/src/ImageSharp/Formats/Gif/GifMetaData.cs b/src/ImageSharp/Formats/Gif/GifMetaData.cs
new file mode 100644
index 0000000000..f58f5dff3e
--- /dev/null
+++ b/src/ImageSharp/Formats/Gif/GifMetaData.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Gif
+{
+    /// <summary>
+    /// Provides Gif specific metadata information for the image.
+    /// </summary>
+    public class GifMetaData
+    {
+        /// <summary>
+        /// Gets or sets the number of times any animation is repeated.
+        /// <remarks>
+        /// 0 means to repeat indefinitely, count is set as play n + 1 times
+        /// </remarks>
+        /// </summary>
+        public ushort RepeatCount { get; set; }
+
+        /// <summary>
+        /// Gets or sets the color table mode.
+        /// </summary>
+        public GifColorTableMode ColorTableMode { get; set; }
+
+        /// <summary>
+        /// Gets or sets the length of the global color table if present.
+        /// </summary>
+        public int GlobalColorTableLength { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/IGifDecoderOptions.cs b/src/ImageSharp/Formats/Gif/IGifDecoderOptions.cs
index e99f09add3..42c202a3d9 100644
--- a/src/ImageSharp/Formats/Gif/IGifDecoderOptions.cs
+++ b/src/ImageSharp/Formats/Gif/IGifDecoderOptions.cs
@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.Text;
+using SixLabors.ImageSharp.MetaData;
 
 namespace SixLabors.ImageSharp.Formats.Gif
 {
diff --git a/src/ImageSharp/Formats/Gif/IGifEncoderOptions.cs b/src/ImageSharp/Formats/Gif/IGifEncoderOptions.cs
index bad6e0031b..4b3c28a92c 100644
--- a/src/ImageSharp/Formats/Gif/IGifEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Gif/IGifEncoderOptions.cs
@@ -11,11 +11,6 @@ namespace SixLabors.ImageSharp.Formats.Gif
     /// </summary>
     internal interface IGifEncoderOptions
     {
-        /// <summary>
-        /// Gets a value indicating whether the metadata should be ignored when the image is being encoded.
-        /// </summary>
-        bool IgnoreMetadata { get; }
-
         /// <summary>
         /// Gets the text encoding used to write comments.
         /// </summary>
@@ -29,6 +24,6 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Gets the color table mode: Global or local.
         /// </summary>
-        GifColorTableMode ColorTableMode { get; }
+        GifColorTableMode? ColorTableMode { get; }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/ImageExtensions.cs b/src/ImageSharp/Formats/Gif/ImageExtensions.cs
index 1c41285a97..8ddd4247e1 100644
--- a/src/ImageSharp/Formats/Gif/ImageExtensions.cs
+++ b/src/ImageSharp/Formats/Gif/ImageExtensions.cs
@@ -34,6 +34,6 @@ namespace SixLabors.ImageSharp
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
         public static void SaveAsGif<TPixel>(this Image<TPixel> source, Stream stream, GifEncoder encoder)
             where TPixel : struct, IPixel<TPixel>
-            => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(ImageFormats.Gif));
+            => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(GifFormat.Instance));
     }
 }
diff --git a/src/ImageSharp/Formats/Gif/Sections/GifGraphicControlExtension.cs b/src/ImageSharp/Formats/Gif/Sections/GifGraphicControlExtension.cs
index 7ec5f20309..cb548d687d 100644
--- a/src/ImageSharp/Formats/Gif/Sections/GifGraphicControlExtension.cs
+++ b/src/ImageSharp/Formats/Gif/Sections/GifGraphicControlExtension.cs
@@ -53,7 +53,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// Gets the disposal method which indicates the way in which the
         /// graphic is to be treated after being displayed.
         /// </summary>
-        public DisposalMethod DisposalMethod => (DisposalMethod)((this.Packed & 0x1C) >> 2);
+        public GifDisposalMethod DisposalMethod => (GifDisposalMethod)((this.Packed & 0x1C) >> 2);
 
         /// <summary>
         /// Gets a value indicating whether transparency flag is to be set.
@@ -77,7 +77,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
             return MemoryMarshal.Cast<byte, GifGraphicControlExtension>(buffer)[0];
         }
 
-        public static byte GetPackedValue(DisposalMethod disposalMethod, bool userInputFlag = false, bool transparencyFlag = false)
+        public static byte GetPackedValue(GifDisposalMethod disposalMethod, bool userInputFlag = false, bool transparencyFlag = false)
         {
             /*
             Reserved               | 3 Bits
diff --git a/src/ImageSharp/Formats/Gif/Sections/GifImageDescriptor.cs b/src/ImageSharp/Formats/Gif/Sections/GifImageDescriptor.cs
index c5360729e8..c3504dfe7b 100644
--- a/src/ImageSharp/Formats/Gif/Sections/GifImageDescriptor.cs
+++ b/src/ImageSharp/Formats/Gif/Sections/GifImageDescriptor.cs
@@ -81,7 +81,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
             return MemoryMarshal.Cast<byte, GifImageDescriptor>(buffer)[0];
         }
 
-        public static byte GetPackedValue(bool localColorTableFlag, bool interfaceFlag, bool sortFlag, byte localColorTableSize)
+        public static byte GetPackedValue(bool localColorTableFlag, bool interfaceFlag, bool sortFlag, int localColorTableSize)
         {
             /*
             Local Color Table Flag     | 1 Bit
@@ -108,7 +108,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 value |= 1 << 5;
             }
 
-            value |= (byte)(localColorTableSize - 1);
+            value |= (byte)localColorTableSize;
 
             return value;
         }
diff --git a/src/ImageSharp/Formats/Gif/Sections/GifNetscapeLoopingApplicationExtension.cs b/src/ImageSharp/Formats/Gif/Sections/GifNetscapeLoopingApplicationExtension.cs
new file mode 100644
index 0000000000..49a52edf6a
--- /dev/null
+++ b/src/ImageSharp/Formats/Gif/Sections/GifNetscapeLoopingApplicationExtension.cs
@@ -0,0 +1,44 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers.Binary;
+
+namespace SixLabors.ImageSharp.Formats.Gif
+{
+    internal readonly struct GifNetscapeLoopingApplicationExtension : IGifExtension
+    {
+        public GifNetscapeLoopingApplicationExtension(ushort repeatCount) => this.RepeatCount = repeatCount;
+
+        public byte Label => GifConstants.ApplicationExtensionLabel;
+
+        /// <summary>
+        /// Gets the repeat count.
+        /// 0 means loop indefinitely. Count is set as play n + 1 times.
+        /// </summary>
+        public ushort RepeatCount { get; }
+
+        public static GifNetscapeLoopingApplicationExtension Parse(ReadOnlySpan<byte> buffer)
+        {
+            ushort repeatCount = BinaryPrimitives.ReadUInt16LittleEndian(buffer.Slice(0, 2));
+            return new GifNetscapeLoopingApplicationExtension(repeatCount);
+        }
+
+        public int WriteTo(Span<byte> buffer)
+        {
+            buffer[0] = GifConstants.ApplicationBlockSize;
+
+            // Write NETSCAPE2.0
+            GifConstants.NetscapeApplicationIdentificationBytes.AsSpan().CopyTo(buffer.Slice(1, 11));
+
+            // Application Data ----
+            buffer[12] = 3; // Application block length (always 3)
+            buffer[13] = 1; // Data sub-block indentity (always 1)
+
+            // 0 means loop indefinitely. Count is set as play n + 1 times.
+            BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(14, 2), this.RepeatCount);
+
+            return 16; // Length - Introducer + Label + Terminator.
+        }
+    }
+}
diff --git a/src/ImageSharp/Formats/IImageFormat.cs b/src/ImageSharp/Formats/IImageFormat.cs
index 15bdc73a84..94191c1493 100644
--- a/src/ImageSharp/Formats/IImageFormat.cs
+++ b/src/ImageSharp/Formats/IImageFormat.cs
@@ -6,7 +6,7 @@ using System.Collections.Generic;
 namespace SixLabors.ImageSharp.Formats
 {
     /// <summary>
-    /// Describes an image format.
+    /// Defines the contract for an image format.
     /// </summary>
     public interface IImageFormat
     {
@@ -30,4 +30,34 @@ namespace SixLabors.ImageSharp.Formats
         /// </summary>
         IEnumerable<string> FileExtensions { get; }
     }
+
+    /// <summary>
+    /// Defines the contract for an image format containing metadata.
+    /// </summary>
+    /// <typeparam name="TFormatMetaData">The type of format metadata.</typeparam>
+    public interface IImageFormat<out TFormatMetaData> : IImageFormat
+        where TFormatMetaData : class
+    {
+        /// <summary>
+        /// Creates a default instance of the format metadata.
+        /// </summary>
+        /// <returns>The <typeparamref name="TFormatMetaData"/>.</returns>
+        TFormatMetaData CreateDefaultFormatMetaData();
+    }
+
+    /// <summary>
+    /// Defines the contract for an image format containing metadata with multiple frames.
+    /// </summary>
+    /// <typeparam name="TFormatMetaData">The type of format metadata.</typeparam>
+    /// <typeparam name="TFormatFrameMetaData">The type of format frame metadata.</typeparam>
+    public interface IImageFormat<out TFormatMetaData, out TFormatFrameMetaData> : IImageFormat<TFormatMetaData>
+        where TFormatMetaData : class
+        where TFormatFrameMetaData : class
+    {
+        /// <summary>
+        /// Creates a default instance of the format frame metadata.
+        /// </summary>
+        /// <returns>The <typeparamref name="TFormatFrameMetaData"/>.</returns>
+        TFormatFrameMetaData CreateDefaultFormatFrameMetaData();
+    }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs
index bebc13f6de..b7dd125a88 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Block8x8F.CopyTo.cs
@@ -5,7 +5,6 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 
 using SixLabors.ImageSharp.Memory;
-using SixLabors.Memory;
 
 // ReSharper disable InconsistentNaming
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components
@@ -15,7 +14,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// <summary>
         /// Copy block data into the destination color buffer pixel area with the provided horizontal and vertical.
         /// </summary>
-        public void CopyTo(BufferArea<float> area, int horizontalScale, int verticalScale)
+        public void CopyTo(in BufferArea<float> area, int horizontalScale, int verticalScale)
         {
             if (horizontalScale == 1 && verticalScale == 1)
             {
@@ -57,7 +56,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         }
 
         // [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyTo(BufferArea<float> area)
+        public void CopyTo(in BufferArea<float> area)
         {
             ref byte selfBase = ref Unsafe.As<Block8x8F, byte>(ref this);
             ref byte destBase = ref Unsafe.As<float, byte>(ref area.GetReferenceToOrigin());
@@ -81,7 +80,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
             Unsafe.CopyBlock(ref d, ref s, 8 * sizeof(float));
         }
 
-        private void CopyTo2x2(BufferArea<float> area)
+        private void CopyTo2x2(in BufferArea<float> area)
         {
             ref float destBase = ref area.GetReferenceToOrigin();
             int destStride = area.Stride;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmyk.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmyk.cs
index bac77f905e..7a14d072e6 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmyk.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromCmyk.cs
@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 // TODO: We can optimize a lot here with Vector<float> and SRCS.Unsafe()!
                 ReadOnlySpan<float> cVals = values.Component0;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScale.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScale.cs
index b07e57e170..5d7a31a12b 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScale.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromGrayScale.cs
@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 // TODO: We can optimize a lot here with Vector<float> and SRCS.Unsafe()!
                 ReadOnlySpan<float> yVals = values.Component0;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgb.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgb.cs
index 6b7e77e148..7cd97c4140 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgb.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromRgb.cs
@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 // TODO: We can optimize a lot here with Vector<float> and SRCS.Unsafe()!
                 ReadOnlySpan<float> rVals = values.Component0;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrBasic.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrBasic.cs
index 35700ea312..cb71889bc5 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrBasic.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrBasic.cs
@@ -15,12 +15,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 ConvertCore(values, result);
             }
 
-            internal static void ConvertCore(ComponentValues values, Span<Vector4> result)
+            internal static void ConvertCore(in ComponentValues values, Span<Vector4> result)
             {
                 // TODO: We can optimize a lot here with Vector<float> and SRCS.Unsafe()!
                 ReadOnlySpan<float> yVals = values.Component0;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs
index fd2f17da9e..4b2626c582 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimd.cs
@@ -19,7 +19,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 int remainder = result.Length % 8;
                 int simdCount = result.Length - remainder;
@@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// <summary>
             /// SIMD convert using buffers of sizes divisable by 8.
             /// </summary>
-            internal static void ConvertCore(ComponentValues values, Span<Vector4> result)
+            internal static void ConvertCore(in ComponentValues values, Span<Vector4> result)
             {
                 DebugGuard.IsTrue(result.Length % 8 == 0, nameof(result), "result.Length should be divisable by 8!");
 
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs
index 25342f4d67..ab4947e65c 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYCbCrSimdAvx2.cs
@@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
 
             public static bool IsAvailable => Vector.IsHardwareAccelerated && SimdUtils.IsAvx2CompatibleArchitecture;
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 int remainder = result.Length % 8;
                 int simdCount = result.Length - remainder;
@@ -37,7 +37,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             /// <summary>
             /// SIMD convert using buffers of sizes divisable by 8.
             /// </summary>
-            internal static void ConvertCore(ComponentValues values, Span<Vector4> result)
+            internal static void ConvertCore(in ComponentValues values, Span<Vector4> result)
             {
                 // This implementation is actually AVX specific.
                 // An AVX register is capable of storing 8 float-s.
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccK.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccK.cs
index 83feefa94a..6f940f62f9 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccK.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.FromYccK.cs
@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
             {
             }
 
-            public override void ConvertToRgba(ComponentValues values, Span<Vector4> result)
+            public override void ConvertToRgba(in ComponentValues values, Span<Vector4> result)
             {
                 // TODO: We can optimize a lot here with Vector<float> and SRCS.Unsafe()!
                 ReadOnlySpan<float> yVals = values.Component0;
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
index 8aeb01d7f0..60abb7fb2c 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/ColorConverters/JpegColorConverter.cs
@@ -58,7 +58,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder.ColorConverters
         /// </summary>
         /// <param name="values">The input as a stack-only <see cref="ComponentValues"/> struct</param>
         /// <param name="result">The destination buffer of <see cref="Vector4"/> values</param>
-        public abstract void ConvertToRgba(ComponentValues values, Span<Vector4> result);
+        public abstract void ConvertToRgba(in ComponentValues values, Span<Vector4> result);
 
         /// <summary>
         /// Returns the <see cref="JpegColorConverter"/> for the YCbCr colorspace that matches the current CPU architecture.
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs
index 900dd3bc89..0108e30815 100644
--- a/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/JpegBlockPostProcessor.cs
@@ -2,9 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.Runtime.InteropServices;
-
 using SixLabors.ImageSharp.Memory;
-using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
@@ -43,6 +41,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// <summary>
         /// Initializes a new instance of the <see cref="JpegBlockPostProcessor"/> struct.
         /// </summary>
+        /// <param name="decoder">The raw jpeg data.</param>
+        /// <param name="component">The raw component.</param>
         public JpegBlockPostProcessor(IRawJpegData decoder, IJpegComponent component)
         {
             int qtIndex = component.QuantizationTableIndex;
@@ -61,9 +61,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
         /// - Level shift by +128, clip to [0, 255]
         /// - Copy the resultin color values into 'destArea' scaling up the block by amount defined in <see cref="subSamplingDivisors"/>
         /// </summary>
+        /// <param name="sourceBlock">The source block.</param>
+        /// <param name="destArea">The destination buffer area.</param>
         public void ProcessBlockColorsInto(
             ref Block8x8 sourceBlock,
-            BufferArea<float> destArea)
+            in BufferArea<float> destArea)
         {
             ref Block8x8F b = ref this.SourceBlock;
             b.LoadFrom(ref sourceBlock);
diff --git a/src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs b/src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs
new file mode 100644
index 0000000000..4e11568c8d
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/Components/Decoder/QualityEvaluator.cs
@@ -0,0 +1,140 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg.Components.Decoder
+{
+    /// <summary>
+    /// Provides methods to evaluate the quality of an image.
+    /// Ported from <see href="https://github.com/ImageMagick/ImageMagick/blob/f362c02083d27211b913c6e44794f0ac6edaf2bd/coders/jpeg.c#L855"/>
+    /// </summary>
+    internal static class QualityEvaluator
+    {
+        private static readonly int[] Hash = new int[101]
+        {
+            1020, 1015,  932,  848,  780,  735,  702,  679,  660,  645,
+            632,  623,  613,  607,  600,  594,  589,  585,  581,  571,
+            555,  542,  529,  514,  494,  474,  457,  439,  424,  410,
+            397,  386,  373,  364,  351,  341,  334,  324,  317,  309,
+            299,  294,  287,  279,  274,  267,  262,  257,  251,  247,
+            243,  237,  232,  227,  222,  217,  213,  207,  202,  198,
+            192,  188,  183,  177,  173,  168,  163,  157,  153,  148,
+            143,  139,  132,  128,  125,  119,  115,  108,  104,   99,
+            94,   90,   84,   79,   74,   70,   64,   59,   55,   49,
+            45,   40,   34,   30,   25,   20,   15,   11,    6,    4,
+            0
+        };
+
+        private static readonly int[] Sums = new int[101]
+        {
+            32640, 32635, 32266, 31495, 30665, 29804, 29146, 28599, 28104,
+            27670, 27225, 26725, 26210, 25716, 25240, 24789, 24373, 23946,
+            23572, 22846, 21801, 20842, 19949, 19121, 18386, 17651, 16998,
+            16349, 15800, 15247, 14783, 14321, 13859, 13535, 13081, 12702,
+            12423, 12056, 11779, 11513, 11135, 10955, 10676, 10392, 10208,
+            9928,  9747,  9564,  9369,  9193,  9017,  8822,  8639,  8458,
+            8270,  8084,  7896,  7710,  7527,  7347,  7156,  6977,  6788,
+            6607,  6422,  6236,  6054,  5867,  5684,  5495,  5305,  5128,
+            4945,  4751,  4638,  4442,  4248,  4065,  3888,  3698,  3509,
+            3326,  3139,  2957,  2775,  2586,  2405,  2216,  2037,  1846,
+            1666,  1483,  1297,  1109,   927,   735,   554,   375,   201,
+            128,     0
+        };
+
+        private static readonly int[] Hash1 = new int[101]
+        {
+            510,  505,  422,  380,  355,  338,  326,  318,  311,  305,
+            300,  297,  293,  291,  288,  286,  284,  283,  281,  280,
+            279,  278,  277,  273,  262,  251,  243,  233,  225,  218,
+            211,  205,  198,  193,  186,  181,  177,  172,  168,  164,
+            158,  156,  152,  148,  145,  142,  139,  136,  133,  131,
+            129,  126,  123,  120,  118,  115,  113,  110,  107,  105,
+            102,  100,   97,   94,   92,   89,   87,   83,   81,   79,
+            76,   74,   70,   68,   66,   63,   61,   57,   55,   52,
+            50,   48,   44,   42,   39,   37,   34,   31,   29,   26,
+            24,   21,   18,   16,   13,   11,    8,    6,    3,    2,
+            0
+        };
+
+        private static readonly int[] Sums1 = new int[101]
+        {
+            16320, 16315, 15946, 15277, 14655, 14073, 13623, 13230, 12859,
+            12560, 12240, 11861, 11456, 11081, 10714, 10360, 10027,  9679,
+            9368,  9056,  8680,  8331,  7995,  7668,  7376,  7084,  6823,
+            6562,  6345,  6125,  5939,  5756,  5571,  5421,  5240,  5086,
+            4976,  4829,  4719,  4616,  4463,  4393,  4280,  4166,  4092,
+            3980,  3909,  3835,  3755,  3688,  3621,  3541,  3467,  3396,
+            3323,  3247,  3170,  3096,  3021,  2952,  2874,  2804,  2727,
+            2657,  2583,  2509,  2437,  2362,  2290,  2211,  2136,  2068,
+            1996,  1915,  1858,  1773,  1692,  1620,  1552,  1477,  1398,
+            1326,  1251,  1179,  1109,  1031,   961,   884,   814,   736,
+            667,   592,   518,   441,   369,   292,   221,   151,    86,
+            64,     0
+        };
+
+        /// <summary>
+        /// Returns an estimated quality of the image based on the quantization tables.
+        /// </summary>
+        /// <param name="quantizationTables">The quantization tables.</param>
+        /// <returns>The <see cref="int"/>.</returns>
+        public static int EstimateQuality(Block8x8F[] quantizationTables)
+        {
+            int quality = 75;
+            float sum = 0;
+
+            for (int i = 0; i < quantizationTables.Length; i++)
+            {
+                ref Block8x8F qTable = ref quantizationTables[i];
+                for (int j = 0; j < Block8x8F.Size; j++)
+                {
+                    sum += qTable[j];
+                }
+            }
+
+            ref Block8x8F qTable0 = ref quantizationTables[0];
+            ref Block8x8F qTable1 = ref quantizationTables[1];
+
+            if (!qTable0.Equals(default))
+            {
+                if (!qTable1.Equals(default))
+                {
+                    quality = (int)(qTable0[2]
+                            + qTable0[53]
+                            + qTable1[0]
+                            + qTable1[Block8x8F.Size - 1]);
+
+                    for (int i = 0; i < 100; i++)
+                    {
+                        if (quality < Hash[i] && sum < Sums[i])
+                        {
+                            continue;
+                        }
+
+                        if (((quality <= Hash[i]) && (sum <= Sums[i])) || (i >= 50))
+                        {
+                            return i + 1;
+                        }
+                    }
+                }
+                else
+                {
+                    quality = (int)(qTable0[2] + qTable0[53]);
+
+                    for (int i = 0; i < 100; i++)
+                    {
+                        if (quality < Hash1[i] && sum < Sums1[i])
+                        {
+                            continue;
+                        }
+
+                        if (((quality <= Hash1[i]) && (sum <= Sums1[i])) || (i >= 50))
+                        {
+                            return i + 1;
+                        }
+                    }
+                }
+            }
+
+            return quality;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs b/src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs
index 4076b7da82..53108de934 100644
--- a/src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Jpeg/IJpegEncoderOptions.cs
@@ -8,17 +8,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// </summary>
     internal interface IJpegEncoderOptions
     {
-        /// <summary>
-        /// Gets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        bool IgnoreMetadata { get; }
-
         /// <summary>
         /// Gets the quality, that will be used to encode the image. Quality
         /// index must be between 0 and 100 (compression from max to min).
         /// </summary>
         /// <value>The quality of the jpg image from 0 to 100.</value>
-        int Quality { get; }
+        int? Quality { get; }
 
         /// <summary>
         /// Gets the subsample ration, that will be used to encode the image.
diff --git a/src/ImageSharp/Formats/Jpeg/ImageExtensions.cs b/src/ImageSharp/Formats/Jpeg/ImageExtensions.cs
index 1d3be063dd..cb7fc19446 100644
--- a/src/ImageSharp/Formats/Jpeg/ImageExtensions.cs
+++ b/src/ImageSharp/Formats/Jpeg/ImageExtensions.cs
@@ -34,6 +34,6 @@ namespace SixLabors.ImageSharp
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
         public static void SaveAsJpeg<TPixel>(this Image<TPixel> source, Stream stream, JpegEncoder encoder)
             where TPixel : struct, IPixel<TPixel>
-            => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(ImageFormats.Jpeg));
+            => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(JpegFormat.Instance));
     }
 }
diff --git a/src/ImageSharp/Formats/Jpeg/JpegConfigurationModule.cs b/src/ImageSharp/Formats/Jpeg/JpegConfigurationModule.cs
index c3bf801ac8..9840a2ae88 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegConfigurationModule.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegConfigurationModule.cs
@@ -9,12 +9,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     public sealed class JpegConfigurationModule : IConfigurationModule
     {
         /// <inheritdoc/>
-        public void Configure(Configuration config)
+        public void Configure(Configuration configuration)
         {
-            config.ImageFormatsManager.SetEncoder(ImageFormats.Jpeg, new JpegEncoder());
-            config.ImageFormatsManager.SetDecoder(ImageFormats.Jpeg, new JpegDecoder());
-
-            config.ImageFormatsManager.AddImageFormatDetector(new JpegImageFormatDetector());
+            configuration.ImageFormatsManager.SetEncoder(JpegFormat.Instance, new JpegEncoder());
+            configuration.ImageFormatsManager.SetDecoder(JpegFormat.Instance, new JpegDecoder());
+            configuration.ImageFormatsManager.AddImageFormatDetector(new JpegImageFormatDetector());
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
index 7561afa1ef..011b6100dc 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegDecoderCore.cs
@@ -234,6 +234,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.InitExifProfile();
             this.InitIccProfile();
             this.InitDerivedMetaDataProperties();
+
             return new ImageInfo(new PixelTypeInfo(this.BitsPerPixel), this.ImageWidth, this.ImageHeight, this.MetaData);
         }
 
@@ -258,17 +259,20 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             this.InputStream.Read(this.markerBuffer, 0, 2);
             byte marker = this.markerBuffer[1];
             fileMarker = new JpegFileMarker(marker, (int)this.InputStream.Position - 2);
+            this.QuantizationTables = new Block8x8F[4];
 
             // Only assign what we need
             if (!metadataOnly)
             {
-                this.QuantizationTables = new Block8x8F[4];
                 this.dcHuffmanTables = new HuffmanTables();
                 this.acHuffmanTables = new HuffmanTables();
                 this.fastACTables = new FastACTables(this.configuration.MemoryAllocator);
             }
 
-            while (fileMarker.Marker != JpegConstants.Markers.EOI)
+            // Break only when we discover a valid EOI marker.
+            // https://github.com/SixLabors/ImageSharp/issues/695
+            while (fileMarker.Marker != JpegConstants.Markers.EOI
+                || (fileMarker.Marker == JpegConstants.Markers.EOI && fileMarker.Invalid))
             {
                 if (!fileMarker.Invalid)
                 {
@@ -310,15 +314,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
                             break;
 
                         case JpegConstants.Markers.DQT:
-                            if (metadataOnly)
-                            {
-                                this.InputStream.Skip(remaining);
-                            }
-                            else
-                            {
-                                this.ProcessDefineQuantizationTablesMarker(remaining);
-                            }
-
+                            this.ProcessDefineQuantizationTablesMarker(remaining);
                             break;
 
                         case JpegConstants.Markers.DRI:
@@ -463,13 +459,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
             else if (this.isExif)
             {
-                double horizontalValue = this.MetaData.ExifProfile.TryGetValue(ExifTag.XResolution, out ExifValue horizontalTag)
-                    ? ((Rational)horizontalTag.Value).ToDouble()
-                    : 0;
-
-                double verticalValue = this.MetaData.ExifProfile.TryGetValue(ExifTag.YResolution, out ExifValue verticalTag)
-                    ? ((Rational)verticalTag.Value).ToDouble()
-                    : 0;
+                double horizontalValue = this.GetExifResolutionValue(ExifTag.XResolution);
+                double verticalValue = this.GetExifResolutionValue(ExifTag.YResolution);
 
                 if (horizontalValue > 0 && verticalValue > 0)
                 {
@@ -480,6 +471,26 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
         }
 
+        private double GetExifResolutionValue(ExifTag tag)
+        {
+            if (!this.MetaData.ExifProfile.TryGetValue(tag, out ExifValue exifValue))
+            {
+                return 0;
+            }
+
+            switch (exifValue.DataType)
+            {
+                case ExifDataType.Rational:
+                    return ((Rational)exifValue.Value).ToDouble();
+                case ExifDataType.Long:
+                    return (uint)exifValue.Value;
+                case ExifDataType.DoubleFloat:
+                    return (double)exifValue.Value;
+                default:
+                    return 0;
+            }
+        }
+
         /// <summary>
         /// Extends the profile with additional data.
         /// </summary>
@@ -689,6 +700,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             {
                 throw new ImageFormatException("DQT has wrong length");
             }
+
+            this.MetaData.GetFormatMetaData(JpegFormat.Instance).Quality = QualityEvaluator.EstimateQuality(this.QuantizationTables);
         }
 
         /// <summary>
@@ -899,9 +912,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="values">The values</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void BuildHuffmanTable(HuffmanTables tables, int index, ReadOnlySpan<byte> codeLengths, ReadOnlySpan<byte> values)
-        {
-            tables[index] = new HuffmanTable(this.configuration.MemoryAllocator, codeLengths, values);
-        }
+            => tables[index] = new HuffmanTable(this.configuration.MemoryAllocator, codeLengths, values);
 
         /// <summary>
         /// Reads a <see cref="ushort"/> from the stream advancing it by two bytes
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoder.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoder.cs
index 0f389dee0f..d649d30418 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoder.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoder.cs
@@ -11,17 +11,12 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// </summary>
     public sealed class JpegEncoder : IImageEncoder, IJpegEncoderOptions
     {
-        /// <summary>
-        /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
-        /// </summary>
-        public bool IgnoreMetadata { get; set; }
-
         /// <summary>
         /// Gets or sets the quality, that will be used to encode the image. Quality
         /// index must be between 0 and 100 (compression from max to min).
         /// Defaults to <value>75</value>.
         /// </summary>
-        public int Quality { get; set; } = 75;
+        public int? Quality { get; set; }
 
         /// <summary>
         /// Gets or sets the subsample ration, that will be used to encode the image.
diff --git a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
index f7b6fe9967..a4677ba2b7 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegEncoderCore.cs
@@ -123,19 +123,14 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         private readonly byte[] huffmanBuffer = new byte[179];
 
         /// <summary>
-        /// Gets or sets a value indicating whether the metadata should be ignored when the image is being decoded.
+        /// Gets or sets the subsampling method to use.
         /// </summary>
-        private readonly bool ignoreMetadata;
+        private JpegSubsample? subsample;
 
         /// <summary>
         /// The quality, that will be used to encode the image.
         /// </summary>
-        private readonly int quality;
-
-        /// <summary>
-        /// Gets or sets the subsampling method to use.
-        /// </summary>
-        private readonly JpegSubsample? subsample;
+        private readonly int? quality;
 
         /// <summary>
         /// The accumulated bits to write to the stream.
@@ -168,11 +163,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <param name="options">The options</param>
         public JpegEncoderCore(IJpegEncoderOptions options)
         {
-            // System.Drawing produces identical output for jpegs with a quality parameter of 0 and 1.
-            this.quality = options.Quality.Clamp(1, 100);
-            this.subsample = options.Subsample ?? (this.quality >= 91 ? JpegSubsample.Ratio444 : JpegSubsample.Ratio420);
-
-            this.ignoreMetadata = options.IgnoreMetadata;
+            this.quality = options.Quality;
+            this.subsample = options.Subsample;
         }
 
         /// <summary>
@@ -194,16 +186,21 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             }
 
             this.outputStream = stream;
+            ImageMetaData metaData = image.MetaData;
+
+            // System.Drawing produces identical output for jpegs with a quality parameter of 0 and 1.
+            int qlty = (this.quality ?? metaData.GetFormatMetaData(JpegFormat.Instance).Quality).Clamp(1, 100);
+            this.subsample = this.subsample ?? (qlty >= 91 ? JpegSubsample.Ratio444 : JpegSubsample.Ratio420);
 
             // Convert from a quality rating to a scaling factor.
             int scale;
-            if (this.quality < 50)
+            if (qlty < 50)
             {
-                scale = 5000 / this.quality;
+                scale = 5000 / qlty;
             }
             else
             {
-                scale = 200 - (this.quality * 2);
+                scale = 200 - (qlty * 2);
             }
 
             // Initialize the quantization tables.
@@ -214,10 +211,10 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
             int componentCount = 3;
 
             // Write the Start Of Image marker.
-            this.WriteApplicationHeader(image.MetaData);
+            this.WriteApplicationHeader(metaData);
 
             // Write Exif and ICC profiles
-            this.WriteProfiles(image);
+            this.WriteProfiles(metaData);
 
             // Write the quantization tables.
             this.WriteDefineQuantizationTables();
@@ -624,6 +621,11 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// </exception>
         private void WriteExifProfile(ExifProfile exifProfile)
         {
+            if (exifProfile is null)
+            {
+                return;
+            }
+
             const int MaxBytesApp1 = 65533;
             const int MaxBytesWithExifId = 65527;
 
@@ -762,19 +764,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <summary>
         /// Writes the metadata profiles to the image.
         /// </summary>
-        /// <param name="image">The image.</param>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        private void WriteProfiles<TPixel>(Image<TPixel> image)
-            where TPixel : struct, IPixel<TPixel>
+        /// <param name="metaData">The image meta data.</param>
+        private void WriteProfiles(ImageMetaData metaData)
         {
-            if (this.ignoreMetadata)
+            if (metaData is null)
             {
                 return;
             }
 
-            image.MetaData.SyncProfiles();
-            this.WriteExifProfile(image.MetaData.ExifProfile);
-            this.WriteIccProfile(image.MetaData.IccProfile);
+            metaData.SyncProfiles();
+            this.WriteExifProfile(metaData.ExifProfile);
+            this.WriteIccProfile(metaData.IccProfile);
         }
 
         /// <summary>
diff --git a/src/ImageSharp/Formats/Jpeg/JpegFormat.cs b/src/ImageSharp/Formats/Jpeg/JpegFormat.cs
index 9a18f14d30..6b23ceac7a 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegFormat.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegFormat.cs
@@ -8,8 +8,17 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
     /// <summary>
     /// Registers the image encoders, decoders and mime type detectors for the jpeg format.
     /// </summary>
-    internal sealed class JpegFormat : IImageFormat
+    public sealed class JpegFormat : IImageFormat<JpegMetaData>
     {
+        private JpegFormat()
+        {
+        }
+
+        /// <summary>
+        /// Gets the current instance.
+        /// </summary>
+        public static JpegFormat Instance { get; } = new JpegFormat();
+
         /// <inheritdoc/>
         public string Name => "JPEG";
 
@@ -21,5 +30,8 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
 
         /// <inheritdoc/>
         public IEnumerable<string> FileExtensions => JpegConstants.FileExtensions;
+
+        /// <inheritdoc/>
+        public JpegMetaData CreateDefaultFormatMetaData() => new JpegMetaData();
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Jpeg/JpegImageFormatDetector.cs b/src/ImageSharp/Formats/Jpeg/JpegImageFormatDetector.cs
index e25957efcf..7594f44770 100644
--- a/src/ImageSharp/Formats/Jpeg/JpegImageFormatDetector.cs
+++ b/src/ImageSharp/Formats/Jpeg/JpegImageFormatDetector.cs
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Formats.Jpeg
         /// <inheritdoc/>
         public IImageFormat DetectFormat(ReadOnlySpan<byte> header)
         {
-            return this.IsSupportedFileFormat(header) ? ImageFormats.Jpeg : null;
+            return this.IsSupportedFileFormat(header) ? JpegFormat.Instance : null;
         }
 
         private bool IsSupportedFileFormat(ReadOnlySpan<byte> header)
diff --git a/src/ImageSharp/Formats/Jpeg/JpegMetaData.cs b/src/ImageSharp/Formats/Jpeg/JpegMetaData.cs
new file mode 100644
index 0000000000..bd7232e602
--- /dev/null
+++ b/src/ImageSharp/Formats/Jpeg/JpegMetaData.cs
@@ -0,0 +1,16 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Jpeg
+{
+    /// <summary>
+    /// Provides Jpeg specific metadata information for the image.
+    /// </summary>
+    public class JpegMetaData
+    {
+        /// <summary>
+        /// Gets or sets the encoded quality.
+        /// </summary>
+        public int Quality { get; set; } = 75;
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Png/IPngEncoderOptions.cs b/src/ImageSharp/Formats/Png/IPngEncoderOptions.cs
index f3231fa22a..77bc9f7a05 100644
--- a/src/ImageSharp/Formats/Png/IPngEncoderOptions.cs
+++ b/src/ImageSharp/Formats/Png/IPngEncoderOptions.cs
@@ -14,12 +14,12 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// Gets the number of bits per sample or per palette index (not per pixel).
         /// Not all values are allowed for all <see cref="ColorType"/> values.
         /// </summary>
-        PngBitDepth BitDepth { get; }
+        PngBitDepth? BitDepth { get; }
 
         /// <summary>
         /// Gets the color type
         /// </summary>
-        PngColorType ColorType { get; }
+        PngColorType? ColorType { get; }
 
         /// <summary>
         /// Gets the filter method.
@@ -33,15 +33,13 @@ namespace SixLabors.ImageSharp.Formats.Png
         int CompressionLevel { get; }
 
         /// <summary>
-        /// Gets the gamma value, that will be written
-        /// the the stream, when the <see cref="WriteGamma"/> property
-        /// is set to true. The default value is 2.2F.
+        /// Gets the gamma value, that will be written the the image.
         /// </summary>
         /// <value>The gamma value of the image.</value>
-        float Gamma { get; }
+        float? Gamma { get; }
 
         /// <summary>
-        /// Gets  quantizer for reducing the color count.
+        /// Gets the quantizer for reducing the color count.
         /// </summary>
         IQuantizer Quantizer { get; }
 
@@ -49,11 +47,5 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// Gets the transparency threshold.
         /// </summary>
         byte Threshold { get; }
-
-        /// <summary>
-        /// Gets a value indicating whether this instance should write
-        /// gamma information to the stream. The default value is false.
-        /// </summary>
-        bool WriteGamma { get; }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Png/ImageExtensions.cs b/src/ImageSharp/Formats/Png/ImageExtensions.cs
index a65845e02d..c73ec6f57e 100644
--- a/src/ImageSharp/Formats/Png/ImageExtensions.cs
+++ b/src/ImageSharp/Formats/Png/ImageExtensions.cs
@@ -35,6 +35,6 @@ namespace SixLabors.ImageSharp
         /// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
         public static void SaveAsPng<TPixel>(this Image<TPixel> source, Stream stream, PngEncoder encoder)
             where TPixel : struct, IPixel<TPixel>
-            => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(ImageFormats.Png));
+            => source.Save(stream, encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(PngFormat.Instance));
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Png/PngBitDepth.cs b/src/ImageSharp/Formats/Png/PngBitDepth.cs
index 0c22a4c913..396f2c1608 100644
--- a/src/ImageSharp/Formats/Png/PngBitDepth.cs
+++ b/src/ImageSharp/Formats/Png/PngBitDepth.cs
@@ -9,6 +9,21 @@ namespace SixLabors.ImageSharp.Formats.Png
     /// </summary>
     public enum PngBitDepth
     {
+        /// <summary>
+        /// 1 bit per sample or per palette index (not per pixel).
+        /// </summary>
+        Bit1 = 1,
+
+        /// <summary>
+        /// 2 bits per sample or per palette index (not per pixel).
+        /// </summary>
+        Bit2 = 2,
+
+        /// <summary>
+        /// 4 bits per sample or per palette index (not per pixel).
+        /// </summary>
+        Bit4 = 4,
+
         /// <summary>
         /// 8 bits per sample or per palette index (not per pixel).
         /// </summary>
diff --git a/src/ImageSharp/Formats/Png/PngChunkType.cs b/src/ImageSharp/Formats/Png/PngChunkType.cs
index e0844ca6b8..7654c17014 100644
--- a/src/ImageSharp/Formats/Png/PngChunkType.cs
+++ b/src/ImageSharp/Formats/Png/PngChunkType.cs
@@ -8,58 +8,58 @@ namespace SixLabors.ImageSharp.Formats.Png
     /// </summary>
     internal enum PngChunkType : uint
     {
-        /// <summary>
-        /// The first chunk in a png file. Can only exists once. Contains
-        /// common information like the width and the height of the image or
-        /// the used compression method.
-        /// </summary>
-        Header = 0x49484452U, // IHDR
-
-        /// <summary>
-        /// The PLTE chunk contains from 1 to 256 palette entries, each a three byte
-        /// series in the RGB format.
-        /// </summary>
-        Palette = 0x504C5445U, // PLTE
-
         /// <summary>
         /// The IDAT chunk contains the actual image data. The image can contains more
         /// than one chunk of this type. All chunks together are the whole image.
         /// </summary>
-        Data = 0x49444154U, // IDAT
+        Data = 0x49444154U,
 
         /// <summary>
         /// This chunk must appear last. It marks the end of the PNG data stream.
         /// The chunk's data field is empty.
         /// </summary>
-        End = 0x49454E44U, // IEND
+        End = 0x49454E44U,
 
         /// <summary>
-        /// This chunk specifies that the image uses simple transparency:
-        /// either alpha values associated with palette entries (for indexed-color images)
-        /// or a single transparent color (for grayscale and true color images).
+        /// The first chunk in a png file. Can only exists once. Contains
+        /// common information like the width and the height of the image or
+        /// the used compression method.
         /// </summary>
-        PaletteAlpha = 0x74524E53U, // tRNS
+        Header = 0x49484452U,
 
         /// <summary>
-        /// Textual information that the encoder wishes to record with the image can be stored in
-        /// tEXt chunks. Each tEXt chunk contains a keyword and a text string.
+        /// The PLTE chunk contains from 1 to 256 palette entries, each a three byte
+        /// series in the RGB format.
+        /// </summary>
+        Palette = 0x504C5445U,
+
+        /// <summary>
+        /// The eXIf data chunk which contains the Exif profile.
         /// </summary>
-        Text = 0x74455874U, // tEXt
+        Exif = 0x65584966U,
 
         /// <summary>
         /// This chunk specifies the relationship between the image samples and the desired
         /// display output intensity.
         /// </summary>
-        Gamma = 0x67414D41U, // gAMA
+        Gamma = 0x67414D41U,
 
         /// <summary>
         /// The pHYs chunk specifies the intended pixel size or aspect ratio for display of the image.
         /// </summary>
-        Physical = 0x70485973U, // pHYs
+        Physical = 0x70485973U,
 
         /// <summary>
-        /// The data chunk which contains the Exif profile.
+        /// Textual information that the encoder wishes to record with the image can be stored in
+        /// tEXt chunks. Each tEXt chunk contains a keyword and a text string.
+        /// </summary>
+        Text = 0x74455874U,
+
+        /// <summary>
+        /// This chunk specifies that the image uses simple transparency:
+        /// either alpha values associated with palette entries (for indexed-color images)
+        /// or a single transparent color (for grayscale and true color images).
         /// </summary>
-        Exif = 0x65584966U // eXIf
+        PaletteAlpha = 0x74524E53U
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Png/PngConfigurationModule.cs b/src/ImageSharp/Formats/Png/PngConfigurationModule.cs
index 64dad23bca..3c9fddbad4 100644
--- a/src/ImageSharp/Formats/Png/PngConfigurationModule.cs
+++ b/src/ImageSharp/Formats/Png/PngConfigurationModule.cs
@@ -11,8 +11,8 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <inheritdoc/>
         public void Configure(Configuration configuration)
         {
-            configuration.ImageFormatsManager.SetEncoder(ImageFormats.Png, new PngEncoder());
-            configuration.ImageFormatsManager.SetDecoder(ImageFormats.Png, new PngDecoder());
+            configuration.ImageFormatsManager.SetEncoder(PngFormat.Instance, new PngEncoder());
+            configuration.ImageFormatsManager.SetDecoder(PngFormat.Instance, new PngDecoder());
             configuration.ImageFormatsManager.AddImageFormatDetector(new PngImageFormatDetector());
         }
     }
diff --git a/src/ImageSharp/Formats/Png/PngDecoderCore.cs b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
index aa96b926ca..9281927012 100644
--- a/src/ImageSharp/Formats/Png/PngDecoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngDecoderCore.cs
@@ -10,7 +10,6 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Png.Filters;
 using SixLabors.ImageSharp.Formats.Png.Zlib;
 using SixLabors.ImageSharp.Memory;
@@ -217,7 +216,8 @@ namespace SixLabors.ImageSharp.Formats.Png
         public Image<TPixel> Decode<TPixel>(Stream stream)
             where TPixel : struct, IPixel<TPixel>
         {
-            var metadata = new ImageMetaData();
+            var metaData = new ImageMetaData();
+            PngMetaData pngMetaData = metaData.GetFormatMetaData(PngFormat.Instance);
             this.currentStream = stream;
             this.currentStream.Skip(8);
             Image<TPixel> image = null;
@@ -232,16 +232,19 @@ namespace SixLabors.ImageSharp.Formats.Png
                             switch (chunk.Type)
                             {
                                 case PngChunkType.Header:
-                                    this.ReadHeaderChunk(chunk.Data.Array);
+                                    this.ReadHeaderChunk(pngMetaData, chunk.Data.Array);
                                     this.ValidateHeader();
                                     break;
                                 case PngChunkType.Physical:
-                                    this.ReadPhysicalChunk(metadata, chunk.Data.GetSpan());
+                                    this.ReadPhysicalChunk(metaData, chunk.Data.GetSpan());
+                                    break;
+                                case PngChunkType.Gamma:
+                                    this.ReadGammaChunk(pngMetaData, chunk.Data.GetSpan());
                                     break;
                                 case PngChunkType.Data:
                                     if (image is null)
                                     {
-                                        this.InitializeImage(metadata, out image);
+                                        this.InitializeImage(metaData, out image);
                                     }
 
                                     deframeStream.AllocateNewBytes(chunk.Length);
@@ -260,14 +263,14 @@ namespace SixLabors.ImageSharp.Formats.Png
                                     this.AssignTransparentMarkers(alpha);
                                     break;
                                 case PngChunkType.Text:
-                                    this.ReadTextChunk(metadata, chunk.Data.Array, chunk.Length);
+                                    this.ReadTextChunk(metaData, chunk.Data.Array, chunk.Length);
                                     break;
                                 case PngChunkType.Exif:
                                     if (!this.ignoreMetadata)
                                     {
                                         byte[] exifData = new byte[chunk.Length];
                                         Buffer.BlockCopy(chunk.Data.Array, 0, exifData, 0, chunk.Length);
-                                        metadata.ExifProfile = new ExifProfile(exifData);
+                                        metaData.ExifProfile = new ExifProfile(exifData);
                                     }
 
                                     break;
@@ -303,7 +306,8 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
         public IImageInfo Identify(Stream stream)
         {
-            var metadata = new ImageMetaData();
+            var metaData = new ImageMetaData();
+            PngMetaData pngMetaData = metaData.GetFormatMetaData(PngFormat.Instance);
             this.currentStream = stream;
             this.currentStream.Skip(8);
             try
@@ -315,17 +319,20 @@ namespace SixLabors.ImageSharp.Formats.Png
                         switch (chunk.Type)
                         {
                             case PngChunkType.Header:
-                                this.ReadHeaderChunk(chunk.Data.Array);
+                                this.ReadHeaderChunk(pngMetaData, chunk.Data.Array);
                                 this.ValidateHeader();
                                 break;
                             case PngChunkType.Physical:
-                                this.ReadPhysicalChunk(metadata, chunk.Data.GetSpan());
+                                this.ReadPhysicalChunk(metaData, chunk.Data.GetSpan());
+                                break;
+                            case PngChunkType.Gamma:
+                                this.ReadGammaChunk(pngMetaData, chunk.Data.GetSpan());
                                 break;
                             case PngChunkType.Data:
                                 this.SkipChunkDataAndCrc(chunk);
                                 break;
                             case PngChunkType.Text:
-                                this.ReadTextChunk(metadata, chunk.Data.Array, chunk.Length);
+                                this.ReadTextChunk(metaData, chunk.Data.Array, chunk.Length);
                                 break;
                             case PngChunkType.End:
                                 this.isEndChunkReached = true;
@@ -349,7 +356,7 @@ namespace SixLabors.ImageSharp.Formats.Png
                 throw new ImageFormatException("PNG Image does not contain a header chunk");
             }
 
-            return new ImageInfo(new PixelTypeInfo(this.CalculateBitsPerPixel()), this.header.Width, this.header.Height, metadata);
+            return new ImageInfo(new PixelTypeInfo(this.CalculateBitsPerPixel()), this.header.Width, this.header.Height, metaData);
         }
 
         /// <summary>
@@ -360,9 +367,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <returns>The <see cref="int"/></returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static byte ReadByteLittleEndian(ReadOnlySpan<byte> buffer, int offset)
-        {
-            return (byte)(((buffer[offset] & 0xFF) << 16) | (buffer[offset + 1] & 0xFF));
-        }
+            => (byte)(((buffer[offset] & 0xFF) << 16) | (buffer[offset + 1] & 0xFF));
 
         /// <summary>
         /// Attempts to convert a byte array to a new array where each value in the original array is represented by the
@@ -430,6 +435,18 @@ namespace SixLabors.ImageSharp.Formats.Png
             metadata.VerticalResolution = vResolution;
         }
 
+        /// <summary>
+        /// Reads the data chunk containing gamma data.
+        /// </summary>
+        /// <param name="pngMetadata">The metadata to read to.</param>
+        /// <param name="data">The data containing physical data.</param>
+        private void ReadGammaChunk(PngMetaData pngMetadata, ReadOnlySpan<byte> data)
+        {
+            // The value is encoded as a 4-byte unsigned integer, representing gamma times 100000.
+            // For example, a gamma of 1/2.2 would be stored as 45455.
+            pngMetadata.Gamma = BinaryPrimitives.ReadUInt32BigEndian(data) / 100_000F;
+        }
+
         /// <summary>
         /// Initializes the image and various buffers needed for processing
         /// </summary>
@@ -711,7 +728,7 @@ namespace SixLabors.ImageSharp.Formats.Png
             {
                 case PngColorType.Grayscale:
 
-                    int factor = 255 / ((int)Math.Pow(2, this.header.BitDepth) - 1);
+                    int factor = 255 / (ImageMaths.GetColorCountForBitDepth(this.header.BitDepth) - 1);
 
                     if (!this.hasTrans)
                     {
@@ -933,7 +950,7 @@ namespace SixLabors.ImageSharp.Formats.Png
             {
                 case PngColorType.Grayscale:
 
-                    int factor = 255 / ((int)Math.Pow(2, this.header.BitDepth) - 1);
+                    int factor = 255 / (ImageMaths.GetColorCountForBitDepth(this.header.BitDepth) - 1);
 
                     if (!this.hasTrans)
                     {
@@ -1270,17 +1287,22 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <summary>
         /// Reads a header chunk from the data.
         /// </summary>
+        /// <param name="pngMetaData">The png metadata.</param>
         /// <param name="data">The <see cref="T:ReadOnlySpan{byte}"/> containing data.</param>
-        private void ReadHeaderChunk(ReadOnlySpan<byte> data)
+        private void ReadHeaderChunk(PngMetaData pngMetaData, ReadOnlySpan<byte> data)
         {
+            byte bitDepth = data[8];
             this.header = new PngHeader(
                 width: BinaryPrimitives.ReadInt32BigEndian(data.Slice(0, 4)),
                 height: BinaryPrimitives.ReadInt32BigEndian(data.Slice(4, 4)),
-                bitDepth: data[8],
+                bitDepth: bitDepth,
                 colorType: (PngColorType)data[9],
                 compressionMethod: data[10],
                 filterMethod: data[11],
                 interlaceMethod: (PngInterlaceMode)data[12]);
+
+            pngMetaData.BitDepth = (PngBitDepth)bitDepth;
+            pngMetaData.ColorType = this.header.ColorType;
         }
 
         /// <summary>
diff --git a/src/ImageSharp/Formats/Png/PngEncoder.cs b/src/ImageSharp/Formats/Png/PngEncoder.cs
index 109e6ad770..f47a6518f0 100644
--- a/src/ImageSharp/Formats/Png/PngEncoder.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoder.cs
@@ -17,12 +17,12 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// Gets or sets the number of bits per sample or per palette index (not per pixel).
         /// Not all values are allowed for all <see cref="ColorType"/> values.
         /// </summary>
-        public PngBitDepth BitDepth { get; set; } = PngBitDepth.Bit8;
+        public PngBitDepth? BitDepth { get; set; }
 
         /// <summary>
         /// Gets or sets the color type.
         /// </summary>
-        public PngColorType ColorType { get; set; } = PngColorType.RgbWithAlpha;
+        public PngColorType? ColorType { get; set; }
 
         /// <summary>
         /// Gets or sets the filter method.
@@ -36,30 +36,21 @@ namespace SixLabors.ImageSharp.Formats.Png
         public int CompressionLevel { get; set; } = 6;
 
         /// <summary>
-        /// Gets or sets the gamma value, that will be written
-        /// the the stream, when the <see cref="WriteGamma"/> property
-        /// is set to true. The default value is 2.2F.
+        /// Gets or sets the gamma value, that will be written the the image.
         /// </summary>
-        /// <value>The gamma value of the image.</value>
-        public float Gamma { get; set; } = 2.2F;
+        public float? Gamma { get; set; }
 
         /// <summary>
         /// Gets or sets quantizer for reducing the color count.
         /// Defaults to the <see cref="WuQuantizer"/>
         /// </summary>
-        public IQuantizer Quantizer { get; set; } = new WuQuantizer();
+        public IQuantizer Quantizer { get; set; }
 
         /// <summary>
         /// Gets or sets the transparency threshold.
         /// </summary>
         public byte Threshold { get; set; } = 255;
 
-        /// <summary>
-        /// Gets or sets a value indicating whether this instance should write
-        /// gamma information to the stream. The default value is false.
-        /// </summary>
-        public bool WriteGamma { get; set; }
-
         /// <summary>
         /// Encodes the image to the specified stream from the <see cref="Image{TPixel}"/>.
         /// </summary>
diff --git a/src/ImageSharp/Formats/Png/PngEncoderCore.cs b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
index ffe29aecae..e4d2fc510d 100644
--- a/src/ImageSharp/Formats/Png/PngEncoderCore.cs
+++ b/src/ImageSharp/Formats/Png/PngEncoderCore.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Buffers.Binary;
 using System.IO;
-using System.Linq;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Common.Helpers;
 using SixLabors.ImageSharp.Formats.Png.Filters;
@@ -45,49 +44,49 @@ namespace SixLabors.ImageSharp.Formats.Png
         private readonly Crc32 crc = new Crc32();
 
         /// <summary>
-        /// The png bit depth
+        /// The png filter method.
         /// </summary>
-        private readonly PngBitDepth pngBitDepth;
+        private readonly PngFilterMethod pngFilterMethod;
 
         /// <summary>
-        /// Gets or sets a value indicating whether to use 16 bit encoding for supported color types.
+        /// Gets or sets the CompressionLevel value
         /// </summary>
-        private readonly bool use16Bit;
+        private readonly int compressionLevel;
 
         /// <summary>
-        /// The png color type.
+        /// Gets or sets the alpha threshold value
         /// </summary>
-        private readonly PngColorType pngColorType;
+        private readonly byte threshold;
 
         /// <summary>
-        /// The png filter method.
+        /// The quantizer for reducing the color count.
         /// </summary>
-        private readonly PngFilterMethod pngFilterMethod;
+        private IQuantizer quantizer;
 
         /// <summary>
-        /// The quantizer for reducing the color count.
+        /// Gets or sets a value indicating whether to write the gamma chunk
         /// </summary>
-        private readonly IQuantizer quantizer;
+        private bool writeGamma;
 
         /// <summary>
-        /// Gets or sets the CompressionLevel value
+        /// The png bit depth
         /// </summary>
-        private readonly int compressionLevel;
+        private PngBitDepth? pngBitDepth;
 
         /// <summary>
-        /// Gets or sets the Gamma value
+        /// Gets or sets a value indicating whether to use 16 bit encoding for supported color types.
         /// </summary>
-        private readonly float gamma;
+        private bool use16Bit;
 
         /// <summary>
-        /// Gets or sets the Threshold value
+        /// The png color type.
         /// </summary>
-        private readonly byte threshold;
+        private PngColorType? pngColorType;
 
         /// <summary>
-        /// Gets or sets a value indicating whether to Write Gamma
+        /// Gets or sets the Gamma value
         /// </summary>
-        private readonly bool writeGamma;
+        private float? gamma;
 
         /// <summary>
         /// The image width.
@@ -158,14 +157,12 @@ namespace SixLabors.ImageSharp.Formats.Png
         {
             this.memoryAllocator = memoryAllocator;
             this.pngBitDepth = options.BitDepth;
-            this.use16Bit = this.pngBitDepth.Equals(PngBitDepth.Bit16);
             this.pngColorType = options.ColorType;
             this.pngFilterMethod = options.FilterMethod;
             this.compressionLevel = options.CompressionLevel;
             this.gamma = options.Gamma;
             this.quantizer = options.Quantizer;
             this.threshold = options.Threshold;
-            this.writeGamma = options.WriteGamma;
         }
 
         /// <summary>
@@ -183,23 +180,42 @@ namespace SixLabors.ImageSharp.Formats.Png
             this.width = image.Width;
             this.height = image.Height;
 
+            // Always take the encoder options over the metadata values.
+            ImageMetaData metaData = image.MetaData;
+            PngMetaData pngMetaData = metaData.GetFormatMetaData(PngFormat.Instance);
+            this.gamma = this.gamma ?? pngMetaData.Gamma;
+            this.writeGamma = this.gamma > 0;
+            this.pngColorType = this.pngColorType ?? pngMetaData.ColorType;
+            this.pngBitDepth = this.pngBitDepth ?? pngMetaData.BitDepth;
+            this.use16Bit = this.pngBitDepth.Equals(PngBitDepth.Bit16);
+
             stream.Write(PngConstants.HeaderBytes, 0, PngConstants.HeaderBytes.Length);
 
             QuantizedFrame<TPixel> quantized = null;
             ReadOnlySpan<byte> quantizedPixelsSpan = default;
             if (this.pngColorType == PngColorType.Palette)
             {
+                byte bits;
+
+                // Use the metadata to determine what quantization depth to use if no quantizer has been set.
+                if (this.quantizer == null)
+                {
+                    bits = (byte)Math.Min(8u, (short)this.pngBitDepth);
+                    int colorSize = ImageMaths.GetColorCountForBitDepth(bits);
+                    this.quantizer = new WuQuantizer(colorSize);
+                }
+
                 // Create quantized frame returning the palette and set the bit depth.
                 quantized = this.quantizer.CreateFrameQuantizer<TPixel>().QuantizeFrame(image.Frames.RootFrame);
                 quantizedPixelsSpan = quantized.GetPixelSpan();
-                byte bits = (byte)ImageMaths.GetBitsNeededForColorDepth(quantized.Palette.Length).Clamp(1, 8);
+                bits = (byte)ImageMaths.GetBitsNeededForColorDepth(quantized.Palette.Length).Clamp(1, 8);
 
                 // Png only supports in four pixel depths: 1, 2, 4, and 8 bits when using the PLTE chunk
                 if (bits == 3)
                 {
                     bits = 4;
                 }
-                else if (bits >= 5 || bits <= 7)
+                else if (bits >= 5 && bits <= 7)
                 {
                     bits = 8;
                 }
@@ -217,7 +233,7 @@ namespace SixLabors.ImageSharp.Formats.Png
                 width: image.Width,
                 height: image.Height,
                 bitDepth: this.bitDepth,
-                colorType: this.pngColorType,
+                colorType: this.pngColorType.Value,
                 compressionMethod: 0, // None
                 filterMethod: 0,
                 interlaceMethod: 0); // TODO: Can't write interlaced yet.
@@ -227,12 +243,12 @@ namespace SixLabors.ImageSharp.Formats.Png
             // Collect the indexed pixel data
             if (quantized != null)
             {
-                this.WritePaletteChunk(stream, header, quantized);
+                this.WritePaletteChunk(stream, quantized);
             }
 
-            this.WritePhysicalChunk(stream, image);
+            this.WritePhysicalChunk(stream, metaData);
             this.WriteGammaChunk(stream);
-            this.WriteExifChunk(stream, image);
+            this.WriteExifChunk(stream, metaData);
             this.WriteDataChunks(image.Frames.RootFrame, quantizedPixelsSpan, stream);
             this.WriteEndChunk(stream);
             stream.Flush();
@@ -539,30 +555,27 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
-        /// <param name="header">The <see cref="PngHeader"/>.</param>
         /// <param name="quantized">The quantized frame.</param>
-        private void WritePaletteChunk<TPixel>(Stream stream, in PngHeader header, QuantizedFrame<TPixel> quantized)
+        private void WritePaletteChunk<TPixel>(Stream stream, QuantizedFrame<TPixel> quantized)
             where TPixel : struct, IPixel<TPixel>
         {
             // Grab the palette and write it to the stream.
             TPixel[] palette = quantized.Palette;
-            byte pixelCount = palette.Length.ToByte();
-
-            // Get max colors for bit depth.
-            int colorTableLength = (int)Math.Pow(2, header.BitDepth) * 3;
+            int paletteLength = Math.Min(palette.Length, 256);
+            int colorTableLength = paletteLength * 3;
             Rgba32 rgba = default;
             bool anyAlpha = false;
 
             using (IManagedByteBuffer colorTable = this.memoryAllocator.AllocateManagedByteBuffer(colorTableLength))
-            using (IManagedByteBuffer alphaTable = this.memoryAllocator.AllocateManagedByteBuffer(pixelCount))
+            using (IManagedByteBuffer alphaTable = this.memoryAllocator.AllocateManagedByteBuffer(paletteLength))
             {
                 Span<byte> colorTableSpan = colorTable.GetSpan();
                 Span<byte> alphaTableSpan = alphaTable.GetSpan();
                 Span<byte> quantizedSpan = quantized.GetPixelSpan();
 
-                for (byte i = 0; i < pixelCount; i++)
+                for (int i = 0; i < paletteLength; i++)
                 {
-                    if (quantizedSpan.IndexOf(i) > -1)
+                    if (quantizedSpan.IndexOf((byte)i) > -1)
                     {
                         int offset = i * 3;
                         palette[i].ToRgba32(ref rgba);
@@ -588,7 +601,7 @@ namespace SixLabors.ImageSharp.Formats.Png
                 // Write the transparency data
                 if (anyAlpha)
                 {
-                    this.WriteChunk(stream, PngChunkType.PaletteAlpha, alphaTable.Array, 0, pixelCount);
+                    this.WriteChunk(stream, PngChunkType.PaletteAlpha, alphaTable.Array, 0, paletteLength);
                 }
             }
         }
@@ -596,11 +609,9 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <summary>
         /// Writes the physical dimension information to the stream.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
-        /// <param name="image">The image.</param>
-        private void WritePhysicalChunk<TPixel>(Stream stream, Image<TPixel> image)
-            where TPixel : struct, IPixel<TPixel>
+        /// <param name="meta">The image meta data.</param>
+        private void WritePhysicalChunk(Stream stream, ImageMetaData meta)
         {
             // The pHYs chunk specifies the intended pixel size or aspect ratio for display of the image. It contains:
             // Pixels per unit, X axis: 4 bytes (unsigned integer)
@@ -612,7 +623,6 @@ namespace SixLabors.ImageSharp.Formats.Png
             //   1: unit is the meter
             //
             // When the unit specifier is 0, the pHYs chunk defines pixel aspect ratio only; the actual size of the pixels remains unspecified.
-            ImageMetaData meta = image.MetaData;
             Span<byte> hResolution = this.chunkDataBuffer.AsSpan(0, 4);
             Span<byte> vResolution = this.chunkDataBuffer.AsSpan(4, 4);
 
@@ -653,16 +663,14 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <summary>
         /// Writes the eXIf chunk to the stream, if any EXIF Profile values are present in the meta data.
         /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
-        /// <param name="image">The image.</param>
-        private void WriteExifChunk<TPixel>(Stream stream, Image<TPixel> image)
-            where TPixel : struct, IPixel<TPixel>
+        /// <param name="meta">The image meta data.</param>
+        private void WriteExifChunk(Stream stream, ImageMetaData meta)
         {
-            if (image.MetaData.ExifProfile?.Values.Count > 0)
+            if (meta.ExifProfile?.Values.Count > 0)
             {
-                image.MetaData.SyncProfiles();
-                this.WriteChunk(stream, PngChunkType.Exif, image.MetaData.ExifProfile.ToByteArray());
+                meta.SyncProfiles();
+                this.WriteChunk(stream, PngChunkType.Exif, meta.ExifProfile.ToByteArray());
             }
         }
 
@@ -693,7 +701,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         private void WriteDataChunks<TPixel>(ImageFrame<TPixel> pixels, ReadOnlySpan<byte> quantizedPixelsSpan, Stream stream)
             where TPixel : struct, IPixel<TPixel>
         {
-            this.bytesPerScanline = this.width * this.bytesPerPixel;
+            this.bytesPerScanline = this.CalculateScanlineLength(this.width);
             int resultLength = this.bytesPerScanline + 1;
 
             this.previousScanline = this.memoryAllocator.AllocateManagedByteBuffer(this.bytesPerScanline, AllocationOptions.Clean);
@@ -781,10 +789,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// Writes the chunk end to the stream.
         /// </summary>
         /// <param name="stream">The <see cref="Stream"/> containing image data.</param>
-        private void WriteEndChunk(Stream stream)
-        {
-            this.WriteChunk(stream, PngChunkType.End, null);
-        }
+        private void WriteEndChunk(Stream stream) => this.WriteChunk(stream, PngChunkType.End, null);
 
         /// <summary>
         /// Writes a chunk to the stream.
@@ -792,10 +797,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <param name="stream">The <see cref="Stream"/> to write to.</param>
         /// <param name="type">The type of chunk to write.</param>
         /// <param name="data">The <see cref="T:byte[]"/> containing data.</param>
-        private void WriteChunk(Stream stream, PngChunkType type, byte[] data)
-        {
-            this.WriteChunk(stream, type, data, 0, data?.Length ?? 0);
-        }
+        private void WriteChunk(Stream stream, PngChunkType type, byte[] data) => this.WriteChunk(stream, type, data, 0, data?.Length ?? 0);
 
         /// <summary>
         /// Writes a chunk of a specified length to the stream at the given offset.
@@ -827,5 +829,26 @@ namespace SixLabors.ImageSharp.Formats.Png
 
             stream.Write(this.buffer, 0, 4); // write the crc
         }
+
+        /// <summary>
+        /// Calculates the scanline length.
+        /// </summary>
+        /// <param name="width">The width of the row.</param>
+        /// <returns>
+        /// The <see cref="int"/> representing the length.
+        /// </returns>
+        private int CalculateScanlineLength(int width)
+        {
+            int mod = this.bitDepth == 16 ? 16 : 8;
+            int scanlineLength = width * this.bitDepth * this.bytesPerPixel;
+
+            int amount = scanlineLength % mod;
+            if (amount != 0)
+            {
+                scanlineLength += mod - amount;
+            }
+
+            return scanlineLength / mod;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Png/PngFormat.cs b/src/ImageSharp/Formats/Png/PngFormat.cs
index 142f660712..210e2a837d 100644
--- a/src/ImageSharp/Formats/Png/PngFormat.cs
+++ b/src/ImageSharp/Formats/Png/PngFormat.cs
@@ -8,8 +8,17 @@ namespace SixLabors.ImageSharp.Formats.Png
     /// <summary>
     /// Registers the image encoders, decoders and mime type detectors for the png format.
     /// </summary>
-    internal sealed class PngFormat : IImageFormat
+    public sealed class PngFormat : IImageFormat<PngMetaData>
     {
+        private PngFormat()
+        {
+        }
+
+        /// <summary>
+        /// Gets the current instance.
+        /// </summary>
+        public static PngFormat Instance { get; } = new PngFormat();
+
         /// <inheritdoc/>
         public string Name => "PNG";
 
@@ -21,5 +30,8 @@ namespace SixLabors.ImageSharp.Formats.Png
 
         /// <inheritdoc/>
         public IEnumerable<string> FileExtensions => PngConstants.FileExtensions;
+
+        /// <inheritdoc/>
+        public PngMetaData CreateDefaultFormatMetaData() => new PngMetaData();
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Png/PngImageFormatDetector.cs b/src/ImageSharp/Formats/Png/PngImageFormatDetector.cs
index c1c039a1be..5deed86e30 100644
--- a/src/ImageSharp/Formats/Png/PngImageFormatDetector.cs
+++ b/src/ImageSharp/Formats/Png/PngImageFormatDetector.cs
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Formats.Png
         /// <inheritdoc/>
         public IImageFormat DetectFormat(ReadOnlySpan<byte> header)
         {
-            return this.IsSupportedFileFormat(header) ? ImageFormats.Png : null;
+            return this.IsSupportedFileFormat(header) ? PngFormat.Instance : null;
         }
 
         private bool IsSupportedFileFormat(ReadOnlySpan<byte> header)
diff --git a/src/ImageSharp/Formats/Png/PngMetaData.cs b/src/ImageSharp/Formats/Png/PngMetaData.cs
new file mode 100644
index 0000000000..1eb3cdad6a
--- /dev/null
+++ b/src/ImageSharp/Formats/Png/PngMetaData.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Formats.Png
+{
+    /// <summary>
+    /// Provides Png specific metadata information for the image.
+    /// </summary>
+    public class PngMetaData
+    {
+        /// <summary>
+        /// Gets or sets the number of bits per sample or per palette index (not per pixel).
+        /// Not all values are allowed for all <see cref="ColorType"/> values.
+        /// </summary>
+        public PngBitDepth BitDepth { get; set; } = PngBitDepth.Bit8;
+
+        /// <summary>
+        /// Gets or sets the color type.
+        /// </summary>
+        public PngColorType ColorType { get; set; } = PngColorType.RgbWithAlpha;
+
+        /// <summary>
+        /// Gets or sets the gamma value for the image.
+        /// </summary>
+        public float Gamma { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/ImageSharp/ImageFormats.cs b/src/ImageSharp/ImageFormats.cs
deleted file mode 100644
index bc437e5a5e..0000000000
--- a/src/ImageSharp/ImageFormats.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using SixLabors.ImageSharp.Formats;
-using SixLabors.ImageSharp.Formats.Bmp;
-using SixLabors.ImageSharp.Formats.Gif;
-using SixLabors.ImageSharp.Formats.Jpeg;
-using SixLabors.ImageSharp.Formats.Png;
-
-namespace SixLabors.ImageSharp
-{
-    /// <summary>
-    /// The static collection of all the default image formats
-    /// </summary>
-    public static class ImageFormats
-    {
-        /// <summary>
-        /// The format details for the jpegs.
-        /// </summary>
-        public static readonly IImageFormat Jpeg = new JpegFormat();
-
-        /// <summary>
-        /// The format details for the pngs.
-        /// </summary>
-        public static readonly IImageFormat Png = new PngFormat();
-
-        /// <summary>
-        /// The format details for the gifs.
-        /// </summary>
-        public static readonly IImageFormat Gif = new GifFormat();
-
-        /// <summary>
-        /// The format details for the bitmaps.
-        /// </summary>
-        public static readonly IImageFormat Bmp = new BmpFormat();
-    }
-}
\ No newline at end of file
diff --git a/src/ImageSharp/ImageFrame{TPixel}.cs b/src/ImageSharp/ImageFrame{TPixel}.cs
index a3971fe9ce..132ab598e5 100644
--- a/src/ImageSharp/ImageFrame{TPixel}.cs
+++ b/src/ImageSharp/ImageFrame{TPixel}.cs
@@ -84,12 +84,11 @@ namespace SixLabors.ImageSharp
             Guard.NotNull(configuration, nameof(configuration));
             Guard.MustBeGreaterThan(width, 0, nameof(width));
             Guard.MustBeGreaterThan(height, 0, nameof(height));
-            Guard.NotNull(metaData, nameof(metaData));
 
             this.configuration = configuration;
             this.MemoryAllocator = configuration.MemoryAllocator;
             this.PixelBuffer = this.MemoryAllocator.Allocate2D<TPixel>(width, height);
-            this.MetaData = metaData;
+            this.MetaData = metaData ?? new ImageFrameMetaData();
             this.Clear(configuration.GetParallelOptions(), backgroundColor);
         }
 
@@ -201,10 +200,7 @@ namespace SixLabors.ImageSharp
         /// <param name="y">The y-coordinate of the pixel. Must be greater than or equal to zero and less than the height of the image.</param>
         /// <returns>The <see typeparam="TPixel"/> at the specified position.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ref TPixel GetPixelReference(int x, int y)
-        {
-            return ref this.PixelBuffer[x, y];
-        }
+        internal ref TPixel GetPixelReference(int x, int y) => ref this.PixelBuffer[x, y];
 
         /// <summary>
         /// Copies the pixels to a <see cref="Buffer2D{TPixel}"/> of the same size.
@@ -249,10 +245,7 @@ namespace SixLabors.ImageSharp
         }
 
         /// <inheritdoc/>
-        public override string ToString()
-        {
-            return $"ImageFrame<{typeof(TPixel).Name}>: {this.Width}x{this.Height}";
-        }
+        public override string ToString() => $"ImageFrame<{typeof(TPixel).Name}>: {this.Width}x{this.Height}";
 
         /// <summary>
         /// Returns a copy of the image frame in the given pixel format.
@@ -309,15 +302,9 @@ namespace SixLabors.ImageSharp
         /// Clones the current instance.
         /// </summary>
         /// <returns>The <see cref="ImageFrame{TPixel}"/></returns>
-        internal ImageFrame<TPixel> Clone()
-        {
-            return new ImageFrame<TPixel>(this.configuration, this);
-        }
+        internal ImageFrame<TPixel> Clone() => new ImageFrame<TPixel>(this.configuration, this);
 
         /// <inheritdoc/>
-        void IDisposable.Dispose()
-        {
-            this.Dispose();
-        }
+        void IDisposable.Dispose() => this.Dispose();
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Formats/Gif/FrameDecodingMode.cs b/src/ImageSharp/MetaData/FrameDecodingMode.cs
similarity index 91%
rename from src/ImageSharp/Formats/Gif/FrameDecodingMode.cs
rename to src/ImageSharp/MetaData/FrameDecodingMode.cs
index 05791c92e5..2863fbf8f9 100644
--- a/src/ImageSharp/Formats/Gif/FrameDecodingMode.cs
+++ b/src/ImageSharp/MetaData/FrameDecodingMode.cs
@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-namespace SixLabors.ImageSharp.Formats.Gif
+namespace SixLabors.ImageSharp.MetaData
 {
     /// <summary>
     /// Enumerated frame process modes to apply to multi-frame images.
diff --git a/src/ImageSharp/MetaData/ImageFrameMetaData.cs b/src/ImageSharp/MetaData/ImageFrameMetaData.cs
index 47a2fb775f..4b819e2013 100644
--- a/src/ImageSharp/MetaData/ImageFrameMetaData.cs
+++ b/src/ImageSharp/MetaData/ImageFrameMetaData.cs
@@ -1,7 +1,9 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Formats.Gif;
+using System;
+using System.Collections.Generic;
+using SixLabors.ImageSharp.Formats;
 
 namespace SixLabors.ImageSharp.MetaData
 {
@@ -10,6 +12,8 @@ namespace SixLabors.ImageSharp.MetaData
     /// </summary>
     public sealed class ImageFrameMetaData
     {
+        private readonly Dictionary<IImageFormat, object> formatMetaData = new Dictionary<IImageFormat, object>();
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ImageFrameMetaData"/> class.
         /// </summary>
@@ -28,32 +32,39 @@ namespace SixLabors.ImageSharp.MetaData
         {
             DebugGuard.NotNull(other, nameof(other));
 
-            this.FrameDelay = other.FrameDelay;
-            this.DisposalMethod = other.DisposalMethod;
+            foreach (KeyValuePair<IImageFormat, object> meta in other.formatMetaData)
+            {
+                this.formatMetaData.Add(meta.Key, meta.Value);
+            }
         }
 
         /// <summary>
-        /// Gets or sets the frame delay for animated images.
-        /// If not 0, when utilized in Gif animation, this field specifies the number of hundredths (1/100) of a second to
-        /// wait before continuing with the processing of the Data Stream.
-        /// The clock starts ticking immediately after the graphic is rendered.
-        /// </summary>
-        public int FrameDelay { get; set; }
-
-        /// <summary>
-        /// Gets or sets the disposal method for animated images.
-        /// Primarily used in Gif animation, this field indicates the way in which the graphic is to
-        /// be treated after being displayed.
+        /// Clones this ImageFrameMetaData.
         /// </summary>
-        public DisposalMethod DisposalMethod { get; set; }
+        /// <returns>The cloned instance.</returns>
+        public ImageFrameMetaData Clone() => new ImageFrameMetaData(this);
 
         /// <summary>
-        /// Clones this ImageFrameMetaData.
+        /// Gets the metadata value associated with the specified key.
         /// </summary>
-        /// <returns>The cloned instance.</returns>
-        public ImageFrameMetaData Clone()
+        /// <typeparam name="TFormatMetaData">The type of format metadata.</typeparam>
+        /// <typeparam name="TFormatFrameMetaData">The type of format frame metadata.</typeparam>
+        /// <param name="key">The key of the value to get.</param>
+        /// <returns>
+        /// The <typeparamref name="TFormatFrameMetaData"/>.
+        /// </returns>
+        public TFormatFrameMetaData GetFormatMetaData<TFormatMetaData, TFormatFrameMetaData>(IImageFormat<TFormatMetaData, TFormatFrameMetaData> key)
+            where TFormatMetaData : class
+            where TFormatFrameMetaData : class
         {
-            return new ImageFrameMetaData(this);
+            if (this.formatMetaData.TryGetValue(key, out object meta))
+            {
+                return (TFormatFrameMetaData)meta;
+            }
+
+            TFormatFrameMetaData newMeta = key.CreateDefaultFormatFrameMetaData();
+            this.formatMetaData[key] = newMeta;
+            return newMeta;
         }
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/MetaData/ImageMetaData.cs b/src/ImageSharp/MetaData/ImageMetaData.cs
index 40880bd085..7e74157e70 100644
--- a/src/ImageSharp/MetaData/ImageMetaData.cs
+++ b/src/ImageSharp/MetaData/ImageMetaData.cs
@@ -1,7 +1,9 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
 using System.Collections.Generic;
+using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.MetaData.Profiles.Exif;
 using SixLabors.ImageSharp.MetaData.Profiles.Icc;
 
@@ -24,6 +26,7 @@ namespace SixLabors.ImageSharp.MetaData
         /// </summary>
         public const double DefaultVerticalResolution = 96;
 
+        private readonly Dictionary<IImageFormat, object> formatMetaData = new Dictionary<IImageFormat, object>();
         private double horizontalResolution;
         private double verticalResolution;
 
@@ -48,7 +51,11 @@ namespace SixLabors.ImageSharp.MetaData
             this.HorizontalResolution = other.HorizontalResolution;
             this.VerticalResolution = other.VerticalResolution;
             this.ResolutionUnits = other.ResolutionUnits;
-            this.RepeatCount = other.RepeatCount;
+
+            foreach (KeyValuePair<IImageFormat, object> meta in other.formatMetaData)
+            {
+                this.formatMetaData.Add(meta.Key, meta.Value);
+            }
 
             foreach (ImageProperty property in other.Properties)
             {
@@ -125,10 +132,31 @@ namespace SixLabors.ImageSharp.MetaData
         public IList<ImageProperty> Properties { get; } = new List<ImageProperty>();
 
         /// <summary>
-        /// Gets or sets the number of times any animation is repeated.
-        /// <remarks>0 means to repeat indefinitely.</remarks>
+        /// Gets the metadata value associated with the specified key.
+        /// </summary>
+        /// <typeparam name="TFormatMetaData">The type of metadata.</typeparam>
+        /// <param name="key">The key of the value to get.</param>
+        /// <returns>
+        /// The <typeparamref name="TFormatMetaData"/>.
+        /// </returns>
+        public TFormatMetaData GetFormatMetaData<TFormatMetaData>(IImageFormat<TFormatMetaData> key)
+             where TFormatMetaData : class
+        {
+            if (this.formatMetaData.TryGetValue(key, out object meta))
+            {
+                return (TFormatMetaData)meta;
+            }
+
+            TFormatMetaData newMeta = key.CreateDefaultFormatMetaData();
+            this.formatMetaData[key] = newMeta;
+            return newMeta;
+        }
+
+        /// <summary>
+        /// Clones this into a new instance
         /// </summary>
-        public ushort RepeatCount { get; set; }
+        /// <returns>The cloned metadata instance</returns>
+        public ImageMetaData Clone() => new ImageMetaData(this);
 
         /// <summary>
         /// Looks up a property with the provided name.
@@ -153,21 +181,9 @@ namespace SixLabors.ImageSharp.MetaData
             return false;
         }
 
-        /// <summary>
-        /// Clones this into a new instance
-        /// </summary>
-        /// <returns>The cloned metadata instance</returns>
-        public ImageMetaData Clone()
-        {
-            return new ImageMetaData(this);
-        }
-
         /// <summary>
         /// Synchronizes the profiles with the current meta data.
         /// </summary>
-        internal void SyncProfiles()
-        {
-            this.ExifProfile?.Sync(this);
-        }
+        internal void SyncProfiles() => this.ExifProfile?.Sync(this);
     }
 }
diff --git a/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs b/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs
index 72db6305dd..549cb3fe09 100644
--- a/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs
+++ b/src/ImageSharp/MetaData/Profiles/Exif/ExifReader.cs
@@ -88,19 +88,19 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif
             }
 
             uint ifdOffset = this.ReadUInt32();
-            this.AddValues(values, (int)ifdOffset);
+            this.AddValues(values, ifdOffset);
 
             uint thumbnailOffset = this.ReadUInt32();
-            this.GetThumbnail((int)thumbnailOffset);
+            this.GetThumbnail(thumbnailOffset);
 
             if (this.exifOffset != 0)
             {
-                this.AddValues(values, (int)this.exifOffset);
+                this.AddValues(values, this.exifOffset);
             }
 
             if (this.gpsOffset != 0)
             {
-                this.AddValues(values, (int)this.gpsOffset);
+                this.AddValues(values, this.gpsOffset);
             }
 
             return values;
@@ -153,9 +153,14 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif
         /// </summary>
         /// <param name="values">The values.</param>
         /// <param name="index">The index.</param>
-        private void AddValues(List<ExifValue> values, int index)
+        private void AddValues(List<ExifValue> values, uint index)
         {
-            this.position = index;
+            if (index > (uint)this.exifData.Length)
+            {
+                return;
+            }
+
+            this.position = (int)index;
             int count = this.ReadUInt16();
 
             for (int i = 0; i < count; i++)
@@ -431,7 +436,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif
             return null;
         }
 
-        private void GetThumbnail(int offset)
+        private void GetThumbnail(uint offset)
         {
             var values = new List<ExifValue>();
             this.AddValues(values, offset);
@@ -515,10 +520,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Exif
             return new Rational(numerator, denominator, false);
         }
 
-        private sbyte ConvertToSignedByte(ReadOnlySpan<byte> buffer)
-        {
-            return unchecked((sbyte)buffer[0]);
-        }
+        private sbyte ConvertToSignedByte(ReadOnlySpan<byte> buffer) => unchecked((sbyte)buffer[0]);
 
         private int ConvertToInt32(ReadOnlySpan<byte> buffer) // SignedLong in Exif Specification
         {
diff --git a/src/ImageSharp/MetaData/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs b/src/ImageSharp/MetaData/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs
index 5d7d729b2c..79b9132192 100644
--- a/src/ImageSharp/MetaData/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs
+++ b/src/ImageSharp/MetaData/Profiles/ICC/DataWriter/IccDataWriter.Matrix.cs
@@ -59,7 +59,7 @@ namespace SixLabors.ImageSharp.MetaData.Profiles.Icc
         /// <param name="value">The matrix to write</param>
         /// <param name="isSingle">True if the values are encoded as Single; false if encoded as Fix16</param>
         /// <returns>The number of bytes written</returns>
-        public int WriteMatrix(DenseMatrix<float> value, bool isSingle)
+        public int WriteMatrix(in DenseMatrix<float> value, bool isSingle)
         {
             int count = 0;
             for (int y = 0; y < value.Rows; y++)
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
index 9b1e29db81..19d1c5dad1 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.cs
@@ -1,4242 +1,3926 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-// <auto-generated />
-using System;
-using System.Numerics;
-using System.Buffers;
-
-using SixLabors.ImageSharp.Memory;
-using SixLabors.Memory;
-
-namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
-{
-    /// <summary>
-    /// Collection of Porter Duff alpha blending functions applying different composition models.
-    /// </summary>
-    /// <remarks>
-    /// These functions are designed to be a general solution for all color cases,
-    /// that is, they take in account the alpha value of both the backdrop
-    /// and source, and there's no need to alpha-premultiply neither the backdrop
-    /// nor the source.
-    /// Note there are faster functions for when the backdrop color is known
-    /// to be opaque
-    /// </remarks>
-    internal static class DefaultPixelBlenders<TPixel>
-        where TPixel : struct, IPixel<TPixel>
-    {
-
-            internal class NormalSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalSrc Instance { get; } = new NormalSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplySrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplySrc Instance { get; } = new MultiplySrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplySrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplySrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddSrc Instance { get; } = new AddSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractSrc Instance { get; } = new SubtractSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenSrc Instance { get; } = new ScreenSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenSrc Instance { get; } = new DarkenSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenSrc Instance { get; } = new LightenSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlaySrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlaySrc Instance { get; } = new OverlaySrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlaySrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlaySrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightSrc : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightSrc Instance { get; } = new HardLightSrc();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightSrc(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightSrc(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplySrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplySrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddSrcAtop Instance { get; } = new AddSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlaySrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlaySrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightSrcAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightSrcAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalSrcOver Instance { get; } = new NormalSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplySrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplySrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddSrcOver Instance { get; } = new AddSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenSrcOver Instance { get; } = new LightenSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlaySrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlaySrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightSrcOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightSrcOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalSrcIn Instance { get; } = new NormalSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplySrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplySrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddSrcIn Instance { get; } = new AddSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenSrcIn Instance { get; } = new LightenSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlaySrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlaySrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightSrcIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightSrcIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalSrcOut Instance { get; } = new NormalSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplySrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplySrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplySrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddSrcOut Instance { get; } = new AddSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenSrcOut Instance { get; } = new LightenSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlaySrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlaySrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlaySrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightSrcOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightSrcOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightSrcOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalDest Instance { get; } = new NormalDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyDest Instance { get; } = new MultiplyDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddDest Instance { get; } = new AddDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractDest Instance { get; } = new SubtractDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenDest Instance { get; } = new ScreenDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenDest Instance { get; } = new DarkenDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenDest Instance { get; } = new LightenDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayDest Instance { get; } = new OverlayDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightDest : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightDest Instance { get; } = new HardLightDest();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightDest(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightDest(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalDestAtop Instance { get; } = new NormalDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddDestAtop Instance { get; } = new AddDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenDestAtop Instance { get; } = new LightenDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightDestAtop : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightDestAtop(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightDestAtop(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalDestOver Instance { get; } = new NormalDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddDestOver Instance { get; } = new AddDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractDestOver Instance { get; } = new SubtractDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenDestOver Instance { get; } = new ScreenDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenDestOver Instance { get; } = new DarkenDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenDestOver Instance { get; } = new LightenDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayDestOver Instance { get; } = new OverlayDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightDestOver : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightDestOver Instance { get; } = new HardLightDestOver();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightDestOver(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightDestOver(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalDestIn Instance { get; } = new NormalDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddDestIn Instance { get; } = new AddDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractDestIn Instance { get; } = new SubtractDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenDestIn Instance { get; } = new ScreenDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenDestIn Instance { get; } = new DarkenDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenDestIn Instance { get; } = new LightenDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayDestIn Instance { get; } = new OverlayDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightDestIn : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightDestIn Instance { get; } = new HardLightDestIn();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightDestIn(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightDestIn(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalDestOut Instance { get; } = new NormalDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddDestOut Instance { get; } = new AddDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractDestOut Instance { get; } = new SubtractDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenDestOut Instance { get; } = new ScreenDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenDestOut Instance { get; } = new DarkenDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenDestOut Instance { get; } = new LightenDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayDestOut Instance { get; } = new OverlayDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightDestOut : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightDestOut Instance { get; } = new HardLightDestOut();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightDestOut(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightDestOut(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalClear Instance { get; } = new NormalClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyClear Instance { get; } = new MultiplyClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddClear Instance { get; } = new AddClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractClear Instance { get; } = new SubtractClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenClear Instance { get; } = new ScreenClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenClear Instance { get; } = new DarkenClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenClear Instance { get; } = new LightenClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayClear Instance { get; } = new OverlayClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightClear : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightClear Instance { get; } = new HardLightClear();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightClear(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightClear(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class NormalXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static NormalXor Instance { get; } = new NormalXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.NormalXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.NormalXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class MultiplyXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static MultiplyXor Instance { get; } = new MultiplyXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.MultiplyXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.MultiplyXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class AddXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static AddXor Instance { get; } = new AddXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.AddXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.AddXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class SubtractXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static SubtractXor Instance { get; } = new SubtractXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.SubtractXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.SubtractXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class ScreenXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static ScreenXor Instance { get; } = new ScreenXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.ScreenXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.ScreenXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class DarkenXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static DarkenXor Instance { get; } = new DarkenXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.DarkenXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.DarkenXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class LightenXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static LightenXor Instance { get; } = new LightenXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.LightenXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.LightenXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class OverlayXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static OverlayXor Instance { get; } = new OverlayXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.OverlayXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.OverlayXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-            internal class HardLightXor : PixelBlender<TPixel>
-            {
-                /// <summary>
-                /// Gets the static instance of this blender.
-                /// </summary>
-                public static HardLightXor Instance { get; } = new HardLightXor();
-
-                /// <inheritdoc />
-                public override TPixel Blend(TPixel background, TPixel source, float amount)
-                {
-                    return PorterDuffFunctions.HardLightXor(background, source, amount);
-                }
-
-                /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
-                {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
-                    {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.HardLightXor(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
-
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
-                }
-            }
-
-    }
+
+
+
+
+
+
+
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+// <auto-generated />
+using System;
+using System.Numerics;
+using System.Buffers;
+
+using SixLabors.ImageSharp.Memory;
+using SixLabors.Memory;
+
+namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
+{
+    /// <summary>
+    /// Collection of Porter Duff alpha blending functions applying different composition models.
+    /// </summary>
+    /// <remarks>
+    /// These functions are designed to be a general solution for all color cases,
+    /// that is, they take in account the alpha value of both the backdrop
+    /// and source, and there's no need to alpha-premultiply neither the backdrop
+    /// nor the source.
+    /// Note there are faster functions for when the backdrop color is known
+    /// to be opaque
+    /// </remarks>
+    internal static class DefaultPixelBlenders<TPixel>
+        where TPixel : struct, IPixel<TPixel>
+    {
+
+
+            internal class NormalSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalSrc Instance { get; } = new NormalSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplySrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplySrc Instance { get; } = new MultiplySrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplySrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddSrc Instance { get; } = new AddSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractSrc Instance { get; } = new SubtractSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenSrc Instance { get; } = new ScreenSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenSrc Instance { get; } = new DarkenSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenSrc Instance { get; } = new LightenSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlaySrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlaySrc Instance { get; } = new OverlaySrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlaySrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightSrc : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightSrc Instance { get; } = new HardLightSrc();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightSrc(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrc(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalSrcAtop Instance { get; } = new NormalSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplySrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplySrcAtop Instance { get; } = new MultiplySrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddSrcAtop Instance { get; } = new AddSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractSrcAtop Instance { get; } = new SubtractSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenSrcAtop Instance { get; } = new ScreenSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenSrcAtop Instance { get; } = new DarkenSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenSrcAtop Instance { get; } = new LightenSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlaySrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlaySrcAtop Instance { get; } = new OverlaySrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlaySrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightSrcAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightSrcAtop Instance { get; } = new HardLightSrcAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightSrcAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalSrcOver Instance { get; } = new NormalSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplySrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplySrcOver Instance { get; } = new MultiplySrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddSrcOver Instance { get; } = new AddSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractSrcOver Instance { get; } = new SubtractSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenSrcOver Instance { get; } = new ScreenSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenSrcOver Instance { get; } = new DarkenSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenSrcOver Instance { get; } = new LightenSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlaySrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlaySrcOver Instance { get; } = new OverlaySrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlaySrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightSrcOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightSrcOver Instance { get; } = new HardLightSrcOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightSrcOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalSrcIn Instance { get; } = new NormalSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplySrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplySrcIn Instance { get; } = new MultiplySrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddSrcIn Instance { get; } = new AddSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractSrcIn Instance { get; } = new SubtractSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenSrcIn Instance { get; } = new ScreenSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenSrcIn Instance { get; } = new DarkenSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenSrcIn Instance { get; } = new LightenSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlaySrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlaySrcIn Instance { get; } = new OverlaySrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlaySrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightSrcIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightSrcIn Instance { get; } = new HardLightSrcIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightSrcIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalSrcOut Instance { get; } = new NormalSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplySrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplySrcOut Instance { get; } = new MultiplySrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplySrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddSrcOut Instance { get; } = new AddSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractSrcOut Instance { get; } = new SubtractSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenSrcOut Instance { get; } = new ScreenSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenSrcOut Instance { get; } = new DarkenSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenSrcOut Instance { get; } = new LightenSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlaySrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlaySrcOut Instance { get; } = new OverlaySrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlaySrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlaySrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightSrcOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightSrcOut Instance { get; } = new HardLightSrcOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightSrcOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightSrcOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalDest Instance { get; } = new NormalDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyDest Instance { get; } = new MultiplyDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddDest Instance { get; } = new AddDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractDest Instance { get; } = new SubtractDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenDest Instance { get; } = new ScreenDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenDest Instance { get; } = new DarkenDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenDest Instance { get; } = new LightenDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayDest Instance { get; } = new OverlayDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightDest : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightDest Instance { get; } = new HardLightDest();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightDest(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDest(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalDestAtop Instance { get; } = new NormalDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyDestAtop Instance { get; } = new MultiplyDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddDestAtop Instance { get; } = new AddDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractDestAtop Instance { get; } = new SubtractDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenDestAtop Instance { get; } = new ScreenDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenDestAtop Instance { get; } = new DarkenDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenDestAtop Instance { get; } = new LightenDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayDestAtop Instance { get; } = new OverlayDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightDestAtop : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightDestAtop Instance { get; } = new HardLightDestAtop();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightDestAtop(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestAtop(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalDestOver Instance { get; } = new NormalDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyDestOver Instance { get; } = new MultiplyDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddDestOver Instance { get; } = new AddDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractDestOver Instance { get; } = new SubtractDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenDestOver Instance { get; } = new ScreenDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenDestOver Instance { get; } = new DarkenDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenDestOver Instance { get; } = new LightenDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayDestOver Instance { get; } = new OverlayDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightDestOver : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightDestOver Instance { get; } = new HardLightDestOver();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightDestOver(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestOver(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalDestIn Instance { get; } = new NormalDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyDestIn Instance { get; } = new MultiplyDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddDestIn Instance { get; } = new AddDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractDestIn Instance { get; } = new SubtractDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenDestIn Instance { get; } = new ScreenDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenDestIn Instance { get; } = new DarkenDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenDestIn Instance { get; } = new LightenDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayDestIn Instance { get; } = new OverlayDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightDestIn : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightDestIn Instance { get; } = new HardLightDestIn();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightDestIn(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestIn(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalDestOut Instance { get; } = new NormalDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyDestOut Instance { get; } = new MultiplyDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddDestOut Instance { get; } = new AddDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractDestOut Instance { get; } = new SubtractDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenDestOut Instance { get; } = new ScreenDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenDestOut Instance { get; } = new DarkenDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenDestOut Instance { get; } = new LightenDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayDestOut Instance { get; } = new OverlayDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightDestOut : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightDestOut Instance { get; } = new HardLightDestOut();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightDestOut(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightDestOut(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalClear Instance { get; } = new NormalClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyClear Instance { get; } = new MultiplyClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddClear Instance { get; } = new AddClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractClear Instance { get; } = new SubtractClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenClear Instance { get; } = new ScreenClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenClear Instance { get; } = new DarkenClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenClear Instance { get; } = new LightenClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayClear Instance { get; } = new OverlayClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightClear : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightClear Instance { get; } = new HardLightClear();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightClear(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightClear(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class NormalXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static NormalXor Instance { get; } = new NormalXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.NormalXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.NormalXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class MultiplyXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static MultiplyXor Instance { get; } = new MultiplyXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.MultiplyXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.MultiplyXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class AddXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static AddXor Instance { get; } = new AddXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.AddXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.AddXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class SubtractXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static SubtractXor Instance { get; } = new SubtractXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.SubtractXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.SubtractXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class ScreenXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static ScreenXor Instance { get; } = new ScreenXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.ScreenXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.ScreenXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class DarkenXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static DarkenXor Instance { get; } = new DarkenXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.DarkenXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.DarkenXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class LightenXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static LightenXor Instance { get; } = new LightenXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.LightenXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.LightenXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class OverlayXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static OverlayXor Instance { get; } = new OverlayXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.OverlayXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.OverlayXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+            internal class HardLightXor : PixelBlender<TPixel>
+            {
+                /// <summary>
+                /// Gets the static instance of this blender.
+                /// </summary>
+                public static HardLightXor Instance { get; } = new HardLightXor();
+
+                /// <inheritdoc />
+                public override TPixel Blend(TPixel background, TPixel source, float amount)
+                {
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.HardLightXor(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
+                {
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount);
+                    }                    
+                }
+
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.HardLightXor(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
+                }
+            }
+
+
+    }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
index 34fe4d4cda..f776da7a02 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/DefaultPixelBlenders.Generated.tt
@@ -12,9 +12,11 @@
 // Licensed under the Apache License, Version 2.0.
 
 // <auto-generated />
-using System;
-using System.Numerics;
-using System.Buffers;
+using System;
+using System.Numerics;
+using System.Buffers;
+
+using SixLabors.ImageSharp.Memory;
 using SixLabors.Memory;
 
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
@@ -78,32 +80,28 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
                 /// <inheritdoc />
                 public override TPixel Blend(TPixel background, TPixel source, float amount)
                 {
-                    return PorterDuffFunctions.<#=blender_composer#>(background, source, amount);
+                    TPixel dest = default;
+                    dest.PackFromScaledVector4(PorterDuffFunctions.<#=blender_composer#>(background.ToScaledVector4(), source.ToScaledVector4(), amount.Clamp(0, 1)));
+                    return dest;                    
                 }
 
                 /// <inheritdoc />
-                public override void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount)
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount)                
                 {
-                    Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
-                    Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
-
-                    using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
+                    amount = amount.Clamp(0, 1);
+                    for (int i = 0; i < destination.Length; i++)
                     {
-                        Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
-                        Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
-                        Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
-
-                        PixelOperations<TPixel>.Instance.ToVector4(background, backgroundSpan, destination.Length);
-                        PixelOperations<TPixel>.Instance.ToVector4(source, sourceSpan, destination.Length);
-
-                        for (int i = 0; i < destination.Length; i++)
-                        {
-                            destinationSpan[i] = PorterDuffFunctions.<#=blender_composer#>(backgroundSpan[i], sourceSpan[i], amount[i]);
-                        }
+                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount);
+                    }                    
+                }
 
-                        PixelOperations<TPixel>.Instance.PackFromVector4(destinationSpan, destination, destination.Length);
-                    }
+                /// <inheritdoc />
+                protected override void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount)                
+                {
+                    for (int i = 0; i < destination.Length; i++)
+                    {
+                        destination[i] = PorterDuffFunctions.<#=blender_composer#>(background[i], source[i], amount[i].Clamp(0, 1));
+                    }                    
                 }
             }
 
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
index 4b0ffdd485..0a6ef60eca 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.cs
@@ -3,6 +3,7 @@
 
 // <auto-generated />
 
+
 using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -16,107 +17,96 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Normal(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Normal(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Normal(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Normal(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Normal(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Normal(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 NormalClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -126,8 +116,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -137,8 +128,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -148,8 +140,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -159,8 +152,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -170,8 +164,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -181,8 +176,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -192,8 +188,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -203,8 +200,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -214,8 +212,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -225,8 +224,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -236,8 +236,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -247,113 +248,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel NormalXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(NormalXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(NormalXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplySrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Multiply(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplySrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Multiply(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplySrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Multiply(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplySrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Multiply(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Multiply(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Multiply(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 MultiplyClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -363,8 +354,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplySrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplySrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplySrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -374,8 +366,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplySrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplySrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplySrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -385,8 +378,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplySrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplySrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplySrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -396,8 +390,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplySrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplySrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplySrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -407,8 +402,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplySrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplySrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplySrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -418,8 +414,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -429,8 +426,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -440,8 +438,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -451,8 +450,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -462,8 +462,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -473,8 +474,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -484,113 +486,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel MultiplyXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(MultiplyXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(MultiplyXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Add(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Add(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Add(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Add(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Add(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Add(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 AddClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -600,8 +592,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -611,8 +604,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -622,8 +616,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -633,8 +628,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -644,8 +640,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -655,8 +652,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -666,8 +664,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -677,8 +676,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -688,8 +688,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -699,8 +700,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -710,8 +712,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -721,113 +724,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel AddXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(AddXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(AddXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Subtract(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Subtract(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Subtract(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Subtract(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Subtract(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Subtract(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 SubtractClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -837,8 +830,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -848,8 +842,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -859,8 +854,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -870,8 +866,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -881,8 +878,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -892,8 +890,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -903,8 +902,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -914,8 +914,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -925,8 +926,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -936,8 +938,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -947,8 +950,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -958,113 +962,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel SubtractXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(SubtractXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(SubtractXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Screen(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Screen(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Screen(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Screen(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Screen(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Screen(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 ScreenClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -1074,8 +1068,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1085,8 +1080,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1096,8 +1092,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1107,8 +1104,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1118,8 +1116,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1129,8 +1128,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1140,8 +1140,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1151,8 +1152,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1162,8 +1164,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1173,8 +1176,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1184,8 +1188,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1195,113 +1200,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel ScreenXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(ScreenXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(ScreenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Darken(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Darken(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Darken(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Darken(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Darken(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Darken(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 DarkenClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -1311,8 +1306,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1322,8 +1318,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1333,8 +1330,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1344,8 +1342,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1355,8 +1354,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1366,8 +1366,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1377,8 +1378,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1388,8 +1390,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1399,8 +1402,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1410,8 +1414,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1421,8 +1426,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1432,113 +1438,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel DarkenXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(DarkenXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(DarkenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Lighten(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Lighten(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Lighten(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Lighten(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Lighten(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Lighten(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 LightenClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -1548,8 +1544,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1559,8 +1556,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1570,8 +1568,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1581,8 +1580,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1592,8 +1592,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1603,8 +1604,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1614,8 +1616,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1625,8 +1628,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1636,8 +1640,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1647,8 +1652,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1658,8 +1664,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1669,113 +1676,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel LightenXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(LightenXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(LightenXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlaySrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlaySrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, Overlay(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlaySrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, Overlay(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlaySrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, Overlay(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlaySrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, Overlay(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, Overlay(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, Overlay(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 OverlayClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -1785,8 +1782,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlaySrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlaySrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlaySrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1796,8 +1794,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlaySrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlaySrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlaySrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1807,8 +1806,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlaySrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlaySrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlaySrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1818,8 +1818,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlaySrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlaySrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlaySrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1829,8 +1830,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlaySrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlaySrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlaySrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1840,8 +1842,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1851,8 +1854,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1862,8 +1866,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1873,8 +1878,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1884,8 +1890,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1895,8 +1902,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -1906,113 +1914,103 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel OverlayXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(OverlayXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(OverlayXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightSrc(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightSrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, HardLight(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightSrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, HardLight(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightSrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, HardLight(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightSrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightDest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightDestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, HardLight(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightDestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, HardLight(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightDestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, HardLight(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightDestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightXor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 HardLightClear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -2022,8 +2020,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightSrc<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightSrc(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightSrc(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2033,8 +2032,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightSrcAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightSrcAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightSrcAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2044,8 +2044,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightSrcOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightSrcOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightSrcOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2055,8 +2056,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightSrcIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightSrcIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightSrcIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2066,8 +2068,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightSrcOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightSrcOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightSrcOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2077,8 +2080,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightDest<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightDest(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightDest(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2088,8 +2092,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightDestAtop<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightDestAtop(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightDestAtop(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2099,8 +2104,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightDestOver<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightDestOver(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightDestOver(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2110,8 +2116,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightDestIn<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightDestIn(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightDestIn(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2121,8 +2128,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightDestOut<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightDestOut(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightDestOut(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2132,8 +2140,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightClear<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightClear(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightClear(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -2143,8 +2152,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel HardLightXor<TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(HardLightXor(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(HardLightXor(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
index 5e46a89a85..73c835e606 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.Generated.tt
@@ -13,6 +13,11 @@
 
 // <auto-generated />
 
+<#
+// Note use of MethodImplOptions.NoInlining. We have tests that are failing on certain architectures when
+// AggresiveInlining is used. Confirmed on Intel i7-6600U in 64bit.
+#>
+
 using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -24,107 +29,96 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 
 <# void GeneratePixelBlenders(string blender) { #>
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>Src(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return source;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>SrcAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(backdrop, source, <#=blender#>(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>SrcOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(backdrop, source, <#=blender#>(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>SrcIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(backdrop, source, <#=blender#>(backdrop, source));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>SrcOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(backdrop, source);
         }
 
-       [MethodImpl(MethodImplOptions.AggressiveInlining)]
+       [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>Dest(Vector4 backdrop, Vector4 source, float opacity)
         {
             return backdrop;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>DestAtop(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Atop(source, backdrop, <#=blender#>(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>DestOver(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Over(source, backdrop, <#=blender#>(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>DestIn(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return In(source, backdrop, <#=blender#>(source, backdrop));
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>DestOut(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Out(source, backdrop);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>Xor(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Xor(backdrop, source);
         }   
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static Vector4 <#=blender#>Clear(Vector4 backdrop, Vector4 source, float opacity)
         {
-            opacity = opacity.Clamp(0, 1);
-            source.W *= opacity;          
+            source.W *= opacity;
 
             return Clear(backdrop, source);
         }
@@ -137,8 +131,9 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
         public static TPixel <#=blender#><#=composer#><TPixel>(TPixel backdrop, TPixel source, float opacity)
             where TPixel : struct, IPixel<TPixel>
         {
+            opacity = opacity.Clamp(0, 1);
             TPixel dest = default;
-            dest.PackFromVector4(<#=blender#><#=composer#>(backdrop.ToVector4(),source.ToVector4(),opacity));
+            dest.PackFromScaledVector4(<#=blender#><#=composer#>(backdrop.ToScaledVector4(), source.ToScaledVector4(), opacity));
             return dest;
         }
 
@@ -175,7 +170,7 @@ string[] blenders = new []{
 
     foreach(var blender in blenders)
     {        
-        GeneratePixelBlenders(blender);
+        GeneratePixelBlenders(blender);        
         
         foreach(var composer in composers)
         {
diff --git a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
index e10c8fe918..9d0e9d04d3 100644
--- a/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlenders/PorterDuffFunctions.cs
@@ -8,7 +8,7 @@ using System.Runtime.CompilerServices;
 namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
 {
     /// <summary>
-    /// Collection of Porter Duff alpha blending functions applying an the 'Over' composition model.
+    /// Collection of Porter Duff Color Blending and Alpha Composition Functions.
     /// </summary>
     /// <remarks>
     /// These functions are designed to be a general solution for all color cases,
@@ -148,31 +148,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return backdrop <= 0.5f ? (2 * backdrop * source) : 1 - ((2 * (1 - source)) * (1 - backdrop));
         }
 
-        /// <summary>
-        /// General composition function for all modes, with a general solution for alpha channel
-        /// </summary>
-        /// <param name="backdrop">Original Backdrop color</param>
-        /// <param name="source">Original source color</param>
-        /// <param name="xform">Desired transformed color, without taking Alpha channel in account</param>
-        /// <returns>The final color</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector4 SrcOverReference(Vector4 backdrop, Vector4 source, Vector4 xform)
-        {
-            // calculate weights
-            float xw = backdrop.W * source.W;
-            float bw = backdrop.W - xw;
-            float sw = source.W - xw;
-
-            // calculate final alpha
-            float a = xw + bw + sw;
-
-            // calculate final value
-            xform = ((xform * xw) + (backdrop * bw) + (source * sw)) / MathF.Max(a, Constants.Epsilon);
-            xform.W = a;
-
-            return xform;
-        }
-
         public static Vector4 Over(Vector4 dst, Vector4 src, Vector4 blend)
         {
             // calculate weights
@@ -193,6 +169,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return color;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector4 Atop(Vector4 dst, Vector4 src, Vector4 blend)
         {
             // calculate weights
@@ -212,6 +189,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return color;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector4 In(Vector4 dst, Vector4 src, Vector4 blend)
         {
             float alpha = dst.W * src.W;
@@ -223,6 +201,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return color;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector4 Out(Vector4 dst, Vector4 src)
         {
             float alpha = (1 - dst.W) * src.W;
@@ -234,6 +213,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return color;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector4 Xor(Vector4 dst, Vector4 src)
         {
             float srcW = 1 - dst.W;
@@ -249,6 +229,7 @@ namespace SixLabors.ImageSharp.PixelFormats.PixelBlenders
             return color;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static Vector4 Clear(Vector4 backdrop, Vector4 source)
         {
             return Vector4.Zero;
diff --git a/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs b/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs
index b8b97ea0a4..63a101656e 100644
--- a/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs
+++ b/src/ImageSharp/PixelFormats/PixelBlender{TPixel}.cs
@@ -2,6 +2,9 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
+using System.Numerics;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.Memory;
 
 namespace SixLabors.ImageSharp.PixelFormats
@@ -23,19 +26,114 @@ namespace SixLabors.ImageSharp.PixelFormats
         /// At amount = 0, "from" is returned, at amount = 1, "to" is returned.
         /// </param>
         /// <returns>The final pixel value after composition</returns>
-        public abstract TPixel Blend(TPixel background, TPixel source, float amount);
-
-        /// <summary>
-        /// Blend 2 pixels together.
-        /// </summary>
-        /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/></param>
-        /// <param name="destination">The destination span.</param>
-        /// <param name="background">The background span.</param>
-        /// <param name="source">The source span.</param>
+        public abstract TPixel Blend(TPixel background, TPixel source, float amount);
+
+        /// <summary>
+        /// Blend 2 rows together.
+        /// </summary>
+        /// <param name="destination">destination span</param>
+        /// <param name="background">the background span</param>
+        /// <param name="source">the source span</param>
         /// <param name="amount">
         /// A value between 0 and 1 indicating the weight of the second source vector.
         /// At amount = 0, "from" is returned, at amount = 1, "to" is returned.
-        /// </param>
-        public abstract void Blend(MemoryAllocator memoryAllocator, Span<TPixel> destination, Span<TPixel> background, Span<TPixel> source, Span<float> amount);
+        /// </param>
+        protected abstract void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, float amount);
+
+        /// <summary>
+        /// Blend 2 rows together.
+        /// </summary>
+        /// <param name="destination">destination span</param>
+        /// <param name="background">the background span</param>
+        /// <param name="source">the source span</param>
+        /// <param name="amount">
+        /// A span with values between 0 and 1 indicating the weight of the second source vector.
+        /// At amount = 0, "from" is returned, at amount = 1, "to" is returned.
+        /// </param>
+        protected abstract void BlendFunction(Span<Vector4> destination, ReadOnlySpan<Vector4> background, ReadOnlySpan<Vector4> source, ReadOnlySpan<float> amount);
+
+        /// <summary>
+        /// Blends 2 rows together
+        /// </summary>
+        /// <param name="memoryManager">memory manager to use internally</param>
+        /// <param name="destination">the destination span</param>
+        /// <param name="background">the background span</param>
+        /// <param name="source">the source span</param>
+        /// <param name="amount">
+        /// A span with values between 0 and 1 indicating the weight of the second source vector.
+        /// At amount = 0, "from" is returned, at amount = 1, "to" is returned.
+        /// </param>
+        public void Blend(MemoryAllocator memoryManager, Span<TPixel> destination, ReadOnlySpan<TPixel> background, ReadOnlySpan<TPixel> source, ReadOnlySpan<float> amount)
+        {
+            this.Blend<TPixel>(memoryManager, destination, background, source, amount);
+        }
+
+        /// <summary>
+        /// Blends 2 rows together
+        /// </summary>
+        /// <typeparam name="TPixelSrc">the pixel format of the source span</typeparam>
+        /// <param name="memoryManager">memory manager to use internally</param>
+        /// <param name="destination">the destination span</param>
+        /// <param name="background">the background span</param>
+        /// <param name="source">the source span</param>
+        /// <param name="amount">
+        /// A span with values between 0 and 1 indicating the weight of the second source vector.
+        /// At amount = 0, "from" is returned, at amount = 1, "to" is returned.
+        /// </param>
+        public void Blend<TPixelSrc>(MemoryAllocator memoryManager, Span<TPixel> destination, ReadOnlySpan<TPixel> background, ReadOnlySpan<TPixelSrc> source, ReadOnlySpan<float> amount)
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+        {
+            Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
+            Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
+            Guard.MustBeGreaterThanOrEqualTo(amount.Length, destination.Length, nameof(amount.Length));
+
+            using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
+            {
+                Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
+                Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
+                Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
+
+                PixelOperations<TPixel>.Instance.ToScaledVector4(background, backgroundSpan, destination.Length);
+                PixelOperations<TPixelSrc>.Instance.ToScaledVector4(source, sourceSpan, destination.Length);
+
+                this.BlendFunction(destinationSpan, backgroundSpan, sourceSpan, amount);
+
+                PixelOperations<TPixel>.Instance.PackFromScaledVector4(destinationSpan, destination, destination.Length);
+            }
+        }
+
+        /// <summary>
+        /// Blends 2 rows together
+        /// </summary>
+        /// <typeparam name="TPixelSrc">the pixel format of the source span</typeparam>
+        /// <param name="memoryManager">memory manager to use internally</param>
+        /// <param name="destination">the destination span</param>
+        /// <param name="background">the background span</param>
+        /// <param name="source">the source span</param>
+        /// <param name="amount">
+        /// A value between 0 and 1 indicating the weight of the second source vector.
+        /// At amount = 0, "from" is returned, at amount = 1, "to" is returned.
+        /// </param>
+        public void Blend<TPixelSrc>(MemoryAllocator memoryManager, Span<TPixel> destination, ReadOnlySpan<TPixel> background, ReadOnlySpan<TPixelSrc> source, float amount)
+            where TPixelSrc : struct, IPixel<TPixelSrc>
+        {
+            Guard.MustBeGreaterThanOrEqualTo(background.Length, destination.Length, nameof(background.Length));
+            Guard.MustBeGreaterThanOrEqualTo(source.Length, destination.Length, nameof(source.Length));
+            Guard.MustBeBetweenOrEqualTo(amount, 0, 1, nameof(amount));
+
+            using (IMemoryOwner<Vector4> buffer = memoryManager.Allocate<Vector4>(destination.Length * 3))
+            {
+                Span<Vector4> destinationSpan = buffer.Slice(0, destination.Length);
+                Span<Vector4> backgroundSpan = buffer.Slice(destination.Length, destination.Length);
+                Span<Vector4> sourceSpan = buffer.Slice(destination.Length * 2, destination.Length);
+
+                PixelOperations<TPixel>.Instance.ToScaledVector4(background, backgroundSpan, destination.Length);
+                PixelOperations<TPixelSrc>.Instance.ToScaledVector4(source, sourceSpan, destination.Length);
+
+                this.BlendFunction(destinationSpan, backgroundSpan, sourceSpan, amount);
+
+                PixelOperations<TPixel>.Instance.PackFromScaledVector4(destinationSpan, destination, destination.Length);
+            }
+        }
     }
 }
diff --git a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs
index 07b2ed064e..0808c07d03 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/Convolution2PassProcessor.cs
@@ -67,7 +67,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             Buffer2D<TPixel> targetPixels,
             Buffer2D<TPixel> sourcePixels,
             Rectangle sourceRectangle,
-            DenseMatrix<float> kernel,
+            DenseMatrix<float> kernel, // TODO: Can't use 'in' as pass by ref to lambda expression.
             Configuration configuration)
         {
             int kernelHeight = kernel.Rows;
diff --git a/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs
index 0f6846d1bf..3da09cde09 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/IQuantizer.cs
@@ -23,5 +23,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <returns>The <see cref="IFrameQuantizer{TPixel}"/></returns>
         IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>()
             where TPixel : struct, IPixel<TPixel>;
+
+        /// <summary>
+        /// Creates the generic frame quantizer
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="maxColors">The maximum number of colors to hold in the color palette.</param>
+        /// <returns>The <see cref="IFrameQuantizer{TPixel}"/></returns>
+        IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(int maxColors)
+            where TPixel : struct, IPixel<TPixel>;
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeFrameQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeFrameQuantizer{TPixel}.cs
index 3eac70eea5..39546d63f7 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeFrameQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeFrameQuantizer{TPixel}.cs
@@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Maximum allowed color depth
         /// </summary>
-        private readonly byte colors;
+        private readonly int colors;
 
         /// <summary>
         /// Stores the tree
@@ -43,9 +43,23 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// the second pass quantizes a color based on the nodes in the tree
         /// </remarks>
         public OctreeFrameQuantizer(OctreeQuantizer quantizer)
+            : this(quantizer, quantizer.MaxColors)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OctreeFrameQuantizer{TPixel}"/> class.
+        /// </summary>
+        /// <param name="quantizer">The octree quantizer.</param>
+        /// <param name="maxColors">The maximum number of colors to hold in the color palette.</param>
+        /// <remarks>
+        /// The Octree quantizer is a two pass algorithm. The initial pass sets up the Octree,
+        /// the second pass quantizes a color based on the nodes in the tree
+        /// </remarks>
+        public OctreeFrameQuantizer(OctreeQuantizer quantizer, int maxColors)
             : base(quantizer, false)
         {
-            this.colors = (byte)quantizer.MaxColors;
+            this.colors = maxColors;
             this.octree = new Octree(ImageMaths.GetBitsNeededForColorDepth(this.colors).Clamp(1, 8));
         }
 
@@ -261,13 +275,13 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public TPixel[] Palletize(int colorCount)
             {
-                while (this.Leaves > colorCount)
+                while (this.Leaves > colorCount - 1)
                 {
                     this.Reduce();
                 }
 
                 // Now palletize the nodes
-                var palette = new TPixel[colorCount + 1];
+                var palette = new TPixel[colorCount];
 
                 int paletteIndex = 0;
                 this.root.ConstructPalette(palette, ref paletteIndex);
@@ -285,10 +299,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             /// The <see cref="int"/>.
             /// </returns>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int GetPaletteIndex(ref TPixel pixel, ref Rgba32 rgba)
-            {
-                return this.root.GetPaletteIndex(ref pixel, 0, ref rgba);
-            }
+            public int GetPaletteIndex(ref TPixel pixel, ref Rgba32 rgba) => this.root.GetPaletteIndex(ref pixel, 0, ref rgba);
 
             /// <summary>
             /// Keep track of the previous node that was quantized
@@ -297,10 +308,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             /// The node last quantized
             /// </param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            protected void TrackPrevious(OctreeNode node)
-            {
-                this.previousNode = node;
-            }
+            protected void TrackPrevious(OctreeNode node) => this.previousNode = node;
 
             /// <summary>
             /// Reduce the depth of the tree
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs
index 385f6246f8..22bb5223f0 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs
@@ -15,6 +15,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// </summary>
     public class OctreeQuantizer : IQuantizer
     {
+        /// <summary>
+        /// The default maximum number of colors to use when quantizing the image.
+        /// </summary>
+        public const int DefaultMaxColors = 256;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
         /// </summary>
@@ -26,7 +31,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
         /// </summary>
-        /// <param name="maxColors">The maximum number of colors to hold in the color palette</param>
+        /// <param name="maxColors">The maximum number of colors to hold in the color palette.</param>
         public OctreeQuantizer(int maxColors)
             : this(GetDiffuser(true), maxColors)
         {
@@ -37,7 +42,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// </summary>
         /// <param name="dither">Whether to apply dithering to the output image</param>
         public OctreeQuantizer(bool dither)
-            : this(GetDiffuser(dither), 255)
+            : this(GetDiffuser(dither), DefaultMaxColors)
         {
         }
 
@@ -46,7 +51,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// </summary>
         /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image</param>
         public OctreeQuantizer(IErrorDiffuser diffuser)
-            : this(diffuser, 255)
+            : this(diffuser, DefaultMaxColors)
         {
         }
 
@@ -57,10 +62,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <param name="maxColors">The maximum number of colors to hold in the color palette</param>
         public OctreeQuantizer(IErrorDiffuser diffuser, int maxColors)
         {
-            Guard.MustBeBetweenOrEqualTo(maxColors, 1, 255, nameof(maxColors));
-
             this.Diffuser = diffuser;
-            this.MaxColors = maxColors;
+            this.MaxColors = maxColors.Clamp(1, DefaultMaxColors);
         }
 
         /// <inheritdoc />
@@ -76,6 +79,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             where TPixel : struct, IPixel<TPixel>
             => new OctreeFrameQuantizer<TPixel>(this);
 
+        /// <inheritdoc/>
+        public IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(int maxColors)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            maxColors = maxColors.Clamp(1, DefaultMaxColors);
+            return new OctreeFrameQuantizer<TPixel>(this, maxColors);
+        }
+
         private static IErrorDiffuser GetDiffuser(bool dither) => dither ? KnownDiffusers.FloydSteinberg : null;
     }
 }
\ No newline at end of file
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteFrameQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteFrameQuantizer{TPixel}.cs
index 8df81b426f..cdf3514e2d 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/PaletteFrameQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/PaletteFrameQuantizer{TPixel}.cs
@@ -36,6 +36,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         public PaletteFrameQuantizer(PaletteQuantizer quantizer, TPixel[] colors)
             : base(quantizer, true)
         {
+            // TODO: Why is this value constrained? Gif has limitations but theoretically
+            // we might want to reduce the palette of an image to greater than that limitation.
             Guard.MustBeBetweenOrEqualTo(colors.Length, 1, 256, nameof(colors));
             this.palette = colors;
             this.paletteVector = new Vector4[this.palette.Length];
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
index 8ae9177185..27ef05dfe9 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
@@ -37,10 +37,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
         /// </summary>
         /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image</param>
-        public PaletteQuantizer(IErrorDiffuser diffuser)
-        {
-            this.Diffuser = diffuser;
-        }
+        public PaletteQuantizer(IErrorDiffuser diffuser) => this.Diffuser = diffuser;
 
         /// <inheritdoc />
         public IErrorDiffuser Diffuser { get; }
@@ -50,6 +47,21 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             where TPixel : struct, IPixel<TPixel>
             => this.CreateFrameQuantizer(() => NamedColors<TPixel>.WebSafePalette);
 
+        /// <inheritdoc/>
+        public IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(int maxColors)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            TPixel[] websafe = NamedColors<TPixel>.WebSafePalette;
+            int max = Math.Min(maxColors, websafe.Length);
+
+            if (max != websafe.Length)
+            {
+                return this.CreateFrameQuantizer(() => NamedColors<TPixel>.WebSafePalette.AsSpan(0, max).ToArray());
+            }
+
+            return this.CreateFrameQuantizer(() => websafe);
+        }
+
         /// <summary>
         /// Gets the palette to use to quantize the image.
         /// </summary>
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs
index 021dc62fbf..13bc057da8 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Buffers;
-using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -38,7 +37,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         where TPixel : struct, IPixel<TPixel>
     {
         // TODO: The WuFrameQuantizer<TPixel> code is rising several questions:
-        // - Do we really need to ALWAYS allocate the whole table of size TableLength? (~ 2471625 * sizeof(long) * 5 bytes )
+        // - Do we really need to ALWAYS allocate the whole table of size TableLength? (~ 2471625 * sizeof(long) * 5 bytes ) JS. I'm afraid so.
         // - Isn't an AOS ("array of structures") layout more efficient & more readable than SOA ("structure of arrays") for this particular use case?
         //   (T, R, G, B, A, M2) could be grouped together!
         // - It's a frequently used class, we need tests! (So we can optimize safely.) There are tests in the original!!! We should just adopt them!
@@ -47,12 +46,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// The index bits.
         /// </summary>
-        private const int IndexBits = 6;
+        private const int IndexBits = 5;
 
         /// <summary>
-        /// The index alpha bits.
+        /// The index alpha bits. Keep separate for now to allow easy adjustment.
         /// </summary>
-        private const int IndexAlphaBits = 3;
+        private const int IndexAlphaBits = 5;
 
         /// <summary>
         /// The index count.
@@ -65,7 +64,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         private const int IndexAlphaCount = (1 << IndexAlphaBits) + 1;
 
         /// <summary>
-        /// The table length.
+        /// The table length. Now 1185921.
         /// </summary>
         private const int TableLength = IndexCount * IndexCount * IndexCount * IndexAlphaCount;
 
@@ -128,11 +127,22 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// the second pass quantizes a color based on the position in the histogram.
         /// </remarks>
         public WuFrameQuantizer(WuQuantizer quantizer)
-            : base(quantizer, false)
+            : this(quantizer, quantizer.MaxColors)
         {
-            this.colors = quantizer.MaxColors;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WuFrameQuantizer{TPixel}"/> class.
+        /// </summary>
+        /// <param name="quantizer">The wu quantizer.</param>
+        /// <param name="maxColors">The maximum number of colors to hold in the color palette.</param>
+        /// <remarks>
+        /// The Wu quantizer is a two pass algorithm. The initial pass sets up the 3-D color histogram,
+        /// the second pass quantizes a color based on the position in the histogram.
+        /// </remarks>
+        public WuFrameQuantizer(WuQuantizer quantizer, int maxColors)
+            : base(quantizer, false) => this.colors = maxColors;
+
         /// <inheritdoc/>
         public override QuantizedFrame<TPixel> QuantizeFrame(ImageFrame<TPixel> image)
         {
@@ -169,18 +179,24 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             if (this.palette is null)
             {
                 this.palette = new TPixel[this.colors];
+                Span<long> vwtSpan = this.vwt.GetSpan();
+                Span<long> vmrSpan = this.vmr.GetSpan();
+                Span<long> vmgSpan = this.vmg.GetSpan();
+                Span<long> vmbSpan = this.vmb.GetSpan();
+                Span<long> vmaSpan = this.vma.GetSpan();
+
                 for (int k = 0; k < this.colors; k++)
                 {
                     this.Mark(ref this.colorCube[k], (byte)k);
 
-                    float weight = Volume(ref this.colorCube[k], this.vwt.GetSpan());
+                    float weight = Volume(ref this.colorCube[k], vwtSpan);
 
                     if (MathF.Abs(weight) > Constants.Epsilon)
                     {
-                        float r = Volume(ref this.colorCube[k], this.vmr.GetSpan());
-                        float g = Volume(ref this.colorCube[k], this.vmg.GetSpan());
-                        float b = Volume(ref this.colorCube[k], this.vmb.GetSpan());
-                        float a = Volume(ref this.colorCube[k], this.vma.GetSpan());
+                        float r = Volume(ref this.colorCube[k], vmrSpan);
+                        float g = Volume(ref this.colorCube[k], vmgSpan);
+                        float b = Volume(ref this.colorCube[k], vmbSpan);
+                        float a = Volume(ref this.colorCube[k], vmaSpan);
 
                         ref TPixel color = ref this.palette[k];
                         color.PackFromScaledVector4(new Vector4(r, g, b, a) / weight / 255F);
@@ -191,57 +207,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             return this.palette;
         }
 
-        /// <summary>
-        /// Quantizes the pixel
-        /// </summary>
-        /// <param name="rgba">The rgba used to quantize the pixel input</param>
-        private void QuantizePixel(ref Rgba32 rgba)
-        {
-            // Add the color to a 3-D color histogram.
-            int r = rgba.R >> (8 - IndexBits);
-            int g = rgba.G >> (8 - IndexBits);
-            int b = rgba.B >> (8 - IndexBits);
-            int a = rgba.A >> (8 - IndexAlphaBits);
-
-            int index = GetPaletteIndex(r + 1, g + 1, b + 1, a + 1);
-
-            Span<long> vwtSpan = this.vwt.GetSpan();
-            Span<long> vmrSpan = this.vmr.GetSpan();
-            Span<long> vmgSpan = this.vmg.GetSpan();
-            Span<long> vmbSpan = this.vmb.GetSpan();
-            Span<long> vmaSpan = this.vma.GetSpan();
-            Span<float> m2Span = this.m2.GetSpan();
-
-            vwtSpan[index]++;
-            vmrSpan[index] += rgba.R;
-            vmgSpan[index] += rgba.G;
-            vmbSpan[index] += rgba.B;
-            vmaSpan[index] += rgba.A;
-
-            var vector = new Vector4(rgba.R, rgba.G, rgba.B, rgba.A);
-            m2Span[index] += Vector4.Dot(vector, vector);
-        }
-
         /// <inheritdoc/>
         protected override void FirstPass(ImageFrame<TPixel> source, int width, int height)
         {
-            // Build up the 3-D color histogram
-            // Loop through each row
-            for (int y = 0; y < height; y++)
-            {
-                Span<TPixel> row = source.GetPixelRowSpan(y);
-                ref TPixel scanBaseRef = ref MemoryMarshal.GetReference(row);
-
-                // And loop through each column
-                Rgba32 rgba = default;
-                for (int x = 0; x < width; x++)
-                {
-                    ref TPixel pixel = ref Unsafe.Add(ref scanBaseRef, x);
-                    pixel.ToRgba32(ref rgba);
-                    this.QuantizePixel(ref rgba);
-                }
-            }
-
+            this.Build3DHistogram(source, width, height);
             this.Get3DMoments(source.MemoryAllocator);
             this.BuildCube();
         }
@@ -456,6 +425,54 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             }
         }
 
+        /// <summary>
+        /// Builds a 3-D color histogram of <c>counts, r/g/b, c^2</c>.
+        /// </summary>
+        /// <param name="source">The source data.</param>
+        /// <param name="width">The width in pixels of the image.</param>
+        /// <param name="height">The height in pixels of the image.</param>
+        private void Build3DHistogram(ImageFrame<TPixel> source, int width, int height)
+        {
+            Span<long> vwtSpan = this.vwt.GetSpan();
+            Span<long> vmrSpan = this.vmr.GetSpan();
+            Span<long> vmgSpan = this.vmg.GetSpan();
+            Span<long> vmbSpan = this.vmb.GetSpan();
+            Span<long> vmaSpan = this.vma.GetSpan();
+            Span<float> m2Span = this.m2.GetSpan();
+
+            // Build up the 3-D color histogram
+            // Loop through each row
+            for (int y = 0; y < height; y++)
+            {
+                Span<TPixel> row = source.GetPixelRowSpan(y);
+                ref TPixel scanBaseRef = ref MemoryMarshal.GetReference(row);
+
+                // And loop through each column
+                Rgba32 rgba = default;
+                for (int x = 0; x < width; x++)
+                {
+                    ref TPixel pixel = ref Unsafe.Add(ref scanBaseRef, x);
+                    pixel.ToRgba32(ref rgba);
+
+                    int r = rgba.R >> (8 - IndexBits);
+                    int g = rgba.G >> (8 - IndexBits);
+                    int b = rgba.B >> (8 - IndexBits);
+                    int a = rgba.A >> (8 - IndexAlphaBits);
+
+                    int index = GetPaletteIndex(r + 1, g + 1, b + 1, a + 1);
+
+                    vwtSpan[index]++;
+                    vmrSpan[index] += rgba.R;
+                    vmgSpan[index] += rgba.G;
+                    vmbSpan[index] += rgba.B;
+                    vmaSpan[index] += rgba.A;
+
+                    var vector = new Vector4(rgba.R, rgba.G, rgba.B, rgba.A);
+                    m2Span[index] += Vector4.Dot(vector, vector);
+                }
+            }
+        }
+
         /// <summary>
         /// Converts the histogram into moments so that we can rapidly calculate the sums of the above quantities over any desired box.
         /// </summary>
@@ -621,22 +638,28 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <returns>The <see cref="float"/>.</returns>
         private float Maximize(ref Box cube, int direction, int first, int last, out int cut, float wholeR, float wholeG, float wholeB, float wholeA, float wholeW)
         {
-            long baseR = Bottom(ref cube, direction, this.vmr.GetSpan());
-            long baseG = Bottom(ref cube, direction, this.vmg.GetSpan());
-            long baseB = Bottom(ref cube, direction, this.vmb.GetSpan());
-            long baseA = Bottom(ref cube, direction, this.vma.GetSpan());
-            long baseW = Bottom(ref cube, direction, this.vwt.GetSpan());
+            Span<long> vwtSpan = this.vwt.GetSpan();
+            Span<long> vmrSpan = this.vmr.GetSpan();
+            Span<long> vmgSpan = this.vmg.GetSpan();
+            Span<long> vmbSpan = this.vmb.GetSpan();
+            Span<long> vmaSpan = this.vma.GetSpan();
+
+            long baseR = Bottom(ref cube, direction, vmrSpan);
+            long baseG = Bottom(ref cube, direction, vmgSpan);
+            long baseB = Bottom(ref cube, direction, vmbSpan);
+            long baseA = Bottom(ref cube, direction, vmaSpan);
+            long baseW = Bottom(ref cube, direction, vwtSpan);
 
             float max = 0F;
             cut = -1;
 
             for (int i = first; i < last; i++)
             {
-                float halfR = baseR + Top(ref cube, direction, i, this.vmr.GetSpan());
-                float halfG = baseG + Top(ref cube, direction, i, this.vmg.GetSpan());
-                float halfB = baseB + Top(ref cube, direction, i, this.vmb.GetSpan());
-                float halfA = baseA + Top(ref cube, direction, i, this.vma.GetSpan());
-                float halfW = baseW + Top(ref cube, direction, i, this.vwt.GetSpan());
+                float halfR = baseR + Top(ref cube, direction, i, vmrSpan);
+                float halfG = baseG + Top(ref cube, direction, i, vmgSpan);
+                float halfB = baseB + Top(ref cube, direction, i, vmbSpan);
+                float halfA = baseA + Top(ref cube, direction, i, vmaSpan);
+                float halfW = baseW + Top(ref cube, direction, i, vwtSpan);
 
                 if (MathF.Abs(halfW) < Constants.Epsilon)
                 {
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer.cs
index 3aa1f4c5e6..5123e737d3 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer.cs
@@ -14,6 +14,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// </summary>
     public class WuQuantizer : IQuantizer
     {
+        /// <summary>
+        /// The default maximum number of colors to use when quantizing the image.
+        /// </summary>
+        public const int DefaultMaxColors = 256;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="WuQuantizer"/> class.
         /// </summary>
@@ -36,7 +41,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// </summary>
         /// <param name="dither">Whether to apply dithering to the output image</param>
         public WuQuantizer(bool dither)
-            : this(GetDiffuser(dither), 255)
+            : this(GetDiffuser(dither), DefaultMaxColors)
         {
         }
 
@@ -45,7 +50,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// </summary>
         /// <param name="diffuser">The error diffusion algorithm, if any, to apply to the output image</param>
         public WuQuantizer(IErrorDiffuser diffuser)
-            : this(diffuser, 255)
+            : this(diffuser, DefaultMaxColors)
         {
         }
 
@@ -56,10 +61,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <param name="maxColors">The maximum number of colors to hold in the color palette</param>
         public WuQuantizer(IErrorDiffuser diffuser, int maxColors)
         {
-            Guard.MustBeBetweenOrEqualTo(maxColors, 1, 255, nameof(maxColors));
-
             this.Diffuser = diffuser;
-            this.MaxColors = maxColors;
+            this.MaxColors = maxColors.Clamp(1, DefaultMaxColors);
         }
 
         /// <inheritdoc />
@@ -75,6 +78,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
             where TPixel : struct, IPixel<TPixel>
             => new WuFrameQuantizer<TPixel>(this);
 
+        /// <inheritdoc/>
+        public IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(int maxColors)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            maxColors = maxColors.Clamp(1, DefaultMaxColors);
+            return new WuFrameQuantizer<TPixel>(this, maxColors);
+        }
+
         private static IErrorDiffuser GetDiffuser(bool dither) => dither ? KnownDiffusers.FloydSteinberg : null;
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/ConfigurationTests.cs b/tests/ImageSharp.Tests/ConfigurationTests.cs
index 4bec25f7a2..6a8479b2b2 100644
--- a/tests/ImageSharp.Tests/ConfigurationTests.cs
+++ b/tests/ImageSharp.Tests/ConfigurationTests.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using Moq;
+using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.IO;
 using Xunit;
 // ReSharper disable InconsistentNaming
@@ -37,19 +38,13 @@ namespace SixLabors.ImageSharp.Tests
         /// Test that the default configuration is not null.
         /// </summary>
         [Fact]
-        public void TestDefaultConfigurationIsNotNull()
-        {
-            Assert.True(Configuration.Default != null);
-        }
+        public void TestDefaultConfigurationIsNotNull() => Assert.True(Configuration.Default != null);
 
         /// <summary>
         /// Test that the default configuration read origin options is set to begin.
         /// </summary>
         [Fact]
-        public void TestDefaultConfigurationReadOriginIsCurrent()
-        {
-            Assert.True(Configuration.Default.ReadOrigin == ReadOrigin.Current);
-        }
+        public void TestDefaultConfigurationReadOriginIsCurrent() => Assert.True(Configuration.Default.ReadOrigin == ReadOrigin.Current);
 
         /// <summary>
         /// Test that the default configuration parallel options max degrees of parallelism matches the
@@ -101,7 +96,7 @@ namespace SixLabors.ImageSharp.Tests
 
             Assert.Equal(count, config.ImageFormats.Count());
 
-            config.ImageFormatsManager.AddImageFormat(ImageFormats.Bmp);
+            config.ImageFormatsManager.AddImageFormat(BmpFormat.Instance);
 
             Assert.Equal(count, config.ImageFormats.Count());
         }
diff --git a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
index d887d23ade..b9f855cf12 100644
--- a/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
@@ -28,10 +28,14 @@ namespace SixLabors.ImageSharp.Tests
             { TestImages.Bmp.RLE, 2835, 2835, PixelResolutionUnit.PixelsPerMeter }
         };
 
-        public BmpEncoderTests(ITestOutputHelper output)
+        public static readonly TheoryData<string, BmpBitsPerPixel> BmpBitsPerPixelFiles =
+        new TheoryData<string, BmpBitsPerPixel>
         {
-            this.Output = output;
-        }
+            { TestImages.Bmp.Car, BmpBitsPerPixel.Pixel24 },
+            { TestImages.Bmp.Bit32Rgb, BmpBitsPerPixel.Pixel32 }
+        };
+
+        public BmpEncoderTests(ITestOutputHelper output) => this.Output = output;
 
         private ITestOutputHelper Output { get; }
 
@@ -61,13 +65,34 @@ namespace SixLabors.ImageSharp.Tests
         }
 
         [Theory]
-        [WithTestPatternImages(nameof(BitsPerPixel), 24, 24, PixelTypes.Rgba32 | PixelTypes.Bgra32 | PixelTypes.Rgb24)]
-        public void Encode_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
-            where TPixel : struct, IPixel<TPixel>
+        [MemberData(nameof(BmpBitsPerPixelFiles))]
+        public void Encode_PreserveBitsPerPixel(string imagePath, BmpBitsPerPixel bmpBitsPerPixel)
         {
-            TestBmpEncoderCore(provider, bitsPerPixel);
+            var options = new BmpEncoder();
+
+            var testFile = TestFile.Create(imagePath);
+            using (Image<Rgba32> input = testFile.CreateImage())
+            {
+                using (var memStream = new MemoryStream())
+                {
+                    input.Save(memStream, options);
+
+                    memStream.Position = 0;
+                    using (var output = Image.Load<Rgba32>(memStream))
+                    {
+                        BmpMetaData meta = output.MetaData.GetFormatMetaData(BmpFormat.Instance);
+
+                        Assert.Equal(bmpBitsPerPixel, meta.BitsPerPixel);
+                    }
+                }
+            }
         }
 
+        [Theory]
+        [WithTestPatternImages(nameof(BitsPerPixel), 24, 24, PixelTypes.Rgba32 | PixelTypes.Bgra32 | PixelTypes.Rgb24)]
+        public void Encode_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel);
+
         [Theory]
         [WithTestPatternImages(nameof(BitsPerPixel), 48, 24, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel), 47, 8, PixelTypes.Rgba32)]
@@ -75,10 +100,7 @@ namespace SixLabors.ImageSharp.Tests
         [WithSolidFilledImages(nameof(BitsPerPixel), 1, 1, 255, 100, 50, 255, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel), 7, 5, PixelTypes.Rgba32)]
         public void Encode_WorksWithDifferentSizes<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            TestBmpEncoderCore(provider, bitsPerPixel);
-        }
+            where TPixel : struct, IPixel<TPixel> => TestBmpEncoderCore(provider, bitsPerPixel);
 
         private static void TestBmpEncoderCore<TPixel>(TestImageProvider<TPixel> provider, BmpBitsPerPixel bitsPerPixel)
             where TPixel : struct, IPixel<TPixel>
diff --git a/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs b/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs
index 23b806767c..f8b035ca83 100644
--- a/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs
+++ b/tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs
@@ -44,7 +44,7 @@ namespace SixLabors.ImageSharp.Tests
                 using (Image<Rgba32> image = file.CreateImage())
                 {
                     string filename = path + "/" + file.FileNameWithoutExtension + ".txt";
-                    File.WriteAllText(filename, image.ToBase64String(ImageFormats.Png));
+                    File.WriteAllText(filename, image.ToBase64String(PngFormat.Instance));
                 }
             }
         }
diff --git a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
index e9104ef8d9..c5c971962c 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
@@ -55,10 +55,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
         [MemberData(nameof(RatioFiles))]
         public void Encode_PreserveRatio(string imagePath, int xResolution, int yResolution, PixelResolutionUnit resolutionUnit)
         {
-            var options = new GifEncoder()
-            {
-                IgnoreMetadata = false
-            };
+            var options = new GifEncoder();
 
             var testFile = TestFile.Create(imagePath);
             using (Image<Rgba32> input = testFile.CreateImage())
@@ -82,10 +79,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
         [Fact]
         public void Encode_IgnoreMetadataIsFalse_CommentsAreWritten()
         {
-            var options = new GifEncoder()
-            {
-                IgnoreMetadata = false
-            };
+            var options = new GifEncoder();
 
             var testFile = TestFile.Create(TestImages.Gif.Rings);
 
@@ -109,15 +103,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
         [Fact]
         public void Encode_IgnoreMetadataIsTrue_CommentsAreNotWritten()
         {
-            var options = new GifEncoder()
-            {
-                IgnoreMetadata = true
-            };
+            var options = new GifEncoder();
 
             var testFile = TestFile.Create(TestImages.Gif.Rings);
 
             using (Image<Rgba32> input = testFile.CreateImage())
             {
+                input.MetaData.Properties.Clear();
                 using (var memStream = new MemoryStream())
                 {
                     input.SaveAsGif(memStream, options);
@@ -179,5 +171,49 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
                 Assert.True(fileInfoGlobal.Length < fileInfoLocal.Length);
             }
         }
+
+        [Fact]
+        public void NonMutatingEncodePreservesPaletteCount()
+        {
+            using (var inStream = new MemoryStream(TestFile.Create(TestImages.Gif.Leo).Bytes))
+            using (var outStream = new MemoryStream())
+            {
+                inStream.Position = 0;
+
+                var image = Image.Load(inStream);
+                GifMetaData metaData = image.MetaData.GetFormatMetaData(GifFormat.Instance);
+                GifFrameMetaData frameMetaData = image.Frames.RootFrame.MetaData.GetFormatMetaData(GifFormat.Instance);
+                GifColorTableMode colorMode = metaData.ColorTableMode;
+                var encoder = new GifEncoder()
+                {
+                    ColorTableMode = colorMode,
+                    Quantizer = new OctreeQuantizer(frameMetaData.ColorTableLength)
+                };
+
+                image.Save(outStream, encoder);
+                outStream.Position = 0;
+
+                outStream.Position = 0;
+                var clone = Image.Load(outStream);
+
+                GifMetaData cloneMetaData = clone.MetaData.GetFormatMetaData<GifMetaData>(GifFormat.Instance);
+                Assert.Equal(metaData.ColorTableMode, cloneMetaData.ColorTableMode);
+
+                // Gifiddle and Cyotek GifInfo say this image has 64 colors.
+                Assert.Equal(64, frameMetaData.ColorTableLength);
+
+                for (int i = 0; i < image.Frames.Count; i++)
+                {
+                    GifFrameMetaData ifm = image.Frames[i].MetaData.GetFormatMetaData(GifFormat.Instance);
+                    GifFrameMetaData cifm = clone.Frames[i].MetaData.GetFormatMetaData(GifFormat.Instance);
+
+                    Assert.Equal(ifm.ColorTableLength, cifm.ColorTableLength);
+                    Assert.Equal(ifm.FrameDelay, cifm.FrameDelay);
+                }
+
+                image.Dispose();
+                clone.Dispose();
+            }
+        }
     }
 }
diff --git a/tests/ImageSharp.Tests/Formats/Gif/Sections/GifGraphicControlExtensionTests.cs b/tests/ImageSharp.Tests/Formats/Gif/Sections/GifGraphicControlExtensionTests.cs
index 2790b1a576..dc0da5e2db 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/Sections/GifGraphicControlExtensionTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/Sections/GifGraphicControlExtensionTests.cs
@@ -12,10 +12,10 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
         [Fact]
         public void TestPackedValue()
         {
-            Assert.Equal(0, GifGraphicControlExtension.GetPackedValue(DisposalMethod.Unspecified, false, false));
-            Assert.Equal(11, GifGraphicControlExtension.GetPackedValue(DisposalMethod.RestoreToBackground, true, true));
-            Assert.Equal(4, GifGraphicControlExtension.GetPackedValue(DisposalMethod.NotDispose, false, false));
-            Assert.Equal(14, GifGraphicControlExtension.GetPackedValue(DisposalMethod.RestoreToPrevious, true, false));
+            Assert.Equal(0, GifGraphicControlExtension.GetPackedValue(GifDisposalMethod.Unspecified, false, false));
+            Assert.Equal(11, GifGraphicControlExtension.GetPackedValue(GifDisposalMethod.RestoreToBackground, true, true));
+            Assert.Equal(4, GifGraphicControlExtension.GetPackedValue(GifDisposalMethod.NotDispose, false, false));
+            Assert.Equal(14, GifGraphicControlExtension.GetPackedValue(GifDisposalMethod.RestoreToPrevious, true, false));
         }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Formats/Gif/Sections/GifImageDescriptorTests.cs b/tests/ImageSharp.Tests/Formats/Gif/Sections/GifImageDescriptorTests.cs
index 4ef4c12d97..6a90c0c277 100644
--- a/tests/ImageSharp.Tests/Formats/Gif/Sections/GifImageDescriptorTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Gif/Sections/GifImageDescriptorTests.cs
@@ -12,13 +12,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Gif
         [Fact]
         public void TestPackedValue()
         {
-            Assert.Equal(128, GifImageDescriptor.GetPackedValue(true, false, false, 1));  // localColorTable
-            Assert.Equal(64,  GifImageDescriptor.GetPackedValue(false, true, false, 1));  // interfaceFlag
-            Assert.Equal(32,  GifImageDescriptor.GetPackedValue(false, false, true, 1));  // sortFlag
-            Assert.Equal(224, GifImageDescriptor.GetPackedValue(true,  true,  true, 1));  // all
-            Assert.Equal(7,   GifImageDescriptor.GetPackedValue(false, false, false, 8));
-            Assert.Equal(227, GifImageDescriptor.GetPackedValue(true, true, true, 4));
-            Assert.Equal(231, GifImageDescriptor.GetPackedValue(true, true, true, 8));
+            Assert.Equal(129, GifImageDescriptor.GetPackedValue(true, false, false, 1));  // localColorTable
+            Assert.Equal(65,  GifImageDescriptor.GetPackedValue(false, true, false, 1));  // interfaceFlag
+            Assert.Equal(33,  GifImageDescriptor.GetPackedValue(false, false, true, 1));  // sortFlag
+            Assert.Equal(225, GifImageDescriptor.GetPackedValue(true,  true,  true, 1));  // all
+            Assert.Equal(8,   GifImageDescriptor.GetPackedValue(false, false, false, 8));
+            Assert.Equal(228, GifImageDescriptor.GetPackedValue(true, true, true, 4));
+            Assert.Equal(232, GifImageDescriptor.GetPackedValue(true, true, true, 8));
         }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs b/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs
index f10a4ce842..464b1564b8 100644
--- a/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs
+++ b/tests/ImageSharp.Tests/Formats/ImageFormatManagerTests.cs
@@ -61,7 +61,7 @@ namespace SixLabors.ImageSharp.Tests
             });
             Assert.Throws<ArgumentNullException>(() =>
             {
-                this.DefaultFormatsManager.SetEncoder(ImageFormats.Bmp, null);
+                this.DefaultFormatsManager.SetEncoder(BmpFormat.Instance, null);
             });
             Assert.Throws<ArgumentNullException>(() =>
             {
@@ -78,7 +78,7 @@ namespace SixLabors.ImageSharp.Tests
             });
             Assert.Throws<ArgumentNullException>(() =>
             {
-                this.DefaultFormatsManager.SetDecoder(ImageFormats.Bmp, null);
+                this.DefaultFormatsManager.SetDecoder(BmpFormat.Instance, null);
             });
             Assert.Throws<ArgumentNullException>(() =>
             {
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs
index 3c98d5be72..a14c4735f5 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.Images.cs
@@ -21,7 +21,11 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                 TestImages.Jpeg.Baseline.Bad.BadEOF,
                 TestImages.Jpeg.Issues.MultiHuffmanBaseline394,
                 TestImages.Jpeg.Baseline.MultiScanBaselineCMYK,
-                TestImages.Jpeg.Baseline.Bad.BadRST
+                TestImages.Jpeg.Baseline.Bad.BadRST,
+                TestImages.Jpeg.Issues.MultiHuffmanBaseline394,
+                TestImages.Jpeg.Issues.ExifDecodeOutOfRange694,
+                TestImages.Jpeg.Issues.InvalidEOI695,
+                TestImages.Jpeg.Issues.ExifResizeOutOfRange696
             };
 
         public static string[] ProgressiveTestJpegs =
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs
index 2e67c06c18..4810985f11 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.MetaData.cs
@@ -49,6 +49,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             { TestImages.Jpeg.Baseline.GammaDalaiLamaGray, 72, 72, PixelResolutionUnit.PixelsPerInch }
         };
 
+        public static readonly TheoryData<string, int> QualityFiles =
+        new TheoryData<string, int>
+        {
+            { TestImages.Jpeg.Baseline.Calliphora, 80},
+            { TestImages.Jpeg.Progressive.Fb, 75 }
+        };
+
         [Theory]
         [MemberData(nameof(MetaDataTestData))]
         public void MetaDataIsParsedCorrectly(
@@ -101,6 +108,36 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             }
         }
 
+        [Theory]
+        [MemberData(nameof(QualityFiles))]
+        public void Identify_VerifyQuality(string imagePath, int quality)
+        {
+            var testFile = TestFile.Create(imagePath);
+            using (var stream = new MemoryStream(testFile.Bytes, false))
+            {
+                var decoder = new JpegDecoder();
+                IImageInfo image = decoder.Identify(Configuration.Default, stream);
+                JpegMetaData meta = image.MetaData.GetFormatMetaData(JpegFormat.Instance);
+                Assert.Equal(quality, meta.Quality);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(QualityFiles))]
+        public void Decode_VerifyQuality(string imagePath, int quality)
+        {
+            var testFile = TestFile.Create(imagePath);
+            using (var stream = new MemoryStream(testFile.Bytes, false))
+            {
+                var decoder = new JpegDecoder();
+                using (Image<Rgba32> image = decoder.Decode<Rgba32>(Configuration.Default, stream))
+                {
+                    JpegMetaData meta = image.MetaData.GetFormatMetaData(JpegFormat.Instance);
+                    Assert.Equal(quality, meta.Quality);
+                }
+            }
+        }
+
         private static void TestImageInfo(string imagePath, IImageDecoder decoder, bool useIdentify, Action<IImageInfo> test)
         {
             var testFile = TestFile.Create(imagePath);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs
index 4ae955c323..5977e59cf3 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs
@@ -48,6 +48,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                     TestImages.Jpeg.Issues.BadZigZagProgressive385,
                     TestImages.Jpeg.Issues.NoEoiProgressive517,
                     TestImages.Jpeg.Issues.BadRstProgressive518,
+                    TestImages.Jpeg.Issues.InvalidEOI695,
+                    TestImages.Jpeg.Issues.ExifResizeOutOfRange696
                 };
 
             return !TestEnvironment.Is64BitProcess && largeImagesToSkipOn32Bit.Contains(provider.SourceFileOrDescription);
diff --git a/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs
index a31ae37b75..598d99274a 100644
--- a/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Jpg/JpegEncoderTests.cs
@@ -14,6 +14,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
 {
     public class JpegEncoderTests
     {
+        public static readonly TheoryData<string, int> QualityFiles =
+        new TheoryData<string, int>
+        {
+            { TestImages.Jpeg.Baseline.Calliphora, 80},
+            { TestImages.Jpeg.Progressive.Fb, 75 }
+        };
+
         public static readonly TheoryData<JpegSubsample, int> BitsPerPixel_Quality =
         new TheoryData<JpegSubsample, int>
         {
@@ -34,6 +41,29 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             { TestImages.Jpeg.Baseline.GammaDalaiLamaGray, 72, 72, PixelResolutionUnit.PixelsPerInch }
         };
 
+        [Theory]
+        [MemberData(nameof(QualityFiles))]
+        public void Encode_PreserveQuality(string imagePath, int quality)
+        {
+            var options = new JpegEncoder();
+
+            var testFile = TestFile.Create(imagePath);
+            using (Image<Rgba32> input = testFile.CreateImage())
+            {
+                using (var memStream = new MemoryStream())
+                {
+                    input.Save(memStream, options);
+
+                    memStream.Position = 0;
+                    using (var output = Image.Load<Rgba32>(memStream))
+                    {
+                        JpegMetaData meta = output.MetaData.GetFormatMetaData(JpegFormat.Instance);
+                        Assert.Equal(quality, meta.Quality);
+                    }
+                }
+            }
+        }
+
         [Theory]
         [WithFile(TestImages.Png.CalliphoraPartial, nameof(BitsPerPixel_Quality), PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 73, 71, PixelTypes.Rgba32)]
@@ -43,18 +73,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
         [WithSolidFilledImages(nameof(BitsPerPixel_Quality), 1, 1, 255, 100, 50, 255, PixelTypes.Rgba32)]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 7, 5, PixelTypes.Rgba32)]
         public void EncodeBaseline_WorksWithDifferentSizes<TPixel>(TestImageProvider<TPixel> provider, JpegSubsample subsample, int quality)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            TestJpegEncoderCore(provider, subsample, quality);
-        }
+            where TPixel : struct, IPixel<TPixel> => TestJpegEncoderCore(provider, subsample, quality);
 
         [Theory]
         [WithTestPatternImages(nameof(BitsPerPixel_Quality), 48, 48, PixelTypes.Rgba32 | PixelTypes.Bgra32)]
         public void EncodeBaseline_IsNotBoundToSinglePixelType<TPixel>(TestImageProvider<TPixel> provider, JpegSubsample subsample, int quality)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            TestJpegEncoderCore(provider, subsample, quality);
-        }
+            where TPixel : struct, IPixel<TPixel> => TestJpegEncoderCore(provider, subsample, quality);
 
         /// <summary>
         /// Anton's SUPER-SCIENTIFIC tolerance threshold calculation
@@ -103,38 +127,6 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
             }
         }
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void IgnoreMetadata_ControlsIfExifProfileIsWritten(bool ignoreMetaData)
-        {
-            var encoder = new JpegEncoder()
-            {
-                IgnoreMetadata = ignoreMetaData
-            };
-
-            using (Image<Rgba32> input = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage())
-            {
-                using (var memStream = new MemoryStream())
-                {
-                    input.Save(memStream, encoder);
-
-                    memStream.Position = 0;
-                    using (var output = Image.Load<Rgba32>(memStream))
-                    {
-                        if (ignoreMetaData)
-                        {
-                            Assert.Null(output.MetaData.ExifProfile);
-                        }
-                        else
-                        {
-                            Assert.NotNull(output.MetaData.ExifProfile);
-                        }
-                    }
-                }
-            }
-        }
-
         [Fact]
         public void Quality_0_And_1_Are_Identical()
         {
diff --git a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
index 62de45064a..0508ac8c26 100644
--- a/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
+++ b/tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
@@ -23,6 +23,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
         // The images are an exact match. Maybe the submodule isn't updating?
         private const float ToleranceThresholdForPaletteEncoder = 1.3F / 100;
 
+        public static readonly TheoryData<string, PngBitDepth> PngBitDepthFiles =
+        new TheoryData<string, PngBitDepth>
+        {
+            { TestImages.Png.Rgb48Bpp, PngBitDepth.Bit16 },
+            { TestImages.Png.Bpp1, PngBitDepth.Bit1 }
+        };
+
         /// <summary>
         /// All types except Palette
         /// </summary>
@@ -221,7 +228,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
                                                : image;
 
                     float paletteToleranceHack = 80f / paletteSize;
-                    paletteToleranceHack = paletteToleranceHack * paletteToleranceHack;
+                    paletteToleranceHack *= paletteToleranceHack;
                     ImageComparer comparer = pngColorType == PngColorType.Palette
                                                  ? ImageComparer.Tolerant(ToleranceThresholdForPaletteEncoder * paletteToleranceHack)
                                                  : ImageComparer.Exact;
@@ -290,5 +297,29 @@ namespace SixLabors.ImageSharp.Tests.Formats.Png
                 }
             }
         }
+
+        [Theory]
+        [MemberData(nameof(PngBitDepthFiles))]
+        public void Encode_PreserveBits(string imagePath, PngBitDepth pngBitDepth)
+        {
+            var options = new PngEncoder();
+
+            var testFile = TestFile.Create(imagePath);
+            using (Image<Rgba32> input = testFile.CreateImage())
+            {
+                using (var memStream = new MemoryStream())
+                {
+                    input.Save(memStream, options);
+
+                    memStream.Position = 0;
+                    using (var output = Image.Load<Rgba32>(memStream))
+                    {
+                        PngMetaData meta = output.MetaData.GetFormatMetaData(PngFormat.Instance);
+
+                        Assert.Equal(pngBitDepth, meta.BitDepth);
+                    }
+                }
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/ImageSharp.Tests/MetaData/ImageFrameMetaDataTests.cs b/tests/ImageSharp.Tests/MetaData/ImageFrameMetaDataTests.cs
index 507401398e..0a0ca1efa4 100644
--- a/tests/ImageSharp.Tests/MetaData/ImageFrameMetaDataTests.cs
+++ b/tests/ImageSharp.Tests/MetaData/ImageFrameMetaDataTests.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Gif;
 using SixLabors.ImageSharp.MetaData;
 using Xunit;
@@ -16,14 +15,22 @@ namespace SixLabors.ImageSharp.Tests
         [Fact]
         public void ConstructorImageFrameMetaData()
         {
-            ImageFrameMetaData metaData = new ImageFrameMetaData();
-            metaData.FrameDelay = 42;
-            metaData.DisposalMethod = DisposalMethod.RestoreToBackground;
+            const int frameDelay = 42;
+            const int colorTableLength = 128;
+            const GifDisposalMethod disposalMethod = GifDisposalMethod.RestoreToBackground;
 
-            ImageFrameMetaData clone = new ImageFrameMetaData(metaData);
+            var metaData = new ImageFrameMetaData();
+            GifFrameMetaData gifFrameMetaData = metaData.GetFormatMetaData(GifFormat.Instance);
+            gifFrameMetaData.FrameDelay = frameDelay;
+            gifFrameMetaData.ColorTableLength = colorTableLength;
+            gifFrameMetaData.DisposalMethod = disposalMethod;
 
-            Assert.Equal(42, clone.FrameDelay);
-            Assert.Equal(DisposalMethod.RestoreToBackground, clone.DisposalMethod);
+            var clone = new ImageFrameMetaData(metaData);
+            GifFrameMetaData cloneGifFrameMetaData = clone.GetFormatMetaData(GifFormat.Instance);
+
+            Assert.Equal(frameDelay, cloneGifFrameMetaData.FrameDelay);
+            Assert.Equal(colorTableLength, cloneGifFrameMetaData.ColorTableLength);
+            Assert.Equal(disposalMethod, cloneGifFrameMetaData.DisposalMethod);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs b/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs
index 8934ebc361..d681c90ba2 100644
--- a/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs
+++ b/tests/ImageSharp.Tests/MetaData/ImageMetaDataTests.cs
@@ -28,7 +28,6 @@ namespace SixLabors.ImageSharp.Tests
             metaData.HorizontalResolution = 4;
             metaData.VerticalResolution = 2;
             metaData.Properties.Add(imageProperty);
-            metaData.RepeatCount = 1;
 
             ImageMetaData clone = metaData.Clone();
 
@@ -36,7 +35,6 @@ namespace SixLabors.ImageSharp.Tests
             Assert.Equal(4, clone.HorizontalResolution);
             Assert.Equal(2, clone.VerticalResolution);
             Assert.Equal(imageProperty, clone.Properties[0]);
-            Assert.Equal(1, clone.RepeatCount);
         }
 
         [Fact]
diff --git a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs
index 8f574ca169..3c562057a8 100644
--- a/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs
+++ b/tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.Blender.cs
@@ -34,7 +34,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
             { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.AddSrcOver), PixelColorBlendingMode.Add },
             { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.SubtractSrcOver), PixelColorBlendingMode.Subtract },
             { new TestPixel<RgbaVector>(), typeof(DefaultPixelBlenders<RgbaVector>.MultiplySrcOver), PixelColorBlendingMode.Multiply },
-        };
+        };        
 
         [Theory]
         [MemberData(nameof(BlenderMappings))]
@@ -43,6 +43,62 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
         {
             PixelBlender<TPixel> blender = PixelOperations<TPixel>.Instance.GetPixelBlender(mode, PixelAlphaCompositionMode.SrcOver);
             Assert.IsType(type, blender);
+        }
+
+        public static TheoryData<Rgba32, Rgba32, float, PixelColorBlendingMode, Rgba32> ColorBlendingExpectedResults = new TheoryData<Rgba32, Rgba32, float, PixelColorBlendingMode, Rgba32>()
+        {
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Normal, Rgba32.MidnightBlue },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Screen, new Rgba32(0xFFEEE7FF) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.HardLight, new Rgba32(0xFFC62D32) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Overlay, new Rgba32(0xFFDDCEFF) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Darken, new Rgba32(0xFF701919) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Lighten, new Rgba32(0xFFE1E4FF) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Add, new Rgba32(0xFFFFFDFF) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Subtract, new Rgba32(0xFF71CBE6) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelColorBlendingMode.Multiply, new Rgba32(0xFF631619) },
+
+        };
+
+        [Theory]
+        [MemberData(nameof(ColorBlendingExpectedResults))]
+        public void TestColorBlendingModes(Rgba32 backdrop, Rgba32 source, float opacity, PixelColorBlendingMode mode, Rgba32 expectedResult)
+        {
+            PixelBlender<Rgba32> blender = PixelOperations<Rgba32>.Instance.GetPixelBlender(mode, PixelAlphaCompositionMode.SrcOver);
+
+            Rgba32 actualResult = blender.Blend(backdrop, source, opacity);
+
+            // var str = actualResult.Rgba.ToString("X8"); // used to extract expectedResults
+
+            Assert.Equal(actualResult.ToVector4(), expectedResult.ToVector4());
+        }
+
+        public static TheoryData<Rgba32, Rgba32, float, PixelAlphaCompositionMode, Rgba32> AlphaCompositionExpectedResults = new TheoryData<Rgba32, Rgba32, float, PixelAlphaCompositionMode, Rgba32>()
+        {
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.Clear, new Rgba32(0) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.Xor, new Rgba32(0) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.Dest, Rgba32.MistyRose },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.DestAtop, Rgba32.MistyRose },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.DestIn, Rgba32.MistyRose },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.DestOut, new Rgba32(0) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.DestOver, Rgba32.MistyRose },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.Src, Rgba32.MidnightBlue },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.SrcAtop, Rgba32.MidnightBlue },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.SrcIn, Rgba32.MidnightBlue },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.SrcOut, new Rgba32(0) },
+            { Rgba32.MistyRose, Rgba32.MidnightBlue, 1, PixelAlphaCompositionMode.SrcOver, Rgba32.MidnightBlue },
+        };
+
+        [Theory]
+        [MemberData(nameof(AlphaCompositionExpectedResults))]
+        public void TestAlphaCompositionModes(Rgba32 backdrop, Rgba32 source, float opacity, PixelAlphaCompositionMode mode, Rgba32 expectedResult)
+        {
+            PixelBlender<Rgba32> blender = PixelOperations<Rgba32>.Instance.GetPixelBlender(PixelColorBlendingMode.Normal, mode);
+
+            Rgba32 actualResult = blender.Blend(backdrop, source, opacity);
+
+            // var str = actualResult.Rgba.ToString("X8"); // used to extract expectedResults
+
+            Assert.Equal(actualResult.ToVector4(), expectedResult.ToVector4());
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/TestImages.cs b/tests/ImageSharp.Tests/TestImages.cs
index 1ee3f96757..acfad042eb 100644
--- a/tests/ImageSharp.Tests/TestImages.cs
+++ b/tests/ImageSharp.Tests/TestImages.cs
@@ -152,6 +152,9 @@ namespace SixLabors.ImageSharp.Tests
                 public const string BadRstProgressive518 = "Jpg/issues/Issue518-Bad-RST-Progressive.jpg";
                 public const string InvalidCast520 = "Jpg/issues/Issue520-InvalidCast.jpg";
                 public const string DhtHasWrongLength624 = "Jpg/issues/Issue624-DhtHasWrongLength-Progressive-N.jpg";
+                public const string ExifDecodeOutOfRange694 = "Jpg/issues/Issue694-Decode-Exif-OutOfRange.jpg";
+                public const string InvalidEOI695 = "Jpg/issues/Issue695-Invalid-EOI.jpg";
+                public const string ExifResizeOutOfRange696 = "Jpg/issues/Issue696-Resize-Exif-OutOfRange.jpg";
             }
 
             public static readonly string[] All = Baseline.All.Concat(Progressive.All).ToArray();
@@ -175,6 +178,7 @@ namespace SixLabors.ImageSharp.Tests
             public const string Bit8Inverted = "Bmp/test8-inverted.bmp";
             public const string Bit16 = "Bmp/test16.bmp";
             public const string Bit16Inverted = "Bmp/test16-inverted.bmp";
+            public const string Bit32Rgb = "Bmp/rgb32.bmp";
 
             public static readonly string[] All
             = {
@@ -201,6 +205,7 @@ namespace SixLabors.ImageSharp.Tests
             public const string Cheers = "Gif/cheers.gif";
             public const string Trans = "Gif/trans.gif";
             public const string Kumin = "Gif/kumin.gif";
+            public const string Leo = "Gif/leo.gif";
             public const string Ratio4x1 = "Gif/base_4x1.gif";
             public const string Ratio1x4 = "Gif/base_1x4.gif";
 
@@ -211,7 +216,7 @@ namespace SixLabors.ImageSharp.Tests
                 public const string BadDescriptorWidth = "Gif/issues/issue403_baddescriptorwidth.gif";
             }
 
-            public static readonly string[] All = { Rings, Giphy, Cheers, Trans, Kumin, Ratio4x1, Ratio1x4 };
+            public static readonly string[] All = { Rings, Giphy, Cheers, Trans, Kumin, Leo, Ratio4x1, Ratio1x4 };
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs
index 6475547a06..3ed696c472 100644
--- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/FileProvider.cs
@@ -55,9 +55,20 @@ namespace SixLabors.ImageSharp.Tests
 
                 public bool Equals(Key other)
                 {
-                    if (other is null) return false;
-                    if (ReferenceEquals(this, other)) return true;
-                    if (!this.commonValues.Equals(other.commonValues)) return false;
+                    if (other is null)
+                    {
+                        return false;
+                    }
+
+                    if (ReferenceEquals(this, other))
+                    {
+                        return true;
+                    }
+
+                    if (!this.commonValues.Equals(other.commonValues))
+                    {
+                        return false;
+                    }
 
                     if (this.decoderParameters.Count != other.decoderParameters.Count)
                     {
@@ -66,8 +77,7 @@ namespace SixLabors.ImageSharp.Tests
 
                     foreach (KeyValuePair<string, object> kv in this.decoderParameters)
                     {
-                        object otherVal;
-                        if (!other.decoderParameters.TryGetValue(kv.Key, out otherVal))
+                        if (!other.decoderParameters.TryGetValue(kv.Key, out object otherVal))
                         {
                             return false;
                         }
@@ -81,26 +91,29 @@ namespace SixLabors.ImageSharp.Tests
 
                 public override bool Equals(object obj)
                 {
-                    if (obj is null) return false;
-                    if (ReferenceEquals(this, obj)) return true;
-                    if (obj.GetType() != this.GetType()) return false;
+                    if (obj is null)
+                    {
+                        return false;
+                    }
+
+                    if (ReferenceEquals(this, obj))
+                    {
+                        return true;
+                    }
+
+                    if (obj.GetType() != this.GetType())
+                    {
+                        return false;
+                    }
+
                     return this.Equals((Key)obj);
                 }
 
-                public override int GetHashCode()
-                {
-                    return this.commonValues.GetHashCode();
-                }
+                public override int GetHashCode() => this.commonValues.GetHashCode();
 
-                public static bool operator ==(Key left, Key right)
-                {
-                    return Equals(left, right);
-                }
+                public static bool operator ==(Key left, Key right) => Equals(left, right);
 
-                public static bool operator !=(Key left, Key right)
-                {
-                    return !Equals(left, right);
-                }
+                public static bool operator !=(Key left, Key right) => !Equals(left, right);
             }
 
             private static readonly ConcurrentDictionary<Key, Image<TPixel>> cache = new ConcurrentDictionary<Key, Image<TPixel>>();
@@ -111,10 +124,7 @@ namespace SixLabors.ImageSharp.Tests
             {
             }
 
-            public FileProvider(string filePath)
-            {
-                this.FilePath = filePath;
-            }
+            public FileProvider(string filePath) => this.FilePath = filePath;
 
             /// <summary>
             /// Gets the file path relative to the "~/tests/images" folder
@@ -135,12 +145,12 @@ namespace SixLabors.ImageSharp.Tests
 
                 if (!TestEnvironment.Is64BitProcess)
                 {
-                    return LoadImage(decoder);
+                    return this.LoadImage(decoder);
                 }
 
                 var key = new Key(this.PixelType, this.FilePath, decoder);
 
-                Image<TPixel> cachedImage = cache.GetOrAdd(key, fn => { return LoadImage(decoder); });
+                Image<TPixel> cachedImage = cache.GetOrAdd(key, _ => this.LoadImage(decoder));
 
                 return cachedImage.Clone();
             }
diff --git a/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.Formats.cs b/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.Formats.cs
index 90c999f7cd..334b6552ac 100644
--- a/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.Formats.cs
+++ b/tests/ImageSharp.Tests/TestUtilities/TestEnvironment.Formats.cs
@@ -62,13 +62,13 @@ namespace SixLabors.ImageSharp.Tests
             IImageEncoder bmpEncoder = IsWindows ? (IImageEncoder)SystemDrawingReferenceEncoder.Bmp : new BmpEncoder();
 
             cfg.ConfigureCodecs(
-                ImageFormats.Png,
+                PngFormat.Instance,
                 MagickReferenceDecoder.Instance,
                 pngEncoder,
                 new PngImageFormatDetector());
 
             cfg.ConfigureCodecs(
-                ImageFormats.Bmp,
+                BmpFormat.Instance,
                 SystemDrawingReferenceDecoder.Instance,
                 bmpEncoder,
                 new BmpImageFormatDetector());
diff --git a/tests/Images/External b/tests/Images/External
index fcf311bf15..6abc3bc0ac 160000
--- a/tests/Images/External
+++ b/tests/Images/External
@@ -1 +1 @@
-Subproject commit fcf311bf15bea061e552e4cc357cafe2d4f4bd70
+Subproject commit 6abc3bc0ac253a24c9e88e68d7b7d853350a85da
diff --git a/tests/Images/Input/Bmp/rgb32.bmp b/tests/Images/Input/Bmp/rgb32.bmp
new file mode 100644
index 0000000000..bc4c47c9e5
--- /dev/null
+++ b/tests/Images/Input/Bmp/rgb32.bmp
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4c79cb8ffd2f1c096af27f9d82b5feaa0aa2cb049c791e0f6251de0435066e5
+size 32566
diff --git a/tests/Images/Input/Gif/leo.gif b/tests/Images/Input/Gif/leo.gif
new file mode 100644
index 0000000000..8cf7078380
--- /dev/null
+++ b/tests/Images/Input/Gif/leo.gif
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ee2bf4404165d534dcbfaebece0eee2a93999c47aec26850a7021b8c5d25f5c
+size 454544
diff --git a/tests/Images/Input/Jpg/issues/Issue694-Decode-Exif-OutOfRange.jpg b/tests/Images/Input/Jpg/issues/Issue694-Decode-Exif-OutOfRange.jpg
new file mode 100644
index 0000000000..b3a7ce356c
--- /dev/null
+++ b/tests/Images/Input/Jpg/issues/Issue694-Decode-Exif-OutOfRange.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b94a283fbe8927ab59745dd67d0b33e90a253e674e5fe4f0ad7594ff868cca2
+size 226421
diff --git a/tests/Images/Input/Jpg/issues/Issue695-Invalid-EOI.jpg b/tests/Images/Input/Jpg/issues/Issue695-Invalid-EOI.jpg
new file mode 100644
index 0000000000..4891779878
--- /dev/null
+++ b/tests/Images/Input/Jpg/issues/Issue695-Invalid-EOI.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e748a684c318b7424dd77b008fe92e179201d0a55106021b453a3fd2a22e9ab6
+size 4805575
diff --git a/tests/Images/Input/Jpg/issues/Issue696-Resize-Exif-OutOfRange.jpg b/tests/Images/Input/Jpg/issues/Issue696-Resize-Exif-OutOfRange.jpg
new file mode 100644
index 0000000000..38c5c8d59c
--- /dev/null
+++ b/tests/Images/Input/Jpg/issues/Issue696-Resize-Exif-OutOfRange.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb22005e1db0f6da8f49ca57979f8b9aa5db7111b717a53e817e24c04283ab43
+size 3196058