Normalize MemoryAllocator references.

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -109,7 +109,7 @@ namespace SixLabors.ImageSharp.Advanced
         private static void AotCompileOctreeQuantizer<TPixel>()
             where TPixel : struct, IPixel<TPixel>
         {
-            using (var test = new OctreeFrameQuantizer<TPixel>(new OctreeQuantizer(false)))
+            using (var test = new OctreeFrameQuantizer<TPixel>(Configuration.Default, new OctreeQuantizer(false)))
             {
                 test.AotGetPalette();
             }
@@ -122,7 +122,7 @@ namespace SixLabors.ImageSharp.Advanced
         private static void AotCompileWuQuantizer<TPixel>()
             where TPixel : struct, IPixel<TPixel>
         {
-            using (var test = new WuFrameQuantizer<TPixel>(Configuration.Default.MemoryAllocator, new WuQuantizer(false)))
+            using (var test = new WuFrameQuantizer<TPixel>(Configuration.Default, new WuQuantizer(false)))
             {
                 test.QuantizeFrame(new ImageFrame<TPixel>(Configuration.Default, 1, 1));
                 test.AotGetPalette();

src/ImageSharp/Configuration.cs

@@ -16,7 +16,7 @@ using SixLabors.ImageSharp.Processing;
 namespace SixLabors.ImageSharp
 {
     /// <summary>
-    /// Provides configuration code which allows altering default behaviour or extending the library.
+    /// Provides configuration which allows altering default behaviour or extending the library.
     /// </summary>
     public sealed class Configuration
     {

src/ImageSharp/Formats/Gif/GifEncoder.cs

@@ -28,7 +28,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         public void Encode<TPixel>(Image<TPixel> image, Stream stream)
             where TPixel : struct, IPixel<TPixel>
         {
-            var encoder = new GifEncoderCore(image.GetConfiguration().MemoryAllocator, this);
+            var encoder = new GifEncoderCore(image.GetConfiguration(), this);
             encoder.Encode(image, stream);
         }
     }

src/ImageSharp/Formats/Gif/GifEncoderCore.cs

@@ -53,11 +53,12 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Initializes a new instance of the <see cref="GifEncoderCore"/> class.
         /// </summary>
-        /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/> to use for buffer allocations.</param>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
         /// <param name="options">The options for the encoder.</param>
-        public GifEncoderCore(MemoryAllocator memoryAllocator, IGifEncoderOptions options)
+        public GifEncoderCore(Configuration configuration, IGifEncoderOptions options)
         {
-            this.memoryAllocator = memoryAllocator;
+            this.configuration = configuration;
+            this.memoryAllocator = configuration.MemoryAllocator;
             this.quantizer = options.Quantizer;
             this.colorTableMode = options.ColorTableMode;
         }
@@ -74,16 +75,14 @@ namespace SixLabors.ImageSharp.Formats.Gif
             Guard.NotNull(image, nameof(image));
             Guard.NotNull(stream, nameof(stream));
 
-            this.configuration = image.GetConfiguration();
-
             ImageMetadata metadata = image.Metadata;
             GifMetadata gifMetadata = metadata.GetGifMetadata();
-            this.colorTableMode = this.colorTableMode ?? gifMetadata.ColorTableMode;
+            this.colorTableMode ??= gifMetadata.ColorTableMode;
             bool useGlobalTable = this.colorTableMode == GifColorTableMode.Global;
 
             // Quantize the image returning a palette.
             IQuantizedFrame<TPixel> quantized;
-            using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
+            using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration))
             {
                 quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame);
             }
@@ -146,7 +145,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
                 else
                 {
                     using (IFrameQuantizer<TPixel> paletteFrameQuantizer =
-                        new PaletteFrameQuantizer<TPixel>(this.quantizer.Diffuser, quantized.Palette))
+                        new PaletteFrameQuantizer<TPixel>(this.configuration, this.quantizer.Diffuser, quantized.Palette))
                     {
                         using (IQuantizedFrame<TPixel> paletteQuantized = paletteFrameQuantizer.QuantizeFrame(frame))
                         {
@@ -172,14 +171,14 @@ namespace SixLabors.ImageSharp.Formats.Gif
                     if (previousFrame != null && previousMeta.ColorTableLength != frameMetadata.ColorTableLength
                                               && frameMetadata.ColorTableLength > 0)
                     {
-                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration(), frameMetadata.ColorTableLength))
+                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration, frameMetadata.ColorTableLength))
                         {
                             quantized = frameQuantizer.QuantizeFrame(frame);
                         }
                     }
                     else
                     {
-                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(image.GetConfiguration()))
+                        using (IFrameQuantizer<TPixel> frameQuantizer = this.quantizer.CreateFrameQuantizer<TPixel>(this.configuration))
                         {
                             quantized = frameQuantizer.QuantizeFrame(frame);
                         }
@@ -202,9 +201,7 @@ namespace SixLabors.ImageSharp.Formats.Gif
         /// <summary>
         /// Returns the index of the most transparent color in the palette.
         /// </summary>
-        /// <param name="quantized">
-        /// The quantized.
-        /// </param>
+        /// <param name="quantized">The quantized frame.</param>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <returns>
         /// The <see cref="int"/>.

src/ImageSharp/ImageFrame.cs

@@ -31,17 +31,11 @@ namespace SixLabors.ImageSharp
             Guard.NotNull(metadata, nameof(metadata));
 
             this.configuration = configuration ?? Configuration.Default;
-            this.MemoryAllocator = configuration.MemoryAllocator;
             this.Width = width;
             this.Height = height;
             this.Metadata = metadata;
         }
 
-        /// <summary>
-        /// Gets the <see cref="MemoryAllocator" /> to use for buffer allocations.
-        /// </summary>
-        public MemoryAllocator MemoryAllocator { get; }
-
         /// <summary>
         /// Gets the width.
         /// </summary>

src/ImageSharp/ImageFrame{TPixel}.cs

@@ -59,7 +59,7 @@ namespace SixLabors.ImageSharp
             Guard.MustBeGreaterThan(width, 0, nameof(width));
             Guard.MustBeGreaterThan(height, 0, nameof(height));
 
-            this.PixelBuffer = this.MemoryAllocator.Allocate2D<TPixel>(width, height, AllocationOptions.Clean);
+            this.PixelBuffer = this.GetConfiguration().MemoryAllocator.Allocate2D<TPixel>(width, height, AllocationOptions.Clean);
         }
 
         /// <summary>
@@ -88,7 +88,7 @@ namespace SixLabors.ImageSharp
             Guard.MustBeGreaterThan(width, 0, nameof(width));
             Guard.MustBeGreaterThan(height, 0, nameof(height));
 
-            this.PixelBuffer = this.MemoryAllocator.Allocate2D<TPixel>(width, height);
+            this.PixelBuffer = this.GetConfiguration().MemoryAllocator.Allocate2D<TPixel>(width, height);
             this.Clear(backgroundColor);
         }
 
@@ -132,7 +132,7 @@ namespace SixLabors.ImageSharp
             Guard.NotNull(configuration, nameof(configuration));
             Guard.NotNull(source, nameof(source));
 
-            this.PixelBuffer = this.MemoryAllocator.Allocate2D<TPixel>(source.PixelBuffer.Width, source.PixelBuffer.Height);
+            this.PixelBuffer = this.GetConfiguration().MemoryAllocator.Allocate2D<TPixel>(source.PixelBuffer.Width, source.PixelBuffer.Height);
             source.PixelBuffer.GetSpan().CopyTo(this.PixelBuffer.GetSpan());
         }
 

src/ImageSharp/Processing/Processors/Overlays/BackgroundColorProcessor{TPixel}.cs

@@ -65,9 +65,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
 
             var workingRect = Rectangle.FromLTRB(minX, minY, maxX, maxY);
             Configuration configuration = this.Configuration;
+            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
 
-            using (IMemoryOwner<TPixel> colors = source.MemoryAllocator.Allocate<TPixel>(width))
-            using (IMemoryOwner<float> amount = source.MemoryAllocator.Allocate<float>(width))
+            using (IMemoryOwner<TPixel> colors = memoryAllocator.Allocate<TPixel>(width))
+            using (IMemoryOwner<float> amount = memoryAllocator.Allocate<float>(width))
             {
                 // Be careful! Do not capture colorSpan & amountSpan in the lambda below!
                 Span<TPixel> colorSpan = colors.GetSpan();

src/ImageSharp/Processing/Processors/Overlays/GlowProcessor{TPixel}.cs

@@ -77,8 +77,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
 
             float blendPercentage = this.definition.GraphicsOptions.BlendPercentage;
             Configuration configuration = this.Configuration;
+            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
 
-            using (IMemoryOwner<TPixel> rowColors = source.MemoryAllocator.Allocate<TPixel>(width))
+            using (IMemoryOwner<TPixel> rowColors = memoryAllocator.Allocate<TPixel>(width))
             {
                 rowColors.GetSpan().Fill(glowColor);
 

src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor{TPixel}.cs

@@ -81,8 +81,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
             var workingRect = Rectangle.FromLTRB(minX, minY, maxX, maxY);
             float blendPercentage = this.definition.GraphicsOptions.BlendPercentage;
             Configuration configuration = this.Configuration;
+            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
 
-            using (IMemoryOwner<TPixel> rowColors = source.MemoryAllocator.Allocate<TPixel>(width))
+            using (IMemoryOwner<TPixel> rowColors = memoryAllocator.Allocate<TPixel>(width))
             {
                 rowColors.GetSpan().Fill(vignetteColor);
 

src/ImageSharp/Processing/Processors/Quantization/FrameQuantizer{TPixel}.cs

@@ -7,7 +7,7 @@ using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors.Dithering;
 
@@ -40,6 +40,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="FrameQuantizer{TPixel}"/> class.
         /// </summary>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
         /// <param name="quantizer">The quantizer</param>
         /// <param name="singlePass">
         /// If true, the quantization process only needs to loop through the source pixels once
@@ -49,10 +50,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// only call the <see cref="SecondPass(ImageFrame{TPixel}, Span{byte}, ReadOnlySpan{TPixel},  int, int)"/> method.
         /// If two passes are required, the code will also call <see cref="FirstPass(ImageFrame{TPixel}, int, int)"/>.
         /// </remarks>
-        protected FrameQuantizer(IQuantizer quantizer, bool singlePass)
+        protected FrameQuantizer(Configuration configuration, IQuantizer quantizer, bool singlePass)
         {
             Guard.NotNull(quantizer, nameof(quantizer));
 
+            this.Configuration = configuration;
             this.Diffuser = quantizer.Diffuser;
             this.Dither = this.Diffuser != null;
             this.singlePass = singlePass;
@@ -61,6 +63,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="FrameQuantizer{TPixel}"/> class.
         /// </summary>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
         /// <param name="diffuser">The diffuser</param>
         /// <param name="singlePass">
         /// If true, the quantization process only needs to loop through the source pixels once
@@ -70,8 +73,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// only call the <see cref="SecondPass(ImageFrame{TPixel}, Span{byte}, ReadOnlySpan{TPixel},  int, int)"/> method.
         /// If two passes are required, the code will also call <see cref="FirstPass(ImageFrame{TPixel}, int, int)"/>.
         /// </remarks>
-        protected FrameQuantizer(IErrorDiffuser diffuser, bool singlePass)
+        protected FrameQuantizer(Configuration configuration, IErrorDiffuser diffuser, bool singlePass)
         {
+            this.Configuration = configuration;
             this.Diffuser = diffuser;
             this.Dither = this.Diffuser != null;
             this.singlePass = singlePass;
@@ -83,6 +87,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <inheritdoc />
         public bool Dither { get; }
 
+        /// <summary>
+        /// Gets the configuration which allows altering default behaviour or extending the library.
+        /// </summary>
+        protected Configuration Configuration { get; }
+
         /// <inheritdoc/>
         public void Dispose()
         {
@@ -109,15 +118,16 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
 
             // Collect the palette. Required before the second pass runs.
             ReadOnlyMemory<TPixel> palette = this.GetPalette();
-            Configuration configuration = image.GetConfiguration();
-            this.paletteVector = configuration.MemoryAllocator.Allocate<Vector4>(palette.Length);
+            MemoryAllocator memoryAllocator = this.Configuration.MemoryAllocator;
+
+            this.paletteVector = memoryAllocator.Allocate<Vector4>(palette.Length);
             PixelOperations<TPixel>.Instance.ToVector4(
-                configuration,
+                this.Configuration,
                 palette.Span,
                 this.paletteVector.Memory.Span,
                 PixelConversionModifiers.Scale);
 
-            var quantizedFrame = new QuantizedFrame<TPixel>(image.MemoryAllocator, width, height, palette);
+            var quantizedFrame = new QuantizedFrame<TPixel>(memoryAllocator, width, height, palette);
 
             Span<byte> pixelSpan = quantizedFrame.GetWritablePixelSpan();
             if (this.Dither)

src/ImageSharp/Processing/Processors/Quantization/OctreeFrameQuantizer{TPixel}.cs

@@ -37,27 +37,29 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeFrameQuantizer{TPixel}"/> class.
         /// </summary>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
         /// <param name="quantizer">The octree quantizer</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)
-            : this(quantizer, quantizer.MaxColors)
+        public OctreeFrameQuantizer(Configuration configuration, OctreeQuantizer quantizer)
+            : this(configuration, quantizer, quantizer.MaxColors)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeFrameQuantizer{TPixel}"/> class.
         /// </summary>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
         /// <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)
+        public OctreeFrameQuantizer(Configuration configuration, OctreeQuantizer quantizer, int maxColors)
+            : base(configuration, quantizer, false)
         {
             this.colors = maxColors;
             this.octree = new Octree(ImageMaths.GetBitsNeededForColorDepth(this.colors).Clamp(1, 8));

src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.PixelFormats;
@@ -83,16 +83,16 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <inheritdoc />
         public IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(Configuration configuration)
             where TPixel : struct, IPixel<TPixel>
-            => new OctreeFrameQuantizer<TPixel>(this);
+            => new OctreeFrameQuantizer<TPixel>(configuration, this);
 
         /// <inheritdoc/>
         public IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(Configuration configuration, int maxColors)
             where TPixel : struct, IPixel<TPixel>
         {
             maxColors = maxColors.Clamp(QuantizerConstants.MinColors, QuantizerConstants.MaxColors);
-            return new OctreeFrameQuantizer<TPixel>(this, maxColors);
+            return new OctreeFrameQuantizer<TPixel>(configuration, this, maxColors);
         }
 
         private static IErrorDiffuser GetDiffuser(bool dither) => dither ? KnownDiffusers.FloydSteinberg : null;
     }
-}
+}

src/ImageSharp/Processing/Processors/Quantization/PaletteFrameQuantizer{TPixel}.cs

@@ -26,10 +26,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="PaletteFrameQuantizer{TPixel}"/> class.
         /// </summary>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
         /// <param name="diffuser">The palette quantizer.</param>
         /// <param name="colors">An array of all colors in the palette.</param>
-        public PaletteFrameQuantizer(IErrorDiffuser diffuser, ReadOnlyMemory<TPixel> colors)
-            : base(diffuser, true) => this.palette = colors;
+        public PaletteFrameQuantizer(Configuration configuration, IErrorDiffuser diffuser, ReadOnlyMemory<TPixel> colors)
+            : base(configuration, diffuser, true) => this.palette = colors;
 
         /// <inheritdoc/>
         protected override void SecondPass(

src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs

@@ -61,7 +61,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         {
             var palette = new TPixel[this.Palette.Length];
             Color.ToPixel(configuration, this.Palette.Span, palette.AsSpan());
-            return new PaletteFrameQuantizer<TPixel>(this.Diffuser, palette);
+            return new PaletteFrameQuantizer<TPixel>(configuration, this.Diffuser, palette);
         }
 
         /// <inheritdoc/>
@@ -73,7 +73,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
 
             var palette = new TPixel[max];
             Color.ToPixel(configuration, this.Palette.Span.Slice(0, max), palette.AsSpan());
-            return new PaletteFrameQuantizer<TPixel>(this.Diffuser, palette);
+            return new PaletteFrameQuantizer<TPixel>(configuration, this.Diffuser, palette);
         }
 
         private static IErrorDiffuser GetDiffuser(bool dither) => dither ? KnownDiffusers.FloydSteinberg : null;

src/ImageSharp/Processing/Processors/Quantization/WuFrameQuantizer{TPixel}.cs

@@ -37,6 +37,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     internal sealed class WuFrameQuantizer<TPixel> : FrameQuantizer<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
+        private readonly MemoryAllocator memoryAllocator;
+
         // The following two variables determine the amount of bits to preserve when calculating the histogram.
         // Reducing the value of these numbers the granularity of the color maps produced, making it much faster
         // and using much less memory but potentially less accurate. Current results are very good though!
@@ -121,39 +123,39 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// <summary>
         /// Initializes a new instance of the <see cref="WuFrameQuantizer{TPixel}"/> class.
         /// </summary>
-        /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/>.</param>
-        /// <param name="quantizer">The wu quantizer</param>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+        /// <param name="quantizer">The Wu quantizer</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(MemoryAllocator memoryAllocator, WuQuantizer quantizer)
-            : this(memoryAllocator, quantizer, quantizer.MaxColors)
+        public WuFrameQuantizer(Configuration configuration, WuQuantizer quantizer)
+            : this(configuration, quantizer, quantizer.MaxColors)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="WuFrameQuantizer{TPixel}"/> class.
         /// </summary>
-        /// <param name="memoryAllocator">The <see cref="MemoryAllocator"/>.</param>
-        /// <param name="quantizer">The wu quantizer.</param>
+        /// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
+        /// <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(MemoryAllocator memoryAllocator, WuQuantizer quantizer, int maxColors)
-            : base(quantizer, false)
+        public WuFrameQuantizer(Configuration configuration, WuQuantizer quantizer, int maxColors)
+            : base(configuration, quantizer, false)
         {
-            Guard.NotNull(memoryAllocator, nameof(memoryAllocator));
+            this.memoryAllocator = this.Configuration.MemoryAllocator;
 
-            this.vwt = memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
-            this.vmr = memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
-            this.vmg = memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
-            this.vmb = memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
-            this.vma = memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
-            this.m2 = memoryAllocator.Allocate<double>(TableLength, AllocationOptions.Clean);
-            this.tag = memoryAllocator.Allocate<byte>(TableLength, AllocationOptions.Clean);
+            this.vwt = this.memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
+            this.vmr = this.memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
+            this.vmg = this.memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
+            this.vmb = this.memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
+            this.vma = this.memoryAllocator.Allocate<long>(TableLength, AllocationOptions.Clean);
+            this.m2 = this.memoryAllocator.Allocate<double>(TableLength, AllocationOptions.Clean);
+            this.tag = this.memoryAllocator.Allocate<byte>(TableLength, AllocationOptions.Clean);
 
             this.colors = maxColors;
         }
@@ -229,7 +231,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         protected override void FirstPass(ImageFrame<TPixel> source, int width, int height)
         {
             this.Build3DHistogram(source, width, height);
-            this.Get3DMoments(source.MemoryAllocator);
+            this.Get3DMoments(this.memoryAllocator);
             this.BuildCube();
         }
 
@@ -465,7 +467,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
 
             // Build up the 3-D color histogram
             // Loop through each row
-            using (IMemoryOwner<Rgba32> rgbaBuffer = source.MemoryAllocator.Allocate<Rgba32>(source.Width))
+            using (IMemoryOwner<Rgba32> rgbaBuffer = this.memoryAllocator.Allocate<Rgba32>(source.Width))
             {
                 for (int y = 0; y < height; y++)
                 {
@@ -840,7 +842,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         private void BuildCube()
         {
             this.colorCube = new Box[this.colors];
-            var vv = new double[this.colors];
+            Span<double> vv = stackalloc double[this.colors];
 
             ref Box cube = ref this.colorCube[0];
             cube.RMin = cube.GMin = cube.BMin = cube.AMin = 0;

src/ImageSharp/Processing/Processors/Quantization/WuQuantizer.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.PixelFormats;
@@ -68,13 +68,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         /// </summary>
         public int MaxColors { get; }
 
-        /// <param name="configuration"></param>
         /// <inheritdoc />
         public IFrameQuantizer<TPixel> CreateFrameQuantizer<TPixel>(Configuration configuration)
             where TPixel : struct, IPixel<TPixel>
         {
             Guard.NotNull(configuration, nameof(configuration));
-            return new WuFrameQuantizer<TPixel>(configuration.MemoryAllocator, this);
+            return new WuFrameQuantizer<TPixel>(configuration, this);
         }
 
         /// <inheritdoc/>
@@ -83,9 +82,9 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
         {
             Guard.NotNull(configuration, nameof(configuration));
             maxColors = maxColors.Clamp(QuantizerConstants.MinColors, QuantizerConstants.MaxColors);
-            return new WuFrameQuantizer<TPixel>(configuration.MemoryAllocator, this, maxColors);
+            return new WuFrameQuantizer<TPixel>(configuration, this, maxColors);
         }
 
         private static IErrorDiffuser GetDiffuser(bool dither) => dither ? KnownDiffusers.FloydSteinberg : null;
     }
-}
+}

tests/ImageSharp.Tests/TestUtilities/ImageComparison/ExactImageComparer.cs

@@ -26,7 +26,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison
             var bBuffer = new Rgba64[width];
 
             var differences = new List<PixelDifference>();
-            Configuration configuration = expected.Configuration;
+            Configuration configuration = expected.GetConfiguration();
 
             for (int y = 0; y < actual.Height; y++)
             {

tests/ImageSharp.Tests/TestUtilities/ImageComparison/TolerantImageComparer.cs

@@ -72,7 +72,7 @@ namespace SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison
             float totalDifference = 0F;
 
             var differences = new List<PixelDifference>();
-            Configuration configuration = expected.Configuration;
+            Configuration configuration = expected.GetConfiguration();
 
             for (int y = 0; y < actual.Height; y++)
             {