Preserve alpha in separate loop

src/ImageSharp/Processing/Processors/Convolution/MedianRowOperation{TPixel}.cs

@@ -59,34 +59,58 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
             var xChannel = channelBuffer.Slice(0, kernelCount);
             var yChannel = channelBuffer.Slice(this.yChannelStart, kernelCount);
             var zChannel = channelBuffer.Slice(this.zChannelStart, kernelCount);
-            var wChannel = channelBuffer.Slice(this.wChannelStart, kernelCount);
 
             var xOffsets = this.map.GetColumnOffsetSpan();
             var yOffsets = this.map.GetRowOffsetSpan();
             var baseXOffsetIndex = 0;
             var baseYOffsetIndex = (y - this.bounds.Top) * this.kernelSize;
 
-            for (var x = boundsLeft; x < boundsRight; x++)
+            if (this.preserveAlpha)
             {
-                var index = 0;
+                for (var x = boundsLeft; x < boundsRight; x++)
-                for (var w = 0; w < this.kernelSize; w++)
                 {
-                    var j = yOffsets[baseYOffsetIndex + w];
+                    var index = 0;
-                    var row = this.sourcePixels.DangerousGetRowSpan(j);
+                    for (var w = 0; w < this.kernelSize; w++)
-                    for (var z = 0; z < this.kernelSize; z++)
                     {
-                        var k = xOffsets[baseXOffsetIndex + z];
+                        var j = yOffsets[baseYOffsetIndex + w];
-                        var pixel = row[k];
+                        var row = this.sourcePixels.DangerousGetRowSpan(j);
-                        kernelBuffer[index + z] = pixel.ToVector4();
+                        for (var z = 0; z < this.kernelSize; z++)
+                        {
+                            var k = xOffsets[baseXOffsetIndex + z];
+                            var pixel = row[k];
+                            kernelBuffer[index + z] = pixel.ToVector4();
+                        }
+
+                        index += this.kernelSize;
                     }
 
-                    index += this.kernelSize;
+                    targetBuffer[x - boundsLeft] = this.FindMedian3(kernelBuffer, xChannel, yChannel, zChannel, kernelCount);
+                    baseXOffsetIndex += this.kernelSize;
                 }
+            }
+            else
+            {
+                var wChannel = channelBuffer.Slice(this.wChannelStart, kernelCount);
+                for (var x = boundsLeft; x < boundsRight; x++)
+                {
+                    var index = 0;
+                    for (var w = 0; w < this.kernelSize; w++)
+                    {
+                        var j = yOffsets[baseYOffsetIndex + w];
+                        var row = this.sourcePixels.DangerousGetRowSpan(j);
+                        for (var z = 0; z < this.kernelSize; z++)
+                        {
+                            var k = xOffsets[baseXOffsetIndex + z];
+                            var pixel = row[k];
+                            kernelBuffer[index + z] = pixel.ToVector4();
+                        }
+
+                        index += this.kernelSize;
+                    }
 
-                targetBuffer[x - boundsLeft] = this.preserveAlpha ?
+                    targetBuffer[x - boundsLeft] = this.FindMedian4(kernelBuffer, xChannel, yChannel, zChannel, wChannel, kernelCount);
-                    this.FindMedian3(kernelBuffer, xChannel, yChannel, zChannel, kernelCount) :
+                    baseXOffsetIndex += this.kernelSize;
-                    this.FindMedian4(kernelBuffer, xChannel, yChannel, zChannel, wChannel, kernelCount);
+                }
-                baseXOffsetIndex += this.kernelSize;
             }
 
             Span<TPixel> targetRowSpan = this.targetPixels.DangerousGetRowSpan(y).Slice(boundsLeft, boundsWidth);