Optimize memory usage for resize pad operations

Author: JimBobSquarePants

src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeKernelMap.cs

@@ -101,7 +101,7 @@ protected virtual void Dispose(bool disposing)
         /// Returns a <see cref="ResizeKernel"/> for an index value between 0 and DestinationSize - 1.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        internal ref ResizeKernel GetKernel(int destIdx) => ref this.kernels[destIdx];
+        internal ref ResizeKernel GetKernel(nint destIdx) => ref this.kernels[destIdx];
 
         /// <summary>
         /// Computes the weights to apply at each pixel when resizing.

src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeProcessor{TPixel}.cs

@@ -209,21 +209,18 @@ private static void ApplyResizeFrameTransform(
 
             // To reintroduce parallel processing, we would launch multiple workers
             // for different row intervals of the image.
-            using (var worker = new ResizeWorker<TPixel>(
+            using var worker = new ResizeWorker<TPixel>(
                 configuration,
                 sourceRegion,
                 conversionModifiers,
                 horizontalKernelMap,
                 verticalKernelMap,
-                destination.Width,
                 interest,
-                destinationRectangle.Location))
-            {
-                worker.Initialize();
+                destinationRectangle.Location);
+            worker.Initialize();
 
-                var workingInterval = new RowInterval(interest.Top, interest.Bottom);
-                worker.FillDestinationPixels(workingInterval, destination.PixelBuffer);
-            }
+            var workingInterval = new RowInterval(interest.Top, interest.Bottom);
+            worker.FillDestinationPixels(workingInterval, destination.PixelBuffer);
         }
 
         private readonly struct NNRowOperation : IRowOperation

src/ImageSharp/Processing/Processors/Transforms/Resize/ResizeWorker.cs

@@ -39,8 +39,6 @@ internal sealed class ResizeWorker<TPixel> : IDisposable
 
         private readonly ResizeKernelMap verticalKernelMap;
 
-        private readonly int destWidth;
-
         private readonly Rectangle targetWorkingRect;
 
         private readonly Point targetOrigin;
@@ -57,7 +55,6 @@ public ResizeWorker(
             PixelConversionModifiers conversionModifiers,
             ResizeKernelMap horizontalKernelMap,
             ResizeKernelMap verticalKernelMap,
-            int destWidth,
             Rectangle targetWorkingRect,
             Point targetOrigin)
         {
@@ -67,7 +64,6 @@ public ResizeWorker(
             this.conversionModifiers = conversionModifiers;
             this.horizontalKernelMap = horizontalKernelMap;
             this.verticalKernelMap = verticalKernelMap;
-            this.destWidth = destWidth;
             this.targetWorkingRect = targetWorkingRect;
             this.targetOrigin = targetOrigin;
 
@@ -80,14 +76,14 @@ public ResizeWorker(
 
             int numberOfWindowBands = ResizeHelper.CalculateResizeWorkerHeightInWindowBands(
                 this.windowBandHeight,
-                destWidth,
+                targetWorkingRect.Width,
                 workingBufferLimitHintInBytes);
 
             this.workerHeight = Math.Min(this.sourceRectangle.Height, numberOfWindowBands * this.windowBandHeight);
 
             this.transposedFirstPassBuffer = configuration.MemoryAllocator.Allocate2D<Vector4>(
                 this.workerHeight,
-                destWidth,
+                targetWorkingRect.Width,
                 preferContiguosImageBuffers: true,
                 options: AllocationOptions.Clean);
 
@@ -137,9 +133,9 @@ public void FillDestinationPixels(RowInterval rowInterval, Buffer2D<TPixel> dest
 
                 ref Vector4 fpBase = ref transposedFirstPassBufferSpan[top];
 
-                for (int x = left; x < right; x++)
+                for (nint x = left; x < right; x++)
                 {
-                    ref Vector4 firstPassColumnBase = ref Unsafe.Add(ref fpBase, x * this.workerHeight);
+                    ref Vector4 firstPassColumnBase = ref Unsafe.Add(ref fpBase, (x - left) * this.workerHeight);
 
                     // Destination color components
                     Unsafe.Add(ref tempRowBase, x - left) = kernel.ConvolveCore(ref firstPassColumnBase);
@@ -174,6 +170,8 @@ private void CalculateFirstPassValues(RowInterval calculationInterval)
             Span<Vector4> tempRowSpan = this.tempRowBuffer.GetSpan();
             Span<Vector4> transposedFirstPassBufferSpan = this.transposedFirstPassBuffer.DangerousGetSingleSpan();
 
+            int left = this.targetWorkingRect.Left;
+            int right = this.targetWorkingRect.Right;
             for (int y = calculationInterval.Min; y < calculationInterval.Max; y++)
             {
                 Span<TPixel> sourceRow = this.source.DangerousGetRowSpan(y);
@@ -188,13 +186,13 @@ private void CalculateFirstPassValues(RowInterval calculationInterval)
                 // Span<Vector4> firstPassSpan = transposedFirstPassBufferSpan.Slice(y - this.currentWindow.Min);
                 ref Vector4 firstPassBaseRef = ref transposedFirstPassBufferSpan[y - this.currentWindow.Min];
 
-                for (int x = this.targetWorkingRect.Left; x < this.targetWorkingRect.Right; x++)
+                for (nint x = left; x < right; x++)
                 {
                     ResizeKernel kernel = this.horizontalKernelMap.GetKernel(x - this.targetOrigin.X);
 
                     // optimization for:
                     // firstPassSpan[x * this.workerHeight] = kernel.Convolve(tempRowSpan);
-                    Unsafe.Add(ref firstPassBaseRef, x * this.workerHeight) = kernel.Convolve(tempRowSpan);
+                    Unsafe.Add(ref firstPassBaseRef, (x - left) * this.workerHeight) = kernel.Convolve(tempRowSpan);
                 }
             }
         }