diff --git a/src/ImageSharp.Drawing/Processing/Extensions/DrawImageExtensions.cs b/src/ImageSharp.Drawing/Processing/Extensions/DrawImageExtensions.cs
index 58459ebc5d..981cf1bef4 100644
--- a/src/ImageSharp.Drawing/Processing/Extensions/DrawImageExtensions.cs
+++ b/src/ImageSharp.Drawing/Processing/Extensions/DrawImageExtensions.cs
@@ -15,98 +15,126 @@ namespace SixLabors.ImageSharp.Processing
         /// <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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            float opacity) =>
+            source.ApplyProcessor(
+                new DrawImageProcessor(
+                    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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            PixelColorBlendingMode colorBlending,
+            float opacity) =>
+            source.ApplyProcessor(
+                new DrawImageProcessor(
+                    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{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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            PixelColorBlendingMode colorBlending,
+            PixelAlphaCompositionMode alphaComposition,
+            float opacity) =>
+            source.ApplyProcessor(new DrawImageProcessor(image, Point.Empty, colorBlending, alphaComposition, 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="options">The options, including the blending type and blending amount.</param>
         /// <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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            GraphicsOptions options) =>
+            source.ApplyProcessor(
+                new DrawImageProcessor(
+                    image,
+                    Point.Empty,
+                    options.ColorBlendingMode,
+                    options.AlphaCompositionMode,
+                    options.BlendPercentage));
 
         /// <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="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{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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            Point location,
+            float opacity) =>
+            source.ApplyProcessor(
+                new DrawImageProcessor(
+                    image,
+                    location,
+                    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="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{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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            Point location,
+            PixelColorBlendingMode colorBlending,
+            float opacity) =>
+            source.ApplyProcessor(
+                new DrawImageProcessor(
+                    image,
+                    location,
+                    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="location">The location to draw the blended image.</param>
@@ -114,24 +142,34 @@ namespace SixLabors.ImageSharp.Processing
         /// <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, 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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            Point location,
+            PixelColorBlendingMode colorBlending,
+            PixelAlphaCompositionMode alphaComposition,
+            float opacity) =>
+            source.ApplyProcessor(new DrawImageProcessor(image, location, colorBlending, alphaComposition, 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="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{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));
+        public static IImageProcessingContext DrawImage(
+            this IImageProcessingContext source,
+            Image image,
+            Point location,
+            GraphicsOptions options) =>
+            source.ApplyProcessor(
+                new DrawImageProcessor(
+                    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 6c03537eb3..0fbef9afea 100644
--- a/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs
+++ b/src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawImageProcessor.cs
@@ -13,14 +13,90 @@ using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Drawing
 {
+    public class DrawImageProcessor : IImageProcessor
+    {
+        public DrawImageProcessor(
+            Image image,
+            Point location,
+            PixelColorBlendingMode colorBlendingMode,
+            PixelAlphaCompositionMode alphaCompositionMode,
+            float opacity)
+        {
+            this.Image = image;
+            this.Location = location;
+            this.ColorBlendingMode = colorBlendingMode;
+            this.AlphaCompositionMode = alphaCompositionMode;
+            this.Opacity = opacity;
+        }
+
+        /// <summary>
+        /// Gets the image to blend
+        /// </summary>
+        public Image Image { get; }
+
+        /// <summary>
+        /// Gets the location to draw the blended image
+        /// </summary>
+        public Point Location { get; }
+        
+        /// <summary>
+        /// Gets the blending mode to use when drawing the image.
+        /// </summary>
+        public PixelColorBlendingMode ColorBlendingMode { get; }
+        
+        /// <summary>
+        /// Gets the Alpha blending mode to use when drawing the image.
+        /// </summary>
+        public PixelAlphaCompositionMode AlphaCompositionMode { get; }
+        
+        /// <summary>
+        /// Gets the opacity of the image to blend
+        /// </summary>
+        public float Opacity { get; }
+
+        /// <inheritdoc />
+        public IImageProcessor<TPixelBg> CreatePixelSpecificProcessor<TPixelBg>()
+            where TPixelBg : struct, IPixel<TPixelBg>
+        {
+            var visitor = new ProcessorFactoryVisitor<TPixelBg>(this);
+            this.Image.AcceptVisitor(visitor);
+            return visitor.Result;
+        }
+
+        private class ProcessorFactoryVisitor<TPixelBg> : IImageVisitor
+            where TPixelBg : struct, IPixel<TPixelBg>
+        {
+            private readonly DrawImageProcessor definition;
+
+            public ProcessorFactoryVisitor(DrawImageProcessor definition)
+            {
+                this.definition = definition;
+            }
+
+            public IImageProcessor<TPixelBg> Result { get; private set; }
+            
+            public void Visit<TPixelFg>(Image<TPixelFg> image)
+                where TPixelFg : struct, IPixel<TPixelFg>
+            {
+                this.Result = new DrawImageProcessor<TPixelBg, TPixelFg>(
+                    image,
+                    this.definition.Location,
+                    this.definition.ColorBlendingMode,
+                    this.definition.AlphaCompositionMode,
+                    this.definition.Opacity
+                    );
+            }
+        }
+    }
+
     /// <summary>
     /// Combines two images together by blending the pixels.
     /// </summary>
-    /// <typeparam name="TPixelDst">The pixel format of destination image.</typeparam>
-    /// <typeparam name="TPixelSrc">The pixel format of source image.</typeparam>
-    internal class DrawImageProcessor<TPixelDst, TPixelSrc> : ImageProcessor<TPixelDst>
-        where TPixelDst : struct, IPixel<TPixelDst>
-        where TPixelSrc : struct, IPixel<TPixelSrc>
+    /// <typeparam name="TPixelBg">The pixel format of destination image.</typeparam>
+    /// <typeparam name="TPixelFg">The pixel format of source image.</typeparam>
+    internal class DrawImageProcessor<TPixelBg, TPixelFg> : ImageProcessor<TPixelBg>
+        where TPixelBg : struct, IPixel<TPixelBg>
+        where TPixelFg : struct, IPixel<TPixelFg>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="DrawImageProcessor{TPixelDst, TPixelSrc}"/> class.
@@ -30,20 +106,25 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
         /// <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<TPixelSrc> image, Point location, PixelColorBlendingMode colorBlendingMode, PixelAlphaCompositionMode alphaCompositionMode, float opacity)
+        public DrawImageProcessor(
+            Image<TPixelFg> 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<TPixelDst>.Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
+            this.Blender = PixelOperations<TPixelBg>.Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
             this.Location = location;
         }
 
         /// <summary>
         /// Gets the image to blend
         /// </summary>
-        public Image<TPixelSrc> Image { get; }
+        public Image<TPixelFg> Image { get; }
 
         /// <summary>
         /// Gets the opacity of the image to blend
@@ -53,7 +134,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
         /// <summary>
         /// Gets the pixel blender
         /// </summary>
-        public PixelBlender<TPixelDst> Blender { get; }
+        public PixelBlender<TPixelBg> Blender { get; }
 
         /// <summary>
         /// Gets the location to draw the blended image
@@ -61,10 +142,13 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
         public Point Location { get; }
 
         /// <inheritdoc/>
-        protected override void OnFrameApply(ImageFrame<TPixelDst> source, Rectangle sourceRectangle, Configuration configuration)
+        protected override void OnFrameApply(
+            ImageFrame<TPixelBg> source,
+            Rectangle sourceRectangle,
+            Configuration configuration)
         {
-            Image<TPixelSrc> targetImage = this.Image;
-            PixelBlender<TPixelDst> blender = this.Blender;
+            Image<TPixelFg> targetImage = this.Image;
+            PixelBlender<TPixelBg> blender = this.Blender;
             int locationY = this.Location.Y;
 
             // Align start/end positions.
@@ -84,7 +168,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
             // not a valid operation because rectangle does not overlap with this image.
             if (workingRect.Width <= 0 || workingRect.Height <= 0)
             {
-                throw new ImageProcessingException("Cannot draw image because the source image does not overlap the target image.");
+                throw new ImageProcessingException(
+                    "Cannot draw image because the source image does not overlap the target image.");
             }
 
             ParallelHelper.IterateRows(
@@ -94,10 +179,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Drawing
                     {
                         for (int y = rows.Min; y < rows.Max; y++)
                         {
-                            Span<TPixelDst> background = source.GetPixelRowSpan(y).Slice(minX, width);
-                            Span<TPixelSrc> foreground =
+                            Span<TPixelBg> background = source.GetPixelRowSpan(y).Slice(minX, width);
+                            Span<TPixelFg> foreground =
                                 targetImage.GetPixelRowSpan(y - locationY).Slice(targetX, width);
-                            blender.Blend<TPixelSrc>(configuration, background, background, foreground, this.Opacity);
+                            blender.Blend<TPixelFg>(configuration, background, background, foreground, this.Opacity);
                         }
                     });
         }