diff --git a/src/ImageSharp/Color/Color.cs b/src/ImageSharp/Color/Color.cs
index 99a271bcf7..13af25f6c7 100644
--- a/src/ImageSharp/Color/Color.cs
+++ b/src/ImageSharp/Color/Color.cs
@@ -286,13 +286,10 @@ public readonly partial struct Color : IEquatable<Color>
     /// Bulk converts a span of <see cref="Color"/> to a span of a specified <typeparamref name="TPixel"/> type.
     /// </summary>
     /// <typeparam name="TPixel">The pixel type to convert to.</typeparam>
-    /// <param name="configuration">The configuration.</param>
     /// <param name="source">The source color span.</param>
     /// <param name="destination">The destination pixel span.</param>
     [MethodImpl(InliningOptions.ShortMethod)]
-#pragma warning disable RCS1163 // Unused parameter.
-    public static void ToPixel<TPixel>(Configuration configuration, ReadOnlySpan<Color> source, Span<TPixel> destination)
-#pragma warning restore RCS1163 // Unused parameter.
+    public static void ToPixel<TPixel>(ReadOnlySpan<Color> source, Span<TPixel> destination)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         // TODO: Investigate bulk operations utilizing configuration parameter here.
diff --git a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
index fd0497d9ac..cb1c7a2511 100644
--- a/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpDecoderCore.cs
@@ -1,9 +1,9 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
-#nullable disable
 
 using System.Buffers;
 using System.Buffers.Binary;
+using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using SixLabors.ImageSharp.Common.Helpers;
@@ -58,20 +58,15 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// </summary>
     private const int RleDelta = 0x02;
 
-    /// <summary>
-    /// The stream to decode from.
-    /// </summary>
-    private BufferedReadStream stream;
-
     /// <summary>
     /// The metadata.
     /// </summary>
-    private ImageMetadata metadata;
+    private ImageMetadata? metadata;
 
     /// <summary>
     /// The bitmap specific metadata.
     /// </summary>
-    private BmpMetadata bmpMetadata;
+    private BmpMetadata? bmpMetadata;
 
     /// <summary>
     /// The file header containing general information.
@@ -126,7 +121,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     public Image<TPixel> Decode<TPixel>(BufferedReadStream stream, CancellationToken cancellationToken)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        Image<TPixel> image = null;
+        Image<TPixel>? image = null;
         try
         {
             int bytesPerColorMapEntry = this.ReadImageHeaders(stream, out bool inverted, out byte[] palette);
@@ -142,24 +137,25 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                     {
                         if (this.bmpMetadata.InfoHeaderType == BmpInfoHeaderType.WinVersion3)
                         {
-                            this.ReadRgb32Slow(pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
+                            this.ReadRgb32Slow(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
                         }
                         else
                         {
-                            this.ReadRgb32Fast(pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
+                            this.ReadRgb32Fast(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
                         }
                     }
                     else if (this.infoHeader.BitsPerPixel == 24)
                     {
-                        this.ReadRgb24(pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
+                        this.ReadRgb24(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
                     }
                     else if (this.infoHeader.BitsPerPixel == 16)
                     {
-                        this.ReadRgb16(pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
+                        this.ReadRgb16(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
                     }
                     else if (this.infoHeader.BitsPerPixel <= 8)
                     {
                         this.ReadRgbPalette(
+                            stream,
                             pixels,
                             palette,
                             this.infoHeader.Width,
@@ -172,19 +168,19 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                     break;
 
                 case BmpCompression.RLE24:
-                    this.ReadRle24(pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
+                    this.ReadRle24(stream, pixels, this.infoHeader.Width, this.infoHeader.Height, inverted);
 
                     break;
 
                 case BmpCompression.RLE8:
                 case BmpCompression.RLE4:
-                    this.ReadRle(this.infoHeader.Compression, pixels, palette, this.infoHeader.Width, this.infoHeader.Height, inverted);
+                    this.ReadRle(stream, this.infoHeader.Compression, pixels, palette, this.infoHeader.Width, this.infoHeader.Height, inverted);
 
                     break;
 
                 case BmpCompression.BitFields:
                 case BmpCompression.BI_ALPHABITFIELDS:
-                    this.ReadBitFields(pixels, inverted);
+                    this.ReadBitFields(stream, pixels, inverted);
 
                     break;
 
@@ -250,14 +246,16 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// which will be used to determine which bits belong to that channel.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The output pixel buffer containing the decoded image.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadBitFields<TPixel>(Buffer2D<TPixel> pixels, bool inverted)
+    private void ReadBitFields<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         if (this.infoHeader.BitsPerPixel == 16)
         {
             this.ReadRgb16(
+                stream,
                 pixels,
                 this.infoHeader.Width,
                 this.infoHeader.Height,
@@ -269,6 +267,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         else
         {
             this.ReadRgb32BitFields(
+                stream,
                 pixels,
                 this.infoHeader.Width,
                 this.infoHeader.Height,
@@ -282,17 +281,17 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
     /// <summary>
     /// Looks up color values and builds the image from de-compressed RLE8 or RLE4 data.
-    /// Compressed RLE8 stream is uncompressed by <see cref="UncompressRle8(int, Span{byte}, Span{bool}, Span{bool})"/>
-    /// Compressed RLE4 stream is uncompressed by <see cref="UncompressRle4(int, Span{byte}, Span{bool}, Span{bool})"/>
+    /// Compressed RLE4 stream is uncompressed by <see cref="UncompressRle4(BufferedReadStream, int, Span{byte}, Span{bool}, Span{bool})"/>
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="compression">The compression type. Either RLE4 or RLE8.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="colors">The <see cref="T:byte[]"/> containing the colors.</param>
     /// <param name="width">The width of the bitmap.</param>
     /// <param name="height">The height of the bitmap.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadRle<TPixel>(BmpCompression compression, Buffer2D<TPixel> pixels, byte[] colors, int width, int height, bool inverted)
+    private void ReadRle<TPixel>(BufferedReadStream stream, BmpCompression compression, Buffer2D<TPixel> pixels, byte[] colors, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         TPixel color = default;
@@ -305,11 +304,11 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             Span<byte> bufferSpan = buffer.Memory.Span;
             if (compression is BmpCompression.RLE8)
             {
-                this.UncompressRle8(width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
+                this.UncompressRle8(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
             }
             else
             {
-                this.UncompressRle4(width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
+                this.UncompressRle4(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
             }
 
             for (int y = 0; y < height; y++)
@@ -368,11 +367,12 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// Looks up color values and builds the image from de-compressed RLE24.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="width">The width of the bitmap.</param>
     /// <param name="height">The height of the bitmap.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadRle24<TPixel>(Buffer2D<TPixel> pixels, int width, int height, bool inverted)
+    private void ReadRle24<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         TPixel color = default;
@@ -384,7 +384,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             Span<bool> undefinedPixelsSpan = undefinedPixels.Memory.Span;
             Span<byte> bufferSpan = buffer.GetSpan();
 
-            this.UncompressRle24(width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
+            this.UncompressRle24(stream, width, bufferSpan, undefinedPixelsSpan, rowsWithUndefinedPixelsSpan);
             for (int y = 0; y < height; y++)
             {
                 int newY = Invert(y, height, inverted);
@@ -446,18 +446,19 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <br/>If first byte is 0, the second byte may have special meaning.
     /// <br/>Otherwise, the first byte is the length of the run and second byte contains two color indexes.
     /// </remarks>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="w">The width of the bitmap.</param>
     /// <param name="buffer">Buffer for uncompressed data.</param>
     /// <param name="undefinedPixels">Keeps track over skipped and therefore undefined pixels.</param>
     /// <param name="rowsWithUndefinedPixels">Keeps track of rows, which have undefined pixels.</param>
-    private void UncompressRle4(int w, Span<byte> buffer, Span<bool> undefinedPixels, Span<bool> rowsWithUndefinedPixels)
+    private void UncompressRle4(BufferedReadStream stream, int w, Span<byte> buffer, Span<bool> undefinedPixels, Span<bool> rowsWithUndefinedPixels)
     {
         Span<byte> cmd = stackalloc byte[2];
         int count = 0;
 
         while (count < buffer.Length)
         {
-            if (this.stream.Read(cmd, 0, cmd.Length) != 2)
+            if (stream.Read(cmd, 0, cmd.Length) != 2)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Failed to read 2 bytes from the stream while uncompressing RLE4 bitmap.");
             }
@@ -478,8 +479,8 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         break;
 
                     case RleDelta:
-                        int dx = this.stream.ReadByte();
-                        int dy = this.stream.ReadByte();
+                        int dx = stream.ReadByte();
+                        int dy = stream.ReadByte();
                         count += RleSkipDelta(count, w, dx, dy, undefinedPixels, rowsWithUndefinedPixels);
 
                         break;
@@ -492,7 +493,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
                         byte[] run = new byte[bytesToRead];
 
-                        this.stream.Read(run, 0, run.Length);
+                        stream.Read(run, 0, run.Length);
 
                         int idx = 0;
                         for (int i = 0; i < max; i++)
@@ -512,7 +513,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         // Absolute mode data is aligned to two-byte word-boundary.
                         int padding = bytesToRead & 1;
 
-                        this.stream.Skip(padding);
+                        stream.Skip(padding);
 
                         break;
                 }
@@ -551,18 +552,19 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <br/>If first byte is 0, the second byte may have special meaning.
     /// <br/>Otherwise, the first byte is the length of the run and second byte is the color for the run.
     /// </remarks>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="w">The width of the bitmap.</param>
     /// <param name="buffer">Buffer for uncompressed data.</param>
     /// <param name="undefinedPixels">Keeps track of skipped and therefore undefined pixels.</param>
     /// <param name="rowsWithUndefinedPixels">Keeps track of rows, which have undefined pixels.</param>
-    private void UncompressRle8(int w, Span<byte> buffer, Span<bool> undefinedPixels, Span<bool> rowsWithUndefinedPixels)
+    private void UncompressRle8(BufferedReadStream stream, int w, Span<byte> buffer, Span<bool> undefinedPixels, Span<bool> rowsWithUndefinedPixels)
     {
         Span<byte> cmd = stackalloc byte[2];
         int count = 0;
 
         while (count < buffer.Length)
         {
-            if (this.stream.Read(cmd, 0, cmd.Length) != 2)
+            if (stream.Read(cmd, 0, cmd.Length) != 2)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Failed to read 2 bytes from stream while uncompressing RLE8 bitmap.");
             }
@@ -583,8 +585,8 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         break;
 
                     case RleDelta:
-                        int dx = this.stream.ReadByte();
-                        int dy = this.stream.ReadByte();
+                        int dx = stream.ReadByte();
+                        int dy = stream.ReadByte();
                         count += RleSkipDelta(count, w, dx, dy, undefinedPixels, rowsWithUndefinedPixels);
 
                         break;
@@ -596,7 +598,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
                         byte[] run = new byte[length];
 
-                        this.stream.Read(run, 0, run.Length);
+                        stream.Read(run, 0, run.Length);
 
                         run.AsSpan().CopyTo(buffer[count..]);
 
@@ -605,7 +607,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         // Absolute mode data is aligned to two-byte word-boundary.
                         int padding = length & 1;
 
-                        this.stream.Skip(padding);
+                        stream.Skip(padding);
 
                         break;
                 }
@@ -630,18 +632,19 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <br/>If first byte is 0, the second byte may have special meaning.
     /// <br/>Otherwise, the first byte is the length of the run and following three bytes are the color for the run.
     /// </remarks>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="w">The width of the bitmap.</param>
     /// <param name="buffer">Buffer for uncompressed data.</param>
     /// <param name="undefinedPixels">Keeps track of skipped and therefore undefined pixels.</param>
     /// <param name="rowsWithUndefinedPixels">Keeps track of rows, which have undefined pixels.</param>
-    private void UncompressRle24(int w, Span<byte> buffer, Span<bool> undefinedPixels, Span<bool> rowsWithUndefinedPixels)
+    private void UncompressRle24(BufferedReadStream stream, int w, Span<byte> buffer, Span<bool> undefinedPixels, Span<bool> rowsWithUndefinedPixels)
     {
         Span<byte> cmd = stackalloc byte[2];
         int uncompressedPixels = 0;
 
         while (uncompressedPixels < buffer.Length)
         {
-            if (this.stream.Read(cmd, 0, cmd.Length) != 2)
+            if (stream.Read(cmd, 0, cmd.Length) != 2)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Failed to read 2 bytes from stream while uncompressing RLE24 bitmap.");
             }
@@ -662,8 +665,8 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         break;
 
                     case RleDelta:
-                        int dx = this.stream.ReadByte();
-                        int dy = this.stream.ReadByte();
+                        int dx = stream.ReadByte();
+                        int dy = stream.ReadByte();
                         uncompressedPixels += RleSkipDelta(uncompressedPixels, w, dx, dy, undefinedPixels, rowsWithUndefinedPixels);
 
                         break;
@@ -675,7 +678,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
                         byte[] run = new byte[length * 3];
 
-                        this.stream.Read(run, 0, run.Length);
+                        stream.Read(run, 0, run.Length);
 
                         run.AsSpan().CopyTo(buffer[(uncompressedPixels * 3)..]);
 
@@ -684,7 +687,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
                         // Absolute mode data is aligned to two-byte word-boundary.
                         int padding = run.Length & 1;
 
-                        this.stream.Skip(padding);
+                        stream.Skip(padding);
 
                         break;
                 }
@@ -693,8 +696,8 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             {
                 int max = uncompressedPixels + cmd[0];
                 byte blueIdx = cmd[1];
-                byte greenIdx = (byte)this.stream.ReadByte();
-                byte redIdx = (byte)this.stream.ReadByte();
+                byte greenIdx = (byte)stream.ReadByte();
+                byte redIdx = (byte)stream.ReadByte();
 
                 int bufferIdx = uncompressedPixels * 3;
                 for (; uncompressedPixels < max; uncompressedPixels++)
@@ -800,6 +803,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// Reads the color palette from the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="colors">The <see cref="T:byte[]"/> containing the colors.</param>
     /// <param name="width">The width of the bitmap.</param>
@@ -808,7 +812,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <param name="bytesPerColorMapEntry">Usually 4 bytes, but in case of Windows 2.x bitmaps or OS/2 1.x bitmaps
     /// the bytes per color palette entry's can be 3 bytes instead of 4.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadRgbPalette<TPixel>(Buffer2D<TPixel> pixels, byte[] colors, int width, int height, int bitsPerPixel, int bytesPerColorMapEntry, bool inverted)
+    private void ReadRgbPalette<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, byte[] colors, int width, int height, int bitsPerPixel, int bytesPerColorMapEntry, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         // Pixels per byte (bits per pixel).
@@ -833,7 +837,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         for (int y = 0; y < height; y++)
         {
             int newY = Invert(y, height, inverted);
-            if (this.stream.Read(rowSpan) == 0)
+            if (stream.Read(rowSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -861,6 +865,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// Reads the 16 bit color palette from the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="width">The width of the bitmap.</param>
     /// <param name="height">The height of the bitmap.</param>
@@ -868,7 +873,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <param name="redMask">The bitmask for the red channel.</param>
     /// <param name="greenMask">The bitmask for the green channel.</param>
     /// <param name="blueMask">The bitmask for the blue channel.</param>
-    private void ReadRgb16<TPixel>(Buffer2D<TPixel> pixels, int width, int height, bool inverted, int redMask = DefaultRgb16RMask, int greenMask = DefaultRgb16GMask, int blueMask = DefaultRgb16BMask)
+    private void ReadRgb16<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted, int redMask = DefaultRgb16RMask, int greenMask = DefaultRgb16GMask, int blueMask = DefaultRgb16BMask)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int padding = CalculatePadding(width, 2);
@@ -889,7 +894,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
         for (int y = 0; y < height; y++)
         {
-            if (this.stream.Read(bufferSpan) == 0)
+            if (stream.Read(bufferSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -935,11 +940,12 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// Reads the 24 bit color palette from the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="width">The width of the bitmap.</param>
     /// <param name="height">The height of the bitmap.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadRgb24<TPixel>(Buffer2D<TPixel> pixels, int width, int height, bool inverted)
+    private void ReadRgb24<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int padding = CalculatePadding(width, 3);
@@ -948,7 +954,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
         for (int y = 0; y < height; y++)
         {
-            if (this.stream.Read(rowSpan) == 0)
+            if (stream.Read(rowSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -967,11 +973,12 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// Reads the 32 bit color palette from the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="width">The width of the bitmap.</param>
     /// <param name="height">The height of the bitmap.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadRgb32Fast<TPixel>(Buffer2D<TPixel> pixels, int width, int height, bool inverted)
+    private void ReadRgb32Fast<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int padding = CalculatePadding(width, 4);
@@ -980,7 +987,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
         for (int y = 0; y < height; y++)
         {
-            if (this.stream.Read(rowSpan) == 0)
+            if (stream.Read(rowSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -1000,11 +1007,12 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// This is a special case only used for 32bpp WinBMPv3 files, which could be in either BGR0 or BGRA format.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> to assign the palette to.</param>
     /// <param name="width">The width of the bitmap.</param>
     /// <param name="height">The height of the bitmap.</param>
     /// <param name="inverted">Whether the bitmap is inverted.</param>
-    private void ReadRgb32Slow<TPixel>(Buffer2D<TPixel> pixels, int width, int height, bool inverted)
+    private void ReadRgb32Slow<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int padding = CalculatePadding(width, 4);
@@ -1012,7 +1020,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         using IMemoryOwner<Bgra32> bgraRow = this.memoryAllocator.Allocate<Bgra32>(width);
         Span<byte> rowSpan = row.GetSpan();
         Span<Bgra32> bgraRowSpan = bgraRow.GetSpan();
-        long currentPosition = this.stream.Position;
+        long currentPosition = stream.Position;
         bool hasAlpha = false;
 
         // Loop though the rows checking each pixel. We start by assuming it's
@@ -1020,7 +1028,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         // actually a BGRA image, and change tactics accordingly.
         for (int y = 0; y < height; y++)
         {
-            if (this.stream.Read(rowSpan) == 0)
+            if (stream.Read(rowSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -1049,14 +1057,14 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         }
 
         // Reset our stream for a second pass.
-        this.stream.Position = currentPosition;
+        stream.Position = currentPosition;
 
         // Process the pixels in bulk taking the raw alpha component value.
         if (hasAlpha)
         {
             for (int y = 0; y < height; y++)
             {
-                if (this.stream.Read(rowSpan) == 0)
+                if (stream.Read(rowSpan) == 0)
                 {
                     BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
                 }
@@ -1077,7 +1085,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         // Slow path. We need to set each alpha component value to fully opaque.
         for (int y = 0; y < height; y++)
         {
-            if (this.stream.Read(rowSpan) == 0)
+            if (stream.Read(rowSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -1105,6 +1113,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// Decode an 32 Bit Bitmap containing a bitmask for each color channel.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
     /// <param name="pixels">The output pixel buffer containing the decoded image.</param>
     /// <param name="width">The width of the image.</param>
     /// <param name="height">The height of the image.</param>
@@ -1113,7 +1122,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <param name="greenMask">The bitmask for the green channel.</param>
     /// <param name="blueMask">The bitmask for the blue channel.</param>
     /// <param name="alphaMask">The bitmask for the alpha channel.</param>
-    private void ReadRgb32BitFields<TPixel>(Buffer2D<TPixel> pixels, int width, int height, bool inverted, int redMask, int greenMask, int blueMask, int alphaMask)
+    private void ReadRgb32BitFields<TPixel>(BufferedReadStream stream, Buffer2D<TPixel> pixels, int width, int height, bool inverted, int redMask, int greenMask, int blueMask, int alphaMask)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         TPixel color = default;
@@ -1142,7 +1151,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
         for (int y = 0; y < height; y++)
         {
-            if (this.stream.Read(bufferSpan) == 0)
+            if (stream.Read(bufferSpan) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for a pixel row!");
             }
@@ -1228,10 +1237,13 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <summary>
     /// Reads the <see cref="BmpInfoHeader"/> from the stream.
     /// </summary>
-    private void ReadInfoHeader()
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
+    [MemberNotNull(nameof(metadata))]
+    [MemberNotNull(nameof(bmpMetadata))]
+    private void ReadInfoHeader(BufferedReadStream stream)
     {
         Span<byte> buffer = stackalloc byte[BmpInfoHeader.MaxHeaderSize];
-        long infoHeaderStart = this.stream.Position;
+        long infoHeaderStart = stream.Position;
 
         // Resolution is stored in PPM.
         this.metadata = new ImageMetadata
@@ -1240,7 +1252,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         };
 
         // Read the header size.
-        this.stream.Read(buffer, 0, BmpInfoHeader.HeaderSizeSize);
+        stream.Read(buffer, 0, BmpInfoHeader.HeaderSizeSize);
 
         int headerSize = BinaryPrimitives.ReadInt32LittleEndian(buffer);
         if (headerSize is < BmpInfoHeader.CoreSize or > BmpInfoHeader.MaxHeaderSize)
@@ -1249,7 +1261,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
         }
 
         // Read the rest of the header.
-        this.stream.Read(buffer, BmpInfoHeader.HeaderSizeSize, headerSize - BmpInfoHeader.HeaderSizeSize);
+        stream.Read(buffer, BmpInfoHeader.HeaderSizeSize, headerSize - BmpInfoHeader.HeaderSizeSize);
 
         BmpInfoHeaderType infoHeaderType = BmpInfoHeaderType.WinVersion2;
         if (headerSize == BmpInfoHeader.CoreSize)
@@ -1275,7 +1287,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             if (this.infoHeader.Compression == BmpCompression.BitFields)
             {
                 byte[] bitfieldsBuffer = new byte[12];
-                this.stream.Read(bitfieldsBuffer, 0, 12);
+                stream.Read(bitfieldsBuffer, 0, 12);
                 Span<byte> data = bitfieldsBuffer.AsSpan();
                 this.infoHeader.RedMask = BinaryPrimitives.ReadInt32LittleEndian(data[..4]);
                 this.infoHeader.GreenMask = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(4, 4));
@@ -1284,7 +1296,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             else if (this.infoHeader.Compression == BmpCompression.BI_ALPHABITFIELDS)
             {
                 byte[] bitfieldsBuffer = new byte[16];
-                this.stream.Read(bitfieldsBuffer, 0, 16);
+                stream.Read(bitfieldsBuffer, 0, 16);
                 Span<byte> data = bitfieldsBuffer.AsSpan();
                 this.infoHeader.RedMask = BinaryPrimitives.ReadInt32LittleEndian(data[..4]);
                 this.infoHeader.GreenMask = BinaryPrimitives.ReadInt32LittleEndian(data.Slice(4, 4));
@@ -1324,12 +1336,12 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             if (this.infoHeader.ProfileData != 0 && this.infoHeader.ProfileSize != 0)
             {
                 // Read color profile.
-                long streamPosition = this.stream.Position;
+                long streamPosition = stream.Position;
                 byte[] iccProfileData = new byte[this.infoHeader.ProfileSize];
-                this.stream.Position = infoHeaderStart + this.infoHeader.ProfileData;
-                this.stream.Read(iccProfileData);
+                stream.Position = infoHeaderStart + this.infoHeader.ProfileData;
+                stream.Read(iccProfileData);
                 this.metadata.IccProfile = new IccProfile(iccProfileData);
-                this.stream.Position = streamPosition;
+                stream.Position = streamPosition;
             }
         }
         else
@@ -1358,10 +1370,11 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <summary>
     /// Reads the <see cref="BmpFileHeader"/> from the stream.
     /// </summary>
-    private void ReadFileHeader()
+    /// <param name="stream">The <see cref="BufferedReadStream"/> containing image data.</param>
+    private void ReadFileHeader(BufferedReadStream stream)
     {
         Span<byte> buffer = stackalloc byte[BmpFileHeader.Size];
-        this.stream.Read(buffer, 0, BmpFileHeader.Size);
+        stream.Read(buffer, 0, BmpFileHeader.Size);
 
         short fileTypeMarker = BinaryPrimitives.ReadInt16LittleEndian(buffer);
         switch (fileTypeMarker)
@@ -1375,7 +1388,7 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
                 // Because we only decode the first bitmap in the array, the array header will be ignored.
                 // The bitmap file header of the first image follows the array header.
-                this.stream.Read(buffer, 0, BmpFileHeader.Size);
+                stream.Read(buffer, 0, BmpFileHeader.Size);
                 this.fileHeader = BmpFileHeader.Parse(buffer);
                 if (this.fileHeader.Type != BmpConstants.TypeMarkers.Bitmap)
                 {
@@ -1398,12 +1411,12 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
     /// <param name="palette">The color palette.</param>
     /// <returns>Bytes per color palette entry. Usually 4 bytes, but in case of Windows 2.x bitmaps or OS/2 1.x bitmaps
     /// the bytes per color palette entry's can be 3 bytes instead of 4.</returns>
+    [MemberNotNull(nameof(metadata))]
+    [MemberNotNull(nameof(bmpMetadata))]
     private int ReadImageHeaders(BufferedReadStream stream, out bool inverted, out byte[] palette)
     {
-        this.stream = stream;
-
-        this.ReadFileHeader();
-        this.ReadInfoHeader();
+        this.ReadFileHeader(stream);
+        this.ReadInfoHeader(stream);
 
         // see http://www.drdobbs.com/architecture-and-design/the-bmp-file-format-part-1/184409517
         // If the height is negative, then this is a Windows bitmap whose origin
@@ -1451,13 +1464,13 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
             colorMapSizeBytes = this.infoHeader.ClrUsed * bytesPerColorMapEntry;
         }
 
-        palette = null;
+        palette = Array.Empty<byte>();
 
         if (colorMapSizeBytes > 0)
         {
             // Usually the color palette is 1024 byte (256 colors * 4), but the documentation does not mention a size limit.
             // Make sure, that we will not read pass the bitmap offset (starting position of image data).
-            if ((this.stream.Position + colorMapSizeBytes) > this.fileHeader.Offset)
+            if ((stream.Position + colorMapSizeBytes) > this.fileHeader.Offset)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException(
                     $"Reading the color map would read beyond the bitmap offset. Either the color map size of '{colorMapSizeBytes}' is invalid or the bitmap offset.");
@@ -1465,21 +1478,21 @@ internal sealed class BmpDecoderCore : IImageDecoderInternals
 
             palette = new byte[colorMapSizeBytes];
 
-            if (this.stream.Read(palette, 0, colorMapSizeBytes) == 0)
+            if (stream.Read(palette, 0, colorMapSizeBytes) == 0)
             {
                 BmpThrowHelper.ThrowInvalidImageContentException("Could not read enough data for the palette!");
             }
         }
 
-        int skipAmount = this.fileHeader.Offset - (int)this.stream.Position;
-        if ((skipAmount + (int)this.stream.Position) > this.stream.Length)
+        int skipAmount = this.fileHeader.Offset - (int)stream.Position;
+        if ((skipAmount + (int)stream.Position) > stream.Length)
         {
             BmpThrowHelper.ThrowInvalidImageContentException("Invalid file header offset found. Offset is greater than the stream length.");
         }
 
         if (skipAmount > 0)
         {
-            this.stream.Skip(skipAmount);
+            stream.Skip(skipAmount);
         }
 
         return bytesPerColorMapEntry;
diff --git a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
index 9f1e856393..f30369d19b 100644
--- a/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
+++ b/src/ImageSharp/Formats/Bmp/BmpEncoderCore.cs
@@ -1,6 +1,5 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
-#nullable disable
 
 using System.Buffers;
 using System.Buffers.Binary;
@@ -69,11 +68,6 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// </summary>
     private readonly MemoryAllocator memoryAllocator;
 
-    /// <summary>
-    /// The global configuration.
-    /// </summary>
-    private Configuration configuration;
-
     /// <summary>
     /// The color depth, in number of bits per pixel.
     /// </summary>
@@ -124,7 +118,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
         Guard.NotNull(image, nameof(image));
         Guard.NotNull(stream, nameof(stream));
 
-        this.configuration = image.GetConfiguration();
+        Configuration configuration = image.GetConfiguration();
         ImageMetadata metadata = image.Metadata;
         BmpMetadata bmpMetadata = metadata.GetBmpMetadata();
         this.bitsPerPixel ??= bmpMetadata.BitsPerPixel;
@@ -142,7 +136,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
             _ => 0
         };
 
-        byte[] iccProfileData = null;
+        byte[]? iccProfileData = null;
         int iccProfileSize = 0;
         if (metadata.IccProfile != null)
         {
@@ -165,7 +159,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
 
         WriteBitmapFileHeader(stream, infoHeaderSize, colorPaletteSize, iccProfileSize, infoHeader, buffer);
         this.WriteBitmapInfoHeader(stream, infoHeader, buffer, infoHeaderSize);
-        this.WriteImage(stream, image);
+        this.WriteImage(configuration, stream, image);
         WriteColorProfile(stream, iccProfileData, buffer);
 
         stream.Flush();
@@ -182,7 +176,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// <param name="metadata">The metadata.</param>
     /// <param name="iccProfileData">The icc profile data.</param>
     /// <returns>The bitmap information header.</returns>
-    private BmpInfoHeader CreateBmpInfoHeader(int width, int height, int infoHeaderSize, short bpp, int bytesPerLine, ImageMetadata metadata, byte[] iccProfileData)
+    private BmpInfoHeader CreateBmpInfoHeader(int width, int height, int infoHeaderSize, short bpp, int bytesPerLine, ImageMetadata metadata, byte[]? iccProfileData)
     {
         int hResolution = 0;
         int vResolution = 0;
@@ -234,7 +228,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
             infoHeader.Compression = BmpCompression.BitFields;
         }
 
-        if (this.infoHeaderType is BmpInfoHeaderType.WinVersion5 && metadata.IccProfile != null)
+        if (this.infoHeaderType is BmpInfoHeaderType.WinVersion5 && iccProfileData != null)
         {
             infoHeader.ProfileSize = iccProfileData.Length;
             infoHeader.CsType = BmpColorSpace.PROFILE_EMBEDDED;
@@ -250,7 +244,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// <param name="stream">The stream to write to.</param>
     /// <param name="iccProfileData">The color profile data.</param>
     /// <param name="buffer">The buffer.</param>
-    private static void WriteColorProfile(Stream stream, byte[] iccProfileData, Span<byte> buffer)
+    private static void WriteColorProfile(Stream stream, byte[]? iccProfileData, Span<byte> buffer)
     {
         if (iccProfileData != null)
         {
@@ -313,42 +307,43 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes the pixel data to the binary stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image">
     /// The <see cref="ImageFrame{TPixel}"/> containing pixel data.
     /// </param>
-    private void WriteImage<TPixel>(Stream stream, Image<TPixel> image)
+    private void WriteImage<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         Buffer2D<TPixel> pixels = image.Frames.RootFrame.PixelBuffer;
         switch (this.bitsPerPixel)
         {
             case BmpBitsPerPixel.Pixel32:
-                this.Write32BitPixelData(stream, pixels);
+                this.Write32BitPixelData(configuration, stream, pixels);
                 break;
 
             case BmpBitsPerPixel.Pixel24:
-                this.Write24BitPixelData(stream, pixels);
+                this.Write24BitPixelData(configuration, stream, pixels);
                 break;
 
             case BmpBitsPerPixel.Pixel16:
-                this.Write16BitPixelData(stream, pixels);
+                this.Write16BitPixelData(configuration, stream, pixels);
                 break;
 
             case BmpBitsPerPixel.Pixel8:
-                this.Write8BitPixelData(stream, image);
+                this.Write8BitPixelData(configuration, stream, image);
                 break;
 
             case BmpBitsPerPixel.Pixel4:
-                this.Write4BitPixelData(stream, image);
+                this.Write4BitPixelData(configuration, stream, image);
                 break;
 
             case BmpBitsPerPixel.Pixel2:
-                this.Write2BitPixelData(stream, image);
+                this.Write2BitPixelData(configuration, stream, image);
                 break;
 
             case BmpBitsPerPixel.Pixel1:
-                this.Write1BitPixelData(stream, image);
+                this.Write1BitPixelData(configuration, stream, image);
                 break;
         }
     }
@@ -360,9 +355,10 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 32-bit data with a color palette to the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-    private void Write32BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
+    private void Write32BitPixelData<TPixel>(Configuration configuration, Stream stream, Buffer2D<TPixel> pixels)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         using IMemoryOwner<byte> row = this.AllocateRow(pixels.Width, 4);
@@ -372,7 +368,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
         {
             Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
             PixelOperations<TPixel>.Instance.ToBgra32Bytes(
-                this.configuration,
+                configuration,
                 pixelSpan,
                 rowSpan,
                 pixelSpan.Length);
@@ -384,9 +380,10 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 24-bit pixel data with a color palette to the stream.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-    private void Write24BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
+    private void Write24BitPixelData<TPixel>(Configuration configuration, Stream stream, Buffer2D<TPixel> pixels)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int width = pixels.Width;
@@ -398,7 +395,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
         {
             Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
             PixelOperations<TPixel>.Instance.ToBgr24Bytes(
-                this.configuration,
+                configuration,
                 pixelSpan,
                 row.Slice(0, rowBytesWithoutPadding),
                 width);
@@ -410,10 +407,11 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 16-bit pixel data with a color palette to the stream.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="pixels">The <see cref="Buffer2D{TPixel}"/> containing pixel data.</param>
-    private void Write16BitPixelData<TPixel>(Stream stream, Buffer2D<TPixel> pixels)
-        where TPixel : unmanaged, IPixel<TPixel>
+    private void Write16BitPixelData<TPixel>(Configuration configuration, Stream stream, Buffer2D<TPixel> pixels)
+    where TPixel : unmanaged, IPixel<TPixel>
     {
         int width = pixels.Width;
         int rowBytesWithoutPadding = width * 2;
@@ -425,7 +423,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
             Span<TPixel> pixelSpan = pixels.DangerousGetRowSpan(y);
 
             PixelOperations<TPixel>.Instance.ToBgra5551Bytes(
-                this.configuration,
+                configuration,
                 pixelSpan,
                 row.Slice(0, rowBytesWithoutPadding),
                 pixelSpan.Length);
@@ -438,9 +436,10 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 8 bit pixel data with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="Image{TPixel}"/> containing pixel data.</param>
-    private void Write8BitPixelData<TPixel>(Stream stream, Image<TPixel> image)
+    private void Write8BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         bool isL8 = typeof(TPixel) == typeof(L8);
@@ -453,7 +452,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
         }
         else
         {
-            this.Write8BitColor(stream, image, colorPalette);
+            this.Write8BitColor(configuration, stream, image, colorPalette);
         }
     }
 
@@ -461,19 +460,20 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes an 8 bit color image with a color palette. The color palette has 256 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="Image{TPixel}"/> containing pixel data.</param>
     /// <param name="colorPalette">A byte span of size 1024 for the color palette.</param>
-    private void Write8BitColor<TPixel>(Stream stream, Image<TPixel> image, Span<byte> colorPalette)
+    private void Write8BitColor<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image, Span<byte> colorPalette)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration);
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration);
 
         frameQuantizer.BuildPalette(this.pixelSamplingStrategy, image);
         using IndexedImageFrame<TPixel> quantized = frameQuantizer.QuantizeFrame(image.Frames.RootFrame, image.Bounds);
 
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         for (int y = image.Height - 1; y >= 0; y--)
         {
@@ -529,12 +529,13 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 4 bit pixel data with a color palette. The color palette has 16 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-    private void Write4BitPixelData<TPixel>(Stream stream, Image<TPixel> image)
+    private void Write4BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, new QuantizerOptions()
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
         {
             MaxColors = 16
         });
@@ -546,7 +547,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
 
         Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         ReadOnlySpan<byte> pixelRowSpan = quantized.DangerousGetRowSpan(0);
         int rowPadding = pixelRowSpan.Length % 2 != 0 ? this.padding - 1 : this.padding;
@@ -576,12 +577,13 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 2 bit pixel data with a color palette. The color palette has 4 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-    private void Write2BitPixelData<TPixel>(Stream stream, Image<TPixel> image)
+    private void Write2BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, new QuantizerOptions()
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
         {
             MaxColors = 4
         });
@@ -593,7 +595,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
 
         Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         ReadOnlySpan<byte> pixelRowSpan = quantized.DangerousGetRowSpan(0);
         int rowPadding = pixelRowSpan.Length % 4 != 0 ? this.padding - 1 : this.padding;
@@ -632,12 +634,13 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes 1 bit pixel data with a color palette. The color palette has 2 entry's with 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="image"> The <see cref="ImageFrame{TPixel}"/> containing pixel data.</param>
-    private void Write1BitPixelData<TPixel>(Stream stream, Image<TPixel> image)
+    private void Write1BitPixelData<TPixel>(Configuration configuration, Stream stream, Image<TPixel> image)
         where TPixel : unmanaged, IPixel<TPixel>
     {
-        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(this.configuration, new QuantizerOptions()
+        using IQuantizer<TPixel> frameQuantizer = this.quantizer.CreatePixelSpecificQuantizer<TPixel>(configuration, new QuantizerOptions()
         {
             MaxColors = 2
         });
@@ -649,7 +652,7 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
 
         Span<byte> colorPalette = colorPaletteBuffer.GetSpan();
         ReadOnlySpan<TPixel> quantizedColorPalette = quantized.Palette.Span;
-        this.WriteColorPalette(stream, quantizedColorPalette, colorPalette);
+        WriteColorPalette(configuration, stream, quantizedColorPalette, colorPalette);
 
         ReadOnlySpan<byte> quantizedPixelRow = quantized.DangerousGetRowSpan(0);
         int rowPadding = quantizedPixelRow.Length % 8 != 0 ? this.padding - 1 : this.padding;
@@ -681,14 +684,15 @@ internal sealed class BmpEncoderCore : IImageEncoderInternals
     /// Writes the color palette to the stream. The color palette has 4 bytes for each entry.
     /// </summary>
     /// <typeparam name="TPixel">The type of the pixel.</typeparam>
+    /// <param name="configuration">The global configuration.</param>
     /// <param name="stream">The <see cref="Stream"/> to write to.</param>
     /// <param name="quantizedColorPalette">The color palette from the quantized image.</param>
     /// <param name="colorPalette">A temporary byte span to write the color palette to.</param>
-    private void WriteColorPalette<TPixel>(Stream stream, ReadOnlySpan<TPixel> quantizedColorPalette, Span<byte> colorPalette)
+    private static void WriteColorPalette<TPixel>(Configuration configuration, Stream stream, ReadOnlySpan<TPixel> quantizedColorPalette, Span<byte> colorPalette)
         where TPixel : unmanaged, IPixel<TPixel>
     {
         int quantizedColorBytes = quantizedColorPalette.Length * 4;
-        PixelOperations<TPixel>.Instance.ToBgra32(this.configuration, quantizedColorPalette, MemoryMarshal.Cast<byte, Bgra32>(colorPalette[..quantizedColorBytes]));
+        PixelOperations<TPixel>.Instance.ToBgra32(configuration, quantizedColorPalette, MemoryMarshal.Cast<byte, Bgra32>(colorPalette[..quantizedColorBytes]));
         Span<uint> colorPaletteAsUInt = MemoryMarshal.Cast<byte, uint>(colorPalette);
         for (int i = 0; i < colorPaletteAsUInt.Length; i++)
         {
diff --git a/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs
index abf283e6c1..982cc7d46c 100644
--- a/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Dithering/PaletteDitherProcessor{TPixel}.cs
@@ -35,7 +35,7 @@ internal sealed class PaletteDitherProcessor<TPixel> : ImageProcessor<TPixel>
 
         ReadOnlySpan<Color> sourcePalette = definition.Palette.Span;
         this.paletteOwner = this.Configuration.MemoryAllocator.Allocate<TPixel>(sourcePalette.Length);
-        Color.ToPixel(this.Configuration, sourcePalette, this.paletteOwner.Memory.Span);
+        Color.ToPixel(sourcePalette, this.paletteOwner.Memory.Span);
 
         this.ditherProcessor = new DitherProcessor(
             this.Configuration,
diff --git a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
index d66a38d80d..1136fbc9da 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs
@@ -26,7 +26,7 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     private readonly int maxColors;
     private readonly int bitDepth;
     private readonly Octree octree;
-    private IMemoryOwner<TPixel> paletteOwner;
+    private readonly IMemoryOwner<TPixel> paletteOwner;
     private ReadOnlyMemory<TPixel> palette;
     private EuclideanPixelMap<TPixel>? pixelMap;
     private readonly bool isDithering;
@@ -40,9 +40,6 @@ public struct OctreeQuantizer<TPixel> : IQuantizer<TPixel>
     [MethodImpl(InliningOptions.ShortMethod)]
     public OctreeQuantizer(Configuration configuration, QuantizerOptions options)
     {
-        Guard.NotNull(configuration, nameof(configuration));
-        Guard.NotNull(options, nameof(options));
-
         this.Configuration = configuration;
         this.Options = options;
 
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
index f3ed39c957..fe4af9005a 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs
@@ -51,7 +51,7 @@ public class PaletteQuantizer : IQuantizer
 
         // Always use the palette length over options since the palette cannot be reduced.
         TPixel[] palette = new TPixel[this.colorPalette.Length];
-        Color.ToPixel(configuration, this.colorPalette.Span, palette.AsSpan());
+        Color.ToPixel(this.colorPalette.Span, palette.AsSpan());
         return new PaletteQuantizer<TPixel>(configuration, options, palette);
     }
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
index ea7413aab4..86db9f6f01 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs
@@ -17,10 +17,10 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization;
     "Design",
     "CA1001:Types that own disposable fields should be disposable",
     Justification = "https://github.com/dotnet/roslyn-analyzers/issues/6151")]
-internal struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
+internal readonly struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
     where TPixel : unmanaged, IPixel<TPixel>
 {
-    private EuclideanPixelMap<TPixel> pixelMap;
+    private readonly EuclideanPixelMap<TPixel> pixelMap;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PaletteQuantizer{TPixel}"/> struct.
@@ -65,8 +65,5 @@ internal struct PaletteQuantizer<TPixel> : IQuantizer<TPixel>
         => (byte)this.pixelMap.GetClosestColor(color, out match);
 
     /// <inheritdoc/>
-    public void Dispose()
-    {
-        this.pixelMap.Dispose();
-    }
+    public void Dispose() => this.pixelMap.Dispose();
 }
diff --git a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
index 0119558bff..edf293d39e 100644
--- a/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Quantization/WuQuantizer{TPixel}.cs
@@ -69,9 +69,9 @@ internal struct WuQuantizer<TPixel> : IQuantizer<TPixel>
     /// </summary>
     private const int TableLength = IndexCount * IndexCount * IndexCount * IndexAlphaCount;
 
-    private IMemoryOwner<Moment> momentsOwner;
-    private IMemoryOwner<byte> tagsOwner;
-    private IMemoryOwner<TPixel> paletteOwner;
+    private readonly IMemoryOwner<Moment> momentsOwner;
+    private readonly IMemoryOwner<byte> tagsOwner;
+    private readonly IMemoryOwner<TPixel> paletteOwner;
     private ReadOnlyMemory<TPixel> palette;
     private int maxColors;
     private readonly Box[] colorCube;